monolith

public

Star0

Fork 0

Watch0

206 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `25731952c6b8`

tarball

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

3 files changed+179-20

input: honour client move and resize requests on floating windows

xdg move_request and resize_request and their X11 stubs were no-ops, so clients with their own headerbars or resize handles could not drag a floating window. The Mod+drag state now takes any set of resize edges and a client button whose release is still forwarded, since the client saw the press.

Modified file: crates/monolith/src/input.rs+111 additions−12 deletions@@ -7,9 +7,11 @@ use smithay::backend::input::{ButtonState, InputTime, KeyState};
 use smithay::backend::session::Session;
 use smithay::input::keyboard::{FilterResult, Keycode, xkb};
 use smithay::input::pointer::{AxisFrame, ButtonEvent, CursorImageStatus, MotionEvent};
+use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
 use smithay::reexports::wayland_server::Resource;
 use smithay::utils::{Logical, Point, SERIAL_COUNTER};
 use smithay::wayland::shell::wlr_layer::Layer;
+use smithay::xwayland::xwm::ResizeEdge;
 
 impl State {
     pub fn pointer_to(&mut self, pos: Point<f64, Logical>, time: InputTime) {
@@ -42,8 +44,14 @@ impl State {
 
     pub fn pointer_button(&mut self, button: u32, pressed: ButtonState, time: InputTime) {
         self.activity();
-        if pressed == ButtonState::Released && self.input.drag.take().is_some() {
-            return;
+        if pressed == ButtonState::Released {
+            let ended = self
+                .input
+                .drag
+                .take_if(|d| d.button.is_none_or(|b| b == button));
+            if ended.is_some_and(|d| d.button.is_none()) {
+                return;
+            }
         }
         if pressed == ButtonState::Pressed && !self.services.lock.active() {
             focus_under_pointer(self);
@@ -236,13 +244,76 @@ impl State {
 
 const BTN_LEFT: u32 = 0x110;
 const BTN_RIGHT: u32 = 0x111;
+const MIN_SIZE: f64 = 32.0;
+
+/// The sides of a window a resize moves.
+#[derive(Clone, Copy, Default)]
+pub struct Edges {
+    left: bool,
+    right: bool,
+    top: bool,
+    bottom: bool,
+}
 
-/// A floating window being moved or resized with Mod and a mouse button.
+impl Edges {
+    const BOTTOM_RIGHT: Self = Self {
+        left: false,
+        right: true,
+        top: false,
+        bottom: true,
+    };
+
+    pub fn from_xdg(edge: xdg_toplevel::ResizeEdge) -> Option<Self> {
+        use xdg_toplevel::ResizeEdge as E;
+        let (left, right, top, bottom) = match edge {
+            E::Top => (false, false, true, false),
+            E::Bottom => (false, false, false, true),
+            E::Left => (true, false, false, false),
+            E::Right => (false, true, false, false),
+            E::TopLeft => (true, false, true, false),
+            E::TopRight => (false, true, true, false),
+            E::BottomLeft => (true, false, false, true),
+            E::BottomRight => (false, true, false, true),
+            _ => return None,
+        };
+        Some(Self {
+            left,
+            right,
+            top,
+            bottom,
+        })
+    }
+
+    pub fn from_x11(edge: ResizeEdge) -> Self {
+        let (left, right, top, bottom) = match edge {
+            ResizeEdge::Top => (false, false, true, false),
+            ResizeEdge::Bottom => (false, false, false, true),
+            ResizeEdge::Left => (true, false, false, false),
+            ResizeEdge::Right => (false, true, false, false),
+            ResizeEdge::TopLeft => (true, false, true, false),
+            ResizeEdge::TopRight => (false, true, true, false),
+            ResizeEdge::BottomLeft => (true, false, false, true),
+            ResizeEdge::BottomRight => (false, true, false, true),
+        };
+        Self {
+            left,
+            right,
+            top,
+            bottom,
+        }
+    }
+}
+
+/// A floating window being moved or resized, either with Mod and a mouse
+/// button or because its client asked while holding `button`.
 pub struct Drag {
     window: WindowId,
     from: Point<f64, Logical>,
     rect: Rect,
-    resize: bool,
+    /// None moves the window.
+    edges: Option<Edges>,
+    /// The client's button, whose release is still the client's to see.
+    button: Option<u32>,
 }
 
 fn start_drag(state: &mut State, button: u32) -> bool {
@@ -258,6 +329,22 @@ fn start_drag(state: &mut State, button: u32) -> bool {
     let Some(id) = state.wm.layout.focused() else {
         return false;
     };
+    if !held {
+        return false;
+    }
+    let edges = (button == BTN_RIGHT).then_some(Edges::BOTTOM_RIGHT);
+    begin_drag(state, id, edges, None)
+}
+
+impl State {
+    /// Starts moving, or with `edges` resizing, a floating window at a
+    /// client's request. Tiled windows are left alone.
+    pub fn client_drag(&mut self, id: WindowId, edges: Option<Edges>, button: u32) {
+        begin_drag(self, id, edges, Some(button));
+    }
+}
+
+fn begin_drag(state: &mut State, id: WindowId, edges: Option<Edges>, button: Option<u32>) -> bool {
     let Some(rect) = state
         .wm
         .layout
@@ -267,28 +354,40 @@ fn start_drag(state: &mut State, button: u32) -> bool {
     else {
         return false;
     };
-    if !held {
-        return false;
-    }
     state.input.drag = Some(Drag {
         window: id,
         from: state.input.pointer_pos,
         rect,
-        resize: button == BTN_RIGHT,
+        edges,
+        button,
     });
     true
 }
 
+fn resized(start: f64, len: f64, delta: f64, low: bool, high: bool) -> (f64, f64) {
+    if low {
+        let len_now = (len - delta).max(MIN_SIZE);
+        (start + len - len_now, len_now)
+    } else if high {
+        (start, (len + delta).max(MIN_SIZE))
+    } else {
+        (start, len)
+    }
+}
+
 fn drag_to(state: &mut State, pos: Point<f64, Logical>) -> bool {
     let Some(d) = &state.input.drag else {
         return false;
     };
     let (dx, dy) = (pos.x - d.from.x, pos.y - d.from.y);
     let r = d.rect;
-    let rect = if d.resize {
-        Rect::new(r.x, r.y, (r.w + dx).max(32.0), (r.h + dy).max(32.0))
-    } else {
-        Rect::new(r.x + dx, r.y + dy, r.w, r.h)
+    let rect = match d.edges {
+        Some(e) => {
+            let (x, w) = resized(r.x, r.w, dx, e.left, e.right);
+            let (y, h) = resized(r.y, r.h, dy, e.top, e.bottom);
+            Rect::new(x, y, w, h)
+        }
+        None => Rect::new(r.x + dx, r.y + dy, r.w, r.h),
     };
     let id = d.window;
     state.wm.layout.set_float_rect(id, rect);

Modified file: crates/monolith/src/xdg.rs+47 additions@@ -1,10 +1,14 @@
+use crate::input::Edges;
 use crate::state::State;
 use monolith_layout::OutputId;
 use smithay::desktop::{PopupKind, Window};
+use smithay::input::Seat;
+use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
 use smithay::reexports::wayland_protocols::xdg::decoration::zv1::server::zxdg_toplevel_decoration_v1::Mode as DecorationMode;
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::State as XdgState;
 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
 use smithay::reexports::wayland_server::protocol::wl_seat::WlSeat;
+use smithay::reexports::wayland_server::Resource;
 use smithay::utils::{Logical, Serial, Size};
 use smithay::wayland::shell::xdg::decoration::XdgDecorationHandler;
 use smithay::wayland::compositor::with_states;
@@ -46,6 +50,22 @@ impl XdgShellHandler for State {
         self.unmap_window(surface.wl_surface());
     }
 
+    fn move_request(&mut self, surface: ToplevelSurface, seat: WlSeat, serial: Serial) {
+        self.xdg_drag(&surface, &seat, serial, None);
+    }
+
+    fn resize_request(
+        &mut self,
+        surface: ToplevelSurface,
+        seat: WlSeat,
+        serial: Serial,
+        edges: xdg_toplevel::ResizeEdge,
+    ) {
+        if let Some(edges) = Edges::from_xdg(edges) {
+            self.xdg_drag(&surface, &seat, serial, Some(edges));
+        }
+    }
+
     fn fullscreen_request(&mut self, surface: ToplevelSurface, output: Option<WlOutput>) {
         self.set_fullscreen(&surface, true, output);
     }
@@ -102,6 +122,33 @@ fn server_side(toplevel: &ToplevelSurface) {
 }
 
 impl State {
+    /// Honours a move or resize only for a serial that is the press the
+    /// pointer is holding on one of the requesting client's surfaces.
+    fn xdg_drag(
+        &mut self,
+        surface: &ToplevelSurface,
+        seat: &WlSeat,
+        serial: Serial,
+        edges: Option<Edges>,
+    ) {
+        let Some(pointer) = Seat::<State>::from_resource(seat).and_then(|s| s.get_pointer()) else {
+            return;
+        };
+        let Some(start) = pointer.grab_start_data() else {
+            return;
+        };
+        let held_by_client = start
+            .focus
+            .as_ref()
+            .is_some_and(|(f, _)| f.id().same_client_as(&surface.wl_surface().id()));
+        if !pointer.has_grab(serial) || !held_by_client {
+            return;
+        }
+        if let Some(id) = self.window_id(surface.wl_surface()) {
+            self.client_drag(id, edges, start.button);
+        }
+    }
+
     /// A toplevel that has not mapped has no window to change, so its wish is
     /// kept in its pending state for `map_window` to find.
     fn set_fullscreen(&mut self, toplevel: &ToplevelSurface, on: bool, output: Option<WlOutput>) {

Modified file: crates/monolith/src/xwayland.rs+21 additions−8 deletions@@ -4,6 +4,7 @@
 //! leaves and the socket is watched again.
 
 use crate::focus::Focus;
+use crate::input::Edges;
 use crate::state::State;
 use monolith_config::SelectionAccess;
 use smithay::desktop::Window;
@@ -374,16 +375,13 @@ impl XwmHandler for State {
         }
     }
 
-    fn resize_request(
-        &mut self,
-        _xwm: XwmId,
-        _window: X11Surface,
-        _button: u32,
-        _edge: ResizeEdge,
-    ) {
+    fn resize_request(&mut self, _xwm: XwmId, window: X11Surface, _button: u32, edge: ResizeEdge) {
+        self.x11_drag(&window, Some(Edges::from_x11(edge)));
     }
 
-    fn move_request(&mut self, _xwm: XwmId, _window: X11Surface, _button: u32) {}
+    fn move_request(&mut self, _xwm: XwmId, window: X11Surface, _button: u32) {
+        self.x11_drag(&window, None);
+    }
 
     fn fullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
         self.x11_fullscreen(&window, true);
@@ -524,6 +522,21 @@ impl State {
             .map(|(id, _)| id)
     }
 
+    /// X11 requests carry no serial, so the pointer must be holding a press.
+    fn x11_drag(&mut self, window: &X11Surface, edges: Option<Edges>) {
+        let Some(start) = self
+            .input
+            .seat
+            .get_pointer()
+            .and_then(|p| p.grab_start_data())
+        else {
+            return;
+        };
+        if let Some(id) = self.x11_window_id(window) {
+            self.client_drag(id, edges, start.button);
+        }
+    }
+
     fn forget_x11(&mut self, window: &X11Surface) {
         if let Some(x) = self.services.xwayland.as_mut() {
             x.unmanaged.retain(|w| w != window);

monolith

Commit 25731952c6b8

Commit `25731952c6b8`