monolith

public

Star0

Fork 0

Watch0

323 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `7caafe71a560`

tarball

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

1 file changed+58-31

drag: resize scratchpads around their centre and never move them

Shown scratchpads are placed at the centre of the output's usable area from their size alone, so a move drag was discarded on the next layout pass and a resize drag left the dragged edge trailing the pointer. A move now does not start, and a resize grows both sides, so the edge follows the pointer with twice the delta in size.

Modified file: crates/monolith/src/drag.rs+58 additions−31 deletions@@ -3,7 +3,7 @@
 
 use crate::state::{Input, State};
 use crate::wm::Resizing;
-use monolith_layout::{Dir, Layout, MIN_FLOAT_SIZE, Rect, WindowId, clamp_float};
+use monolith_layout::{Dir, Layout, MIN_FLOAT_SIZE, OutputId, Rect, WindowId, clamp_float};
 use smithay::input::pointer::CursorIcon;
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel;
 use smithay::utils::{Logical, Point};
@@ -159,6 +159,8 @@ pub struct Drag {
     bounds: Rect,
     /// A tiled window, whose splits follow the pointer instead of a rect.
     tiled: bool,
+    /// A scratchpad, which is always centred so a resize grows both sides.
+    centred: bool,
     /// None moves the window.
     edges: Option<Edges>,
     /// The button the drag started with, whose release ends it.
@@ -275,8 +277,24 @@ pub(crate) fn start_drag(state: &mut State, button: u32) -> bool {
     begin_drag(state, id, edges, button, false)
 }
 
+/// The output a window sits on, which for a scratchpad is wherever it is shown.
+fn output_of(layout: &Layout, id: WindowId) -> Option<OutputId> {
+    let win = layout.window(id)?;
+    win.scratchpad
+        .and_then(|s| layout.scratchpads().get(s)?.output)
+        .or(win.output)
+}
+
 fn window_rect(layout: &Layout, id: WindowId) -> Option<Rect> {
     let win = layout.window(id)?;
+    if win.scratchpad.is_some() {
+        return layout
+            .arrange(output_of(layout, id)?)
+            .floating
+            .iter()
+            .find(|f| f.0 == id)
+            .map(|f| f.1);
+    }
     if win.floating {
         return win.float_rect;
     }
@@ -320,29 +338,27 @@ fn begin_drag(
     } else {
         edges
     };
-    if tiled && edges.is_none() {
+    let centred = win.scratchpad.is_some();
+    if (tiled || centred) && edges.is_none() {
         return false;
     }
-    let (Some(rect), Some(out)) = (
-        window_rect(layout, id),
-        win.output.and_then(|o| layout.output(o)),
-    ) else {
+    let home = output_of(layout, id);
+    let (Some(rect), Some(out)) = (window_rect(layout, id), home.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.wm.resizing = home.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,
+        centred,
         edges,
         button,
         client,
@@ -413,23 +429,34 @@ pub(crate) fn drag_to(state: &mut State, pos: Point<f64, Logical>) -> bool {
                 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)
+            if d.centred {
+                let both = (f64::NEG_INFINITY, f64::INFINITY);
+                let grown = |start, len, delta, edges, limits: (f64, f64), room: f64| {
+                    let (_, len) = resized(start, len, 2.0 * delta, edges, both, limits);
+                    len.min(room).max(limits.0)
+                };
+                let w = grown(r.x, r.w, dx, (e.left, e.right), (min.0, max_w), b.w);
+                let h = grown(r.y, r.h, dy, (e.top, e.bottom), (min.1, max_h), b.h);
+                Rect::new(r.x + (r.w - w) / 2.0, r.y + (r.h - h) / 2.0, w, h)
+            } else {
+                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),
     };

monolith

Commit 7caafe71a560

Commit `7caafe71a560`