wake-up-neo.com

Korrektur der Skalierung von Java-basierten Anwendungen für einen hochauflösenden Bildschirm

Es gibt einige Anwendungen (hauptsächlich auf der Basis von Java), die nicht der in den Bildschirmeinstellungen festgelegten globalen 2x-Skala entsprechen. Diese Apps sind auf meinem hochauflösenden Bildschirm mit 3200x1800px wirklich winzig .

Wie kann ich diese Apps in einer kleineren Bildschirmauflösung zum Laufen bringen?

23
rubo77

Ein wichtiges Komfort-Upgrade wäre die Verwendung eines Hintergrundskripts, mit dem die Auflösung automatisch eingestellt wird pro Anwendung, während Sie verschiedene Auflösungen für verschiedene (mehrere) Anwendungen gleichzeitig einstellen können.

Genau das macht das folgende Skript.

Ein Beispiel für eine Standard Auflösung von 1680x1050:

enter image description here

gedit ausführen und automatisch zu 640x480 wechseln:

enter image description here

gnome-terminal ausführen und automatisch zu 1280x1024 wechseln:

enter image description here

Wenn die Anwendung geschlossen wird, wird die Auflösung automatisch auf 1680x1050 zurückgesetzt.

Wie benutzt man

  1. Kopieren Sie das folgende Skript in eine leere Datei und speichern Sie es als set_resolution.py
  2. Stellen Sie im Kopf des Skripts Ihre Standardauflösung in der folgenden Zeile ein:

    #--- set the default resolution below
    default = "1680x1050"
    #---
    
  3. Erstellen Sie in genau dasselbe Verzeichnis (Ordner) eine Textdatei gena mit dem Namen: procsdata.txt. Stellen Sie in dieser Textdatei die gewünschte Anwendung oder den gewünschten Prozess ein, gefolgt von einem Leerzeichen und der gewünschten Auflösung. Eine Anwendung oder ein Skript pro Zeile sieht folgendermaßen aus:

    gedit 640x480
    gnome-terminal 1280x1024
    Java 1280x1024
    

    enter image description here

  4. Führen Sie das Skript mit folgendem Befehl aus:

    python3 /path/to/set_resolution.py
    

Hinweis

Das Skript verwendet pgrep -f <process>, wodurch alle Übereinstimmungen abgefangen werden, einschließlich Skripten. Der mögliche Nachteil ist, dass es zu Namenskonflikten kommen kann, wenn eine Datei mit demselben Namen wie der Prozess geöffnet wird.
Wenn Sie auf solche Probleme stoßen, ändern Sie Folgendes:

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

in:

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

Das Drehbuch

#!/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)

Erläuterung

Beim Start des Skripts wird die Datei gelesen, in der Sie Ihre Anwendungen definiert haben, und die entsprechenden gewünschten Bildschirmauflösungen.

Anschließend werden die laufenden Prozesse überwacht (wobei pgrep -f <process> für jede Anwendung ausgeführt wird) und die Auflösung festgelegt, wenn die Anwendung gestartet wird.

Wenn pgrep -f <process> für keine der aufgelisteten Anwendungen eine Ausgabe erzeugt, wird die Auflösung auf "Standard" gesetzt.


Bearbeiten:

"Dynamische" Version (wie gewünscht)

Während die obige Version mit mehreren aufgelisteten Anwendungen funktioniert, wird nur die Auflösung für jeweils eine Anwendung festgelegt.

Die folgende Version kann verschiedene Anwendungen mit einer unterschiedlichen (erforderlichen) Auflösung gleichzeitig ausführen. Das Hintergrundskript verfolgt die Anwendung mit der höchsten Priorität und stellt die Auflösung entsprechend ein. Es funktioniert auch gut mit Alt+Tab.

Beachten Sie, dass dieses Verhalten möglicherweise ärgerlich ist, wenn Sie häufig zwischen dem Desktop und den aufgelisteten Anwendungen wechseln. Der Schalter für die häufige Auflösung ist möglicherweise zu viel.

unterschiede in der Einrichtung

Das Setup ist ziemlich gleich, abgesehen von der Tatsache, dass dieses wmctrl und xdotool verwendet:

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

Das Drehbuch

#!/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

Anmerkungen

  • Obwohl ich es jetzt mehrere Stunden ohne Fehler laufen habe, testen Sie es bitte gründlich. Falls ein Fehler auftreten sollte, hinterlassen Sie bitte einen Kommentar.
  • Das Skript funktioniert - wie es ist - auf einem einzelnen Monitor-Setup.
14
Jacob Vlijm

Als Workaround

Ich habe ein Bash-Skript erstellt, das die Auflösung vor dem Start der Anwendung in FullHD ändert (in diesem Beispiel Android Studio) und beim Beenden der Anwendung auf 3200x1800 zurücksetzt:

Sudo nano /usr/local/bin/studio

Geben Sie dieses Skript ein:

#!/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

und gib ihm ausführbare Rechte:

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

Dann können Sie es mit starten Alt+F1 studio


Für andere Größenänderungsfaktoren, die 2.0 betreffen, siehe https://askubuntu.com/a/486611/34298


Verwenden Sie zum einfachen Ein- und Ausschalten des Zooms in Firefox die Erweiterung Zoom-Menüelemente

2
rubo77

Testen Sie das Hinzufügen zu Ihrer Java -Befehlszeile: -Dsun.Java2d.uiScale=2.0, oder stellen Sie den gewünschten Skalierungsfaktor ein.

2
epineda