monolith

public

Star0

Fork 0

Watch0

252 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `ecb0c8c1f31d`

tarball

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

6 files changed+160-26

focus: keep focus on a window's modal dialog over the window

Focus aimed at a window with a mapped modal child used to land on the blocked parent, whichever path asked for it. Layout::focus and focused_on now resolve to the deepest modal dialog, fed from xdg_dialog_v1 and _NET_WM_STATE_MODAL, and the dialog sits above its parent in the focus history so closing it returns focus there.

Modified file: crates/layout/src/lib.rs+75 additions−17 deletions@@ -67,6 +67,8 @@ pub struct Window {
     pub fullscreen: bool,
     /// The window this one is a dialog or other transient of.
     pub parent: Option<WindowId>,
+    /// Focus aimed at the parent goes to this window while it is mapped.
+    pub modal: bool,
     pub sticky: bool,
     pub scratchpad: Option<usize>,
     pub urgent: bool,
@@ -140,6 +142,8 @@ pub struct Layout {
     active: Option<OutputId>,
     /// Focus history, most recent last.
     history: Vec<WindowId>,
+    /// How many windows are modal, so focus lookups skip the scan for one.
+    modals: usize,
     scratchpads: Vec<Scratchpad>,
     last_scratchpad: Option<usize>,
     parked: HashMap<String, Parked>,
@@ -162,6 +166,7 @@ impl Default for Layout {
             outputs: SlotMap::with_key(),
             active: None,
             history: Vec::new(),
+            modals: 0,
             scratchpads: Vec::new(),
             last_scratchpad: None,
             parked: HashMap::new(),
@@ -351,6 +356,7 @@ impl Layout {
             float_default: false,
             fullscreen: false,
             parent: None,
+            modal: false,
             sticky: false,
             scratchpad: None,
             urgent: false,
@@ -371,6 +377,7 @@ impl Layout {
         }
         self.unplace(w);
         self.history.retain(|&h| h != w);
+        self.modals -= usize::from(self.windows[w].modal);
         if let Some(s) = self.windows[w].scratchpad {
             self.leave_scratchpad(s, w);
         }
@@ -449,21 +456,71 @@ impl Layout {
         out.floating.retain(|&f| f != w);
     }
 
-    pub fn focus(&mut self, w: WindowId) {
-        let Some(win) = self.windows.get(w) else {
-            return;
-        };
-        self.active = win.output.or(self.active);
-        if let Some(o) = win.output {
-            let stack = &mut self.outputs[o].floating;
-            if let Some(i) = stack.iter().position(|&f| f == w) {
-                stack.remove(i);
-                stack.push(w);
+    /// Focuses `w`, or the deepest modal dialog over it, which is returned.
+    /// The windows between stay below it in the history, so closing the
+    /// dialog hands focus back to its parent.
+    pub fn focus(&mut self, mut w: WindowId) -> Option<WindowId> {
+        loop {
+            let win = self.windows.get(w)?;
+            self.active = win.output.or(self.active);
+            if let Some(o) = win.output {
+                let stack = &mut self.outputs[o].floating;
+                if let Some(i) = stack.iter().position(|&f| f == w) {
+                    stack.remove(i);
+                    stack.push(w);
+                }
+            }
+            self.history.retain(|&h| h != w);
+            self.history.push(w);
+            self.windows[w].urgent = false;
+            match self.modal_child(w) {
+                Some(child) => w = child,
+                None => return Some(w),
             }
         }
-        self.history.retain(|&h| h != w);
-        self.history.push(w);
-        self.windows[w].urgent = false;
+    }
+
+    /// Marks `w` as a modal dialog of its parent, or not.
+    pub fn set_modal(&mut self, w: WindowId, modal: bool) {
+        if let Some(win) = self.windows.get_mut(w)
+            && std::mem::replace(&mut win.modal, modal) != modal
+        {
+            self.modals = if modal {
+                self.modals + 1
+            } else {
+                self.modals - 1
+            };
+        }
+    }
+
+    /// The visible modal dialog of `w` on its output, the most recently
+    /// focused if it has several.
+    pub fn modal_child(&self, w: WindowId) -> Option<WindowId> {
+        if self.modals == 0 {
+            return None;
+        }
+        let output = self.windows.get(w)?.output;
+        self.windows
+            .iter()
+            .filter(|&(c, win)| {
+                win.modal && win.parent == Some(w) && win.output == output && self.visible(c)
+            })
+            .max_by_key(|&(c, _)| self.history.iter().rposition(|&h| h == c))
+            .map(|(c, _)| c)
+    }
+
+    /// The window that takes focus aimed at `w`, the deepest modal dialog
+    /// over it or `w` itself.
+    pub fn modal_leaf(&self, mut w: WindowId) -> WindowId {
+        while let Some(child) = self.modal_child(w) {
+            w = child;
+        }
+        w
+    }
+
+    /// Whether focus aimed at `w` would change nothing.
+    pub fn is_focused(&self, w: WindowId) -> bool {
+        self.focused() == Some(self.modal_leaf(w))
     }
 
     /// The most recently focused visible window on the active output. Focus
@@ -480,13 +537,15 @@ impl Layout {
             .rev()
             .copied()
             .find(|&w| self.windows[w].output == Some(o) && self.visible(w))
+            .map(|w| self.modal_leaf(w))
     }
 
     /// Focuses the nearest visible window in `dir`, crossing to the next
     /// output when there is none on this one.
     pub fn focus_dir(&mut self, dir: Dir) -> Option<WindowId> {
         let o = self.active?;
-        let from = self.focused_on(o).and_then(|f| self.rect_of(f));
+        let current = self.focused_on(o);
+        let from = current.and_then(|f| self.rect_of(f));
         let target = from.and_then(|from| {
             let arr = self.arrange(o);
             let reachable = |w| {
@@ -499,12 +558,11 @@ impl Layout {
                 .filter(|p| p.visible)
                 .map(|p| (p.window, p.rect))
                 .chain(arr.floating.iter().copied())
-                .filter(|&(w, _)| Some(w) != self.focused_on(o) && reachable(w));
+                .filter(|&(w, _)| Some(self.modal_leaf(w)) != current && reachable(w));
             nearest(from, dir, candidates)
         });
         if let Some(w) = target {
-            self.focus(w);
-            return Some(w);
+            return self.focus(w);
         }
         let next = self.output_towards(o, dir)?;
         self.active = Some(next);

Modified file: crates/layout/src/tests.rs+40 additions@@ -729,3 +729,43 @@ fn scratchpads_stay_centred_whatever_their_rect() {
     assert_eq!(r.x + r.w / 2.0, area.x + area.w / 2.0);
     assert_eq!(r.y, area.y);
 }
+
+/// Focus aimed at a window with a modal dialog lands on the deepest dialog
+/// from every path, and falls back to the parent once the dialog is gone.
+#[test]
+fn modal_dialogs_keep_focus_over_their_parent() {
+    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);
+    let dialog = l.add_window(None, None, Some(Rect::new(300.0, 200.0, 200.0, 100.0)));
+    let nested = l.add_window(None, None, Some(Rect::new(350.0, 250.0, 100.0, 50.0)));
+    l.set_parent(dialog, Some(parent));
+    l.set_parent(nested, Some(dialog));
+    l.set_modal(dialog, true);
+    assert_eq!(l.focused(), Some(dialog));
+    l.set_modal(nested, true);
+    assert_eq!(l.focused(), Some(nested));
+
+    l.focus(other);
+    assert_eq!(l.focused(), Some(other));
+    assert_eq!(l.focus(parent), Some(nested));
+    assert_eq!(l.focused(), Some(nested));
+    assert!(l.is_focused(parent));
+
+    l.focus(other);
+    for dir in [Dir::Left, Dir::Right, Dir::Up, Dir::Down] {
+        l.focus(other);
+        if let Some(w) = l.focus_dir(dir) {
+            assert_ne!(w, parent, "directional focus stopped on a blocked parent");
+        }
+    }
+
+    l.focus(parent);
+    l.remove_window(nested);
+    assert_eq!(l.focused(), Some(dialog));
+    l.remove_window(dialog);
+    assert_eq!(l.focused(), Some(parent));
+    l.check();
+}

Modified file: crates/monolith/src/input.rs+6 additions−9 deletions@@ -261,10 +261,9 @@ fn focus_under_pointer(state: &mut State) {
     }
     let id = window_at(state, pos);
     if let Some(id) = id
-        && state.wm.layout.focused() != Some(id)
+        && !state.wm.layout.is_focused(id)
     {
-        state.input.followed = Some(id);
-        state.wm.layout.focus(id);
+        state.input.followed = state.wm.layout.focus(id);
         state.apply_layout();
     }
 }
@@ -297,12 +296,11 @@ fn focus_on_hover(state: &mut State, pos: Point<f64, Logical>, warped: bool) {
     let Some(id) = under else {
         return;
     };
-    if state.wm.layout.focused() == Some(id) {
+    if state.wm.layout.is_focused(id) {
         return;
     }
     state.wm.layer_focus = None;
-    state.input.followed = Some(id);
-    state.wm.layout.focus(id);
+    state.input.followed = state.wm.layout.focus(id);
     state.apply_layout();
 }
 
@@ -561,10 +559,9 @@ fn start_drag(state: &mut State, button: u32) -> bool {
         let Some((id, edges)) = state.edge_at(pos, over).filter(|_| button == BTN_LEFT) else {
             return false;
         };
-        if state.wm.layout.focused() != Some(id) {
+        if !state.wm.layout.is_focused(id) {
             state.wm.layer_focus = None;
-            state.input.followed = Some(id);
-            state.wm.layout.focus(id);
+            state.input.followed = state.wm.layout.focus(id);
             state.apply_layout();
         }
         return begin_drag(state, id, Some(edges), None);

Modified file: crates/monolith/src/windows.rs+15 additions@@ -52,6 +52,7 @@ impl State {
             .add_window(output, tag, float.filter(|_| floating));
         let parent = self.parent_of(&window);
         self.wm.layout.set_parent(id, parent);
+        self.wm.layout.set_modal(id, is_modal(&window));
         if floating != self.wm.layout.window(id).is_some_and(|w| w.floating) {
             self.wm.layout.toggle_floating(id);
         }
@@ -100,6 +101,13 @@ impl State {
         self.window_id(&parent)
     }
 
+    /// Feeds the window's modal state to the layout and lets focus follow.
+    pub(crate) fn sync_modal(&mut self, id: WindowId) {
+        let modal = self.wm.window(id).is_some_and(is_modal);
+        self.wm.layout.set_modal(id, modal);
+        self.apply_layout();
+    }
+
     /// Holds a new window on its seed until its first buffer lands, so the
     /// spawn animation never plays over an empty slot. Clients that are slow
     /// to draw get it anyway after a while.
@@ -547,6 +555,13 @@ impl State {
 
 /// Whether the client has acknowledged the configure with `serial` or a later
 /// one.
+fn is_modal(window: &Window) -> bool {
+    match window.x11_surface() {
+        Some(x) => x.is_modal(),
+        None => window.toplevel().is_some_and(crate::xdg::is_modal),
+    }
+}
+
 fn acked(window: &Window, serial: Serial) -> bool {
     let Some(t) = window.toplevel() else {
         return true;

Modified file: crates/monolith/src/xdg.rs+9 additions@@ -35,6 +35,14 @@ pub fn is_dialog(toplevel: &ToplevelSurface) -> bool {
     toplevel.parent().is_some() || marked
 }
 
+/// A toplevel that asked to be modal through xdg_dialog_v1.
+pub fn is_modal(toplevel: &ToplevelSurface) -> bool {
+    with_states(toplevel.wl_surface(), |s| {
+        let role = s.data_map.get::<XdgToplevelSurfaceData>();
+        role.is_some_and(|r| r.lock().unwrap().dialog_hint == ToplevelDialogHint::Modal)
+    })
+}
+
 /// The size of a window that asks for exactly one.
 pub fn fixed_size(toplevel: &ToplevelSurface) -> Option<Size<i32, Logical>> {
     let (min, max) = size_hints(toplevel);
@@ -142,6 +150,7 @@ impl XdgDialogHandler for State {
     fn dialog_hint_changed(&mut self, surface: ToplevelSurface, _hint: ToplevelDialogHint) {
         if let Some(id) = self.window_id(surface.wl_surface()) {
             self.rematch(id);
+            self.sync_modal(id);
         }
     }
 }

Modified file: crates/monolith/src/xwayland.rs+15 additions@@ -399,6 +399,14 @@ impl XwmHandler for State {
         }
     }
 
+    fn modal_request(&mut self, _xwm: XwmId, window: X11Surface) {
+        self.x11_modal(&window, true);
+    }
+
+    fn unmodal_request(&mut self, _xwm: XwmId, window: X11Surface) {
+        self.x11_modal(&window, false);
+    }
+
     fn allow_selection_access(&mut self, xwm: XwmId, _selection: SelectionTarget) -> bool {
         self.settings.config.xwayland.selection_access == SelectionAccess::Any
             || matches!(
@@ -547,6 +555,13 @@ impl State {
         self.dirty.redraw = true;
     }
 
+    fn x11_modal(&mut self, window: &X11Surface, on: bool) {
+        logged("modal", window.set_modal(on));
+        if let Some(id) = self.x11_window_id(window) {
+            self.sync_modal(id);
+        }
+    }
+
     fn x11_fullscreen(&mut self, window: &X11Surface, on: bool) {
         if let Some(id) = self.x11_window_id(window)
             && self

monolith

Commit ecb0c8c1f31d

Commit `ecb0c8c1f31d`