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/crates/komorebi-core/src/command.rs b/crates/komorebi-core/src/command.rs index 712ee73e..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>; @@ -49,6 +43,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, @@ -100,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")?; @@ -138,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; @@ -173,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() @@ -367,3 +359,37 @@ 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<()> { + 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<()> { + 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/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() diff --git a/crates/komorebi-core/tests/commands.rs b/crates/komorebi-core/tests/commands.rs index f82f86ee..ab914aad 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,56 @@ 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()); } + +fn pointer_on_the_second_monitor() -> Host { + let mut host = two_monitors(); + host.pointer_on = Some(1); + host +} + +#[test] +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; the monitor under the pointer is focused first when its workspace is empty + for command in 0..5 { + let mut host = pointer_on_the_second_monitor(); + match command { + 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!(host.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/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). diff --git a/docs/dev/core-model.md b/docs/dev/core-model.md index a26aa3d9..c83df496 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): @@ -1409,3 +1409,87 @@ 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. + +## 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. 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/docs/dev/macos-handcheck.md b/docs/dev/macos-handcheck.md index 6ebaade9..48bd431a 100644 --- a/docs/dev/macos-handcheck.md +++ b/docs/dev/macos-handcheck.md @@ -97,6 +97,8 @@ 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. | +| 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. @@ -164,3 +166,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/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 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 } 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)); + } } 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-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(()) } 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); +} 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_command.rs b/komorebi-for-mac/komorebi/src/process_command.rs index da3e5181..3b3f0732 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; @@ -592,37 +593,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)? @@ -645,117 +619,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 +627,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 +818,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 +901,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 +1262,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 +1400,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; @@ -1759,6 +1724,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_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); diff --git a/komorebi/src/process_command.rs b/komorebi/src/process_command.rs index 6cc8c186..157260c7 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<()> { @@ -2293,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) } @@ -2324,6 +2285,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,