Add is-active window rule matcher

2 files changed, 63 insertions, 5 deletions

diff --git a/src/window/mapped.rs b/src/window/mapped.rs
index b5caf8e2..0d3a3ac1 100644
--- a/src/window/mapped.rs
+++ b/src/window/mapped.rs
@@ -1,5 +1,6 @@
 use std::cmp::{max, min};
 
+use niri_config::WindowRule;
 use smithay::backend::renderer::element::{AsRenderElements as _, Id};
 use smithay::desktop::space::SpaceElement as _;
 use smithay::desktop::Window;
@@ -11,7 +12,7 @@ use smithay::utils::{Logical, Point, Rectangle, Scale, Size, Transform};
 use smithay::wayland::compositor::{send_surface_state, with_states};
 use smithay::wayland::shell::xdg::{SurfaceCachedState, ToplevelSurface};
 
-use super::ResolvedWindowRules;
+use super::{ResolvedWindowRules, WindowRef};
 use crate::layout::{LayoutElement, LayoutElementRenderElement};
 use crate::niri::WindowOffscreenId;
 use crate::render_helpers::renderer::NiriRenderer;
@@ -22,16 +23,47 @@ pub struct Mapped {
 
     /// Up-to-date rules.
     pub rules: ResolvedWindowRules,
+
+    /// Whether the window rules need to be recomputed.
+    ///
+    /// This is not used in all cases; for example, app ID and title changes recompute the rules
+    /// immediately, rather than setting this flag.
+    pub need_to_recompute_rules: bool,
 }
 
 impl Mapped {
     pub fn new(window: Window, rules: ResolvedWindowRules) -> Self {
-        Self { window, rules }
+        Self {
+            window,
+            rules,
+            need_to_recompute_rules: false,
+        }
     }
 
     pub fn toplevel(&self) -> &ToplevelSurface {
         self.window.toplevel().expect("no X11 support")
     }
+
+    /// Recomputes the resolved window rules and returns whether they changed.
+    pub fn recompute_window_rules(&mut self, rules: &[WindowRule]) -> bool {
+        self.need_to_recompute_rules = false;
+
+        let new_rules = ResolvedWindowRules::compute(rules, WindowRef::Mapped(self));
+        if new_rules == self.rules {
+            return false;
+        }
+
+        self.rules = new_rules;
+        true
+    }
+
+    pub fn recompute_window_rules_if_needed(&mut self, rules: &[WindowRule]) -> bool {
+        if !self.need_to_recompute_rules {
+            return false;
+        }
+
+        self.recompute_window_rules(rules)
+    }
 }
 
 impl LayoutElement for Mapped {
@@ -155,8 +187,15 @@ impl LayoutElement for Mapped {
         data.0.replace(id);
     }
 
-    fn set_activated(&self, active: bool) {
-        self.window.set_activated(active);
+    fn set_activated(&mut self, active: bool) {
+        let changed = self.toplevel().with_pending_state(|state| {
+            if active {
+                state.states.set(xdg_toplevel::State::Activated)
+            } else {
+                state.states.unset(xdg_toplevel::State::Activated)
+            }
+        });
+        self.need_to_recompute_rules |= changed;
     }
 
     fn set_bounds(&self, bounds: Size<i32, Logical>) {
diff --git a/src/window/mod.rs b/src/window/mod.rs
index 4d225223..4ff943aa 100644
--- a/src/window/mod.rs
+++ b/src/window/mod.rs
@@ -1,4 +1,5 @@
 use niri_config::{Match, WindowRule};
+use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
 use smithay::wayland::compositor::with_states;
 use smithay::wayland::shell::xdg::{
     ToplevelSurface, XdgToplevelSurfaceData, XdgToplevelSurfaceRoleAttributes,
@@ -84,13 +85,18 @@ impl ResolvedWindowRules {
 
         let toplevel = window.toplevel();
         with_states(toplevel.wl_surface(), |states| {
-            let role = states
+            let mut role = states
                 .data_map
                 .get::<XdgToplevelSurfaceData>()
                 .unwrap()
                 .lock()
                 .unwrap();
 
+            // Ensure server_pending like in Smithay's with_pending_state().
+            if role.server_pending.is_none() {
+                role.server_pending = Some(role.current_server_state().clone());
+            }
+
             let mut open_on_output = None;
 
             for rule in rules {
@@ -150,6 +156,19 @@ impl ResolvedWindowRules {
 }
 
 fn window_matches(role: &XdgToplevelSurfaceRoleAttributes, m: &Match) -> bool {
+    // Must be ensured by the caller.
+    let server_pending = role.server_pending.as_ref().unwrap();
+
+    if let Some(is_active) = m.is_active {
+        // Our "is-active" definition corresponds to the window having a pending Activated state.
+        let pending_activated = server_pending
+            .states
+            .contains(xdg_toplevel::State::Activated);
+        if is_active != pending_activated {
+            return false;
+        }
+    }
+
     if let Some(app_id_re) = &m.app_id {
         let Some(app_id) = &role.app_id else {
             return false;