monolith

public

Star0

Fork 0

Watch0

24 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `60f00dd4f2be`

tarball

atagen <boss@atagen.co>2026-10-16 11:50 UTC

4 files changed+68-3

layout: let moved windows join lanes of hidden windows

Stepping a window out of a row toward a lane whose windows were all hidden used to open a new lane between them, so showing the tag again stacked an extra row the user never asked for. The window now joins that lane, and shares it once the hidden windows return.

Modified file: crates/layout/proptest-regressions/tests.txt+1

@@ -5,3 +5,4 @@

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

66 # 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+21 additions@@ -186,3 +186,24 @@ fn hidden_windows_keep_their_slots() {
     t.check();
     assert_eq!(rect(&t, e).w, AREA.w, "E is demoted to a row of its own");
 }
+
+/// Moving out of a row toward a lane of hidden windows joins that lane, so
+/// they share it when shown again instead of a new lane opening between.
+#[test]
+fn moving_toward_a_hidden_lane_joins_it() {
+    let (a, b, c, d, e) = (1, 2, 3, 4, 5);
+    let mut t: Tree<u32> = Tree::default();
+    t.insert_row(a);
+    t.insert_after(b, a);
+    t.insert_after(c, b);
+    t.insert_row(d);
+    t.insert_after(e, c);
+    let tag_two = |w: u32| w != a && w != d;
+    assert!(t.move_window(e, Dir::Down, tag_two));
+    t.check();
+    let all = t.arrange(AREA, 0.0, |_| true);
+    let rect = |w| all.iter().find(|p| p.0 == w).unwrap().1;
+    assert_eq!(rect(e).y, rect(d).y);
+    assert!(rect(d).x < rect(e).x);
+    assert!(rect(a).y < rect(d).y);
+}

Modified file: crates/layout/src/tree.rs+45 additions−2 deletions@@ -339,9 +339,16 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         let mut cur = n;
         while let Some((p, i)) = self.position(cur) {
             if self.axis(p) == Some(dir.axis()) {
+                let hidden_lane = self
+                    .adjacent(p, i, dir)
+                    .filter(|&j| enter && !self.visible(self.children(p)[j].node, vis));
                 if cur != n {
-                    let at = if dir.forward() { i + 1 } else { i };
-                    self.relocate(n, p, at);
+                    if let Some(j) = hidden_lane {
+                        self.join_lane(n, p, j);
+                    } else {
+                        let at = if dir.forward() { i + 1 } else { i };
+                        self.relocate(n, p, at);
+                    }
                     return true;
                 }
                 if let Some(j) = self.next_shown(p, i, dir, vis) {
@@ -356,6 +363,10 @@ impl<W: Copy + Eq + Hash> Tree<W> {
                     }
                     return true;
                 }
+                if let Some(j) = hidden_lane {
+                    self.join_lane(n, p, j);
+                    return true;
+                }
             }
             cur = p;
         }
@@ -397,6 +408,38 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         }
     }
 
+    fn adjacent(&self, p: NodeId, i: usize, dir: Dir) -> Option<usize> {
+        let j = if dir.forward() {
+            i + 1
+        } else {
+            i.checked_sub(1)?
+        };
+        (j < self.children(p).len()).then_some(j)
+    }
+
+    /// Moves `n` to the end of the lane at `p`'s child `j`, which holds only
+    /// hidden windows, so it shares that lane when they come back instead of
+    /// opening a new one beside it. A lone window becomes a lane of its own.
+    fn join_lane(&mut self, n: NodeId, p: NodeId, j: usize) {
+        let lane = self.children(p)[j].node;
+        let lane = if self.axis(lane).is_some() {
+            lane
+        } else {
+            let c = self.new_container(self.axis(p).expect("p is a container").other());
+            self.children_mut(p)[j].node = c;
+            self.nodes[c].parent = Some(p);
+            if let Kind::Container { expanded, .. } = &mut self.nodes[p].kind
+                && *expanded == Some(lane)
+            {
+                *expanded = Some(c);
+            }
+            self.attach(c, 0, lane, 1.0);
+            c
+        };
+        let end = self.children(lane).len();
+        self.relocate(n, lane, end);
+    }
+
     fn relocate(&mut self, n: NodeId, p: NodeId, at: usize) {
         let (old, i) = self.position(n).expect("relocated nodes have a parent");
         let weight = self.mean_weight(p);

Modified file: design/decisions.md+1−1

@@ -92,7 +92,7 @@ Running log of settled decisions and open questions. Research backing lives in `

9292

 - Floating to tiled and fullscreen use a direct glide above the tiled layer. Expand is a tiled operation planned normally, siblings squeezed to zero-size lines.

9393

 - One layout tree per output, tags filter it. Hidden windows keep their slots, visible moves swap visible slots only, containers collapse by the normal one-child rule counting hidden children, and a hidden only child is demoted into the grandparent. This replaces per-tag layouts and the row-stacking merge rule, row stacking is just the default arrangement.

9494 - Lanes span only the band of the involved windows, never the whole output.

95-- Hidden-slot rules confirmed.

+- Hidden-slot rules confirmed. A window moving toward a lane that holds only hidden windows joins that lane rather than opening a new one beside it.

9696 - Input hit-tests against final layout geometry, never animated geometry.

9797 - smithay is pinned by git rev. The repo uses jj.

monolith

Commit 60f00dd4f2be

Commit `60f00dd4f2be`