Willkommen zu diesem umfassenden Guide, der Ihnen zeigt, wie Sie das lästige manuelle Anpassen der Bildschirmauflösung und Skalierung unter Arch Linux und KDE Plasma für immer hinter sich lassen können! Wenn Sie regelmäßig externe Monitore an Ihr Laptop anschließen oder trennen und dabei mit inkonsistenten Skalierungseinstellungen kämpfen, sind Sie hier genau richtig. Wir werden ein robustes Bashscript erstellen, das diese Aufgabe für Sie automatisiert und Ihr Nutzererlebnis erheblich verbessert.
Warum automatisches Skalieren?
Moderne Bildschirme, insbesondere Laptop-Displays, haben oft eine hohe Pixeldichte (HiDPI), während externe Monitore häufig eine Standard-DPI aufweisen. Dies führt zu Problemen: Ohne Anpassung erscheinen Elemente auf dem HiDPI-Bildschirm winzig oder auf dem externen Monitor riesig. Manuelles Ändern der Skalierung in den Systemeinstellungen von KDE ist mühsam und erfordert bei jeder Änderung mehrere Klicks. Ein automatisiertes Bashscript erkennt Display-Änderungen und wendet sofort die optimalen Einstellungen an, was zu einem nahtlosen Übergang und einer konsistenten Darstellung führt.
Voraussetzungen für den Start
Bevor wir loslegen, stellen Sie sicher, dass Sie die folgenden Punkte erfüllen:
- Ein funktionierendes Arch Linux System.
- Die KDE Plasma Desktop-Umgebung ist installiert und wird verwendet.
- Grundkenntnisse im Umgang mit dem Terminal und Bash-Skripting.
- Die Befehlszeilentools
xrandr
undudev
sind verfügbar (standardmäßig in Arch Linux).
Wir werden uns hauptsächlich auf xrandr
konzentrieren, da es das leistungsstärkste Tool zur Verwaltung von Bildschirmkonfigurationen unter X Window System ist.
Grundlagen von `xrandr` verstehen
xrandr
(X Resize And Rotate) ist das Herzstück unserer Lösung. Es ermöglicht Ihnen, die Größe, Ausrichtung und Position von Bildschirmausgaben sowie deren Skalierungsfaktoren zu steuern. Bevor wir unser Script schreiben, sollten wir verstehen, wie xrandr
funktioniert.
Aktuelle Bildschirmkonfiguration abfragen
Öffnen Sie ein Terminal und geben Sie ein:
xrandr --query
Die Ausgabe zeigt Ihnen alle verbundenen und nicht verbundenen Bildschirmausgänge (z.B. eDP-1
für das interne Laptop-Display, DP-1
oder HDMI-1
für externe Monitore). Achten Sie auf Zeilen, die ” connected” enthalten. Diese zeigen die Namen Ihrer derzeit angeschlossenen Monitore und deren native Auflösungen.
eDP-1 connected primary 1920x1080+0+0 (normal left inverted right x axis y axis) 344mm x 194mm
1920x1080 60.00*+ 59.97 59.96 59.93
DP-1 connected 3840x2160+1920+0 (normal left inverted right x axis y axis) 600mm x 340mm
3840x2160 60.00*+ 59.94 50.00 24.00 23.98
...
In diesem Beispiel ist eDP-1
das primäre Laptop-Display und DP-1
ein externer Monitor.
Bildschirme skalieren mit `xrandr –scale`
Der Schlüssel zu unserer Automatisierung liegt im --scale
-Parameter. Dieser Parameter weist X an, das gerenderte Bild auf einer höheren oder niedrigeren virtuellen Auflösung zu rendern und dann auf die tatsächliche physikalische Auflösung des Monitors zu skalieren. Dies ist wichtig: Es ist keine DPI-Skalierung im Sinne von KDEs „Global Scale”, die Anwendungen anweist, ihre Elemente größer zu zeichnen. Stattdessen ändert --scale
die effektive Auflösung, die an den Monitor gesendet wird, wodurch alles auf dem Bildschirm größer oder kleiner erscheint.
Wenn Ihr Laptop-Display beispielsweise eine native Auflösung von 1920x1080
hat und Sie alles 1,5-mal größer darstellen möchten, können Sie eine virtuelle Auflösung von 1.5x1.5 = 2.25
mal der nativen Auflösung rendern lassen (was zu winzigen Elementen führen würde) und diese dann auf 1920x1080
herunterskalieren. Oder, einfacher ausgedrückt: Sie möchten, dass die Elemente so groß erscheinen, als hätten Sie eine Auflösung von 1280x720
auf einem 1920x1080
Monitor.
Um eine Skalierung von 1.5x zu erreichen, verwenden Sie den Kehrwert: 1/1.5 = 0.6667
. Wenn Sie also --scale 0.6667x0.6667
angeben, werden die Elemente größer dargestellt.
# Laptop-Display eDP-1 auf 1.5x skalieren (alles 1.5x größer machen)
xrandr --output eDP-1 --scale 0.6667x0.6667 --pos 0x0 --mode 1920x1080 --panning 2880x1620
# Externen Monitor DP-1 auf 1.0x skalieren (keine Skalierung)
xrandr --output DP-1 --scale 1x1 --pos 1920x0 --mode 3840x2160
Beachten Sie die Parameter:
--output <Name>
: Gibt den zu konfigurierenden Monitor an.--scale <X>x<Y>
: Der Skalierungsfaktor. Für 1.5x Skalierung (alles 1.5x größer) verwenden Sie 0.6667×0.6667. Für 1.0x Skalierung (normale Größe) verwenden Sie 1×1.--pos <X>x<Y>
: Die Position des Monitors relativ zum virtuellen Desktop.--mode <Auflösung>
: Die native Auflösung des Monitors.--panning <Breite>x<Höhe>
: Wichtig bei Skalierung! Setzt die virtuelle Desktopgröße für diesen Monitor. Wenn Sie z.B.1.5x
Skalierung (--scale 0.6667x0.6667
) auf einem1920x1080
Monitor anwenden, dann muss der Panning-Bereich1920 * 1.5 = 2880
und1080 * 1.5 = 1620
sein, also--panning 2880x1620
. Ohne dies könnten Sie nur einen Teil des Desktops sehen.
KDEs interne Skalierung vs. `xrandr –scale`
Es ist wichtig, den Unterschied zu verstehen: KDE Plasma bietet in den Systemeinstellungen eine „Globale Skalierung” (Global Scale) und oft auch eine „Fraktionale Skalierung” (Fractional Scaling) an. Diese Skalierungen werden in der Regel auf der Toolkit-Ebene (Qt, GTK) angewendet und teilen Anwendungen mit, wie groß sie ihre Elemente zeichnen sollen. xrandr --scale
hingegen wirkt auf einer tieferen Ebene, indem es die effektive Auflösung verändert, die an den Monitor gesendet wird. Für eine konsistente, automatische Anpassung bei Monitorwechseln ist xrandr --scale
oft die robustere und direktere Methode.
Wenn Sie xrandr --scale
verwenden, sollten Sie die KDE-eigene Skalierung idealerweise auf 100% (1x) lassen, um Konflikte und doppelte Skalierungseffekte zu vermeiden.
Das Bashscript erstellen: `auto-scale.sh`
Erstellen Sie eine neue Datei, z.B. ~/.local/bin/auto-scale.sh
, und machen Sie sie ausführbar (`chmod +x ~/.local/bin/auto-scale.sh`).
Das Script wird die aktuell verbundenen Monitore erkennen und basierend auf dieser Erkennung die entsprechenden xrandr
-Befehle ausführen.
#!/bin/bash
# --- Konfiguration ---
# Hier die Namen Ihrer Monitor-Ausgänge und gewünschten Skalierungen anpassen.
# Namen finden Sie mit 'xrandr --query'.
INTERNAL_DISPLAY="eDP-1" # Beispiel für Laptop-Display
EXTERNAL_DISPLAY_1="DP-1" # Beispiel für externen Monitor 1
EXTERNAL_DISPLAY_2="HDMI-1" # Beispiel für externen Monitor 2 (falls vorhanden)
# Skalierungsfaktoren (Kehrwert für --scale: 1.5x -> 0.6667, 1.25x -> 0.8)
SCALE_INTERNAL_LAPTOP_ONLY="0.6667x0.6667" # z.B. 1.5x für Laptop-Display allein
SCALE_INTERNAL_WITH_EXTERNAL="0.8x0.8" # z.B. 1.25x für Laptop-Display mit externem
SCALE_EXTERNAL_NORMAL="1x1" # z.B. 1.0x für externen Monitor
# Auflösungen (native Auflösungen Ihrer Monitore)
RESOLUTION_INTERNAL="1920x1080"
RESOLUTION_EXTERNAL_1="3840x2160"
RESOLUTION_EXTERNAL_2="1920x1080"
# --- Script-Logik ---
# Überprüfen, welche Monitore verbunden sind
INTERNAL_CONNECTED=$(xrandr --query | grep "$INTERNAL_DISPLAY connected")
EXTERNAL_1_CONNECTED=$(xrandr --query | grep "$EXTERNAL_DISPLAY_1 connected")
EXTERNAL_2_CONNECTED=$(xrandr --query | grep "$EXTERNAL_DISPLAY_2 connected")
echo "--- Auto-Scale Script Start ---"
echo "Internal: $INTERNAL_CONNECTED"
echo "External 1: $EXTERNAL_1_CONNECTED"
echo "External 2: $EXTERNAL_2_CONNECTED"
# Fall 1: Nur Laptop-Display angeschlossen
if [[ -n "$INTERNAL_CONNECTED" && -z "$EXTERNAL_1_CONNECTED" && -z "$EXTERNAL_2_CONNECTED" ]]; then
echo "Szenario: Nur Laptop-Display"
xrandr --output "$INTERNAL_DISPLAY" --primary --mode "$RESOLUTION_INTERNAL" --pos 0x0 --scale "$SCALE_INTERNAL_LAPTOP_ONLY" --panning $(echo "$RESOLUTION_INTERNAL" | awk -F'x' '{print $1 * (1/0.6667)"x"$2 * (1/0.6667)}') --rotate normal
# Andere Displays deaktivieren (falls sie noch aktiv sind)
xrandr --output "$EXTERNAL_DISPLAY_1" --off
xrandr --output "$EXTERNAL_DISPLAY_2" --off
# Fall 2: Laptop-Display und externer Monitor 1 angeschlossen
elif [[ -n "$INTERNAL_CONNECTED" && -n "$EXTERNAL_1_CONNECTED" && -z "$EXTERNAL_2_CONNECTED" ]]; then
echo "Szenario: Laptop-Display und externer Monitor 1"
# Annahme: Externer Monitor links oder rechts vom Laptop-Display
# Positionierung anpassen: Hier externer Monitor rechts vom internen
# Berechne die effektive Breite des internen Displays mit Skalierung für die Positionierung des externen
EFFECTIVE_INTERNAL_WIDTH=$(echo "$RESOLUTION_INTERNAL" | awk -F'x' '{print $1 * (1/0.8)}') # Bei SCALE_INTERNAL_WITH_EXTERNAL="0.8x0.8"
xrandr --output "$INTERNAL_DISPLAY" --primary --mode "$RESOLUTION_INTERNAL" --pos 0x0 --scale "$SCALE_INTERNAL_WITH_EXTERNAL" --panning $(echo "$RESOLUTION_INTERNAL" | awk -F'x' '{print $1 * (1/0.8)"x"$2 * (1/0.8)}') --rotate normal
xrandr --output "$EXTERNAL_DISPLAY_1" --mode "$RESOLUTION_EXTERNAL_1" --pos "${EFFECTIVE_INTERNAL_WIDTH}x0" --scale "$SCALE_EXTERNAL_NORMAL" --panning $(echo "$RESOLUTION_EXTERNAL_1" | awk -F'x' '{print $1 * (1/1)"x"$2 * (1/1)}') --rotate normal
xrandr --output "$EXTERNAL_DISPLAY_2" --off
# Fall 3: Nur externer Monitor 1 angeschlossen (Laptop-Deckel geschlossen, oder nur extern)
elif [[ -z "$INTERNAL_CONNECTED" && -n "$EXTERNAL_1_CONNECTED" && -z "$EXTERNAL_2_CONNECTED" ]]; then
echo "Szenario: Nur externer Monitor 1"
xrandr --output "$EXTERNAL_DISPLAY_1" --primary --mode "$RESOLUTION_EXTERNAL_1" --pos 0x0 --scale "$SCALE_EXTERNAL_NORMAL" --panning $(echo "$RESOLUTION_EXTERNAL_1" | awk -F'x' '{print $1 * (1/1)"x"$2 * (1/1)}') --rotate normal
xrandr --output "$INTERNAL_DISPLAY" --off
xrandr --output "$EXTERNAL_DISPLAY_2" --off
# Fall 4: Laptop-Display und zwei externe Monitore (Beispiel)
# Fügen Sie hier weitere 'elif'-Bedingungen für Ihre spezifischen Szenarien hinzu.
# Bedenken Sie die Positionierung sorgfältig!
# elif [[ -n "$INTERNAL_CONNECTED" && -n "$EXTERNAL_1_CONNECTED" && -n "$EXTERNAL_2_CONNECTED" ]]; then
# echo "Szenario: Laptop-Display und zwei externe Monitore"
# # ... Ihre xrandr-Befehle hier ...
else
echo "Unbekanntes Szenario oder keine Monitore erkannt. Standard auf Laptop-Display."
xrandr --output "$INTERNAL_DISPLAY" --primary --mode "$RESOLUTION_INTERNAL" --pos 0x0 --scale "$SCALE_INTERNAL_LAPTOP_ONLY" --panning $(echo "$RESOLUTION_INTERNAL" | awk -F'x' '{print $1 * (1/0.6667)"x"$2 * (1/0.6667)}') --rotate normal
xrandr --output "$EXTERNAL_DISPLAY_1" --off
xrandr --output "$EXTERNAL_DISPLAY_2" --off
fi
echo "--- Auto-Scale Script Ende ---"
Wichtige Anpassungen:
- Ersetzen Sie
eDP-1
,DP-1
,HDMI-1
durch die tatsächlichen Namen Ihrer Bildschirmausgänge (ermittelt mitxrandr --query
). - Passen Sie die
_RESOLUTION
-Variablen an die nativen Auflösungen Ihrer Monitore an. - Passen Sie die
_SCALE
-Variablen an Ihre gewünschten Skalierungsfaktoren an (denken Sie an den Kehrwert!). - Die
--panning
-Berechnung im Beispiel nutztawk
, um den Kehrwert des Skalierungsfaktors für die Panning-Größe zu berechnen. Das ist entscheidend für die korrekte Darstellung. - Fügen Sie weitere
elif
-Bedingungen für alle Ihre denkbaren Monitor-Konfigurationen hinzu. Die Logik basiert auf der Abwesenheit oder Anwesenheit von" connected"
imxrandr --query
Output.
Testen Sie das Script manuell im Terminal, indem Sie es direkt aufrufen, um sicherzustellen, dass es wie erwartet funktioniert, bevor Sie die Automatisierung einrichten.
Automatisierung mit `udev`
Der eleganteste Weg, unser Script automatisch auszuführen, wenn ein Monitor angeschlossen oder getrennt wird, ist die Verwendung von udev
. udev
ist der Gerätemanager von Linux und reagiert auf Hardware-Ereignisse.
`udev`-Regel erstellen
Erstellen Sie eine neue Regeldatei in /etc/udev/rules.d/
. Nennen Sie sie zum Beispiel 95-monitor-hotplug.rules
(die Zahl am Anfang beeinflusst die Reihenfolge der Ausführung):
sudo nano /etc/udev/rules.d/95-monitor-hotplug.rules
Fügen Sie folgenden Inhalt hinzu:
# Run script on display changes
ACTION=="change", SUBSYSTEM=="drm", KERNEL=="card[0-9]*", ENV{DISPLAY}=":0", ENV{XAUTHORITY}="/home/ihrnutzername/.Xauthority", RUN+="/usr/bin/su ihrnutzername -c "/home/ihrnutzername/.local/bin/auto-scale.sh""
Erklärung der Regel:
ACTION=="change"
: Die Regel wird ausgelöst, wenn sich der Status eines Geräts ändert (z.B. Monitor angeschlossen/getrennt).SUBSYSTEM=="drm"
: Betrifft das Direct Rendering Manager Subsystem, das für Grafikkarten und Displays zuständig ist.KERNEL=="card[0-9]*"
: Betrifft Kernel-Geräte, die Grafikkarten repräsentieren (z.B.card0
,card1
).ENV{DISPLAY}=":0"
: Setzt dieDISPLAY
-Umgebungsvariable, die für X-Anwendungen wiexrandr
notwendig ist.ENV{XAUTHORITY}="/home/ihrnutzername/.Xauthority"
: Setzt dieXAUTHORITY
-Umgebungsvariable, die X-Anwendungen zur Authentifizierung am X-Server benötigen. Ersetzen Sieihrnutzername
durch Ihren tatsächlichen Benutzernamen.RUN+="/usr/bin/su ihrnutzername -c "/home/ihrnutzername/.local/bin/auto-scale.sh""
: Dies ist der entscheidende Teil.RUN+="..."
: Führt ein Programm aus./usr/bin/su ihrnutzername -c "..."
: Führt den nachfolgenden Befehl als Ihr normaler Benutzer aus. Dies ist absolut notwendig, daudev
-Regeln alsroot
ausgeführt werden undxrandr
die Berechtigung des aktuell angemeldeten Benutzers benötigt, um die Anzeige zu ändern."/home/ihrnutzername/.local/bin/auto-scale.sh"
: Der Pfad zu Ihrem Bashscript. Ersetzen Sie auch hierihrnutzername
. Achten Sie auf die Backslashes vor den Anführungszeichen, um sie innerhalb des-c
Arguments zu maskieren.
`udev`-Regeln aktivieren
Nachdem Sie die Regeldatei erstellt haben, müssen Sie udev
anweisen, die neuen Regeln zu laden:
sudo udevadm control --reload-rules
sudo udevadm trigger
udevadm trigger
erzwingt die Ausführung aller passenden Regeln für bereits vorhandene Geräte. Dies sollte Ihr Script einmal auslösen, aber der eigentliche Test kommt beim An- und Abstecken eines Monitors.
Testen und Debugging
Jetzt ist es Zeit für den Praxistest!
- Stecken Sie einen externen Monitor an Ihr Laptop an und beobachten Sie, ob sich die Skalierung wie gewünscht anpasst.
- Ziehen Sie den Monitor ab. Die Skalierung des Laptop-Displays sollte sich wieder ändern.
Was tun, wenn es nicht funktioniert?
- Script manuell testen: Führen Sie
/home/ihrnutzername/.local/bin/auto-scale.sh
direkt im Terminal aus. Funktioniert es dann? Wenn nicht, liegt der Fehler im Script selbst (Variablennamen,xrandr
-Parameter, Logikfehler). Fügen Sieecho
-Befehle in Ihr Script ein, um zu sehen, welche Pfade genommen werden und welche Werte die Variablen haben. - `udev`-Logs prüfen: Wenn das manuelle Ausführen funktioniert, aber die Automatisierung nicht, liegt das Problem wahrscheinlich bei der
udev
-Regel oder den Umgebungsvariablen. Überprüfen Sie die System-Logs:journalctl -f -u udev
Stecken Sie dann einen Monitor an oder ab. Sie sollten Einträge sehen, die auf die Aktivierung der Regel hinweisen. Achten Sie auf Fehlermeldungen.
- Umgebungsvariablen: Stellen Sie sicher, dass
ENV{DISPLAY}
undENV{XAUTHORITY}
korrekt sind.DISPLAY=:0
ist der Standard für den ersten X-Server auf den meisten Desktops..Xauthority
befindet sich normalerweise in Ihrem Benutzer-Home-Verzeichnis. - Berechtigungen: Ist Ihr Script ausführbar (
chmod +x
)? Hat Ihr Benutzer Zugriff auf die.Xauthority
-Datei? - `su` Problem: Manchmal kann es Probleme mit
su
und der Umgebung geben. Wenn Sie weiterhin Probleme haben, das Script als Benutzer überudev
auszuführen, könnte eine fortgeschrittenere Methode übersystemd --user
-Dienste notwendig sein. Dabei triggert dieudev
-Regel einensystemctl --user
Befehl, der einen Service startet, der wiederum Ihr Script ausführt. Dies ist robuster, aber auch komplexer einzurichten. Für die meisten Fälle sollte diesu
-Methode ausreichen.
Feinjustierung und Best Practices
- Verzögerungen: Manchmal braucht das System einen Moment, um den Monitor vollständig zu erkennen. Sie können am Anfang Ihres Scripts eine kurze Verzögerung einbauen:
sleep 2
. - Robustheit: Erweitern Sie Ihr Script um Fehlerbehandlung. Überprüfen Sie z.B., ob
xrandr
überhaupt gefunden wird. - Standardkonfiguration: Eine „catch-all”
else
-Bedingung, die eine Standardkonfiguration für unbekannte Szenarien setzt, ist hilfreich. - Backup: Sichern Sie Ihre
udev
-Regel und Ihr Bashscript, besonders vor größeren Systemaktualisierungen. - KDE-Einstellungen: Stellen Sie sicher, dass die „Globale Skalierung” in den KDE-Systemeinstellungen auf 100% (1x) steht, um Konflikte mit Ihrer
xrandr
-basierten Skalierung zu vermeiden.
Fazit
Mit diesem umfassenden Guide haben Sie gelernt, wie Sie ein leistungsstarkes Bashscript erstellen und es mittels udev automatisieren, um die Bildschirmskalierung unter Arch Linux und KDE Plasma nahtlos zu handhaben. Sie können nun externe Monitore anschließen und trennen, ohne sich Gedanken über manuelle Anpassungen machen zu müssen. Dies ist ein großer Schritt in Richtung eines optimierten und frustfreien Desktop-Erlebnisses. Experimentieren Sie mit den Skalierungsfaktoren und Konfigurationen, um die perfekte Einstellung für Ihre Arbeitsumgebung zu finden!
Die Fähigkeit, Ihr System so detailliert anzupassen, ist einer der großen Vorteile von Arch Linux. Genießen Sie Ihr automatisch skalierendes Setup!