monolith

public

Star0

Fork 0

Watch0

134 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `e2443dec4dcd`

tarball

atagen <boss@atagen.co>2026-10-18 10:18 UTC

2 files changed+173-202

layout: keep window sizes on the windows

Sizes lived on container slots, so a row holding windows of other tags kept claiming their room and every move had to hand weight between slots. Carrying it into a lane of hidden windows made the moved window take that lane's whole size, and no rule for passing weight around kept both on-screen sizes and hidden windows' sizes stable. Each window now has its own width and height and a container asks for the mean of its visible children, so moves carry nothing and hidden windows change nothing on screen.

Modified file: crates/layout/src/tests.rs+11 additions−10 deletions@@ -330,8 +330,7 @@ fn expand_skips_containers_of_hidden_windows() {
     assert_eq!(rect(b).w, AREA.w);
 }
 
-/// Joining a stack hands the window's weight to it and leaving hands it back,
-/// so going in and out repeatedly leaves every window the size it was.
+/// Going in and out of a stack repeatedly leaves every window the size it was.
 #[test]
 fn stacking_in_and_out_does_not_drift() {
     for out in [Dir::Up, Dir::Down, Dir::Right] {
@@ -352,8 +351,8 @@ fn stacking_in_and_out_does_not_drift() {
     }
 }
 
-/// Hidden windows in the rows around a window must not soak up its weight
-/// as it passes through their lanes, or it shrinks on every round trip.
+/// Windows of other tags in the rows around a window must not change what
+/// the user sees as it moves through them, nor drift over round trips.
 #[test]
 fn moving_past_hidden_windows_does_not_drift() {
     let (a, b, h, h2) = (1, 2, 3, 4);
@@ -366,15 +365,17 @@ fn moving_past_hidden_windows_does_not_drift() {
     let once = t.arrange(AREA, 0.0, |_| true);
     for _ in 0..4 {
         for d in [Dir::Up, Dir::Up, Dir::Down] {
-            assert!(t.move_window(b, d, vis));
+            t.move_window(b, d, vis);
+            let shown = t.arrange(AREA, 0.0, vis);
+            let r = shown.iter().find(|p| p.0 == b).unwrap().1;
+            assert!(
+                (r.w * r.h - AREA.w * AREA.h / 2.0).abs() < 1e-6,
+                "{d:?} left {r:?}"
+            );
         }
         t.check();
     }
-    let after = t.arrange(AREA, 0.0, |_| true);
-    for ((w, r), (v, s)) in once.iter().zip(&after) {
-        assert_eq!(w, v);
-        assert!((r.y - s.y).abs() < 1e-6 && (r.h - s.h).abs() < 1e-6, "{w}: {r:?} became {s:?}");
-    }
+    assert_eq!(t.arrange(AREA, 0.0, |_| true), once);
 }
 
 /// Monitors sleeping together unplug one after another, so windows already

Modified file: crates/layout/src/tree.rs+162 additions−192 deletions@@ -20,6 +20,13 @@ impl Axis {
             Self::Vertical => Self::Horizontal,
         }
     }
+
+    fn index(self) -> usize {
+        match self {
+            Self::Horizontal => 0,
+            Self::Vertical => 1,
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
@@ -47,18 +54,15 @@ impl Dir {
 
 const MIN_SHARE: f64 = 0.05;
 
-#[derive(Clone, Debug)]
-struct Child {
-    node: NodeId,
-    weight: f64,
-}
+/// A window's width and height relative to its neighbours'.
+type Size = [f64; 2];
 
 #[derive(Clone, Debug)]
 enum Kind<W> {
-    Leaf(W),
+    Leaf(W, Size),
     Container {
         axis: Axis,
-        children: Vec<Child>,
+        children: Vec<NodeId>,
         expanded: Option<NodeId>,
     },
 }
@@ -118,43 +122,45 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         let Some(&a) = self.leaves.get(&anchor) else {
             return self.insert_row(w);
         };
-        let n = self.new_leaf(w);
         match self.position(a) {
             Some((p, i)) if Some(p) == self.root && self.axis(p) == Some(self.stack) => {
-                let weight = self.unlink(p, i).weight;
+                let n = self.new_leaf(w, self.size(a));
+                self.unlink(p, i);
                 let c = self.new_container(self.stack.other());
-                self.attach(c, 0, a, 1.0);
-                self.attach(c, 1, n, 1.0);
-                self.attach(p, i, c, weight);
+                self.attach(c, 0, a);
+                self.attach(c, 1, n);
+                self.attach(p, i, c);
+                self.reveal(n, true);
             }
             Some((p, i)) => {
-                let weight = self.mean_weight(p);
-                self.attach(p, i + 1, n, weight);
+                let n = self.new_leaf(w, self.size(p));
+                self.attach(p, i + 1, n);
+                self.reveal(n, true);
             }
             None => {
+                let n = self.new_leaf(w, self.size(a));
                 let c = self.new_container(self.stack.other());
-                self.attach(c, 0, a, 1.0);
-                self.attach(c, 1, n, 1.0);
+                self.attach(c, 0, a);
+                self.attach(c, 1, n);
                 self.root = Some(c);
             }
         }
-        self.reveal(n, true);
     }
 
     /// Appends `w` as a row of its own along the stacking axis.
     pub fn insert_row(&mut self, w: W) {
-        let n = self.new_leaf(w);
+        let size = self.root.map_or([1.0; 2], |r| self.size(r));
+        let n = self.new_leaf(w, size);
         match self.root {
             None => self.root = Some(n),
             Some(r) if self.axis(r) == Some(self.stack) => {
-                let weight = self.mean_weight(r);
                 let end = self.children(r).len();
-                self.attach(r, end, n, weight);
+                self.attach(r, end, n);
             }
             Some(r) => {
                 let c = self.new_container(self.stack);
-                self.attach(c, 0, r, 1.0);
-                self.attach(c, 1, n, 1.0);
+                self.attach(c, 0, r);
+                self.attach(c, 1, n);
                 self.root = Some(c);
             }
         }
@@ -257,7 +263,7 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             let shared = self
                 .children(p)
                 .iter()
-                .any(|c| c.node != cur && self.visible(c.node, vis));
+                .any(|&c| c != cur && self.visible(c, vis));
             if shared {
                 path.push((p, cur));
             }
@@ -270,8 +276,9 @@ impl<W: Copy + Eq + Hash> Tree<W> {
     pub fn flip(&mut self) {
         self.stack = self.stack.other();
         for node in self.nodes.values_mut() {
-            if let Kind::Container { axis, .. } = &mut node.kind {
-                *axis = axis.other();
+            match &mut node.kind {
+                Kind::Container { axis, .. } => *axis = axis.other(),
+                Kind::Leaf(_, size) => size.reverse(),
             }
         }
     }
@@ -306,30 +313,28 @@ impl<W: Copy + Eq + Hash> Tree<W> {
 
     /// Grows `w` by `delta`, a fraction of the visible length of the nearest
     /// container along `axis` where it has a visible sibling. Hidden siblings
-    /// keep their weights, and with them their share.
+    /// keep their sizes, and with them their share.
     pub fn resize(&mut self, w: W, axis: Axis, delta: f64, vis: impl Fn(W) -> bool) -> bool {
         let Some(&leaf) = self.leaves.get(&w) else {
             return false;
         };
         let mut cur = leaf;
-        while let Some((p, i)) = self.position(cur) {
+        while let Some(p) = self.nodes[cur].parent {
             if self.axis(p) == Some(axis) {
-                let shown: Vec<usize> = (0..self.children(p).len())
-                    .filter(|&j| self.visible(self.children(p)[j].node, &vis))
+                let shown: Vec<(NodeId, f64)> = self
+                    .children(p)
+                    .iter()
+                    .filter(|&&c| self.visible(c, &vis))
+                    .map(|&c| (c, self.extent(c, axis, &vis)))
                     .collect();
                 if shown.len() >= 2 {
-                    let children = self.children_mut(p);
-                    let sum: f64 = shown.iter().map(|&j| children[j].weight).sum();
-                    let old = children[i].weight;
+                    let sum: f64 = shown.iter().map(|s| s.1).sum();
+                    let old = self.extent(cur, axis, &vis);
                     let max = 1.0 - MIN_SHARE * (shown.len() - 1) as f64;
                     let new = (old / sum + delta).clamp(MIN_SHARE, max) * sum;
                     let scale = (sum - new) / (sum - old);
-                    for j in shown {
-                        children[j].weight = if j == i {
-                            new
-                        } else {
-                            children[j].weight * scale
-                        };
+                    for (c, _) in shown {
+                        self.scale(c, axis, if c == cur { new / old } else { scale });
                     }
                     return true;
                 }
@@ -339,6 +344,55 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         false
     }
 
+    /// Scales every window under `n` along `axis`, hidden ones too, so they
+    /// keep their proportions for when they are shown again.
+    fn scale(&mut self, n: NodeId, axis: Axis, by: f64) {
+        match &mut self.nodes[n].kind {
+            Kind::Leaf(_, size) => size[axis.index()] *= by,
+            Kind::Container { children, .. } => {
+                for c in children.clone() {
+                    self.scale(c, axis, by);
+                }
+            }
+        }
+    }
+
+    /// How much room `n` asks for along `axis` among its siblings. A
+    /// container asks for the mean of what its visible children ask for, so
+    /// windows of other tags sharing a lane change nothing on screen, and a
+    /// window carries its own size wherever it moves.
+    fn extent(&self, n: NodeId, axis: Axis, vis: &impl Fn(W) -> bool) -> f64 {
+        match &self.nodes[n].kind {
+            Kind::Leaf(_, size) => size[axis.index()],
+            Kind::Container { children, .. } => {
+                let shown: Vec<f64> = children
+                    .iter()
+                    .filter(|&&c| self.visible(c, vis))
+                    .map(|&c| self.extent(c, axis, vis))
+                    .collect();
+                if shown.is_empty() {
+                    children
+                        .iter()
+                        .map(|&c| self.extent(c, axis, vis))
+                        .sum::<f64>()
+                        / children.len() as f64
+                } else {
+                    shown.iter().sum::<f64>() / shown.len() as f64
+                }
+            }
+        }
+    }
+
+    /// The size a window placed in `n`'s stead would take, ignoring
+    /// visibility since new windows land on any tag.
+    fn size(&self, n: NodeId) -> Size {
+        let all = |_: W| true;
+        [
+            self.extent(n, Axis::Horizontal, &all),
+            self.extent(n, Axis::Vertical, &all),
+        ]
+    }
+
     /// Lays the tree out in `area`. Hidden windows come back as zero-size
     /// rects on the boundary where they would reappear.
     pub fn arrange(&self, area: Rect, gap: f64, vis: impl Fn(W) -> bool) -> Vec<(W, Rect)> {
@@ -363,54 +417,54 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         out: &mut Vec<(W, Rect)>,
     ) {
         let (axis, children, expanded) = match &self.nodes[n].kind {
-            Kind::Leaf(w) => return out.push((*w, r)),
+            Kind::Leaf(w, _) => return out.push((*w, r)),
             Kind::Container {
                 axis,
                 children,
                 expanded,
             } => (*axis, children, *expanded),
         };
-        let shown: Vec<bool> = children.iter().map(|c| self.visible(c.node, vis)).collect();
+        let shown: Vec<bool> = children.iter().map(|&c| self.visible(c, vis)).collect();
         let (start, len) = span(r, axis);
-        if let Some(e) = expanded.and_then(|e| children.iter().position(|c| c.node == e))
+        if let Some(e) = expanded.and_then(|e| children.iter().position(|&c| c == e))
             && shown[e]
         {
-            for (i, c) in children.iter().enumerate() {
+            for (i, &c) in children.iter().enumerate() {
                 let sub = match i.cmp(&e) {
                     std::cmp::Ordering::Equal => r,
                     std::cmp::Ordering::Less => with_span(r, axis, start, 0.0),
                     std::cmp::Ordering::Greater => with_span(r, axis, start + len, 0.0),
                 };
-                self.place(c.node, sub, gap, vis, out);
+                self.place(c, sub, gap, vis, out);
             }
             return;
         }
         let count = shown.iter().filter(|s| **s).count();
-        let total: f64 = children
+        let extents: Vec<f64> = children
             .iter()
             .zip(&shown)
-            .filter(|(_, s)| **s)
-            .map(|(c, _)| c.weight)
-            .sum();
+            .map(|(&c, &s)| if s { self.extent(c, axis, vis) } else { 0.0 })
+            .collect();
+        let total: f64 = extents.iter().sum();
         let gaps = count.saturating_sub(1) as f64;
         let gap = if gaps > 0.0 { gap.min(len / gaps) } else { gap };
         let avail = len - gap * gaps;
         let last = shown.iter().rposition(|s| *s);
         let mut pos = start;
         let mut seen = false;
-        for (i, c) in children.iter().enumerate() {
+        for (i, &c) in children.iter().enumerate() {
             if shown[i] {
                 if seen {
                     pos += gap;
                 }
-                let l = avail * c.weight / total;
-                self.place(c.node, with_span(r, axis, pos, l), gap, vis, out);
+                let l = avail * extents[i] / total;
+                self.place(c, with_span(r, axis, pos, l), gap, vis, out);
                 pos += l;
                 seen = true;
             } else {
                 let between = seen && last.is_some_and(|l| l > i);
                 let at = if between { pos + gap / 2.0 } else { pos };
-                self.place(c.node, with_span(r, axis, at, 0.0), gap, vis, out);
+                self.place(c, with_span(r, axis, at, 0.0), gap, vis, out);
             }
         }
     }
@@ -421,24 +475,23 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             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));
+                    .filter(|&j| enter && !self.visible(self.children(p)[j], vis));
                 if cur != n {
                     if let Some(j) = hidden_lane {
                         self.join_lane(n, p, j);
                     } else {
                         let at = if dir.forward() { i + 1 } else { i };
-                        self.step_out(n, p, i, at);
+                        self.relocate(n, p, at);
                     }
                     return true;
                 }
                 if let Some(j) = self.next_shown(p, i, dir, vis) {
-                    let sib = self.children(p)[j].node;
+                    let sib = self.children(p)[j];
                     if enter && self.axis(sib).is_some() {
                         self.join_lane(n, p, j);
                     } else {
                         let children = self.children_mut(p);
-                        children[i].node = sib;
-                        children[j].node = n;
+                        children.swap(i, j);
                     }
                     return true;
                 }
@@ -453,27 +506,25 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             return false;
         }
         let (old, i) = self.position(n).expect("n is below the root");
-        self.release_share(n);
         self.unlink(old, i);
         self.normalize(old);
         let r = self.root.expect("the rest of the tree survives");
         if self.axis(r) == Some(dir.axis()) {
-            let weight = self.mean_weight(r);
             let at = if dir.forward() {
                 self.children(r).len()
             } else {
                 0
             };
-            self.attach(r, at, n, weight);
+            self.attach(r, at, n);
         } else {
             let c = self.new_container(dir.axis());
-            self.attach(c, 0, r, 1.0);
+            self.attach(c, 0, r);
             let at = if dir.forward() {
                 self.children(c).len()
             } else {
                 0
             };
-            self.attach(c, at, n, 1.0);
+            self.attach(c, at, n);
             self.root = Some(c);
         }
         true
@@ -482,9 +533,9 @@ impl<W: Copy + Eq + Hash> Tree<W> {
     fn next_shown(&self, p: NodeId, i: usize, dir: Dir, vis: &impl Fn(W) -> bool) -> Option<usize> {
         let children = self.children(p);
         if dir.forward() {
-            (i + 1..children.len()).find(|&j| self.visible(children[j].node, vis))
+            (i + 1..children.len()).find(|&j| self.visible(children[j], vis))
         } else {
-            (0..i).rev().find(|&j| self.visible(children[j].node, vis))
+            (0..i).rev().find(|&j| self.visible(children[j], vis))
         }
     }
 
@@ -500,129 +551,52 @@ impl<W: Copy + Eq + Hash> Tree<W> {
     /// Moves `n` to the end of the lane at `p`'s child `j`. A lone window
     /// there becomes a lane of its own, perpendicular to `p`.
     fn join_lane(&mut self, n: NodeId, p: NodeId, j: usize) {
-        let lane = self.children(p)[j].node;
+        let lane = self.children(p)[j];
         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.children_mut(p)[j] = 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);
+            self.attach(c, 0, lane);
             c
         };
         let end = self.children(lane).len();
-        let (old, i) = self.position(n).expect("n is below p");
-        let weight = if old == p {
-            Some(self.children(p)[i].weight)
-        } else if self.position(old).is_some_and(|(q, _)| q == p) {
-            self.release_share(n)
-        } else {
-            None
-        };
-        let inner = match weight {
-            Some(weight) => {
-                let k = self.position(lane).expect("lanes sit in p").1;
-                let total: f64 = self.children(lane).iter().map(|c| c.weight).sum();
-                total * weight / self.children(p)[k].weight
-            }
-            None => self.mean_weight(lane),
-        };
-        self.relocate_weighted(n, lane, end, inner);
-        if let Some(weight) = weight
-            && self.nodes.contains_key(lane)
-            && let Some((q, k)) = self.position(lane)
-            && q == p
-        {
-            self.children_mut(p)[k].weight += weight;
-        }
-    }
-
-    /// Moves `n` out of `p`'s child `i` to sit beside it at `at`, taking
-    /// along the share of that child's weight it had.
-    fn step_out(&mut self, n: NodeId, p: NodeId, i: usize, at: usize) {
-        let cur = self.children(p)[i].node;
-        let Some((parent, k)) = self.position(n).filter(|&(q, _)| q == cur) else {
-            self.relocate(n, p, at);
-            return;
-        };
-        let share = self.release_share(n).unwrap_or_else(|| self.mean_weight(p));
-        self.unlink(parent, k);
-        self.attach(p, at, n, share);
-        self.normalize(parent);
-    }
-
-    /// Takes `n`'s share of its container's weight away from the container,
-    /// for `n` to carry out. Joining a lane hands a window's weight to the
-    /// lane, so leaving gives it back and windows going in and out of
-    /// stacks do not shrink their neighbours a little more each time.
-    fn release_share(&mut self, n: NodeId) -> Option<f64> {
-        let (old, i) = self.position(n)?;
-        let (q, k) = self.position(old)?;
-        let total: f64 = self.children(old).iter().map(|c| c.weight).sum();
-        let share = self.children(q)[k].weight * self.children(old)[i].weight / total;
-        self.children_mut(q)[k].weight -= share;
-        Some(share)
+        self.relocate(n, lane, end);
     }
 
     fn relocate(&mut self, n: NodeId, p: NodeId, at: usize) {
-        self.relocate_weighted(n, p, at, self.mean_weight(p));
-    }
-
-    fn relocate_weighted(&mut self, n: NodeId, p: NodeId, at: usize, weight: f64) {
         let (old, i) = self.position(n).expect("relocated nodes have a parent");
         let at = if old == p && i < at { at - 1 } else { at };
         self.unlink(old, i);
-        self.attach(p, at, n, weight);
+        self.attach(p, at, n);
         self.normalize(old);
     }
 
     /// Places `node` among `p`'s children. A container running along `p`'s
     /// axis is dissolved into `p` so axes keep alternating.
-    fn attach(&mut self, p: NodeId, at: usize, node: NodeId, weight: f64) {
-        if self.axis(node) == self.axis(p) {
-            let Some(Node {
-                kind: Kind::Container { children, .. },
-                ..
-            }) = self.nodes.remove(node)
-            else {
-                unreachable!("only containers have an axis");
-            };
-            let total: f64 = children.iter().map(|c| c.weight).sum();
-            for (k, c) in children.into_iter().enumerate() {
-                self.nodes[c.node].parent = Some(p);
-                let weight = weight * c.weight / total;
-                self.children_mut(p).insert(
-                    at + k,
-                    Child {
-                        node: c.node,
-                        weight,
-                    },
-                );
+    fn attach(&mut self, p: NodeId, at: usize, node: NodeId) {
+        if self.axis(node).is_some() && self.axis(node) == self.axis(p) {
+            let children = self.children(node).to_vec();
+            self.nodes.remove(node);
+            for (k, &c) in children.iter().enumerate() {
+                self.nodes[c].parent = Some(p);
+                self.children_mut(p).insert(at + k, c);
             }
         } else {
             self.nodes[node].parent = Some(p);
-            self.children_mut(p).insert(at, Child { node, weight });
+            self.children_mut(p).insert(at, node);
         }
     }
 
-    fn unlink(&mut self, p: NodeId, i: usize) -> Child {
-        let Kind::Container {
-            children, expanded, ..
-        } = &mut self.nodes[p].kind
-        else {
-            unreachable!("parents are containers");
-        };
-        let child = children.remove(i);
-        if *expanded == Some(child.node) {
-            *expanded = None;
-        }
-        self.nodes[child.node].parent = None;
-        child
+    fn unlink(&mut self, p: NodeId, i: usize) {
+        let child = self.unlink_dead(p, i);
+        self.nodes[child].parent = None;
     }
 
     fn detach(&mut self, n: NodeId) {
@@ -657,25 +631,25 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             }
             (None, None) => self.root = None,
             (Some(only), Some((p, i))) => {
-                let weight = self.unlink_dead(p, i).weight;
-                let leaf_like = self.axis(only.node) != self.axis(p);
-                self.attach(p, i, only.node, weight);
+                self.unlink_dead(p, i);
+                let leaf_like = self.axis(only) != self.axis(p);
+                self.attach(p, i, only);
                 if was_expanded
                     && leaf_like
                     && let Kind::Container { expanded, .. } = &mut self.nodes[p].kind
                 {
-                    *expanded = Some(only.node);
+                    *expanded = Some(only);
                 }
             }
             (Some(only), None) => {
-                self.nodes[only.node].parent = None;
-                self.root = Some(only.node);
+                self.nodes[only].parent = None;
+                self.root = Some(only);
             }
         }
     }
 
     /// Like `unlink`, for a child whose node is already gone.
-    fn unlink_dead(&mut self, p: NodeId, i: usize) -> Child {
+    fn unlink_dead(&mut self, p: NodeId, i: usize) -> NodeId {
         let Kind::Container {
             children, expanded, ..
         } = &mut self.nodes[p].kind
@@ -683,16 +657,16 @@ impl<W: Copy + Eq + Hash> Tree<W> {
             unreachable!("parents are containers");
         };
         let child = children.remove(i);
-        if *expanded == Some(child.node) {
+        if *expanded == Some(child) {
             *expanded = None;
         }
         child
     }
 
-    fn new_leaf(&mut self, w: W) -> NodeId {
+    fn new_leaf(&mut self, w: W, size: Size) -> NodeId {
         let n = self.nodes.insert(Node {
             parent: None,
-            kind: Kind::Leaf(w),
+            kind: Kind::Leaf(w, size),
         });
         self.leaves.insert(w, n);
         n
@@ -711,51 +685,42 @@ impl<W: Copy + Eq + Hash> Tree<W> {
 
     fn position(&self, n: NodeId) -> Option<(NodeId, usize)> {
         let p = self.nodes[n].parent?;
-        let i = self.children(p).iter().position(|c| c.node == n)?;
+        let i = self.children(p).iter().position(|&c| c == n)?;
         Some((p, i))
     }
 
     fn axis(&self, n: NodeId) -> Option<Axis> {
         match &self.nodes[n].kind {
             Kind::Container { axis, .. } => Some(*axis),
-            Kind::Leaf(_) => None,
+            Kind::Leaf(..) => None,
         }
     }
 
     fn expanded(&self, n: NodeId) -> Option<NodeId> {
         match &self.nodes[n].kind {
             Kind::Container { expanded, .. } => *expanded,
-            Kind::Leaf(_) => None,
+            Kind::Leaf(..) => None,
         }
     }
 
-    fn children(&self, n: NodeId) -> &[Child] {
+    fn children(&self, n: NodeId) -> &[NodeId] {
         match &self.nodes[n].kind {
             Kind::Container { children, .. } => children,
-            Kind::Leaf(_) => &[],
+            Kind::Leaf(..) => &[],
         }
     }
 
-    fn children_mut(&mut self, n: NodeId) -> &mut Vec<Child> {
+    fn children_mut(&mut self, n: NodeId) -> &mut Vec<NodeId> {
         match &mut self.nodes[n].kind {
             Kind::Container { children, .. } => children,
-            Kind::Leaf(_) => unreachable!("leaves have no children"),
-        }
-    }
-
-    fn mean_weight(&self, p: NodeId) -> f64 {
-        let children = self.children(p);
-        if children.is_empty() {
-            1.0
-        } else {
-            children.iter().map(|c| c.weight).sum::<f64>() / children.len() as f64
+            Kind::Leaf(..) => unreachable!("leaves have no children"),
         }
     }
 
     fn visible(&self, n: NodeId, vis: &impl Fn(W) -> bool) -> bool {
         match &self.nodes[n].kind {
-            Kind::Leaf(w) => vis(*w),
-            Kind::Container { children, .. } => children.iter().any(|c| self.visible(c.node, vis)),
+            Kind::Leaf(w, _) => vis(*w),
+            Kind::Container { children, .. } => children.iter().any(|&c| self.visible(c, vis)),
         }
     }
 
@@ -770,14 +735,20 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         };
         assert_eq!(reachable, self.nodes.len(), "orphaned nodes");
         for (&w, &n) in &self.leaves {
-            assert!(matches!(self.nodes[n].kind, Kind::Leaf(x) if x == w));
+            assert!(matches!(self.nodes[n].kind, Kind::Leaf(x, _) if x == w));
         }
     }
 
     #[cfg(test)]
     fn check_node(&self, n: NodeId) -> usize {
         match &self.nodes[n].kind {
-            Kind::Leaf(_) => 1,
+            Kind::Leaf(_, size) => {
+                assert!(
+                    size.iter().all(|s| *s > 0.0 && s.is_finite()),
+                    "size {size:?}"
+                );
+                1
+            }
             Kind::Container {
                 axis,
                 children,
@@ -789,14 +760,13 @@ impl<W: Copy + Eq + Hash> Tree<W> {
                     children.len()
                 );
                 if let Some(e) = expanded {
-                    assert!(children.iter().any(|c| c.node == *e));
+                    assert!(children.contains(e));
                 }
                 let mut count = 1;
-                for c in children {
-                    assert!(c.weight > 0.0 && c.weight.is_finite());
-                    assert_eq!(self.nodes[c.node].parent, Some(n));
-                    assert_ne!(self.axis(c.node), Some(*axis), "axes must alternate");
-                    count += self.check_node(c.node);
+                for &c in children {
+                    assert_eq!(self.nodes[c].parent, Some(n));
+                    assert_ne!(self.axis(c), Some(*axis), "axes must alternate");
+                    count += self.check_node(c);
                 }
                 count
             }

monolith

Commit e2443dec4dcd

Commit `e2443dec4dcd`