monolith

public

Star0

Fork 0

Watch0

210 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `e32c28d90a3d`

tarball

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

4 files changed+140-10

input: grab window borders to resize with a resize cursor

Resizing needed Mod or a client that asked for it, so tiles and bare floats could only be resized from the keyboard. A ring just outside each window, wider than the drawn border, now picks the edges or corner under the pointer, shows the matching resize cursor, and starts the same drag as Mod+right-drag on a left press. Edges of a tile with no neighbour across them are not grabbable.

Modified file: crates/monolith/src/cursor.rs+8 additions@@ -55,6 +55,14 @@ impl Cursor {
             CursorIcon::Progress,
             CursorIcon::EwResize,
             CursorIcon::NsResize,
+            CursorIcon::NResize,
+            CursorIcon::SResize,
+            CursorIcon::EResize,
+            CursorIcon::WResize,
+            CursorIcon::NwResize,
+            CursorIcon::NeResize,
+            CursorIcon::SwResize,
+            CursorIcon::SeResize,
         ] {
             cursor.image(icon);
         }

Modified file: crates/monolith/src/frame.rs+3 additions−5 deletions@@ -43,11 +43,9 @@ pub fn compose(
         if area.contains(pos.x, pos.y) {
             let local = pos - Point::from((area.x, area.y));
             if cursor {
-                elements.extend(ctx.input.cursor.elements(
-                    ctx.renderer,
-                    &ctx.input.cursor_status,
-                    local,
-                ));
+                let resize = ctx.input.resize_icon().map(CursorImageStatus::Named);
+                let status = resize.as_ref().unwrap_or(&ctx.input.cursor_status);
+                elements.extend(ctx.input.cursor.elements(ctx.renderer, status, local));
             }
             if let Some(icon) = &ctx.input.dnd_icon {
                 elements.extend(icon.elements(ctx.renderer, local));

Modified file: crates/monolith/src/input.rs+126 additions−5 deletions@@ -1,12 +1,12 @@
 //! Input handling shared by every backend. Backends translate their events
 //! into these calls, with pointer positions in global logical coordinates.
 
-use crate::state::State;
+use crate::state::{Input, State};
 use monolith_layout::{Axis, Dir, Layout, MIN_FLOAT_SIZE, Rect, WindowId, clamp_float};
 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::input::pointer::{AxisFrame, ButtonEvent, CursorIcon, 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};
@@ -26,6 +26,10 @@ impl State {
         focus_on_hover(self, pos, self.input.warping);
         let under = self.surface_under(pos);
         let before = pointer.current_focus().and_then(|s| s.client());
+        let hover = self.edge_at(pos, under.is_some()).map(|(_, e)| e);
+        if std::mem::replace(&mut self.input.hover, hover) != hover {
+            self.dirty.cursor = true;
+        }
         pointer.motion(
             self,
             under,
@@ -49,6 +53,12 @@ impl State {
                 .input
                 .drag
                 .take_if(|d| d.button.is_none_or(|b| b == button));
+            if ended.is_some() {
+                let pos = self.input.pointer_pos;
+                let over = self.surface_under(pos).is_some();
+                self.input.hover = self.edge_at(pos, over).map(|(_, e)| e);
+                self.dirty.cursor = true;
+            }
             if ended.is_some_and(|d| d.button.is_none()) {
                 return;
             }
@@ -302,6 +312,42 @@ impl Edges {
         self.left || self.right || self.top || self.bottom
     }
 
+    /// The edges whose ring of width hw around r holds pos, a corner when
+    /// pos is near the end of a side. None inside r or beyond the ring.
+    fn in_ring(r: Rect, pos: Point<f64, Logical>, hw: f64) -> Option<Self> {
+        let (left, right) = (pos.x < r.x, pos.x >= r.right());
+        let (top, bottom) = (pos.y < r.y, pos.y >= r.bottom());
+        let beyond = pos.x < r.x - hw
+            || pos.x >= r.right() + hw
+            || pos.y < r.y - hw
+            || pos.y >= r.bottom() + hw;
+        if beyond || !(left || right || top || bottom) {
+            return None;
+        }
+        let (cx, cy) = ((2.0 * hw).min(r.w / 2.0), (2.0 * hw).min(r.h / 2.0));
+        let sideways = (left || right) && !(top || bottom);
+        let lengthwise = (top || bottom) && !(left || right);
+        Some(Self {
+            left: left || (lengthwise && pos.x < r.x + cx),
+            right: right || (lengthwise && pos.x >= r.right() - cx),
+            top: top || (sideways && pos.y < r.y + cy),
+            bottom: bottom || (sideways && pos.y >= r.bottom() - cy),
+        })
+    }
+
+    pub fn icon(self) -> CursorIcon {
+        match (self.left, self.right, self.top, self.bottom) {
+            (true, _, true, _) => CursorIcon::NwResize,
+            (_, true, true, _) => CursorIcon::NeResize,
+            (true, _, _, true) => CursorIcon::SwResize,
+            (_, true, _, true) => CursorIcon::SeResize,
+            (true, ..) => CursorIcon::WResize,
+            (_, true, ..) => CursorIcon::EResize,
+            (_, _, true, _) => CursorIcon::NResize,
+            _ => CursorIcon::SResize,
+        }
+    }
+
     pub fn from_xdg(edge: xdg_toplevel::ResizeEdge) -> Option<Self> {
         use xdg_toplevel::ResizeEdge as E;
         let (left, right, top, bottom) = match edge {
@@ -358,6 +404,70 @@ pub struct Drag {
     button: Option<u32>,
 }
 
+impl Input {
+    /// The resize cursor to show over the client's own, if any.
+    pub fn resize_icon(&self) -> Option<CursorIcon> {
+        let edges = match &self.drag {
+            Some(d) => d.edges,
+            None => self.hover,
+        };
+        edges.map(Edges::icon)
+    }
+}
+
+impl State {
+    /// The window and edges of a resize grab at pos. Rings sit just outside
+    /// windows, so the client's own surface is never taken over, except
+    /// that a floating window's ring wins over a tile it overlaps.
+    fn edge_at(&self, pos: Point<f64, Logical>, over_surface: bool) -> Option<(WindowId, Edges)> {
+        if self.services.lock.active() {
+            return None;
+        }
+        let layout = &self.wm.layout;
+        let (o, out) = layout
+            .outputs()
+            .find(|(_, out)| out.area.contains(pos.x, pos.y))?;
+        let floats = !out.floating.is_empty()
+            || layout
+                .scratchpads()
+                .iter()
+                .any(|s| s.shown.is_some() && s.output == Some(o));
+        if over_surface && !floats {
+            return None;
+        }
+        let arr = layout.arrange(o);
+        if arr.fullscreen.is_some() {
+            return None;
+        }
+        let hw = f64::from(self.settings.config.decoration.border.max(4) + 4);
+        for &(w, r) in arr.floating.iter().rev() {
+            if r.contains(pos.x, pos.y) {
+                return None;
+            }
+            if let Some(e) = Edges::in_ring(r, pos, hw) {
+                return Some((w, e));
+            }
+        }
+        if over_surface {
+            return None;
+        }
+        let distance = |r: Rect| {
+            let dx = (r.x - pos.x).max(pos.x - r.right()).max(0.0);
+            let dy = (r.y - pos.y).max(pos.y - r.bottom()).max(0.0);
+            dx.hypot(dy)
+        };
+        arr.tiled
+            .iter()
+            .filter(|p| p.visible)
+            .filter_map(|p| {
+                let e = Edges::in_ring(p.rect, pos, hw)?.movable(layout, p.window);
+                e.any().then_some((p.window, e, distance(p.rect)))
+            })
+            .min_by(|a, b| a.2.total_cmp(&b.2))
+            .map(|(w, e, _)| (w, e))
+    }
+}
+
 fn start_drag(state: &mut State, button: u32) -> bool {
     if button != BTN_LEFT && button != BTN_RIGHT {
         return false;
@@ -368,12 +478,23 @@ fn start_drag(state: &mut State, button: u32) -> bool {
         .get_keyboard()
         .map(|k| k.modifier_state())
         .is_some_and(|m| crate::commands::held(&m).has(state.settings.config.general.mod_key));
+    if !held {
+        let pos = state.input.pointer_pos;
+        let over = state.surface_under(pos).is_some();
+        let Some((id, edges)) = state.edge_at(pos, over).filter(|_| button == BTN_LEFT) else {
+            return false;
+        };
+        if state.wm.layout.focused() != Some(id) {
+            state.wm.layer_focus = None;
+            state.input.followed = Some(id);
+            state.wm.layout.focus(id);
+            state.apply_layout();
+        }
+        return begin_drag(state, id, Some(edges), None);
+    }
     let Some(id) = state.wm.layout.focused() else {
         return false;
     };
-    if !held {
-        return false;
-    }
     let edges = match button {
         BTN_RIGHT => {
             let Some(rect) = window_rect(&state.wm.layout, id) else {

Modified file: crates/monolith/src/state.rs+3 additions@@ -60,6 +60,8 @@ pub struct Input {
     pub cursor: crate::cursor::Cursor,
     pub cursor_status: CursorImageStatus,
     pub dnd_icon: Option<crate::cursor::DndIcon>,
+    /// The edges of the window border under the pointer, for the resize cursor.
+    pub hover: Option<crate::input::Edges>,
 }
 
 /// What needs doing after this batch of events.
@@ -191,6 +193,7 @@ impl State {
                 cursor: crate::cursor::Cursor::load(),
                 cursor_status: CursorImageStatus::default_named(),
                 dnd_icon: None,
+                hover: None,
             },
             dirty: Dirty {
                 redraw: true,

monolith

Commit e32c28d90a3d

Commit `e32c28d90a3d`