web-dev-qa-db-fra.com

Correction de la mise à l'échelle des applications Java pour un écran haute résolution

Certaines applications (principalement basées sur Java) ne suivent pas la échelle de 2x globale 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 avec une résolution d'écran plus petite?

javadisplay-resolutiondpihdpiscale-mode
23
rubo77

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

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

Exemple de résolution par défaut de 1680x1050:

enter image description here

Lancer gedit, en passant automatiquement à 640x480:

enter image description here

Lancer gnome-terminal en passant automatiquement à 1280x1024:

enter image description here

Lorsque l'application est fermée, la résolution est automatiquement redéfinie sur 1680x1050

Comment utiliser

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

  2. Dans l'en-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 nommé: 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

    enter image description here

  4. Exécutez le script à l'aide de la commande:

    python3 /path/to/set_resolution.py

Remarque

Le script utilise 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 de tels problèmes, 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 scénario

#!/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 les résolutions d'écran correspondantes.

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

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

Modifier:

Version "dynamique" (à la demande)

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

La version ci-dessous peut gérer différentes applications avec une résolution différente (requise) s'exécutant simultanément. Le script d'arrière-plan garde la trace de l'application la plus en tête et définit la résolution en conséquence. Cela fonctionne aussi 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équente est peut-être trop.

différences dans la façon de configurer

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

Sudo apt-get install wmctrl
Sudo apt-get install xdotool

Le scénario

#!/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 l'utilise depuis plusieurs heures sans erreur, testez-le soigneusement. Si une erreur risque de se produire, veuillez laisser un commentaire.
  • Le script - en tant que tel - fonctionne sur une seule configuration de moniteur.
14
Jacob Vlijm

Comme solution de contournement

J'ai créé un script bash qui modifie la résolution en fullHD avant de lancer l'application (dans cet exemple Android Studio) et le rétablit en 3200x1800 à la fermeture de l'application:

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 commencer avec Alt+F1 studioname__

Pour les autres facteurs de redimensionnement que 2.0 voir https://askubuntu.com/a/486611/34298

Pour activer facilement le zoom sur Firefox, utilisez l’extension Eléments du menu Zoom

2
rubo77

Testez l'ajout à votre ligne de commande Java: -Dsun.Java2d.uiScale=2.0 ou définissez-le sur le facteur d'échelle souhaité.

2
epineda