Comment surligner l'écran actuel (ou la fenêtre)?

Question

J'utilise deux écrans au travail et bien que cela aide généralement plus que ça ne fait pas mal, j'ai quelques problèmes avec.

L'un d'entre eux est le problème de la mise au point tardive - parfois, je me trompe en tapant sur un mauvais écran (la mise au point traîne par rapport à mon curseur, mais il n'est pas toujours facile de remarquer que le curseur se trouve sur un autre écran lorsque vous faites des choses en mode précipité). C’est très ennuyant au lieu de taper je provoque des tonnes d’actions différentes (raccourcis à une touche dans Thunderbird).

Existe-t-il un moyen de mieux mettre en évidence l'écran ou la fenêtre active (par exemple, en utilisant une bordure facilement visible - même pour des fenêtres agrandies)?

MODIFIER:

Je pense que la solution de Nice serait une sorte d’animation courte lorsque la fenêtre est activée.

Answer 1

Mettez en surbrillance l’écran de mise au point (ou un flash atténué lors d’un changement de mise au point, voir ÉDITER plus bas)

Dans une configuration à double moniteur côte à côte (gauche-droite), le script ci-dessous règle la luminosité du moniteur avec la fenêtre focalisée sur "normale" (100%), tandis que l'autre est atténuée à 60%.

Si la mise au point change, la luminosité suit la mise au point:

se concentre sur (une fenêtre) sur l'écran de droite

se concentre sur (une fenêtre) sur l'écran de gauche

Le scénario

#!/usr/bin/env python3
"""
In a side-by-side dual monitor setup (left-right), the script below will set
the brightness of the monitor with the focussed window to "normal" (100%),
while other one is dimmed to 60%. If the focus changes, the brightness will
follow the focus
"""
import subprocess
import time

def get_wposition():
    # get the position of the currently frontmost window
    try:
        w_data = subprocess.check_output(["wmctrl", "-lG"]).decode("utf-8").splitlines()
        frontmost = subprocess.check_output(["xprop", "-root", "_NET_ACTIVE_WINDOW"]).decode("utf-8").split()[-1].strip()
        z = 10-len(frontmost); frontmost = frontmost[:2]+z*"0"+frontmost[2:]
        return [int(l.split()[2]) for l in w_data if frontmost in l][0]
    except subprocess.CalledProcessError:
        pass

def get_onscreen():
    # get the size of the desktop, the names of both screens and the x-resolution of the left screen
    resdata = subprocess.check_output(["xrandr"]).decode("utf-8")
    if resdata.count(" connected") == 2:
        resdata = resdata.splitlines()
        r = resdata[0].split(); span = int(r[r.index("current")+1])
        screens = [l for l in resdata if " connected" in l]
        lr = [[(l.split()[0], int([s.split("x")[0] for s in l.split() if "+0+0" in s][0])) for l in screens if "+0+0" in l][0],
               [l.split()[0] for l in screens if not "+0+0" in l][0]]
        return [span, lr]
    else:
        print("no second screen seems to be connected")

def scr_position(span, limit, pos):
    # determine if the frontmost window is on the left- or right screen
    if limit < pos < span:
        return [right_scr, left_scr]
    else:
        return [left_scr, right_scr]

def highlight(scr1, scr2):
    # highlight the "active" window, dim the other one
    action1 = "xrandr", "--output", scr1, "--brightness", "1.0"
    action2 = "xrandr", "--output", scr2, "--brightness", "0.6"
    for action in [action1, action2]:
        subprocess.Popen(action)

# determine the screen setup
screendata = get_onscreen()
left_scr = screendata[1][0][0]; right_scr = screendata[1][1]
limit = screendata[1][0][1]; span = screendata[0]

# set initial highlight
oncurrent1 = scr_position(span, limit, get_wposition())
highlight(oncurrent1[0], oncurrent1[1])

while True:
    time.sleep(0.5)
    pos = get_wposition()
    # bypass possible incidental failures of the wmctrl command
    if pos != None:
        oncurrent2 = scr_position(span, limit, pos)
        # only set highlight if there is a change in active window
        if oncurrent2 != oncurrent1:
            highlight(oncurrent1[1], oncurrent1[0])
        oncurrent1 = oncurrent2

Comment utiliser

1. Le script a besoin de wmctrl:

   Sudo apt-get install wmctrl
   

2. Copiez le script dans un fichier vide, enregistrez-le sous le nom highlight_focus.py

3. Testez-le avec la commande:

   python3 /path/to/highlight_focus.py
   

   Lorsque le deuxième moniteur est connecté , vérifiez si le script fonctionne comme prévu.

4. Si tout fonctionne correctement, ajoutez-le aux applications de démarrage: Dash> Applications de démarrage> Ajoutez la commande:

   /bin/bash -c "sleep 15 && python3 /path/to/highlight_focus.py"
   

Remarques

• Le script est extrêmement pauvre en ressources. Pour "économiser du carburant", la configuration de l'écran; les résolutions, la taille des étendues, etc. ne sont lues qu’une fois, lors du démarrage du script (non inclus dans la boucle). Cela implique que vous devez redémarrer le script si vous connectez/déconnectez le second moniteur.

• Si vous l'avez ajouté aux applications de démarrage, cela signifie que vous devez vous déconnecter/ouvrir une session après les modifications apportées à la configuration du moniteur.

• Si vous préférez un autre pourcentage de luminosité pour l’écran estompé, modifiez la valeur dans la ligne:

  action2 = "xrandr", "--output", scr2, "--brightness", "0.6"
  

La valeur peut être comprise entre 0,0 (écran noir) et 1.0 (100%).

Explication

Au démarrage du script, il détermine:

• la résolution étendue des deux écrans
• la résolution x de l'écran de gauche
• les noms des deux écrans

Puis, dans une boucle (une fois par seconde), il:

• vérifie la position de la fenêtre active avec les commandes:

  • wmctrl -lG (pour obtenir la liste des fenêtres et leurs positions)
  • xprop -root _NET_ACTIVE_WINDOW (pour obtenir l'id de la fenêtre la plus en avant)

Si la position (x) de la fenêtre est supérieure à la résolution x de l'écran de gauche, la fenêtre est apparemment sur l'écran de droite sauf si elle est supérieure à la taille des deux écrans (elle se trouverait alors dans l’espace de travail à droite). par conséquent:

if limit < pos < span:

détermine si la fenêtre se trouve sur l'écran de droite (où limit est la résolution x de l'écran de gauche, pos correspond à la position x de la fenêtre et span représente la combinaison des résolutions x des deux écrans. ).

Si il y a un changement de la position de la fenêtre la plus en avant (sur l'écran gauche ou droit), le script règle la luminosité des deux écrans avec le xrandr commande:

xrandr --output <screen_name> --brightness <value>

---

MODIFIER

Dim-flash l'écran ciblé au lieu d'un écran "non focalisé" permanent estompé

Comme demandé dans un commentaire et dans le chat, vous trouverez ci-dessous une version du script qui donne un éclair faible sur l’écran nouvellement ciblé:

#!/usr/bin/env python3
"""
In a side-by-side dual monitor setup (left-right), the script below will give
a short dim- flash on the newly focussed screen if the focussed screen changes
"""

import subprocess
import time

def get_wposition():
    # get the position of the currently frontmost window
    try:
        w_data = subprocess.check_output(["wmctrl", "-lG"]).decode("utf-8").splitlines()
        frontmost = subprocess.check_output(["xprop", "-root", "_NET_ACTIVE_WINDOW"]).decode("utf-8").split()[-1].strip()
        z = 10-len(frontmost); frontmost = frontmost[:2]+z*"0"+frontmost[2:]
        return [int(l.split()[2]) for l in w_data if frontmost in l][0]
    except subprocess.CalledProcessError:
        pass

def get_onscreen():
    # get the size of the desktop, the names of both screens and the x-resolution of the left screen
    resdata = subprocess.check_output(["xrandr"]).decode("utf-8")
    if resdata.count(" connected") == 2:
        resdata = resdata.splitlines()
        r = resdata[0].split(); span = int(r[r.index("current")+1])
        screens = [l for l in resdata if " connected" in l]
        lr = [[(l.split()[0], int([s.split("x")[0] for s in l.split() if "+0+0" in s][0])) for l in screens if "+0+0" in l][0],
               [l.split()[0] for l in screens if not "+0+0" in l][0]]
        return [span, lr]
    else:
        print("no second screen seems to be connected")

def scr_position(span, limit, pos):
    # determine if the frontmost window is on the left- or right screen
    if limit < pos < span:
        return [right_scr, left_scr]
    else:
        return [left_scr, right_scr]

def highlight(scr1):
    # highlight the "active" window, dim the other one
    subprocess.Popen([ "xrandr", "--output", scr1, "--brightness", "0.3"])
    time.sleep(0.1)
    subprocess.Popen([ "xrandr", "--output", scr1, "--brightness", "1.0"])

# determine the screen setup
screendata = get_onscreen()
left_scr = screendata[1][0][0]; right_scr = screendata[1][1]
limit = screendata[1][0][1]; span = screendata[0]

# set initial highlight
oncurrent1 = []

while True:
    time.sleep(0.5)
    pos = get_wposition()
    # bypass possible incidental failures of the wmctrl command
    if pos != None:
        oncurrent2 = scr_position(span, limit, pos)
        # only set highlight if there is a change in active window
        if oncurrent2 != oncurrent1:
            highlight(oncurrent2[0])
        oncurrent1 = oncurrent2

Answer 2

J'ai également trouvé une autre solution, légèrement différente de ce que je recherchais au départ, mais qui fonctionne bien aussi.

1. Installer compizconfig-settings-manager compiz-plugins
2. Run ccsm
3. Dans la section Effects, activez le plug-in Animations
4. Dans Focus Animation éditez et sélectionnez l'animation souhaitée.

Seul l'effet de vague a fonctionné ... Donc si vous ne l'aimez pas, vous aurez un visage aussi triste que le mien.