Correction de la mise à l'échelle des applications basées sur java pour un écran à haute résolution

Certaines applications (principalement basées sur java) ne suivent pas l' échelle globale 2x que j'ai définie dans les paramètres d'écran. Donc, ces applications sont vraiment minuscules sur mon écran haute résolution avec 3200x1800px.

Comment puis-je faire fonctionner ces applications dans une résolution d'écran plus petite?

Une mise à niveau pratique majeure consisterait à utiliser un script d'arrière-plan, définissant automatiquement la résolution par application , tandis que vous pouvez définir différentes résolutions pour différentes (plusieurs) applications à la fois.

C'est exactement ce que fait le script ci-dessous.

Un exemple de résolution par défaut de 1680x1050:

En cours d'exécution gedit, passant automatiquement à 640x480:

En cours d'exécution gnome-terminal, passant automatiquement à 1280x1024:

Lorsque l'application est fermée, la résolution est automatiquement ramenée à 1680x1050

Comment utiliser

1. Copiez le script ci-dessous dans un fichier vide, enregistrez-le sous set_resolution.py

2. Dans la tête du script, définissez votre résolution par défaut, dans la ligne:

   #--- set the default resolution below
   default = "1680x1050"
   #---

3. Dans le même répertoire (dossier), créez un fichier texte, exactement le nom: procsdata.txt. Dans ce fichier texte, définissez l'application ou le processus souhaité, suivi d'un espace, suivi de la résolution souhaitée. Une application ou un script par ligne, ressemblant à:

   gedit 640x480
   gnome-terminal 1280x1024
   java 1280x1024

   

4. Exécutez le script par la commande:

   python3 /path/to/set_resolution.py

Remarque

L'utilisation du script pgrep -f <process>, qui intercepte toutes les correspondances, y compris les scripts. L'inconvénient possible est qu'il peut provoquer des conflits de noms lors de l'ouverture d'un fichier portant le même nom que le processus.
Si vous rencontrez des problèmes comme celui-ci, changez:

matches.append([p, subprocess.check_output(["pgrep", "-f", p]).decode("utf-8")])

dans:

matches.append([p, subprocess.check_output(["pgrep", p]).decode("utf-8")])

Le script

#!/usr/bin/env python3
import subprocess
import os
import time

#--- set the default resolution below
default = "1680x1050"
#---

# read the datafile
curr_dir = os.path.dirname(os.path.abspath(__file__))
datafile = curr_dir+"/procsdata.txt"
procs_data = [l.split() for l in open(datafile).read().splitlines() if not l == "\n"]
procs = [pdata[0] for pdata in procs_data]

def check_matches():
    # function to find possible running (listed) applications
    matches = []
    for p in procs:
        try:
            matches.append([p, subprocess.check_output(["pgrep", "-f", p]).decode("utf-8")])
        except subprocess.CalledProcessError:
            pass
    match = matches[-1][0] if len(matches) != 0 else None
    return match

matches1 = check_matches()

while True:
    time.sleep(2)
    matches2 = check_matches()
    if matches2 == matches1:
        pass
    else:
        if matches2 != None:
            # a listed application started up since two seconds ago
            resdata = [("x").join(item[1].split("x")) for item in \
                       procs_data if item[0] == matches2][0]
        elif matches2 == None:
            # none of the listed applications is running any more
            resdata = default
        subprocess.Popen(["xrandr", "-s", resdata])
    matches1 = matches2
    time.sleep(1)

Explication

Lorsque le script démarre, il lit le fichier dans lequel vous avez défini vos applications et leurs résolutions d'écran souhaitées correspondantes.

Il garde ensuite un œil sur les processus en cours pgrep -f <process>d' exécution (en cours d' exécution pour chacune des applications) et définit la résolution si l'application démarre.

Lorsque pgrep -f <process>ne produit aucune sortie pour aucune des applications répertoriées, il définit la résolution sur "par défaut".

Modifier:

Version "dynamique" (comme demandé)

Bien que la version ci-dessus fonctionne avec plusieurs applications répertoriées, elle ne définit la résolution que pour une seule application à la fois .

La version ci-dessous peut gérer différentes applications avec une résolution différente (requise), fonctionnant en même temps. Le script d'arrière-plan conservera la trace de l'application la plus avancée et définira la résolution en conséquence. Cela fonctionne également très bien avec Alt+ Tab.

Notez que ce comportement peut être gênant si vous basculez beaucoup entre le bureau et les applications répertoriées; le commutateur de résolution fréquent peut être trop.

différences dans la configuration

La configuration est à peu près la même, à part le fait que celui-ci utilise wmctrlet xdotool:

sudo apt-get install wmctrl
sudo apt-get install xdotool

Le script

#!/usr/bin/env python3
import subprocess
import os
import sys
import time

#--- set default resolution below
resolution = "1680x1050"
#---

curr_dir = os.path.dirname(os.path.abspath(__file__))
datafile = curr_dir+"/procsdata.txt"
applist = [l.split() for l in open(datafile).read().splitlines()]
apps = [item[0] for item in applist]

def get(cmd):
    try:
        return subprocess.check_output(["/bin/bash", "-c", cmd]).decode("utf-8")
    except subprocess.CalledProcessError:
        pass

def get_pids():
    # returns pids of listed applications; seems ok
    runs = []
    for item in apps:
        pid = get("pgrep -f "+item)
        if pid != None:
            runs.append((item, pid.strip()))    
    return runs

def check_frontmost():
    # returns data on the frontmost window; seems ok
    frontmost = str(hex(int(get("xdotool getwindowfocus").strip())))
    frontmost = frontmost[:2]+"0"+frontmost[2:]
    try:
        wlist = get("wmctrl -lpG").splitlines()
        return [l for l in wlist if frontmost in l]
    except subprocess.CalledProcessError:
        pass

def front_pid():
    # returns the frontmost pid, seems ok
    return check_frontmost()[0].split()[2]

def matching():
    # nakijken
    running = get_pids(); frontmost = check_frontmost()
    if all([frontmost != None, len(running) != 0]):
        matches = [item[0] for item in running if item[1] == frontmost[0].split()[2]]
        if len(matches) != 0:
            return matches[0]
    else:
        pass

trigger1 = matching()

while True:
    time.sleep(1)
    trigger2 = matching()
    if trigger2 != trigger1:
        if trigger2 == None:
            command = "xrandr -s "+resolution
        else:
            command = "xrandr -s "+[it[1] for it in applist if it[0] == trigger2][0]
        subprocess.Popen(["/bin/bash", "-c", command])
        print(trigger2, command)
    trigger1 = trigger2

Remarques

• Bien que je le fasse fonctionner pendant plusieurs heures sans erreur maintenant, veuillez le tester soigneusement. Si une erreur peut se produire, veuillez laisser un commentaire.
• Le script, tel qu'il est, fonctionne sur une seule configuration de moniteur.

Testez l'ajout à votre ligne de commande java:, -Dsun.java2d.uiScale=2.0ou définissez-le sur un facteur d'échelle que vous souhaitez.

Comme solution de contournement

J'ai créé un script bash qui modifie la résolution en fullHD avant de démarrer l'application (dans cet exemple Android Studio) et la redéfinit en 3200x1800 lorsque l'application se ferme:

sudo nano /usr/local/bin/studio

Entrez ce script:

#!/bin/bash
# set scaling to x1.0
gsettings set org.gnome.desktop.interface scaling-factor 1
gsettings set com.ubuntu.user-interface scale-factor "{'HDMI1': 8, 'eDP1': 8}"
xrandr -s 1920x1080
# call your program
/usr/share/android-studio/data/bin/studio.sh
# set scaling to x2.0
gsettings set org.gnome.desktop.interface scaling-factor 2
gsettings set com.ubuntu.user-interface scale-factor "{'HDMI1': 8, 'eDP1': 16}"
xrandr -s 3200x1800

et lui donner des droits exécutables:

sudo chmod +x /usr/local/bin/studio

Ensuite, vous pouvez le démarrer avec Alt+F1 studio

Pour d'autres facteurs de redimensionnement 2.0, voir /ubuntu//a/486611/34298

Pour activer et désactiver facilement le zoom dans Firefox, utilisez l'extension Zoom Menu Elements