monolith

public

Star0

Fork 0

Watch0

304 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `5c459f657de6`

tarball

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

5 files changed+58-48

popups: show and hit-test transients above a fullscreen window

A fullscreen window hid the popups of every other window, including the floating transients that Arrangement::over keeps above it, so a dialog's menus were neither drawn nor clickable. The fullscreen check is also now Layout::fullscreen_at, which reads the history instead of arranging the whole output, since each pointer motion made it three or four times. window_popup_under no longer collects a Vec of popups for every window it tests.

Modified file: crates/layout/src/lib.rs+43 additions−20 deletions@@ -852,6 +852,23 @@ impl Layout {
                 visible: vis(window),
             })
             .collect();
+        let floating = self.floating_on(o, out, vis);
+        let fullscreen = self.fullscreen_in(vis);
+        let over = fullscreen.map_or_else(Vec::new, |f| self.above_fullscreen(f, &floating));
+        Arrangement {
+            tiled,
+            floating,
+            fullscreen,
+            over,
+        }
+    }
+
+    fn floating_on(
+        &self,
+        o: OutputId,
+        out: &Output,
+        vis: &dyn Fn(WindowId) -> bool,
+    ) -> Vec<(WindowId, Rect)> {
         let mut floating: Vec<(WindowId, Rect)> = out
             .floating
             .iter()
@@ -868,31 +885,37 @@ impl Layout {
                 floating.push((sp.windows[i], centre_in(out.usable(), r.w, r.h)));
             }
         }
+        floating
+    }
+
+    fn fullscreen_in(&self, vis: &dyn Fn(WindowId) -> bool) -> Option<WindowId> {
         let is_fullscreen = |w: WindowId| self.windows[w].fullscreen && vis(w);
-        let fullscreen = self
-            .history
+        self.history
             .iter()
             .rev()
             .copied()
             .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) || self.windows[w].scratchpad.is_some())
-                    })
-                    .collect()
-            })
-            .unwrap_or_default();
-        Arrangement {
-            tiled,
-            floating,
-            fullscreen,
-            over,
-        }
+            .or_else(|| self.windows.keys().find(|&w| is_fullscreen(w)))
+    }
+
+    fn above_fullscreen(&self, f: WindowId, floating: &[(WindowId, Rect)]) -> Vec<WindowId> {
+        floating
+            .iter()
+            .map(|&(w, _)| w)
+            .filter(|&w| w != f && (self.descends(w, f) || self.windows[w].scratchpad.is_some()))
+            .collect()
+    }
+
+    /// The fullscreen window of the output under (x, y), with the floating
+    /// transients that stay above it. Cheaper than arranging the output.
+    pub fn fullscreen_at(&self, x: f64, y: f64) -> Option<(WindowId, Vec<WindowId>)> {
+        let (o, out) = self
+            .outputs
+            .iter()
+            .find(|(_, out)| out.area.contains(x, y))?;
+        let vis = self.vis_on(o);
+        let f = self.fullscreen_in(&vis)?;
+        Some((f, self.above_fullscreen(f, &self.floating_on(o, out, &vis))))
     }
 
     /// Records that `w` is a transient of `parent`.

Modified file: crates/monolith/src/input.rs+2 additions−1 deletions@@ -275,7 +275,8 @@ fn focus_under_pointer(state: &mut State) {
 }
 
 fn window_at(state: &State, pos: Point<f64, Logical>) -> Option<WindowId> {
-    if let Some((root, ..)) = state.window_popup_under(pos) {
+    let fullscreen = state.wm.layout.fullscreen_at(pos.x, pos.y);
+    if let Some((root, ..)) = state.window_popup_under(pos, fullscreen.as_ref()) {
         return state.window_id(&root);
     }
     let (w, _) = state.wm.space.element_under(pos)?;

Modified file: crates/monolith/src/popups.rs+8 additions−22 deletions@@ -165,25 +165,21 @@ impl State {
 pub fn placed(
     root: &WlSurface,
     geometry_at: Point<i32, Logical>,
-) -> Vec<(WlSurface, Point<i32, Logical>)> {
-    offsets(root)
-        .into_iter()
-        .map(|(popup, at)| (popup, geometry_at + at))
-        .collect()
+) -> impl Iterator<Item = (WlSurface, Point<i32, Logical>)> + use<> {
+    offsets(root).map(move |(popup, at)| (popup, geometry_at + at))
 }
 
-fn offsets(root: &WlSurface) -> Vec<(WlSurface, Point<i32, Logical>)> {
+fn offsets(root: &WlSurface) -> impl Iterator<Item = (WlSurface, Point<i32, Logical>)> + use<> {
     PopupManager::popups_for_surface(root)
         .map(|(popup, at)| (popup.wl_surface().clone(), at - popup.geometry().loc))
-        .collect()
 }
 
 /// The surface of `popups` under `pos`, with its origin.
 pub fn hit(
-    popups: Vec<(WlSurface, Point<i32, Logical>)>,
+    mut popups: impl Iterator<Item = (WlSurface, Point<i32, Logical>)>,
     pos: Point<f64, Logical>,
 ) -> Option<(WlSurface, Point<f64, Logical>)> {
-    popups.into_iter().find_map(|(popup, at)| {
+    popups.find_map(|(popup, at)| {
         let (s, p) =
             under_from_surface_tree(&popup, pos - at.to_f64(), (0, 0), WindowSurfaceType::ALL)?;
         Some((s, (p + at).to_f64()))
@@ -217,28 +213,18 @@ pub fn elements(
 }
 
 impl State {
-    /// The window covering the output under `pos` while it is fullscreen.
-    pub fn fullscreen_at(&self, pos: Point<f64, Logical>) -> Option<WindowId> {
-        self.wm.layout.outputs().find_map(|(o, out)| {
-            let a = out.area;
-            a.contains(pos.x, pos.y)
-                .then(|| self.wm.layout.arrange(o).fullscreen)
-                .flatten()
-        })
-    }
-
     /// The popup of a window under `pos`, frontmost window first, with the
     /// window's root surface. A fullscreen window hides the popups of the
-    /// windows below it.
+    /// windows below it, except those of the transients kept above it.
     pub fn window_popup_under(
         &self,
         pos: Point<f64, Logical>,
+        fullscreen: Option<&(WindowId, Vec<WindowId>)>,
     ) -> Option<(WlSurface, WlSurface, Point<f64, Logical>)> {
-        let fullscreen = self.fullscreen_at(pos);
         self.wm.space.elements().rev().find_map(|window| {
             let root = crate::wm::root(window).filter(|_| window.toplevel().is_some())?;
             let id = self.window_id(&root)?;
-            if fullscreen.is_some_and(|f| f != id) {
+            if fullscreen.is_some_and(|(f, over)| *f != id && !over.contains(&id)) {
                 return None;
             }
             let (_, rect, _) = self.wm.get(id)?.placed?;

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

@@ -137,7 +137,7 @@ pub fn build(

137137 }

138138 let covering = arr.fullscreen.filter(|_| fullscreen_at_rest);

139139 for &(id, r, _, _) in tiled.iter().chain(&above).rev() {

140- if covering.is_some_and(|f| f != id) {

140+ if covering.is_some_and(|f| f != id) && !arr.over.contains(&id) {

141141 continue;

142142 }

143143 let Some(root) = windows.get(id).and_then(|s| s.window.toplevel()) else {

Modified file: crates/monolith/src/state.rs+4 additions−4 deletions@@ -560,8 +560,8 @@ impl State {
                 return Some(other((s, (p + geo.loc).to_f64())));
             }
         }
-        let fullscreen = self.fullscreen_at(pos).is_some();
-        let above: &[Layer] = if fullscreen {
+        let fullscreen = self.wm.layout.fullscreen_at(pos.x, pos.y);
+        let above: &[Layer] = if fullscreen.is_some() {
             &[Layer::Overlay]
         } else {
             &[Layer::Overlay, Layer::Top]
@@ -569,11 +569,11 @@ impl State {
         let layer = |layers| self.layer_under(pos, layers).map(|(_, s, p)| (s, p));
         layer(above)
             .or_else(|| {
-                self.window_popup_under(pos)
+                self.window_popup_under(pos, fullscreen.as_ref())
                     .map(|(_, surface, origin)| (surface, origin))
             })
             .or_else(|| {
-                if fullscreen {
+                if fullscreen.is_some() {
                     return None;
                 }
                 self.lower_popup_under(pos)

monolith

Commit 5c459f657de6

Commit `5c459f657de6`