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
- Copiez le script ci-dessous dans un fichier vide, enregistrez-le sous
set_resolution.py
Dans la tête du script, définissez votre résolution par défaut, dans la ligne:
#--- set the default resolution below
default = "1680x1050"
#---
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
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.