From 84080f879e91853444a283dcea1be99ae513e6d8 Mon Sep 17 00:00:00 2001 From: LGUG2Z Date: Fri, 30 Oct 2026 14:07:30 -0700 Subject: [PATCH] fix(wm): a title change does not make the daemon look at a window again --- docs/dev/ARCHITECTURE.md | 8 ++++---- komorebi/src/process_event.rs | 21 +++++--------------- komorebi/tests/rule_commands.rs | 35 +++++++++++++++++++++------------ 3 files changed, 31 insertions(+), 33 deletions(-) diff --git a/docs/dev/ARCHITECTURE.md b/docs/dev/ARCHITECTURE.md index 843f3218..21b34e90 100644 --- a/docs/dev/ARCHITECTURE.md +++ b/docs/dev/ARCHITECTURE.md @@ -709,10 +709,10 @@ the workspaces in front; `SessionFloatRule` adds a float rule made of the focuse executable, title and class, all three to be equal, and floats it, and `ClearSessionFloatRules` takes those rules out again. `GlobalState` answers with the ignore and the manage rules ([`GlobalState`]), and `DebugWindow` with what [`Window::should_manage`] read of a window and -which rules matched ([`RuleDebug`]). A rule decides when a window is shown; the bridge reports -a title change (`caption`), which is a `TitleUpdate` event, and a `TitleUpdate` about a window -the index does not have, and that is not minimized, is sent again as a `Show`, so that a rule -about the title it has now decides. +which rules matched ([`RuleDebug`]). A rule decides when a window is shown, by the title it has +then; the bridge reports a title change (`caption`), which is a `TitleUpdate` event, and the +window manager does nothing with it, so a window an ignore rule matched stays unmanaged when its +title changes, as in kfw. `TogglePause` sets [`WindowManager::is_paused`]: while it is set, `handle_event` returns at once for every event, and [`read_commands_uds`] hands only `TogglePause`, `State`, `GlobalState` and diff --git a/komorebi/src/process_event.rs b/komorebi/src/process_event.rs index f3cf7ab1..a762f856 100644 --- a/komorebi/src/process_event.rs +++ b/komorebi/src/process_event.rs @@ -41,8 +41,8 @@ //! of its own ([`WindowManager::adopt_maximize_change`]). The maximize and the restore that //! `ToggleMaximize` asks for come back as this event too, and change nothing. A window that //! opens maximized is taken the same way, after its Show. -//! - **TitleUpdate**: a window komorebi does not have, and that was not minimized, is announced -//! again as a Show, so that a rule that matches on the title it has now decides. +//! - **TitleUpdate**: nothing. The rules decide when a window opens; a window an ignore rule +//! matched stays unmanaged when its title changes, and a managed one stays managed, as in kfw. //! - **MoveStart** and **MoveEnd**: the user dragged a window with the pointer. When they let go //! on another monitor, the window's container goes there and takes the place of the container //! whose tile the pointer is on ([`WindowManager::transfer_window`]). When they let go on the @@ -112,10 +112,7 @@ use crate::window::live_resize_ends; use crate::window::should_act; use crate::window_manager::LiveResize; use crate::window_manager::WindowManager; -use crate::window_manager_event::KWinNotification; -use crate::window_manager_event::SystemNotification; use crate::window_manager_event::WindowManagerEvent; -use crate::window_manager_event_listener; use crate::workspace::WorkspaceLayer; use color_eyre::eyre; use color_eyre::eyre::OptionExt; @@ -556,17 +553,9 @@ impl WindowManager { } }, WindowManagerEvent::TitleUpdate(_, _) => { - // Windows are routinely announced before their title is set. Now that it is, a rule - // that matches on the title can finally decide, so a window that was not picked up - // gets another chance to be. - if !self.known_window_ids.contains_key(&window_id) - && !self.minimized_windows.contains_key(&window_id) - { - window_manager_event_listener::send_notification(WindowManagerEvent::Show( - SystemNotification::KWin(KWinNotification::WindowAdded), - window, - )); - } + // The rules decide when a window opens, by the title it has then. A later title + // change does not make the daemon look at the window again: one an ignore rule + // matched stays unmanaged, and one that is managed stays so. kfw does the same. } WindowManagerEvent::MoveStart(_, window) => { let window_id = window.id; diff --git a/komorebi/tests/rule_commands.rs b/komorebi/tests/rule_commands.rs index ae730253..5d3ee2a2 100644 --- a/komorebi/tests/rule_commands.rs +++ b/komorebi/tests/rule_commands.rs @@ -176,7 +176,7 @@ fn a_session_float_rule_floats_the_focused_window_and_the_ones_like_it_until_it_ } #[test] -fn a_window_whose_title_no_longer_matches_an_ignore_rule_is_tiled_when_the_title_changes() { +fn a_window_an_ignore_rule_matched_stays_unmanaged_when_its_title_changes() { let (fake, mut wm) = desktop(); send( &fake, @@ -195,19 +195,28 @@ fn a_window_whose_title_no_longer_matches_an_ignore_rule_is_tiled_when_the_title with_backend(fake.clone(), || wm.process_event(title_changed(29_031))).unwrap(); forget_ignore_rule("pending-29"); - // the title update announces the window again, on the channel the events thread reads + // the title change announces nothing: the window is not looked at again let events = window_manager_event_listener::event_rx(); - let shown = loop { - let event = events - .recv_timeout(Duration::from_secs(5)) - .expect("the window is announced again"); - if event.window_id() == Some(29_031) { - break event; - } - }; - assert!(matches!(shown, WindowManagerEvent::Show(..)), "{shown:?}"); - with_backend(fake.clone(), || wm.process_event(shown)).unwrap(); - assert_eq!(tiled(&wm), [29_031]); + let announced = std::iter::from_fn(|| events.recv_timeout(Duration::from_millis(300)).ok()) + .any(|event| event.window_id() == Some(29_031)); + assert!(!announced, "the window is not announced again"); + assert!(tiled(&wm).is_empty()); +} + +#[test] +fn a_managed_window_stays_managed_when_its_title_changes() { + let (fake, mut wm) = desktop(); + open( + &fake, + &mut wm, + 29_032, + ("browser-29", "org.example.browser", "a page"), + ); + assert_eq!(tiled(&wm), [29_032]); + + fake.set_title(29_032, "another page"); + with_backend(fake.clone(), || wm.process_event(title_changed(29_032))).unwrap(); + assert_eq!(tiled(&wm), [29_032]); } #[test]