monolith

public

Star0

Fork 0

Watch0

110 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `605c44c8c5fc`

tarball

atagen <boss@atagen.co>2026-10-17 09:57 UTC

2 files changed+36-22

layout: merge only into sibling lanes, stepping out of a stack first

Leaving a stack to merge straight into the next lane over skipped the spot beside the stack, so a window at A C / B C moved right ended up under C instead of between B and C. Merging now considers only the window's own container and otherwise steps out like move_window, one press per step.

Modified file: crates/layout/src/tests.rs+26 additions−9 deletions@@ -263,17 +263,34 @@ fn moving_toward_a_hidden_lane_joins_it() {
 }
 
 #[test]
-fn merging_past_the_last_lane_leaves_the_stack() {
+fn merging_steps_out_of_a_stack_before_joining_another() {
     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(b, Dir::Left, |_| true));
+    let stacked = || {
+        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(b, Dir::Left, |_| true));
+        t
+    };
+    let rects = |t: &Tree<u32>| {
+        t.check();
+        let all = t.arrange(AREA, 0.0, |_| true);
+        move |w| all.iter().find(|p: &&(u32, Rect)| p.0 == w).unwrap().1
+    };
+
+    let mut t = stacked();
+    assert!(t.merge_window(a, Dir::Right, |_| true));
+    let rect = rects(&t);
+    assert!(rect(b).x < rect(a).x && rect(a).x < rect(c).x);
+    assert_eq!(rect(a).h, AREA.h);
+    assert!(t.merge_window(a, Dir::Right, |_| true));
+    let rect = rects(&t);
+    assert_eq!(rect(a).x, rect(c).x);
+
+    let mut t = stacked();
     assert!(t.merge_window(a, Dir::Up, |_| true));
-    t.check();
-    let all = t.arrange(AREA, 0.0, |_| true);
-    let rect = |w| all.iter().find(|p| p.0 == w).unwrap().1;
+    let rect = rects(&t);
     assert_eq!(rect(a).w, AREA.w);
     assert!(rect(a).bottom() <= rect(b).y && rect(b).y == rect(c).y);
 }

Modified file: crates/layout/src/tree.rs+10 additions−13 deletions@@ -198,23 +198,20 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         self.move_node(block, dir, &vis, false)
     }
 
-    /// Moves a window to the end of the next visible lane in `dir`, stepping
-    /// up a level when its container has none that way. A lone window there
-    /// becomes a stack with it. With no lane anywhere that way, it leaves its
-    /// stack as `move_window` would.
+    /// Moves a window to the end of the next visible lane in `dir` among its
+    /// siblings. A lone window there becomes a stack with it. A window with no
+    /// sibling lane that way leaves its stack as `move_window` would, so it
+    /// takes one press to step out and another to merge.
     pub fn merge_window(&mut self, w: W, dir: Dir, vis: impl Fn(W) -> bool) -> bool {
         let Some(&n) = self.leaves.get(&w) else {
             return false;
         };
-        let mut cur = n;
-        while let Some((p, i)) = self.position(cur) {
-            if self.axis(p) == Some(dir.axis())
-                && let Some(j) = self.next_shown(p, i, dir, &vis)
-            {
-                self.join_lane(n, p, j);
-                return true;
-            }
-            cur = p;
+        if let Some((p, i)) = self.position(n)
+            && self.axis(p) == Some(dir.axis())
+            && let Some(j) = self.next_shown(p, i, dir, &vis)
+        {
+            self.join_lane(n, p, j);
+            return true;
         }
         self.move_node(n, dir, &vis, true)
     }

monolith

Commit 605c44c8c5fc

Commit `605c44c8c5fc`