fix(nix): KdePlatform.work_area asks KWin for the area less the panels

The headless suites have no panel, so the whole output was right there,
but a session with one got a work area that scenarios could not hold a
window to. KWin's placement area of the first output is asked through a
script, with the whole output as the answer where KWin does not say.

The contract of Platform.work_area is spelled out: the display less what
the system keeps for itself, as the system says. Monocle and maximize
check that the window stays inside it. The fake platform takes a panel,
and a daemon that tiles under it.
This commit is contained in:
LGUG2Z committed 2026-10-30 12:51:01 -07:00
1 parent 720daea382
commit 9c9639949c
8 files changed
+228 -23

No files matched your search

@@ -191,7 +191,13 @@ class Platform(Protocol):
...
def work_area(self) -> Rect:
"""The area of the first display that windows may take."""
"""The area of the first display that windows may take, in the coordinates of the
desktop: the display less what the operating system keeps for itself (a panel, a dock, the
taskbar), as the operating system says and not the daemon.
It is the whole display only where there is nothing of the kind. A scenario that asks
whether a window is "inside the work area" asks this, so a platform that answers with the
display where the system has a bar makes that check weaker than it says."""
...
def activate(self, client: Client) -> None:
@@ -33,6 +33,11 @@ def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
f"after 'toggle-maximize' {target.title} fills the work area",
platform.wait_for(fills, timeout=20),
)
window = platform.os_window(target)
checks.check(
"... without going past the work area",
window is not None and window.frame.inside(area),
)
checks.check(
"... and the daemon has it as the maximized window",
platform.wait_for(lambda: maximized() == target.title, timeout=20),
@@ -30,6 +30,11 @@ def run(platform: Platform, checks: Checks, clients: list[Client]) -> None:
"in monocle the focused window fills the work area",
platform.wait_for(fills_the_work_area, timeout=20),
)
window = platform.os_window(last)
checks.check(
"... without going past the work area",
window is not None and window.frame.inside(area),
)
checks.check(
"... the daemon's state has it as the monocle container",
platform.wait_for(
+42
View File
@@ -5,6 +5,7 @@ import re
import shlex
import time
from collections.abc import Callable
from itertools import count
from typing import Any
from PIL import Image
@@ -12,6 +13,9 @@ from PIL import Image
from komorebi_vm.core.geometry import Rect
from komorebi_vm.machine import Machine
# a KWin script is told apart by its name in the journal, so each probe has a name of its own
_PROBES = count(1)
class Outputs:
"""The outputs of a KWin session, as `kscreen-doctor` lists and changes them.
@@ -698,6 +702,44 @@ class Kde:
)
return [line for line in self.kwin_reports(name) if line != "done"]
def work_area(self) -> Rect | None:
"""The area of the first output that windows may take, as KWin has it (its placement
area: the output less the panels), or `None` when KWin does not say.
The first output is the leftmost one. It is the area of the desktop the output shows, as
the daemon's bridge reads it. A KWin script asks, because `kdotool` has no call for it.
"""
source = """
var first = null;
for (var i = 0; i < workspace.screens.length; i++) {
var s = workspace.screens[i];
if (first === null || s.geometry.x < first.geometry.x
|| (s.geometry.x === first.geometry.x && s.geometry.y < first.geometry.y)) {
first = s;
}
}
if (first !== null) {
var a = workspace.clientArea(
KWin.PlacementArea, first, workspace.currentDesktopForScreen(first));
report("area", Math.round(a.x), Math.round(a.y), Math.round(a.width),
Math.round(a.height));
}
report("done");
"""
try:
lines = self.kwin_script(f"work-area-{next(_PROBES)}", source)
except AssertionError:
return None
for line in lines:
words = line.split()
if words[:1] == ["area"] and len(words) == 5:
try:
x, y, w, h = (int(word) for word in words[1:])
except ValueError:
return None
return Rect(x, y, w, h) if w > 0 and h > 0 else None
return None
def kwin_reports(self, name: str) -> list[str]:
"""Every line the KWin script `name` has reported so far ([`Kde.kwin_script`][])."""
log = self.machine.execute(f"journalctl _UID={self.uid} --no-pager -o cat")[1]
+8 -1
View File
@@ -180,7 +180,14 @@ class KdePlatform:
self.kde.sh(f"kdotool windowmove {self.kde.wid(client.title)} {x} {y}")
def work_area(self) -> Rect:
return Rect(0, 0, *self.size)
"""What KWin says windows may take of the first output, which is the output less the
panels and docks the shell has made (a headless session has none, so it is all of it).
Where KWin does not answer, the first output whole: a scenario then checks less, and does
not fail for it.
"""
area = self.kde.work_area()
return area if area is not None else Rect(0, 0, *self.size)
def minimize(self, client: Client) -> None:
self.kde.minimize(self.kde.wid(client.title))
+61 -21
View File
@@ -14,7 +14,7 @@ from komorebi_vm.core.platform import Client, OsWindow
from komorebi_vm.core.scenarios.commands import PRINTED
from komorebi_vm.core.snapshot import Snapshot, parse
TILES = [Rect(0, 0, 640, 1080), Rect(640, 0, 640, 1080), Rect(1280, 0, 640, 1080)]
SCREEN = Rect(0, 0, 1920, 1080)
def _place_index(place: str, count: int) -> int:
@@ -60,8 +60,18 @@ class FakePlatform:
follows_pointer: bool = True,
reloads: bool = True,
retiles_on_unlock: bool = True,
panel: int = 0,
ignores_panel: bool = False,
second: Rect | None = None,
) -> None:
self.tiles = list(TILES)
self.panel = panel
"""The height of a panel along the bottom of the first display, which the work area leaves
out."""
self.ignores_panel = ignores_panel
"""A daemon that tiles on the whole display, under the panel."""
self.second = second
"""The rectangle of the second display, when it is not one of the first's size."""
self.tiles = self._base()
self.has_pointer = pointer
self.follows_pointer = follows_pointer
self.spaces: list[list[list[str]]] = [[], [], []]
@@ -108,6 +118,21 @@ class FakePlatform:
self.moves = moves
self.focus_follows_move = focus_follows_move
@property
def area(self) -> Rect:
"""What windows may take of the first display."""
return Rect(0, 0, SCREEN.w, SCREEN.h - self.panel)
@property
def tiled_area(self) -> Rect:
"""What the daemon tiles on: the work area, or the display for a daemon that ignores the
panel."""
return SCREEN if self.ignores_panel else self.area
def _base(self) -> list[Rect]:
a = self.tiled_area
return [Rect(i * a.w // 3, 0, a.w // 3, a.h) for i in range(3)]
def has(self, feature: str) -> bool:
return feature == "lock" or (feature == "pointer" and self.has_pointer)
@@ -279,7 +304,17 @@ class FakePlatform:
raise KeyError(title)
def displays(self) -> list[Rect]:
return [Rect(i * 1920, 0, 1920, 1080) for i in range(self.display_count)]
return [SCREEN, *self._others()][: self.display_count]
def _others(self) -> list[Rect]:
"""The displays after the first, side by side to its right."""
found = []
x = SCREEN.w
for n in range(1, max(self.display_count, 1)):
size = self.second if self.second is not None and n == 1 else SCREEN
found.append(Rect(x, 0, size.w, size.h))
x += size.w
return found
def add_display(self) -> None:
self.display_count += 1
@@ -312,19 +347,21 @@ class FakePlatform:
def _relayout(self) -> None:
"""The tiles of each workspace share the work area in equal columns."""
self.tiles = list(TILES)
base = self._base()
self.tiles = list(base)
n = len(self.containers)
if n:
area = self.tiled_area
w, c = self.workspace_padding, self.container_padding
width = (1920 - 2 * w) // n
width = (area.w - 2 * w) // n
self.tiles = [
Rect(w + i * width + c, w + c, width - 2 * c, 1080 - 2 * w - 2 * c)
Rect(w + i * width + c, w + c, width - 2 * c, area.h - 2 * w - 2 * c)
for i in range(n)
] + list(TILES[n:])
] + list(base[n:])
if self.flipped:
self.tiles = [Rect(1920 - t.x - t.w, t.y, t.w, t.h) for t in self.tiles[:n]] + list(
TILES[n:]
)
self.tiles = [
Rect(area.w - t.x - t.w, t.y, t.w, t.h) for t in self.tiles[:n]
] + list(base[n:])
def _container(self, title: str) -> int:
return self._find(title)[1]
@@ -339,7 +376,7 @@ class FakePlatform:
return s != self.current or self.spaces[s][i][0] != client.title or away
def work_area(self) -> Rect:
return Rect(0, 0, 1920, 1080)
return self.area
def minimize(self, client: Client) -> None:
self._find_remove(client.title)
@@ -364,7 +401,7 @@ class FakePlatform:
def os_window(self, client: Client) -> OsWindow | None:
if client.title == self.maximized:
return OsWindow(client.title, Rect(0, 0, 1920, 1080), focused=True)
return OsWindow(client.title, self.tiled_area, focused=True)
if client.title in self.minimized:
return OsWindow(client.title, Rect(0, 0, 0, 0), focused=False)
if client.title in self.floats:
@@ -376,15 +413,19 @@ class FakePlatform:
except KeyError:
return None
if self.monocle == client.title:
return OsWindow(client.title, Rect(0, 0, 1920, 1080), focused=True)
return OsWindow(client.title, self.tiled_area, focused=True)
focused = (
s == self.current and i == self.focuses[s] and self.spaces[s][i][0] == client.title
)
tile = self.tiles[i]
shift = 1920 * self.display_of.get(client.title, 0)
elsewhere = self.display_of.get(client.title, 0)
if client.title in self.moved:
return OsWindow(client.title, self.moved[client.title], focused=focused)
return OsWindow(client.title, Rect(tile.x + shift, tile.y, tile.w, tile.h), focused=focused)
if elsewhere:
d = self.displays()[elsewhere]
frame = Rect(d.x + tile.x, d.y + tile.y, min(tile.w, d.w), min(tile.h, d.h))
return OsWindow(client.title, frame, focused=focused)
return OsWindow(client.title, tile, focused=focused)
def komorebic_status(self, *args: str) -> tuple[int, str]:
"""The fake's answer as a real `komorebic` gives it: exit 0, or 2 for what it lacks."""
@@ -556,7 +597,7 @@ class FakePlatform:
floats = self.floats if current else []
monocle = None
if current and self.monocle is not None:
whole = Rect(0, 0, 1920, 1080)
whole = self.tiled_area
windows = {"elements": [window(self.monocle, whole)], "focused": 0}
monocle = {"id": "m", "locked": False, "windows": windows}
return {
@@ -577,9 +618,7 @@ class FakePlatform:
},
"monocle_container": monocle,
"maximized_window": (
window(self.maximized, Rect(0, 0, 1920, 1080))
if current and self.maximized
else None
window(self.maximized, self.tiled_area) if current and self.maximized else None
),
"floating_windows": {
"elements": [window(t, Rect(300, 300, 600, 400)) for t in floats],
@@ -594,7 +633,8 @@ class FakePlatform:
monitor = {
"id": 1,
"size": rect(Rect(0, 0, 1920, 1080)),
"size": rect(SCREEN),
"work_area_size": rect(self.area),
"workspaces": {
"elements": [
workspace(i, c, f, i == self.current)
@@ -606,7 +646,7 @@ class FakePlatform:
extra = [
{
"id": n + 1,
"size": rect(Rect(n * 1920, 0, 1920, 1080)),
"size": rect(self._others()[n - 1]),
"workspaces": {"elements": [workspace(0, [], 0, False)], "focused": 0},
}
for n in range(1, 1 if self.forgets_displays else self.display_count)
@@ -781,3 +781,49 @@ def test_focus_follows_mouse_is_skipped_without_a_pointer() -> None:
base = checks.passed
focus_follows_mouse.run(platform, checks, clients[0], clients[1])
assert checks.failed == 0 and checks.passed == base
def test_a_daemon_that_tiles_inside_the_work_area_passes_with_a_panel() -> None:
platform = FakePlatform(panel=40)
checks = Checks()
clients = opened(platform, checks)
for scenario in (monocle, maximizing, layouts, floating, flipping, closing):
if scenario is closing:
closing.run(platform, checks, clients, clients[0])
else:
scenario.run(platform, checks, clients)
assert platform.work_area().h == 1040
assert checks.failed == 0, checks.failures
assert checks.passed > 20
def test_a_daemon_that_tiles_under_the_panel_fails_tiling() -> None:
platform = FakePlatform(panel=40, ignores_panel=True)
checks = Checks()
opened(platform, checks)
assert any("inside the work area" in f for f in checks.failures)
def test_a_window_that_is_maximized_past_the_work_area_fails_maximizing() -> None:
platform = FakePlatform(panel=40, ignores_panel=True)
checks = Checks()
clients = [platform.spawn(t) for t in ("a", "b", "c")]
maximizing.run(platform, checks, clients)
assert any("without going past the work area" in f for f in checks.failures)
def test_a_window_in_monocle_past_the_work_area_fails_monocle() -> None:
platform = FakePlatform(panel=40, ignores_panel=True)
checks = Checks()
clients = [platform.spawn(t) for t in ("a", "b", "c")]
monocle.run(platform, checks, clients)
assert any("without going past the work area" in f for f in checks.failures)
def test_a_second_display_of_another_size_passes_hotplug() -> None:
platform = FakePlatform(second=Rect(0, 0, 1280, 800))
checks = Checks()
clients = opened(platform, checks)
hotplug.run(platform, checks, clients)
assert platform.displays()[1] == Rect(1920, 0, 1280, 800)
assert checks.failed == 0, checks.failures
@@ -0,0 +1,54 @@
"""KDE as a platform, against a machine that answers from a script."""
from itertools import count
import pytest
import komorebi_vm.kde as kde_module
from komorebi_vm import Kde, Rect
from komorebi_vm.kde_platform import KdePlatform
from .conftest import FakeMachine
@pytest.fixture(autouse=True)
def probes(monkeypatch: pytest.MonkeyPatch) -> None:
"""The first probe a test makes is `work-area-1`."""
monkeypatch.setattr(kde_module, "_PROBES", count(1))
def kde_with_area(machine: FakeMachine, area: str) -> KdePlatform:
machine.reply("loadScript", output="i 7\n")
machine.reply("journalctl", output=f"{area}KS:work-area-1 done\n")
return KdePlatform(Kde(machine, "main", scale=0.01), (1920, 1080))
def test_the_work_area_is_what_kwin_says_and_not_the_whole_output(machine: FakeMachine) -> None:
platform = kde_with_area(machine, "KS:work-area-1 area 0 0 1920 1040\n")
assert platform.work_area() == Rect(0, 0, 1920, 1040)
def test_the_work_area_is_asked_of_the_first_output_less_its_panels(machine: FakeMachine) -> None:
platform = kde_with_area(machine, "KS:work-area-1 area 0 0 1920 1040\n")
platform.work_area()
scripts = [c for c in machine.commands if "KWin.PlacementArea" in c]
assert scripts, "the script that asks KWin for its placement area was never written"
assert "currentDesktopForScreen" in scripts[0]
def test_the_work_area_is_the_whole_output_where_kwin_does_not_answer(
machine: FakeMachine,
) -> None:
machine.reply("loadScript", output="i 7\n")
platform = KdePlatform(Kde(machine, "main", scale=0.01), (1920, 1080))
assert platform.work_area() == Rect(0, 0, 1920, 1080)
def test_the_work_area_is_the_whole_output_where_kwin_says_nonsense(machine: FakeMachine) -> None:
platform = kde_with_area(machine, "KS:work-area-1 area 0 0 many 1040\n")
assert platform.work_area() == Rect(0, 0, 1920, 1080)