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

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:

gedit ausführen und automatisch zu 640x480 wechseln:

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

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
   

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.