monolith

public

Star0

Fork 0

Watch0

319 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `846bdd33d84f`

tarball

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

6 files changed+450-437

input: move the mouse drag code into drag

Pointer and key dispatch shared a 750 line file with the resize rings, Drag and Edges, none of which touch the dispatch beyond three calls.

Added file: crates/monolith/src/drag.rs+440 additions@@ -0,0 +1,440 @@
+//! Mouse-driven moves and resizes, from the rings around floating windows
+//! to the splits between tiles.
+
+use crate::state::{Input, State};
+use crate::wm::Resizing;
+use monolith_layout::{Dir, Layout, MIN_FLOAT_SIZE, Rect, WindowId, clamp_float};
+use smithay::input::pointer::CursorIcon;
+use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
+use smithay::utils::{Logical, Point};
+use smithay::xwayland::xwm::ResizeEdge;
+
+const BTN_LEFT: u32 = 0x110;
+const BTN_RIGHT: u32 = 0x111;
+
+/// The sides of a window a resize moves.
+#[derive(Clone, Copy, Default, PartialEq, Eq)]
+pub struct Edges {
+    left: bool,
+    right: bool,
+    top: bool,
+    bottom: bool,
+}
+
+impl Edges {
+    /// The edges a drag from pos resizes, from the cell of a 3x3 grid over
+    /// the rect. The centre cell takes the nearest corner.
+    fn grid(r: Rect, pos: Point<f64, Logical>) -> Self {
+        let (fx, fy) = ((pos.x - r.x) / r.w, (pos.y - r.y) / r.h);
+        let third = |f: f64| match f {
+            f if f < 1.0 / 3.0 => -1,
+            f if f > 2.0 / 3.0 => 1,
+            _ => 0,
+        };
+        let (col, row) = match (third(fx), third(fy)) {
+            (0, 0) => (if fx < 0.5 { -1 } else { 1 }, if fy < 0.5 { -1 } else { 1 }),
+            cell => cell,
+        };
+        Self {
+            left: col < 0,
+            right: col > 0,
+            top: row < 0,
+            bottom: row > 0,
+        }
+    }
+
+    fn dirs(self) -> impl Iterator<Item = Dir> {
+        [
+            (Dir::Left, self.left),
+            (Dir::Right, self.right),
+            (Dir::Up, self.top),
+            (Dir::Down, self.bottom),
+        ]
+        .into_iter()
+        .filter_map(|(dir, on)| on.then_some(dir))
+    }
+
+    /// Drops the edges of a tiled window that have no split to move.
+    fn movable(self, layout: &Layout, id: WindowId) -> Self {
+        let has = |dir, on: bool| on && layout.has_split(id, dir);
+        Self {
+            left: has(Dir::Left, self.left),
+            right: has(Dir::Right, self.right),
+            top: has(Dir::Up, self.top),
+            bottom: has(Dir::Down, self.bottom),
+        }
+    }
+
+    fn any(self) -> bool {
+        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 {
+            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 {
+        use xdg_toplevel::ResizeEdge as E;
+        Self::from_xdg(match edge {
+            ResizeEdge::Top => E::Top,
+            ResizeEdge::Bottom => E::Bottom,
+            ResizeEdge::Left => E::Left,
+            ResizeEdge::Right => E::Right,
+            ResizeEdge::TopLeft => E::TopLeft,
+            ResizeEdge::TopRight => E::TopRight,
+            ResizeEdge::BottomLeft => E::BottomLeft,
+            ResizeEdge::BottomRight => E::BottomRight,
+        })
+        .unwrap_or_default()
+    }
+}
+
+/// What the pointer is over. Layer surfaces, popups and X11 menus keep the
+/// resize rings around windows from taking their clicks.
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub enum Cover {
+    Window,
+    Other,
+}
+
+/// 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,
+    bounds: Rect,
+    /// A tiled window, whose splits follow the pointer instead of a rect.
+    tiled: bool,
+    /// None moves the window.
+    edges: Option<Edges>,
+    /// The button the drag started with, whose release ends it.
+    pub(crate) button: u32,
+    /// Whether the client asked for the drag and so still sees the release.
+    pub(crate) client: bool,
+}
+
+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.
+    pub(crate) fn edge_at(
+        &self,
+        pos: Point<f64, Logical>,
+        cover: Option<Cover>,
+    ) -> Option<(WindowId, Edges)> {
+        if self.services.lock.active() || cover == Some(Cover::Other) {
+            return None;
+        }
+        let over_surface = cover.is_some();
+        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))
+    }
+}
+
+pub(crate) fn start_drag(state: &mut State, button: u32) -> bool {
+    if button != BTN_LEFT && button != BTN_RIGHT {
+        return false;
+    }
+    let held = !state.shortcuts_inhibited()
+        && state
+            .input
+            .seat
+            .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 cover = state.cover_under(pos).map(|c| c.2);
+        let Some((id, edges)) = state.edge_at(pos, cover).filter(|_| button == BTN_LEFT) else {
+            return false;
+        };
+        if !state.wm.layout.is_focused(id) {
+            state.wm.layer_focus = None;
+            state.input.followed = state.wm.layout.focus(id);
+            state.apply_layout();
+        }
+        return begin_drag(state, id, Some(edges), button, false);
+    }
+    let Some(id) = state.wm.layout.focused() else {
+        return false;
+    };
+    let edges = match button {
+        BTN_RIGHT => {
+            let Some(rect) = window_rect(&state.wm.layout, id) else {
+                return false;
+            };
+            Some(Edges::grid(rect, state.input.pointer_pos))
+        }
+        _ => None,
+    };
+    begin_drag(state, id, edges, button, false)
+}
+
+fn window_rect(layout: &Layout, id: WindowId) -> Option<Rect> {
+    let win = layout.window(id)?;
+    if win.floating {
+        return win.float_rect;
+    }
+    layout
+        .arrange(win.output?)
+        .tiled
+        .iter()
+        .find(|p| p.window == id && p.visible)
+        .map(|p| p.rect)
+}
+
+impl State {
+    pub fn forget_drag(&mut self, id: WindowId) {
+        self.input.drag.take_if(|d| d.window == id);
+        self.wm.resizing.take_if(|r| r.window == id);
+    }
+
+    /// 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) {
+        if self.wm.layout.window(id).is_some_and(|w| w.floating) {
+            begin_drag(self, id, edges, button, true);
+        }
+    }
+}
+
+fn begin_drag(
+    state: &mut State,
+    id: WindowId,
+    edges: Option<Edges>,
+    button: u32,
+    client: bool,
+) -> bool {
+    let layout = &state.wm.layout;
+    let Some(win) = layout.window(id).filter(|w| !w.fullscreen) else {
+        return false;
+    };
+    let tiled = !win.floating;
+    let edges = if tiled {
+        edges.map(|e| e.movable(layout, id)).filter(|e| e.any())
+    } else {
+        edges
+    };
+    if tiled && edges.is_none() {
+        return false;
+    }
+    let (Some(rect), Some(out)) = (
+        window_rect(layout, id),
+        win.output.and_then(|o| layout.output(o)),
+    ) else {
+        return false;
+    };
+    state.wm.resizing = win
+        .output
+        .filter(|_| edges.is_some())
+        .map(|output| Resizing {
+            output,
+            window: id,
+            tiled,
+        });
+    state.input.drag = Some(Drag {
+        window: id,
+        from: state.input.pointer_pos,
+        rect,
+        bounds: out.usable(),
+        tiled,
+        edges,
+        button,
+        client,
+    });
+    true
+}
+
+/// Moves the dragged edges of an axis, keeping them between lo and hi unless
+/// the window started beyond them, and the size between `limits`, whose
+/// minimum wins over its maximum.
+fn resized(
+    start: f64,
+    len: f64,
+    delta: f64,
+    edges: (bool, bool),
+    (lo, hi): (f64, f64),
+    (min, max): (f64, f64),
+) -> (f64, f64) {
+    let end = start + len;
+    match edges {
+        (true, _) => {
+            let edge = (start + delta)
+                .max(lo.min(start))
+                .max(end - max)
+                .min(end - min);
+            (edge, end - edge)
+        }
+        (_, true) => {
+            let edge = (end + delta)
+                .min(hi.max(end))
+                .min(start + max)
+                .max(start + min);
+            (start, edge - start)
+        }
+        _ => (start, len),
+    }
+}
+
+pub(crate) 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);
+    if let (true, Some(e)) = (d.tiled, d.edges) {
+        let (id, start) = (d.window, d.rect);
+        for dir in e.dirs() {
+            let Some(now) = window_rect(&state.wm.layout, id) else {
+                continue;
+            };
+            let (at, was, offset) = match dir {
+                Dir::Left => (now.x, start.x, dx),
+                Dir::Right => (now.right(), start.right(), dx),
+                Dir::Up => (now.y, start.y, dy),
+                Dir::Down => (now.bottom(), start.bottom(), dy),
+            };
+            state.wm.layout.move_split(id, dir, was + offset - at);
+        }
+        state.apply_layout();
+        return true;
+    }
+    let r = d.rect;
+    let rect = match d.edges {
+        Some(e) => {
+            let b = d.bounds;
+            let rule = state.wm.get(d.window).map(|s| &s.rule);
+            let (min_w, min_h) = rule.map_or((0.0, 0.0), |r| r.clamp_size(0.0, 0.0));
+            let (max_w, max_h) = rule.map_or((f64::INFINITY, f64::INFINITY), |r| {
+                r.clamp_size(f64::INFINITY, f64::INFINITY)
+            });
+            let min = (min_w.max(MIN_FLOAT_SIZE), min_h.max(MIN_FLOAT_SIZE));
+            let (x, w) = resized(
+                r.x,
+                r.w,
+                dx,
+                (e.left, e.right),
+                (b.x, b.right()),
+                (min.0, max_w),
+            );
+            let (y, h) = resized(
+                r.y,
+                r.h,
+                dy,
+                (e.top, e.bottom),
+                (b.y, b.bottom()),
+                (min.1, max_h),
+            );
+            Rect::new(x, y, w, h)
+        }
+        None => clamp_float(Rect::new(r.x + dx, r.y + dy, r.w, r.h), d.bounds),
+    };
+    let id = d.window;
+    state.wm.layout.set_float_rect(id, rect);
+    state.apply_layout();
+    true
+}

Modified file: crates/monolith/src/input.rs+4 additions−432 deletions@@ -2,21 +2,19 @@
 //! 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::{Dir, Layout, MIN_FLOAT_SIZE, Rect, WindowId, clamp_float};
+use crate::drag::{drag_to, start_drag};
+use crate::state::State;
+use monolith_layout::WindowId;
 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, CursorIcon, CursorImageStatus, MotionEvent, RelativeMotionEvent,
+    AxisFrame, ButtonEvent, CursorImageStatus, MotionEvent, RelativeMotionEvent,
 };
-use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
 use smithay::reexports::wayland_server::Resource;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::{Logical, Point, SERIAL_COUNTER};
 use smithay::wayland::shell::wlr_layer::Layer;
-use smithay::xwayland::xwm::ResizeEdge;
 
 /// How the pointer got to where a motion wants it.
 pub enum Motion {
@@ -333,429 +331,3 @@ impl State {
         );
     }
 }
-
-const BTN_LEFT: u32 = 0x110;
-const BTN_RIGHT: u32 = 0x111;
-
-/// The sides of a window a resize moves.
-#[derive(Clone, Copy, Default, PartialEq, Eq)]
-pub struct Edges {
-    left: bool,
-    right: bool,
-    top: bool,
-    bottom: bool,
-}
-
-impl Edges {
-    /// The edges a drag from pos resizes, from the cell of a 3x3 grid over
-    /// the rect. The centre cell takes the nearest corner.
-    fn grid(r: Rect, pos: Point<f64, Logical>) -> Self {
-        let (fx, fy) = ((pos.x - r.x) / r.w, (pos.y - r.y) / r.h);
-        let third = |f: f64| match f {
-            f if f < 1.0 / 3.0 => -1,
-            f if f > 2.0 / 3.0 => 1,
-            _ => 0,
-        };
-        let (col, row) = match (third(fx), third(fy)) {
-            (0, 0) => (if fx < 0.5 { -1 } else { 1 }, if fy < 0.5 { -1 } else { 1 }),
-            cell => cell,
-        };
-        Self {
-            left: col < 0,
-            right: col > 0,
-            top: row < 0,
-            bottom: row > 0,
-        }
-    }
-
-    fn dirs(self) -> impl Iterator<Item = Dir> {
-        [
-            (Dir::Left, self.left),
-            (Dir::Right, self.right),
-            (Dir::Up, self.top),
-            (Dir::Down, self.bottom),
-        ]
-        .into_iter()
-        .filter_map(|(dir, on)| on.then_some(dir))
-    }
-
-    /// Drops the edges of a tiled window that have no split to move.
-    fn movable(self, layout: &Layout, id: WindowId) -> Self {
-        let has = |dir, on: bool| on && layout.has_split(id, dir);
-        Self {
-            left: has(Dir::Left, self.left),
-            right: has(Dir::Right, self.right),
-            top: has(Dir::Up, self.top),
-            bottom: has(Dir::Down, self.bottom),
-        }
-    }
-
-    fn any(self) -> bool {
-        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 {
-            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 {
-        use xdg_toplevel::ResizeEdge as E;
-        Self::from_xdg(match edge {
-            ResizeEdge::Top => E::Top,
-            ResizeEdge::Bottom => E::Bottom,
-            ResizeEdge::Left => E::Left,
-            ResizeEdge::Right => E::Right,
-            ResizeEdge::TopLeft => E::TopLeft,
-            ResizeEdge::TopRight => E::TopRight,
-            ResizeEdge::BottomLeft => E::BottomLeft,
-            ResizeEdge::BottomRight => E::BottomRight,
-        })
-        .unwrap_or_default()
-    }
-}
-
-/// What the pointer is over. Layer surfaces, popups and X11 menus keep the
-/// resize rings around windows from taking their clicks.
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum Cover {
-    Window,
-    Other,
-}
-
-/// 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,
-    bounds: Rect,
-    /// A tiled window, whose splits follow the pointer instead of a rect.
-    tiled: bool,
-    /// None moves the window.
-    edges: Option<Edges>,
-    /// The button the drag started with, whose release ends it.
-    button: u32,
-    /// Whether the client asked for the drag and so still sees the release.
-    client: bool,
-}
-
-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>, cover: Option<Cover>) -> Option<(WindowId, Edges)> {
-        if self.services.lock.active() || cover == Some(Cover::Other) {
-            return None;
-        }
-        let over_surface = cover.is_some();
-        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;
-    }
-    let held = !state.shortcuts_inhibited()
-        && state
-            .input
-            .seat
-            .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 cover = state.cover_under(pos).map(|c| c.2);
-        let Some((id, edges)) = state.edge_at(pos, cover).filter(|_| button == BTN_LEFT) else {
-            return false;
-        };
-        if !state.wm.layout.is_focused(id) {
-            state.wm.layer_focus = None;
-            state.input.followed = state.wm.layout.focus(id);
-            state.apply_layout();
-        }
-        return begin_drag(state, id, Some(edges), button, false);
-    }
-    let Some(id) = state.wm.layout.focused() else {
-        return false;
-    };
-    let edges = match button {
-        BTN_RIGHT => {
-            let Some(rect) = window_rect(&state.wm.layout, id) else {
-                return false;
-            };
-            Some(Edges::grid(rect, state.input.pointer_pos))
-        }
-        _ => None,
-    };
-    begin_drag(state, id, edges, button, false)
-}
-
-fn window_rect(layout: &Layout, id: WindowId) -> Option<Rect> {
-    let win = layout.window(id)?;
-    if win.floating {
-        return win.float_rect;
-    }
-    layout
-        .arrange(win.output?)
-        .tiled
-        .iter()
-        .find(|p| p.window == id && p.visible)
-        .map(|p| p.rect)
-}
-
-impl State {
-    pub fn forget_drag(&mut self, id: WindowId) {
-        self.input.drag.take_if(|d| d.window == id);
-        self.wm.resizing.take_if(|r| r.window == id);
-    }
-
-    /// 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) {
-        if self.wm.layout.window(id).is_some_and(|w| w.floating) {
-            begin_drag(self, id, edges, button, true);
-        }
-    }
-}
-
-fn begin_drag(
-    state: &mut State,
-    id: WindowId,
-    edges: Option<Edges>,
-    button: u32,
-    client: bool,
-) -> bool {
-    let layout = &state.wm.layout;
-    let Some(win) = layout.window(id).filter(|w| !w.fullscreen) else {
-        return false;
-    };
-    let tiled = !win.floating;
-    let edges = if tiled {
-        edges.map(|e| e.movable(layout, id)).filter(|e| e.any())
-    } else {
-        edges
-    };
-    if tiled && edges.is_none() {
-        return false;
-    }
-    let (Some(rect), Some(out)) = (
-        window_rect(layout, id),
-        win.output.and_then(|o| layout.output(o)),
-    ) else {
-        return false;
-    };
-    state.wm.resizing = win
-        .output
-        .filter(|_| edges.is_some())
-        .map(|output| Resizing {
-            output,
-            window: id,
-            tiled,
-        });
-    state.input.drag = Some(Drag {
-        window: id,
-        from: state.input.pointer_pos,
-        rect,
-        bounds: out.usable(),
-        tiled,
-        edges,
-        button,
-        client,
-    });
-    true
-}
-
-/// Moves the dragged edges of an axis, keeping them between lo and hi unless
-/// the window started beyond them, and the size between `limits`, whose
-/// minimum wins over its maximum.
-fn resized(
-    start: f64,
-    len: f64,
-    delta: f64,
-    edges: (bool, bool),
-    (lo, hi): (f64, f64),
-    (min, max): (f64, f64),
-) -> (f64, f64) {
-    let end = start + len;
-    match edges {
-        (true, _) => {
-            let edge = (start + delta)
-                .max(lo.min(start))
-                .max(end - max)
-                .min(end - min);
-            (edge, end - edge)
-        }
-        (_, true) => {
-            let edge = (end + delta)
-                .min(hi.max(end))
-                .min(start + max)
-                .max(start + min);
-            (start, edge - start)
-        }
-        _ => (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);
-    if let (true, Some(e)) = (d.tiled, d.edges) {
-        let (id, start) = (d.window, d.rect);
-        for dir in e.dirs() {
-            let Some(now) = window_rect(&state.wm.layout, id) else {
-                continue;
-            };
-            let (at, was, offset) = match dir {
-                Dir::Left => (now.x, start.x, dx),
-                Dir::Right => (now.right(), start.right(), dx),
-                Dir::Up => (now.y, start.y, dy),
-                Dir::Down => (now.bottom(), start.bottom(), dy),
-            };
-            state.wm.layout.move_split(id, dir, was + offset - at);
-        }
-        state.apply_layout();
-        return true;
-    }
-    let r = d.rect;
-    let rect = match d.edges {
-        Some(e) => {
-            let b = d.bounds;
-            let rule = state.wm.get(d.window).map(|s| &s.rule);
-            let (min_w, min_h) = rule.map_or((0.0, 0.0), |r| r.clamp_size(0.0, 0.0));
-            let (max_w, max_h) = rule.map_or((f64::INFINITY, f64::INFINITY), |r| {
-                r.clamp_size(f64::INFINITY, f64::INFINITY)
-            });
-            let min = (min_w.max(MIN_FLOAT_SIZE), min_h.max(MIN_FLOAT_SIZE));
-            let (x, w) = resized(
-                r.x,
-                r.w,
-                dx,
-                (e.left, e.right),
-                (b.x, b.right()),
-                (min.0, max_w),
-            );
-            let (y, h) = resized(
-                r.y,
-                r.h,
-                dy,
-                (e.top, e.bottom),
-                (b.y, b.bottom()),
-                (min.1, max_h),
-            );
-            Rect::new(x, y, w, h)
-        }
-        None => clamp_float(Rect::new(r.x + dx, r.y + dy, r.w, r.h), d.bounds),
-    };
-    let id = d.window;
-    state.wm.layout.set_float_rect(id, rect);
-    state.apply_layout();
-    true
-}

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

@@ -7,6 +7,7 @@ mod commit;

77 mod constraints;

88 mod cursor;

99 mod devices;

10+mod drag;

1011 mod drm;

1112 mod fifo;

1213 mod focus;

Modified file: crates/monolith/src/state.rs+3 additions−3 deletions@@ -1,9 +1,9 @@
 use crate::anim::Animator;
 use crate::backend::logical_area;
 use crate::commands::Binds;
+use crate::drag::Cover;
 use crate::focus::Focus;
 use crate::globals::Protocols;
-use crate::input::Cover;
 use crate::wm::{Kind, Wm, configure};
 use monolith_config::Config;
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
@@ -52,7 +52,7 @@ pub struct Input {
     pub pointer_pos: Point<f64, Logical>,
     /// Keys whose press ran a bind, so their release is swallowed too.
     pub suppressed: Vec<Keycode>,
-    pub drag: Option<crate::input::Drag>,
+    pub drag: Option<crate::drag::Drag>,
     pub move_inverted: bool,
     /// The focus mouse-follows-focus last saw, so pointer-made focus
     /// changes can mark themselves as already followed.
@@ -65,7 +65,7 @@ pub struct Input {
     pub dnd_icon: Option<crate::cursor::DndIcon>,
     pub dnd: bool,
     /// The edges of the window border under the pointer, for the resize cursor.
-    pub hover: Option<crate::input::Edges>,
+    pub hover: Option<crate::drag::Edges>,
     /// The output the pointer was last on, whose scale cursor and drag icon surfaces follow.
     pub pointer_output: Option<smithay::output::Output>,
     /// Where the last absolute device event put the pointer, so the next

Modified file: crates/monolith/src/xdg.rs+1−1

@@ -1,4 +1,4 @@

1-use crate::input::Edges;

1+use crate::drag::Edges;

22 use crate::state::State;

33 use monolith_layout::OutputId;

44 use smithay::desktop::{PopupKind, Window};

Modified file: crates/monolith/src/xwayland.rs+1 additions−1 deletions@@ -3,8 +3,8 @@
 //! connection that woke it is served. Xwayland exits once its last client
 //! leaves and the socket is watched again.
 
+use crate::drag::Edges;
 use crate::focus::Focus;
-use crate::input::Edges;
 use crate::state::State;
 use monolith_config::SelectionAccess;
 use smithay::desktop::Window;

monolith

Commit 846bdd33d84f

Commit `846bdd33d84f`