monolith

public

Star0

Fork 0

Watch0

154 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `b44dde08d7ac`

tarball

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

6 files changed+130-13

layout: keep a fullscreen window's transients above it

Fullscreen was raised last and alone received frame callbacks, while a new window still took focus, so a save dialog from a fullscreen game was focused but invisible. Layout now records transient parents and exposes the floating descendants of the fullscreen window as Arrangement::over, which scene, hit-testing and frame callbacks keep live above it. focus_dir no longer walks into covered windows, and a new non-transient window mapping under a fullscreen one does not take focus.

Modified file: crates/layout/src/lib.rs+60 additions−1 deletions@@ -65,6 +65,8 @@ pub struct Window {
     /// user chose.
     pub float_default: bool,
     pub fullscreen: bool,
+    /// The window this one is a dialog or other transient of.
+    pub parent: Option<WindowId>,
     pub sticky: bool,
     pub scratchpad: Option<usize>,
     evicted_from: Option<String>,
@@ -103,6 +105,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.
+    pub over: Vec<WindowId>,
 }
 
 #[derive(Clone, Copy, Debug)]
@@ -330,6 +334,7 @@ impl Layout {
             float_rect: floating,
             float_default: false,
             fullscreen: false,
+            parent: None,
             sticky: false,
             scratchpad: None,
             evicted_from: None,
@@ -352,6 +357,11 @@ impl Layout {
         if let Some(s) = self.windows[w].scratchpad {
             self.leave_scratchpad(s, w);
         }
+        for win in self.windows.values_mut() {
+            if win.parent == Some(w) {
+                win.parent = None;
+            }
+        }
         self.windows.remove(w);
     }
 
@@ -440,13 +450,17 @@ impl Layout {
         let from = self.focused_on(o).and_then(|f| self.rect_of(f));
         let target = from.and_then(|from| {
             let arr = self.arrange(o);
+            let reachable = |w| {
+                arr.fullscreen
+                    .is_none_or(|f| w == f || arr.over.contains(&w))
+            };
             let candidates = arr
                 .tiled
                 .iter()
                 .filter(|p| p.visible)
                 .map(|p| (p.window, p.rect))
                 .chain(arr.floating.iter().copied())
-                .filter(|&(w, _)| Some(w) != self.focused_on(o));
+                .filter(|&(w, _)| Some(w) != self.focused_on(o) && reachable(w));
             nearest(from, dir, candidates)
         });
         if let Some(w) = target {
@@ -703,11 +717,56 @@ impl Layout {
             .rev()
             .copied()
             .find(|&w| self.windows[w].fullscreen && vis(w));
+        let over = fullscreen
+            .map(|f| {
+                floating
+                    .iter()
+                    .map(|&(w, _)| w)
+                    .filter(|&w| w != f && self.descends(w, f))
+                    .collect()
+            })
+            .unwrap_or_default();
         Arrangement {
             tiled,
             floating,
             fullscreen,
+            over,
+        }
+    }
+
+    /// Records that `w` is a transient of `parent`.
+    pub fn set_parent(&mut self, w: WindowId, parent: Option<WindowId>) {
+        if parent.is_some_and(|p| p == w || self.descends(p, w)) {
+            return;
+        }
+        if let Some(win) = self.windows.get_mut(w) {
+            win.parent = parent;
+        }
+    }
+
+    fn descends(&self, mut w: WindowId, of: WindowId) -> bool {
+        for _ in 0..self.windows.len() {
+            match self.windows.get(w).and_then(|x| x.parent) {
+                Some(p) if p == of => return true,
+                Some(p) => w = p,
+                None => return false,
+            }
         }
+        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.
+    pub fn covered(&self, w: WindowId) -> bool {
+        let Some(win) = self.windows.get(w) else {
+            return false;
+        };
+        let Some(o) = win.output else {
+            return false;
+        };
+        let arr = self.arrange(o);
+        !win.fullscreen && arr.fullscreen.is_some_and(|f| f != w) && !arr.over.contains(&w)
     }
 
     #[cfg(test)]

Modified file: crates/layout/src/tests.rs+32 additions@@ -470,3 +470,35 @@ fn moves_are_seen_or_undone() {
         }
     }
 }
+
+/// A fullscreen window hides everything but its own transients, which stay
+/// reachable by focus and are not hidden when they map.
+#[test]
+fn fullscreen_leaves_its_transients_reachable() {
+    let mut l = Layout::default();
+    let o = l.add_output("a", AREA);
+    let beside = l.add_window(None, None, None);
+    l.focus(beside);
+    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.covered(stranger));
+    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.covered(dialog));
+    l.focus(dialog);
+
+    let arr = l.arrange(o);
+    assert_eq!(arr.fullscreen, Some(game));
+    assert_eq!(arr.over, vec![dialog]);
+    for dir in [Dir::Left, Dir::Right, Dir::Up, Dir::Down] {
+        if let Some(w) = l.focus_dir(dir) {
+            assert!(w == game || w == dialog, "focus walked to a covered window");
+        }
+    }
+
+    l.remove_window(game);
+    assert!(!l.covered(stranger));
+    assert_eq!(l.window(dialog).and_then(|w| w.parent), None);
+}

Modified file: crates/monolith/src/frame.rs+4 additions−4 deletions@@ -77,14 +77,14 @@ pub fn send_frame_callbacks(
         crate::lock::send_frames(lock, output, elapsed);
         return;
     }
-    let covering = wm
-        .layout
-        .arrange(o)
+    let arr = wm.layout.arrange(o);
+    let covering = arr
         .fullscreen
         .filter(|&w| wm.anim.gliding(w, now).is_none())
         .and_then(|w| wm.window(w));
+    let over: Vec<_> = arr.over.iter().filter_map(|&w| wm.window(w)).collect();
     for window in wm.space.elements_for_output(output) {
-        if covering.is_some_and(|c| c != window) {
+        if covering.is_some_and(|c| c != window && !over.contains(&window)) {
             continue;
         }
         window.send_frame(output, elapsed, Some(Duration::ZERO), |_, _| {

Modified file: crates/monolith/src/scene.rs+8 additions−4 deletions@@ -3,7 +3,7 @@
 
 use crate::wm::{LastFrame, Wm};
 use monolith_config::Decoration;
-use monolith_layout::{OutputId, Rect};
+use monolith_layout::{OutputId, Rect, WindowId};
 use monolith_render_vk::{Clip, Effect, VulkanFrame, VulkanRenderer, VulkanTexture};
 use smithay::backend::renderer::element::memory::MemoryRenderBufferRenderElement;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
@@ -89,14 +89,18 @@ pub fn build(
             }
         }
     }
-    for &(w, r) in &arr.floating {
+    let float = |&(w, r): &(WindowId, Rect)| {
         let glide = anim.gliding(w, now);
-        above.push((w, local(glide.unwrap_or(r)), true, glide.is_some()));
-    }
+        (w, local(glide.unwrap_or(r)), true, glide.is_some())
+    };
+    let (over, under): (Vec<_>, Vec<_>) =
+        arr.floating.iter().partition(|f| arr.over.contains(&f.0));
+    above.extend(under.into_iter().map(float));
     if let Some(w) = arr.fullscreen {
         let glide = anim.gliding(w, now);
         above.push((w, local(glide.unwrap_or(area)), false, glide.is_some()));
     }
+    above.extend(over.into_iter().map(float));
     let focused = layout.focused();
     let mut out = Vec::new();
     for x in unmanaged.iter().rev() {

Modified file: crates/monolith/src/state.rs+3 additions−1 deletions@@ -251,6 +251,7 @@ impl State {
         let now = now_ns();
         let mut shown = Vec::new();
         let mut tracks = Vec::new();
+        let mut over = Vec::new();
         let outputs: Vec<OutputId> = self.wm.layout.outputs().map(|(o, _)| o).collect();
         for o in outputs {
             let arr = self.wm.layout.arrange(o);
@@ -268,6 +269,7 @@ impl State {
             if let Some(w) = arr.fullscreen {
                 shown.push((w, area, Kind::Fullscreen, o));
             }
+            over.extend(arr.over.iter().copied());
             let held: Vec<WindowId> = arr
                 .tiled
                 .iter()
@@ -384,7 +386,7 @@ impl State {
         for window in hidden {
             self.wm.space.unmap_elem(&window);
         }
-        for id in mapped {
+        for id in mapped.into_iter().chain(over) {
             if let Some(window) = self.wm.window(id).cloned() {
                 self.wm.space.raise_element(&window, false);
             }

Modified file: crates/monolith/src/windows.rs+23 additions−3 deletions@@ -62,6 +62,8 @@ impl State {
             .wm
             .layout
             .add_window(output, tag, float.filter(|_| floating));
+        let parent = self.parent_of(&window);
+        self.wm.layout.set_parent(id, parent);
         if floating != self.wm.layout.window(id).is_some_and(|w| w.floating) {
             self.wm.layout.toggle_floating(id);
         }
@@ -84,12 +86,30 @@ impl State {
             s.reclassify = reclassify;
         }
         self.await_first_buffer(id);
-        if self.wm.layout.visible(id) {
+        if self.wm.layout.visible(id) && !self.wm.layout.covered(id) {
             self.wm.layout.focus(id);
         }
         self.apply_layout();
     }
 
+    /// The mapped window `window` is a dialog or other transient of.
+    fn parent_of(&self, window: &Window) -> Option<WindowId> {
+        if let Some(x) = window.x11_surface() {
+            let parent = x.is_transient_for()?;
+            return self
+                .wm
+                .iter()
+                .find(|(_, w)| {
+                    w.window
+                        .x11_surface()
+                        .is_some_and(|p| p.window_id() == parent)
+                })
+                .map(|(id, _)| id);
+        }
+        let parent = window.toplevel()?.parent()?;
+        self.window_id(&parent)
+    }
+
     /// 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.
@@ -264,9 +284,9 @@ impl State {
     fn float_at_natural_size(&mut self, id: WindowId, w: f64, h: f64) {
         let parent = self
             .wm
+            .layout
             .window(id)
-            .and_then(|win| win.toplevel()?.parent())
-            .and_then(|p| self.window_id(&p))
+            .and_then(|win| win.parent)
             .and_then(|p| self.wm.get(p)?.placed)
             .map(|(_, r, _)| r);
         let output = self

monolith

Commit b44dde08d7ac

Commit `b44dde08d7ac`