monolith

public

Star0

Fork 0

Watch0

122 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `3b1cf5ee2ea2`

tarball

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

3 files changed+103-13

layout: keep moved windows visible and stack weights stable

A move into a container expanded toward another child gave the moved window no room, so it vanished while staying focused. Moves and new windows now clear expansions that favour someone else. Joining a stack also hands the window's weight to the stack and leaving hands it back, where before each round trip split a slot's weight again and shrank the windows around it.

Deleted file: crates/layout/proptest-regressions/tests.txt−8

@@ -1,8 +0,0 @@

1-# Seeds for failure cases proptest has generated in the past. It is

2-# automatically read and these particular cases re-run before any

3-# novel cases are generated.

4-#

5-# It is recommended to check this file in to source control so that

6-# everyone who runs the test benefits from these saved cases.

-cc feaaec708a35beac0ab9749dd260c423ed4177da099bd85a2041f38172334f65 # shrinks to ops = [Add(0, false), Add(0, false), Add(0, false), View(1), Scratch(0), Add(0, false), Add(0, false), Add(0, false), Summon, Summon, Flip, Add(1, false), Move(Left), Add(0, false), Add(0, false), Focus(114), Flip, Move(Left), Focus(0), Add(0, false), View(0), View(0), View(0), Add(0, false), Expand(0)]

-cc 796d3b6a182db230a58f8fcf320dde6b4ffd5ff3128b07a4f4c75737b25d9e88 # shrinks to ops = [Add(0, false), Focus(0), Add(0, false), Focus(30), View(3), Focus(0), Add(3, false), Move(Up), Add(0, false), Move(Left), Add(0, false), View(0), Add(0, false), Block(Right), Add(0, false), Move(Right), Add(0, false), View(3), Flip, Add(3, false), Expand(0), View(0), Move(Right)]

Modified file: crates/layout/src/tests.rs+39 additions@@ -128,6 +128,18 @@ fn apply(l: &mut Layout, tags: &[TagId], op: &Op) {
     }
 }
 
+/// The area a tiled window gets, zero for floating or unplaced ones.
+fn tiled_area(l: &Layout, w: WindowId) -> f64 {
+    let Some(o) = l.window(w).and_then(|x| x.output) else {
+        return 0.0;
+    };
+    l.arrange(o)
+        .tiled
+        .iter()
+        .find(|p| p.window == w && p.visible)
+        .map_or(0.0, |p| p.rect.w * p.rect.h)
+}
+
 fn check_geometry(l: &Layout) {
     for (o, out) in l.outputs() {
         let arr = l.arrange(o);
@@ -182,9 +194,14 @@ proptest! {
         l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));
         let tags = [l.homeless(), l.tag("1"), l.tag("2"), l.tag("3")];
         for op in &ops {
+            let moving = matches!(op, Op::Move(_) | Op::Merge(_) | Op::Block(_));
+            let shown_before = l.focused().filter(|&w| tiled_area(&l, w) > 1.0);
             apply(&mut l, &tags, op);
             l.check();
             check_geometry(&l);
+            if moving && let Some(w) = shown_before {
+                prop_assert!(tiled_area(&l, w) > 1.0, "{w:?} vanished after {op:?}");
+            }
         }
     }
 
@@ -312,3 +329,25 @@ fn expand_skips_containers_of_hidden_windows() {
     let rect = |w| all.iter().find(|p| p.0 == w).unwrap().1;
     assert_eq!(rect(b).w, AREA.w);
 }
+
+/// Joining a stack hands the window's weight to it and leaving hands it back,
+/// so going in and out repeatedly leaves every window the size it was.
+#[test]
+fn stacking_in_and_out_does_not_drift() {
+    for out in [Dir::Up, Dir::Down, Dir::Right] {
+        let (a, b, c) = (1, 2, 3);
+        let mut t: Tree<u32> = Tree::default();
+        t.insert_row(a);
+        t.insert_after(b, a);
+        t.insert_after(c, b);
+        assert!(t.merge_window(c, Dir::Left, |_| true));
+        assert!(t.merge_window(c, out, |_| true));
+        let once = t.arrange(AREA, 0.0, |_| true);
+        for _ in 0..8 {
+            t.merge_window(c, Dir::Left, |_| true);
+            t.merge_window(c, out, |_| true);
+        }
+        t.check();
+        assert_eq!(t.arrange(AREA, 0.0, |_| true), once, "stepping out {out:?}");
+    }
+}

Modified file: crates/layout/src/tree.rs+64 additions−5 deletions@@ -138,6 +138,7 @@ impl<W: Copy + Eq + Hash> Tree<W> {
                 self.root = Some(c);
             }
         }
+        self.reveal(n, true);
     }
 
     /// Appends `w` as a row of its own along the stacking axis.
@@ -157,6 +158,7 @@ impl<W: Copy + Eq + Hash> Tree<W> {
                 self.root = Some(c);
             }
         }
+        self.reveal(n, true);
     }
 
     pub fn remove(&mut self, w: W) -> bool {
@@ -182,7 +184,8 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         let Some(&n) = self.leaves.get(&w) else {
             return false;
         };
-        self.move_node(n, dir, &vis, true)
+        let moved = self.move_node(n, dir, &vis, true);
+        self.reveal(n, moved)
     }
 
     /// Moves the container holding `w` as a rigid block. A window sitting
@@ -195,7 +198,8 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             .parent
             .filter(|&p| Some(p) != self.root)
             .unwrap_or(n);
-        self.move_node(block, dir, &vis, false)
+        let moved = self.move_node(block, dir, &vis, false);
+        self.reveal(n, moved)
     }
 
     /// Moves a window to the end of the next visible lane in `dir` among its
@@ -211,9 +215,27 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             && let Some(j) = self.next_shown(p, i, dir, &vis)
         {
             self.join_lane(n, p, j);
-            return true;
+            return self.reveal(n, true);
         }
-        self.move_node(n, dir, &vis, true)
+        let moved = self.move_node(n, dir, &vis, true);
+        self.reveal(n, moved)
+    }
+
+    /// Undoes any expansion along `leaf`'s ancestry that favours another
+    /// child, once it has `moved` or arrived. An expanded container gives its
+    /// other children no room, so a window moved into one vanished while
+    /// staying focused.
+    fn reveal(&mut self, leaf: NodeId, moved: bool) -> bool {
+        let mut cur = leaf;
+        while moved && let Some(p) = self.nodes[cur].parent {
+            if let Kind::Container { expanded, .. } = &mut self.nodes[p].kind
+                && expanded.is_some_and(|e| e != cur)
+            {
+                *expanded = None;
+            }
+            cur = p;
+        }
+        moved
     }
 
     /// Whether every container above `w` is expanded towards it.
@@ -405,7 +427,7 @@ impl<W: Copy + Eq + Hash> Tree<W> {
                         self.join_lane(n, p, j);
                     } else {
                         let at = if dir.forward() { i + 1 } else { i };
-                        self.relocate(n, p, at);
+                        self.step_out(n, p, i, at);
                     }
                     return true;
                 }
@@ -432,6 +454,7 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             return false;
         }
         let (old, i) = self.position(n).expect("n is below the root");
+        self.release_share(n);
         self.unlink(old, i);
         self.normalize(old);
         let r = self.root.expect("the rest of the tree survives");
@@ -494,7 +517,43 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             c
         };
         let end = self.children(lane).len();
+        let from_p = self.position(n).filter(|&(old, _)| old == p);
+        let weight = from_p.map(|(_, i)| self.children(p)[i].weight);
         self.relocate(n, lane, end);
+        if let Some(weight) = weight
+            && self.nodes.contains_key(lane)
+            && let Some((q, k)) = self.position(lane)
+            && q == p
+        {
+            self.children_mut(p)[k].weight += weight;
+        }
+    }
+
+    /// Moves `n` out of `p`'s child `i` to sit beside it at `at`, taking
+    /// along the share of that child's weight it had.
+    fn step_out(&mut self, n: NodeId, p: NodeId, i: usize, at: usize) {
+        let cur = self.children(p)[i].node;
+        let Some((parent, k)) = self.position(n).filter(|&(q, _)| q == cur) else {
+            self.relocate(n, p, at);
+            return;
+        };
+        let share = self.release_share(n).unwrap_or_else(|| self.mean_weight(p));
+        self.unlink(parent, k);
+        self.attach(p, at, n, share);
+        self.normalize(parent);
+    }
+
+    /// Takes `n`'s share of its container's weight away from the container,
+    /// for `n` to carry out. Joining a lane hands a window's weight to the
+    /// lane, so leaving gives it back and windows going in and out of
+    /// stacks do not shrink their neighbours a little more each time.
+    fn release_share(&mut self, n: NodeId) -> Option<f64> {
+        let (old, i) = self.position(n)?;
+        let (q, k) = self.position(old)?;
+        let total: f64 = self.children(old).iter().map(|c| c.weight).sum();
+        let share = self.children(q)[k].weight * self.children(old)[i].weight / total;
+        self.children_mut(q)[k].weight -= share;
+        Some(share)
     }
 
     fn relocate(&mut self, n: NodeId, p: NodeId, at: usize) {

monolith

Commit 3b1cf5ee2ea2

Commit `3b1cf5ee2ea2`