mirror of
https://github.com/LGUG2Z/komorebi.git
synced 2026-11-17 06:11:21 +01:00
133 lines
8.9 KiB
Markdown
133 lines
8.9 KiB
Markdown
# Shared scenarios and platform extras: what moved where
|
|
|
|
A suite runs shared scenarios (`komorebi_vm.core.scenarios`) and what only its platform can check
|
|
(`komorebi_vm.platforms.kde.extras`), with the checks labelled `[shared]` and `[kde]`. This is the
|
|
ledger of the checks a suite stopped making because a shared check makes them, so that none is
|
|
dropped without a replacement. A check that only KDE can make stays, as an extra.
|
|
|
|
## hotplug
|
|
|
|
The suite had its own sections, then ran the shared scenario "the same, through the neutral
|
|
platform". The sections the shared scenario repeats are gone; the rest are `kde_hotplug` steps.
|
|
|
|
| Was (section) | Now |
|
|
|---|---|
|
|
| 1, the daemon answers with both monitors; three windows on the left; the monitor's size; tiled | extra `setup` |
|
|
| 2, the scale of the left output changes and returns | extra `scale` |
|
|
| 3, `move-to-monitor 1`: containers, KWin's `OutputChange`, tiled on the right | extra `sent_by_the_daemon` |
|
|
| 4, the user moves a window to the right output | extra `sent_by_the_user` |
|
|
| 5, one monitor after the unplug | shared "after a display is unplugged the daemon has one monitor fewer" |
|
|
| 5, all three windows on the left monitor | shared "... the daemon still manages every window", and "every window is on the displays that are left" |
|
|
| 5, tiled inside the screen that is left, not on each other | shared "... tiled and clear of each other" |
|
|
| 5, the daemon alive, its focus KWin's | extra `after` |
|
|
| 6, two monitors again | shared "after a display is plugged in the daemon has a monitor for it again" |
|
|
| 6, still three windows | shared "... still manages every window" |
|
|
| 6, each window somewhere it can be seen | shared "... each where it can be seen" |
|
|
| 7, a window moved to the other output again is followed | extra `after` |
|
|
| 8, the daemon runs and answers | extra `after` |
|
|
|
|
Not kept: that the daemon's container count on the left monitor is 3 after the unplug. The shared
|
|
scenario checks the managed count and where the windows are, not the count of containers per
|
|
monitor. The windows are where the layout puts them, which is what that count stood for.
|
|
|
|
The suite goes from 25 checks plus the shared ones to 28, which is the shared 11 and 17 of KDE's.
|
|
|
|
## commands
|
|
|
|
The suite had its own layout loop (section 2) and then called the shared `layouts`, `sweep` and
|
|
`prints`. Nothing the shared scenarios check was removed except as listed; the rest moved to
|
|
`kde_commands`, which reads KWin and the daemon's log.
|
|
|
|
| Was (section) | Now |
|
|
|---|---|
|
|
| 1, the daemon answers with both outputs; five windows | extra `setup` |
|
|
| 2, every layout with five windows: inside the outputs, apart, healthy | shared `layouts`; the extra repeats it at five windows, see below |
|
|
| 2, every layout with three, two and one windows | extra `layouts_by_count` |
|
|
| 2, each window where the daemon last asked KWin for it | extra `layouts_by_count` (KDE only: reads the daemon's log) |
|
|
| 3, the layouts and the sweep of commands | shared `layouts` and `sweep` |
|
|
| 3, `replace-configuration` made the window manager from the file | extra `replace_configuration` |
|
|
| 3b, `minimize`, `unmanage`, `manage` | extra `handover` |
|
|
| 3c, a title rule decides when the window has its title | extra `title_rule` |
|
|
| 4, every command that only prints | shared `prints` |
|
|
| 4, `komorebic query ...`, `quick-save-resize`, `save-resize` | extra `queries` (candidates for the shared list) |
|
|
| 5, every window is where the daemon last asked; a clean stop | extra `at_the_end` |
|
|
|
|
The extra's layout loop still goes through five windows, for the daemon's log check at that count;
|
|
it states its overlap verdict for five windows too, so that one is made twice. Dropping it from the
|
|
extra would lose the five-window `where asked` check, which is KDE's.
|
|
|
|
## drag-resize
|
|
|
|
The suite's own cases are all KDE's: the pointer put to the pixel, and eight drags of edges and
|
|
corners checked against frames, tiles and neighbors. None of them is removed; they moved to
|
|
`kde_drag_resize` as `pointer_is_exact` and `edge_cases`, and the suite calls the shared `resize`
|
|
and `focus_follows_mouse` after them, as before. The shared `resize` makes one drag of one edge,
|
|
which the extra's `win1:right:...` cases also make: that is a repeat by design, because the extra
|
|
reads the daemon's tiles and the frames together, and the shared one reads only the system.
|
|
|
|
One run of the suite failed `win2:left:-240,0` ("frame R moved -96 but was not dragged": the
|
|
terminal's frame four cells short of an unchanged tile) and the next passed; not seen again.
|
|
|
|
## core-e2e
|
|
|
|
The suite had sections 1 to 11 of its own, written against KWin and the daemon's log, and then ran
|
|
the shared scenarios in section 12 through the neutral platform. Sections 2 to 8 made, with KDE's
|
|
tools, the checks the shared `tiling`, `focus`, `moving`, `monocle`, `minimizing` and `closing`
|
|
make. They are gone; what only KDE can read stayed, as `kde_core` steps after the shared one.
|
|
|
|
| Was (section) | Now |
|
|
|---|---|
|
|
| 1, the script is loaded into KWin, which runs it; the daemon answers | extra `start` |
|
|
| 2, every window is where the daemon asked for it | extra `windows_where_asked`, after each shared step that moves windows |
|
|
| 2, inside the screen; windows apart; none takes the full width; the daemon manages the three | shared `tiling` ("where the layout says", "do not overlap", "share the work area") |
|
|
| 2, KWin and the daemon agree on the focus, by the daemon's log | extra `focus_agrees_with_the_log` |
|
|
| 2, the daemon's state focuses the window KWin does | shared `tiling` and `focus` |
|
|
| 3, 4, the focus by hand, `focus right/left`, `cycle-focus` | shared `focus` |
|
|
| 4, moving the focus moved no window | extra `windows_where_asked` after `focus` |
|
|
| 5, `move right`, `cycle-move previous`, the focus kept | shared `moving`; extra `windows_where_asked` after it |
|
|
| 6, monocle fills the work area, the state says so, back on the tile | shared `monocle` |
|
|
| 6, monocle focus behaviour `cycle` | extra `monocle_focus_behaviour` (a candidate for the shared scenario) |
|
|
| 7, minimize and restore | shared `minimizing`; extra `windows_where_asked` after it |
|
|
| 8, close, the others share the screen, the daemon manages the rest | shared `closing` |
|
|
| 8, KWin carried out every command | extra `bridge_did_everything` |
|
|
| 9, a clean stop undoes what a monocle did | extra `parking` (opens two windows of its own) |
|
|
| 10, a crash with a monocle on leaves nothing stuck | extra `parking` |
|
|
| 11, KWin restarts under the daemon | extra `kwin_restart` (the `kwin-restart` suite also covers it) |
|
|
| 13, `komorebic stop`: the socket, the script, the window stays | extra `stopped` |
|
|
|
|
Changed on purpose: the lifecycle sections run after the shared scenarios, on windows of their
|
|
own, so that the stop and the crash no longer depend on windows a shared scenario left behind. The
|
|
daemon's frame log is read after four shared steps, not after every one.
|
|
|
|
Also learned while moving it:
|
|
|
|
- `KWin carried out every command` was one check after section 8, over a log of three windows' worth
|
|
of commands. After every shared step, over the whole corpus, the bridge logs `could not do` for a
|
|
`geo` that targets a window a scenario closed a moment later. That is a race, not a failure, so
|
|
the check now counts only a command for a window that is still open, and runs after each shared
|
|
step so that a real failure names its scenario. A failure there with the window alive is a
|
|
finding.
|
|
- After a daemon restart the daemon's focused window can differ from the one KWin has active, and
|
|
activating a window KWin already has active sends no event. `parking` activates another window
|
|
first. Whether the daemon should pick up KWin's active window at start is not decided here.
|
|
|
|
## workspace-rules
|
|
|
|
The suite made, with KDE's tools, the checks that the shared `rules` and `startup_rules` make. It
|
|
keeps the part that is KWin's: a workspace is a virtual desktop.
|
|
|
|
| Was (section) | Now |
|
|
|---|---|
|
|
| 1, an initial rule sends a window to workspace 1; it is put away | shared `rules` |
|
|
| 1, it is on the parking desktop while desktop 1 shows; on desktop 2 once shown, not parked; tiled where asked | extra `desktops` |
|
|
| 1, the other window is where it opened (desktop 1) | extra `desktops` |
|
|
| 2, the user takes the window back; an initial rule does not send it again | shared `rules` |
|
|
| 2, a rule by the name of a workspace (`chat`) sends a window; desktop 3 when shown | extra `named_rule` (the shared scenarios use indexes) |
|
|
| 2, a new window is an event that applies the rules again | extra `named_rule` (a candidate for the shared `rules`) |
|
|
| 2, `enforce-workspace-rules` sends the initial rule's window again | shared `rules` |
|
|
| 3, the rules are cleared; a window that opens stays on the workspace in front | shared `rules`; extra `cleared` (the daemon's global state has no rule; desktop of the new window) |
|
|
| 4, a `komorebi.json` rule, with a window open before the daemon | shared `startup_rules` |
|
|
|
|
The extras open windows of their own and close them, so that the shared scenarios start from a
|
|
daemon with none.
|