mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-20 23:51:40 +01:00
komorebi's workspaces exist on Windows and macOS because neither has a virtual desktop API: switching hides every window of the workspace being left. KWin has virtual desktops, per output since 6.8, so here workspace i is KWin's desktop i on every monitor, and each monitor shows one. KWin shows, hides and focuses the windows of a desktop; komorebi asks for a switch, puts a window on a desktop, and follows what anything else does. The Backend gets the workspace methods (ensure_workspaces, switch_workspace, set_window_workspace, window_workspace, current_workspaces), and the fake its desktops. The bridge reports the desktops, the desktop each output shows and a window's desktops, and carries out output_desktop and desktop commands, typed and tested with the fixtures like the rest. The table turns a switch or a move komorebi did not make into a WorkspaceChange or a WorkspaceMove, and records its own when it sends them, so that KWin's report of those raises nothing. The window manager follows a switch with no command in reply (adopt_workspace_change), puts windows on their desktops before a desktop is shown (focusing a window first would take the monitor back), and loads the windows open at startup onto the workspace of their desktop. Per-output desktops are a kwinrc setting that is off by default, and kwriteconfig6 was not on the PATH of the user service in a live session, so komorebi edits kwinrc itself (kwin::kwinrc) and puts the user's value back when it stops, also after a crash. focus-workspace, move-to-workspace and send-to-workspace come with this commit, since the tests of switching and moving, and vm-workspace-switch, need them; the named and cycling workspace commands follow. vm-workspace-switch runs the daemon against a real KWin; vm-kwin-contract checks what komorebi relies on from KWin's per-output desktops, on a headless KWin with two outputs and no komorebi.
141 lines
5.8 KiB
Python
141 lines
5.8 KiB
Python
# komorebi's workspaces are KWin's own virtual desktops, per output. What only a real KWin can
|
|
# tell: that komorebi turns on KWin's per-output virtual desktops and puts the user's setting back
|
|
# when it stops; that `komorebic send-to-workspace` puts a window on another desktop and leaves the
|
|
# one in front showing; that `komorebic focus-workspace` has KWin show the other desktop, and KWin
|
|
# focuses the window there, which komorebi agrees with, without komorebi hiding or parking any
|
|
# window; that a switch by anything else (a shortcut, an app raising a window of another desktop)
|
|
# is followed once, with KWin and komorebi agreeing on the focused window and nothing flip-flopping;
|
|
# and that a window moved to another desktop by someone else (the window menu's "Move to Desktop")
|
|
# moves to that workspace. `komorebi/tests/workspaces.rs` checks the same against the fake.
|
|
import time
|
|
|
|
from komorebi_vm import Checks, Kde, daemon
|
|
|
|
start_all()
|
|
machine.wait_for_unit("multi-user.target")
|
|
machine.wait_for_unit("user@1000.service")
|
|
|
|
checks = Checks()
|
|
kde = Kde.headless(machine, "main", size=(1920, 1080), scale=SCALE)
|
|
|
|
|
|
def focus_changes() -> int:
|
|
return sum(1 for e in daemon.events(kde.komorebi_log()) if e.kind == "FocusChange")
|
|
|
|
|
|
def ws() -> int:
|
|
"""The workspace komorebi has in front on the (only) monitor."""
|
|
return kde.state()["monitors"]["elements"][0]["workspaces"]["focused"]
|
|
|
|
|
|
def active_title() -> str:
|
|
active = kde.active()
|
|
return kde.title(active) if active else ""
|
|
|
|
|
|
def per_output() -> bool:
|
|
return kde.kwinrc("Windows", "PerOutputVirtualDesktops") == "true"
|
|
|
|
|
|
print("== 1. start, and three windows")
|
|
checks.check("per-output virtual desktops are off before komorebi starts", not per_output())
|
|
kde.start_komorebi()
|
|
checks.check(
|
|
"the daemon answers komorebic",
|
|
kde.wait_for(lambda: kde.run("komorebic state")[0] == 0, timeout=30),
|
|
)
|
|
for title in ["w1", "w2", "w3"]:
|
|
kde.spawn(f"foot -T {title} sleep 3000")
|
|
kde.wait_for(lambda title=title: kde.wid(title) != "", timeout=30)
|
|
checks.check("komorebi manages the three", kde.wait_for(lambda: kde.managed(0) == 3, timeout=20))
|
|
|
|
print("== 2. workspaces are desktops")
|
|
checks.check("komorebi turned on per-output virtual desktops in kwinrc", per_output())
|
|
checks.check(
|
|
"all three windows are on desktop 1, which is showing",
|
|
all(kde.desk(kde.wid(t)) == 1 for t in ["w1", "w2", "w3"]) and kde.shown() == 1,
|
|
)
|
|
|
|
print("== 3. one window goes to workspace 1 and stays there")
|
|
moved = active_title()
|
|
mid = kde.wid(moved)
|
|
kde.komorebic("send-to-workspace", "1")
|
|
checks.check(
|
|
f"{moved} is on desktop 2, and desktop 1 is still showing",
|
|
kde.wait_for(lambda: kde.desk(mid) == 2 and kde.shown() == 1 and ws() == 0),
|
|
)
|
|
checks.check(
|
|
"the other two are on workspace 0, and komorebi has the moved one on workspace 1",
|
|
kde.wait_for(lambda: kde.managed(0) == 2 and kde.managed(1) == 1),
|
|
)
|
|
stayed = [t for t in ["w1", "w2", "w3"] if t != moved]
|
|
|
|
print("== 4. komorebic switches workspace: KWin shows the desktop, komorebi hides nothing")
|
|
kde.komorebic("focus-workspace", "1")
|
|
checks.check(
|
|
"desktop 2 is showing and komorebi agrees",
|
|
kde.wait_for(lambda: kde.shown() == 2 and ws() == 1),
|
|
)
|
|
checks.check(
|
|
"KWin focused the window of that desktop and komorebi knows it",
|
|
kde.wait_for(lambda: active_title() == moved and kde.focused_title(1) == moved),
|
|
)
|
|
checks.check(
|
|
"the windows of desktop 1 never left it", all(kde.desk(kde.wid(t)) == 1 for t in stayed)
|
|
)
|
|
checks.check("komorebi made one desktop, for workspace 1, and no other", kde.desktops() == 2)
|
|
kde.komorebic("focus-workspace", "0")
|
|
checks.check("back on desktop 1", kde.wait_for(lambda: kde.shown() == 1 and ws() == 0))
|
|
|
|
print("== 5. something else switches: a pager or a shortcut")
|
|
kde.sh("busctl --user call org.kde.KWin /KWin org.kde.KWin setCurrentDesktop i 2 > /dev/null")
|
|
checks.check("komorebi followed to workspace 1", kde.wait_for(lambda: ws() == 1))
|
|
checks.check(
|
|
"and agrees with KWin on the focused window",
|
|
kde.wait_for(lambda: active_title() != "" and active_title() == kde.focused_title(1)),
|
|
)
|
|
|
|
print("== 6. an app raises a window of another desktop")
|
|
kde.sh("busctl --user call org.kde.KWin /KWin org.kde.KWin setCurrentDesktop i 1 > /dev/null")
|
|
kde.wait_for(lambda: ws() == 0)
|
|
time.sleep(1 * SCALE)
|
|
before = focus_changes()
|
|
kde.activate(mid)
|
|
checks.check(
|
|
"KWin switched to the window's desktop and komorebi followed",
|
|
kde.wait_for(lambda: kde.shown() == 2 and ws() == 1),
|
|
)
|
|
checks.check(
|
|
f"KWin and komorebi agree on the focused window: {moved}",
|
|
kde.wait_for(lambda: active_title() == moved and kde.focused_title(1) == moved),
|
|
)
|
|
time.sleep(3 * SCALE)
|
|
after = focus_changes()
|
|
print(f" focus changes komorebi handled meanwhile: {after - before}")
|
|
checks.check(
|
|
f"nothing is flip-flopping (at most 6 focus events, got {after - before})",
|
|
after - before <= 6,
|
|
)
|
|
time.sleep(3 * SCALE)
|
|
final = focus_changes()
|
|
checks.check(f"and it stays quiet afterwards ({final - after} more)", final - after <= 1)
|
|
|
|
print("== 7. somebody moves a window to another desktop (the window menu's Move to Desktop)")
|
|
other = kde.wid(stayed[0])
|
|
kde.sh(f"kdotool set_desktop_for_window {other} 2")
|
|
checks.check(
|
|
"komorebi moved it to workspace 1: one window left on workspace 0, two on workspace 1",
|
|
kde.wait_for(lambda: kde.managed(0) == 1 and kde.managed(1) == 2),
|
|
)
|
|
checks.check("and left it where KWin put it", kde.desk(other) == 2)
|
|
checks.check("KWin carried out every command", "the bridge could not do" not in kde.komorebi_log())
|
|
|
|
print("== 8. a clean stop")
|
|
kde.komorebic("stop")
|
|
checks.check("the daemon exited", kde.wait_for(lambda: not kde.komorebi_running()))
|
|
checks.check("per-output virtual desktops are back as they were (off)", not per_output())
|
|
checks.check("the desktops komorebi made stay: they are the user's now", kde.desktops() == 2)
|
|
|
|
kde.stop()
|
|
checks.finish()
|