monolith

public

Star0

Fork 0

Watch0

120 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `54559daf11c3`

tarball

atagen <boss@atagen.co>2026-10-17 13:39 UTC

3 files changed+57-22

layout: expand and report maximized against the visible tree

A window whose container held only hidden siblings looked like a top-level window but expanded inside that container, which changed nothing on screen. Containers where the window has no visible sibling are now skipped.

Modified file: crates/layout/src/lib.rs+5 additions−2 deletions@@ -524,7 +524,7 @@ impl Layout {
         let Some(o) = self.windows.get(w).and_then(|w| w.output) else {
             return false;
         };
-        self.outputs[o].tree.maximized(w)
+        self.outputs[o].tree.maximized(w, self.vis_on(o))
     }
 
     pub fn resize(&mut self, axis: Axis, delta: f64) -> bool {
@@ -546,7 +546,10 @@ impl Layout {
             ExpandScope::Container => (1, 1),
             ExpandScope::All => (0, usize::MAX),
         };
-        self.outputs[o].tree.toggle_expand(w, skip, count)
+        let mut tree = std::mem::take(&mut self.outputs[o].tree);
+        let expanded = tree.toggle_expand(w, skip, count, self.vis_on(o));
+        self.outputs[o].tree = tree;
+        expanded
     }
 
     pub fn flip(&mut self, o: OutputId) {

Modified file: crates/layout/src/tests.rs+18 additions@@ -294,3 +294,21 @@ fn merging_steps_out_of_a_stack_before_joining_another() {
     assert_eq!(rect(a).w, AREA.w);
     assert!(rect(a).bottom() <= rect(b).y && 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]
+fn expand_skips_containers_of_hidden_windows() {
+    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(a, Dir::Right, |_| true));
+    let shown = |w: u32| w != a;
+    assert!(t.toggle_expand(b, 0, 1, shown));
+    assert!(t.maximized(b, shown));
+    let all = t.arrange(AREA, 0.0, shown);
+    let rect = |w| all.iter().find(|p| p.0 == w).unwrap().1;
+    assert_eq!(rect(b).w, AREA.w);
+}

Modified file: crates/layout/src/tree.rs+34 additions−20 deletions@@ -217,20 +217,31 @@ impl<W: Copy + Eq + Hash> Tree<W> {
     }
 
     /// Whether every container above `w` is expanded towards it.
-    pub fn maximized(&self, w: W) -> bool {
+    pub fn maximized(&self, w: W, vis: impl Fn(W) -> bool) -> bool {
+        let path = self.shown_path(w, &vis);
+        !path.is_empty() && path.iter().all(|&(p, c)| self.expanded(p) == Some(c))
+    }
+
+    /// `w`'s ancestry as (container, child) pairs, leaving out containers
+    /// where the child has no visible sibling. Those look like nothing on
+    /// screen, so expanding there would do nothing the user could see.
+    fn shown_path(&self, w: W, vis: &impl Fn(W) -> bool) -> Vec<(NodeId, NodeId)> {
         let Some(&leaf) = self.leaves.get(&w) else {
-            return false;
+            return Vec::new();
         };
+        let mut path = Vec::new();
         let mut cur = leaf;
-        let mut any = false;
         while let Some(p) = self.nodes[cur].parent {
-            if self.expanded(p) != Some(cur) {
-                return false;
+            let shared = self
+                .children(p)
+                .iter()
+                .any(|c| c.node != cur && self.visible(c.node, vis));
+            if shared {
+                path.push((p, cur));
             }
-            any = true;
             cur = p;
         }
-        any
+        path
     }
 
     /// Transposes the whole tree.
@@ -243,19 +254,22 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         }
     }
 
-    /// Toggles expansion for `count` levels of `w`'s ancestry, starting
-    /// `skip` levels up. Level 0 expands the window inside its container.
-    pub fn toggle_expand(&mut self, w: W, skip: usize, count: usize) -> bool {
-        let Some(&leaf) = self.leaves.get(&w) else {
-            return false;
-        };
-        let mut path = Vec::new();
-        let mut cur = leaf;
-        while let Some(p) = self.nodes[cur].parent {
-            path.push((p, cur));
-            cur = p;
-        }
-        let path: Vec<_> = path.into_iter().skip(skip).take(count).collect();
+    /// Toggles expansion for `count` levels of `w`'s visible ancestry,
+    /// starting `skip` levels up. Level 0 expands the window inside the
+    /// nearest container where it has a visible sibling.
+    pub fn toggle_expand(
+        &mut self,
+        w: W,
+        skip: usize,
+        count: usize,
+        vis: impl Fn(W) -> bool,
+    ) -> bool {
+        let path: Vec<_> = self
+            .shown_path(w, &vis)
+            .into_iter()
+            .skip(skip)
+            .take(count)
+            .collect();
         if path.is_empty() {
             return false;
         }

monolith

Commit 54559daf11c3

Commit `54559daf11c3`