monolith

public

Star0

Fork 0

Watch0

138 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `ae47743b5745`

tarball

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

2 files changed+45-11

layout: refuse to move hidden windows

The move docs promised hidden windows never move, but nothing checked it, and a step that moved a hidden window could still change the visible layout. Moves now fail outright for a window its own view hides.

Modified file: crates/layout/src/tests.rs+20 additions−8 deletions@@ -418,20 +418,21 @@ fn moving_toward_a_stack_showing_one_window_swaps() {
     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.
+/// A move either changes what is on screen or changes nothing at all, and a
+/// window move never rearranges hidden windows among themselves. 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);
+    let ops = prop::collection::vec((0u8..4, 0u8..4, 0u8..4, 0u8..32), 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);
+            let vis = |x: u32| hide & (1 << x) == 0;
             if kind == 0 && n < 5 {
                 t.insert_after(n, u32::from(w) % n);
                 n += 1;
@@ -448,13 +449,24 @@ fn moves_are_seen_or_undone() {
                 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)
+            let hidden = |t: &Tree<u32>| {
+                let mut t = t.clone();
+                t.retain(|x| !vis(x));
+                t.shape()
+            };
+            let rest = hidden(&t);
+            let d = dirs[usize::from(d)];
+            let moved = match kind {
+                1 => t.merge_window(w, d, vis),
+                2 => t.move_window(w, d, vis),
+                3 => t.move_container(w, d, vis),
+                _ => continue,
             };
             t.check();
             assert_eq!(moved, shown(&t) != before, "{seq:?}");
+            if kind != 3 {
+                assert_eq!(hidden(&t), rest, "{seq:?}");
+            }
         }
     }
 }

Modified file: crates/layout/src/tree.rs+25 additions−3 deletions@@ -187,7 +187,7 @@ impl<W: Copy + Eq + Hash> Tree<W> {
     /// visible sibling, enter a sibling container, or step out beside their
     /// container. Hidden windows never move.
     pub fn move_window(&mut self, w: W, dir: Dir, vis: impl Fn(W) -> bool) -> bool {
-        let Some(&n) = self.leaves.get(&w) else {
+        let Some(&n) = self.leaves.get(&w).filter(|_| vis(w)) else {
             return false;
         };
         self.until_seen(&vis, |t| {
@@ -199,7 +199,7 @@ impl<W: Copy + Eq + Hash> Tree<W> {
     /// Moves the container holding `w` as a rigid block. A window sitting
     /// directly in the root is its own block.
     pub fn move_container(&mut self, w: W, dir: Dir, vis: impl Fn(W) -> bool) -> bool {
-        let Some(&n) = self.leaves.get(&w) else {
+        let Some(&n) = self.leaves.get(&w).filter(|_| vis(w)) else {
             return false;
         };
         self.until_seen(&vis, |t| {
@@ -217,7 +217,7 @@ impl<W: Copy + Eq + Hash> Tree<W> {
     /// 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 {
+        let Some(&n) = self.leaves.get(&w).filter(|_| vis(w)) else {
             return false;
         };
         self.until_seen(&vis, |t| {
@@ -779,6 +779,28 @@ impl<W: Copy + Eq + Hash> Tree<W> {
     }
 
     #[cfg(test)]
+    pub(crate) fn shape(&self) -> String
+    where
+        W: std::fmt::Debug,
+    {
+        fn go<W: Copy + Eq + Hash + std::fmt::Debug>(t: &Tree<W>, n: NodeId) -> String {
+            match &t.nodes[n].kind {
+                Kind::Leaf(w, [x, y]) => format!("{w:?}[{x:.6},{y:.6}]"),
+                Kind::Container {
+                    axis,
+                    children,
+                    expanded,
+                } => {
+                    let inner: Vec<String> = children.iter().map(|&c| go(t, c)).collect();
+                    let e = expanded.and_then(|e| children.iter().position(|&c| c == e));
+                    format!("{axis:?}{e:?}({})", inner.join(" "))
+                }
+            }
+        }
+        self.root.map(|r| go(self, r)).unwrap_or_default()
+    }
+
+    #[cfg(test)]
     pub(crate) fn check(&self) {
         let reachable = match self.root {
             Some(r) => {

monolith

Commit ae47743b5745

Commit `ae47743b5745`