monolith

public

Star0

Fork 0

Watch0

182 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `913b1f9fe652`

tarball

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

6 files changed+98-1

popups: take xdg popup grabs so menus close on outside clicks

XdgShellHandler::grab was empty, so GTK, Qt and quickshell menus never got popup_done when another client was clicked. The popup keyboard grab hands focus back to the grab's root, so button presses and after_dispatch resync with the layout's focus instead of leaving it on the window the menu came from. A locked session dismisses the popup instead of granting the grab, since a grab could take the keyboard from the lock surface.

Modified file: crates/monolith/src/focus.rs+18 additions@@ -3,6 +3,7 @@
 
 use crate::state::State;
 use smithay::backend::input::KeyState;
+use smithay::desktop::PopupKind;
 use smithay::input::Seat;
 use smithay::input::keyboard::{KeyboardTarget, KeysymHandle, ModifiersState};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
@@ -90,3 +91,20 @@ impl KeyboardTarget<State> for Focus {
         }
     }
 }
+
+impl From<PopupKind> for Focus {
+    fn from(p: PopupKind) -> Self {
+        Focus::Surface(p.wl_surface().clone())
+    }
+}
+
+impl From<Focus> for WlSurface {
+    fn from(f: Focus) -> Self {
+        match f {
+            Focus::Surface(s) => s,
+            Focus::X11(x) => x
+                .wl_surface()
+                .expect("popup grabs are rooted at wayland surfaces"),
+        }
+    }
+}

Modified file: crates/monolith/src/input.rs+4 additions@@ -54,6 +54,7 @@ impl State {
         let Some(pointer) = self.input.seat.get_pointer() else {
             return;
         };
+        let grabbed = self.keyboard_grabbed();
         pointer.button(
             self,
             &ButtonEvent {
@@ -63,6 +64,9 @@ impl State {
                 time,
             },
         );
+        if grabbed {
+            self.sync_focus();
+        }
     }
 
     pub fn pointer_axis(&mut self, frame: AxisFrame) {

Modified file: crates/monolith/src/main.rs+1

@@ -19,6 +19,7 @@ mod layers;

1919 mod lock;

2020 mod nested;

2121 mod pacing;

22+mod popups;

2223 mod power;

2324 mod scene;

2425 mod seat;

Added file: crates/monolith/src/popups.rs+69 additions@@ -0,0 +1,69 @@
+//! xdg popups, from their grabs to where they are placed.
+
+use crate::focus::Focus;
+use crate::state::State;
+use smithay::desktop::{
+    PopupKeyboardGrab, PopupKind, PopupPointerGrab, PopupUngrabStrategy, find_popup_root_surface,
+};
+use smithay::input::Seat;
+use smithay::input::pointer::Focus as GrabFocus;
+use smithay::reexports::wayland_server::protocol::wl_seat::WlSeat;
+use smithay::utils::Serial;
+use smithay::wayland::shell::xdg::PopupSurface;
+
+impl State {
+    /// Popup grabs are the only keyboard grabs, and they hand the focus back
+    /// to the grab's root, not to whatever the layout has focused, so the
+    /// callers resync once one may have ended.
+    pub fn keyboard_grabbed(&self) -> bool {
+        self.input
+            .seat
+            .get_keyboard()
+            .is_some_and(|k| k.is_grabbed())
+    }
+
+    /// Gives an explicit popup grab the keyboard and pointer, so clicking
+    /// elsewhere dismisses it. A locked session refuses grabs, since a
+    /// client could otherwise take the keyboard from the lock surface.
+    pub fn grab_popup(&mut self, surface: PopupSurface, seat: &WlSeat, serial: Serial) {
+        let Some(seat) = Seat::from_resource(seat) else {
+            return;
+        };
+        if self.services.lock.active() {
+            surface.send_popup_done();
+            return;
+        }
+        let kind = PopupKind::Xdg(surface);
+        let Ok(root) = find_popup_root_surface(&kind) else {
+            return;
+        };
+        let Ok(mut grab) = self
+            .wm
+            .popups
+            .grab_popup(Focus::from(root), kind, &seat, serial)
+        else {
+            return;
+        };
+        if let Some(keyboard) = seat.get_keyboard() {
+            if keyboard.is_grabbed()
+                && !(keyboard.has_grab(serial)
+                    || keyboard.has_grab(grab.previous_serial().unwrap_or(serial)))
+            {
+                grab.ungrab(PopupUngrabStrategy::All);
+                return;
+            }
+            keyboard.set_focus(self, grab.current_grab(), serial);
+            keyboard.set_grab(self, PopupKeyboardGrab::new(&grab), serial);
+        }
+        if let Some(pointer) = seat.get_pointer() {
+            if pointer.is_grabbed()
+                && !(pointer.has_grab(serial)
+                    || pointer.has_grab(grab.previous_serial().unwrap_or_else(|| grab.serial())))
+            {
+                grab.ungrab(PopupUngrabStrategy::All);
+                return;
+            }
+            pointer.set_grab(self, PopupPointerGrab::new(&grab), serial, GrabFocus::Keep);
+        }
+    }
+}

Modified file: crates/monolith/src/state.rs+3 additions@@ -213,6 +213,9 @@ impl State {
     pub fn after_dispatch(&mut self) {
         self.wm.space.refresh();
         self.wm.popups.cleanup();
+        if self.keyboard_grabbed() {
+            self.sync_focus();
+        }
         match self.backend {
             crate::backend::Backend::Drm(_) => crate::drm::render(self),
             crate::backend::Backend::Nested(_) => crate::nested::render(self),

Modified file: crates/monolith/src/xdg.rs+3 additions−1 deletions@@ -72,7 +72,9 @@ impl XdgShellHandler for State {
         surface.send_repositioned(token);
     }
 
-    fn grab(&mut self, _surface: PopupSurface, _seat: WlSeat, _serial: Serial) {}
+    fn grab(&mut self, surface: PopupSurface, seat: WlSeat, serial: Serial) {
+        self.grab_popup(surface, &seat, serial);
+    }
 }
 
 impl XdgDecorationHandler for State {

monolith

Commit 913b1f9fe652

Commit `913b1f9fe652`