monolith

public

Star0

Fork 0

Watch0

137 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `8f1f743a2f6b`

tarball

atagen <boss@atagen.co>2026-10-19 03:49 UTC

2 files changed+102-16

layout: repeat a move until it shows, or undo it

Steps around hidden windows, like stepping out beside a lane of another tag or escaping to the root next to nothing visible, changed the tree without changing the screen. The keypress looked dropped and rearranged windows the user could not see. move_window, merge_window and move_container now keep stepping until the visible layout changes and restore the tree when it never does.

Modified file: crates/layout/src/tests.rs+41 additions@@ -417,3 +417,44 @@ fn moving_toward_a_stack_showing_one_window_swaps() {
     assert!(rect(b).x < rect(a).x);
     assert_eq!(rect(a).h, AREA.h);
 }
+
+/// A move either changes what is on screen or changes nothing at all. Steps
+/// around hidden windows used to succeed invisibly and eat the keypress.
+#[test]
+fn moves_are_seen_or_undone() {
+    let dirs = [Dir::Left, Dir::Right, Dir::Up, Dir::Down];
+    let mut runner = proptest::test_runner::TestRunner::deterministic();
+    let ops = prop::collection::vec((0u8..4, 0u8..4, 0u8..3, any::<bool>()), 1..14);
+    for _ in 0..2000 {
+        let seq = proptest::strategy::ValueTree::current(&ops.new_tree(&mut runner).unwrap());
+        let mut t: Tree<u32> = Tree::default();
+        t.insert_row(0);
+        let mut n = 1;
+        for &(w, d, kind, hide) in &seq {
+            let vis = |x: u32| !(hide && x == 0);
+            if kind == 0 && n < 5 {
+                t.insert_after(n, u32::from(w) % n);
+                n += 1;
+                continue;
+            }
+            let w = u32::from(w) % n;
+            let shown = |t: &Tree<u32>| {
+                let mut v: Vec<_> = t
+                    .arrange(AREA, 0.0, vis)
+                    .into_iter()
+                    .filter(|p| vis(p.0))
+                    .collect();
+                v.sort_by_key(|p| p.0);
+                v
+            };
+            let before = shown(&t);
+            let moved = if kind == 1 {
+                t.merge_window(w, dirs[usize::from(d)], vis)
+            } else {
+                t.move_window(w, dirs[usize::from(d)], vis)
+            };
+            t.check();
+            assert_eq!(moved, shown(&t) != before, "{seq:?}");
+        }
+    }
+}

Modified file: crates/layout/src/tree.rs+61 additions−16 deletions@@ -190,8 +190,10 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         let Some(&n) = self.leaves.get(&w) else {
             return false;
         };
-        let moved = self.move_node(n, dir, &vis, true);
-        self.reveal(n, moved)
+        self.until_seen(&vis, |t| {
+            let moved = t.move_node(n, dir, &vis, true);
+            t.reveal(n, moved)
+        })
     }
 
     /// Moves the container holding `w` as a rigid block. A window sitting
@@ -200,12 +202,14 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         let Some(&n) = self.leaves.get(&w) else {
             return false;
         };
-        let block = self.nodes[n]
-            .parent
-            .filter(|&p| Some(p) != self.root)
-            .unwrap_or(n);
-        let moved = self.move_node(block, dir, &vis, false);
-        self.reveal(n, moved)
+        self.until_seen(&vis, |t| {
+            let block = t.nodes[n]
+                .parent
+                .filter(|&p| Some(p) != t.root)
+                .unwrap_or(n);
+            let moved = t.move_node(block, dir, &vis, false);
+            t.reveal(n, moved)
+        })
     }
 
     /// Moves a window to the end of the next visible lane in `dir` among its
@@ -216,15 +220,56 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         let Some(&n) = self.leaves.get(&w) else {
             return false;
         };
-        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 self.reveal(n, true);
+        self.until_seen(&vis, |t| {
+            if let Some((p, i)) = t.position(n)
+                && t.axis(p) == Some(dir.axis())
+                && let Some(j) = t.next_shown(p, i, dir, &vis)
+            {
+                t.join_lane(n, p, j);
+                return t.reveal(n, true);
+            }
+            let moved = t.move_node(n, dir, &vis, true);
+            t.reveal(n, moved)
+        })
+    }
+
+    /// Repeats `step` until the visible layout changes, or undoes it all when
+    /// it never does. Steps around hidden windows otherwise ate keypresses
+    /// and rearranged windows the user could not see.
+    fn until_seen(
+        &mut self,
+        vis: &impl Fn(W) -> bool,
+        mut step: impl FnMut(&mut Self) -> bool,
+    ) -> bool {
+        let seen = |t: &Self| -> Vec<(W, Rect)> {
+            t.arrange(Rect::new(0.0, 0.0, 1000.0, 1000.0), 0.0, vis)
+                .into_iter()
+                .filter(|p| vis(p.0))
+                .collect()
+        };
+        let same = |a: &[(W, Rect)], b: &[(W, Rect)]| {
+            a.len() == b.len()
+                && a.iter().all(|(v, r)| {
+                    b.iter().any(|(w, s)| {
+                        v == w
+                            && [r.x - s.x, r.y - s.y, r.w - s.w, r.h - s.h]
+                                .iter()
+                                .all(|d| d.abs() < 1e-6)
+                    })
+                })
+        };
+        let before = self.clone();
+        let start = seen(self);
+        for _ in 0..=before.nodes.len() {
+            if !step(self) {
+                break;
+            }
+            if !same(&start, &seen(self)) {
+                return true;
+            }
         }
-        let moved = self.move_node(n, dir, &vis, true);
-        self.reveal(n, moved)
+        *self = before;
+        false
     }
 
     /// Undoes any expansion along `leaf`'s ancestry that favours another

monolith

Commit 8f1f743a2f6b

Commit `8f1f743a2f6b`