From 401ce9112a2249f71c455a24eae2d9ff92bda7da Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:13:38 -0700 Subject: [PATCH 01/14] refactor(core): Workspace::hide_spot and hide_spot_on_display as methods Convenience for the callers that have a workspace and no platform type to name (the window manager functions, which are the same text on KDE and macOS): the same as P::hide_spot(self) and P::hide_spot_on_display(self). Nothing calls them yet in the KDE and Windows daemons; no behaviour change. Verified: native cargo test -p komorebi-core passes; fast-check all trees PASS. --- crates/komorebi-core/src/workspace.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/crates/komorebi-core/src/workspace.rs b/crates/komorebi-core/src/workspace.rs index 9462957d..31e45ebb 100644 --- a/crates/komorebi-core/src/workspace.rs +++ b/crates/komorebi-core/src/workspace.rs @@ -473,6 +473,18 @@ pub fn resolve_threshold_match( } impl Workspace

{ + /// Where the windows of this workspace are hidden ([`WorkspacePlatform::hide_spot`]), for the + /// calls that hide or stack a window + pub fn hide_spot(&self) -> PlatformHideSpot

{ + P::hide_spot(self) + } + + /// Where the containers of this workspace are hidden when the whole workspace is + /// ([`WorkspacePlatform::hide_spot_on_display`]) + pub fn hide_spot_on_display(&self) -> PlatformHideSpot

{ + P::hide_spot_on_display(self) + } + /// The containers of the workspace. pub const fn containers(&self) -> &std::collections::VecDeque> { self.containers.elements() From 4c15358f7b238d79184aa17e62db53bb62985a2d Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:14:05 -0700 Subject: [PATCH 02/14] refactor(core,kde,windows,mac): FocusWorkspaceNumber and FocusWorkspaceNumbers are komorebi-core commands komorebi_core::command gets focus_workspace_number (show a workspace unless it is in front) and focus_workspace_numbers (show it on every other monitor, then on the focused one), both with the pointer preamble when the host's POINTER_PICKS_THE_MONITOR_FOR_ALL says so, over a new CommandHost method show_workspace_on (focus the workspace of a monitor and load it, which the daemons already did inline). The three daemons' arms call them (Windows keeps its focus_workspace_numbers method as a wrapper) and implement show_workspace_on. The const is unchanged: true for Windows, false for KDE and macOS, so nothing changes yet; the next revisions flip it. Tests: the Windows-switch test becomes a test of all five commands with the switch off and on, and focus_workspace_number(s) are tested on the stub host (commands.py: focus-workspace, focus-workspaces). Verified: cargo test -p komorebi-core --features schemars --test commands: 18 passed; KDE cargo test -p komorebi-linux (lite env): 666 passed, 0 failed; fake-CC cargo clippy -D warnings on the macOS packages: PASS; Windows cargo clippy -p komorebi-windows --locked --all-targets -D warnings: PASS. Not run: Windows tests, VM and Mac. --- crates/komorebi-core/src/command.rs | 42 ++++ crates/komorebi-core/tests/commands.rs | 204 ++++++++++++------ .../komorebi/src/process_command.rs | 25 ++- .../komorebi/src/process_command.rs | 41 ++-- komorebi/src/process_command.rs | 50 ++--- 5 files changed, 219 insertions(+), 143 deletions(-) diff --git a/crates/komorebi-core/src/command.rs b/crates/komorebi-core/src/command.rs index 712ee73e..e328b6ef 100644 --- a/crates/komorebi-core/src/command.rs +++ b/crates/komorebi-core/src/command.rs @@ -49,6 +49,10 @@ pub trait CommandHost { /// Shows workspace `idx` on the focused monitor and focuses it. fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()>; + /// Shows workspace `workspace_idx` on the monitor at `monitor_idx` (creating it if it is not + /// there) without focusing that monitor. + fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()>; + /// Moves the focused container to workspace `idx` of the focused monitor. fn move_container_to_workspace( &mut self, @@ -367,3 +371,41 @@ pub fn set_container_locked( Ok(()) } + +/// Shows workspace `workspace_idx` on the focused monitor, unless it is the one in front; the +/// monitor the pointer is on is focused first when its workspace is empty +pub fn focus_workspace_number( + host: &mut H, + workspace_idx: usize, +) -> eyre::Result<()> { + if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { + focus_the_monitor_under_the_pointer(host)?; + } + + if host.focused_workspace_idx().unwrap_or_default() != workspace_idx { + host.focus_workspace(workspace_idx)?; + } + Ok(()) +} + +/// Shows workspace `workspace_idx` on every monitor, the focused one last; the monitor the pointer +/// is on is focused first when its workspace is empty +pub fn focus_workspace_numbers( + host: &mut H, + workspace_idx: usize, +) -> eyre::Result<()> { + if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { + focus_the_monitor_under_the_pointer(host)?; + } + + let focused_monitor_idx = host.focused_monitor_idx(); + + for idx in 0..host.monitors().len() { + if idx != focused_monitor_idx { + host.show_workspace_on(idx, workspace_idx)?; + } + } + + host.focus_workspace(workspace_idx)?; + Ok(()) +} diff --git a/crates/komorebi-core/tests/commands.rs b/crates/komorebi-core/tests/commands.rs index f82f86ee..faa8507e 100644 --- a/crates/komorebi-core/tests/commands.rs +++ b/crates/komorebi-core/tests/commands.rs @@ -98,6 +98,12 @@ impl CommandHost for Host { self.monitors[self.focused].focus_workspace(idx) } + fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { + self.calls + .push(format!("show_workspace_on {monitor_idx} {workspace_idx}")); + self.monitors[monitor_idx].focus_workspace(workspace_idx) + } + fn move_container_to_workspace( &mut self, idx: usize, @@ -227,69 +233,6 @@ fn move_to_last_workspace_moves_the_container_and_remembers_where_it_came_from() ); } -#[test] -fn only_windows_lets_the_pointer_pick_the_monitor_for_the_empty_and_close_commands() { - // the platform switch of CommandHost::POINTER_PICKS_THE_MONITOR_FOR_ALL (default false: KDE and - // macOS); a host that says true gets the preamble for close and cycle-empty too - struct WindowsLike(Host); - - impl CommandHost for WindowsLike { - type P = StubPlatform; - const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = true; - - fn monitors(&self) -> &VecDeque> { - self.0.monitors() - } - fn focused_monitor(&self) -> Option<&Monitor> { - self.0.focused_monitor() - } - fn focused_monitor_mut(&mut self) -> Option<&mut Monitor> { - self.0.focused_monitor_mut() - } - fn focused_monitor_idx(&self) -> usize { - self.0.focused_monitor_idx() - } - fn monitor_idx_from_current_pos(&mut self) -> Option { - self.0.monitor_idx_from_current_pos() - } - fn focus_monitor(&mut self, idx: usize) -> eyre::Result<()> { - self.0.focus_monitor(idx) - } - fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()> { - self.0.focus_workspace(idx) - } - fn move_container_to_workspace( - &mut self, - idx: usize, - follow: bool, - direction: Option, - ) -> eyre::Result<()> { - self.0.move_container_to_workspace(idx, follow, direction) - } - } - - let mut other = Host::new(2); - other.monitors.push_back(monitor(2)); - other.pointer_on = Some(1); - komorebi_core::close_workspace(&mut other).unwrap(); - assert!( - !other - .calls - .iter() - .any(|call| call.starts_with("focus_monitor")), - "KDE and macOS do not look at the pointer here" - ); - - let mut host = WindowsLike({ - let mut host = Host::new(2); - host.monitors.push_back(monitor(2)); - host.pointer_on = Some(1); - host - }); - komorebi_core::close_workspace(&mut host).unwrap(); - assert_eq!(host.0.calls[0], "focus_monitor 1"); -} - impl komorebi_core::MonitorCommandHost for Host { fn mouse_follows_focus(&self) -> bool { true @@ -441,3 +384,138 @@ fn locking_a_container_that_is_not_there_is_ignored_but_a_missing_monitor_or_wor assert!(komorebi_core::set_container_locked(&mut host, 3, 0, 0, true).is_err()); assert!(komorebi_core::set_container_locked(&mut host, 0, 9, 0, true).is_err()); } + +/// A host that says whether the pointer picks the monitor first, and does what `Host` does +struct Pointer(Host); + +impl CommandHost for Pointer { + type P = StubPlatform; + const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = ALL; + + fn monitors(&self) -> &VecDeque> { + self.0.monitors() + } + fn focused_monitor(&self) -> Option<&Monitor> { + self.0.focused_monitor() + } + fn focused_monitor_mut(&mut self) -> Option<&mut Monitor> { + self.0.focused_monitor_mut() + } + fn focused_monitor_idx(&self) -> usize { + self.0.focused_monitor_idx() + } + fn monitor_idx_from_current_pos(&mut self) -> Option { + self.0.monitor_idx_from_current_pos() + } + fn focus_monitor(&mut self, idx: usize) -> eyre::Result<()> { + self.0.focus_monitor(idx) + } + fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()> { + self.0.focus_workspace(idx) + } + fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { + self.0.show_workspace_on(monitor_idx, workspace_idx) + } + fn move_container_to_workspace( + &mut self, + idx: usize, + follow: bool, + direction: Option, + ) -> eyre::Result<()> { + self.0.move_container_to_workspace(idx, follow, direction) + } +} + +impl komorebi_core::MonitorCommandHost for Pointer { + fn mouse_follows_focus(&self) -> bool { + self.0.mouse_follows_focus() + } + fn update_focused_workspace(&mut self, a: bool, b: bool) -> eyre::Result<()> { + self.0.update_focused_workspace(a, b) + } + fn direction_from_monitor_idx(&self, idx: usize) -> Option { + self.0.direction_from_monitor_idx(idx) + } + fn move_container_to_monitor( + &mut self, + idx: usize, + workspace_idx: Option, + follow: bool, + direction: Option, + ) -> eyre::Result<()> { + self.0 + .move_container_to_monitor(idx, workspace_idx, follow, direction) + } + fn focused_workspace_idx(&self) -> eyre::Result { + self.0.focused_workspace_idx() + } +} + +fn pointer_on_the_second_monitor() -> Host { + let mut host = two_monitors(); + host.pointer_on = Some(1); + host +} + +fn focused_monitor_calls(host: &Host) -> usize { + host.calls + .iter() + .filter(|call| call.starts_with("focus_monitor")) + .count() +} + +#[test] +fn the_pointer_switch_gives_the_empty_close_last_and_number_commands_the_preamble() { + // commands.py: close-workspace, cycle-empty-workspace, focus-last-workspace, focus-workspace, + // focus-workspaces; with the switch off nothing looks at the pointer, with it on the monitor + // under the pointer is focused first when its workspace is empty + let mut off = Pointer::(pointer_on_the_second_monitor()); + komorebi_core::close_workspace(&mut off).unwrap(); + komorebi_core::focus_last_workspace(&mut off).unwrap(); + komorebi_core::cycle_focus_empty_workspace(&mut off, CycleDirection::Next).unwrap(); + komorebi_core::focus_workspace_number(&mut off, 1).unwrap(); + komorebi_core::focus_workspace_numbers(&mut off, 1).unwrap(); + assert_eq!(focused_monitor_calls(&off.0), 0); + + for command in 0..5 { + let mut on = Pointer::(pointer_on_the_second_monitor()); + match command { + 0 => komorebi_core::close_workspace(&mut on).unwrap(), + 1 => komorebi_core::focus_last_workspace(&mut on).unwrap(), + 2 => komorebi_core::cycle_focus_empty_workspace(&mut on, CycleDirection::Next).unwrap(), + 3 => komorebi_core::focus_workspace_number(&mut on, 1).unwrap(), + _ => komorebi_core::focus_workspace_numbers(&mut on, 1).unwrap(), + } + assert_eq!(on.0.calls[0], "focus_monitor 1", "command {command}"); + } +} + +#[test] +fn focus_workspace_number_only_switches_when_it_is_not_in_front() { + // commands.py: "focus-workspace 1", "focus-workspace 0" + let mut host = Host::new(3); + + komorebi_core::focus_workspace_number(&mut host, 0).unwrap(); + assert!(host.calls.is_empty()); + + komorebi_core::focus_workspace_number(&mut host, 2).unwrap(); + assert_eq!(host.calls, ["focus_workspace 2"]); +} + +#[test] +fn focus_workspaces_shows_the_workspace_on_every_other_monitor_then_on_the_focused_one() { + // commands.py: "focus-workspaces 1", "focus-workspaces 0" + let mut host = two_monitors(); + host.monitors.push_back(monitor(3)); + + komorebi_core::focus_workspace_numbers(&mut host, 2).unwrap(); + + assert_eq!( + host.calls, + [ + "show_workspace_on 1 2", + "show_workspace_on 2 2", + "focus_workspace 2" + ] + ); +} diff --git a/komorebi-for-kde/komorebi/src/process_command.rs b/komorebi-for-kde/komorebi/src/process_command.rs index 7208edb5..60b5b3f0 100644 --- a/komorebi-for-kde/komorebi/src/process_command.rs +++ b/komorebi-for-kde/komorebi/src/process_command.rs @@ -1125,21 +1125,10 @@ impl WindowManager { } SocketMessage::FocusLastWorkspace => self.focus_last_workspace()?, SocketMessage::FocusWorkspaceNumber(workspace_idx) => { - if self.focused_workspace_idx().unwrap_or_default() != workspace_idx { - self.focus_workspace(workspace_idx)?; - } + komorebi_core::focus_workspace_number(self, workspace_idx)? } SocketMessage::FocusWorkspaceNumbers(workspace_idx) => { - let focused_monitor_idx = self.focused_monitor_idx(); - - for (i, monitor) in self.monitors_mut().iter_mut().enumerate() { - if i != focused_monitor_idx { - monitor.focus_workspace(workspace_idx)?; - monitor.load_focused_workspace(false)?; - } - } - - self.focus_workspace(workspace_idx)?; + komorebi_core::focus_workspace_numbers(self, workspace_idx)? } SocketMessage::FocusMonitorWorkspaceNumber(monitor_idx, workspace_idx) => { komorebi_core::focus_monitor_workspace_number(self, monitor_idx, workspace_idx)? @@ -2052,6 +2041,16 @@ impl komorebi_core::CommandHost for WindowManager { WindowManager::focus_workspace(self, idx) } + fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { + let monitor = self + .monitors_mut() + .get_mut(monitor_idx) + .ok_or_eyre("there is no monitor at this index")?; + monitor.focus_workspace(workspace_idx)?; + monitor.load_focused_workspace(false)?; + Ok(()) + } + fn move_container_to_workspace( &mut self, idx: usize, diff --git a/komorebi-for-mac/komorebi/src/process_command.rs b/komorebi-for-mac/komorebi/src/process_command.rs index da3e5181..7dda17a0 100644 --- a/komorebi-for-mac/komorebi/src/process_command.rs +++ b/komorebi-for-mac/komorebi/src/process_command.rs @@ -592,37 +592,10 @@ impl WindowManager { } SocketMessage::FocusLastWorkspace => self.focus_last_workspace()?, SocketMessage::FocusWorkspaceNumber(workspace_idx) => { - if self.focused_workspace_idx().unwrap_or_default() != workspace_idx { - self.focus_workspace(workspace_idx)?; - } + komorebi_core::focus_workspace_number(self, workspace_idx)? } SocketMessage::FocusWorkspaceNumbers(workspace_idx) => { - // TODO: figure out if we need to do this on macOS - // // This is to ensure that even on an empty workspace on a secondary monitor, the - // // secondary monitor where the cursor is focused will be used as the target for - // // the workspace switch op - // if let Some(monitor_idx) = self.monitor_idx_from_current_pos() { - // if monitor_idx != self.focused_monitor_idx() { - // if let Some(monitor) = self.monitors().get(monitor_idx) { - // if let Some(workspace) = monitor.focused_workspace() { - // if workspace.is_empty() { - // self.focus_monitor(monitor_idx)?; - // } - // } - // } - // } - // } - - let focused_monitor_idx = self.focused_monitor_idx(); - - for (i, monitor) in self.monitors_mut().iter_mut().enumerate() { - if i != focused_monitor_idx { - monitor.focus_workspace(workspace_idx)?; - monitor.load_focused_workspace(false)?; - } - } - - self.focus_workspace(workspace_idx)?; + komorebi_core::focus_workspace_numbers(self, workspace_idx)? } SocketMessage::FocusMonitorWorkspaceNumber(monitor_idx, workspace_idx) => { komorebi_core::focus_monitor_workspace_number(self, monitor_idx, workspace_idx)? @@ -1759,6 +1732,16 @@ impl komorebi_core::CommandHost for WindowManager { WindowManager::focus_workspace(self, idx) } + fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { + let monitor = self + .monitors_mut() + .get_mut(monitor_idx) + .ok_or_eyre("there is no monitor at this index")?; + monitor.focus_workspace(workspace_idx)?; + monitor.load_focused_workspace(false)?; + Ok(()) + } + fn move_container_to_workspace( &mut self, idx: usize, diff --git a/komorebi/src/process_command.rs b/komorebi/src/process_command.rs index 6cc8c186..6eefbe18 100644 --- a/komorebi/src/process_command.rs +++ b/komorebi/src/process_command.rs @@ -927,21 +927,7 @@ impl WindowManager { self.focus_last_workspace()?; } SocketMessage::FocusWorkspaceNumber(workspace_idx) => { - // This is to ensure that even on an empty workspace on a secondary monitor, the - // secondary monitor where the cursor is focused will be used as the target for - // the workspace switch op - if let Some(monitor_idx) = self.monitor_idx_from_current_pos() - && monitor_idx != self.focused_monitor_idx() - && let Some(monitor) = self.monitors().get(monitor_idx) - && let Some(workspace) = monitor.focused_workspace() - && workspace.is_empty() - { - self.focus_monitor(monitor_idx)?; - } - - if self.focused_workspace_idx().unwrap_or_default() != workspace_idx { - self.focus_workspace(workspace_idx)?; - } + komorebi_core::focus_workspace_number(self, workspace_idx)? } SocketMessage::FocusWorkspaceNumbers(workspace_idx) => { self.focus_workspace_numbers(workspace_idx)?; @@ -2145,29 +2131,7 @@ impl WindowManager { } pub fn focus_workspace_numbers(&mut self, workspace_idx: usize) -> eyre::Result<()> { - // This is to ensure that even on an empty workspace on a secondary monitor, the - // secondary monitor where the cursor is focused will be used as the target for - // the workspace switch op - if let Some(monitor_idx) = self.monitor_idx_from_current_pos() - && monitor_idx != self.focused_monitor_idx() - && let Some(monitor) = self.monitors().get(monitor_idx) - && let Some(workspace) = monitor.focused_workspace() - && workspace.is_empty() - { - self.focus_monitor(monitor_idx)?; - } - - let focused_monitor_idx = self.focused_monitor_idx(); - - for (i, monitor) in self.monitors_mut().iter_mut().enumerate() { - if i != focused_monitor_idx { - monitor.focus_workspace(workspace_idx)?; - monitor.load_focused_workspace(false)?; - } - } - - self.focus_workspace(workspace_idx)?; - Ok(()) + komorebi_core::focus_workspace_numbers(self, workspace_idx) } pub fn focus_last_workspace(&mut self) -> eyre::Result<()> { @@ -2324,6 +2288,16 @@ impl komorebi_core::CommandHost for WindowManager { WindowManager::focus_workspace(self, idx) } + fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { + let monitor = self + .monitors_mut() + .get_mut(monitor_idx) + .ok_or_eyre("there is no monitor at this index")?; + monitor.focus_workspace(workspace_idx)?; + monitor.load_focused_workspace(false)?; + Ok(()) + } + fn move_container_to_workspace( &mut self, idx: usize, From a4784950495c4bd8b274be8f382d93c04d8bd4e9 Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:13:38 -0700 Subject: [PATCH 03/14] refactor(mac): the daemon uses the shared Container API with the hide spot Deep dedup D-coord-13 (1), the container API. BEHAVIOUR (type-checked and clippy-clean with the fake CC; the macOS tests are the oracle). ContainerExt is deleted. Its four methods were the shared Container's with the monitor's corner as an argument; every call (about 28 sites in window_manager.rs, process_event.rs, scrolling.rs, workspace.rs, monitor.rs) is now the shared one: add_window(window, spot), load_focused_window(spot), hide(omit, spot), restore(), with spot = workspace.hide_spot() (MacosPlatform::hide_spot: the workspace's corner, no display, which is what the old calls passed; hide_on's screen argument was None at every remaining caller; the whole-workspace hide with the display is Workspace::hide, already shared). The nine window manager functions that differed from KDE's only in these calls (add_window_to_container, cycle_container_window_in_direction, cycle_container_window_index_in_direction, focus_container_window, stack_all, monocle_on, monocle_off, cycle_monocle, transfer_window) now differ from KDE's text only in the spot and in the error policy (let _ against ?), which the next revisions remove. Two things change at run time, both small: monocle_on and cycle_monocle took the corner from the monitor (monitor.extra.window_hiding_position) and now take it from the workspace's state, which the monitor writes into every workspace when it updates their globals, so they differ only if a workspace's globals are stale (a config reload without a layout update in between); and Container::restore skips the Accessibility call under cfg!(test), as hide and load_focused_window already did. Verified: fast-check macOS PASS; fake-CC cargo clippy -p komorebi-macos --all-targets -D warnings clean. Not verified: any macOS test or run. Verified on the Mini: not yet. Hand check row added to docs/dev/macos-handcheck.md. --- docs/dev/macos-handcheck.md | 1 + komorebi-for-mac/komorebi/src/container.rs | 137 ++---------------- komorebi-for-mac/komorebi/src/monitor.rs | 5 +- .../komorebi/src/process_event.rs | 5 +- komorebi-for-mac/komorebi/src/scrolling.rs | 17 +-- .../komorebi/src/window_manager.rs | 45 +++--- komorebi-for-mac/komorebi/src/workspace.rs | 13 +- 7 files changed, 46 insertions(+), 177 deletions(-) diff --git a/docs/dev/macos-handcheck.md b/docs/dev/macos-handcheck.md index 6ebaade9..b86aae80 100644 --- a/docs/dev/macos-handcheck.md +++ b/docs/dev/macos-handcheck.md @@ -97,6 +97,7 @@ timeout. Until then H5 documents the hang. | 11(iii) Workspace: `refactor(mac): the daemon's Workspace is komorebi_core::Workspace` (see `jj log -r wip-u-kfm2`) | About 50 workspace functions (container and focus operations, placement, resize constraints, window lookups, floating helpers, the stack and monocle operations that hide windows) are now the shared ones; `hide`, `new_container_for_window` and the stack functions pass the monitor's corner through `MacosPlatform::hide_spot` (kept in `MacosWorkspaceState`, set by the monitor with the globals), and `hide` passes the display bounds for the containers through `hide_spot_on_display`. macOS's own `update`, `apply_wallpaper`, `restore`, `remove_window`, `load_static_config`, `prune_duplicate_windows`, `visible_window_details`, `reap_invalid_windows_for_application`, `restore_windows`, `calculate_layouts` and `set_scrolling_columns` are `WorkspaceExt`; the scrolling methods are `WorkspaceScrolling`. | `cargo test` first (the workspace, scrolling and window_manager tests). Then: stack and unstack, switch workspaces both ways (each stack shows its front window, the hidden ones are in their monitor's corner), toggle monocle and back, float and unfloat a window, cycle the monocle container, move a window to another workspace, move a container across monitors; with a different `window_hiding_position` on each monitor check each monitor's windows park in their own corner and that a floating window that overhangs the edge of a display is still parked on its own display. `komorebic state` keys of a workspace are unchanged (pinned by `state_pin`). Scrolling layout: focus, move, consume and expel, pan, resize a column. | | 11(iii) Monitor: `refactor(mac): the daemon's Monitor is komorebi_core::Monitor` (see `jj log -r wip-u-kfm2`) | The monitor is the shared generic type; the corner (`window_hiding_position`) is the platform's flattened `extra` (written last, as before), the constructors, `update_*_globals`, `load_focused_workspace`, `move_container_to_workspace(1)`, `add_container_with_direction`, `hide_unfocused_workspaces` and `restore_focused_workspace` are `MonitorExt`; `focus_workspace`, `add_container`, `remove_workspace*`, `ensure_workspace_count` and the name and layout lookups are the shared ones. The monitor gives its workspaces the corner through `workspace.state` when it updates their globals. | `cargo test` (monitor tests, `state_pin`). By hand: `komorebic state | jq '.monitors.elements[0] | keys_unsorted'` is the same list as before with `window_hiding_position` last; switch workspaces on each monitor (hide and restore of the whole workspace), focus-workspace by index and by name, move a container to another workspace and to another monitor, unplug and replug a display (the monitor and its workspaces are rebuilt through `Monitor::new` and `update_all_workspace_globals`), a config with `window_hiding_position` per monitor. | | `wip-u-kfm3` registry fixes (see `jj log -r wip-u-kfm3`) | The registry keeps inert application copies (no blocking Accessibility call when an entry is dropped), a window is registered when its observer is attached, a clone being dropped no longer deregisters its window, `forget_pid` runs ahead of the pause and other-space returns, and the application reaper forgets what it reaps. Nothing reads the registry except the unused `MacosBackend`. | H3, H4, H6, H7 above, and the usual walk-through: no change in what the daemon does is expected. | +| deep dedup 1: `refactor(mac): the daemon uses the shared Container API with the hide spot` (see `jj log -r wip-u-mac-deep`) | `ContainerExt` (`add_window_at`, `load_focused_window_at`, `hide_on`, `restore_focused_window`) is gone: every call is the shared `Container::{add_window, load_focused_window, hide, restore}` with `workspace.hide_spot()`. `monocle_on` and `cycle_monocle` took the corner from the monitor (`monitor.extra`) and now take it from the workspace (`workspace.state`), which the monitor writes with the globals; `restore()` now skips the Accessibility call under `cfg!(test)`. | `cargo test`; then H1 (hide spot) and: toggle monocle on a workspace with two containers on a monitor with `window_hiding_position: BottomRight` (every other container parks in that corner), cycle the monocle container, stack with `komorebic stack`/`stack-all`, `cycle-stack`, `add-window-to-container`, switch workspaces. Change the monitor's `window_hiding_position` in the config, reload, and toggle monocle at once: the corner must be the new one. | Revisions in section B change no behaviour on purpose (rename, move, route); they still need the sections C walk-through, because a mechanical mistake would show there. diff --git a/komorebi-for-mac/komorebi/src/container.rs b/komorebi-for-mac/komorebi/src/container.rs index 617fc716..a4b07fbf 100644 --- a/komorebi-for-mac/komorebi/src/container.rs +++ b/komorebi-for-mac/komorebi/src/container.rs @@ -1,14 +1,11 @@ //! [`Container`], the windows that share one tile of a workspace's layout. //! //! The container is [`komorebi_core::Container`], shared with the other komorebi daemons, over the -//! macOS [`Window`]. What it cannot share is how a window is hidden: macOS needs the monitor's -//! `WindowHidingPosition` (and for a whole container the bounds of its display) with every hide, -//! and a hide can fail. Those four operations are [`ContainerExt`], under names the shared -//! container does not use (`add_window_at`, `load_focused_window_at`, `hide_on`, -//! `restore_focused_window`), because an inherent method of the shared type would hide an -//! extension method of the same name. +//! macOS [`Window`]. How a window is hidden is [`MacosHideSpot`]: the monitor's `WindowHidingPosition` +//! and, for the containers of a workspace that is being hidden, the bounds of its display. The +//! workspace gives it with `Workspace::hide_spot` and every container call takes it, as on the other +//! platforms (where it is `()`). -use crate::accessibility::error::AccessibilityError; use crate::core::WindowHidingPosition; use crate::window::Window; use color_eyre::eyre; @@ -94,120 +91,6 @@ impl komorebi_core::WorkspaceWindow for Window { } } -/// What a macOS container does that the shared one cannot: hide and restore its windows with the -/// monitor's hiding position, and say when that failed. -pub trait ContainerExt { - /// Puts a window at the back of the container and gives it the front, hiding every other - /// window of the container at `hiding_position` - fn add_window_at( - &mut self, - window: &Window, - hiding_position: WindowHidingPosition, - ) -> eyre::Result<()>; - - /// Hides the unfocused windows of the container and restores the focused one. This function - /// is used to make sure we update the window that should be shown on a stack. If the container - /// isn't a stack this function won't change anything. - fn load_focused_window_at( - &mut self, - hiding_position: WindowHidingPosition, - ) -> Result<(), AccessibilityError>; - - /// Hide the windows of the container, other than `omit`, on `screen`, the bounds of the display - /// of the monitor that has the container, or on whichever display they are found on if that is - /// not given - fn hide_on( - &mut self, - hiding_position: WindowHidingPosition, - omit: Option, - screen: Option, - ) -> eyre::Result<()>; - - /// Restores the window in front, which is the one that is shown when the container is a stack - fn restore_focused_window(&mut self) -> eyre::Result<()>; -} - -impl ContainerExt for Container { - fn add_window_at( - &mut self, - window: &Window, - hiding_position: WindowHidingPosition, - ) -> eyre::Result<()> { - self.windows_mut().push_back(window.clone()); - self.focus_window(self.windows().len().saturating_sub(1)); - - if !cfg!(test) { - let focused_window_idx = self.focused_window_idx(); - - for (i, window) in self.windows_mut().iter_mut().enumerate() { - if i != focused_window_idx { - window.hide(hiding_position)?; - } - } - } else { - tracing::info!("not hiding windows to {hiding_position} during test execution") - } - - Ok(()) - } - - fn load_focused_window_at( - &mut self, - hiding_position: WindowHidingPosition, - ) -> Result<(), AccessibilityError> { - let focused_idx = self.focused_window_idx(); - - if !cfg!(test) { - for (i, window) in self.windows_mut().iter_mut().enumerate() { - if i == focused_idx { - window.restore()?; - } else { - window.hide(hiding_position)?; - } - } - } else { - tracing::info!( - "not hiding/restoring windows to/from {hiding_position} during test execution" - ) - } - - Ok(()) - } - - fn hide_on( - &mut self, - hiding_position: WindowHidingPosition, - omit: Option, - screen: Option, - ) -> eyre::Result<()> { - for window in self.windows_mut().iter_mut().rev() { - let mut should_hide = omit.is_none(); - - if !should_hide - && let Some(omit) = omit - && omit != window.id - { - should_hide = true - } - - // a window that has gone away must not leave the ones after it in view - if should_hide && let Err(error) = window.hide_on(hiding_position, screen) { - tracing::warn!("failed to hide window {}: {error}", window.id); - } - } - - Ok(()) - } - - fn restore_focused_window(&mut self) -> eyre::Result<()> { - if let Some(window) = self.focused_window_mut() { - window.restore()?; - } - - Ok(()) - } -} - #[cfg(test)] mod tests { use super::*; @@ -220,7 +103,7 @@ mod tests { for i in 0..3 { container - .add_window_at(&Window::from(i), WindowHidingPosition::BottomLeft) + .add_window(Window::from(i), Default::default()) .unwrap(); } @@ -239,7 +122,7 @@ mod tests { for i in 0..3 { container - .add_window_at(&Window::from(i), WindowHidingPosition::BottomLeft) + .add_window(Window::from(i), Default::default()) .unwrap(); } @@ -259,7 +142,7 @@ mod tests { for i in 0..3 { container - .add_window_at(&Window::from(i), WindowHidingPosition::BottomLeft) + .add_window(Window::from(i), Default::default()) .unwrap(); } @@ -281,7 +164,7 @@ mod tests { let mut container = Container::default(); container - .add_window_at(&Window::from(1), WindowHidingPosition::BottomLeft) + .add_window(Window::from(1), Default::default()) .unwrap(); assert_eq!(container.windows().len(), 1); @@ -295,7 +178,7 @@ mod tests { for i in 0..3 { container - .add_window_at(&Window::from(i), WindowHidingPosition::BottomLeft) + .add_window(Window::from(i), Default::default()) .unwrap(); } @@ -321,7 +204,7 @@ mod tests { for i in 0..3 { container - .add_window_at(&Window::from(i), WindowHidingPosition::BottomLeft) + .add_window(Window::from(i), Default::default()) .unwrap(); } diff --git a/komorebi-for-mac/komorebi/src/monitor.rs b/komorebi-for-mac/komorebi/src/monitor.rs index c6e6747f..011d046b 100644 --- a/komorebi-for-mac/komorebi/src/monitor.rs +++ b/komorebi-for-mac/komorebi/src/monitor.rs @@ -6,7 +6,6 @@ //! was), and what it does differently from the shared monitor is [`MonitorExt`]. use crate::container::Container; -use crate::container::ContainerExt; use crate::core::DefaultLayout; use crate::core::Layout; use crate::core::OperationDirection; @@ -396,7 +395,7 @@ impl MonitorExt for Monitor { if target_workspace.monocle_container.is_some() { for container in target_workspace.containers_mut() { - container.restore_focused_window()?; + container.restore()?; } for window in target_workspace.floating_windows_mut() { @@ -454,7 +453,7 @@ impl MonitorExt for Monitor { if target_workspace.monocle_container.is_some() { for container in target_workspace.containers_mut() { - container.restore_focused_window()?; + container.restore()?; } target_workspace.reintegrate_monocle_container()?; diff --git a/komorebi-for-mac/komorebi/src/process_event.rs b/komorebi-for-mac/komorebi/src/process_event.rs index d4844df1..838fe544 100644 --- a/komorebi-for-mac/komorebi/src/process_event.rs +++ b/komorebi-for-mac/komorebi/src/process_event.rs @@ -13,7 +13,6 @@ use crate::accessibility::notification_constants::AccessibilityNotification; use crate::animation::animator; use crate::app_kit_notification_constants::AppKitWorkspaceNotification; use crate::border_manager; -use crate::container::ContainerExt; use crate::core::DefaultLayout; use crate::core::Layout; use crate::core::Rect; @@ -701,11 +700,11 @@ impl WindowManager { self.update_focused_workspace(false, false)?; } WindowContainerBehaviour::Append => { - let window_hiding_position = workspace.state.window_hiding_position; + let spot = workspace.hide_spot(); workspace .focused_container_mut() .ok_or_eyre("there is no focused container")? - .add_window_at(&window, window_hiding_position)?; + .add_window(window.clone(), spot)?; workspace.layer = WorkspaceLayer::Tiling; self.update_focused_workspace(true, false)?; } diff --git a/komorebi-for-mac/komorebi/src/scrolling.rs b/komorebi-for-mac/komorebi/src/scrolling.rs index c58d7127..9618cfb7 100644 --- a/komorebi-for-mac/komorebi/src/scrolling.rs +++ b/komorebi-for-mac/komorebi/src/scrolling.rs @@ -13,7 +13,6 @@ use crate::arrival; use crate::container::Container; -use crate::container::ContainerExt; use crate::core::LayoutOptions; use crate::core::OperationDirection; use crate::core::Rect; @@ -60,7 +59,7 @@ fn show(container: &mut Container) -> eyre::Result<()> { }); #[cfg(not(test))] - container.restore_focused_window()?; + container.restore()?; Ok(()) } @@ -632,7 +631,7 @@ impl WorkspaceScrolling for Workspace { } fn stack_scrolling_column(&mut self, column: &[String]) -> eyre::Result<()> { - let hiding_position = self.state.window_hiding_position; + let spot = self.hide_spot(); let focused_window = self .focused_container() @@ -654,7 +653,7 @@ impl WorkspaceScrolling for Workspace { if let Some(container) = self.containers_mut().get_mut(idx) { for window in &windows { - container.add_window_at(window, hiding_position)?; + container.add_window(window.clone(), spot)?; } // the window that had focus is the one that is showing @@ -665,7 +664,7 @@ impl WorkspaceScrolling for Workspace { } if !cfg!(test) { - container.load_focused_window_at(hiding_position)?; + container.load_focused_window(spot)?; } } @@ -675,7 +674,7 @@ impl WorkspaceScrolling for Workspace { } fn unstack_scrolling_column(&mut self) -> eyre::Result { - let hiding_position = self.state.window_hiding_position; + let spot = self.hide_spot(); let idx = self.focused_container_idx(); let Some(container) = self.containers_mut().get_mut(idx) else { @@ -703,7 +702,7 @@ impl WorkspaceScrolling for Workspace { let mut ids = vec![]; for (offset, window) in rest.iter().enumerate() { let mut container = Container::default(); - container.add_window_at(window, hiding_position)?; + container.add_window(window.clone(), spot)?; ids.push(container.id.clone()); // it was one of the tabs that were out of sight, and has to be put where it is shown @@ -1448,7 +1447,7 @@ mod tests { .containers_mut() .front_mut() .unwrap() - .add_window_at(&Window::from(6_000_062), WindowHidingPosition::default()) + .add_window(Window::from(6_000_062), Default::default()) .unwrap(); workspace.layout_scrolling(&AREA, 0); @@ -1839,7 +1838,7 @@ mod tests { .containers_mut() .front_mut() .unwrap() - .add_window_at(&Window::from(212), WindowHidingPosition::default()) + .add_window(Window::from(212), Default::default()) .unwrap(); workspace.layout_scrolling(&AREA, 0); assert_eq!(windows_of(&workspace), [vec![210, 212], vec![211]]); diff --git a/komorebi-for-mac/komorebi/src/window_manager.rs b/komorebi-for-mac/komorebi/src/window_manager.rs index bf0c0158..62912a0d 100644 --- a/komorebi-for-mac/komorebi/src/window_manager.rs +++ b/komorebi-for-mac/komorebi/src/window_manager.rs @@ -17,7 +17,6 @@ use crate::application::Application; use crate::border_manager; use crate::border_manager::BorderLook; use crate::container::Container; -use crate::container::ContainerExt; use crate::core::Arrangement; use crate::core::Axis; use crate::core::CrossBoundaryBehaviour; @@ -1249,9 +1248,9 @@ impl WindowManager { } } - let window_hiding_position = workspace.state.window_hiding_position; + let spot = workspace.hide_spot(); if changed_focus && let Some(container) = workspace.focused_container_mut() { - container.load_focused_window_at(window_hiding_position)?; + container.load_focused_window(spot)?; if let Some(window) = container.focused_window() { window.focus(mouse_follows_focus)?; } @@ -1332,7 +1331,7 @@ impl WindowManager { tracing::info!("cycling container windows"); let mouse_follows_focus = self.mouse_follows_focus; - let window_hiding_position = self.focused_workspace()?.state.window_hiding_position; + let spot = self.focused_workspace()?.hide_spot(); let container = self.focused_container_mut()?; @@ -1347,7 +1346,7 @@ impl WindowManager { let next_idx = direction.next_idx(current_idx, len); container.focus_window(next_idx); - container.load_focused_window_at(window_hiding_position)?; + container.load_focused_window(spot)?; if let Some(window) = container.focused_window() { window.focus(mouse_follows_focus)?; @@ -1545,17 +1544,12 @@ impl WindowManager { pub fn monocle_on(&mut self) -> eyre::Result<()> { tracing::info!("enabling monocle"); - let hiding_position = self - .focused_monitor() - .ok_or_eyre("there is no monitor")? - .extra - .window_hiding_position; - let workspace = self.focused_workspace_mut()?; workspace.new_monocle_container()?; + let spot = workspace.hide_spot(); for container in workspace.containers_mut() { - container.hide_on(hiding_position, None, None)?; + container.hide(None, spot)?; } Ok(()) @@ -1568,7 +1562,7 @@ impl WindowManager { let workspace = self.focused_workspace_mut()?; for container in workspace.containers_mut() { - container.restore_focused_window()?; + container.restore()?; } workspace.reintegrate_monocle_container() @@ -1582,17 +1576,12 @@ impl WindowManager { return Ok(()); } - let hiding_position = self - .focused_monitor() - .ok_or_eyre("there is no monitor")? - .extra - .window_hiding_position; - self.focused_workspace_mut()? .cycle_monocle_container(direction)?; + let spot = self.focused_workspace()?.hide_spot(); for container in self.focused_workspace_mut()?.containers_mut() { - container.hide_on(hiding_position, None, None)?; + container.hide(None, spot)?; } self.update_focused_workspace(true, true) @@ -2611,7 +2600,7 @@ impl WindowManager { if target_workspace.monocle_container.is_some() { for container in target_workspace.containers_mut() { - container.restore_focused_window()?; + container.restore()?; } for window in target_workspace.floating_windows_mut() { @@ -2881,7 +2870,7 @@ impl WindowManager { tracing::info!("cycling container window index"); let mouse_follows_focus = self.mouse_follows_focus; - let window_hiding_position = self.focused_workspace()?.state.window_hiding_position; + let spot = self.focused_workspace()?.hide_spot(); let container = if let Some(container) = &mut self.focused_workspace_mut()?.monocle_container { @@ -2902,7 +2891,7 @@ impl WindowManager { container.windows_mut().swap(current_idx, next_idx); container.focus_window(next_idx); - container.load_focused_window_at(window_hiding_position)?; + container.load_focused_window(spot)?; if let Some(window) = container.focused_window() { window.focus(mouse_follows_focus)?; @@ -2916,7 +2905,7 @@ impl WindowManager { tracing::info!("focusing container window at index {idx}"); let mouse_follows_focus = self.mouse_follows_focus; - let window_hiding_position = self.focused_workspace()?.state.window_hiding_position; + let spot = self.focused_workspace()?.hide_spot(); let container = if let Some(container) = &mut self.focused_workspace_mut()?.monocle_container { @@ -2937,7 +2926,7 @@ impl WindowManager { } container.focus_window(idx); - container.load_focused_window_at(window_hiding_position)?; + container.load_focused_window(spot)?; if let Some(window) = container.focused_window() { window.focus(mouse_follows_focus)?; @@ -2951,7 +2940,7 @@ impl WindowManager { tracing::info!("stacking all windows on workspace"); let workspace = self.focused_workspace_mut()?; - let window_hiding_position = workspace.state.window_hiding_position; + let spot = workspace.hide_spot(); let mut focused_hwnd = None; if let Some(container) = workspace.focused_container() @@ -2979,7 +2968,7 @@ impl WindowManager { && let Some(w_idx_to_focus) = c.idx_for_window(hwnd) { c.focus_window(w_idx_to_focus); - c.load_focused_window_at(window_hiding_position)?; + c.load_focused_window(spot)?; } self.update_focused_workspace(self.mouse_follows_focus, true) } @@ -3783,7 +3772,7 @@ impl WindowManager { .ok_or_eyre("there is no workspace for this monitor")?; for container in origin_workspace.containers_mut() { - container.restore_focused_window()?; + container.restore()?; } origin_workspace.reintegrate_monocle_container()?; diff --git a/komorebi-for-mac/komorebi/src/workspace.rs b/komorebi-for-mac/komorebi/src/workspace.rs index 00219297..e7aae902 100644 --- a/komorebi-for-mac/komorebi/src/workspace.rs +++ b/komorebi-for-mac/komorebi/src/workspace.rs @@ -8,7 +8,6 @@ use crate::DATA_DIR; use crate::REGEX_IDENTIFIERS; -use crate::container::ContainerExt; use crate::container::MacosHideSpot; use crate::core::DefaultLayout; use crate::core::Layout; @@ -464,7 +463,7 @@ impl WorkspaceExt for Workspace { } for c in self.containers_mut() { - c.restore_focused_window()?; + c.restore()?; } return Ok(window); @@ -474,7 +473,7 @@ impl WorkspaceExt for Workspace { .container_idx_for_window(window_id) .ok_or_eyre("there is no window")?; - let window_hiding_position = self.state.window_hiding_position; + let spot = self.hide_spot(); // a strip of columns has to know what there is before it is told what goes self.sync_scrolling_containers(); @@ -502,7 +501,7 @@ impl WorkspaceExt for Workspace { self.focus_previous_container(); } } else { - container.load_focused_window_at(window_hiding_position)?; + container.load_focused_window(spot)?; if let Some(window) = container.focused_window() { window.focus(false)?; } @@ -523,7 +522,7 @@ impl WorkspaceExt for Workspace { fn restore_windows(&mut self, mouse_follows_focus: bool) -> eyre::Result<()> { if let Some(container) = &mut self.monocle_container { - container.restore_focused_window()?; + container.restore()?; if let Some(window) = container.focused_window() { window.focus(mouse_follows_focus)?; @@ -544,7 +543,7 @@ impl WorkspaceExt for Workspace { } for container in self.containers_mut() { - container.restore_focused_window()?; + container.restore()?; } if let Some(container) = self.focused_container_mut() { @@ -1074,7 +1073,7 @@ mod tests { let window = ws.floating_windows_mut().pop_back().unwrap(); let mut container = Container::default(); container - .add_window_at(&window, WindowHidingPosition::BottomLeft) + .add_window(window, Default::default()) .unwrap(); ws.insert_container_at_idx(ws.focused_container_idx(), container); From c424c03e34d4e7ce14530dd82a05ceb5cfd65497 Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:13:13 -0700 Subject: [PATCH 04/14] build(bar): enable eframe's wgpu feature for the Windows bar komorebi-bar gets a second renderer, wgpu, for machines without OpenGL 2.0 (the Windows e2e guest is one: egui_glow refuses its generic OpenGL 1.1). wgpu draws through Direct3D 12 on Windows, which has the software adapter WARP, so it needs no driver. The feature is on only in the `[target.cfg(windows)]` table of komorebi-bar, so the macOS bar and the shared bar-core are untouched and nothing here compiles for them. Cargo.lock gains exactly one entry, `pollster` 0.4.0 (eframe's optional block_on helper) and two dependency lines of eframe and nothing else: the wgpu stack (wgpu 27, naga, wgpu-hal, egui-wgpu, ash, gpu-allocator ...) was already locked as optional dependencies. pollster was not in the offline registry, so `cargo metadata` fetched it from crates.io; no other version changed. Cost measured with `cargo tree -e normal --target x86_64-pc-windows-msvc -p komorebi-bar`: 622 -> 664 distinct crate versions (+42) for the Windows bar. With both features compiled, eframe's default renderer becomes Wgpu, so the next revision names the renderer explicitly. Verified: lock diff reviewed; not built yet (the next revision builds). --- Cargo.lock | 8 ++++++++ komorebi-bar/Cargo.toml | 3 +++ 2 files changed, 11 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index c051a910..07f6653e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1728,6 +1728,7 @@ dependencies = [ "objc2-foundation 0.2.2", "parking_lot 0.12.5", "percent-encoding", + "pollster", "profiling", "raw-window-handle", "static_assertions", @@ -1735,6 +1736,7 @@ dependencies = [ "wasm-bindgen-futures", "web-sys", "web-time", + "wgpu", "windows-sys 0.61.2", "winit", ] @@ -5771,6 +5773,12 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "pollster" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f3a9f18d041e6d0e102a0a46750538147e5e8992d3b4873aaafee2520b00ce3" + [[package]] name = "portable-atomic" version = "1.15.0" diff --git a/komorebi-bar/Cargo.toml b/komorebi-bar/Cargo.toml index 74b6b1da..dae5406e 100644 --- a/komorebi-bar/Cargo.toml +++ b/komorebi-bar/Cargo.toml @@ -40,6 +40,9 @@ tracing-subscriber = { workspace = true } [target.'cfg(windows)'.dependencies] komorebi-themes = { path = "../komorebi-themes", default-features = false } egui_extras = { workspace = true } +# a second renderer, wgpu (Direct3D 12, which has the software adapter WARP), for a machine where OpenGL 2.0 is not +# there; glow stays the first (see `renderer_attempts` in windows/mod.rs). Windows only: the macOS bar has no use for it +eframe = { workspace = true, features = ["wgpu"] } netdev = "0.46" regex = "1" sysinfo = { workspace = true } From 51dca808b01763aa8bc36c844573d201ade48dc9 Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:23:56 -0700 Subject: [PATCH 05/14] refactor(kde): the pointer picks the monitor for the workspace commands BEHAVIOUR (KDE): FocusWorkspaceNumber, FocusWorkspaceNumbers and FocusLastWorkspace now focus the monitor under the pointer first when its workspace is empty, then run the workspace command, as on Windows. This resolves item 1 of docs/dev/known-issues.md. Done by setting CommandHost::POINTER_PICKS_THE_MONITOR_FOR_ALL to true in the KDE CommandHost impl; the shared komorebi-core functions do the rest. New tests/pointer_monitor.rs on FakeBackend: three of four failed before the flip, all pass after it (the fourth checks that a pointer on the focused monitor changes nothing). Verified: cargo test -p komorebi-linux in the lite env, 670 passed, 0 failed. Not verified: KDE VM suites. Gate owed: KDE VM commands and workspace-switch. --- .../komorebi/src/process_command.rs | 3 + .../komorebi/tests/pointer_monitor.rs | 133 ++++++++++++++++++ 2 files changed, 136 insertions(+) create mode 100644 komorebi-for-kde/komorebi/tests/pointer_monitor.rs diff --git a/komorebi-for-kde/komorebi/src/process_command.rs b/komorebi-for-kde/komorebi/src/process_command.rs index 60b5b3f0..3cedffa7 100644 --- a/komorebi-for-kde/komorebi/src/process_command.rs +++ b/komorebi-for-kde/komorebi/src/process_command.rs @@ -2041,6 +2041,9 @@ impl komorebi_core::CommandHost for WindowManager { WindowManager::focus_workspace(self, idx) } + // the pointer picks the monitor, as on Windows (docs/dev/known-issues.md item 1) + const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = true; + fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { let monitor = self .monitors_mut() diff --git a/komorebi-for-kde/komorebi/tests/pointer_monitor.rs b/komorebi-for-kde/komorebi/tests/pointer_monitor.rs new file mode 100644 index 00000000..767fe465 --- /dev/null +++ b/komorebi-for-kde/komorebi/tests/pointer_monitor.rs @@ -0,0 +1,133 @@ +//! The pointer picks the monitor: `focus-workspace`, `focus-workspaces`, `focus-last-workspace`, +//! `cycle-empty-workspace`, `close-workspace` and the cycles act on the monitor the pointer is on +//! when the workspace shown there is empty (the behaviour Windows always had; see +//! docs/dev/known-issues.md item 1), against an in-memory desktop with two monitors side by side. +//! +//! Window ids are in the 33_000s. + +use komorebi::backend::fake::FakeBackend; +use komorebi::backend::with_backend; +use komorebi::core::Rect; +use komorebi::core::SocketMessage; +use komorebi::window::Window; +use komorebi::window_manager::WindowManager; +use komorebi::window_manager_event::KWinNotification; +use komorebi::window_manager_event::SystemNotification; +use komorebi::window_manager_event::WindowManagerEvent; +use std::sync::Arc; + +const RIGHT: u32 = 2; + +fn added(id: u32) -> WindowManagerEvent { + WindowManagerEvent::Show( + SystemNotification::KWin(KWinNotification::WindowAdded), + Window::from(id), + ) +} + +/// The bounds of the monitor on the right, which is also its work area +fn right_half() -> Rect { + Rect { + left: 1920, + top: 0, + right: 1920, + bottom: 1080, + } +} + +/// A window manager over a fake desktop with the monitor of `with_one_monitor` on the left and a +/// second one on the right +fn two_monitors() -> (Arc, WindowManager) { + let fake = FakeBackend::with_one_monitor(); + fake.add_monitor(RIGHT, "Virtual-1", right_half(), right_half()); + let fake = Arc::new(fake); + let (_sender, receiver) = crossbeam_channel::bounded(1); + // unix socket paths are limited to ~104 bytes on macOS, which the temp dir alone can exceed + static NEXT: std::sync::atomic::AtomicU32 = std::sync::atomic::AtomicU32::new(0); + let socket = std::path::PathBuf::from(format!( + "/tmp/kmm-{}-{}.sock", + std::process::id(), + NEXT.fetch_add(1, std::sync::atomic::Ordering::SeqCst) + )); + + let wm = with_backend(fake.clone(), || { + let mut wm = WindowManager::new(receiver, Some(socket)).unwrap(); + wm.init().unwrap(); + wm + }); + + (fake, wm) +} + +fn open_on_the_left(fake: &Arc, wm: &mut WindowManager, id: u32) { + fake.open_window(id, "foot", "foot", &format!("terminal {id}")); + with_backend(fake.clone(), || wm.process_event(added(id))).unwrap(); +} + +fn send( + fake: &Arc, + wm: &mut WindowManager, + message: SocketMessage, +) -> color_eyre::Result<()> { + with_backend(fake.clone(), || wm.process_command(message, Vec::new())) +} + +/// The left monitor has a window and the focus; the right one is empty and has the pointer +fn pointer_on_the_empty_monitor() -> (Arc, WindowManager) { + let (fake, mut wm) = two_monitors(); + open_on_the_left(&fake, &mut wm, 33_001); + fake.set_cursor(2500, 300); + assert_eq!(wm.focused_monitor_idx(), 0); + (fake, wm) +} + +#[test] +fn focus_workspace_switches_the_monitor_under_the_pointer_when_it_is_empty() { + let (fake, mut wm) = pointer_on_the_empty_monitor(); + + send(&fake, &mut wm, SocketMessage::FocusWorkspaceNumber(1)).unwrap(); + + assert_eq!( + wm.focused_monitor_idx(), + 1, + "the pointer's monitor is focused first" + ); + assert_eq!(wm.monitors()[1].focused_workspace_idx(), 1); + assert_eq!( + wm.monitors()[0].focused_workspace_idx(), + 0, + "and the monitor that had the focus keeps its workspace" + ); +} + +#[test] +fn focus_workspaces_starts_from_the_monitor_under_the_pointer() { + let (fake, mut wm) = pointer_on_the_empty_monitor(); + + send(&fake, &mut wm, SocketMessage::FocusWorkspaceNumbers(1)).unwrap(); + + assert_eq!(wm.focused_monitor_idx(), 1); + assert_eq!(wm.monitors()[0].focused_workspace_idx(), 1); + assert_eq!(wm.monitors()[1].focused_workspace_idx(), 1); +} + +#[test] +fn focus_last_workspace_acts_on_the_monitor_under_the_pointer() { + let (fake, mut wm) = pointer_on_the_empty_monitor(); + + send(&fake, &mut wm, SocketMessage::FocusLastWorkspace).unwrap(); + + assert_eq!(wm.focused_monitor_idx(), 1); +} + +#[test] +fn a_pointer_on_the_focused_monitor_changes_nothing() { + let (fake, mut wm) = two_monitors(); + open_on_the_left(&fake, &mut wm, 33_002); + fake.set_cursor(500, 300); + + send(&fake, &mut wm, SocketMessage::FocusWorkspaceNumber(1)).unwrap(); + + assert_eq!(wm.focused_monitor_idx(), 0); + assert_eq!(wm.monitors()[0].focused_workspace_idx(), 1); +} From 0373d7f0b4be6af6be655b967b549528dc5e196b Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:17:24 -0700 Subject: [PATCH 06/14] refactor(kde): the nine container functions of the window manager have the macOS text Deep dedup D-coord-13 (2), the KDE side (kfde had not edited it; no other KDE revision touches these functions). add_window_to_container, cycle_container_window_in_direction, cycle_container_window_index_in_direction, focus_container_window, stack_all, monocle_on, monocle_off, cycle_monocle and transfer_window are replaced by the macOS text: 'let spot = workspace.hide_spot(); container.load_focused_window(spot)?;' (and hide(None, spot)?, restore()?) where KDE had 'let _ = container.load_focused_window(())'. The shared form is ?, which is equivalent here: the KDE window operations always answer Ok, so no ? ever returns; hide_spot() is () on KDE. The functions are now byte-identical in the two daemons (checked with the function splitter diff: no changed line). The binding of a () value is allowed for the file with a comment (clippy::let_unit_value) because the point is the identical text. BEHAVIOUR: none intended (the ? cannot fail), so the gate is to confirm that. Gate for the coordinator: KDE fast tier and VM scenarios that stack, unstack, cycle a stack, monocle on and off and cycle, move a window to another workspace. Verified: KDE cargo check + lib tests (fast-check) PASS; cargo clippy -p komorebi-linux --all-targets -D warnings shows only errors that predate this revision (a ptr_arg in process_command.rs:456 and useless conversions in kwin/mod.rs), none in these files. Not run: the VM. --- .../komorebi/src/window_manager.rs | 65 +++++++++++++++---- 1 file changed, 54 insertions(+), 11 deletions(-) diff --git a/komorebi-for-kde/komorebi/src/window_manager.rs b/komorebi-for-kde/komorebi/src/window_manager.rs index 8ac80635..448f2b5d 100644 --- a/komorebi-for-kde/komorebi/src/window_manager.rs +++ b/komorebi-for-kde/komorebi/src/window_manager.rs @@ -48,6 +48,10 @@ //! //! [`listen_for_commands`]: crate::process_command::listen_for_commands +// the text of the container calls is the same as on macOS, where the hide spot is a value: here it +// is `()`, and binding it is how the two stay identical +#![allow(clippy::let_unit_value)] + use crate::DATA_DIR; use crate::HIDDEN_WINDOWS; use crate::LibraryError; @@ -1320,8 +1324,10 @@ impl WindowManager { workspace.move_window_to_container(adjusted_new_index)?; } } + + let spot = workspace.hide_spot(); if changed_focus && let Some(container) = workspace.focused_container_mut() { - let _ = container.load_focused_window(()); + container.load_focused_window(spot)?; if let Some(window) = container.focused_window() { window.focus(mouse_follows_focus)?; } @@ -1425,6 +1431,7 @@ impl WindowManager { tracing::info!("cycling container windows"); let mouse_follows_focus = self.mouse_follows_focus; + let spot = self.focused_workspace()?.hide_spot(); let container = self.focused_container_mut()?; @@ -1439,7 +1446,7 @@ impl WindowManager { let next_idx = direction.next_idx(current_idx, len); container.focus_window(next_idx); - let _ = container.load_focused_window(()); + container.load_focused_window(spot)?; if let Some(window) = container.focused_window() { window.focus(mouse_follows_focus)?; @@ -1631,8 +1638,9 @@ impl WindowManager { let workspace = self.focused_workspace_mut()?; workspace.new_monocle_container()?; + let spot = workspace.hide_spot(); for container in workspace.containers_mut() { - let _ = container.hide(None, ()); + container.hide(None, spot)?; } Ok(()) @@ -1651,7 +1659,7 @@ impl WindowManager { let workspace = self.focused_workspace_mut()?; for container in workspace.containers_mut() { - let _ = container.restore(); + container.restore()?; } workspace.reintegrate_monocle_container() @@ -1678,8 +1686,9 @@ impl WindowManager { self.focused_workspace_mut()? .cycle_monocle_container(direction)?; + let spot = self.focused_workspace()?.hide_spot(); for container in self.focused_workspace_mut()?.containers_mut() { - let _ = container.hide(None, ()); + container.hide(None, spot)?; } self.update_focused_workspace(true, true) @@ -2811,6 +2820,7 @@ impl WindowManager { tracing::info!("cycling container window index"); let mouse_follows_focus = self.mouse_follows_focus; + let spot = self.focused_workspace()?.hide_spot(); let container = if let Some(container) = &mut self.focused_workspace_mut()?.monocle_container { @@ -2831,7 +2841,7 @@ impl WindowManager { container.windows_mut().swap(current_idx, next_idx); container.focus_window(next_idx); - let _ = container.load_focused_window(()); + container.load_focused_window(spot)?; if let Some(window) = container.focused_window() { window.focus(mouse_follows_focus)?; @@ -2853,6 +2863,7 @@ impl WindowManager { tracing::info!("focusing container window at index {idx}"); let mouse_follows_focus = self.mouse_follows_focus; + let spot = self.focused_workspace()?.hide_spot(); let container = if let Some(container) = &mut self.focused_workspace_mut()?.monocle_container { @@ -2873,7 +2884,7 @@ impl WindowManager { } container.focus_window(idx); - let _ = container.load_focused_window(()); + container.load_focused_window(spot)?; if let Some(window) = container.focused_window() { window.focus(mouse_follows_focus)?; @@ -2893,6 +2904,7 @@ impl WindowManager { tracing::info!("stacking all windows on workspace"); let workspace = self.focused_workspace_mut()?; + let spot = workspace.hide_spot(); let mut focused_hwnd = None; if let Some(container) = workspace.focused_container() @@ -2920,7 +2932,7 @@ impl WindowManager { && let Some(w_idx_to_focus) = c.idx_for_window(hwnd) { c.focus_window(w_idx_to_focus); - let _ = c.load_focused_window(()); + c.load_focused_window(spot)?; } self.update_focused_workspace(self.mouse_follows_focus, true) } @@ -3893,7 +3905,7 @@ impl WindowManager { .ok_or_eyre("there is no workspace for this monitor")?; for container in origin_workspace.containers_mut() { - let _ = container.restore(); + container.restore()?; } origin_workspace.reintegrate_monocle_container()?; @@ -3906,15 +3918,46 @@ impl WindowManager { target_container_idx, ), )?; + // TODO: don't think this is needed on macOS + // After we restore the origin workspace, some windows that were cloacked + // by the monocle might now be uncloacked which would trigger a workspace + // reconciliation since the focused monitor would be different from origin. + // That workspace reconciliation would focus the window on the origin monitor. + // So we need to ignore the uncloak events produced by the origin workspace + // restore to avoid that issue. + // self.uncloack_to_ignore = uncloack_amount; } + // TODO: this probably won't be used on macOS } else if origin_workspace .maximized_window .as_ref() .map(|max| max.id == window_id) .unwrap_or_default() { - // A maximized window is in no container, so there is none to transfer: it stays where - // it is + // Moving maximized_window + // TODO: not sure if we'll support maximized windows on macOS + // if let Some(maximized_idx) = origin_workspace.maximized_window_restore_idx { + // self.focus_monitor(origin_monitor_idx)?; + // let origin_monitor = self + // .focused_monitor_mut() + // .ok_or_eyre("there is no origin monitor")?; + // origin_monitor.focus_workspace(origin_workspace_idx)?; + // self.unmaximize_window()?; + // self.focus_monitor(target_monitor_idx)?; + // let target_monitor = self + // .focused_monitor_mut() + // .ok_or_eyre("there is no target monitor")?; + // target_monitor.focus_workspace(target_workspace_idx)?; + // + // self.transfer_container( + // (origin_monitor_idx, origin_workspace_idx, maximized_idx), + // ( + // target_monitor_idx, + // target_workspace_idx, + // target_container_idx, + // ), + // )?; + // } } Ok(()) } From b57ef03421226e0f58fca5810a8667dd141a9bbd Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:14:47 -0700 Subject: [PATCH 07/14] feat(bar): try wgpu when glow cannot make an OpenGL context (Windows) The Windows bar starts with glow exactly as before (the renderer is now named in NativeOptions: with the glow and wgpu features both compiled eframe's default is wgpu, so leaving it unnamed would have switched every machine). Only when glow fails to get a context (eframe::Error::OpenGL, Glutin or NoGlutinConfigs: "egui_glow requires opengl 2.0+" is the one seen in the Windows e2e guest) it runs once more with `Renderer::Wgpu`, which draws through Direct3D 12 and finds the software adapter WARP when there is no GPU driver. If both fail the error names both ("glow: ...; wgpu: ..."), so the e2e scenario can report it. The renderer in use is logged at info ("renderer: glow", and "renderer: glow failed (...); trying wgpu"). To make a second attempt possible the application creator moved out of the `run_native` call into a closure that builds it from clones of the channels and the configuration (the first creator is never run when its renderer fails to start); its body is unchanged. eframe reuses its thread-local winit event loop, so a second `run_native` on the same thread is supported. BEHAVIOUR (Windows, only where glow fails): the bar now opens with wgpu instead of exiting. Nothing changes where glow works except one info log line. The macOS bar and the bar core are untouched. Verified: Windows clippy --all-targets -D warnings clean (default members); a unit test that a creation error is not a context failure. NOT verified: that WARP accepts egui's Direct3D 12 device in the guest, or transparency under wgpu: needs the win-e2e bar scenario. --- komorebi-bar/src/windows/mod.rs | 74 ++++++++++++++++++++++++++++----- 1 file changed, 64 insertions(+), 10 deletions(-) diff --git a/komorebi-bar/src/windows/mod.rs b/komorebi-bar/src/windows/mod.rs index 58e6d745..3c66fe97 100644 --- a/komorebi-bar/src/windows/mod.rs +++ b/komorebi-bar/src/windows/mod.rs @@ -273,10 +273,7 @@ pub fn main() -> color_eyre::Result<()> { .with_transparent(true) .with_taskbar(false); - let native_options = eframe::NativeOptions { - viewport: viewport_builder, - ..Default::default() - }; + let native_options = |renderer| native_options(viewport_builder.clone(), renderer); if let Some(rect) = &work_area_offset { komorebi_client::send_message(&SocketMessage::MonitorWorkAreaOffset(monitor_index, *rect))?; @@ -307,10 +304,12 @@ pub fn main() -> color_eyre::Result<()> { tracing::info!("watching configuration file for changes"); - eframe::run_native( - "komorebi-bar", - native_options, - Box::new(|cc| { + let app_creator = |tx_gui: crossbeam_channel::Sender, + rx_gui: crossbeam_channel::Receiver, + rx_config: crossbeam_channel::Receiver, + config: KomobarConfig| + -> eframe::AppCreator<'static> { + Box::new(move |cc| { let ctx_repainter = cc.egui_ctx.clone(); std::thread::spawn(move || loop { std::thread::sleep(Duration::from_secs(1)); @@ -395,7 +394,62 @@ pub fn main() -> color_eyre::Result<()> { }); Ok(Box::new(Komobar::new(cc, rx_gui, rx_config, config))) - }), + }) + }; + + run_with_fallback( + native_options, + // a creator for each attempt: the first is never run when its renderer fails to start, so the + // second gets what it would have had (the channels are shared, the configuration is a copy) + |_renderer| app_creator(tx_gui.clone(), rx_gui.clone(), rx_config.clone(), config.clone()), ) - .map_err(|error| color_eyre::eyre::Error::msg(error.to_string())) +} + +/// The options of a window drawn by `renderer`. The renderer is always named: with eframe's `glow` and `wgpu` +/// features both compiled, its default is wgpu, and glow has to stay the first choice. +fn native_options(viewport: ViewportBuilder, renderer: eframe::Renderer) -> eframe::NativeOptions { + eframe::NativeOptions { + viewport, + renderer, + ..Default::default() + } +} + +/// Whether `error` is the renderer failing to get a graphics context (what a machine without OpenGL 2.0 +/// does to glow: "egui_glow requires opengl 2.0+"), so that the other renderer is worth a try. +fn is_context_failure(error: &eframe::Error) -> bool { + matches!( + error, + eframe::Error::OpenGL(_) | eframe::Error::Glutin(_) | eframe::Error::NoGlutinConfigs(..) + ) +} + +/// Runs the bar with glow, as always; only when glow cannot make its context (no OpenGL 2.0), runs it again with +/// wgpu, which draws through Direct3D 12 and finds the software adapter (WARP) when there is no GPU driver. +fn run_with_fallback( + options: impl Fn(eframe::Renderer) -> eframe::NativeOptions, + creator: impl Fn(eframe::Renderer) -> eframe::AppCreator<'static>, +) -> color_eyre::Result<()> { + tracing::info!("renderer: glow"); + match eframe::run_native("komorebi-bar", options(eframe::Renderer::Glow), creator(eframe::Renderer::Glow)) { + Err(error) if is_context_failure(&error) => { + tracing::warn!("renderer: glow failed ({error}); trying wgpu"); + eframe::run_native("komorebi-bar", options(eframe::Renderer::Wgpu), creator(eframe::Renderer::Wgpu)) + .map_err(|wgpu| { + color_eyre::eyre::Error::msg(format!("glow: {error}; wgpu: {wgpu}")) + }) + } + result => result.map_err(|error| color_eyre::eyre::Error::msg(error.to_string())), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn the_bar_failing_to_start_is_not_a_reason_to_try_the_other_renderer() { + let creation = eframe::Error::AppCreation("no".into()); + assert!(!is_context_failure(&creation)); + } } From 24d083bce803210c14d53af40e42eee86b45fb7b Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:26:13 -0700 Subject: [PATCH 08/14] refactor(mac): the pointer picks the monitor for the workspace commands BEHAVIOUR (macOS): FocusWorkspaceNumber, FocusWorkspaceNumbers and FocusLastWorkspace now focus the display under the pointer first when its workspace is empty, then run the workspace command, as on Windows and (since the previous revision) KDE. Done by setting CommandHost::POINTER_PICKS_THE_MONITOR_FOR_ALL to true in the macOS CommandHost impl. Adds hand-check row H1 to docs/dev/macos-handcheck.md. Verified: fake-CC cargo clippy --all-targets -D warnings on aarch64-apple-darwin for the four macOS packages passes. Not verified: nothing ran on a Mac. Gate owed: macOS hand check H1. --- docs/dev/macos-handcheck.md | 6 ++++++ komorebi-for-mac/komorebi/src/process_command.rs | 3 +++ 2 files changed, 9 insertions(+) diff --git a/docs/dev/macos-handcheck.md b/docs/dev/macos-handcheck.md index 6ebaade9..dad911be 100644 --- a/docs/dev/macos-handcheck.md +++ b/docs/dev/macos-handcheck.md @@ -164,3 +164,9 @@ Type-check and clippy only; nothing here ran on a Mac. The settings now live in 1. **S3 groups (paddings, floating aspect ratio, `layout_defaults`, `display_index_preferences`).** Config with `default_workspace_padding` 20 and `default_container_padding` 15: tiles 20 px from the work area, 15 apart. Reload with the key dropped: padding stays (merge); set it to 5 and reload: 5. `layout_defaults`: set, reload, workspaces use it; remove and reload: they fall back (the key resets). Aspect ratio: `toggle-float` with centring uses the configured ratio; remove the key and reload: 4:3 (Standard). `display_index_preference 0 `: monitor order follows it. Reload during a drag or workspace switch: no one-frame flash of half-new padding. 2. **S5 animation (BEHAVIOUR: one snapshot for enabled, duration, style and fps).** Animation on (`komorebic animation true`), switch workspace: transition plays. While a transition runs, `komorebic animation-duration 1000`, then `animation-style`, then `animation false`: the running transition is not torn (no mix of old duration with new style), the next one follows the new values. Per-kind: `animation true --movement`, `animation false` (global): per-kind values are cleared by a global value, so movement is off again. Reload a file with `"animation": {"enabled": {"movement": true}}`: only movement animates and the global flag is untouched; reload a file with `"animation": {"enabled": true}` (no fps): fps back to 60; reload a file with no animation block: all animation settings keep their values. `komorebic animation-fps 30` then watch frame cadence. Stack a window (`stack`): no animation during the stack (the `suspend()` counter, unchanged), and animation is back after it, including after a stack command that fails. 3. The border and transparency groups (S6, S4) are not moved on macOS: transparency does not exist there. + +## H. Pointer picks the monitor (wip-u-ptr), appended by the KDE agent + +Type-check and clippy only (fake CC); nothing here ran on a Mac. + +1. **Pointer on an empty workspace of another monitor (BEHAVIOUR).** With two displays, an empty workspace on the second display and the pointer over it while the first display is focused: `komorebic focus-workspace 1`, `komorebic focus-workspaces 1` and `komorebic focus-last-workspace` first focus the display under the pointer, then switch its workspace (before, `focus-workspace` and `focus-workspaces` acted on the focused display). With the pointer on the focused display nothing changes. diff --git a/komorebi-for-mac/komorebi/src/process_command.rs b/komorebi-for-mac/komorebi/src/process_command.rs index 7dda17a0..09e3fb33 100644 --- a/komorebi-for-mac/komorebi/src/process_command.rs +++ b/komorebi-for-mac/komorebi/src/process_command.rs @@ -1732,6 +1732,9 @@ impl komorebi_core::CommandHost for WindowManager { WindowManager::focus_workspace(self, idx) } + // the pointer picks the monitor, as on Windows (docs/dev/known-issues.md item 1) + const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = true; + fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { let monitor = self .monitors_mut() From 008c112964faf22021f14bcd5df387299b1100df Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:19:42 -0700 Subject: [PATCH 09/14] refactor(mac): five router arms are methods with the KDE names Deep dedup D-coord-13 (3), the part that is a move. BEHAVIOUR (a pure move; type-checked and clippy-clean with the fake CC). The inline arms of ToggleWorkspaceLayer (88 lines), ResizeWindowAxis (59), SessionFloatRule, IgnoreRule and ReplaceConfiguration in process_command.rs become the methods toggle_workspace_layer, resize_window_axis, add_session_float_rule, add_ignore_rule(identifier, &str) and replace_configuration(&Path) (KDE's is &PathBuf, which clippy::ptr_arg flags) of the same names as KDE's, with the bodies the arms had (de-indented, ending in Ok(())); the router arms are now the same text as KDE's. Two spellings changed because the KDE signature has them: the ignore rule's id is a &str (compared with ==, copied with to_string()), and replace_configuration takes the run loop from self as the arm did. What stays macOS's own and is not moved, because the body is the platform's: Minimize and Close (AdhocWindow on the foreground element), DebugWindow and ManageRule (role against class; no KDE method to match yet), and the macOS bodies of the five moved methods (the role in the session float rule, the run loop in replace_configuration, the animation suspension in resize_window_axis): they are the methods' own differences now, behind the same names. Verified: fast-check macOS PASS; fake-CC cargo clippy -p komorebi-macos --all-targets -D warnings clean. Not verified: any macOS test or run. Verified on the Mini: not yet. Hand check row added to docs/dev/macos-handcheck.md. --- docs/dev/macos-handcheck.md | 1 + .../komorebi/src/process_command.rs | 604 +++++++++--------- 2 files changed, 299 insertions(+), 306 deletions(-) diff --git a/docs/dev/macos-handcheck.md b/docs/dev/macos-handcheck.md index b86aae80..23406b7c 100644 --- a/docs/dev/macos-handcheck.md +++ b/docs/dev/macos-handcheck.md @@ -98,6 +98,7 @@ timeout. Until then H5 documents the hang. | 11(iii) Monitor: `refactor(mac): the daemon's Monitor is komorebi_core::Monitor` (see `jj log -r wip-u-kfm2`) | The monitor is the shared generic type; the corner (`window_hiding_position`) is the platform's flattened `extra` (written last, as before), the constructors, `update_*_globals`, `load_focused_workspace`, `move_container_to_workspace(1)`, `add_container_with_direction`, `hide_unfocused_workspaces` and `restore_focused_workspace` are `MonitorExt`; `focus_workspace`, `add_container`, `remove_workspace*`, `ensure_workspace_count` and the name and layout lookups are the shared ones. The monitor gives its workspaces the corner through `workspace.state` when it updates their globals. | `cargo test` (monitor tests, `state_pin`). By hand: `komorebic state | jq '.monitors.elements[0] | keys_unsorted'` is the same list as before with `window_hiding_position` last; switch workspaces on each monitor (hide and restore of the whole workspace), focus-workspace by index and by name, move a container to another workspace and to another monitor, unplug and replug a display (the monitor and its workspaces are rebuilt through `Monitor::new` and `update_all_workspace_globals`), a config with `window_hiding_position` per monitor. | | `wip-u-kfm3` registry fixes (see `jj log -r wip-u-kfm3`) | The registry keeps inert application copies (no blocking Accessibility call when an entry is dropped), a window is registered when its observer is attached, a clone being dropped no longer deregisters its window, `forget_pid` runs ahead of the pause and other-space returns, and the application reaper forgets what it reaps. Nothing reads the registry except the unused `MacosBackend`. | H3, H4, H6, H7 above, and the usual walk-through: no change in what the daemon does is expected. | | deep dedup 1: `refactor(mac): the daemon uses the shared Container API with the hide spot` (see `jj log -r wip-u-mac-deep`) | `ContainerExt` (`add_window_at`, `load_focused_window_at`, `hide_on`, `restore_focused_window`) is gone: every call is the shared `Container::{add_window, load_focused_window, hide, restore}` with `workspace.hide_spot()`. `monocle_on` and `cycle_monocle` took the corner from the monitor (`monitor.extra`) and now take it from the workspace (`workspace.state`), which the monitor writes with the globals; `restore()` now skips the Accessibility call under `cfg!(test)`. | `cargo test`; then H1 (hide spot) and: toggle monocle on a workspace with two containers on a monitor with `window_hiding_position: BottomRight` (every other container parks in that corner), cycle the monocle container, stack with `komorebic stack`/`stack-all`, `cycle-stack`, `add-window-to-container`, switch workspaces. Change the monitor's `window_hiding_position` in the config, reload, and toggle monocle at once: the corner must be the new one. | +| deep dedup 2: `refactor(mac): five router arms are methods with the KDE names` | `ToggleWorkspaceLayer`, `ResizeWindowAxis`, `SessionFloatRule`, `IgnoreRule` and `ReplaceConfiguration` call `toggle_workspace_layer`, `resize_window_axis`, `add_session_float_rule`, `add_ignore_rule(identifier, id: &str)` and `replace_configuration(&PathBuf)`, with the bodies the arms had (a pure move; the router arms are now the KDE text). `id` of the ignore rule is a `&str`, compared with `==`. | `cargo test`; by hand: `komorebic toggle-workspace-layer` twice (tiling to floating and back: a window of the layer is focused, the others hide at the corner and come back), `resize-axis horizontal|vertical increase|decrease`, `komorebic session-float-rule` on a window, `komorebic ignore-rule exe ` and `ignore-rule title/class` (the matching windows leave the workspaces), `komorebic replace-configuration ` (the daemon restarts its windows under the new config; with a broken file it is left alone). | Revisions in section B change no behaviour on purpose (rename, move, route); they still need the sections C walk-through, because a mechanical mistake would show there. diff --git a/komorebi-for-mac/komorebi/src/process_command.rs b/komorebi-for-mac/komorebi/src/process_command.rs index da3e5181..773d1290 100644 --- a/komorebi-for-mac/komorebi/src/process_command.rs +++ b/komorebi-for-mac/komorebi/src/process_command.rs @@ -21,6 +21,7 @@ use crate::core::MonocleFocusBehaviour; use crate::core::MoveBehaviour; use crate::core::OperationDirection; use crate::core::Rect; +use crate::core::Sizing; use crate::core::SocketMessage; use crate::core::StateQuery; use crate::core::WindowContainerBehaviour; @@ -645,117 +646,7 @@ impl WindowManager { } SocketMessage::ToggleMonocle => self.toggle_monocle()?, SocketMessage::ToggleFloat => self.toggle_float(false)?, - SocketMessage::ToggleWorkspaceLayer => { - let mouse_follows_focus = self.mouse_follows_focus; - let hiding_position = self - .focused_monitor() - .ok_or_eyre("there is no monitor")? - .extra - .window_hiding_position; - let workspace = self.focused_workspace_mut()?; - - let mut to_focus = None; - match workspace.layer { - WorkspaceLayer::Tiling => { - workspace.layer = WorkspaceLayer::Floating; - tracing::info!("WorkspaceLayer is now Floating"); - - let focused_idx = workspace.focused_floating_window_idx(); - let mut window_idx_pairs = workspace - .floating_windows_mut() - .make_contiguous() - .iter_mut() - .enumerate() - .collect::>(); - - // Sort by window area - window_idx_pairs.sort_by_key(|(_, w)| { - let rect = Rect::from(w.window_rect().unwrap_or_default()); - rect.right * rect.bottom - }); - window_idx_pairs.reverse(); - - for (i, window) in window_idx_pairs { - if i == focused_idx { - to_focus = Some(window.clone()); - } else { - window.restore()?; - window.raise()?; - } - } - - if let Some(focused_window) = &mut to_focus { - // The focused window should be the last one raised to make sure it is - // on top - focused_window.restore()?; - focused_window.raise()?; - } - - for container in workspace.containers() { - if let Some(_window) = container.focused_window() { - // TODO: figure out z order - // window.lower()?; - } - } - - if let Some(monocle) = &workspace.monocle_container - && let Some(_window) = monocle.focused_window() - { - // TODO: figure out z order - // window.lower()?; - } - } - WorkspaceLayer::Floating => { - workspace.layer = WorkspaceLayer::Tiling; - tracing::info!("WorkspaceLayer is now Tiling"); - - if let Some(monocle) = &workspace.monocle_container { - if let Some(window) = monocle.focused_window() { - to_focus = Some(window.clone()); - window.raise()?; - } - - for window in workspace.floating_windows_mut() { - window.hide(hiding_position)?; - } - } else { - let focused_container_idx = workspace.focused_container_idx(); - for (i, container) in workspace.containers_mut().iter_mut().enumerate() - { - if let Some(window) = container.focused_window() { - if i == focused_container_idx { - to_focus = Some(window.clone()); - } - - window.raise()?; - } - } - - let mut window_idx_pairs = workspace - .floating_windows_mut() - .make_contiguous() - .iter_mut() - .collect::>(); - - // Sort by window area - window_idx_pairs.sort_by_key(|w| { - let rect = Rect::from(w.window_rect().unwrap_or_default()); - rect.right * rect.bottom - }); - - for window in window_idx_pairs { - // TODO: figure out z order - window.hide(hiding_position)?; - // window.lower()?; - } - } - } - }; - - if let Some(window) = to_focus { - window.focus(mouse_follows_focus)?; - } - } + SocketMessage::ToggleWorkspaceLayer => self.toggle_workspace_layer()?, SocketMessage::ResizeWindowEdge(direction, sizing) => { // resizing is done by the key, over and over, and every press is laid out where it // goes and not by an animation that the next press would have to catch up with @@ -763,65 +654,7 @@ impl WindowManager { self.resize_window(direction, sizing, self.resize_delta, true)?; } SocketMessage::ResizeWindowAxis(axis, sizing) => { - let _suspended_animations = animation::suspend(); - match axis { - Axis::Horizontal => { - self.resize_window( - OperationDirection::Left, - sizing, - self.resize_delta, - false, - )?; - self.resize_window( - OperationDirection::Right, - sizing, - self.resize_delta, - false, - )?; - } - Axis::Vertical => { - self.resize_window( - OperationDirection::Up, - sizing, - self.resize_delta, - false, - )?; - self.resize_window( - OperationDirection::Down, - sizing, - self.resize_delta, - false, - )?; - } - Axis::HorizontalAndVertical => { - self.resize_window( - OperationDirection::Left, - sizing, - self.resize_delta, - false, - )?; - self.resize_window( - OperationDirection::Right, - sizing, - self.resize_delta, - false, - )?; - self.resize_window( - OperationDirection::Up, - sizing, - self.resize_delta, - false, - )?; - self.resize_window( - OperationDirection::Down, - sizing, - self.resize_delta, - false, - )?; - } - } - - self.update_focused_workspace(false, false)?; + self.resize_window_axis(axis, sizing)? } SocketMessage::Retile => self.retile_all(false)?, SocketMessage::RetileWithResizeDimensions => self.retile_all(true)?, @@ -1012,42 +845,7 @@ impl WindowManager { reply.write_all(monitors_state.as_bytes())?; } SocketMessage::Query(query) => self.answer_query(query, &mut reply)?, - SocketMessage::SessionFloatRule => { - let foreground_window = - MacosApi::foreground_window().ok_or_eyre("there is no foreground window")?; - let (exe, title, role) = ( - AdhocWindow::exe(&foreground_window), - AdhocWindow::title(&foreground_window), - AdhocWindow::role(&foreground_window), - ); - - if let (Some(exe), Some(title), Some(role)) = (exe, title, role) { - let rule = MatchingRule::Composite(vec![ - IdWithIdentifier { - kind: ApplicationIdentifier::Exe, - id: exe, - matching_strategy: Option::from(MatchingStrategy::Equals), - }, - IdWithIdentifier { - kind: ApplicationIdentifier::Title, - id: title, - matching_strategy: Option::from(MatchingStrategy::Equals), - }, - IdWithIdentifier { - kind: ApplicationIdentifier::Class, - id: role, - matching_strategy: Option::from(MatchingStrategy::Equals), - }, - ]); - - let mut floating_applications = FLOATING_APPLICATIONS.lock(); - floating_applications.push(rule.clone()); - let mut session_floating_applications = SESSION_FLOATING_APPLICATIONS.lock(); - session_floating_applications.push(rule.clone()); - - self.toggle_float(true)?; - } - } + SocketMessage::SessionFloatRule => self.add_session_float_rule()?, SocketMessage::SessionFloatRules => { let session_floating_applications = SESSION_FLOATING_APPLICATIONS.lock(); let rules = serde_json::to_string_pretty(&*session_floating_applications) @@ -1130,78 +928,7 @@ impl WindowManager { self.enforce_workspace_rules()?; } SocketMessage::IgnoreRule(identifier, ref id) => { - let mut ignore_identifiers = IGNORE_IDENTIFIERS.lock(); - - let mut should_push = true; - for i in &*ignore_identifiers { - if let MatchingRule::Simple(i) = i - && i.id.eq(id) - { - should_push = false; - } - } - - if should_push { - ignore_identifiers.push(MatchingRule::Simple(IdWithIdentifier { - kind: identifier, - id: id.clone(), - matching_strategy: Option::from(MatchingStrategy::Legacy), - })); - } - - let offset = self.work_area_offset; - - let mut window_ids_to_purge = vec![]; - for (i, monitor) in self.monitors().iter().enumerate() { - for container in monitor - .focused_workspace() - .ok_or_eyre("there is no workspace")? - .containers() - { - for window in container.windows() { - match identifier { - ApplicationIdentifier::Path => { - if window.path().unwrap_or_default().to_string_lossy() == *id { - window_ids_to_purge.push((i, window.id)); - } - } - ApplicationIdentifier::Exe => { - if window.exe().unwrap_or_default() == *id { - window_ids_to_purge.push((i, window.id)); - } - } - ApplicationIdentifier::Class => { - if window.role().unwrap_or_default() == *id { - window_ids_to_purge.push((i, window.id)); - } - - if window.subrole().unwrap_or_default() == *id { - window_ids_to_purge.push((i, window.id)); - } - } - ApplicationIdentifier::Title => { - if window.title().unwrap_or_default() == *id { - window_ids_to_purge.push((i, window.id)); - } - } - } - } - } - } - - for (monitor_idx, id) in window_ids_to_purge { - let monitor = self - .monitors_mut() - .get_mut(monitor_idx) - .ok_or_eyre("there is no monitor")?; - - monitor - .focused_workspace_mut() - .ok_or_eyre("there is no focused workspace")? - .remove_window(id)?; - - monitor.update_focused_workspace(offset)?; - } + self.add_ignore_rule(identifier, id)? } SocketMessage::ManageRule(identifier, ref id) => { let mut manage_identifiers = MANAGE_IDENTIFIERS.lock(); @@ -1562,34 +1289,7 @@ impl WindowManager { }); } SocketMessage::ReplaceConfiguration(ref config) => { - // Check that this is a valid static config file first - if StaticConfig::read(config).is_ok() { - // Clear workspace rules; these will need to be replaced - WORKSPACE_MATCHING_RULES.lock().clear(); - // Pause so that restored windows come to the foreground from all workspaces - self.is_paused = true; - // Bring all windows to the foreground - self.restore_all_windows(false)?; - - // Create a new wm from the config path - let mut wm = StaticConfig::preload( - config, - window_manager_event_listener::event_rx(), - self.command_listener.try_clone().ok(), - &self.run_loop.0, - )?; - - // Initialize the new wm - wm.init()?; - - wm.restore_all_windows(true)?; - - // This is equivalent to StaticConfig::postload for this use case - StaticConfig::reload(config, &mut wm)?; - - // Set self to the new wm instance - *self = wm; - } + self.replace_configuration(config)? } SocketMessage::Border(enable) => { border_manager::BORDER_ENABLED.store(enable, Ordering::SeqCst); @@ -1727,6 +1427,298 @@ pub fn read_commands_uds(wm: &Arc>, stream: UnixStream) -> komorebi_transport::read_commands::(wm, stream, &NoPolicy) } +impl WindowManager { + /// Switches the focused workspace between its tiling and floating layers, and focuses a window of the layer it switched to + pub fn toggle_workspace_layer(&mut self) -> eyre::Result<()> { + let mouse_follows_focus = self.mouse_follows_focus; + let hiding_position = self + .focused_monitor() + .ok_or_eyre("there is no monitor")? + .extra + .window_hiding_position; + let workspace = self.focused_workspace_mut()?; + + let mut to_focus = None; + match workspace.layer { + WorkspaceLayer::Tiling => { + workspace.layer = WorkspaceLayer::Floating; + tracing::info!("WorkspaceLayer is now Floating"); + + let focused_idx = workspace.focused_floating_window_idx(); + let mut window_idx_pairs = workspace + .floating_windows_mut() + .make_contiguous() + .iter_mut() + .enumerate() + .collect::>(); + + // Sort by window area + window_idx_pairs.sort_by_key(|(_, w)| { + let rect = Rect::from(w.window_rect().unwrap_or_default()); + rect.right * rect.bottom + }); + window_idx_pairs.reverse(); + + for (i, window) in window_idx_pairs { + if i == focused_idx { + to_focus = Some(window.clone()); + } else { + window.restore()?; + window.raise()?; + } + } + + if let Some(focused_window) = &mut to_focus { + // The focused window should be the last one raised to make sure it is + // on top + focused_window.restore()?; + focused_window.raise()?; + } + + for container in workspace.containers() { + if let Some(_window) = container.focused_window() { + // TODO: figure out z order + // window.lower()?; + } + } + + if let Some(monocle) = &workspace.monocle_container + && let Some(_window) = monocle.focused_window() + { + // TODO: figure out z order + // window.lower()?; + } + } + WorkspaceLayer::Floating => { + workspace.layer = WorkspaceLayer::Tiling; + tracing::info!("WorkspaceLayer is now Tiling"); + + if let Some(monocle) = &workspace.monocle_container { + if let Some(window) = monocle.focused_window() { + to_focus = Some(window.clone()); + window.raise()?; + } + + for window in workspace.floating_windows_mut() { + window.hide(hiding_position)?; + } + } else { + let focused_container_idx = workspace.focused_container_idx(); + for (i, container) in workspace.containers_mut().iter_mut().enumerate() { + if let Some(window) = container.focused_window() { + if i == focused_container_idx { + to_focus = Some(window.clone()); + } + + window.raise()?; + } + } + + let mut window_idx_pairs = workspace + .floating_windows_mut() + .make_contiguous() + .iter_mut() + .collect::>(); + + // Sort by window area + window_idx_pairs.sort_by_key(|w| { + let rect = Rect::from(w.window_rect().unwrap_or_default()); + rect.right * rect.bottom + }); + + for window in window_idx_pairs { + // TODO: figure out z order + window.hide(hiding_position)?; + // window.lower()?; + } + } + } + }; + + if let Some(window) = to_focus { + window.focus(mouse_follows_focus)?; + } + Ok(()) + } + + /// Resizes the focused window along an axis, by the edge that the axis says + pub fn resize_window_axis(&mut self, axis: Axis, sizing: Sizing) -> eyre::Result<()> { + let _suspended_animations = animation::suspend(); + match axis { + Axis::Horizontal => { + self.resize_window(OperationDirection::Left, sizing, self.resize_delta, false)?; + self.resize_window(OperationDirection::Right, sizing, self.resize_delta, false)?; + } + Axis::Vertical => { + self.resize_window(OperationDirection::Up, sizing, self.resize_delta, false)?; + self.resize_window(OperationDirection::Down, sizing, self.resize_delta, false)?; + } + Axis::HorizontalAndVertical => { + self.resize_window(OperationDirection::Left, sizing, self.resize_delta, false)?; + self.resize_window(OperationDirection::Right, sizing, self.resize_delta, false)?; + self.resize_window(OperationDirection::Up, sizing, self.resize_delta, false)?; + self.resize_window(OperationDirection::Down, sizing, self.resize_delta, false)?; + } + } + + self.update_focused_workspace(false, false)?; + Ok(()) + } + + /// Adds a float rule for the focused window (its executable, title and role), until the daemon stops + pub fn add_session_float_rule(&mut self) -> eyre::Result<()> { + let foreground_window = + MacosApi::foreground_window().ok_or_eyre("there is no foreground window")?; + let (exe, title, role) = ( + AdhocWindow::exe(&foreground_window), + AdhocWindow::title(&foreground_window), + AdhocWindow::role(&foreground_window), + ); + + if let (Some(exe), Some(title), Some(role)) = (exe, title, role) { + let rule = MatchingRule::Composite(vec![ + IdWithIdentifier { + kind: ApplicationIdentifier::Exe, + id: exe, + matching_strategy: Option::from(MatchingStrategy::Equals), + }, + IdWithIdentifier { + kind: ApplicationIdentifier::Title, + id: title, + matching_strategy: Option::from(MatchingStrategy::Equals), + }, + IdWithIdentifier { + kind: ApplicationIdentifier::Class, + id: role, + matching_strategy: Option::from(MatchingStrategy::Equals), + }, + ]); + + let mut floating_applications = FLOATING_APPLICATIONS.lock(); + floating_applications.push(rule.clone()); + let mut session_floating_applications = SESSION_FLOATING_APPLICATIONS.lock(); + session_floating_applications.push(rule.clone()); + + self.toggle_float(true)?; + } + Ok(()) + } + + /// Adds a rule that ignores the windows matching `id`, and takes the ones it matches out of the workspaces + pub fn add_ignore_rule( + &mut self, + identifier: ApplicationIdentifier, + id: &str, + ) -> eyre::Result<()> { + let mut ignore_identifiers = IGNORE_IDENTIFIERS.lock(); + + let mut should_push = true; + for i in &*ignore_identifiers { + if let MatchingRule::Simple(i) = i + && i.id == id + { + should_push = false; + } + } + + if should_push { + ignore_identifiers.push(MatchingRule::Simple(IdWithIdentifier { + kind: identifier, + id: id.to_string(), + matching_strategy: Option::from(MatchingStrategy::Legacy), + })); + } + + let offset = self.work_area_offset; + + let mut window_ids_to_purge = vec![]; + for (i, monitor) in self.monitors().iter().enumerate() { + for container in monitor + .focused_workspace() + .ok_or_eyre("there is no workspace")? + .containers() + { + for window in container.windows() { + match identifier { + ApplicationIdentifier::Path => { + if window.path().unwrap_or_default().to_string_lossy() == *id { + window_ids_to_purge.push((i, window.id)); + } + } + ApplicationIdentifier::Exe => { + if window.exe().unwrap_or_default() == *id { + window_ids_to_purge.push((i, window.id)); + } + } + ApplicationIdentifier::Class => { + if window.role().unwrap_or_default() == *id { + window_ids_to_purge.push((i, window.id)); + } + + if window.subrole().unwrap_or_default() == *id { + window_ids_to_purge.push((i, window.id)); + } + } + ApplicationIdentifier::Title => { + if window.title().unwrap_or_default() == *id { + window_ids_to_purge.push((i, window.id)); + } + } + } + } + } + } + + for (monitor_idx, id) in window_ids_to_purge { + let monitor = self + .monitors_mut() + .get_mut(monitor_idx) + .ok_or_eyre("there is no monitor")?; + + monitor + .focused_workspace_mut() + .ok_or_eyre("there is no focused workspace")? + .remove_window(id)?; + + monitor.update_focused_workspace(offset)?; + } + Ok(()) + } + + /// Replaces the running configuration with the one in the file + pub fn replace_configuration(&mut self, config: &std::path::Path) -> eyre::Result<()> { + // Check that this is a valid static config file first + if StaticConfig::read(config).is_ok() { + // Clear workspace rules; these will need to be replaced + WORKSPACE_MATCHING_RULES.lock().clear(); + // Pause so that restored windows come to the foreground from all workspaces + self.is_paused = true; + // Bring all windows to the foreground + self.restore_all_windows(false)?; + + // Create a new wm from the config path + let mut wm = StaticConfig::preload( + config, + window_manager_event_listener::event_rx(), + self.command_listener.try_clone().ok(), + &self.run_loop.0, + )?; + + // Initialize the new wm + wm.init()?; + + wm.restore_all_windows(true)?; + + // This is equivalent to StaticConfig::postload for this use case + StaticConfig::reload(config, &mut wm)?; + + // Set self to the new wm instance + *self = wm; + } + Ok(()) + } +} + /// The window manager as the shared commands of `komorebi_core::command` see it impl komorebi_core::CommandHost for WindowManager { type P = crate::workspace::MacosPlatform; From 0a315a61bcc1516f93d8664a066397b54479d5ed Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:19:00 -0700 Subject: [PATCH 10/14] test(e2e): the bar scenario's window checks are real again when wgpu draws the bar The bar now falls back to wgpu (Direct3D 12, WARP) when glow has no OpenGL context, so in the OpenGL-less golden guest the bar can open a window and the window, stays-alive, daemon-restart and notify checks run for real. They are skipped only when BOTH renderers fail, and the skip names both errors (`skip ...: guest cannot draw: glow: ...; wgpu: ...`, taken from the bar's "Error: glow: ...; wgpu: ..." line); any other early exit still fails. The scenario starts the bar with RUST_LOG=info,wgpu_hal=debug,wgpu_core=warn so bar.out keeps what wgpu says about its adapters on the first run, and prints which renderer drew the window ("the bar draws with wgpu"). Unit tests: both renderers failing (classify + the error line), a bar that fell back and runs (the glow warning is not an "Error:"), plus the earlier ones. Verified: runner and library tests 163 passed; ruff clean on the scenario and its test. NOT run: needs the win-e2e `bar` gate. --- e2e/platforms/qemu_windows/extras/bar.py | 41 +++++++++++++------ .../qemu_windows/tests/test_bar_scenario.py | 23 ++++++++++- 2 files changed, 50 insertions(+), 14 deletions(-) diff --git a/e2e/platforms/qemu_windows/extras/bar.py b/e2e/platforms/qemu_windows/extras/bar.py index fb97bc35..baf1856f 100644 --- a/e2e/platforms/qemu_windows/extras/bar.py +++ b/e2e/platforms/qemu_windows/extras/bar.py @@ -31,6 +31,7 @@ BAR_CONFIG = "C:\\e2e\\bar.json" BAR_OUTPUT = "C:\\e2e\\bar.out" # the title eframe gives the window (`run_native("komorebi-bar", ...)`) ANSI = re.compile(r"\x1b\[[0-9;]*m") +BAR_LOG = "info,wgpu_hal=debug,wgpu_core=warn" BAR_TITLE = "komorebi-bar" # how long the bar must keep running, in seconds ALIVE_SECONDS = 15 @@ -104,23 +105,34 @@ def _alive_for(platform: WindowsPlatform, seconds: float) -> bool: return bool(_bar_pids(platform)) -# what the bar prints when eframe cannot make a window for lack of OpenGL (komorebi-bar's -# `run_native` error), as the gate printed it: "egui_glow requires opengl 2.0+" +# what the bar prints when glow cannot make its context (komorebi-bar's `run_native` error), as the gate +# printed it: "egui_glow requires opengl 2.0+". The bar then tries wgpu (Direct3D 12, WARP) and, when that +# fails too, ends with "glow: ; wgpu: ". NO_OPENGL_TEXT = "requires opengl" -NO_OPENGL = "guest has no OpenGL 2.0" def classify(output: str) -> str | None: - """What the bar's own output says about its start: "no_opengl" (it could not make a - window for lack of OpenGL), "failed" (it ended with any other error: a configuration it + """What the bar's own output says about its start: "no_renderer" (neither glow nor wgpu + could make a window: no OpenGL 2.0 and no usable Direct3D 12 adapter), "failed" (it ended with any other error: a configuration it could not read, a crash) or None (no error, it runs).""" if "Error:" not in output and "panicked" not in output: return None if NO_OPENGL_TEXT in output.lower(): - return "no_opengl" + return "no_renderer" return "failed" +def _renderer_errors(output: str) -> str: + """The line that names what glow and wgpu said, for a skip.""" + for line in output.splitlines(): + if "wgpu:" in line and "glow:" in line: + return line.strip() + for line in output.splitlines(): + if NO_OPENGL_TEXT in line.lower(): + return f"glow: {line.strip()}; (no wgpu attempt: an older bar)" + return "no renderer" + + def _bar_output(platform: WindowsPlatform) -> str: try: text = platform.agent_get_file(BAR_OUTPUT).decode(errors="replace") @@ -135,7 +147,7 @@ def _started(platform: WindowsPlatform) -> bool: def _outcome(platform: WindowsPlatform) -> str: - """Waits for the bar's window or its end: "running" (the window is there), "no_opengl", + """Waits for the bar's window or its end: "running" (the window is there), "no_renderer", "failed", or "timeout" (neither within a minute).""" deadline = time.monotonic() + 60 * platform._scale while time.monotonic() < deadline: @@ -172,8 +184,10 @@ def run(platform: WindowsPlatform, checks: Checks, clients: list[Client]) -> Non local = platform._out / "bar.json" local.write_text(json.dumps(CONFIG, indent=2)) platform._agent.put_file(local, BAR_CONFIG) + # the log of the first run keeps what wgpu says about its adapters platform.agent_spawn( - "cmd", "/c", f"{BAR_BINARY} --config {BAR_CONFIG} > {BAR_OUTPUT} 2>&1" + "cmd", "/c", + f"set RUST_LOG={BAR_LOG}&& {BAR_BINARY} --config {BAR_CONFIG} > {BAR_OUTPUT} 2>&1", ) checks.check("the bar process starts", platform.wait_for(lambda: _started(platform), timeout=30)) @@ -188,16 +202,17 @@ def run(platform: WindowsPlatform, checks: Checks, clients: list[Client]) -> Non outcome != "failed" and "found configuration file" in text, ) - if outcome == "no_opengl": - # the golden guest has no OpenGL 2.0 (basic display and QXL, no software opengl32), so - # eframe cannot make the window: not what a change of the bar did, and not a pass + if outcome == "no_renderer": + # the bar tried glow and then wgpu and neither could make a window: not what a change of the + # bar did, and not a pass + reason = f"guest cannot draw: {_renderer_errors(text)}" for what in ( f"the bar's window titled {BAR_TITLE!r} appears", f"the bar keeps running for {ALIVE_SECONDS} s", "the bar is still running after the daemon stopped", "the bar runs on after the daemon is back", ): - checks.skip(what, NO_OPENGL) + checks.skip(what, reason) checks.check( "`komorebic state` answers after the bar has started", platform.wait_for(lambda: platform.komorebic_status("state")[0] == 0), @@ -215,6 +230,8 @@ def run(platform: WindowsPlatform, checks: Checks, clients: list[Client]) -> Non platform.start_komorebi() return + used = "wgpu" if "trying wgpu" in text else "glow" + print(f" the bar draws with {used}") window = _bar_window(platform) checks.check(f"the bar's window titled {BAR_TITLE!r} appears", window is not None) if window is not None: diff --git a/e2e/platforms/qemu_windows/tests/test_bar_scenario.py b/e2e/platforms/qemu_windows/tests/test_bar_scenario.py index e4a266cd..95166261 100644 --- a/e2e/platforms/qemu_windows/tests/test_bar_scenario.py +++ b/e2e/platforms/qemu_windows/tests/test_bar_scenario.py @@ -12,8 +12,8 @@ PARSE = ( ) -def test_no_opengl_is_told_from_other_errors(): - assert bar.classify(GL) == "no_opengl" +def test_no_renderer_is_told_from_other_errors(): + assert bar.classify(GL) == "no_renderer" def test_any_other_error_is_a_failure(): @@ -29,3 +29,22 @@ def test_a_bar_that_prints_no_error_runs(): def test_the_test_configuration_is_plain_json_values(): # the untagged MouseMessage::Command is a string assert isinstance(bar.CONFIG["mouse"]["on_middle_click"], str) + + +BOTH = ( + "INFO komorebi_bar::windows: renderer: glow\n" + " WARN komorebi_bar::windows: renderer: glow failed (egui_glow: OpenGL: egui_glow requires opengl 2.0+. ); trying wgpu\n" + "Error: glow: egui_glow: OpenGL: egui_glow requires opengl 2.0+. ; wgpu: Failed to find a suitable adapter\n" +) + + +def test_both_renderers_failing_is_reported_with_both_errors(): + assert bar.classify(BOTH) == "no_renderer" + line = bar._renderer_errors(BOTH) + assert "glow:" in line and "wgpu:" in line + + +def test_a_bar_that_fell_back_to_wgpu_and_runs_is_not_an_error(): + # the warning about glow is not an "Error:" line + ran = BOTH.splitlines()[0] + "\n" + BOTH.splitlines()[1] + "\nINFO wgpu_hal: adapter WARP\n" + assert bar.classify(ran) is None From 3e5475e7efb39689fc832d53cf6047256c1c5e8b Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:27:24 -0700 Subject: [PATCH 11/14] refactor(core,kde,windows,mac): remove CommandHost::POINTER_PICKS_THE_MONITOR_FOR_ALL All three daemons now let the pointer pick the monitor for every shared command that has the preamble, so the const has no reason left. The shared functions always call focus_the_monitor_under_the_pointer; the three CommandHost impls lose the const (Windows had it true already, so nothing changes there). The core test of the switch becomes the_pointer_picks_the_monitor_..._on_all_platforms. known-issues item 1 is marked resolved and core-model.md section 18 text is updated. No behaviour change in this revision beyond the previous two. Verified: komorebi-core tests all pass (command tests 18); KDE cargo test -p komorebi-linux 670 passed, 0 failed; fake-CC clippy for the four macOS packages passes; cargo clippy -p komorebi-windows --all-targets -D warnings passes. Not verified: Windows tests or e2e (cannot run on Linux). --- crates/komorebi-core/src/command.rs | 26 +---- crates/komorebi-core/tests/commands.rs | 100 ++---------------- docs/dev/core-model.md | 4 +- docs/dev/known-issues.md | 4 +- .../komorebi/src/process_command.rs | 3 - .../komorebi/src/process_command.rs | 3 - komorebi/src/process_command.rs | 3 - 7 files changed, 19 insertions(+), 124 deletions(-) diff --git a/crates/komorebi-core/src/command.rs b/crates/komorebi-core/src/command.rs index e328b6ef..c5383cab 100644 --- a/crates/komorebi-core/src/command.rs +++ b/crates/komorebi-core/src/command.rs @@ -22,12 +22,6 @@ pub trait CommandHost { /// The platform whose monitors the host has. type P: MonitorPlatform; - /// Whether the commands that act on the focused monitor first focus the monitor the pointer is - /// on when the workspace shown there is empty, for `cycle_focus_empty_workspace`, - /// `close_workspace` and `focus_last_workspace` (the other commands always do). Windows does it - /// for all of them; KDE and macOS do not. - const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = false; - /// The monitors. fn monitors(&self) -> &VecDeque>; @@ -104,9 +98,7 @@ pub fn cycle_focus_empty_workspace( host: &mut H, direction: CycleDirection, ) -> eyre::Result<()> { - if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { - focus_the_monitor_under_the_pointer(host)?; - } + focus_the_monitor_under_the_pointer(host)?; let focused_monitor = host.focused_monitor().ok_or_eyre("there is no monitor")?; @@ -142,9 +134,7 @@ pub fn cycle_focus_empty_workspace( /// Removes the focused workspace when it is empty, unnamed and not the monitor's only one, and /// focuses the one before it pub fn close_workspace(host: &mut H) -> eyre::Result<()> { - if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { - focus_the_monitor_under_the_pointer(host)?; - } + focus_the_monitor_under_the_pointer(host)?; let mut can_close = false; @@ -177,9 +167,7 @@ pub fn close_workspace(host: &mut H) -> eyre::Result<()> { /// Focuses the workspace that was focused before this one pub fn focus_last_workspace(host: &mut H) -> eyre::Result<()> { - if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { - focus_the_monitor_under_the_pointer(host)?; - } + focus_the_monitor_under_the_pointer(host)?; let idx = host .focused_monitor() @@ -378,9 +366,7 @@ pub fn focus_workspace_number( host: &mut H, workspace_idx: usize, ) -> eyre::Result<()> { - if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { - focus_the_monitor_under_the_pointer(host)?; - } + focus_the_monitor_under_the_pointer(host)?; if host.focused_workspace_idx().unwrap_or_default() != workspace_idx { host.focus_workspace(workspace_idx)?; @@ -394,9 +380,7 @@ pub fn focus_workspace_numbers( host: &mut H, workspace_idx: usize, ) -> eyre::Result<()> { - if H::POINTER_PICKS_THE_MONITOR_FOR_ALL { - focus_the_monitor_under_the_pointer(host)?; - } + focus_the_monitor_under_the_pointer(host)?; let focused_monitor_idx = host.focused_monitor_idx(); diff --git a/crates/komorebi-core/tests/commands.rs b/crates/komorebi-core/tests/commands.rs index faa8507e..ab914aad 100644 --- a/crates/komorebi-core/tests/commands.rs +++ b/crates/komorebi-core/tests/commands.rs @@ -385,108 +385,26 @@ fn locking_a_container_that_is_not_there_is_ignored_but_a_missing_monitor_or_wor assert!(komorebi_core::set_container_locked(&mut host, 0, 9, 0, true).is_err()); } -/// A host that says whether the pointer picks the monitor first, and does what `Host` does -struct Pointer(Host); - -impl CommandHost for Pointer { - type P = StubPlatform; - const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = ALL; - - fn monitors(&self) -> &VecDeque> { - self.0.monitors() - } - fn focused_monitor(&self) -> Option<&Monitor> { - self.0.focused_monitor() - } - fn focused_monitor_mut(&mut self) -> Option<&mut Monitor> { - self.0.focused_monitor_mut() - } - fn focused_monitor_idx(&self) -> usize { - self.0.focused_monitor_idx() - } - fn monitor_idx_from_current_pos(&mut self) -> Option { - self.0.monitor_idx_from_current_pos() - } - fn focus_monitor(&mut self, idx: usize) -> eyre::Result<()> { - self.0.focus_monitor(idx) - } - fn focus_workspace(&mut self, idx: usize) -> eyre::Result<()> { - self.0.focus_workspace(idx) - } - fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { - self.0.show_workspace_on(monitor_idx, workspace_idx) - } - fn move_container_to_workspace( - &mut self, - idx: usize, - follow: bool, - direction: Option, - ) -> eyre::Result<()> { - self.0.move_container_to_workspace(idx, follow, direction) - } -} - -impl komorebi_core::MonitorCommandHost for Pointer { - fn mouse_follows_focus(&self) -> bool { - self.0.mouse_follows_focus() - } - fn update_focused_workspace(&mut self, a: bool, b: bool) -> eyre::Result<()> { - self.0.update_focused_workspace(a, b) - } - fn direction_from_monitor_idx(&self, idx: usize) -> Option { - self.0.direction_from_monitor_idx(idx) - } - fn move_container_to_monitor( - &mut self, - idx: usize, - workspace_idx: Option, - follow: bool, - direction: Option, - ) -> eyre::Result<()> { - self.0 - .move_container_to_monitor(idx, workspace_idx, follow, direction) - } - fn focused_workspace_idx(&self) -> eyre::Result { - self.0.focused_workspace_idx() - } -} - fn pointer_on_the_second_monitor() -> Host { let mut host = two_monitors(); host.pointer_on = Some(1); host } -fn focused_monitor_calls(host: &Host) -> usize { - host.calls - .iter() - .filter(|call| call.starts_with("focus_monitor")) - .count() -} - #[test] -fn the_pointer_switch_gives_the_empty_close_last_and_number_commands_the_preamble() { +fn the_pointer_picks_the_monitor_for_the_empty_close_last_cycle_and_number_commands_on_all_platforms() { // commands.py: close-workspace, cycle-empty-workspace, focus-last-workspace, focus-workspace, - // focus-workspaces; with the switch off nothing looks at the pointer, with it on the monitor - // under the pointer is focused first when its workspace is empty - let mut off = Pointer::(pointer_on_the_second_monitor()); - komorebi_core::close_workspace(&mut off).unwrap(); - komorebi_core::focus_last_workspace(&mut off).unwrap(); - komorebi_core::cycle_focus_empty_workspace(&mut off, CycleDirection::Next).unwrap(); - komorebi_core::focus_workspace_number(&mut off, 1).unwrap(); - komorebi_core::focus_workspace_numbers(&mut off, 1).unwrap(); - assert_eq!(focused_monitor_calls(&off.0), 0); - + // focus-workspaces; the monitor under the pointer is focused first when its workspace is empty for command in 0..5 { - let mut on = Pointer::(pointer_on_the_second_monitor()); + let mut host = pointer_on_the_second_monitor(); match command { - 0 => komorebi_core::close_workspace(&mut on).unwrap(), - 1 => komorebi_core::focus_last_workspace(&mut on).unwrap(), - 2 => komorebi_core::cycle_focus_empty_workspace(&mut on, CycleDirection::Next).unwrap(), - 3 => komorebi_core::focus_workspace_number(&mut on, 1).unwrap(), - _ => komorebi_core::focus_workspace_numbers(&mut on, 1).unwrap(), + 0 => komorebi_core::close_workspace(&mut host).unwrap(), + 1 => komorebi_core::focus_last_workspace(&mut host).unwrap(), + 2 => komorebi_core::cycle_focus_empty_workspace(&mut host, CycleDirection::Next).unwrap(), + 3 => komorebi_core::focus_workspace_number(&mut host, 1).unwrap(), + _ => komorebi_core::focus_workspace_numbers(&mut host, 1).unwrap(), } - assert_eq!(on.0.calls[0], "focus_monitor 1", "command {command}"); + assert_eq!(host.calls[0], "focus_monitor 1", "command {command}"); } } diff --git a/docs/dev/core-model.md b/docs/dev/core-model.md index a26aa3d9..10974f03 100644 --- a/docs/dev/core-model.md +++ b/docs/dev/core-model.md @@ -1390,8 +1390,8 @@ monitors (`CycleMoveContainerToWorkspace`, `CycleSendContainerToWorkspace`, `Cyc `CycleMoveContainerToMonitor`, `CycleSendContainerToMonitor`, `FocusMonitorWorkspaceNumber`, `MoveContainerToMonitorWorkspaceNumber`, `SendContainerToMonitorWorkspaceNumber`) and the lock and unlock of a container by index. The one platform difference found, that Windows lets the pointer pick the -monitor first for the empty, close and last-workspace commands (a probable omission on KDE and macOS, -section 18), is the const `CommandHost::POINTER_PICKS_THE_MONITOR_FOR_ALL`, true only for Windows. +monitor first for the empty, close, last-workspace and workspace-number commands (an omission on KDE and macOS, +section 18), is gone: all three do it now (wip-u-ptr), so the const that held the difference was removed. **What stays, and why** (identical across the three unless noted; each needs a `WindowManager` method or field, so moving them means moving `WindowManager`, the blockers of section 18): diff --git a/docs/dev/known-issues.md b/docs/dev/known-issues.md index f0ba8ea6..1b073c7f 100644 --- a/docs/dev/known-issues.md +++ b/docs/dev/known-issues.md @@ -2,7 +2,9 @@ Findings of the consolidation reviews and tests that are NOT fixed because whether they are bugs, or how to fix them, is a decision for the owner. Each has the evidence, why it may or may not be a bug, the platforms, and a proposed fix. Paths are relative to the repository root at the time of writing and may have moved. -## 1. KDE FocusWorkspaceNumber, FocusWorkspaceNumbers and FocusLastWorkspace skip the pointer-monitor preamble +## 1. RESOLVED (wip-u-ptr): KDE FocusWorkspaceNumber, FocusWorkspaceNumbers and FocusLastWorkspace skipped the pointer-monitor preamble + +- **Resolution**: the owner approved Windows behaviour for all platforms. The preamble now runs for all three daemons in the shared `komorebi_core::command` functions (`focus_workspace_number`, `focus_workspace_numbers`, `focus_last_workspace`, and the others). KDE is covered by `komorebi-for-kde/komorebi/tests/pointer_monitor.rs`, core by `crates/komorebi-core/tests/commands.rs`. Owed: KDE VM commands and workspace-switch, macOS hand check H1 (docs/dev/macos-handcheck.md). The text below is the original finding. - **Evidence**: komorebi-for-kde/komorebi/src/process_command.rs lines 1245-1277: the arms for the three messages call `focus_workspace` on the focused monitor directly. The Windows daemon (komorebi/src/process_command.rs:972-987 for `FocusWorkspaceNumber`, and lines about 2185 and 2215 for the helpers behind `FocusLastWorkspace` and `FocusWorkspaceNumbers`) first checks `monitor_idx_from_current_pos()`: when the pointer is on another monitor whose focused workspace is empty, that monitor becomes the focused one. KDE has the same preamble only in `cycle_focus_workspace` (line 897-909). - **Why it may be a bug**: on a secondary monitor with an empty workspace and the pointer on it, `focus-workspace 2` switches the workspace of the monitor that was focused before, not the one the user is pointing at, unlike on Windows and unlike KDE's own `cycle-focus-workspace`. **Why not**: KWin may not report an empty monitor as pointed at the same way; the KDE tests do not cover it, so it may have been left out on purpose. diff --git a/komorebi-for-kde/komorebi/src/process_command.rs b/komorebi-for-kde/komorebi/src/process_command.rs index 3cedffa7..60b5b3f0 100644 --- a/komorebi-for-kde/komorebi/src/process_command.rs +++ b/komorebi-for-kde/komorebi/src/process_command.rs @@ -2041,9 +2041,6 @@ impl komorebi_core::CommandHost for WindowManager { WindowManager::focus_workspace(self, idx) } - // the pointer picks the monitor, as on Windows (docs/dev/known-issues.md item 1) - const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = true; - fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { let monitor = self .monitors_mut() diff --git a/komorebi-for-mac/komorebi/src/process_command.rs b/komorebi-for-mac/komorebi/src/process_command.rs index 09e3fb33..7dda17a0 100644 --- a/komorebi-for-mac/komorebi/src/process_command.rs +++ b/komorebi-for-mac/komorebi/src/process_command.rs @@ -1732,9 +1732,6 @@ impl komorebi_core::CommandHost for WindowManager { WindowManager::focus_workspace(self, idx) } - // the pointer picks the monitor, as on Windows (docs/dev/known-issues.md item 1) - const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = true; - fn show_workspace_on(&mut self, monitor_idx: usize, workspace_idx: usize) -> eyre::Result<()> { let monitor = self .monitors_mut() diff --git a/komorebi/src/process_command.rs b/komorebi/src/process_command.rs index 6eefbe18..157260c7 100644 --- a/komorebi/src/process_command.rs +++ b/komorebi/src/process_command.rs @@ -2257,9 +2257,6 @@ impl WindowManager { impl komorebi_core::CommandHost for WindowManager { type P = crate::workspace::WindowsPlatform; - // Windows lets the pointer pick the monitor first for these commands too - const POINTER_PICKS_THE_MONITOR_FOR_ALL: bool = true; - fn monitors(&self) -> &std::collections::VecDeque { WindowManager::monitors(self) } From 730f12e719d3989aa7fbefad85e23a2b5cd02f4b Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:22:53 -0700 Subject: [PATCH 12/14] docs(core): section 22, what the macOS deep dedup did and why update is not adopted Records the container API unification (ContainerExt gone, Workspace::hide_spot), the nine window manager functions that are now identical on KDE and macOS (76 of 92 shared function names identical, 1521 of KDE's 2713 stripped lines: 56%), the five router arms that became methods, the four that stay macOS's, and the exact differences between the macOS update and update_shared (a scrolling workspace returns early and skips the resize-dimensions fix-up and places the windows itself; the SkyLight batch is wider; the rest folds with hooks), which is why update is not adopted without the owner's decision. Verified: documentation only. --- docs/dev/core-model.md | 46 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) diff --git a/docs/dev/core-model.md b/docs/dev/core-model.md index a26aa3d9..24be7983 100644 --- a/docs/dev/core-model.md +++ b/docs/dev/core-model.md @@ -1409,3 +1409,49 @@ or field, so moving them means moving `WindowManager`, the blockers of section 1 `WorkAreaOffset`, ...): thin calls of `WindowManager` methods that edit a workspace and re-layout, the same coupling; - queries, configuration, borders, animations, transparency, schema: statics and the platform. + +## 22. After the macOS deep dedup (kfm, D-coord-13): the container API, the arms, and `update` + +**Done.** (1) macOS `ContainerExt` is gone: every container call in the macOS daemon is the shared +`Container::{add_window, load_focused_window, hide, restore}` with `workspace.hide_spot()`, a method of +`Workspace` that is `P::hide_spot(self)` (`()` on KDE, `MacosHideSpot` on macOS). (2) the nine window +manager functions that differed only in these calls (`add_window_to_container`, +`cycle_container_window_in_direction`, `cycle_container_window_index_in_direction`, +`focus_container_window`, `stack_all`, `monocle_on`, `monocle_off`, `cycle_monocle`, `transfer_window`) +are now byte-identical in `komorebi-for-kde` and `komorebi-for-mac`; the `?` form replaced KDE's +`let _ =` (equivalent, its operations always answer `Ok`). Measured with the function splitter: 76 of the +92 function names that the two `window_manager.rs` share have the same text, and 1521 of KDE's 2713 +stripped lines are identical with macOS (56%, from 45% in section 20; the 60% bar needs the platform +entry points of blocker 3). (3) `ToggleWorkspaceLayer`, `ResizeWindowAxis`, `SessionFloatRule`, +`IgnoreRule` and `ReplaceConfiguration` are methods of the KDE names on macOS and the router arms are the +KDE text; `Close`, `Minimize`, `DebugWindow` and `ManageRule` stay macOS's own arms (the foreground +element and the role instead of the class; there is no KDE method to match). + +**`update` is not adopted, and why (exact differences from `update_shared`).** Each is a reason, and +the first two alone would make it unprovable: + +1. **A scrolling workspace returns early.** macOS's `update` does `return self.arrange_scrolling(..)` + inside the tile branch, so for a scrolling workspace it never reaches the closing + `self.resize_dimensions.resize(container_count, None)` that `update_shared` always runs, and it places + the windows itself (drag-step layout, `adopt_actual_sizes`, `hide_scrolling` at the display edge, + the animator), not through one `place_container` per container. Folding it into `scrolling_layouts` plus + `place_container` would change both the placement order and whether the resize dimensions are + truncated for a scrolling workspace. +2. **The SkyLight batch is wider.** macOS disables screen updates around the whole tile branch + (monocle, scrolling and the container loop) and re-enables on every exit; a `begin_update` guard would + start before `prune_duplicate_windows` and the container retain and end after the resize-dimensions + fix-up, and would be taken when `tile` is false as well. Probably harmless, not provable. +3. **Own `calculate_layouts`**: the same arrangement call as `update_shared`'s inline one (checked line by + line), so this one alone would fold. +4. **Unconditional clamp**: `clamp_to_work_area` runs for every non-scrolling layout; the shared + `adjust_layout` hook can do that (as KDE's does). +5. **No maximized branch**: the macOS workspace never has a `maximized_window` (no writer), so the shared + branch is unreachable; `maximize_in_layout` is not needed. +6. **Placement errors are logged and the next window is placed** (`tracing::warn!`): a `place_container` + hook can swallow them as KDE's does. +7. **No second pass and no stackbar**: `end_update` answers `Pass::Done`. + +Items 3 to 7 would fold with hooks; 1 and 2 are the blockers, and 1 is the owner's decision: either the +macOS scrolling placement becomes the `scrolling_layouts` and `place_container` hooks (and the +truncation of the resize dimensions is accepted for a scrolling workspace, which is a behaviour change), +or `update` stays macOS's. From d9da8771340b1ddaee4022c5a0d928ca39003a3a Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:20:00 -0700 Subject: [PATCH 13/14] docs(bar): the wgpu fallback, the scenario's new rules, cost and risks docs/dev/bar-e2e.md: why the golden guest cannot use glow, how the bar falls back to wgpu (WARP), what the scenario now counts as real and as a skip (both renderers failing, naming both errors), the log level kept in bar.out, the measured cost (622 -> 664 crate versions in the Windows bar tree, one new lock entry; build time and exe size not measured) and the risks. Verified: not applicable (docs). The checks of the stack: see the other revisions. --- docs/dev/bar-e2e.md | 74 +++++++++++++++++++-------------------------- 1 file changed, 31 insertions(+), 43 deletions(-) diff --git a/docs/dev/bar-e2e.md b/docs/dev/bar-e2e.md index 4f38448c..b83ef1e0 100644 --- a/docs/dev/bar-e2e.md +++ b/docs/dev/bar-e2e.md @@ -25,51 +25,39 @@ macOS (see `docs/dev/macos-handcheck.md`). Not run when it was written (the guest was reserved): lint only (`py_compile`, `ruff`, the runner's 157 unit tests pass). -## The golden guest has no OpenGL 2.0 -The Windows gate (candidate 5) found that the bar cannot open a window in the golden guest: -eframe's default renderer is `egui_glow`, the guest has the basic display adapter and QXL and no -OpenGL driver, so Windows offers only the generic software OpenGL 1.1 of `opengl32.dll`, and the bar -exits at start with `Error: egui_glow: OpenGL: egui_glow requires opengl 2.0+` -(`komorebi-bar/src/windows/mod.rs`, the `run_native` error). The scenario therefore reports the -window, stays-alive and daemon-restart checks as `skipped: guest has no OpenGL 2.0` when, and only -when, the bar's own output says that (`extras/bar.py`, `classify`); any other early exit is a -failure. The schema equality, the configuration read, `komorebic state` and `stop --bar` stay real -checks. A skip is not a pass: the bar's runtime behaviour is unverified until the guest can draw. +## Renderers: glow first, wgpu when there is no OpenGL -### Getting rendering into the guest (analysis, nothing added) +The golden guest has no OpenGL 2.0 (the basic display adapter and QXL; Windows offers only the generic +OpenGL 1.1), and eframe's `egui_glow` refuses that: the first gate of the `bar` scenario saw +`Error: egui_glow: OpenGL: egui_glow requires opengl 2.0+` and the bar never opened a window. +Decision D-coord-14: the Windows bar tries glow as before and, only when glow cannot make its context +(`eframe::Error::OpenGL`, `Glutin` or `NoGlutinConfigs`), runs again with eframe's wgpu renderer, which +draws through Direct3D 12 and finds the software adapter WARP (Windows 11 ships it in the Basic Render +Driver) with no driver and no download (`run_with_fallback` in `komorebi-bar/src/windows/mod.rs`; the +`wgpu` feature of `eframe` is in the Windows-only table of `komorebi-bar/Cargo.toml`, the bar core and +the macOS bar do not have it). The bar logs `renderer: glow`, and on a fallback `renderer: glow failed +(...); trying wgpu`. With both features compiled eframe's default renderer is wgpu, so the first attempt +names `Renderer::Glow`: machines where glow works run exactly as before. -How the context is chosen: `komorebi-bar` uses `eframe` 0.33 with its default features, so only -the glow renderer is compiled (glutin + `egui_glow`); `NativeOptions` is left at its defaults on -Windows (the macOS bar sets its own), so the bar asks for a hardware OpenGL 2.0+ config through -glutin, falls back to the Windows generic GDI implementation (1.1) and `egui_glow` refuses it. +In the scenario: -1. Mesa llvmpipe `opengl32.dll` next to `komorebi-bar.exe` (the classic recipe: Mesa's - `opengl32.dll` takes over from the system one for that process). Not possible from this flake: - nixpkgs marks `pkgsCross.mingwW64.mesa` as an unsupported platform (`nix build --dry-run` refuses - it), and `nixpkgs` has no Windows `opengl32sw.dll` (that file ships with Qt) or ANGLE. Building - Mesa for mingw means porting its nix expression (swrast + llvm cross for mingw, a cross LLVM - build) and carrying a binary of unknown license status in the image: days of work, hours of - build, and the result is a third-party DLL in the test that real users do not run. -2. A wgpu renderer with the Windows software adapter. Windows 11 ships WARP, the software - Direct3D 12 rasteriser, in the Basic Render Driver, which the guest has; wgpu's DX12 backend - finds it as an adapter, no download. In `eframe` this is the `wgpu` feature plus - `NativeOptions { renderer: Renderer::Wgpu, .. }` (and `wgpu_options` with a fallback adapter if - it does not pick WARP by itself). The sources of the wgpu stack (wgpu 27, naga, wgpu-hal, - gpu-allocator, ash) are already in the local cargo registry because they are in `Cargo.lock` - as optional dependencies of eframe, so it should build offline. Proposal, smallest first: - in `komorebi-bar`'s `[target.'cfg(windows)'.dependencies]` ask for `eframe` with the `wgpu` - feature, and at start: try glow as now; if `run_native` fails with the OpenGL message, run again - with `Renderer::Wgpu` (the e2e then passes the window checks, and a user without OpenGL gets a - bar instead of an error). Cost: about 60 more crates in `Cargo.lock` that are compiled for - Windows only (cold build +3 to 5 minutes in CI, +8 to 12 MB in `komorebi-bar.exe`); a retry path - that needs `NativeOptions` to be built twice; a new, untested code path for real users (low - risk: it only runs where glow already failed). Without the fallback, a `KOMOREBI_BAR_RENDERER=wgpu` - switch the scenario sets would keep users on glow and cost the same dependencies. -3. ANGLE (EGL on Direct3D 11, itself on WARP) through `glutin`'s EGL support: needs - `libEGL.dll`/`libGLESv2.dll`, which are not in nix either. Rejected. +- the bar's window, stays-alive, daemon-restart and notify checks are real when either renderer opens the + window; the scenario prints which one drew it; +- only when both fail (the bar ends with `Error: glow: ...; wgpu: ...`) those checks are skipped, and the + skip line names both errors (`skip ...: guest cannot draw: glow: ...; wgpu: ...`); the schema, the + configuration read, `komorebic state` and `stop --bar` stay checks; any other early exit of the bar is a + failure; +- the bar is started with `RUST_LOG=info,wgpu_hal=debug,wgpu_core=warn` so `bar.out` keeps what wgpu says + about its adapters (read it first when the window does not appear). -Recommendation: 2, with the glow-then-wgpu fallback, as its own revision with the e2e `bar` -scenario as its gate (the window checks stop being skipped). Whether the guest's WARP accepts -wgpu's DX12 device (feature level, no HLSL compiler problem for egui's shaders) can only be -learned by running it; the first run should keep `RUST_LOG=wgpu_hal=debug` output in `bar.out`. +Cost, measured: 622 -> 664 distinct crate versions in the Windows bar's dependency tree (+42), one new +lock entry (`pollster` 0.4.0; the rest of the wgpu stack was already locked as optional dependencies of +eframe). Not measured here (no nix build was run): compile time and the size of `komorebi-bar.exe` +(estimate: a few minutes cold, 8 to 12 MB). + +Risks: WARP may not accept egui's Direct3D 12 device or the transparent surface the bar asks for +(`with_transparent(true)`; only the e2e gate can say); wgpu picks a hardware Vulkan/D3D12 adapter before +WARP when there is one, so on a machine with a GPU but broken OpenGL the bar now uses that adapter; a +second `run_native` on the same thread relies on eframe reusing its thread-local event loop (it does, by +design, for reopening windows). From ea996a917196c2460af970eecc72173d415aefa4 Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Sat, 31 Oct 2026 19:32:33 -0700 Subject: [PATCH 14/14] docs(core): section 23, design note for thin events (a common event vocabulary) Design only, nothing implemented (D-coord-13 (c)). Lists the three event vocabularies read from the window_manager_event.rs files (only Destroy, Show and Minimize share a name on all three), proposes a small CoreEvent produced by the platform adapters, sketches the shared handlers for Gone, Appeared and Minimized with platform hooks, orders the prerequisites (unmanaged check converged, shared WindowManager state, PlatformMonitorId, border hooks) and names the risks (side-effect order per arm, macOS FocusChange without a Window). Verified: docs only; claims about handler arms rest on section 17 and were not re-measured. --- docs/dev/core-model.md | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/docs/dev/core-model.md b/docs/dev/core-model.md index 10974f03..ebf44d9b 100644 --- a/docs/dev/core-model.md +++ b/docs/dev/core-model.md @@ -1409,3 +1409,41 @@ or field, so moving them means moving `WindowManager`, the blockers of section 1 `WorkAreaOffset`, ...): thin calls of `WindowManager` methods that edit a workspace and re-layout, the same coupling; - queries, configuration, borders, animations, transparency, schema: statics and the platform. + +## 23. Design note: thin events, a common vocabulary for `process_event` (not implemented) + +Status: design only (D-coord-13 (c)). Nothing here is built; the event enums and handlers are unchanged. The variant lists below were read from the three `window_manager_event.rs` files; how each handler arm behaves was read at section 17 and not re-measured here. + +**Today.** Each daemon has its own `WindowManagerEvent`, built from the platform notification: +- Windows: `Destroy, FocusChange, Hide, Cloak, Minimize, Show, Uncloak, MoveResizeStart, MoveResizeEnd, MouseCapture, Maximize, Unmaximize, Manage, Unmanage, Raise, TitleUpdate`, most carrying `(WinEvent, Window)`. +- KDE: `FocusChange, Show, Destroy, Minimize, Restore, TitleUpdate, FullscreenChange(bool), OutputChange, MaximizeChange(bool), Manage, Unmanage, MoveStart, MoveEnd, ResizeStart, ResizeEnd, ResizeStep, WorkspaceChange(desktop, idx), WorkspaceMove`, carrying `(SystemNotification, Window)`. +- macOS: `FocusChange, Show, Destroy, Minimize, Restore, Manage, Unmanage, MoveStart, MoveEnd, ResizeStart, ResizeStep, ResizeEnd, SpaceChange, ScreenLock, ScreenUnlock`, carrying a process id and a window id instead of a `Window`. + +Only `Destroy`, `Show` and `Minimize` exist under the same name on all three; `FocusChange`, `Manage`, `Unmanage`, `TitleUpdate` exist on Windows and KDE (macOS has the first three). The payloads differ: the platform notification, a `Window` or raw ids. So a shared `process_event` cannot match on today's enums. + +**Proposal.** A small enum in `komorebi-core`, generic over the platform's window id and window type, that the platform adapter produces from its notification and that describes what happened, not how the OS said it: + +```rust +pub enum CoreEvent { + Appeared(W), // Show, Manage, Uncloak, WindowAdded + Gone(W), // Destroy, Unmanage, Hide of a managed window + Minimized(W), // Minimize, Cloak on Windows + Restored(W), // Restore, Unminimize, Uncloak + FocusMoved(W), // FocusChange + MoveOrResize(Phase, W), // Start, Step, End for Windows MoveResize*, KDE and macOS Move/Resize + FullscreenOrMaximize(W, bool), + Retitled(W), + OutputChanged(W), + WorkspaceChanged(..), // KDE virtual desktop, macOS space: the platform tells which workspace +} +``` + +The Windows events that have no other-platform meaning (`MouseCapture`, `Raise`, `Cloak`/`Uncloak` distinctions) stay platform events: the adapter turns them into `CoreEvent` where they mean the same thing and handles the rest itself before or after. A handler for a `CoreEvent` is a `WindowManager` method with a platform hook for each decision the arms make today: `should_manage` (rules, already in `komorebi-rules` or in the daemon), whether the window is on this monitor, the border and transparency refresh after the layout, and the unmanaged-window check at the top (section 18 blocker; the router form is the target). + +**What a shared handler looks like.** For `Gone(w)`: find the container holding `w`, `Workspace::remove_window` (shared), prune empty containers, `update`, then the border hook. For `Appeared(w)`: ask the `should_manage` hook, find the target monitor and workspace through the (shared) rules, `Workspace::new_container_for_window`, `update`, focus hook. For `Minimized(w)`: shared `Workspace` already hides and updates. These three account for the arms the three process_event files share most (sections 17 and 18). + +**Prerequisites** (in order): the unmanaged-window-check converged to the router form on Windows (kfw); `WindowManager

` or at least a shared `WindowManagerState

` in core so the shared handler has a `self` (section 18 says the 60% threshold is not met yet); a `PlatformMonitorId`; the border calls behind hooks. Without the first two the shared handlers have nothing to run on. + +**Risks.** The ordering of side effects inside each arm is part of today's behaviour, for instance Windows doing the border update before the focus event is forwarded, and KDE debouncing `ResizeStep`; a shared handler must keep the order per platform through hooks, or the change is a BEHAVIOUR change needing the Windows e2e, the KDE VM suites and the macOS hand check. `FocusChange` on macOS carries an optional window id and there is no `Window` yet at that point, so the `CoreEvent` payload cannot always be a window. + +**Decision wanted from the owner.** Whether to pursue this after `WindowManager

` lands; the gain is the event-handling arms (about a third of `process_event.rs` by line count at section 17) running natively on a stub for all three platforms.