monolith

public

Star0

Fork 0

Watch0

302 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `783f8b1b03c5`

tarball

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

5 files changed+101-19

popups: end popup grabs on lock and when focus moves to another root

lock() left the popup keyboard grab in place, and smithay's PopupKeyboardGrab ignores set_focus until it ends, so the password went to the client that owned the menu. The same grab survived binds and tag switches because sync_focus could not move the keyboard, and after_dispatch re-ran it on every dispatch. State now keeps the PopupGrab, ends it (popup_done plus seat grab release) on lock and when the layout's keyboard target changes root, and only resyncs once the grab has ended. Drag and drop is cancelled on lock and refused while locked.

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

Modified file: crates/monolith/src/lock.rs+24 additions−2 deletions@@ -4,6 +4,7 @@
 use crate::scene::Draw;
 use crate::state::State;
 use monolith_render_vk::VulkanRenderer;
+use smithay::backend::input::InputTime;
 use smithay::backend::renderer::element::Kind;
 use smithay::backend::renderer::element::surface::render_elements_from_surface_tree;
 use smithay::desktop::WindowSurfaceType;
@@ -11,11 +12,12 @@ use smithay::desktop::utils::{
     OutputPresentationFeedback, send_frames_surface_tree, take_presentation_feedback_surface_tree,
     under_from_surface_tree,
 };
+use smithay::input::pointer::MotionEvent;
 use smithay::output::Output;
 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::reexports::wayland_protocols::wp::presentation_time::server::wp_presentation_feedback::Kind as PresentationKind;
-use smithay::utils::{Logical, Point};
+use smithay::utils::{Logical, Point, SERIAL_COUNTER};
 use smithay::wayland::compositor::SurfaceData;
 use smithay::wayland::session_lock::{
     LockSurface, SessionLockHandler, SessionLockManagerState, SessionLocker,
@@ -83,7 +85,12 @@ impl SessionLockHandler for State {
         self.services.lock.pending = Some(confirmation);
         self.services.lock.blanked.clear();
         self.input.drag = None;
-        self.wm.resizing = None;
+        self.end_popup_grab();
+        self.cancel_dnd();
+        if self.wm.resizing.take().is_some() {
+            self.apply_layout();
+        }
+        self.refocus_pointer();
         self.sync_focus();
         self.dirty.redraw = true;
     }
@@ -126,6 +133,21 @@ fn configure(surface: &LockSurface, output: &Output) {
 }
 
 impl State {
+    fn refocus_pointer(&mut self) {
+        let Some(pointer) = self.input.seat.get_pointer() else {
+            return;
+        };
+        let location = self.input.pointer_pos;
+        let under = self.surface_under(location);
+        let event = MotionEvent {
+            location,
+            serial: SERIAL_COUNTER.next_serial(),
+            time: InputTime::now(),
+        };
+        pointer.motion(self, under, &event);
+        pointer.frame(self);
+    }
+
     /// Confirms a pending lock once every output has drawn without the
     /// windows, so nothing private is left on screen when the locker is told
     /// it holds the session.

Modified file: crates/monolith/src/popups.rs+47 additions−9 deletions@@ -5,6 +5,7 @@ use crate::scene::Draw;
 use crate::state::State;
 use monolith_layout::{Rect, WindowId};
 use monolith_render_vk::VulkanRenderer;
+use smithay::backend::input::InputTime;
 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;
@@ -16,18 +17,54 @@ 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, Physical, Point, Rectangle, Serial};
+use smithay::utils::{Logical, Physical, Point, Rectangle, SERIAL_COUNTER, Serial};
+use smithay::wayland::seat::WaylandFocus;
 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())
+    /// Ends the popup grab if it has run its course, and hands the keyboard
+    /// back to the layout, since a finished grab restores the focus to its own
+    /// root and not to whatever the layout has focused.
+    pub fn reap_popup_grab(&mut self) {
+        if self
+            .input
+            .popup_grab
+            .take_if(|grab| grab.has_ended())
+            .is_some()
+        {
+            self.sync_focus();
+        }
+    }
+
+    /// Whether the popup grab is rooted at `target`, or nothing is grabbed.
+    pub fn popup_grab_roots(&self, target: Option<&Focus>) -> bool {
+        let Some(grab) = &self.input.popup_grab else {
+            return true;
+        };
+        let root = grab.keyboard_grab_start_data().focus.as_ref();
+        let wl = |f: &Focus| f.wl_surface().map(|s| s.into_owned());
+        root.and_then(wl) == target.and_then(wl)
+    }
+
+    /// Dismisses the popup grab and every popup in it, and releases the seat
+    /// grabs it holds without moving the focus, which the caller sets next.
+    pub fn end_popup_grab(&mut self) {
+        let Some(mut grab) = self.input.popup_grab.take() else {
+            return;
+        };
+        grab.ungrab(PopupUngrabStrategy::All);
+        let serials = [Some(grab.serial()), grab.previous_serial()];
+        let seat = self.input.seat.clone();
+        if let Some(keyboard) = seat.get_keyboard()
+            && keyboard.is_grabbed()
+        {
+            keyboard.unset_grab(self);
+        }
+        if let Some(pointer) = seat.get_pointer()
+            && serials.into_iter().flatten().any(|s| pointer.has_grab(s))
+        {
+            pointer.unset_grab(self, SERIAL_COUNTER.next_serial(), InputTime::now());
+        }
     }
 
     /// Gives an explicit popup grab the keyboard and pointer, so clicking
@@ -63,6 +100,7 @@ impl State {
             keyboard.set_focus(self, grab.current_grab(), serial);
             keyboard.set_grab(self, PopupKeyboardGrab::new(&grab), serial);
         }
+        self.input.popup_grab = Some(grab.clone());
         if let Some(pointer) = seat.get_pointer() {
             if pointer.is_grabbed()
                 && !(pointer.has_grab(serial)

Modified file: crates/monolith/src/seat.rs+17 additions−1 deletions@@ -1,11 +1,12 @@
 use crate::cursor::DndIcon;
 use crate::state::State;
+use smithay::backend::input::InputTime;
 use smithay::input::dnd::{DnDGrab, DndGrabHandler, DndTarget, GrabType, Source};
 use smithay::input::pointer::{CursorImageStatus, Focus};
 use smithay::input::{Seat, SeatHandler, SeatState};
 use smithay::reexports::wayland_server::Resource;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::utils::{Logical, Point, Serial};
+use smithay::utils::{Logical, Point, SERIAL_COUNTER, Serial};
 use smithay::wayland::seat::WaylandFocus;
 use smithay::wayland::selection::data_device::{
     DataDeviceHandler, DataDeviceState, WaylandDndGrabHandler, set_data_device_focus,
@@ -122,6 +123,17 @@ impl DndGrabHandler for State {
 }
 
 impl State {
+    /// Drops whatever holds the pointer, which once popup grabs are gone is
+    /// a drag and drop or a client's button press.
+    pub fn cancel_dnd(&mut self) {
+        if let Some(pointer) = self.input.seat.get_pointer()
+            && pointer.is_grabbed()
+        {
+            pointer.unset_grab(self, SERIAL_COUNTER.next_serial(), InputTime::now());
+        }
+        self.end_dnd();
+    }
+
     fn end_dnd(&mut self) {
         self.input.dnd_icon = None;
         self.dirty.redraw = true;
@@ -141,6 +153,10 @@ impl WaylandDndGrabHandler for State {
         serial: Serial,
         type_: GrabType,
     ) {
+        if self.services.lock.active() {
+            source.cancel();
+            return;
+        }
         self.input.dnd_icon = icon.map(|surface| DndIcon {
             surface,
             offset: Point::default(),

Modified file: crates/monolith/src/state.rs+12 additions−3 deletions@@ -70,6 +70,10 @@ pub struct Input {
     /// one yields a relative delta even while the pointer is held in place.
     pub absolute: Option<Point<f64, Logical>>,
     pub inhibitor: Option<smithay::wayland::keyboard_shortcuts_inhibit::KeyboardShortcutsInhibitor>,
+    /// The explicit popup grab holding the keyboard and pointer, if any.
+    pub popup_grab: Option<smithay::desktop::PopupGrab<State>>,
+    /// What the layout last wanted the keyboard on, which a popup grab may be hiding.
+    pub focus_target: Option<Focus>,
 }
 
 /// What needs doing after this batch of events.
@@ -208,6 +212,8 @@ impl State {
                 pointer_output: None,
                 absolute: None,
                 inhibitor: None,
+                popup_grab: None,
+                focus_target: None,
             },
             dirty: Dirty {
                 redraw: true,
@@ -234,9 +240,7 @@ impl State {
     pub fn after_dispatch(&mut self) {
         self.wm.space.refresh();
         self.wm.popups.cleanup();
-        if self.keyboard_grabbed() {
-            self.sync_focus();
-        }
+        self.reap_popup_grab();
         match self.backend {
             crate::backend::Backend::Drm(_) => crate::drm::render(self),
             crate::backend::Backend::Nested(_) => crate::nested::render(self),
@@ -497,6 +501,11 @@ impl State {
                 }
             })
         };
+        if std::mem::replace(&mut self.input.focus_target, target.clone()) != target
+            && !self.popup_grab_roots(target.as_ref())
+        {
+            self.end_popup_grab();
+        }
         if let Some(keyboard) = self.input.seat.get_keyboard()
             && keyboard.current_focus() != target
         {

monolith

Commit 783f8b1b03c5

Commit `783f8b1b03c5`