Wie kann ich den aktuellen Bildschirm (oder das aktuelle Fenster) markieren?

Ich verwende zwei Bildschirme bei der Arbeit und obwohl es normalerweise mehr hilft als es schmerzt, habe ich einige Probleme damit.

Eines davon ist das Problem mit dem nachlaufenden Fokus - manchmal mache ich einen Fehler beim Tippen auf einem falschen Bildschirm (der Fokus folgt meinem Cursor, aber es ist nicht immer leicht zu bemerken, dass sich der Cursor auf einem anderen Bildschirm befindet, wenn Sie Dinge in Eile tun). Dies ist sehr ärgerlich, wenn ich anstelle des Tippens unzählige verschiedene Aktionen ausführe (Tastenkombinationen in Thunderbird).

Gibt es eine Möglichkeit, den aktiven Bildschirm oder das aktive Fenster besser hervorzuheben (z. B. mithilfe eines gut sichtbaren Rahmens - auch bei maximierten Fenstern)?

BEARBEITEN:

Ich denke, eine gute Lösung wäre eine Art kurze Animation, wenn das Fenster den Fokus erhält.

Markieren Sie den fokussierten Bildschirm (oder dimmen Sie den Blitz bei Fokusänderung, siehe BEARBEITEN weiter unten).

In einem Side-by-Side-Dual-Monitor-Setup (links-rechts) setzt das folgende Skript die Helligkeit des Monitors mit dem fokussierten Fenster auf "normal" (100%), während das andere auf 60% gedimmt ist.

Wenn sich der Fokus ändert, folgt die Helligkeit dem Fokus:

Konzentrieren Sie sich auf (ein Fenster) auf dem rechten Bildschirm

Konzentrieren Sie sich auf (ein Fenster) auf dem linken Bildschirm

Das Skript

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

Wie benutzt man

1. Das Skript benötigt wmctrl:

   sudo apt-get install wmctrl

2. Kopieren Sie das Skript in eine leere Datei und speichern Sie es unter highlight_focus.py

3. Testen Sie es mit dem folgenden Befehl:

   python3 /path/to/highlight_focus.py

   Testen Sie bei angeschlossenem zweiten Monitor , ob das Skript wie erwartet funktioniert.

4. Wenn alles einwandfrei funktioniert, fügen Sie es zu Startanwendungen hinzu: Dash> Startanwendungen> Befehl hinzufügen:

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

Anmerkungen

• Das Skript ist äußerst ressourcenschonend. Um "Kraftstoff zu sparen", wird der Bildschirm eingerichtet; Auflösungen, Bereichsgröße usw. werden beim Start des Skripts nur einmal gelesen (nicht in der Schleife enthalten). Dies bedeutet, dass Sie das Skript neu starten müssen, wenn Sie den zweiten Monitor verbinden / trennen.

• Wenn Sie es zu Startanwendungen hinzugefügt haben, bedeutet dies, dass Sie sich nach Änderungen in der Monitorkonfiguration abmelden / anmelden müssen.

• Wenn Sie einen anderen Helligkeitsprozentsatz für den abgeblendeten Bildschirm bevorzugen, ändern Sie den Wert in der Zeile:

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

Der Wert kann zwischen 0,0(schwarzer Bildschirm) und 1.0(100%) liegen.

Erläuterung

Beim Start des Skripts wird Folgendes festgelegt:

• die übergreifende Auflösung beider Bildschirme
• die x-Auflösung des linken Bildschirms
• die Namen beider Bildschirme

Dann in einer Schleife (einmal pro Sekunde):

• überprüft die Position des aktiven Fensters mit den Befehlen:

  • wmctrl -lG (um die Liste der Fenster und ihrer Positionen zu erhalten)
  • xprop -root _NET_ACTIVE_WINDOW (um die ID des vordersten Fensters zu erhalten)

Wenn die (x-) Position des Fensters größer ist als die x-Auflösung des linken Bildschirms, befindet sich das Fenster anscheinend auf dem rechten Bildschirm, es sei denn, es ist größer als die Spannweite der beiden Bildschirme (dann befindet es sich auf dem Arbeitsbereich das Recht). deshalb:

if limit < pos < span:

Legt fest, ob sich das Fenster auf dem rechten Bildschirm befindet (wobei limitx-res des linken Bildschirms posdie x-Position des Fensters und spandie kombinierten x-res beider Bildschirme ist).

Wenn sich die Position des vordersten Fensters (auf dem linken oder rechten Bildschirm) ändert, stellt das Skript die Helligkeit beider Bildschirme mit dem einxrandr Befehl fest:

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

BEARBEITEN

Verdunkeln Sie den fokussierten Bildschirm anstelle eines permanent gedimmten "nicht fokussierten" Bildschirms

Wie in einem Kommentar und im Chat angefordert, unten eine Version des Skripts, die stattdessen einen kurzen, schwachen Blitz auf dem neu fokussierten Bildschirm erzeugt:

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

Ich habe auch eine andere Lösung gefunden, die etwas anders ist als die, die ich ursprünglich wollte, aber auch gut funktioniert.

1. Installieren compizconfig-settings-manager compiz-plugins
2. Führen Sie ccsm aus
3. Im EffectsAbschnitt AnimationsPlugin aktivieren
4. In Focus Animationbearbeiten und gewünschte Animation auswählen.

Nur der Welleneffekt hat funktioniert ... Wenn Sie ihn nicht mögen, haben Sie ein so trauriges Gesicht wie ich.