monolith

public

Star0

Fork 0

Watch0

248 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `fb4bcf5b1d29`

tarball

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

6 files changed+226-20

constraints: honour pointer lock and confine requests

The stub PointerConstraintsHandler never advertised the global, so Proton and SDL games could not capture the mouse. A constraint now activates only when its surface has pointer and keyboard focus, so a lock cannot trap the pointer on a window the keyboard has left, and it releases with the cursor position hint. While locked, focus-follows-mouse, mouse-follows-focus warps, Mod+drag and the resize hover are skipped.

Added file: crates/monolith/src/constraints.rs+202 additions@@ -0,0 +1,202 @@
+//! Pointer lock and confinement. A constraint is active while its surface
+//! has both pointer and keyboard focus and the pointer is inside its region,
+//! so a game that locks the mouse never traps it away from the window the
+//! keyboard went to.
+
+use crate::idle::root_surface;
+use crate::state::State;
+use smithay::backend::input::InputTime;
+use smithay::desktop::utils::bbox_from_surface_tree;
+use smithay::input::pointer::PointerHandle;
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::utils::{Logical, Point, Rectangle};
+use smithay::wayland::compositor::{RectangleKind, RegionAttributes};
+use smithay::wayland::pointer_constraints::{
+    ConstraintRemove, PointerConstraint, PointerConstraintsHandler, with_pointer_constraint,
+};
+use smithay::wayland::seat::WaylandFocus;
+
+pub enum Constraint {
+    Locked,
+    Confined {
+        surface: WlSurface,
+        region: Option<RegionAttributes>,
+    },
+}
+
+impl State {
+    pub fn pointer_constraint(&self) -> Option<Constraint> {
+        let pointer = self.input.seat.get_pointer()?;
+        let surface = pointer.current_focus()?;
+        with_pointer_constraint(&surface, &pointer, |c| {
+            let c = c.filter(|c| c.is_active())?;
+            Some(match &*c {
+                PointerConstraint::Locked(_) => Constraint::Locked,
+                PointerConstraint::Confined(_) => Constraint::Confined {
+                    surface: surface.clone(),
+                    region: c.region().cloned(),
+                },
+            })
+        })
+    }
+
+    pub fn pointer_locked(&self) -> bool {
+        matches!(self.pointer_constraint(), Some(Constraint::Locked))
+    }
+
+    /// Where a motion from `from` to `to` ends up inside a confinement,
+    /// at the nearest allowed point when `to` falls outside the region.
+    pub fn confine(
+        &self,
+        surface: &WlSurface,
+        region: Option<&RegionAttributes>,
+        from: Point<f64, Logical>,
+        to: Point<f64, Logical>,
+    ) -> Point<f64, Logical> {
+        let Some(origin) = self.origin_of(surface, from) else {
+            return to;
+        };
+        let bounds = bbox_from_surface_tree(surface, (0, 0));
+        let allowed = |p: Point<f64, Logical>| {
+            bounds.to_f64().contains(p) && region.is_none_or(|r| r.contains(p.to_i32_floor()))
+        };
+        let local = to - origin;
+        if allowed(local) {
+            return to;
+        }
+        let rects: Vec<Rectangle<i32, Logical>> = match region {
+            Some(r) => r
+                .rects
+                .iter()
+                .filter(|(kind, _)| matches!(kind, RectangleKind::Add))
+                .filter_map(|(_, rect)| rect.intersection(bounds))
+                .collect(),
+            None => vec![bounds],
+        };
+        let nearest = rects
+            .iter()
+            .map(|r| {
+                let r = r.to_f64();
+                Point::from((
+                    local
+                        .x
+                        .clamp(r.loc.x, (r.loc.x + r.size.w - 1.0).max(r.loc.x)),
+                    local
+                        .y
+                        .clamp(r.loc.y, (r.loc.y + r.size.h - 1.0).max(r.loc.y)),
+                ))
+            })
+            .filter(|p| allowed(*p))
+            .min_by(|a: &Point<f64, Logical>, b| {
+                let d = |p: &Point<f64, Logical>| (p.x - local.x).hypot(p.y - local.y);
+                d(a).total_cmp(&d(b))
+            });
+        nearest.map_or(from, |p| p + origin)
+    }
+
+    fn origin_of(
+        &self,
+        surface: &WlSurface,
+        at: Point<f64, Logical>,
+    ) -> Option<Point<f64, Logical>> {
+        self.surface_under(at)
+            .filter(|(s, _)| s == surface)
+            .map(|(_, origin)| origin)
+    }
+
+    fn constraint_eligible(&self, surface: &WlSurface) -> bool {
+        !self.services.lock.active()
+            && self.input.drag.is_none()
+            && self
+                .input
+                .seat
+                .get_keyboard()
+                .and_then(|k| k.current_focus())
+                .and_then(|f| f.wl_surface().map(|s| root_surface(&s)))
+                .is_some_and(|root| root == root_surface(surface))
+    }
+
+    /// Activates the pointer focus's constraint once it may apply, and
+    /// deactivates it when keyboard focus has moved off the surface.
+    pub fn sync_pointer_constraint(&mut self) {
+        let Some(pointer) = self.input.seat.get_pointer() else {
+            return;
+        };
+        let Some(surface) = pointer.current_focus() else {
+            return;
+        };
+        let state = with_pointer_constraint(&surface, &pointer, |c| {
+            c.map(|c| (c.is_active(), c.region().cloned()))
+        });
+        let Some((active, region)) = state else {
+            return;
+        };
+        let eligible = self.constraint_eligible(&surface);
+        if active && !eligible {
+            self.release_constraint(&surface, &pointer);
+        } else if !active && eligible && self.pointer_in(&surface, region.as_ref()) {
+            let locked = with_pointer_constraint(&surface, &pointer, |c| {
+                c.inspect(|c| c.activate())
+                    .is_some_and(|c| matches!(&*c, PointerConstraint::Locked(_)))
+            });
+            if locked {
+                self.input.hover = None;
+                self.dirty.cursor = true;
+            }
+        }
+    }
+
+    fn pointer_in(&self, surface: &WlSurface, region: Option<&RegionAttributes>) -> bool {
+        let pos = self.input.pointer_pos;
+        let Some(origin) = self.origin_of(surface, pos) else {
+            return false;
+        };
+        region.is_none_or(|r| r.contains((pos - origin).to_i32_floor()))
+    }
+
+    fn release_constraint(&mut self, surface: &WlSurface, pointer: &PointerHandle<State>) {
+        let hint = with_pointer_constraint(surface, pointer, |c| {
+            let c = c?;
+            let hint = match &*c {
+                PointerConstraint::Locked(l) => l.cursor_position_hint(),
+                PointerConstraint::Confined(_) => None,
+            };
+            c.deactivate();
+            hint
+        });
+        if let Some(hint) = hint {
+            self.warp_to_hint(surface, hint);
+        }
+    }
+
+    fn warp_to_hint(&mut self, surface: &WlSurface, hint: Point<f64, Logical>) {
+        let Some(origin) = self.origin_of(surface, self.input.pointer_pos) else {
+            return;
+        };
+        let target = origin + hint;
+        if self.origin_of(surface, target).is_some() {
+            self.warp_pointer(target, InputTime::now());
+        }
+    }
+}
+
+impl PointerConstraintsHandler for State {
+    fn new_constraint(&mut self, _surface: &WlSurface, _pointer: &PointerHandle<Self>) {
+        self.sync_pointer_constraint();
+    }
+
+    fn remove_constraint(
+        &mut self,
+        surface: &WlSurface,
+        _pointer: &PointerHandle<Self>,
+        remove: ConstraintRemove,
+    ) {
+        if let ConstraintRemove::Destroyed(constraint) = remove
+            && constraint.is_active()
+            && let PointerConstraint::Locked(lock) = &constraint
+            && let Some(hint) = lock.cursor_position_hint()
+        {
+            self.warp_to_hint(surface, hint);
+        }
+    }
+}

Modified file: crates/monolith/src/globals.rs+3 additions@@ -21,6 +21,7 @@ use smithay::wayland::image_capture_source::{
 };
 use smithay::wayland::image_copy_capture::ImageCopyCaptureState;
 use smithay::wayland::output::OutputManagerState;
+use smithay::wayland::pointer_constraints::PointerConstraintsState;
 use smithay::wayland::presentation::PresentationState;
 use smithay::wayland::relative_pointer::RelativePointerManagerState;
 use smithay::wayland::selection::data_device::DataDeviceState;
@@ -72,6 +73,7 @@ pub struct Protocols {
     _fractional_scale: FractionalScaleManagerState,
     _presentation: PresentationState,
     _relative_pointer: RelativePointerManagerState,
+    _pointer_constraints: PointerConstraintsState,
 }
 
 impl Protocols {
@@ -137,6 +139,7 @@ impl Protocols {
             _fractional_scale: FractionalScaleManagerState::new::<State>(dh),
             _presentation: PresentationState::new::<State>(dh, Monotonic::ID as u32),
             _relative_pointer: RelativePointerManagerState::new::<State>(dh),
+            _pointer_constraints: PointerConstraintsState::new::<State>(dh),
         }
     }
 }

Modified file: crates/monolith/src/input.rs+18 additions−2 deletions@@ -1,6 +1,7 @@
 //! Input handling shared by every backend. Backends translate their events
 //! into these calls, with pointer positions in global logical coordinates.
 
+use crate::constraints::Constraint;
 use crate::state::{Input, State};
 use crate::wm::Resizing;
 use monolith_layout::{Axis, Dir, Layout, MIN_FLOAT_SIZE, Rect, WindowId, clamp_float};
@@ -41,7 +42,19 @@ impl State {
             }
             Motion::Warp => Default::default(),
         };
-        let pos = wanted;
+        let constraint = self.pointer_constraint();
+        if let Some(Constraint::Locked) = constraint {
+            self.activity();
+            let under = self.surface_under(self.input.pointer_pos);
+            self.relative_motion(under, delta, unaccel, time);
+            return;
+        }
+        let pos = match &constraint {
+            Some(Constraint::Confined { surface, region }) => {
+                self.confine(surface, region.as_ref(), self.input.pointer_pos, wanted)
+            }
+            _ => wanted,
+        };
         self.input.pointer_pos = pos;
         self.follow_pointer_scale();
         self.activity();
@@ -73,6 +86,7 @@ impl State {
             self.input.cursor_status = CursorImageStatus::default_named();
             self.dirty.redraw = true;
         }
+        self.sync_pointer_constraint();
     }
 
     fn relative_motion(
@@ -125,7 +139,8 @@ impl State {
                 return;
             }
         }
-        if pressed == ButtonState::Pressed && !self.services.lock.active() {
+        if pressed == ButtonState::Pressed && !self.services.lock.active() && !self.pointer_locked()
+        {
             focus_under_pointer(self);
             if start_drag(self, button) {
                 return;
@@ -297,6 +312,7 @@ impl State {
             || !self.settings.config.general.mouse_follows_focus
             || self.backend.drm().is_none()
             || self.services.lock.active()
+            || self.pointer_locked()
         {
             return;
         }

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

@@ -4,6 +4,7 @@ mod backend;

44 mod capture;

55 mod commands;

66 mod commit;

7+mod constraints;

78 mod cursor;

89 mod devices;

910 mod drm;

Modified file: crates/monolith/src/seat.rs−17 deletions@@ -169,20 +169,3 @@ impl WaylandDndGrabHandler for State {
         }
     }
 }
-
-impl smithay::wayland::pointer_constraints::PointerConstraintsHandler for State {
-    fn new_constraint(
-        &mut self,
-        _surface: &WlSurface,
-        _pointer: &smithay::input::pointer::PointerHandle<Self>,
-    ) {
-    }
-
-    fn cursor_position_hint(
-        &mut self,
-        _surface: &WlSurface,
-        _pointer: &smithay::input::pointer::PointerHandle<Self>,
-        _location: smithay::utils::Point<f64, smithay::utils::Logical>,
-    ) {
-    }
-}

Modified file: crates/monolith/src/state.rs+2 additions−1 deletions@@ -468,8 +468,9 @@ impl State {
         if let Some(keyboard) = self.input.seat.get_keyboard()
             && keyboard.current_focus() != target
         {
-            keyboard.set_focus(self, target, SERIAL_COUNTER.next_serial());
+            keyboard.set_focus(self, target.clone(), SERIAL_COUNTER.next_serial());
         }
+        self.sync_pointer_constraint();
     }
 
     pub fn reconfigure_keyboard(&mut self) {

monolith

Commit fb4bcf5b1d29

Commit `fb4bcf5b1d29`