monolith

public

Star0

Fork 0

Watch0

287 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `1c7e3075e57f`

tarball

atagen <boss@atagen.co>2026-10-19 10:50 UTC

5 files changed+166-16

layout: focus requests give way to a covering fullscreen window

Activation tokens, taskbar activation and scratchpad summons could focus a window hidden behind a fullscreen one, leaving the keyboard on something invisible. They now share focus_unless_covered, which flags the window urgent instead. A shown scratchpad counts like a fullscreen window's transient and stays above it, since the user asked for it. arrange also finds a fullscreen window that was never focused, as a focus=false rule makes, and a modal dialog now brings its parent up just beneath it so closing the dialog does not focus an unrelated window.

Modified file: crates/layout/src/lib.rs+43 additions−8 deletions@@ -72,6 +72,9 @@ pub struct Window {
     pub sticky: bool,
     pub scratchpad: Option<usize>,
     pub urgent: bool,
+    /// Its client took the buffer away, as when hiding to a tray. The entry
+    /// stays for when the client maps it again, but nothing shows or focuses it.
+    pub hidden: bool,
     evicted_from: Option<String>,
 }
 
@@ -121,7 +124,8 @@ pub struct Arrangement {
     /// Visible floating windows and shown scratchpads, bottom to top.
     pub floating: Vec<(WindowId, Rect)>,
     pub fullscreen: Option<WindowId>,
-    /// Floating transients of the fullscreen window, which stay above it.
+    /// Floating transients of the fullscreen window and shown scratchpads,
+    /// which stay above it.
     pub over: Vec<WindowId>,
 }
 
@@ -321,7 +325,7 @@ impl Layout {
         let Some(win) = self.windows.get(w) else {
             return false;
         };
-        let Some(o) = win.output else {
+        let Some(o) = win.output.filter(|_| !win.hidden) else {
             return false;
         };
         match win.scratchpad {
@@ -360,6 +364,7 @@ impl Layout {
             sticky: false,
             scratchpad: None,
             urgent: false,
+            hidden: false,
             evicted_from: None,
         });
         if let Some(o) = output {
@@ -457,7 +462,8 @@ impl Layout {
     }
 
     /// Focuses `w`, or the deepest modal dialog over it, which is returned.
-    /// The windows between stay below it in the history, so closing the
+    /// The windows between stay below it in the history, and a modal dialog
+    /// focused on its own brings its parent up beneath it, so closing the
     /// dialog hands focus back to its parent.
     pub fn focus(&mut self, mut w: WindowId) -> Option<WindowId> {
         loop {
@@ -470,8 +476,13 @@ impl Layout {
                     stack.push(w);
                 }
             }
+            let parent = win.parent.filter(|_| win.modal);
             self.history.retain(|&h| h != w);
             self.history.push(w);
+            if let Some(p) = parent {
+                self.history.retain(|&h| h != p);
+                self.history.insert(self.history.len() - 1, p);
+            }
             self.windows[w].urgent = false;
             match self.modal_child(w) {
                 Some(child) => w = child,
@@ -716,7 +727,7 @@ impl Layout {
     /// Flags a window that wants attention unless it already has the focus,
     /// and its tag too when the window is out of sight.
     pub fn mark_urgent(&mut self, w: WindowId) {
-        if !self.windows.contains_key(w) {
+        if self.windows.get(w).is_none_or(|win| win.hidden) {
             return;
         }
         if self.focused() != Some(w) {
@@ -805,6 +816,14 @@ impl Layout {
         }
     }
 
+    /// Hides `w` or shows it again, keeping everything else about it.
+    pub fn set_hidden(&mut self, w: WindowId, hidden: bool) {
+        if let Some(win) = self.windows.get_mut(w) {
+            win.hidden = hidden;
+            win.urgent &= !hidden;
+        }
+    }
+
     /// Target geometry for everything on `o`, in output-local logical
     /// coordinates offset by the output's area.
     pub fn arrange(&self, o: OutputId) -> Arrangement {
@@ -840,23 +859,28 @@ impl Layout {
         for sp in &self.scratchpads {
             if let Some(i) = sp.shown
                 && sp.output == Some(o)
+                && !self.windows[sp.windows[i]].hidden
                 && let Some(r) = self.windows[sp.windows[i]].float_rect
             {
                 floating.push((sp.windows[i], centre_in(out.usable(), r.w, r.h)));
             }
         }
+        let is_fullscreen = |w: WindowId| self.windows[w].fullscreen && vis(w);
         let fullscreen = self
             .history
             .iter()
             .rev()
             .copied()
-            .find(|&w| self.windows[w].fullscreen && vis(w));
+            .find(|&w| is_fullscreen(w))
+            .or_else(|| self.windows.keys().find(|&w| is_fullscreen(w)));
         let over = fullscreen
             .map(|f| {
                 floating
                     .iter()
                     .map(|&(w, _)| w)
-                    .filter(|&w| w != f && self.descends(w, f))
+                    .filter(|&w| {
+                        w != f && (self.descends(w, f) || self.windows[w].scratchpad.is_some())
+                    })
                     .collect()
             })
             .unwrap_or_default();
@@ -903,9 +927,20 @@ impl Layout {
         }
     }
 
+    /// Focuses `w` unless it is out of sight or a fullscreen window hides it,
+    /// flagging it urgent then. Returns whether it took the focus.
+    pub fn focus_unless_covered(&mut self, w: WindowId) -> bool {
+        if self.visible(w) && !self.covered(w) {
+            self.focus(w);
+            return true;
+        }
+        self.mark_urgent(w);
+        false
+    }
+
     /// Whether a fullscreen window on `w`'s output hides it. The fullscreen
-    /// window's transients are not hidden, and a window that is itself
-    /// fullscreen takes over.
+    /// window's transients and shown scratchpads are not hidden, and a window
+    /// that is itself fullscreen takes over.
     pub fn covered(&self, w: WindowId) -> bool {
         let Some(win) = self.windows.get(w) else {
             return false;

Modified file: crates/layout/src/scratchpad.rs+5 additions−5 deletions@@ -39,10 +39,10 @@ impl Layout {
         let s = self.scratchpads.iter().position(|sp| sp.name == name)?;
         let o = self.active?;
         let sp = &mut self.scratchpads[s];
-        let next = match sp.shown {
-            None => 0,
-            Some(i) => i + 1,
-        };
+        let mut next = sp.shown.map_or(0, |i| i + 1);
+        while sp.windows.get(next).is_some_and(|&w| self.windows[w].hidden) {
+            next += 1;
+        }
         if next >= sp.windows.len() {
             sp.shown = None;
             return None;
@@ -63,7 +63,7 @@ impl Layout {
             win.output = Some(o);
         }
         win.float_rect = win.float_rect.map(|r| centre_in(usable, r.w, r.h));
-        self.focus(w);
+        self.focus_unless_covered(w);
         Some(w)
     }
 

Modified file: crates/layout/src/tests.rs+115 additions@@ -769,3 +769,118 @@ fn modal_dialogs_keep_focus_over_their_parent() {
     assert_eq!(l.focused(), Some(parent));
     l.check();
 }
+
+/// A fullscreen window nobody ever focused, as a rule with `focus = false`
+/// makes, still takes the output once its tag is in view.
+#[test]
+fn fullscreen_does_not_need_focus_history() {
+    let mut l = Layout::default();
+    let o = l.add_output("a", AREA);
+    let (main, other) = (l.tag("main"), l.tag("other"));
+    l.view(o, main);
+    let shown = l.add_window(None, Some(main), None);
+    let player = l.add_window(None, Some(main), None);
+    l.toggle_fullscreen(player);
+    assert_eq!(l.arrange(o).fullscreen, Some(player));
+    assert!(l.covered(shown));
+
+    let hidden = l.add_window(None, Some(other), None);
+    l.toggle_fullscreen(hidden);
+    assert_eq!(l.arrange(o).fullscreen, Some(player));
+    l.focus(shown);
+    l.view(o, other);
+    assert_eq!(l.arrange(o).fullscreen, Some(hidden));
+}
+
+/// A request to focus a covered window flags it instead, but its own
+/// fullscreen window's transients and a summoned scratchpad take the focus.
+#[test]
+fn covered_windows_are_flagged_not_focused() {
+    let mut l = Layout::default();
+    let o = l.add_output("a", AREA);
+    let game = l.add_window(None, None, None);
+    l.focus(game);
+    l.toggle_fullscreen(game);
+    let stranger = l.add_window(None, None, None);
+    assert!(!l.focus_unless_covered(stranger));
+    assert_eq!(l.focused(), Some(game));
+    assert!(l.window(stranger).unwrap().urgent);
+
+    let dialog = l.add_window(None, None, Some(Rect::new(300.0, 200.0, 200.0, 100.0)));
+    l.set_parent(dialog, Some(game));
+    assert!(l.focus_unless_covered(dialog));
+    assert_eq!(l.focused(), Some(dialog));
+
+    let pad = l.add_window(None, None, None);
+    l.scratchpad_add(pad, "s");
+    assert_eq!(l.summon("s"), Some(pad));
+    assert_eq!(l.focused(), Some(pad));
+    assert!(l.arrange(o).over.contains(&pad));
+    l.check();
+}
+
+/// A window its client hid keeps its place, floating state, parent links and
+/// scratchpad, and comes back as it was when shown again.
+#[test]
+fn hidden_windows_come_back_as_they_were() {
+    let mut l = Layout::default();
+    let o = l.add_output("a", AREA);
+    let tag = l.tag("work");
+    l.view(o, tag);
+    let tray = l.add_window(None, Some(tag), Some(Rect::new(40.0, 50.0, 300.0, 200.0)));
+    let child = l.add_window(None, Some(tag), Some(Rect::new(60.0, 70.0, 100.0, 80.0)));
+    let tiled = l.add_window(None, Some(tag), None);
+    l.set_parent(child, Some(tray));
+    l.toggle_sticky(tray);
+    l.focus(tray);
+    l.focus(tiled);
+
+    l.set_hidden(tray, true);
+    assert!(!l.visible(tray));
+    assert!(l.arrange(o).floating.iter().all(|f| f.0 != tray));
+    assert!(!l.focus_unless_covered(tray));
+    assert!(!l.window(tray).unwrap().urgent);
+    assert_eq!(l.focused(), Some(tiled));
+    assert_eq!(l.window(child).and_then(|w| w.parent), Some(tray));
+
+    l.set_hidden(tray, false);
+    let w = l.window(tray).unwrap();
+    assert!(l.visible(tray));
+    assert!(w.floating && w.sticky && w.tag == tag);
+    assert_eq!(w.float_rect, Some(Rect::new(40.0, 50.0, 300.0, 200.0)));
+    assert!(l.arrange(o).floating.iter().any(|f| f.0 == tray));
+    l.check();
+}
+
+/// Summoning skips a scratchpad window that is hidden to a tray.
+#[test]
+fn summoning_skips_hidden_scratchpad_windows() {
+    let mut l = Layout::default();
+    let o = l.add_output("a", AREA);
+    let a = l.add_window(None, None, None);
+    let b = l.add_window(None, None, None);
+    l.scratchpad_add(a, "s");
+    l.scratchpad_add(b, "s");
+    l.set_hidden(a, true);
+    assert_eq!(l.summon("s"), Some(b));
+    assert!(l.arrange(o).floating.iter().all(|f| f.0 != a));
+    assert_eq!(l.summon("s"), None);
+}
+
+/// A modal dialog that takes focus on mapping puts its parent just beneath
+/// it, so closing it does not land on whatever was focused before the parent.
+#[test]
+fn a_modal_brings_its_parent_up_beneath_it() {
+    let mut l = Layout::default();
+    l.add_output("a", AREA);
+    let parent = l.add_window(None, None, None);
+    let other = l.add_window(None, None, None);
+    l.focus(parent);
+    l.focus(other);
+    let dialog = l.add_window(None, None, Some(Rect::new(300.0, 200.0, 200.0, 100.0)));
+    l.set_parent(dialog, Some(parent));
+    l.set_modal(dialog, true);
+    l.focus(dialog);
+    l.remove_window(dialog);
+    assert_eq!(l.focused(), Some(parent));
+}

Modified file: crates/monolith/src/activation.rs+2 additions−2 deletions@@ -63,8 +63,8 @@ impl XdgActivationHandler for State {
         let refused = self.wm.get(id).is_some_and(|w| w.rule.focus == Some(false));
         let may_focus =
             ctx.is_some_and(|c| c.may_focus) && data.timestamp.elapsed() < FRESH && !refused;
-        if may_focus && self.wm.layout.visible(id) {
-            self.wm.layout.focus(id);
+        if may_focus {
+            self.wm.layout.focus_unless_covered(id);
         } else {
             self.wm.layout.mark_urgent(id);
         }

Modified file: crates/monolith/src/toplevels.rs+1−1

@@ -33,7 +33,7 @@ impl ForeignToplevelHandler for State {

3333 let tag = w.tag;

3434 self.wm.layout.toggle_view(o, tag);

3535 }

36- self.wm.layout.focus(id);

36+ self.wm.layout.focus_unless_covered(id);

3737 }

3838 Action::Close(k) => {

3939 if let Some(window) = id_of(k).and_then(|id| self.wm.window(id)) {

monolith

Commit 1c7e3075e57f

Commit `1c7e3075e57f`