monolith

public

Star0

Fork 0

Watch0

208 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `4b73e40af1e3`

tarball

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

4 files changed+85-21

layout: rescale floating windows with their output

set_output_area and set_reserved left float_rect untouched, so a mode change, rotation or new bar stranded floats partly off screen. They now map the rect proportionally from the old usable area to the new one and clamp it. Moves between outputs share that translate, which used to scale only the position and cap the size.

Modified file: crates/layout/src/lib.rs+12 additions−7 deletions@@ -664,11 +664,11 @@ impl Layout {
         if !self.outputs.contains_key(o) || win.output == Some(o) || win.scratchpad.is_some() {
             return;
         }
-        let from = win.output.map(|f| self.outputs[f].area);
+        let from = win.output.map(|f| self.outputs[f].usable());
         self.unplace(w);
         let win = &mut self.windows[w];
         if let (Some(from), Some(rect)) = (from, win.float_rect) {
-            win.float_rect = Some(translate(rect, from, self.outputs[o].area));
+            win.float_rect = Some(translate(rect, from, self.outputs[o].usable()));
         }
         win.output = Some(o);
         win.evicted_from = None;
@@ -948,14 +948,19 @@ pub fn clamp_float(r: Rect, bounds: Rect) -> Rect {
     Rect::new(x, y, r.w, r.h)
 }
 
-/// Keeps a rect at the same relative spot when it changes output.
+/// Keeps a floating rect at the same relative spot and size when the area
+/// it lives in changes.
 fn translate(r: Rect, from: Rect, to: Rect) -> Rect {
+    if to.w <= 0.0 || to.h <= 0.0 {
+        return r;
+    }
     let sx = if from.w > 0.0 { to.w / from.w } else { 1.0 };
     let sy = if from.h > 0.0 { to.h / from.h } else { 1.0 };
-    Rect::new(
+    let scaled = Rect::new(
         to.x + (r.x - from.x) * sx,
         to.y + (r.y - from.y) * sy,
-        r.w.min(to.w),
-        r.h.min(to.h),
-    )
+        (r.w * sx).max(MIN_FLOAT_SIZE),
+        (r.h * sy).max(MIN_FLOAT_SIZE),
+    );
+    clamp_float(scaled, to)
 }

Modified file: crates/layout/src/outputs.rs+34 additions−12 deletions@@ -5,7 +5,6 @@ pub(crate) struct Parked {
     tree: Tree<WindowId>,
     viewed: Vec<TagId>,
     floating: Vec<WindowId>,
-    area: Rect,
 }
 
 impl Layout {
@@ -59,7 +58,11 @@ impl Layout {
             self.unplace(w);
             let win = &mut self.windows[w];
             if let (Some(from), Some(rect)) = (win.output, win.float_rect) {
-                win.float_rect = Some(translate(rect, self.outputs[from].area, parked.area));
+                win.float_rect = Some(translate(
+                    rect,
+                    self.outputs[from].usable(),
+                    self.outputs[id].usable(),
+                ));
             }
             win.output = Some(id);
             win.evicted_from = None;
@@ -80,13 +83,13 @@ impl Layout {
         let Some(out) = self.outputs.remove(o) else {
             return;
         };
+        let left_usable = out.usable();
         self.parked.insert(
             out.name.clone(),
             Parked {
                 tree: out.tree,
                 viewed: out.viewed,
                 floating: out.floating,
-                area: out.area,
             },
         );
         if self.active == Some(o) {
@@ -112,7 +115,7 @@ impl Layout {
                 .or(self.active);
             let win = &mut self.windows[w];
             if let (Some(t), Some(rect)) = (target, win.float_rect) {
-                win.float_rect = Some(translate(rect, out.area, self.outputs[t].area));
+                win.float_rect = Some(translate(rect, left_usable, self.outputs[t].usable()));
             }
             win.output = target;
             if win.scratchpad.is_some() {
@@ -126,19 +129,38 @@ impl Layout {
     }
 
     pub fn set_output_area(&mut self, o: OutputId, area: Rect) {
-        if let Some(out) = self.outputs.get_mut(o) {
-            out.area = area;
-        }
+        let Some(out) = self.outputs.get_mut(o) else {
+            return;
+        };
+        let before = out.usable();
+        out.area = area;
+        self.rescale_floats(o, before);
     }
 
     /// Returns whether anything changed.
     pub fn set_reserved(&mut self, o: OutputId, reserved: Insets) -> bool {
-        match self.outputs.get_mut(o) {
-            Some(out) if out.reserved != reserved => {
-                out.reserved = reserved;
-                true
+        let Some(out) = self.outputs.get_mut(o) else {
+            return false;
+        };
+        if out.reserved == reserved {
+            return false;
+        }
+        let before = out.usable();
+        out.reserved = reserved;
+        self.rescale_floats(o, before);
+        true
+    }
+
+    /// Carries floating windows along when the usable area of o changes.
+    fn rescale_floats(&mut self, o: OutputId, before: Rect) {
+        let after = self.outputs[o].usable();
+        if after == before {
+            return;
+        }
+        for win in self.windows.values_mut().filter(|w| w.output == Some(o)) {
+            if let Some(rect) = win.float_rect {
+                win.float_rect = Some(translate(rect, before, after));
             }
-            _ => false,
         }
     }
 }

Modified file: crates/layout/src/scratchpad.rs+3 additions−2 deletions@@ -47,16 +47,17 @@ impl Layout {
             sp.shown = None;
             return None;
         }
-        let from = sp.output.map(|f| self.outputs[f].area);
+        let from = sp.output.map(|f| self.outputs[f].usable());
         sp.shown = Some(next);
         sp.output = Some(o);
         let w = sp.windows[next];
         self.last_scratchpad = Some(s);
         let area = self.outputs[o].area;
+        let usable = self.outputs[o].usable();
         let win = &mut self.windows[w];
         if win.output != Some(o) {
             win.float_rect = match (from, win.float_rect) {
-                (Some(from), Some(r)) => Some(translate(r, from, area)),
+                (Some(from), Some(r)) => Some(translate(r, from, usable)),
                 _ => Some(centred(area, 0.6)),
             };
             win.output = Some(o);

Modified file: crates/layout/src/tests.rs+36 additions@@ -641,3 +641,39 @@ fn oversized_floats_keep_their_top_edge_and_a_strip() {
     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));
 }
+
+#[test]
+fn floats_follow_their_output_area_and_panels() {
+    let mut l = Layout::default();
+    let o = l.add_output("a", AREA);
+    let w = l.add_window(Some(o), None, Some(Rect::new(500.0, 300.0, 400.0, 300.0)));
+    l.set_output_area(o, Rect::new(100.0, 50.0, 500.0, 300.0));
+    let r = l.window(w).unwrap().float_rect.unwrap();
+    assert_eq!((r.x, r.y, r.w, r.h), (350.0, 200.0, 200.0, 150.0));
+
+    l.set_reserved(
+        o,
+        Insets {
+            top: 100.0,
+            ..Insets::default()
+        },
+    );
+    let r = l.window(w).unwrap().float_rect.unwrap();
+    let usable = l.output(o).unwrap().usable();
+    assert!(r.y >= usable.y && r.bottom() <= usable.bottom());
+}
+
+#[test]
+fn floats_shrink_into_a_smaller_output_they_are_evicted_to() {
+    let mut l = Layout::default();
+    let a = l.add_output("a", AREA);
+    let b = l.add_output("b", Rect::new(1000.0, 0.0, 500.0, 300.0));
+    let w = l.add_window(Some(a), None, Some(Rect::new(800.0, 400.0, 200.0, 200.0)));
+    l.remove_output(a);
+    assert_eq!(l.window(w).unwrap().output, Some(b));
+    let r = l.window(w).unwrap().float_rect.unwrap();
+    let usable = l.output(b).unwrap().usable();
+    assert_eq!((r.w, r.h), (100.0, 100.0));
+    assert!(r.x >= usable.x && r.right() <= usable.right());
+    assert!(r.y >= usable.y && r.bottom() <= usable.bottom());
+}

monolith

Commit 4b73e40af1e3

Commit `4b73e40af1e3`