monolith

public

Star0

Fork 0

Watch0

207 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `b01f4e7ab7e6`

tarball

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

3 files changed+80-25

input: keep dragged floating windows reachable

Mod+drag and client move or resize requests could push a floating window entirely off its output with no way back. Moves now go through layout clamp_float against the output's usable area, and resizes stop each dragged edge at that area.

Modified file: crates/layout/src/lib.rs+38 additions−8 deletions@@ -91,6 +91,19 @@ pub struct Output {
     pub floating: Vec<WindowId>,
 }
 
+impl Output {
+    /// The area left once bars and panels have taken their edges.
+    pub fn usable(&self) -> Rect {
+        let (a, r) = (self.area, self.reserved);
+        Rect::new(
+            a.x + r.left,
+            a.y + r.top,
+            (a.w - r.left - r.right).max(0.0),
+            (a.h - r.top - r.bottom).max(0.0),
+        )
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct Scratchpad {
     pub name: String,
@@ -725,14 +738,7 @@ impl Layout {
         let Some(out) = self.outputs.get(o) else {
             return Arrangement::default();
         };
-        let r = out.reserved;
-        let usable = Rect::new(
-            out.area.x + r.left,
-            out.area.y + r.top,
-            (out.area.w - r.left - r.right).max(0.0),
-            (out.area.h - r.top - r.bottom).max(0.0),
-        );
-        let area = inset(usable, self.gaps.outer);
+        let area = inset(out.usable(), self.gaps.outer);
         let shown = self.vis_on(o);
         let vis = &|w: WindowId| shown(w) && !hide.contains(&w);
         let tiled = out
@@ -918,6 +924,30 @@ fn centred(area: Rect, frac: f64) -> Rect {
     )
 }
 
+/// The smallest a floating window gets when dragged or rescaled.
+pub const MIN_FLOAT_SIZE: f64 = 32.0;
+
+/// How much of a floating window stays reachable when it is larger than
+/// the area it lives in.
+const STRIP: f64 = 64.0;
+
+/// Moves a floating rect to keep it reachable inside bounds. A window that
+/// fits stays whole inside, a larger one keeps its top edge and a strip.
+pub fn clamp_float(r: Rect, bounds: Rect) -> Rect {
+    let x = if r.w <= bounds.w {
+        r.x.clamp(bounds.x, bounds.right() - r.w)
+    } else {
+        let strip = STRIP.min(bounds.w);
+        r.x.clamp(bounds.x + strip - r.w, bounds.right() - strip)
+    };
+    let y = if r.h <= bounds.h {
+        r.y.clamp(bounds.y, bounds.bottom() - r.h)
+    } else {
+        r.y.clamp(bounds.y, bounds.bottom() - STRIP.min(bounds.h))
+    };
+    Rect::new(x, y, r.w, r.h)
+}
+
 /// Keeps a rect at the same relative spot when it changes output.
 fn translate(r: Rect, from: Rect, to: Rect) -> Rect {
     let sx = if from.w > 0.0 { to.w / from.w } else { 1.0 };

Modified file: crates/layout/src/tests.rs+12 additions@@ -629,3 +629,15 @@ fn urgency_skips_the_focused_window_and_ends_with_focus() {
     l.focus(b);
     assert!(!l.window(b).unwrap().urgent);
 }
+
+#[test]
+fn oversized_floats_keep_their_top_edge_and_a_strip() {
+    let bounds = Rect::new(0.0, 0.0, 1000.0, 600.0);
+    let huge = Rect::new(-5000.0, -300.0, 3000.0, 2000.0);
+    let r = clamp_float(huge, bounds);
+    assert_eq!((r.x, r.y), (-2936.0, 0.0));
+    let r = clamp_float(Rect::new(5000.0, 5000.0, 3000.0, 2000.0), bounds);
+    assert_eq!((r.x, r.y), (936.0, 536.0));
+    let fits = clamp_float(Rect::new(900.0, 500.0, 300.0, 200.0), bounds);
+    assert_eq!((fits.x, fits.y), (700.0, 400.0));
+}

Modified file: crates/monolith/src/input.rs+30 additions−17 deletions@@ -2,7 +2,7 @@
 //! into these calls, with pointer positions in global logical coordinates.
 
 use crate::state::State;
-use monolith_layout::{Rect, WindowId};
+use monolith_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};
@@ -244,7 +244,6 @@ 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)]
@@ -310,6 +309,7 @@ pub struct Drag {
     window: WindowId,
     from: Point<f64, Logical>,
     rect: Rect,
+    bounds: Rect,
     /// None moves the window.
     edges: Option<Edges>,
     /// The client's button, whose release is still the client's to see.
@@ -345,12 +345,11 @@ impl State {
 }
 
 fn begin_drag(state: &mut State, id: WindowId, edges: Option<Edges>, button: Option<u32>) -> bool {
-    let Some(rect) = state
-        .wm
-        .layout
+    let layout = &state.wm.layout;
+    let Some((rect, bounds)) = layout
         .window(id)
         .filter(|w| w.floating && !w.fullscreen)
-        .and_then(|w| w.float_rect)
+        .and_then(|w| Some((w.float_rect?, layout.output(w.output?)?.usable())))
     else {
         return false;
     };
@@ -358,20 +357,33 @@ fn begin_drag(state: &mut State, id: WindowId, edges: Option<Edges>, button: Opt
         window: id,
         from: state.input.pointer_pos,
         rect,
+        bounds,
         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)
+/// Moves the dragged edges of an axis, keeping them between lo and hi unless
+/// the window started beyond them, and the size above the minimum.
+fn resized(
+    start: f64,
+    len: f64,
+    delta: f64,
+    edges: (bool, bool),
+    (lo, hi): (f64, f64),
+) -> (f64, f64) {
+    let end = start + len;
+    match edges {
+        (true, _) => {
+            let edge = (start + delta).max(lo.min(start)).min(end - MIN_FLOAT_SIZE);
+            (edge, end - edge)
+        }
+        (_, true) => {
+            let edge = (end + delta).min(hi.max(end)).max(start + MIN_FLOAT_SIZE);
+            (start, edge - start)
+        }
+        _ => (start, len),
     }
 }
 
@@ -383,11 +395,12 @@ fn drag_to(state: &mut State, pos: Point<f64, Logical>) -> bool {
     let r = d.rect;
     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);
+            let b = d.bounds;
+            let (x, w) = resized(r.x, r.w, dx, (e.left, e.right), (b.x, b.right()));
+            let (y, h) = resized(r.y, r.h, dy, (e.top, e.bottom), (b.y, b.bottom()));
             Rect::new(x, y, w, h)
         }
-        None => Rect::new(r.x + dx, r.y + dy, r.w, r.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);

monolith

Commit b01f4e7ab7e6

Commit `b01f4e7ab7e6`