monolith

public

Star0

Fork 0

Watch0

184 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `2888d5881262`

tarball

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

5 files changed+186-35

popups: draw and hit-test popups above every window

scene.rs drew a window's popups with the window, so a menu from the left tile sat under the tile to its right and was cropped or clipped along with its window. Popups now draw in a pass of their own above all windows, and surface_under and window_at look at them first in the same order, so the surface a menu shows is the one that gets the click.

Modified file: crates/monolith/src/input.rs+3 additions@@ -172,6 +172,9 @@ 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) {
+        return state.window_id(&root);
+    }
     let (w, _) = state.wm.space.element_under(pos)?;
     state.window_id(&crate::wm::root(w)?)
 }

Modified file: crates/monolith/src/layers.rs+48 additions−2 deletions@@ -6,7 +6,10 @@ use crate::state::State;
 use monolith_layout::{Insets, OutputId};
 use monolith_render_vk::VulkanRenderer;
 use smithay::backend::renderer::element::AsRenderElements;
-use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
+use smithay::backend::renderer::element::Kind;
+use smithay::backend::renderer::element::surface::{
+    WaylandSurfaceRenderElement, render_elements_from_surface_tree,
+};
 use smithay::desktop::{LayerSurface, PopupKind, WindowSurfaceType, layer_map_for_output};
 use smithay::output::Output;
 use smithay::reexports::wayland_server::Resource;
@@ -213,6 +216,24 @@ impl State {
         })
     }
 
+    /// The popup of a layer surface below the windows under `pos`.
+    pub fn lower_popup_under(
+        &self,
+        pos: Point<f64, Logical>,
+    ) -> Option<(WlSurface, Point<f64, Logical>)> {
+        let output = self.wm.space.output_under(pos).next()?;
+        let origin = self.wm.space.output_geometry(output)?.loc;
+        let map = layer_map_for_output(output);
+        [Layer::Bottom, Layer::Background]
+            .into_iter()
+            .find_map(|layer| {
+                map.layers_on(layer).rev().find_map(|l| {
+                    let at = origin + map.layer_geometry(l)?.loc;
+                    crate::popups::hit(crate::popups::placed(l.wl_surface(), at), pos)
+                })
+            })
+    }
+
     /// The layer surface under `pos` on `layers`, with its surface origin.
     pub fn layer_under(
         &self,
@@ -239,12 +260,37 @@ pub fn elements(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, output: &Out
         let Some(geo) = map.layer_geometry(l) else {
             continue;
         };
+        let at = geo.loc.to_physical(1);
         let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =
-            l.render_elements(renderer, geo.loc.to_physical(1), Scale::from(1.0), 1.0);
+            if matches!(layer, Layer::Bottom | Layer::Background) {
+                render_elements_from_surface_tree(
+                    renderer,
+                    l.wl_surface(),
+                    at,
+                    1.0,
+                    1.0,
+                    Kind::Unspecified,
+                )
+            } else {
+                l.render_elements(renderer, at, Scale::from(1.0), 1.0)
+            };
         out.extend(elems.into_iter().map(Draw::Surface));
     }
 }
 
+/// The popups of the layer surfaces below the windows. Those surfaces draw
+/// without them, so a menu is not hidden by the window it opens over.
+pub fn lower_popups(out: &mut Vec<Draw>, renderer: &mut VulkanRenderer, output: &Output) {
+    let map = layer_map_for_output(output);
+    for layer in [Layer::Bottom, Layer::Background] {
+        for l in map.layers_on(layer).rev() {
+            if let Some(geo) = map.layer_geometry(l) {
+                crate::popups::elements(out, renderer, l.wl_surface(), geo.loc, 1.0);
+            }
+        }
+    }
+}
+
 /// With `covered`, a fullscreen window hides everything below the overlay
 /// layer, so only overlay surfaces are asked to draw.
 pub fn send_frames(output: &Output, elapsed: Duration, covered: bool) {

Modified file: crates/monolith/src/popups.rs+88 additions−4 deletions@@ -1,17 +1,22 @@
 //! xdg popups, from their grabs to where they are placed.
 
 use crate::focus::Focus;
+use crate::scene::Draw;
 use crate::state::State;
-use monolith_layout::Rect;
+use monolith_layout::{Rect, WindowId};
+use monolith_render_vk::VulkanRenderer;
+use smithay::backend::renderer::element::Kind;
+use smithay::backend::renderer::element::surface::render_elements_from_surface_tree;
+use smithay::desktop::utils::under_from_surface_tree;
 use smithay::desktop::{
-    PopupKeyboardGrab, PopupKind, PopupPointerGrab, PopupUngrabStrategy, WindowSurfaceType,
-    find_popup_root_surface, get_popup_toplevel_coords, layer_map_for_output,
+    PopupKeyboardGrab, PopupKind, PopupManager, PopupPointerGrab, PopupUngrabStrategy,
+    WindowSurfaceType, find_popup_root_surface, get_popup_toplevel_coords, layer_map_for_output,
 };
 use smithay::input::Seat;
 use smithay::input::pointer::Focus as GrabFocus;
 use smithay::reexports::wayland_server::protocol::wl_seat::WlSeat;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::utils::{Logical, Point, Rectangle, Serial};
+use smithay::utils::{Logical, Physical, Point, Rectangle, Serial};
 use smithay::wayland::shell::xdg::PopupSurface;
 
 impl State {
@@ -115,3 +120,82 @@ impl State {
         popup.with_pending_state(|s| s.geometry = s.positioner.get_unconstrained_geometry(target));
     }
 }
+
+/// The popup surfaces of `root` with where their origins are, newest first.
+/// `geometry_at` is where root's window geometry sits, which for a layer
+/// surface is where the surface itself sits.
+pub fn placed(
+    root: &WlSurface,
+    geometry_at: Point<i32, Logical>,
+) -> Vec<(WlSurface, Point<i32, Logical>)> {
+    PopupManager::popups_for_surface(root)
+        .map(|(popup, at)| {
+            (
+                popup.wl_surface().clone(),
+                geometry_at + at - popup.geometry().loc,
+            )
+        })
+        .collect()
+}
+
+/// The surface of `popups` under `pos`, with its origin.
+pub fn hit(
+    popups: Vec<(WlSurface, Point<i32, Logical>)>,
+    pos: Point<f64, Logical>,
+) -> Option<(WlSurface, Point<f64, Logical>)> {
+    popups.into_iter().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()))
+    })
+}
+
+/// Draws `root`'s popups with its window geometry at `geometry_at`.
+pub fn elements(
+    out: &mut Vec<Draw>,
+    renderer: &mut VulkanRenderer,
+    root: &WlSurface,
+    geometry_at: Point<i32, Logical>,
+    alpha: f32,
+) {
+    for (popup, at) in placed(root, geometry_at) {
+        let at = Point::<i32, Physical>::from((at.x, at.y));
+        out.extend(
+            render_elements_from_surface_tree(renderer, &popup, at, 1.0, alpha, Kind::Unspecified)
+                .into_iter()
+                .map(Draw::Surface),
+        );
+    }
+}
+
+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.
+    pub fn window_popup_under(
+        &self,
+        pos: Point<f64, Logical>,
+    ) -> 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) {
+                return None;
+            }
+            let (_, rect, _) = self.wm.get(id)?.placed?;
+            let (surface, at) = hit(placed(&root, whole(rect).loc), pos)?;
+            Some((root, surface, at))
+        })
+    }
+}

Modified file: crates/monolith/src/scene.rs+36 additions−25 deletions@@ -15,11 +15,10 @@ use smithay::backend::renderer::element::{AsRenderElements, Element, Id, Kind, R
 use smithay::backend::renderer::utils::with_renderer_surface_state;
 use smithay::backend::renderer::utils::{CommitCounter, DamageSet, OpaqueRegions};
 use smithay::backend::renderer::{ContextId, Renderer, Texture};
-use smithay::desktop::{PopupManager, Window};
+use smithay::desktop::Window;
 use smithay::output::Output;
 use smithay::utils::user_data::UserDataMap;
 use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
-use smithay::wayland::compositor::{TraversalAction, with_surface_tree_downward};
 use smithay::wayland::shell::wlr_layer::Layer;
 use smithay::xwayland::X11Surface;
 
@@ -121,6 +120,25 @@ pub fn build(
             crate::layers::elements(&mut out, renderer, output, Layer::Top);
         }
     }
+    let covering = arr.fullscreen.filter(|_| fullscreen_at_rest);
+    for &(id, r, _, _) in tiled.iter().chain(&above).rev() {
+        if covering.is_some_and(|f| f != id) {
+            continue;
+        }
+        let Some(root) = windows.get(id).and_then(|s| s.window.toplevel()) else {
+            continue;
+        };
+        let Some(((x, y), _)) = pixels(r) else {
+            continue;
+        };
+        let alpha = anim.effect(id, now).map_or(1.0, |e| e.progress);
+        crate::popups::elements(&mut out, renderer, root.wl_surface(), (x, y).into(), alpha);
+    }
+    if let Some(output) = output
+        && !fullscreen_at_rest
+    {
+        crate::layers::lower_popups(&mut out, renderer, output);
+    }
     for (g, frame, r) in fading.into_iter().rev() {
         out.extend(ghost_element(frame, r, anim.ghost_effect(g, now), deco));
     }
@@ -133,7 +151,7 @@ pub fn build(
         window_elements(&mut out, renderer, &state.window, r, effect, gliding);
         let clip = framed.then(|| corner_clip(r, deco)).flatten();
         if let Some(clip) = clip {
-            clip_window(&mut out, first, &state.window, clip);
+            clip_window(&mut out, first, clip);
         }
         if framed && deco.border > 0 {
             let color = if focused == Some(id) {
@@ -180,8 +198,17 @@ fn window_elements(
     let geo = window.geometry();
     let loc = Point::<i32, Physical>::from((x - geo.loc.x, y - geo.loc.y));
     let alpha = effect.map_or(1.0, |e| e.progress);
-    let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> =
-        window.render_elements(renderer, loc, Scale::from(1.0), alpha);
+    let elems: Vec<WaylandSurfaceRenderElement<VulkanRenderer>> = match window.toplevel() {
+        Some(t) => render_elements_from_surface_tree(
+            renderer,
+            t.wl_surface(),
+            loc,
+            1.0,
+            alpha,
+            Kind::Unspecified,
+        ),
+        None => window.render_elements(renderer, loc, Scale::from(1.0), alpha),
+    };
     if let Some(effect) = effect {
         effect_elements(out, renderer, window, elems, ((x, y), (w, h)), effect);
         return;
@@ -320,7 +347,7 @@ fn texture(
 }
 
 /// A window in a spawn transition. Its root surface goes through the effect
-/// shader, clamped to fill its rect, and its subsurfaces and popups fade with it.
+/// shader, clamped to fill its rect, and its subsurfaces fade with it.
 fn effect_elements(
     out: &mut Vec<Draw>,
     renderer: &mut VulkanRenderer,
@@ -471,26 +498,10 @@ fn corner_clip(r: Rect, deco: &Decoration) -> Option<Clip> {
     })
 }
 
-/// Clips what a window drew from `first` on, leaving its popups whole.
-fn clip_window(out: &mut [Draw], first: usize, window: &Window, clip: Clip) {
-    let mut popups = std::collections::HashSet::new();
-    if let Some(root) = crate::wm::root(window) {
-        for (popup, _) in PopupManager::popups_for_surface(&root) {
-            with_surface_tree_downward(
-                popup.wl_surface(),
-                (),
-                |_, _, _| TraversalAction::DoChildren(()),
-                |s, _, _| {
-                    popups.insert(Id::from_wayland_resource(s));
-                },
-                |_, _, _| true,
-            );
-        }
-    }
+/// Clips what a window drew from `first` on.
+fn clip_window(out: &mut [Draw], first: usize, clip: Clip) {
     for draw in &mut out[first..] {
-        if !popups.contains(draw.id()) {
-            wrap(draw, clip);
-        }
+        wrap(draw, clip);
     }
 }
 

Modified file: crates/monolith/src/state.rs+11 additions−4 deletions@@ -472,10 +472,7 @@ impl State {
                 return Some((s, (p + geo.loc).to_f64()));
             }
         }
-        let fullscreen = self.wm.layout.outputs().any(|(o, out)| {
-            let a = out.area;
-            a.contains(pos.x, pos.y) && self.wm.layout.arrange(o).fullscreen.is_some()
-        });
+        let fullscreen = self.fullscreen_at(pos).is_some();
         let above: &[Layer] = if fullscreen {
             &[Layer::Overlay]
         } else {
@@ -484,6 +481,16 @@ impl State {
         let layer = |layers| self.layer_under(pos, layers).map(|(_, s, p)| (s, p));
         layer(above)
             .or_else(|| {
+                self.window_popup_under(pos)
+                    .map(|(_, surface, origin)| (surface, origin))
+            })
+            .or_else(|| {
+                if fullscreen {
+                    return None;
+                }
+                self.lower_popup_under(pos)
+            })
+            .or_else(|| {
                 self.wm
                     .space
                     .element_under(pos)

monolith

Commit 2888d5881262

Commit `2888d5881262`