monolith

public

Star0

Fork 0

Watch0

327 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `21e8e8e5aa3d`

tarball

atagen <boss@atagen.co>2026-10-20 11:57 UTC

4 files changed+129-33

layout: move an extended window's group as a block

Moving an extended window broke it out of the container it was extended in, scattering windows the user could not see. The group now moves whole through move_window, merge_window and move_container, and attach turns an expanded container across rather than dissolving it into a parent on its own axis, which would have shown everything it covered. MoveContainer also honours the move mode and the invert latch, so blocks merge into the next lane when windows would.

Modified file: crates/layout/src/lib.rs+2 additions−2 deletions@@ -624,12 +624,12 @@ impl Layout {
         moved
     }
 
-    pub fn move_container(&mut self, dir: Dir) -> bool {
+    pub fn move_container(&mut self, dir: Dir, merge: bool) -> bool {
         let Some((w, o)) = self.focused_tiled() else {
             return false;
         };
         let mut tree = std::mem::take(&mut self.outputs[o].tree);
-        let moved = tree.move_container(w, dir, self.vis_on(o));
+        let moved = tree.move_container(w, dir, merge, self.vis_on(o));
         self.outputs[o].tree = tree;
         moved
     }

Modified file: crates/layout/src/tests.rs+38 additions−6 deletions@@ -9,7 +9,7 @@ enum Op {
     Remove(u8),
     Focus(u8),
     Move(Dir),
-    Block(Dir),
+    Block(Dir, bool),
     Merge(Dir),
     View(u8),
     ToggleView(u8),
@@ -39,7 +39,7 @@ fn op() -> impl Strategy<Value = Op> {
         1 => any::<u8>().prop_map(Op::Remove),
         3 => any::<u8>().prop_map(Op::Focus),
         4 => dir().prop_map(Op::Move),
-        2 => dir().prop_map(Op::Block),
+        2 => (dir(), any::<bool>()).prop_map(|(d, m)| Op::Block(d, m)),
         3 => dir().prop_map(Op::Merge),
         1 => (0u8..4).prop_map(Op::View),
         2 => (0u8..4).prop_map(Op::ToggleView),
@@ -82,8 +82,8 @@ fn apply(l: &mut Layout, tags: &[TagId], op: &Op) {
         Op::Move(d) => {
             l.move_window(d);
         }
-        Op::Block(d) => {
-            l.move_container(d);
+        Op::Block(d, m) => {
+            l.move_container(d, m);
         }
         Op::Merge(d) => {
             l.merge_window(d);
@@ -200,7 +200,7 @@ 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 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();
@@ -318,6 +318,38 @@ fn merging_steps_out_of_a_stack_before_joining_another() {
     assert!(rect(a).bottom() <= rect(b).y && rect(b).y == rect(c).y);
 }
 
+/// An extended window's group moves whole, even into a container running
+/// its own way, where it would otherwise dissolve and show what it covers.
+#[test]
+fn extended_windows_move_their_group() {
+    let (a, b, c) = (1, 2, 3);
+    let all = |_| true;
+    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, all));
+    assert!(t.toggle_expand(b, 0, 1, all));
+    let rects = |t: &Tree<u32>| {
+        t.check();
+        assert!(t.grouped(b, all) && t.eclipsed(a, all));
+        let placed = t.arrange(AREA, 0.0, all);
+        move |w| placed.iter().find(|p: &&(u32, Rect)| p.0 == w).unwrap().1
+    };
+
+    assert!(t.move_window(b, Dir::Right, all));
+    let rect = rects(&t);
+    assert!(rect(c).x < rect(b).x);
+
+    assert!(t.move_window(b, Dir::Down, all));
+    let rect = rects(&t);
+    assert!(rect(c).bottom() <= rect(b).y && rect(b).w == AREA.w);
+
+    assert!(t.merge_window(b, Dir::Up, all));
+    let rect = rects(&t);
+    assert!(rect(c).right() <= rect(b).x && rect(b).y == rect(c).y);
+}
+
 /// A window alone on screen in a container of hidden ones expands among the
 /// windows it is shown beside, not inside the container nobody can see.
 #[test]
@@ -465,7 +497,7 @@ fn moves_are_seen_or_undone() {
             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),
+                3 => t.move_container(w, d, false, vis),
                 _ => continue,
             };
             t.check();

Modified file: crates/layout/src/tree.rs+88 additions−24 deletions@@ -222,52 +222,98 @@ impl<W: Copy + Eq + Hash> Tree<W> {
 
     /// Moves a window one step in `dir`. Leaves swap slots with the next
     /// visible sibling, enter a sibling container, or step out beside their
-    /// container. Hidden windows never move.
+    /// container. Hidden windows never move, and an extended window moves
+    /// its group as a rigid block.
     pub fn move_window(&mut self, w: W, dir: Dir, vis: impl Fn(W) -> bool) -> bool {
         let Some(&n) = self.leaves.get(&w).filter(|_| vis(w)) else {
             return false;
         };
+        let block = self.group(w, &vis).unwrap_or(n);
         self.until_seen(&vis, |t| {
-            let moved = t.move_node(n, dir, &vis, true);
+            let moved = t.move_node(block, dir, &vis, block == n);
             t.reveal(n, moved)
         })
     }
 
-    /// 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 {
+    /// Moves the group or container holding `w` as a block, merging it into
+    /// the next lane in `dir` like `merge_window` when `merge` is set. A
+    /// window sitting directly in the root is its own block.
+    pub fn move_container(&mut self, w: W, dir: Dir, merge: bool, vis: impl Fn(W) -> bool) -> bool {
         let Some(&n) = self.leaves.get(&w).filter(|_| vis(w)) else {
             return false;
         };
+        let group = self.group(w, &vis);
         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)
+            let block = group.unwrap_or_else(|| {
+                t.nodes[n]
+                    .parent
+                    .filter(|&p| Some(p) != t.root)
+                    .unwrap_or(n)
+            });
+            if merge {
+                t.merge_node(n, block, dir, &vis)
+            } else {
+                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
     /// 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.
+    /// takes one press to step out and another to merge. An extended window
+    /// takes its group along.
     pub fn merge_window(&mut self, w: W, dir: Dir, vis: impl Fn(W) -> bool) -> bool {
         let Some(&n) = self.leaves.get(&w).filter(|_| vis(w)) else {
             return false;
         };
-        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)
+        let block = self.group(w, &vis).unwrap_or(n);
+        self.until_seen(&vis, |t| t.merge_node(n, block, dir, &vis))
+    }
+
+    fn merge_node(&mut self, leaf: NodeId, n: NodeId, dir: Dir, vis: &impl Fn(W) -> bool) -> bool {
+        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(leaf, true);
+        }
+        let moved = self.move_node(n, dir, vis, true);
+        self.reveal(leaf, moved)
+    }
+
+    /// The outermost container `w` is extended in, the block it moves as.
+    fn group(&self, w: W, vis: &impl Fn(W) -> bool) -> Option<NodeId> {
+        self.shown_path(w, vis)
+            .into_iter()
+            .take_while(|&(p, c)| self.expanded(p) == Some(c))
+            .last()
+            .map(|(p, _)| p)
+    }
+
+    /// Whether `w` is extended over windows it shares a container with.
+    pub fn grouped(&self, w: W, vis: impl Fn(W) -> bool) -> bool {
+        self.group(w, &vis).is_some()
+    }
+
+    /// Whether a visible window extended over `w` takes all its room.
+    pub fn eclipsed(&self, w: W, vis: impl Fn(W) -> bool) -> bool {
+        let Some(&leaf) = self.leaves.get(&w) else {
+            return false;
+        };
+        let mut cur = leaf;
+        while let Some(p) = self.nodes[cur].parent {
+            if self
+                .expanded(p)
+                .is_some_and(|e| e != cur && self.visible(e, &vis))
             {
-                t.join_lane(n, p, j);
-                return t.reveal(n, true);
+                return true;
             }
-            let moved = t.move_node(n, dir, &vis, true);
-            t.reveal(n, moved)
-        })
+            cur = p;
+        }
+        false
     }
 
     /// Repeats `step` until the visible layout changes, or undoes it all when
@@ -757,9 +803,16 @@ impl<W: Copy + Eq + Hash> Tree<W> {
     }
 
     /// Places `node` among `p`'s children. A container running along `p`'s
-    /// axis is dissolved into `p` so axes keep alternating.
+    /// axis is dissolved into `p` so axes keep alternating, unless it holds an
+    /// extended window, whose group is turned across instead to survive.
     fn attach(&mut self, p: NodeId, at: usize, node: NodeId) {
         if self.axis(node).is_some() && self.axis(node) == self.axis(p) {
+            if self.expanded(node).is_some() {
+                self.transpose(node);
+                self.nodes[node].parent = Some(p);
+                self.children_mut(p).insert(at, node);
+                return;
+            }
             let children = self.children(node).to_vec();
             self.nodes.remove(node);
             for (k, &c) in children.iter().enumerate() {
@@ -787,6 +840,18 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         }
     }
 
+    fn transpose(&mut self, n: NodeId) {
+        match &mut self.nodes[n].kind {
+            Kind::Container { axis, children, .. } => {
+                *axis = axis.other();
+                for c in children.clone() {
+                    self.transpose(c);
+                }
+            }
+            Kind::Leaf(_, size) => size.reverse(),
+        }
+    }
+
     /// Repairs a container that lost a child.
     fn normalize(&mut self, c: NodeId) {
         if self.children(c).len() >= 2 {
@@ -810,10 +875,9 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             (None, None) => self.root = None,
             (Some(only), Some((p, i))) => {
                 self.unlink_dead(p, i);
-                let leaf_like = self.axis(only) != self.axis(p);
                 self.attach(p, i, only);
                 if was_expanded
-                    && leaf_like
+                    && self.nodes.contains_key(only)
                     && let Kind::Container { expanded, .. } = &mut self.nodes[p].kind
                 {
                     *expanded = Some(only);

Modified file: crates/monolith/src/commands.rs+1−1

@@ -87,7 +87,7 @@ impl State {

8787 self.wm.layout.move_window(d);

8888 }

8989 Command::MoveContainer { dir: d } => {

90- self.wm.layout.move_container(d);

90+ self.wm.layout.move_container(d, merge);

9191 }

9292 Command::Maximize => {

9393 self.wm.layout.expand(ExpandScope::All);

monolith

Commit 21e8e8e5aa3d

Commit `21e8e8e5aa3d`