mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-16 22:01:22 +01:00
feat(nix): hotplug as shared steps and KDE extras
This commit is contained in:
1 parent
47123ad748
commit
f5db6975b4
6 files changed
+272
-222
No files matched your search
Whitespace-only changes.
Whitespace-only changes.
@@ -0,0 +1,7 @@
|
||||
"""What only KDE can check, each file after the shared scenario of the same name.
|
||||
|
||||
An extra has the shape of a scenario, `run(platform: KdePlatform, checks, ...)`, and takes the
|
||||
concrete platform so that it can use `platform.kde`: `kscreen-doctor`, `kdotool`, the daemon's log.
|
||||
A suite runs it with `platform_only("kde", ...)`. It does not repeat a check the shared scenario
|
||||
makes.
|
||||
"""
|
||||
@@ -0,0 +1,234 @@
|
||||
"""What only KDE can tell about monitors that change, round the shared `hotplug` scenario.
|
||||
|
||||
A scale that `kscreen-doctor` changes reaches the daemon as a change of the monitor's size; KWin
|
||||
tells the daemon that a window is on another output, whether the daemon or the user sent it
|
||||
there; and what the daemon believes of its monitors is what the compositor has.
|
||||
|
||||
The suite runs `setup`, `scale`, `sent_by_the_daemon` and `sent_by_the_user`, then the shared
|
||||
scenario, which unplugs a display and plugs it in again, then `after`. The daemon runs on a
|
||||
session with two outputs, and `clients` are three windows on the left one.
|
||||
"""
|
||||
|
||||
import time
|
||||
|
||||
from komorebi_vm import daemon
|
||||
from komorebi_vm.core.checks import Checks
|
||||
from komorebi_vm.core.geometry import Rect
|
||||
from komorebi_vm.core.platform import Client
|
||||
from komorebi_vm.kde_platform import KdePlatform
|
||||
|
||||
|
||||
def _monitor(platform: KdePlatform, idx: int) -> Rect:
|
||||
"""The bounds the daemon has for a monitor."""
|
||||
size = platform.kde.state()["monitors"]["elements"][idx]["size"]
|
||||
return Rect(size["left"], size["top"], size["right"], size["bottom"])
|
||||
|
||||
|
||||
def _containers_on(platform: KdePlatform, idx: int) -> int:
|
||||
"""How many containers the workspace in front of a monitor has in the daemon."""
|
||||
workspaces = platform.kde.state()["monitors"]["elements"][idx]["workspaces"]
|
||||
return len(workspaces["elements"][workspaces["focused"]]["containers"]["elements"])
|
||||
|
||||
|
||||
def _rects(platform: KdePlatform, clients: list[Client]) -> list[Rect]:
|
||||
"""The frames KWin has for the windows."""
|
||||
return [platform.kde.rect(platform.kde.wid(c.title)) for c in clients]
|
||||
|
||||
|
||||
def _tiled_in(platform: KdePlatform, clients: list[Client], area: Rect) -> bool:
|
||||
"""Every one of the windows is inside `area`, and none is on another.
|
||||
|
||||
A pixel is allowed at each edge: at a fractional scale KWin reports frames that are not whole
|
||||
pixels.
|
||||
"""
|
||||
frames = _rects(platform, clients)
|
||||
return all(r.inside(area, slack=1) for r in frames) and not any(
|
||||
a.overlaps(b) for i, a in enumerate(frames) for b in frames[i + 1 :]
|
||||
)
|
||||
|
||||
|
||||
def _on_the_right(platform: KdePlatform, clients: list[Client]) -> list[Client]:
|
||||
"""The windows that are on the right output, as KWin has them."""
|
||||
width = platform.size[0]
|
||||
pairs = zip(clients, _rects(platform, clients), strict=True)
|
||||
return [c for c, r in pairs if r.x >= width]
|
||||
|
||||
|
||||
def _output_changes(platform: KdePlatform) -> int:
|
||||
"""How many times KWin has told the daemon that a window is on another output."""
|
||||
events = daemon.events(platform.kde.komorebi_log())
|
||||
return sum(1 for e in events if e.kind == "OutputChange")
|
||||
|
||||
|
||||
def _let_komorebi_finish(platform: KdePlatform) -> None:
|
||||
"""Waits until the bridge has stopped asking again for the position of the windows the daemon
|
||||
just moved.
|
||||
|
||||
The bridge asks again for a second after each command (`WANT_MS` in `bridge.js`), which puts
|
||||
back a window that somebody moves in that time. A user moves a window later than that, so a
|
||||
test that plays the user does too.
|
||||
"""
|
||||
time.sleep(2 * platform.kde.scale)
|
||||
|
||||
|
||||
def _show(platform: KdePlatform, clients: list[Client], what: str) -> None:
|
||||
"""Prints where the daemon has the windows and where KWin has them, for a failure to be read."""
|
||||
state = f"{_containers_on(platform, 0)} on the left monitor, {_containers_on(platform, 1)} on"
|
||||
frames = ", ".join(
|
||||
f"{c.title} {r}" for c, r in zip(clients, _rects(platform, clients), strict=True)
|
||||
)
|
||||
print(f" {what}: komorebi has {state} the right; KWin has {frames}")
|
||||
log = platform.kde.komorebi_log().splitlines()
|
||||
lines = [x[-160:] for x in log if "OutputChange" in x or "following them" in x][-8:]
|
||||
print(" " + "\n ".join(lines))
|
||||
|
||||
|
||||
def setup(platform: KdePlatform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""The daemon has a monitor for each of the two outputs, with the size of its output, and the
|
||||
windows are on the left one."""
|
||||
width, height = platform.size
|
||||
checks.check(
|
||||
"the daemon answers komorebic, with both monitors",
|
||||
platform.wait_for(
|
||||
lambda: len(platform.state().monitors) == 2 and platform.komorebic("state") != "",
|
||||
timeout=30,
|
||||
),
|
||||
)
|
||||
checks.check(
|
||||
"the daemon has the three windows on the left monitor",
|
||||
platform.wait_for(
|
||||
lambda: _containers_on(platform, 0) == 3 and _containers_on(platform, 1) == 0
|
||||
),
|
||||
)
|
||||
checks.check(
|
||||
"the left monitor has the size of its output",
|
||||
_monitor(platform, 0) == Rect(0, 0, width, height),
|
||||
)
|
||||
checks.check(
|
||||
"the windows are tiled inside it",
|
||||
platform.wait_for(lambda: _tiled_in(platform, clients, _monitor(platform, 0))),
|
||||
)
|
||||
|
||||
|
||||
def scale(platform: KdePlatform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""The scale of the left output changes to 1.5 and back, and the daemon follows both."""
|
||||
width, height = platform.size
|
||||
left = platform.kde.outputs.names()[0]
|
||||
resizes = lambda: platform.kde.komorebi_log().count("updated monitor size and work area") # noqa: E731
|
||||
before = resizes()
|
||||
platform.kde.outputs.scale(left, 1.5)
|
||||
smaller = Rect(0, 0, width * 2 // 3, height * 2 // 3)
|
||||
checks.check(
|
||||
f"the daemon has the new size of the monitor, {smaller}",
|
||||
platform.wait_for(lambda: _monitor(platform, 0) == smaller, timeout=20),
|
||||
)
|
||||
checks.check("it read the sizes again for it", resizes() > before)
|
||||
checks.check(
|
||||
"the windows are tiled again inside the monitor as it is now",
|
||||
platform.wait_for(lambda: _tiled_in(platform, clients, smaller)),
|
||||
)
|
||||
platform.kde.outputs.scale(left, 1)
|
||||
full = Rect(0, 0, width, height)
|
||||
checks.check(
|
||||
"the monitor has its size back, and the windows fill it again",
|
||||
platform.wait_for(
|
||||
lambda: _monitor(platform, 0) == full and _tiled_in(platform, clients, full),
|
||||
timeout=20,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def sent_by_the_daemon(platform: KdePlatform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""`move-to-monitor 1` sends the focused window to the right output: KWin reports it there,
|
||||
and the daemon leaves it where it put it."""
|
||||
changes = _output_changes(platform)
|
||||
platform.komorebic("move-to-monitor", "1")
|
||||
checks.check(
|
||||
"the daemon has two containers on the left monitor and one on the right",
|
||||
platform.wait_for(
|
||||
lambda: _containers_on(platform, 0) == 2 and _containers_on(platform, 1) == 1
|
||||
),
|
||||
)
|
||||
checks.check(
|
||||
"KWin reported the window on the other output",
|
||||
platform.wait_for(lambda: _output_changes(platform) > changes),
|
||||
)
|
||||
moved = _on_the_right(platform, clients)
|
||||
checks.check(
|
||||
"the window is tiled on the right output",
|
||||
len(moved) == 1 and _tiled_in(platform, moved, _monitor(platform, 1)),
|
||||
)
|
||||
checks.check(
|
||||
"and it is still on the right monitor once KWin has said so",
|
||||
_containers_on(platform, 0) == 2 and _containers_on(platform, 1) == 1,
|
||||
)
|
||||
|
||||
|
||||
def _send_by_the_user(platform: KdePlatform, clients: list[Client]) -> Client:
|
||||
"""Moves a window that is on the left output to the right one, as a shortcut that sends a
|
||||
window to the next screen does: not by the daemon."""
|
||||
right = _on_the_right(platform, clients)
|
||||
window = next(c for c in clients if c not in right)
|
||||
_let_komorebi_finish(platform)
|
||||
platform.move_window(window, platform.size[0] + 180, 300)
|
||||
return window
|
||||
|
||||
|
||||
def sent_by_the_user(platform: KdePlatform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""A window the user moves to the other output is tiled on that monitor."""
|
||||
_send_by_the_user(platform, clients)
|
||||
checks.check(
|
||||
"the daemon has one container on the left monitor and two on the right",
|
||||
platform.wait_for(
|
||||
lambda: _containers_on(platform, 0) == 1 and _containers_on(platform, 1) == 2
|
||||
),
|
||||
)
|
||||
checks.check(
|
||||
"the two are tiled on the right output, and the third fills the left one",
|
||||
platform.wait_for(lambda: _split_tiled(platform, clients, 2)),
|
||||
)
|
||||
_show(platform, clients, "after the user's move")
|
||||
|
||||
|
||||
def _split_tiled(platform: KdePlatform, clients: list[Client], on_right: int) -> bool:
|
||||
right = _on_the_right(platform, clients)
|
||||
left = [c for c in clients if c not in right]
|
||||
return (
|
||||
len(right) == on_right
|
||||
and _tiled_in(platform, right, _monitor(platform, 1))
|
||||
and (not left or _tiled_in(platform, left, _monitor(platform, 0)))
|
||||
)
|
||||
|
||||
|
||||
def after(platform: KdePlatform, checks: Checks, clients: list[Client]) -> None:
|
||||
"""After the display was unplugged and plugged in again the daemon is alive and agrees with
|
||||
KWin on the focus, and a window the user moves to the other output is followed."""
|
||||
kde = platform.kde
|
||||
|
||||
def focus_agrees() -> bool:
|
||||
# the focused window may be on either monitor: the shared scenario sent one to the other
|
||||
state = platform.state()
|
||||
return (
|
||||
kde.komorebi_running()
|
||||
and kde.active() != ""
|
||||
and kde.title(kde.active()) == state.focused_title(monitor=state.focused_monitor)
|
||||
)
|
||||
|
||||
checks.check(
|
||||
"the daemon is alive and its idea of the focus is KWin's", platform.wait_for(focus_agrees)
|
||||
)
|
||||
on_right = len(_on_the_right(platform, clients))
|
||||
_send_by_the_user(platform, clients)
|
||||
checks.check(
|
||||
"the daemon follows a window moved to the other output again",
|
||||
platform.wait_for(lambda: _containers_on(platform, 1) == on_right + 1),
|
||||
)
|
||||
checks.check(
|
||||
"it is tiled on the right output, and the others on the left",
|
||||
platform.wait_for(lambda: _split_tiled(platform, clients, on_right + 1)),
|
||||
)
|
||||
_show(platform, clients, "after the second move")
|
||||
checks.check(
|
||||
"the daemon is running and answers",
|
||||
kde.komorebi_running() and kde.run("komorebic state")[0] == 0,
|
||||
)
|
||||
@@ -10,7 +10,14 @@ requires-python = ">=3.12"
|
||||
dependencies = ["pillow"]
|
||||
|
||||
[tool.setuptools]
|
||||
packages = ["komorebi_vm", "komorebi_vm.core", "komorebi_vm.core.scenarios"]
|
||||
packages = [
|
||||
"komorebi_vm",
|
||||
"komorebi_vm.core",
|
||||
"komorebi_vm.core.scenarios",
|
||||
"komorebi_vm.platforms",
|
||||
"komorebi_vm.platforms.kde",
|
||||
"komorebi_vm.platforms.kde.extras",
|
||||
]
|
||||
|
||||
[tool.setuptools.package-data]
|
||||
komorebi_vm = ["py.typed"]
|
||||
|
||||
@@ -1,20 +1,19 @@
|
||||
# Monitors that change, against a real headless KWin with two outputs. What only a real KWin can
|
||||
# tell: that `kscreen-doctor` changing the scale of an output reaches komorebi as a change of that
|
||||
# monitor's size, and the windows on it are tiled in the size it has now; that a window moved to
|
||||
# the other output by something other than komorebi (what a shortcut that sends a window to the
|
||||
# next screen does) is tiled on that monitor, and one komorebi moved itself is left where it is;
|
||||
# that an output that is disabled (KWin's way to unplug one) takes its windows to the other
|
||||
# output, where komorebi tiles them; and that the output enabled again is a monitor again, which
|
||||
# windows can be sent to. `komorebi/tests/monitor_resize.rs`, `komorebi/tests/hotplug.rs` and
|
||||
# `komorebi/tests/follow_output.rs` check the same against the fake.
|
||||
import time
|
||||
|
||||
from komorebi_vm import Checks, Kde, Rect, daemon
|
||||
from komorebi_vm.core.platform import Client
|
||||
# Monitors that change, against a real headless KWin with two outputs. The shared scenario is
|
||||
# `komorebi_vm.core.scenarios.hotplug`, which runs on Windows too: it unplugs a display, plugs one in
|
||||
# and sends a window to it, and asks the operating system where the windows are. What only a real
|
||||
# KWin can tell is in `komorebi_vm.platforms.kde.extras.hotplug`: that `kscreen-doctor` changing
|
||||
# the scale of an output reaches komorebi as a change of that monitor's size, that KWin reports a
|
||||
# window on another output whether komorebi or the user sent it there, and that a window the user
|
||||
# moves to the other output is tiled on that monitor. `komorebi/tests/monitor_resize.rs`,
|
||||
# `komorebi/tests/hotplug.rs` and `komorebi/tests/follow_output.rs` check the same against the fake.
|
||||
from komorebi_vm import Checks, Kde
|
||||
from komorebi_vm.core.scenarios import hotplug
|
||||
from komorebi_vm.core.suite import platform_only, run_suite, shared
|
||||
from komorebi_vm.kde_platform import KdePlatform
|
||||
from komorebi_vm.platforms.kde.extras import hotplug as kde_hotplug
|
||||
|
||||
W, H = 1920, 1080
|
||||
TITLES = ["w1", "w2", "w3"]
|
||||
|
||||
start_all()
|
||||
machine.wait_for_unit("multi-user.target")
|
||||
@@ -22,218 +21,21 @@ machine.wait_for_unit("user@1000.service")
|
||||
|
||||
checks = Checks()
|
||||
kde = Kde.headless(machine, "main", size=(W, H), outputs=2, scale=SCALE)
|
||||
platform = KdePlatform(kde, (W, H))
|
||||
|
||||
TITLES = ["w1", "w2", "w3"]
|
||||
platform.start_komorebi()
|
||||
clients = [platform.spawn(title) for title in TITLES]
|
||||
|
||||
|
||||
def monitor(idx: int) -> Rect:
|
||||
"""The bounds komorebi has for a monitor."""
|
||||
size = kde.state()["monitors"]["elements"][idx]["size"]
|
||||
return Rect(size["left"], size["top"], size["right"], size["bottom"])
|
||||
|
||||
|
||||
def monitors() -> int:
|
||||
"""How many monitors komorebi has."""
|
||||
return len(kde.state()["monitors"]["elements"])
|
||||
|
||||
|
||||
def containers_on(idx: int) -> int:
|
||||
"""How many containers the workspace in front of a monitor has in komorebi."""
|
||||
workspaces = kde.state()["monitors"]["elements"][idx]["workspaces"]
|
||||
return len(workspaces["elements"][workspaces["focused"]]["containers"]["elements"])
|
||||
|
||||
|
||||
def rects(titles: list[str]) -> list[Rect]:
|
||||
"""The frames KWin has for these windows."""
|
||||
return [kde.rect(kde.wid(title)) for title in titles]
|
||||
|
||||
|
||||
def tiled_in(titles: list[str], area: Rect) -> bool:
|
||||
"""Every one of these windows is inside `area`, and none is on another.
|
||||
|
||||
A pixel is allowed at each edge: at a fractional scale KWin reports frames that are not
|
||||
whole pixels.
|
||||
"""
|
||||
frames = rects(titles)
|
||||
return all(r.inside(area, slack=1) for r in frames) and not any(
|
||||
a.overlaps(b) for i, a in enumerate(frames) for b in frames[i + 1 :]
|
||||
)
|
||||
|
||||
|
||||
def on_the_right() -> list[str]:
|
||||
"""The windows that are on the right output, as KWin has them."""
|
||||
return [t for t, r in zip(TITLES, rects(TITLES), strict=True) if r.x >= W]
|
||||
|
||||
|
||||
def output_changes() -> int:
|
||||
"""How many times KWin has told the daemon that a window is on another output."""
|
||||
return sum(1 for e in daemon.events(kde.komorebi_log()) if e.kind == "OutputChange")
|
||||
|
||||
|
||||
def output_lines() -> list[str]:
|
||||
"""The lines of the daemon's log about windows on other outputs, for a failure to be read."""
|
||||
log = kde.komorebi_log().splitlines()
|
||||
return [line[-160:] for line in log if "OutputChange" in line or "following them" in line][-8:]
|
||||
|
||||
|
||||
def let_komorebi_finish() -> None:
|
||||
"""Waits until the bridge has stopped asking again for the position of the windows komorebi
|
||||
just moved.
|
||||
|
||||
The bridge asks again for a second after each command (`WANT_MS` in `bridge.js`), which puts
|
||||
back a window that somebody moves in that time. A user moves a window later than that, so a
|
||||
test that plays the user does too.
|
||||
"""
|
||||
time.sleep(2 * SCALE)
|
||||
|
||||
|
||||
def show(what: str) -> None:
|
||||
"""Prints where komorebi has the windows and where KWin has them, for a failure to be read."""
|
||||
state = f"{containers_on(0)} on the left monitor, {containers_on(1)} on the right"
|
||||
frames = ", ".join(f"{t} {r}" for t, r in zip(TITLES, rects(TITLES), strict=True))
|
||||
print(f" {what}: komorebi has {state}; KWin has {frames}")
|
||||
|
||||
|
||||
def resizes_handled() -> int:
|
||||
"""How many times the daemon has read the sizes of its monitors again."""
|
||||
return kde.komorebi_log().count("updated monitor size and work area")
|
||||
|
||||
|
||||
print("== 1. two outputs, and three windows on the left one")
|
||||
left, right = kde.outputs.names()
|
||||
print(f" outputs: {left} (left), {right} (right)")
|
||||
kde.start_komorebi()
|
||||
checks.check(
|
||||
"the daemon answers komorebic, with both monitors",
|
||||
kde.wait_for(lambda: kde.run("komorebic state")[0] == 0 and monitors() == 2, timeout=30),
|
||||
)
|
||||
for title in TITLES:
|
||||
kde.spawn(f"foot -T {title} sleep 3000")
|
||||
kde.wait_for(lambda title=title: kde.wid(title) != "", timeout=30)
|
||||
checks.check(
|
||||
"komorebi has the three windows on the left monitor",
|
||||
kde.wait_for(lambda: containers_on(0) == 3 and containers_on(1) == 0),
|
||||
)
|
||||
checks.check("the left monitor has the size of its output", monitor(0) == Rect(0, 0, W, H))
|
||||
checks.check("the windows are tiled inside it", kde.wait_for(lambda: tiled_in(TITLES, monitor(0))))
|
||||
|
||||
print("== 2. the scale of the left output changes")
|
||||
before = resizes_handled()
|
||||
kde.outputs.scale(left, 1.5)
|
||||
smaller = Rect(0, 0, W * 2 // 3, H * 2 // 3)
|
||||
checks.check(
|
||||
f"komorebi has the new size of the monitor, {smaller}",
|
||||
kde.wait_for(lambda: monitor(0) == smaller, timeout=20),
|
||||
)
|
||||
checks.check("it read the sizes again for it", resizes_handled() > before)
|
||||
checks.check(
|
||||
"the windows are tiled again inside the monitor as it is now",
|
||||
kde.wait_for(lambda: tiled_in(TITLES, smaller)),
|
||||
)
|
||||
kde.outputs.scale(left, 1)
|
||||
checks.check(
|
||||
"the monitor has its size back, and the windows fill it again",
|
||||
kde.wait_for(lambda: monitor(0) == Rect(0, 0, W, H) and tiled_in(TITLES, monitor(0)), 20),
|
||||
run_suite(
|
||||
checks,
|
||||
platform_only("kde", kde_hotplug.setup, platform, checks, clients),
|
||||
platform_only("kde", kde_hotplug.scale, platform, checks, clients),
|
||||
platform_only("kde", kde_hotplug.sent_by_the_daemon, platform, checks, clients),
|
||||
platform_only("kde", kde_hotplug.sent_by_the_user, platform, checks, clients),
|
||||
shared(hotplug.run, platform, checks, clients),
|
||||
platform_only("kde", kde_hotplug.after, platform, checks, clients),
|
||||
)
|
||||
|
||||
print("== 3. komorebi sends a window to the right monitor itself")
|
||||
changes = output_changes()
|
||||
kde.komorebic("move-to-monitor", "1")
|
||||
checks.check(
|
||||
"komorebi has two containers on the left monitor and one on the right",
|
||||
kde.wait_for(lambda: containers_on(0) == 2 and containers_on(1) == 1),
|
||||
)
|
||||
checks.check(
|
||||
"KWin reported the window on the other output",
|
||||
kde.wait_for(lambda: output_changes() > changes),
|
||||
)
|
||||
moved = on_the_right()
|
||||
checks.check(
|
||||
"the window is tiled on the right output",
|
||||
len(moved) == 1 and tiled_in(moved, monitor(1)),
|
||||
)
|
||||
checks.check(
|
||||
"and it is still on the right monitor once KWin has said so",
|
||||
containers_on(0) == 2 and containers_on(1) == 1,
|
||||
)
|
||||
|
||||
print("== 4. the user sends another window to the right screen")
|
||||
sent = [t for t in TITLES if t not in moved][0]
|
||||
let_komorebi_finish()
|
||||
kde.sh(f"kdotool windowmove {kde.wid(sent)} 2100 300")
|
||||
checks.check(
|
||||
"komorebi has one container on the left monitor and two on the right",
|
||||
kde.wait_for(lambda: containers_on(0) == 1 and containers_on(1) == 2),
|
||||
)
|
||||
checks.check(
|
||||
"the two are tiled on the right output, and the third fills the left one",
|
||||
kde.wait_for(
|
||||
lambda: len(on_the_right()) == 2
|
||||
and tiled_in(on_the_right(), monitor(1))
|
||||
and tiled_in([t for t in TITLES if t not in on_the_right()], monitor(0))
|
||||
),
|
||||
)
|
||||
show("after the user's move")
|
||||
print(" " + "\n ".join(output_lines()))
|
||||
|
||||
print("== 5. the right output is unplugged")
|
||||
kde.outputs.disable(right)
|
||||
checks.check("komorebi has one monitor", kde.wait_for(lambda: monitors() == 1, timeout=30))
|
||||
checks.check("and all three windows on it", kde.wait_for(lambda: containers_on(0) == 3))
|
||||
checks.check(
|
||||
"they are tiled inside the screen that is left, and not on each other",
|
||||
kde.wait_for(lambda: tiled_in(TITLES, Rect(0, 0, W, H))),
|
||||
)
|
||||
checks.check(
|
||||
"komorebi is alive and its idea of the focus is KWin's",
|
||||
kde.wait_for(
|
||||
lambda: kde.komorebi_running()
|
||||
and kde.active() != ""
|
||||
and kde.title(kde.active()) == kde.focused_title(0)
|
||||
),
|
||||
)
|
||||
|
||||
print("== 6. it is plugged back")
|
||||
kde.outputs.enable(right)
|
||||
checks.check("komorebi has two monitors again", kde.wait_for(lambda: monitors() == 2, timeout=30))
|
||||
checks.check("and still three windows", kde.wait_for(lambda: kde.managed_all() == 3))
|
||||
checks.check(
|
||||
"each window is somewhere it can be seen",
|
||||
kde.wait_for(
|
||||
lambda: all(
|
||||
r.inside(Rect(0, 0, W, H), 1) or r.inside(Rect(W, 0, W, H), 1) for r in rects(TITLES)
|
||||
)
|
||||
),
|
||||
)
|
||||
|
||||
print("== 7. and a window can be sent over again")
|
||||
let_komorebi_finish()
|
||||
kde.sh(f"kdotool windowmove {kde.wid('w3')} 2100 300")
|
||||
checks.check(
|
||||
"komorebi follows it: one container on the right monitor",
|
||||
kde.wait_for(lambda: containers_on(1) == 1),
|
||||
)
|
||||
checks.check(
|
||||
"it is tiled on the right output, and the others together on the left",
|
||||
kde.wait_for(
|
||||
lambda: on_the_right() == ["w3"]
|
||||
and tiled_in(["w3"], monitor(1))
|
||||
and tiled_in(["w1", "w2"], monitor(0))
|
||||
),
|
||||
)
|
||||
show("after the second move")
|
||||
print(" " + "\n ".join(output_lines()))
|
||||
|
||||
print("== 7b. the same, through the neutral platform")
|
||||
# the scenario of komorebi_vm.core.scenarios.hotplug is what runs on Windows too: it unplugs a
|
||||
# display, plugs one in and sends a window to it, and asks the operating system where the windows are
|
||||
hotplug.run(KdePlatform(kde, (W, H)), checks, [Client(t) for t in TITLES])
|
||||
|
||||
print("== 8. nothing is left behind")
|
||||
checks.check(
|
||||
"komorebi is running and answers",
|
||||
kde.komorebi_running() and kde.run("komorebic state")[0] == 0,
|
||||
)
|
||||
kde.stop_komorebi()
|
||||
checks.check("komorebi stopped", not kde.komorebi_running())
|
||||
|
||||
|
||||
Reference in new issue
Block a user