Experiment: say the room from the cursor as an inset, and read the row's length only where a slot depends on it

Measured identical to its parent at every phase of the cost rig; kept as
evidence, not proposed for landing.

Cargo.toml

@@ -25,12 +25,6 @@ tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread", "time"]
 [workspace]
 members = ["core", "macro", "rig-input"]
 
-# Full debug info was the bulk of what the linker wrote here and almost none of
-# what anything read. `dev` keeps line tables and scopes, which is what stepping
-# through an example wants; the tests keep the line tables alone, which is what
-# a backtrace reads. Measured when the tests became one target: relinking them
-# went from 9.8 s to 7.7 s with these, and target/ from 45 GB to 13 GB with the
-# two changes together.
 [profile.dev]
 debug = 1
 

TODO

@@ -14,27 +14,3 @@ WidgetRef<W> or smth instead of Id
 vecs for each widget type?
 
 POTENTIAL BUG: closures that store IDs will not decrement the id!!! need to not increment id if moved into closure somehow??? wait no, need to decrement ID every time an event fn is added...... only if the id is used in it..??
-
-transforms on a move entry (scale + rotation)
-    an entry is a translation today; composing through one scales the rel
-    part and passes px through untouched, so fixed-size content and glyphs
-    do not follow a shortened entry
-    want a real transform per entry, resolved in resolve_move the way the
-    translation already is, so a whole subtree transforms with one buffer
-    write and no redraw
-    wanted for compose-style stretch at the end of a scroll area, and for
-    rotation generally
-
-a prepare stage on Event, so Data has no placeholder field
-    run_sensors builds one CursorData per widget and has to put something in
-    `sense` before anything knows which sense matched, so it writes
-    CursorSense::Hovering and says in place that it means nothing;
-    should_run then clones the whole thing to overwrite that one field
-    the state is representable only because the type lets the caller say it:
-    what the caller supplies and what matching adds are two different things
-    wearing one struct
-    the awkward part is doing it without the generics getting annoying --
-    Data<'a> is already a GAT with a default, and splitting it in two adds
-    another associated type to every Event impl for the sake of one field
-    (Bryan, 2026-09-20; low priority, he wants a good answer rather than a
-    quick one)

core/src/fixed.rs

@@ -131,6 +131,14 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
         self.0 as f32 / Self::one().0 as f32
     }
 
+    /// The same value on another grid, rounded where the new one is coarser.
+    pub const fn to_scale<const TO: u32>(self) -> Fixed<TO> {
+        Fixed(match TO >= SHIFT {
+            true => self.0 << (TO - SHIFT),
+            false => shift_round(self.0 as i64, SHIFT - TO) as i32,
+        })
+    }
+
     pub const fn add(self, rhs: Self) -> Self {
         Self(self.0.wrapping_add(rhs.0))
     }
@@ -238,6 +246,16 @@ impl<const SHIFT: u32> Fixed<SHIFT> {
     }
 }
 
+/// Back to a single step, rounding halves away from zero so that a value and
+/// its negation round to the same distance.
+const fn shift_round(v: i64, bits: u32) -> i64 {
+    let half = (1i64 << bits) >> 1;
+    match v < 0 {
+        true => -((-v + half) >> bits),
+        false => (v + half) >> bits,
+    }
+}
+
 const fn div_round(num: i64, den: i64) -> i64 {
     let (q, rem) = (num / den, num % den);
     match rem.unsigned_abs() * 2 >= den.unsigned_abs() {
@@ -513,6 +531,15 @@ mod tests {
         assert_eq!(Px::from_f32(-1e12), Px::MIN);
     }
 
+    #[test]
+    fn a_coarser_grid_rounds_and_a_finer_one_does_not() {
+        // A third, which neither grid holds exactly.
+        let third = Rel::ONE / Rel::from_int(3);
+        assert_eq!(third.to_scale::<6>(), Fixed::<6>::from_raw(21));
+        let coarse = Fixed::<6>::from_raw(21);
+        assert_eq!(coarse.to_scale::<24>().to_scale::<6>(), coarse);
+    }
+
     #[test]
     fn lerp_takes_the_fraction_as_the_receiver() {
         let (from, to) = (Px::from_int(10), Px::from_int(20));

core/src/layout_diagnostics.rs

@@ -15,7 +15,7 @@
 //! reuse, size, placement, and text events for one suspicious widget. The
 //! selection is a set and survives [`take`] until cleared.
 
-use crate::{Axis, LayoutHolds, LayoutLen, PxVec2, Size, UiRegion, UiVec2, WidgetId};
+use crate::{Axis, LayoutLen, PxVec2, Size, UiRegion, WidgetId};
 use std::{
     cell::RefCell,
     collections::{HashMap, HashSet},
@@ -23,71 +23,100 @@ use std::{
     time::Instant,
 };
 
-/// Declares a counter or timer kind beside the name its report prints. Two
+#[derive(Clone, Copy)]
-/// lists in the same order was one list too many: a variant inserted without
+pub(crate) enum Counter {
-/// its label moving with it renames every total after it, and nothing says
+    Updates,
-/// so.
+    DrawRequests,
-macro_rules! labelled {
+    WidgetDraws,
-    ($(#[$meta:meta])* $vis:vis enum $Name:ident { $($variant:ident = $label:literal,)* }) => {
+    RegionNodeDraws,
-        $(#[$meta])*
+    SizeReads,
-        #[derive(Clone, Copy)]
+    HintHits,
-        $vis enum $Name { $($variant,)* }
+    HintMisses,
-
+    ReuseAttempts,
-        impl $Name {
+    ReuseExact,
-            const COUNT: usize = [$($label,)*].len();
+    ReuseMoved,
-            const NAMES: [&'static str; Self::COUNT] = [$($label,)*];
+    ReuseDirty,
-        }
+    ReuseWrongParent,
-    };
+    ReuseRemapped,
+    ReuseOutside,
+    ReuseWrongLayer,
+    ReuseWrongNode,
+    QueuePops,
+    DepthReads,
+    LocalRedraws,
+    SizeChanges,
+    ReaderEdges,
+    PrimitiveWrites,
+    TextRenders,
+    TextShapeHits,
+    TextShapes,
+    TextBreaks,
+    GlyphPlacements,
+    OutsidePinnedLen,
+    OutsideFrame,
+    OutsideExtent,
 }
 
-labelled! {
+impl Counter {
-    pub(crate) enum Counter {
+    const COUNT: usize = Self::OutsideExtent as usize + 1;
-        Updates = "updates",
+
-        DrawRequests = "draw requests",
+    const NAMES: [&'static str; Self::COUNT] = [
-        WidgetDraws = "widget draws",
+        "updates",
-        RegionNodeDraws = "region-node draws",
+        "draw requests",
-        SizeReads = "draw-result size reads",
+        "widget draws",
-        HintHits = "hint hits",
+        "region-node draws",
-        HintMisses = "hint misses",
+        "draw-result size reads",
-        ReuseAttempts = "reuse attempts",
+        "hint hits",
-        ReuseExact = "reuse exact",
+        "hint misses",
-        ReuseMoved = "reuse moved",
+        "reuse attempts",
-        ReuseDirty = "reuse: dirty",
+        "reuse exact",
-        ReuseUndrawn = "reuse: nothing drawn to keep",
+        "reuse moved",
-        ReuseWrongParent = "reuse: wrong parent",
+        "reuse: dirty",
-        ReuseRemapped = "reuse remapped",
+        "reuse: wrong parent",
-        ReuseOutside = "reuse: outside what it holds for",
+        "reuse remapped",
-        ReuseWrongLayer = "reuse: another layer",
+        "reuse: outside what it holds for",
-        ReuseWrongNode = "reuse: region-node choice changed",
+        "reuse: another layer",
-        ReuseWrongMask = "reuse: a different inherited mask",
+        "reuse: region-node choice changed",
-        QueuePops = "redraw queue pops",
+        "redraw queue pops",
-        DepthReads = "depth reads",
+        "depth reads",
-        LocalRedraws = "local redraws",
+        "local redraws",
-        SizeChanges = "size changes",
+        "size changes",
-        ReaderEdges = "reader edges",
+        "reader edges",
-        PrimitiveWrites = "primitive writes",
+        "primitive writes",
-        TextRenders = "text renders",
+        "text renders",
-        TextShapeHits = "text shape hits",
+        "text shape hits",
-        TextShapes = "text shapes",
+        "text shapes",
-        TextBreaks = "text line breaks",
+        "text line breaks",
-        GlyphPlacements = "glyph placements",
+        "glyph placements",
-        OutsidePinnedLen = "reuse outside: the length it was pinned to",
+        "reuse outside: the length it was pinned to",
-        OutsideWindow = "reuse outside: this window",
+        "reuse outside: a frame length",
-        OutsideRelBase = "reuse outside: a rel base",
+        "reuse outside: an extent length",
-        OutsideRegion = "reuse outside: a region length",
+    ];
-    }
 }
 
-labelled! {
+#[derive(Clone, Copy)]
-    pub(crate) enum TimerKind {
+pub(crate) enum TimerKind {
-        Update = "update total",
+    Update,
-        FullLayout = "full layout",
+    FullLayout,
-        IncrementalLayout = "incremental layout",
+    IncrementalLayout,
-        TextRender = "text render",
+    TextRender,
-        TextShape = "text shape",
+    TextShape,
-        TextBreak = "text line break",
+    TextBreak,
-        GlyphPlacement = "glyph placement",
+    GlyphPlacement,
-    }
+}
+
+impl TimerKind {
+    const COUNT: usize = Self::GlyphPlacement as usize + 1;
+
+    const NAMES: [&'static str; Self::COUNT] = [
+        "update total",
+        "full layout",
+        "incremental layout",
+        "text render",
+        "text shape",
+        "text line break",
+        "glyph placement",
+    ];
 }
 
 #[derive(Clone)]
@@ -222,8 +251,6 @@ pub enum ReuseOutcome {
     Dirty,
     WrongParent,
     WrongLayer,
-    WrongMask,
-    WrongNode,
     Remapped,
     Outside,
     Undrawn,
@@ -237,7 +264,7 @@ pub enum TraceEvent {
         id: WidgetId,
         parent: Option<WidgetId>,
         region: UiRegion,
-        region_px: PxVec2,
+        pixel_size: PxVec2,
         region_node: bool,
     },
     Reuse {
@@ -333,7 +360,7 @@ pub(crate) fn draw_request(
     id: WidgetId,
     parent: Option<WidgetId>,
     region: UiRegion,
-    region_px: PxVec2,
+    pixel_size: PxVec2,
     region_node: bool,
 ) {
     trace(
@@ -342,7 +369,7 @@ pub(crate) fn draw_request(
             id,
             parent,
             region,
-            region_px,
+            pixel_size,
             region_node,
         },
     );
@@ -352,41 +379,6 @@ pub(crate) fn reuse(id: WidgetId, outcome: ReuseOutcome) {
     trace(id, TraceEvent::Reuse { id, outcome });
 }
 
-/// A drawing that cannot be reused because the box on offer is outside what
-/// it holds for, and which of the four contracts said so. They overlap: a
-/// drawing can be outside two of them at once, and counting each is what
-/// says where a rel base redrawing more than it should is coming from.
-pub(crate) fn outside(
-    id: WidgetId,
-    holds: LayoutHolds,
-    region: UiRegion,
-    rel_base: UiVec2,
-    window: PxVec2,
-) {
-    for axis in Axis::BOTH {
-        let holds = holds[axis];
-        let len = region[axis].len();
-        let window = window[axis];
-        if holds.region_len.is_some_and(|pinned| pinned != len) {
-            bump(Counter::OutsidePinnedLen);
-        }
-        if !holds.window.contains(window) {
-            bump(Counter::OutsideWindow);
-        }
-        if holds
-            .rel_base
-            .is_some_and(|pinned| pinned != rel_base[axis])
-        {
-            bump(Counter::OutsideRelBase);
-        }
-        if !holds.region.contains(len.to_px(window)) {
-            bump(Counter::OutsideRegion);
-        }
-    }
-    bump(Counter::ReuseOutside);
-    reuse(id, ReuseOutcome::Outside);
-}
-
 pub(crate) fn size_reported(id: WidgetId, size: Size) {
     trace(id, TraceEvent::SizeReported { id, size });
 }

core/src/lib.rs

@@ -9,7 +9,6 @@
 #![feature(unsize)]
 #![feature(coerce_unsized)]
 #![feature(option_into_flat_iter)]
-#![feature(const_index)]
 
 #[cfg(feature = "layout-diagnostics")]
 pub mod layout_diagnostics;

core/src/orientation/align.rs

@@ -1,9 +1,8 @@
-use crate::util::impl_axis_index;
 use crate::{Px, Rel};
 
 use super::*;
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq)]
 pub struct Align {
     pub x: Option<AxisAlign>,
     pub y: Option<AxisAlign>,
@@ -84,6 +83,28 @@ pub struct RegionAlign {
     pub y: AxisAlign,
 }
 
+impl RegionAlign {
+    /// Both axes at the near edge: the start of a box in its own orientation.
+    pub const NEAR: Self = Self {
+        x: AxisAlign::NEG,
+        y: AxisAlign::NEG,
+    };
+
+    pub fn axis(&self, axis: Axis) -> AxisAlign {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+
+    pub fn axis_mut(&mut self, axis: Axis) -> &mut AxisAlign {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+}
+
 impl RegionAlign {
     pub const TOP_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::NEG);
     pub const TOP_CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::NEG);
@@ -151,15 +172,13 @@ impl Vec2 {
 }
 
 impl Len {
-    /// This length placed in the box it is measured in: the alignment names a
-    /// point along that box, and the two ends are that point less the part of
-    /// the length falling before it and plus the part falling after.
     pub const fn align(&self, align: AxisAlign) -> UiSpan {
         let rel = align.rel();
+        let rest = Rel::ONE.sub(rel);
         let at = Len::from_parts(rel, Px::ZERO);
         UiSpan {
-            start: at - self.scale(rel),
+            start: Len::from_parts(at.rel.sub(self.rel.mul(rel)), at.px.sub(self.px.mul(rel))),
-            end: at + self.scale(Rel::ONE.sub(rel)),
+            end: Len::from_parts(at.rel.add(self.rel.mul(rest)), at.px.add(self.px.mul(rest))),
         }
     }
 }
@@ -212,6 +231,3 @@ impl RegionAlign {
         UiVec2::from(self)
     }
 }
-
-impl_axis_index!(RegionAlign => AxisAlign);
-impl_axis_index!(Align => Option<AxisAlign>);

core/src/orientation/axis.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::util::impl_axis_index;
 use crate::{Fixed, FixedVec2};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -9,8 +8,14 @@ pub enum Axis {
 }
 
 impl Axis {
-    /// Both of them, for the layout code that asks the same question of each.
+    /// A per-axis pair with `aligned` on this axis and `ortho` on the other,
-    pub const BOTH: [Self; 2] = [Self::X, Self::Y];
+    /// which is what `from_axis` does for a vector.
+    pub fn pair<T>(self, aligned: T, ortho: T) -> [T; 2] {
+        match self {
+            Self::X => [aligned, ortho],
+            Self::Y => [ortho, aligned],
+        }
+    }
 }
 
 impl std::ops::Not for Axis {
@@ -48,6 +53,20 @@ pub enum Sign {
 }
 
 impl<const SHIFT: u32> FixedVec2<SHIFT> {
+    pub const fn axis(&self, axis: Axis) -> Fixed<SHIFT> {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+
+    pub const fn axis_mut(&mut self, axis: Axis) -> &mut Fixed<SHIFT> {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+
     pub const fn from_axis(axis: Axis, aligned: Fixed<SHIFT>, ortho: Fixed<SHIFT>) -> Self {
         match axis {
             Axis::X => Self::new(aligned, ortho),
@@ -57,6 +76,20 @@ impl<const SHIFT: u32> FixedVec2<SHIFT> {
 }
 
 impl Vec2 {
+    pub fn axis(&self, axis: Axis) -> f32 {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+
+    pub fn axis_mut(&mut self, axis: Axis) -> &mut f32 {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+
     pub const fn from_axis(axis: Axis, aligned: f32, ortho: f32) -> Self {
         Self {
             x: match axis {
@@ -71,5 +104,47 @@ impl Vec2 {
     }
 }
 
-impl_axis_index!({const SHIFT: u32} FixedVec2<SHIFT> => Fixed<SHIFT>);
+pub const trait AxisT {
-impl_axis_index!(Vec2 => f32);
+    fn get() -> Axis;
+}
+
+pub struct XAxis;
+const impl AxisT for XAxis {
+    fn get() -> Axis {
+        Axis::X
+    }
+}
+
+pub struct YAxis;
+const impl AxisT for YAxis {
+    fn get() -> Axis {
+        Axis::Y
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct BothAxis<T> {
+    pub x: T,
+    pub y: T,
+}
+
+impl<T> BothAxis<T> {
+    pub const fn axis<A: const AxisT>(&mut self) -> &mut T {
+        match A::get() {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+    pub fn take_axis<A: const AxisT>(self) -> T {
+        match A::get() {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+    pub fn axis_dyn(&mut self, axis: Axis) -> &mut T {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+}

core/src/orientation/len.rs

@@ -1,5 +1,4 @@
 use super::*;
-use crate::util::impl_axis_index;
 use crate::{Px, PxVec2, Rel, UiNum, Weight, util::impl_op};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
@@ -23,14 +22,6 @@ pub struct LayoutLen {
     pub leftover: Weight,
 }
 
-/// A bare number is pixels, which is the one length that needs no box to be
-/// read in.
-impl<N: UiNum> From<N> for Len {
-    fn from(value: N) -> Self {
-        Len::px(value.to_f32())
-    }
-}
-
 impl<N: UiNum> From<N> for LayoutLen {
     fn from(value: N) -> Self {
         LayoutLen::px(value.to_f32())
@@ -127,6 +118,20 @@ impl Size {
             },
         }
     }
+
+    pub fn axis(&self, axis: Axis) -> LayoutLen {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+
+    pub fn axis_mut(&mut self, axis: Axis) -> &mut LayoutLen {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
 }
 
 impl LayoutLen {
@@ -153,39 +158,11 @@ impl LayoutLen {
         Len::from_parts(self.rel.add(share), self.px)
     }
 
-    /// Only pixels: the same number of them whatever box it lands in, and
-    /// whatever anyone else in the row asks for. A length that is any part
-    /// of a box or of what is left over is not one.
-    pub fn is_px(&self) -> bool {
-        self.rel == Rel::ZERO && self.leftover == Weight::ZERO
-    }
-
-    /// Nothing but a claim on what is left over, so there is no length here
-    /// at all where nothing is.
-    pub fn is_only_leftover(&self) -> bool {
-        self.leftover > Weight::ZERO && self.without_leftover() == Len::ZERO
-    }
-
-    /// This as a length of a box, where it is one. `leftover` is not: a
-    /// share of what is left over is a length only to whoever divides one,
-    /// so it passes up in the reported size instead and is resolved there.
-    pub fn declared(&self) -> Option<Len> {
-        (self.leftover == Weight::ZERO).then(|| self.without_leftover())
-    }
-
-    /// What this takes whatever is left over: the reading of a length for
-    /// anyone not dividing a box between siblings, where a share is a claim
-    /// on someone else's room rather than a length of its own.
-    /// [`Self::apply_leftover`] is the opposite reading of the same value.
-    pub const fn without_leftover(&self) -> Len {
-        Len::from_parts(self.rel, self.px)
-    }
-
     /// This length, given as a part of a box `len` long, as a part of the
     /// box `len` is itself a part of. The share is untouched: it is a claim
     /// on whoever divides the room, not a fraction of anything.
     pub const fn within_len(self, len: Len) -> Self {
-        let part = self.without_leftover().within_len(len);
+        let part = Len::from_parts(self.rel, self.px).within_len(len);
         Self {
             px: part.px,
             rel: part.rel,
@@ -259,5 +236,3 @@ impl std::fmt::Display for LayoutLen {
         Ok(())
     }
 }
-
-impl_axis_index!(Size => LayoutLen);

core/src/orientation/pos.rs

@@ -1,4 +1,3 @@
-use crate::util::impl_axis_index;
 use std::{fmt::Display, marker::Destruct};
 
 use super::*;
@@ -62,6 +61,20 @@ impl UiVec2 {
         }
     }
 
+    pub fn axis_mut(&mut self, axis: Axis) -> &mut Len {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+
+    pub fn axis(&self, axis: Axis) -> Len {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+
     /// Resolved against a box of `size`, which is where a fraction stops
     /// being one and becomes a place.
     pub fn to_px(&self, size: PxVec2) -> PxVec2 {
@@ -163,6 +176,14 @@ impl Len {
         Self::from_parts(Rel::ZERO, Px::from_f32(px))
     }
 
+    pub const fn rel_min() -> Self {
+        Self::ZERO
+    }
+
+    pub const fn rel_max() -> Self {
+        Self::FULL
+    }
+
     pub const fn max(&self, other: Self) -> Self {
         Self {
             rel: self.rel.max(other.rel),
@@ -205,6 +226,10 @@ impl Len {
         })
     }
 
+    pub fn select_len(&self, len: Len) -> Self {
+        len.within_len(*self)
+    }
+
     pub const fn flip(&mut self) {
         self.rel = Rel::ONE.sub(self.rel);
         self.px = self.px.neg();
@@ -269,18 +294,18 @@ impl UiSpan {
         }
     }
 
-    /// A box `len` long inside this one, on the side `align` says. Both must
-    /// be lengths of the same rel base: it subtracts one from the other
-    /// rather than composing it in, which is what keeps a fraction the same
-    /// fraction however long this box turns out to be.
-    pub const fn place(self, len: Len, align: AxisAlign) -> Self {
-        let start = self.start + (self.len() - len).scale(align.rel());
-        Self::new(start, start + len)
-    }
-
     pub const fn len(&self) -> Len {
         self.end - self.start
     }
+
+    /// Both ends by the same amount, which is what moving a box without
+    /// changing its length does to every part of it.
+    pub const fn translated(self, by: Len) -> Self {
+        Self {
+            start: self.start + by,
+            end: self.end + by,
+        }
+    }
 }
 
 #[repr(C)]
@@ -291,6 +316,17 @@ pub struct UiRegion {
 }
 
 impl UiRegion {
+    /// Every part of the box by the same amount on each axis. Done to the
+    /// whole region rather than an end at a time, because that is what it is
+    /// -- and because four adds in a row are four adds, where four asked for
+    /// separately are four sequences.
+    pub const fn translated(self, x: Len, y: Len) -> Self {
+        Self {
+            x: self.x.translated(x),
+            y: self.y.translated(y),
+        }
+    }
+
     pub const FULL: Self = Self {
         x: UiSpan::FULL,
         y: UiSpan::FULL,
@@ -312,6 +348,20 @@ impl UiRegion {
             y: self.y.within(&parent.y),
         }
     }
+    pub const fn axis(&self, axis: Axis) -> &UiSpan {
+        match axis {
+            Axis::X => &self.x,
+            Axis::Y => &self.y,
+        }
+    }
+
+    pub const fn axis_mut(&mut self, axis: Axis) -> &mut UiSpan {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+
     pub const fn flip(&mut self, axis: Axis) {
         match axis {
             Axis::X => self.x.flip(),
@@ -412,6 +462,3 @@ impl Display for PixelRegion {
         write!(f, "{} -> {}", self.top_left, self.bot_right)
     }
 }
-
-impl_axis_index!(UiVec2 => Len);
-impl_axis_index!(UiRegion => UiSpan);

core/src/primitive/text.rs

@@ -133,6 +133,10 @@ impl TextBuffer {
         }
     }
 
+    pub fn new_empty() -> Self {
+        Self::new("")
+    }
+
     pub fn text(&self) -> &str {
         &self.text
     }

core/src/render/atlas.rs

@@ -167,6 +167,10 @@ impl GlyphAtlas {
     pub fn page_count(&self) -> u32 {
         self.pages.len() as u32
     }
+
+    pub fn glyph_count(&self) -> usize {
+        self.entries.len()
+    }
 }
 
 impl Page {

core/src/render/mod.rs

@@ -23,22 +23,13 @@ pub use primitive::*;
 const PRELUDE: &str = include_str!("./shader/prelude.wgsl");
 
 fn module_source(wgsl: &str) -> String {
-    // Every number both sides count in, written once here rather than a
+    // The steps come from the same constants the CPU counts in, rather than
-    // second time in the shader: a grid the two disagree about puts every
+    // a second copy of them written into the shader: a grid the two disagree
-    // coordinate somewhere else, and a sentinel they disagree about makes one
+    // about puts every coordinate somewhere else.
-    // of them walk a chain from a slot the other says is not there.
     format!(
-        "const PX_STEP: f32 = 1.0 / {}.0;\n\
+        "const PX_STEP: f32 = 1.0 / {}.0;\nconst REL_STEP: f32 = 1.0 / {}.0;\n{PRELUDE}\n{wgsl}",
-         const REL_STEP: f32 = 1.0 / {}.0;\n\
-         const MASK_NONE: u32 = {}u;\n\
-         const MOVE_NONE: u32 = {}u;\n\
-         const CHAIN_LIMIT: u32 = {}u;\n\
-         {PRELUDE}\n{wgsl}",
         1u32 << crate::PX_SHIFT,
         1u32 << crate::REL_SHIFT,
-        MaskIdx::NONE.idx(),
-        MoveIdx::NONE.idx(),
-        crate::CHAIN_LIMIT,
     )
 }
 

core/src/render/shader/prelude.wgsl

@@ -26,11 +26,9 @@ struct MoveOffset {
     parent: u32,
 }
 
-// `PX_STEP`, `REL_STEP`, `MASK_NONE`, `MOVE_NONE` and `CHAIN_LIMIT` are
+// `PX_STEP` and `REL_STEP` are prepended from `iris_core`'s own constants:
-// prepended from `iris_core`'s own constants, so none of them is written
+// what it stores is a whole count of each, both powers of two, so decoding
-// twice. What the CPU stores is a whole count of each step, and both steps
+// is exact and the number here is the number the CPU decided.
-// are powers of two, so decoding is exact and the number here is the number
-// the CPU decided.
 
 // Every coordinate the CPU decided is a whole count of `PX_STEP`, so one that
 // composes to within half a step of a pixel boundary is on that boundary and
@@ -72,6 +70,12 @@ struct Region {
     y: UiSpan,
 }
 
+const MOVE_NONE: u32 = 4294967295u;
+// Keep in step with `iris_core::CHAIN_LIMIT`. It bounds a malformed cycle
+// rather than any real tree, and the CPU walk uses the same number so both
+// resolve a deep one the same way.
+const CHAIN_LIMIT: u32 = 64u;
+
 // The same expression `Len::within` uses, in floats rather than on the
 // CPU's grid: a move is resolved here so that scrolling a subtree writes one
 // entry instead of walking it. What has to hold is that this agrees with
@@ -167,7 +171,7 @@ fn vs_main(
 }
 
 fn masked(in: VertexOutput, color: vec4<f32>) -> vec4<f32> {
-    if in.mask_idx == MASK_NONE {
+    if in.mask_idx == 4294967295u {
         return color;
     }
     let mask = masks[in.mask_idx];

core/src/ui/active.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Bounds, Declared, LayerId, LayoutHolds, MaskIdx, MoveIdx, PlaceDesc, RegionAlign,
+    LayerId, LayoutHolds, LayoutLen, Len, MaskIdx, MoveIdx, Place, RegionAlign, RetainedPrimitive,
-    RetainedPrimitive, Size, TextureHandle, UiRegion, UiVec2, WidgetId,
+    Size, TextureHandle, UiRegion, UiVec2, WidgetId,
 };
 
 /// What is kept of a widget its parent has asked about. `drawn` says whether
@@ -10,24 +10,29 @@ use crate::{
 pub struct ActiveData {
     pub id: WidgetId,
     /// Where its drawing goes, in its region node's coordinates.
-    pub placement: UiRegion,
+    pub extent: UiRegion,
     /// What a fraction declared or reported under this widget is a fraction
     /// of, as a length of the window.
-    pub rel_base: UiVec2,
+    pub frame: UiVec2,
-    /// Where its drawing was put, and where it was asked. The two differ
+    /// A frame its parent decided for it on each axis -- a row's slot, or
-    /// where a container asks in one place and puts the answer in another --
+    /// padding's frame less its pixels -- as a length of the window. `None`
-    /// a row measures from its cursor and puts the child in its slot. Each
+    /// forwards the parent's frame. What it declared is kept separately in
-    /// carries the rel base that ask stated, so asking again from either is
+    /// `declared` and is a fraction of whichever of the two reached it.
-    /// the same question it was.
+    pub narrow: [Option<Len>; 2],
-    pub placed: PlaceDesc,
+    /// Where its drawing was put, and where it was asked, each as a part of
-    pub asked: PlaceDesc,
+    /// its parent's box. The two differ where a container asks in one place
+    /// and puts the answer in another -- a row measures from its cursor and
+    /// puts the child in its slot. A part is a length from the box's start,
+    /// so a box that moved re-places every child by re-adding that start.
+    pub placed: [Place; 2],
+    pub asked: [Place; 2],
     /// The box it was asked in, in the parent's region-node coordinates: the
     /// box its drawing was made in and the one its contract is about. Its
     /// drawing is placed elsewhere by re-expression, never by asking again.
-    pub region: UiRegion,
+    pub part: UiRegion,
     /// The measured answer and its dependencies. A hint-only dependency or
     /// a widget first encountered during placement has no measurement yet.
-    pub answer: Option<Answer>,
+    pub answer: Option<(Size, LayoutHolds)>,
     /// Asked more than once in its parent's last draw -- measured in one box
     /// and then asked in the one the parent decided. The parent's layout
     /// rests on the first answer and its drawing on the last, so only the
@@ -35,8 +40,8 @@ pub struct ActiveData {
     pub re_asked: bool,
     /// What the widget reported, in window-unit lengths.
     pub size: Size,
-    /// The window and region reads that this drawing holds for, and the
+    /// The window and extent reads that this drawing holds for, and the
-    /// rel base and region it pinned.
+    /// frame and box it pinned.
     pub holds: LayoutHolds,
     pub drawn: bool,
     pub parent: Option<WidgetId>,
@@ -46,29 +51,24 @@ pub struct ActiveData {
     pub depth: usize,
     pub textures: Vec<TextureHandle>,
     /// Its primitives, each keeping the box it was written in -- in this
-    /// widget's placement coordinates, which is what a move recomposes from.
+    /// widget's extent coordinates, which is what a move recomposes from.
     pub primitives: Vec<RetainedPrimitive>,
-    /// An owned mask holds one reference independently of its primitives.
     pub mask_region: Option<UiRegion>,
     pub children: Vec<WidgetId>,
-    pub request_deps: Vec<WidgetId>,
+    /// The children whose size this widget read while drawing.
-    pub(crate) scratch: DrawScratch,
+    pub size_deps: Vec<WidgetId>,
     /// The movable region its primitives are positioned through: its own when
     /// opted in, otherwise the nearest ancestor's.
     pub move_idx: MoveIdx,
-    /// The declared lengths whoever drew this widget resolved into its rel base.
+    /// The declared lengths whoever drew this widget resolved into its frame.
     /// A change to one moves a box this widget cannot fix by drawing again,
     /// and comparing them is what says so.
-    pub declared: Declared,
+    pub declared: [Option<LayoutLen>; 2],
-    /// Its bounds, resolved the same way. The answer is held to these where
-    /// the box was not, so a change to one changes what it answers even
-    /// where its declared lengths stand.
-    pub bounds: Bounds,
     /// Its alignment when it was last drawn, which a change to the property
     /// is found against.
     pub own_align: RegionAlign,
-    /// The movable region whose coordinates its placement is in when this
+    /// The movable region whose coordinates `extent` uses when this widget
-    /// widget does not own a region node.
+    /// does not own a region node.
     pub parent_move: MoveIdx,
     /// The mask its drawing is clipped to: one it set itself, or the one it
     /// inherited from whoever drew it.
@@ -86,29 +86,6 @@ impl ActiveData {
     /// all. Not `size`, which is what its last drawing reported: a drawing
     /// re-expressed in the box that answer chose is not a second answer.
     pub fn measured(&self) -> Option<Size> {
-        self.answer.map(|answer| answer.size)
+        self.answer.map(|(size, _)| size)
-    }
-
-    /// Whether it owns a region node rather than sharing the one it was drawn
-    /// under, which is what its two move indices being different says.
-    pub fn is_region_node(&self) -> bool {
-        self.move_idx != self.parent_move
     }
 }
-
-/// What a widget answered when it was asked: the size it reported, and the
-/// boxes and windows that answer holds for.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct Answer {
-    pub size: Size,
-    pub holds: LayoutHolds,
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct DrawScratch {
-    pub children: Vec<WidgetId>,
-    pub size_deps: Vec<WidgetId>,
-    pub under: Vec<(WidgetId, LayoutHolds)>,
-    pub requests: Vec<crate::RequestedLen>,
-    pub lengths: Vec<crate::Px>,
-}

core/src/ui/holds.rs

@@ -1,4 +1,4 @@
-use crate::{Bound, Len, Outside, Px, REL_SHIFT, fixed::div_toward, fixed::narrow};
+use crate::{Len, Px, REL_SHIFT, fixed::div_toward, fixed::narrow};
 use std::ops::RangeInclusive;
 
 /// The lengths of a box, in pixels, that one drawing of a widget holds for:
@@ -19,64 +19,6 @@ pub struct Holds {
     pub hi: Px,
 }
 
-impl Len {
-    /// Whether this is longer than `than` in a window this wide, and the
-    /// windows that answer holds for.
-    ///
-    /// Which is longer is a question in pixels -- `rel(0.5)` is longer than
-    /// 300 px at a box of 600 and shorter at 400 -- and it is asked of the
-    /// difference and answered back through that same difference, so the
-    /// boundary is the comparison's own rather than a second way of finding
-    /// it.
-    pub fn longer_than(&self, than: Len, window: Px) -> (bool, Holds) {
-        let over = *self - than;
-        let longer = over.to_px(window) > Px::ZERO;
-        let side = match longer {
-            true => Px::STEP..=Px::MAX,
-            false => Px::MIN..=Px::ZERO,
-        };
-        (longer, Holds::from(side).through(over))
-    }
-}
-
-impl Bound {
-    /// Which end of this bound `len` falls outside, and the windows that
-    /// answer holds for. Nothing where it is inside, which is the answer
-    /// wherever there is no bound at all.
-    ///
-    /// `len` and this bound are lengths of the same thing, whichever that
-    /// is: a box in window lengths wants the bound resolved, and a length a
-    /// widget declares of its rel base wants it as the rule wrote it. Both
-    /// comparisons are in pixels, so each is a question about this window,
-    /// and the box is decided again on the other side of a crossing.
-    pub fn outside(&self, len: Len, window: Px) -> (Option<Outside>, Holds) {
-        let mut outside = None;
-        let mut holds = Holds::ANY;
-        let mut held = len;
-        if let Some(min) = self.min {
-            let (shorter, kept) = min.longer_than(held, window);
-            holds = holds.and(kept);
-            if shorter {
-                outside = Some(Outside::Shorter);
-                held = min;
-            }
-        }
-        if let Some(max) = self.max {
-            let (longer, kept) = held.longer_than(max, window);
-            holds = holds.and(kept);
-            if longer {
-                debug_assert!(
-                    outside.is_none(),
-                    "a floor of {:?} over a cap of {max:?} bounds nothing",
-                    self.min,
-                );
-                outside = Some(Outside::Longer);
-            }
-        }
-        (outside, holds)
-    }
-}
-
 impl Holds {
     pub const ANY: Self = Self {
         lo: Px::MIN,
@@ -91,13 +33,7 @@ impl Holds {
         len.raw() >= self.lo.raw() && len.raw() <= self.hi.raw()
     }
 
-    /// Every length `other` holds for is one this holds for, so a drawing
+    pub const fn and(self, other: Self) -> Self {
-    /// made under this range is still good wherever `other` is.
-    pub const fn covers(&self, other: Self) -> bool {
-        self.lo.raw() <= other.lo.raw() && self.hi.raw() >= other.hi.raw()
-    }
-
-    pub const fn and(&self, other: Self) -> Self {
         Self {
             lo: self.lo.max(other.lo),
             hi: self.hi.min(other.hi),
@@ -115,7 +51,7 @@ impl Holds {
     /// boxes therefore give one length. That is a floor rather than an
     /// allowance: inverting it is two divisions and nothing else, and the
     /// whole of a box maps back to itself.
-    pub const fn through(&self, len: Len) -> Self {
+    pub const fn through(self, len: Len) -> Self {
         if self.lo.raw() == Px::MIN.raw() && self.hi.raw() == Px::MAX.raw() {
             return Self::ANY;
         }
@@ -137,6 +73,21 @@ impl Holds {
         }
     }
 
+    /// What a box has to be for a part of it, this many pixels shorter, to
+    /// stay in this range: the range moved by that much, an end that was
+    /// unbounded staying so.
+    pub const fn longer_by(self, px: Px) -> Self {
+        let lo = match self.lo.raw() == Px::MIN.raw() {
+            true => self.lo,
+            false => self.lo.add(px),
+        };
+        let hi = match self.hi.raw() == Px::MAX.raw() {
+            true => self.hi,
+            false => self.hi.add(px),
+        };
+        Self { lo, hi }
+    }
+
     const fn raws(lo: i64, hi: i64) -> Self {
         Self {
             lo: Px::from_raw(narrow(lo)),

core/src/ui/layout_holds.rs

@@ -1,108 +1,79 @@
-use crate::util::impl_axis_index;
+use crate::{Axis, Holds, Len, PxVec2, UiRegion, UiVec2};
-use crate::{Axis, Holds, Len, Px, PxVec2, UiRegion, UiVec2};
 
-/// What one evaluation of a widget depends on along one axis: the window
+const AXES: [Axis; 2] = [Axis::X, Axis::Y];
-/// lengths its reads hold for, the pixel lengths of its own box, and the
+
-/// symbolic lengths of that box and of its rel base where either one is what
+/// What one evaluation of a widget depends on: the window lengths its reads
-/// it was expressed in.
+/// hold for, the pixel lengths of its own box, and the symbolic lengths of
+/// that box and of its frame where either one is what it was expressed in.
 ///
 /// The symbolic lengths are pins rather than ranges: a container places its
-/// children as lengths of its rel base measured from where its own box starts,
+/// children as lengths of its frame measured from where its own box starts,
 /// so what it draws turns on that box's length and on nothing about where it
 /// is. A box pin reaches the parent only where the box it pinned is the
 /// parent's own; anywhere else the parent chose that length itself, and a
 /// widget pinned this way is checked when it is re-placed.
 ///
-/// A rel base pin says the answer or the drawing is a fraction of the rel base,
+/// A frame pin says the answer or the drawing is a fraction of the frame,
-/// which is a different length wherever the rel base is a different one -- at
+/// which is a different length wherever the frame is a different one -- at
 /// the same window size, so no range of window pixels can say it. A length
-/// of the rel base that is only pixels is not one: it is that many pixels
+/// of the frame that is only pixels is not one: it is that many pixels
-/// whatever the rel base turns out to be.
+/// whatever the frame turns out to be.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct AxisHolds {
-    pub window: Holds,
-    pub rel_base: Option<Len>,
-    pub region: Holds,
-    pub region_len: Option<Len>,
-}
-
-impl AxisHolds {
-    pub const ANY: Self = Self {
-        window: Holds::ANY,
-        rel_base: None,
-        region: Holds::ANY,
-        region_len: None,
-    };
-
-    pub fn and(&self, other: Self) -> Self {
-        // Two pins of the same length disagreeing would mean one drawing was
-        // a fraction of two different lengths at once.
-        debug_assert!(
-            self.region_len.is_none()
-                || other.region_len.is_none()
-                || self.region_len == other.region_len
-        );
-        debug_assert!(
-            self.rel_base.is_none() || other.rel_base.is_none() || self.rel_base == other.rel_base
-        );
-        Self {
-            window: self.window.and(other.window),
-            rel_base: self.rel_base.or(other.rel_base),
-            region: self.region.and(other.region),
-            region_len: self.region_len.or(other.region_len),
-        }
-    }
-
-    pub fn covers(&self, other: Self) -> bool {
-        self.window.covers(other.window)
-            && self.region.covers(other.region)
-            && self
-                .region_len
-                .is_none_or(|len| other.region_len == Some(len))
-            && self.rel_base.is_none_or(|len| other.rel_base == Some(len))
-    }
-
-    /// Whether a widget in a box `len` long, with that rel base, in that
-    /// window, is one this drawing holds for.
-    pub fn contains(&self, window: Px, rel_base: Len, len: Len) -> bool {
-        self.window.contains(window)
-            && self.rel_base.is_none_or(|pinned| pinned == rel_base)
-            && self.region.contains(len.to_px(window))
-            && self.region_len.is_none_or(|pinned| pinned == len)
-    }
-}
-
-/// [`AxisHolds`] on both axes. Every question asked of it is asked of one
-/// axis at a time, since a widget that read one length holds for any length
-/// of the other.
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct LayoutHolds {
-    pub x: AxisHolds,
+    pub window: [Holds; 2],
-    pub y: AxisHolds,
+    pub frame_len: [Option<Len>; 2],
+    pub extent: [Holds; 2],
+    pub extent_len: [Option<Len>; 2],
 }
 
 impl LayoutHolds {
     pub const ANY: Self = Self {
-        x: AxisHolds::ANY,
+        window: [Holds::ANY; 2],
-        y: AxisHolds::ANY,
+        frame_len: [None; 2],
+        extent: [Holds::ANY; 2],
+        extent_len: [None; 2],
     };
 
-    pub fn and(&self, other: Self) -> Self {
+    pub fn and(self, other: Self) -> Self {
-        Self {
+        let mut result = Self::ANY;
-            x: self.x.and(other.x),
+        for n in 0..2 {
-            y: self.y.and(other.y),
+            result.window[n] = self.window[n].and(other.window[n]);
+            result.extent[n] = self.extent[n].and(other.extent[n]);
+            debug_assert!(
+                self.extent_len[n].is_none()
+                    || other.extent_len[n].is_none()
+                    || self.extent_len[n] == other.extent_len[n]
+            );
+            debug_assert!(
+                self.frame_len[n].is_none()
+                    || other.frame_len[n].is_none()
+                    || self.frame_len[n] == other.frame_len[n]
+            );
+            result.extent_len[n] = self.extent_len[n].or(other.extent_len[n]);
+            result.frame_len[n] = self.frame_len[n].or(other.frame_len[n]);
         }
+        result
     }
 
-    pub fn covers(&self, other: Self) -> bool {
+    pub fn covers(self, other: Self) -> bool {
-        self.x.covers(other.x) && self.y.covers(other.y)
+        (0..2).all(|n| {
+            self.window[n].lo <= other.window[n].lo
+                && self.window[n].hi >= other.window[n].hi
+                && self.extent[n].lo <= other.extent[n].lo
+                && self.extent[n].hi >= other.extent[n].hi
+                && self.extent_len[n].is_none_or(|len| other.extent_len[n] == Some(len))
+                && self.frame_len[n].is_none_or(|len| other.frame_len[n] == Some(len))
+        })
     }
 
-    pub fn contains(&self, window: PxVec2, rel_base: UiVec2, region: UiRegion) -> bool {
+    pub fn contains(self, window: PxVec2, frame: UiVec2, extent: UiRegion) -> bool {
-        Axis::BOTH
+        AXES.into_iter().all(|axis| {
-            .into_iter()
+            let n = axis as usize;
-            .all(|axis| self[axis].contains(window[axis], rel_base[axis], region[axis].len()))
+            let len = extent.axis(axis).len();
+            self.window[n].contains(window.axis(axis))
+                && self.frame_len[n].is_none_or(|pinned| pinned == frame.axis(axis))
+                && self.extent[n].contains(len.to_px(window.axis(axis)))
+                && self.extent_len[n].is_none_or(|pinned| pinned == len)
+        })
     }
 }
-
-impl_axis_index!(LayoutHolds => AxisHolds);

core/src/ui/mod.rs

@@ -20,7 +20,7 @@ pub use active::*;
 pub use holds::*;
 pub use layout_holds::*;
 pub use painter::{Painter, PrimitiveLike};
-pub use place::{PlaceDesc, PlaceDescAxis, PlaceFit, RetainedPrimitive};
+pub use place::*;
 pub use render_state::*;
 
 #[derive(Default)]

core/src/ui/place.rs

@@ -1,225 +1,67 @@
-use crate::util::impl_axis_index;
+use crate::{AxisAlign, Len, PrimitiveHandle, UiRegion, UiSpan};
-use crate::{Axis, AxisAlign, Len, PrimitiveHandle, RegionAlign, UiRegion, UiSpan, UiVec2};
 
-/// How a child's region along one axis comes from the region of the widget
+/// What of a widget's own box a child is given, along one axis.
-/// asking, and what its fractions are of.
-///
-/// The three ways of saying a region are the three the geometry already has:
-/// a span composed into the caller's box, a span shifted to where that box
-/// starts, and a length placed in it by alignment. Which one is meant cannot
-/// be read off the numbers, since two of them take the same span and apply
-/// it differently, so it is said here.
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub struct PlaceDescAxis {
+pub enum Part {
-    pub span: PlaceSpan,
+    /// The whole of it.
-    pub fit: PlaceFit,
+    All,
-    pub rel_base: RelBase,
+    /// Window lengths from where the box starts, which is what a container
-}
+    /// dividing room among its children speaks: a child's report is a window
-
+    /// length, so the cursor that sums those reports is one too. A moved box
-#[derive(Clone, Copy, Debug, PartialEq)]
+    /// re-places every child by re-adding its start, exactly. A fraction
-pub enum PlaceFit {
+    /// here is a fraction of the window and not of the box -- the whole of a
-    Align,
+    /// box is [`Self::All`], not a `rel(1.0)` span.
-    Fill,
+    From(UiSpan),
-    /// The parent has already evaluated the child's size request.
+    /// The box less a window length at each end, which is what a container
-    Allocated,
+    /// that insets one speaks -- padding, or a row asking a child in the
-}
+    /// room left from its cursor. Neither end names the box's length, so a
-
+    /// container can say "from here to my end" without reading how long it
-impl PlaceFit {
+    /// is, and a box chosen from its own answer does not feed back into the
-    pub fn fills(self) -> bool {
+    /// answer.
-        self != Self::Align
+    Inset { lead: Len, trail: Len },
-    }
+    /// A box of this length, wherever in the parent's box the child's own
-}
+    /// alignment puts it, and that same length as its frame. Unlike `From`,
-
+    /// it is a length decided from above rather than a place along a
-#[derive(Clone, Copy, Debug, PartialEq)]
+    /// container's cursor -- what a stack's sizing child decides for the
-pub enum PlaceSpan {
+    /// rest.
-    Within(UiSpan),
-    Shifted(UiSpan),
     Sized(Len),
 }
 
-/// What a child's fractions are of. [`PlaceSpan::Sized`] is a length the
+impl Part {
-/// caller named, which is always its own base, so nothing here constructs one
+    /// Where it lands in the coordinates `extent` is in.
-/// beside anything but [`Self::Len`].
+    pub(crate) fn of(self, extent: UiSpan, align: AxisAlign) -> UiSpan {
+        match self {
+            Self::All => extent,
+            Self::From(span) => UiSpan::new(extent.start + span.start, extent.start + span.end),
+            Self::Inset { lead, trail } => UiSpan::new(extent.start + lead, extent.end - trail),
+            Self::Sized(len) => {
+                let start = extent.start + (extent.len() - len).scale(align.rel());
+                UiSpan::new(start, start + len)
+            }
+        }
+    }
+}
+
+/// Where a child goes along one axis, as a part of this widget's box.
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub enum RelBase {
+pub enum Place {
-    /// The caller's own, unchanged.
+    /// The child's answer, aligned inside the part by the child's alignment.
-    Inherit,
+    Within(Part),
-    /// The caller's own, narrowed the way the region is.
+    /// Exactly the part; the answer is not placed inside it again.
-    WithRegion,
+    Fill(Part),
-    /// This length of the window.
-    Len(Len),
 }
 
-impl PlaceDescAxis {
+impl Place {
-    /// The whole of the caller's box.
+    pub(crate) fn part(self) -> Part {
-    pub const WHOLE: Self = UiSpan::FULL.within_desc();
+        match self {
-
+            Self::Within(part) | Self::Fill(part) => part,
-    /// This region is the child's placement: its answer is not placed inside
-    /// it again. A container uses it where it hands back exactly what the
-    /// child asked for -- a row placing a child at the length it reported.
-    pub const fn fills(mut self) -> Self {
-        self.fit = PlaceFit::Fill;
-        self
-    }
-
-    /// A final allocation, including any comparisons in the child's request.
-    pub const fn allocated(mut self) -> Self {
-        self.fit = PlaceFit::Allocated;
-        self
-    }
-
-    /// This along `axis`, and the whole of the caller's box across it: what
-    /// a container dividing one axis says, since nothing divides the other.
-    /// [`PlaceDesc::from_axis`] says the across one where it is not the
-    /// whole.
-    pub const fn on_axis(self, axis: Axis) -> PlaceDesc {
-        PlaceDesc::from_axis(axis, self, Self::WHOLE)
-    }
-
-    /// What the child's fractions are of, as a length of the window: a
-    /// resolved share, or a box a sibling's answer decided.
-    pub const fn rel_base(mut self, len: Len) -> Self {
-        self.rel_base = RelBase::Len(len);
-        self
-    }
-
-    /// Where it lands in the coordinates `own` is in.
-    pub fn of(self, own: UiSpan, align: AxisAlign) -> UiSpan {
-        match self.span {
-            PlaceSpan::Within(span) => span.within(&own),
-            PlaceSpan::Shifted(mut span) => {
-                span.shift(own.start);
-                span
-            }
-            PlaceSpan::Sized(len) => own.place(len, align),
-        }
-    }
-}
-
-/// Where a child is asked, on both axes. A [`UiRegion`] converts into the
-/// common case: that box of the caller's own, the answer placed inside it.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct PlaceDesc {
-    pub x: PlaceDescAxis,
-    pub y: PlaceDescAxis,
-}
-
-impl PlaceDesc {
-    /// The whole of the caller's box, on both axes.
-    pub const WHOLE: Self = Self::splat(PlaceDescAxis::WHOLE);
-
-    pub const fn new(x: PlaceDescAxis, y: PlaceDescAxis) -> Self {
-        Self { x, y }
-    }
-
-    /// The same on both axes.
-    pub const fn splat(place: PlaceDescAxis) -> Self {
-        Self { x: place, y: place }
-    }
-
-    /// A description per axis, where the two differ and neither is the
-    /// axis a container divides.
-    pub fn from_axes(f: impl Fn(Axis) -> PlaceDescAxis) -> Self {
-        Self::new(f(Axis::X), f(Axis::Y))
-    }
-
-    /// `aligned` on `axis` and `ortho` on the other, which is how a
-    /// container that divides one axis says what it is doing.
-    pub const fn from_axis(axis: Axis, aligned: PlaceDescAxis, ortho: PlaceDescAxis) -> Self {
-        match axis {
-            Axis::X => Self::new(aligned, ortho),
-            Axis::Y => Self::new(ortho, aligned),
         }
     }
 
-    /// Both regions are the child's placement. See [`PlaceDescAxis::fills`].
+    /// Whether the part is the drawing's box outright, rather than the box
-    pub const fn fills(self) -> Self {
+    /// the answer is placed inside.
-        Self::new(self.x.fills(), self.y.fills())
+    pub(crate) fn fills(self) -> bool {
-    }
+        matches!(self, Self::Fill(_))
-
-    /// The child's rel base on one axis. See [`PlaceDescAxis::rel_base`].
-    pub const fn rel_base(mut self, axis: Axis, len: Len) -> Self {
-        self[axis] = self[axis].rel_base(len);
-        self
-    }
-
-    /// What a child's fractions on one axis are of, as a length of the
-    /// window: a length this place names, or the rel base of the widget
-    /// giving it, which is `parent_rel_base`.
-    pub(super) fn base(&self, axis: Axis, parent_rel_base: UiVec2) -> Len {
-        match self[axis].rel_base {
-            RelBase::Len(len) => len,
-            RelBase::Inherit | RelBase::WithRegion => parent_rel_base[axis],
-        }
-    }
-
-    /// The box each axis names, in the coordinates `own` is in.
-    pub fn of(self, own: UiRegion, align: RegionAlign) -> UiRegion {
-        UiRegion::new(self.x.of(own.x, align.x), self.y.of(own.y, align.y))
-    }
-}
-
-impl UiSpan {
-    /// This span composed into the caller's own box, so it moves and scales
-    /// with it: [`UiSpan::within`], which is what a container that insets
-    /// one speaks. Taking eleven pixels off the end needs no length, where
-    /// saying the same thing in window lengths would make the container read
-    /// its own box -- and a box chosen from its own answer then feeds back
-    /// into the answer.
-    ///
-    /// The child's rel base is narrowed the same way, so padding takes its
-    /// pixels off both and `rel(1)` under it fills the caller rather than
-    /// overflowing it.
-    pub const fn within_desc(self) -> PlaceDescAxis {
-        PlaceDescAxis {
-            span: PlaceSpan::Within(self),
-            fit: PlaceFit::Align,
-            rel_base: RelBase::WithRegion,
-        }
-    }
-
-    /// This span shifted to where the caller's own box starts: window
-    /// lengths along a cursor, which is what a container dividing room among
-    /// its children speaks. A child's report is a window length, so the
-    /// cursor that sums those reports is one too, and a moved box re-places
-    /// every child by re-adding its start, exactly.
-    ///
-    /// The child's rel base passes through: how far along the cursor a child
-    /// sits says nothing about what a fraction under it is of. The same span
-    /// says [`Self::within_desc`] as a part of that box instead, and which is
-    /// meant cannot be read off the numbers.
-    pub const fn shifted_desc(self) -> PlaceDescAxis {
-        PlaceDescAxis {
-            span: PlaceSpan::Shifted(self),
-            fit: PlaceFit::Align,
-            rel_base: RelBase::Inherit,
-        }
-    }
-}
-
-impl Len {
-    /// A box this long, placed in the caller's own by the child's alignment:
-    /// the rule that places an answer, with the length given from above
-    /// rather than reported. What a stack's sizing child decides for the
-    /// rest. It is the child's rel base too.
-    pub const fn as_desc(self) -> PlaceDescAxis {
-        PlaceDescAxis {
-            span: PlaceSpan::Sized(self),
-            fit: PlaceFit::Align,
-            rel_base: RelBase::Len(self),
-        }
-    }
-}
-
-impl From<UiRegion> for PlaceDesc {
-    fn from(region: UiRegion) -> Self {
-        Self::new(region.x.within_desc(), region.y.within_desc())
-    }
-}
-
-impl From<PlaceDescAxis> for PlaceDesc {
-    fn from(place: PlaceDescAxis) -> Self {
-        Self::splat(place)
     }
 }
 
@@ -230,5 +72,3 @@ pub struct RetainedPrimitive {
     pub handle: PrimitiveHandle,
     pub region: UiRegion,
 }
-
-impl_axis_index!(PlaceDesc => PlaceDescAxis);

core/src/util/arena.rs

@@ -35,7 +35,7 @@ impl<T, I: IdNum> Arena<T, I> {
         self.data[i]
     }
 
-    pub fn get_mut(&mut self, id: Id<I>) -> &mut T {
+    pub(crate) fn get_mut(&mut self, id: Id<I>) -> &mut T {
         &mut self.data[id.idx()]
     }
 }

core/src/util/math.rs

@@ -93,31 +93,3 @@ macro_rules! impl_op {
 }
 
 pub(crate) use impl_op;
-
-/// `Index<Axis>` for a pair, which is how every pair here is read by axis.
-/// The generics clause is given in braces where the type has one.
-macro_rules! impl_axis_index {
-    ($({$($gen:tt)*})? $T:ty => $Out:ty) => {
-        const impl $(<$($gen)*>)? std::ops::Index<crate::Axis> for $T {
-            type Output = $Out;
-
-            fn index(&self, axis: crate::Axis) -> &$Out {
-                match axis {
-                    crate::Axis::X => &self.x,
-                    crate::Axis::Y => &self.y,
-                }
-            }
-        }
-
-        const impl $(<$($gen)*>)? std::ops::IndexMut<crate::Axis> for $T {
-            fn index_mut(&mut self, axis: crate::Axis) -> &mut $Out {
-                match axis {
-                    crate::Axis::X => &mut self.x,
-                    crate::Axis::Y => &mut self.y,
-                }
-            }
-        }
-    };
-}
-
-pub(crate) use impl_axis_index;

core/src/widget/mod.rs

@@ -4,7 +4,6 @@ use std::any::Any;
 mod data;
 mod handle;
 mod like;
-mod request;
 mod size_rule;
 mod tag;
 mod view;
@@ -13,7 +12,6 @@ mod widgets;
 pub use data::*;
 pub use handle::*;
 pub use like::*;
-pub use request::*;
 pub use size_rule::*;
 pub use tag::*;
 pub use view::*;
@@ -23,12 +21,6 @@ pub trait Widget: Any {
     /// Draws the widget, and returns what it used of the box it was given.
     fn draw(&mut self, painter: &mut Painter) -> Size;
 
-    /// Describes an axis before painting. Return `None` when discovering it
-    /// needs a concrete box or work performed by `draw`.
-    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
-        self.size_hint(axis).map(|len| requests.length(len))
-    }
-
     /// An exact length the widget can give without a painter or its children.
     /// Optional, and saves a draw rather than changing one: a hint that
     /// disagrees with the eventual draw fails a debug assertion.

core/src/widget/request.rs

@@ -1,438 +0,0 @@
-use crate::{Axis, LayoutLen, Len, Px, StrongWidget, Weight, WidgetId, Widgets};
-
-impl<N: crate::UiNum> From<N> for SizeRequest {
-    fn from(value: N) -> Self {
-        LayoutLen::px(value).into()
-    }
-}
-
-impl LayoutLen {
-    pub fn min(self, other: impl Into<SizeRequest>) -> SizeRequest {
-        SizeRequest::from(self).min(other)
-    }
-
-    pub fn max(self, other: impl Into<SizeRequest>) -> SizeRequest {
-        SizeRequest::from(self).max(other)
-    }
-
-    pub fn clamp(self, min: impl Into<SizeRequest>, max: impl Into<SizeRequest>) -> SizeRequest {
-        SizeRequest::from(self).clamp(min, max)
-    }
-}
-
-/// A size request before a container has divided its leftover space.
-/// Comparisons keep both operands until the share is known.
-#[derive(Clone, Debug, PartialEq)]
-pub enum SizeRequest {
-    Linear(LayoutLen),
-    Sum(std::sync::Arc<(Self, Self)>),
-    Min(std::sync::Arc<(Self, Self)>),
-    Max(std::sync::Arc<(Self, Self)>),
-}
-
-impl From<LayoutLen> for SizeRequest {
-    fn from(len: LayoutLen) -> Self {
-        Self::Linear(len)
-    }
-}
-
-impl From<Len> for SizeRequest {
-    fn from(len: Len) -> Self {
-        LayoutLen::from(len).into()
-    }
-}
-
-impl SizeRequest {
-    pub fn min(self, other: impl Into<Self>) -> Self {
-        let other = other.into();
-        if let (Self::Linear(a), Self::Linear(b)) = (&self, &other)
-            && let Some(order) = independent_order(*a, *b)
-        {
-            return if !order.is_gt() { self } else { other };
-        }
-        if self == other {
-            self
-        } else {
-            Self::Min(std::sync::Arc::new((self, other)))
-        }
-    }
-
-    pub fn max(self, other: impl Into<Self>) -> Self {
-        let other = other.into();
-        if let (Self::Linear(a), Self::Linear(b)) = (&self, &other)
-            && let Some(order) = independent_order(*a, *b)
-        {
-            return if !order.is_lt() { self } else { other };
-        }
-        if self == other {
-            self
-        } else {
-            Self::Max(std::sync::Arc::new((self, other)))
-        }
-    }
-
-    pub fn clamp(self, min: impl Into<Self>, max: impl Into<Self>) -> Self {
-        self.max(min).min(max)
-    }
-}
-
-impl std::ops::Add for SizeRequest {
-    type Output = Self;
-
-    fn add(self, other: Self) -> Self {
-        match (self, other) {
-            (Self::Linear(a), Self::Linear(b)) => Self::Linear(a + b),
-            (a, b) => Self::Sum(std::sync::Arc::new((a, b))),
-        }
-    }
-}
-
-/// A discovered length. Deferred values belong to the current layout pass;
-/// widgets must not retain them. Ordinary requests remain inline lengths.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct RequestedLen(RequestValue);
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-enum RequestValue {
-    Linear(LayoutLen),
-    Deferred {
-        index: usize,
-        epoch: u64,
-        leftover: bool,
-    },
-}
-
-impl From<LayoutLen> for RequestedLen {
-    fn from(len: LayoutLen) -> Self {
-        Self(RequestValue::Linear(len))
-    }
-}
-impl From<Len> for RequestedLen {
-    fn from(len: Len) -> Self {
-        LayoutLen::from(len).into()
-    }
-}
-impl RequestedLen {
-    pub fn linear(self) -> Option<LayoutLen> {
-        match self.0 {
-            RequestValue::Linear(len) => Some(len),
-            _ => None,
-        }
-    }
-    pub fn has_leftover(self) -> bool {
-        match self.0 {
-            RequestValue::Linear(len) => len.leftover > Weight::ZERO,
-            RequestValue::Deferred { leftover, .. } => leftover,
-        }
-    }
-}
-
-#[derive(Clone, Copy)]
-enum Op {
-    Sum,
-    Min,
-    Max,
-}
-struct Node {
-    op: Op,
-    a: RequestedLen,
-    b: RequestedLen,
-}
-
-#[derive(Default)]
-pub(crate) struct RequestArena {
-    nodes: Vec<Node>,
-    epoch: u64,
-}
-
-impl RequestArena {
-    pub(crate) fn reset(&mut self) {
-        self.nodes.clear();
-        self.epoch = self
-            .epoch
-            .checked_add(1)
-            .expect("layout generation exhausted");
-    }
-    pub(crate) fn import(&mut self, request: &SizeRequest, base: Len) -> RequestedLen {
-        let (op, pair) = match request {
-            SizeRequest::Linear(len) => return len.within_len(base).into(),
-            SizeRequest::Sum(pair) => (Op::Sum, pair),
-            SizeRequest::Min(pair) => (Op::Min, pair),
-            SizeRequest::Max(pair) => (Op::Max, pair),
-        };
-        let a = self.import(&pair.0, base);
-        let b = self.import(&pair.1, base);
-        self.combine(op, a, b)
-    }
-    fn combine(&mut self, op: Op, a: RequestedLen, b: RequestedLen) -> RequestedLen {
-        if let (Some(x), Some(y)) = (a.linear(), b.linear()) {
-            if matches!(op, Op::Sum) {
-                return (x + y).into();
-            }
-            let order = independent_order(x, y);
-            if let Some(order) = order {
-                let take_a = match op {
-                    Op::Min => !order.is_gt(),
-                    _ => !order.is_lt(),
-                };
-                return if take_a { a } else { b };
-            }
-        }
-        if a == b && !matches!(op, Op::Sum) {
-            return a;
-        }
-        let index = self.nodes.len();
-        self.nodes.push(Node { op, a, b });
-        RequestedLen(RequestValue::Deferred {
-            index,
-            epoch: self.epoch,
-            leftover: a.has_leftover() || b.has_leftover(),
-        })
-    }
-    pub(crate) fn minimum(&self, request: RequestedLen, window: Px) -> Px {
-        Px::from_raw(self.segment(request, Ratio::ZERO, window).fixed as i32)
-    }
-    fn segment(&self, request: RequestedLen, at: Ratio, window: Px) -> Segment {
-        match request.0 {
-            RequestValue::Linear(len) => {
-                assert!(
-                    len.leftover >= Weight::ZERO,
-                    "a leftover weight cannot be negative"
-                );
-                Segment {
-                    fixed: i64::from(len.without_leftover().to_px(window).raw()),
-                    weight: i64::from(len.leftover.raw()),
-                    end: None,
-                }
-            }
-            RequestValue::Deferred { index, epoch, .. } => {
-                assert_eq!(epoch, self.epoch, "request retained beyond its layout pass");
-                let Node { op, a, b } = self.nodes[index];
-                let a = self.segment(a, at, window);
-                let b = self.segment(b, at, window);
-                if matches!(op, Op::Sum) {
-                    return a + b;
-                }
-                // At a crossing choose the branch to its right, so the next
-                // iteration advances rather than selecting that crossing again.
-                let order = a.value(at).cmp(&b.value(at)).then(a.weight.cmp(&b.weight));
-                let take_a = match op {
-                    Op::Min => !order.is_gt(),
-                    _ => !order.is_lt(),
-                };
-                let mut selected = if take_a { a } else { b };
-                selected.end = first(a.end, b.end);
-                if a.weight != b.weight {
-                    let crossing = Ratio::new(b.fixed - a.fixed, a.weight - b.weight);
-                    if crossing > at {
-                        selected.end = first(selected.end, Some(crossing));
-                    }
-                }
-                selected
-            }
-        }
-    }
-    /// Allocates one scope of nonnegative shares. Floors can overflow; caps
-    /// can leave unused room. Prefix rounding keeps adjacent slot edges equal.
-    pub(crate) fn allocate<'a>(
-        &'a self,
-        requests: &'a [RequestedLen],
-        room: Px,
-        window: Px,
-    ) -> impl Iterator<Item = Px> + 'a {
-        let mut at = Ratio::ZERO;
-        loop {
-            let total = requests.iter().fold(Segment::ZERO, |total, request| {
-                total + self.segment(*request, at, window)
-            });
-            if total.value(at) >= i128::from(room.raw()) * i128::from(at.den) {
-                break;
-            }
-            if total.weight != 0 {
-                let solution = Ratio::new(i64::from(room.raw()) - total.fixed, total.weight);
-                if total.end.is_none_or(|end| solution <= end) {
-                    at = solution;
-                    break;
-                }
-            }
-            match total.end {
-                Some(end) => at = end,
-                None => break,
-            }
-        }
-        let mut prefix = 0_i128;
-        let mut previous = 0_i128;
-        requests.iter().map(move |request| {
-            prefix += self.segment(*request, at, window).value(at);
-            let den = i128::from(at.den);
-            let edge = prefix.signum() * ((prefix.abs() + den / 2) / den);
-            let len = Px::from_raw((edge - previous) as i32);
-            previous = edge;
-            len
-        })
-    }
-}
-
-#[derive(Clone, Copy, Debug, Eq)]
-struct Ratio {
-    num: i64,
-    den: i64,
-}
-
-impl PartialEq for Ratio {
-    fn eq(&self, other: &Self) -> bool {
-        self.cmp(other).is_eq()
-    }
-}
-
-impl Ratio {
-    const ZERO: Self = Self { num: 0, den: 1 };
-
-    fn new(num: i64, den: i64) -> Self {
-        assert_ne!(den, 0);
-        if den < 0 {
-            Self {
-                num: -num,
-                den: -den,
-            }
-        } else {
-            Self { num, den }
-        }
-    }
-}
-
-impl Ord for Ratio {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        (i128::from(self.num) * i128::from(other.den))
-            .cmp(&(i128::from(other.num) * i128::from(self.den)))
-    }
-}
-
-impl PartialOrd for Ratio {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-#[derive(Clone, Copy)]
-struct Segment {
-    fixed: i64,
-    weight: i64,
-    end: Option<Ratio>,
-}
-
-impl Segment {
-    const ZERO: Self = Self {
-        fixed: 0,
-        weight: 0,
-        end: None,
-    };
-
-    fn value(self, at: Ratio) -> i128 {
-        i128::from(self.fixed) * i128::from(at.den) + i128::from(self.weight) * i128::from(at.num)
-    }
-}
-
-impl std::ops::Add for Segment {
-    type Output = Self;
-    fn add(self, other: Self) -> Self {
-        Self {
-            fixed: self.fixed + other.fixed,
-            weight: self.weight + other.weight,
-            end: first(self.end, other.end),
-        }
-    }
-}
-
-fn first(a: Option<Ratio>, b: Option<Ratio>) -> Option<Ratio> {
-    match (a, b) {
-        (Some(a), Some(b)) => Some(a.min(b)),
-        (a, b) => a.or(b),
-    }
-}
-
-/// Read-only discovery of requests through a widget's children. A request is
-/// expressed in window lengths; `rel_base` supplies the base for declarations.
-pub struct SizeRequests<'a> {
-    pub(crate) arena: &'a mut RequestArena,
-    pub(crate) measured: Option<&'a crate::util::HashMap<WidgetId, crate::ActiveData>>,
-    pub(crate) widgets: &'a Widgets,
-    pub(crate) dependencies: &'a mut Vec<WidgetId>,
-    pub(crate) rel_base: Len,
-}
-
-impl SizeRequests<'_> {
-    pub fn sum(&mut self, a: RequestedLen, b: RequestedLen) -> RequestedLen {
-        self.arena.combine(Op::Sum, a, b)
-    }
-    pub fn min(&mut self, a: RequestedLen, b: RequestedLen) -> RequestedLen {
-        self.arena.combine(Op::Min, a, b)
-    }
-    pub fn max(&mut self, a: RequestedLen, b: RequestedLen) -> RequestedLen {
-        self.arena.combine(Op::Max, a, b)
-    }
-
-    pub fn widget<W: ?Sized>(
-        &mut self,
-        child: &StrongWidget<W>,
-        axis: Axis,
-    ) -> Option<RequestedLen> {
-        self.dependencies.push(child.id());
-        let rules = self.widgets.size_rules(child.id());
-        let rule = &rules[axis];
-        if let crate::SizeRule::Request(request) = rule {
-            return Some(self.arena.import(request, self.rel_base));
-        }
-        if let Some(exact) = rule.exact() {
-            return Some(exact.within_len(self.rel_base).into());
-        }
-        let widget = self.widgets.get_dyn(child.id())?;
-        let request = widget.size_request(self, axis).or_else(|| {
-            self.measured?
-                .get(&child.id())?
-                .measured()
-                .map(|size| size[axis].into())
-        })?;
-        Some(self.bounded(request, rule.bound()))
-    }
-
-    pub(crate) fn bounded(&mut self, request: RequestedLen, bound: crate::Bound) -> RequestedLen {
-        let bound = bound.within_len(self.rel_base);
-        let request = match bound.min {
-            Some(min) => self.max(request, min.into()),
-            None => request,
-        };
-        match bound.max {
-            Some(max) => self.min(request, max.into()),
-            None => request,
-        }
-    }
-
-    pub fn length(&self, len: LayoutLen) -> RequestedLen {
-        len.within_len(self.rel_base).into()
-    }
-
-    pub fn inset<W: ?Sized>(
-        &mut self,
-        child: &StrongWidget<W>,
-        axis: Axis,
-        padding: Px,
-    ) -> Option<RequestedLen> {
-        let base = self.rel_base;
-        self.rel_base.px -= padding;
-        let request = self.widget(child, axis);
-        self.rel_base = base;
-        request.map(|request| self.sum(request, Len::from_parts(crate::Rel::ZERO, padding).into()))
-    }
-}
-
-// Equal fractions keep this valid even when padding makes a rel base negative.
-fn independent_order(a: LayoutLen, b: LayoutLen) -> Option<std::cmp::Ordering> {
-    if a.rel == b.rel && a.leftover == b.leftover {
-        Some(a.px.cmp(&b.px))
-    } else if a.px == b.px && a.rel == b.rel {
-        Some(a.leftover.cmp(&b.leftover))
-    } else {
-        None
-    }
-}

core/src/widget/size_rule.rs

@@ -1,5 +1,4 @@
-use crate::util::impl_axis_index;
+use crate::{Axis, LayoutLen, Weight};
-use crate::{Axis, LayoutLen, Len, Rel, SizeRequest};
 
 /// What a widget's length on one axis is, as a rule its parent applies where
 /// it draws it rather than an answer the widget gives about itself.
@@ -9,84 +8,25 @@ use crate::{Axis, LayoutLen, Len, Rel, SizeRequest};
 /// with no rule. That is what lets a span divide its space around a length
 /// nobody has drawn yet, and it is why a rule lives beside the widget rather
 /// than inside it -- the widget under the rule never has to know about it.
-///
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
-/// Exact expressions can bound a share before allocation. Bounds on an
-/// intrinsic answer are applied after that answer becomes known.
-#[derive(Debug, Clone, PartialEq, Default)]
 pub enum SizeRule {
     /// Whatever the widget reports from drawing.
     #[default]
     Free,
     /// This length, whatever the widget reports.
     Exact(LayoutLen),
-    /// An exact request whose comparisons await the parent's allocation.
-    Request(std::sync::Arc<SizeRequest>),
-    /// At least this long, and otherwise whatever the box gives it.
-    Min(Len),
-    /// At most this long.
-    Max(Len),
-    /// Between the two.
-    Clamp { min: Len, max: Len },
 }
 
 impl SizeRule {
-    /// What this rule allows the length to be where it does not give one
-    /// outright.
-    pub fn bound(&self) -> Bound {
-        match *self {
-            Self::Free | Self::Exact(_) | Self::Request(_) => Bound::ANY,
-            Self::Min(min) => Bound {
-                min: Some(min),
-                max: None,
-            },
-            Self::Max(max) => Bound {
-                min: None,
-                max: Some(max),
-            },
-            Self::Clamp { min, max } => Bound {
-                min: Some(min),
-                max: Some(max),
-            },
-        }
-    }
-
-    /// Whether what this rule says is a fraction of the rel base, so that
-    /// the same rule against a different one is a different length.
-    pub fn has_fraction(&self) -> bool {
-        let bound = self.bound();
-        self.exact().is_some_and(|len| len.rel != Rel::ZERO)
-            || [bound.min, bound.max]
-                .iter()
-                .flatten()
-                .any(|len| len.rel != Rel::ZERO)
-    }
-
-    /// This rule with a floor under it, which is the whole of it where there
-    /// was no rule.
-    pub fn at_least(&self, min: Len) -> Self {
-        match *self {
-            Self::Free | Self::Min(_) => Self::Min(min),
-            Self::Max(max) | Self::Clamp { max, .. } => Self::Clamp { min, max },
-            Self::Request(ref request) => request.as_ref().clone().max(min).into(),
-            Self::Exact(len) => len.max(min).into(),
-        }
-    }
-
-    /// This rule with a cap over it, which is the whole of it where there was
-    /// no rule.
-    pub fn at_most(&self, max: Len) -> Self {
-        match *self {
-            Self::Free | Self::Max(_) => Self::Max(max),
-            Self::Min(min) | Self::Clamp { min, .. } => Self::Clamp { min, max },
-            Self::Request(ref request) => request.as_ref().clone().min(max).into(),
-            Self::Exact(len) => len.min(max).into(),
-        }
-    }
-
     /// The length this rule gives without the widget being drawn, if it can
-    /// give one.
+    /// give one. `leftover` is never among them: a share is a length only to
-    pub fn declared(&self) -> Option<Len> {
+    /// whoever divides one, so it passes up in the reported size instead and
-        self.exact().and_then(|len| len.declared())
+    /// is resolved there.
+    pub fn declared(&self) -> Option<LayoutLen> {
+        match self {
+            Self::Exact(len) if len.leftover == Weight::ZERO => Some(*len),
+            _ => None,
+        }
     }
 
     /// The length this rule gives outright, whatever the widget reports --
@@ -96,97 +36,26 @@ impl SizeRule {
     /// that give a box directly.
     pub fn exact(&self) -> Option<LayoutLen> {
         match self {
+            Self::Free => None,
             Self::Exact(len) => Some(*len),
-            Self::Free | Self::Request(_) | Self::Min(_) | Self::Max(_) | Self::Clamp { .. } => {
-                None
         }
     }
-    }
-}
 
-/// What a rule allows a length to be where it does not give one outright: a
+    /// The length a widget reporting `reported` ends up with.
-/// floor, a cap, or both. Each is a length of the rel base the widget is
+    pub fn apply(&self, reported: LayoutLen) -> LayoutLen {
-/// asked with, which is the base a declared length is a fraction of too.
+        match self {
-///
+            Self::Free => reported,
-/// A bound is a [`Len`]. Comparisons involving shares are [`SizeRequest`]s.
+            Self::Exact(len) => *len,
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
-pub struct Bound {
-    pub min: Option<Len>,
-    pub max: Option<Len>,
-}
-
-/// Which end of a bound a length fell outside.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Outside {
-    Shorter,
-    Longer,
-}
-
-impl Bound {
-    /// Every length.
-    pub const ANY: Self = Self {
-        min: None,
-        max: None,
-    };
-
-    /// The end [`Outside`] names, which is the length a widget outside it
-    /// gets instead of its own.
-    pub fn at(&self, outside: Outside) -> Len {
-        let end = match outside {
-            Outside::Shorter => self.min,
-            Outside::Longer => self.max,
-        };
-        end.expect("an end nothing is outside of")
-    }
-
-    /// This bound as lengths of the window, from lengths of a rel base that
-    /// long.
-    pub fn within_len(&self, len: Len) -> Self {
-        Self {
-            min: self.min.map(|min| min.within_len(len)),
-            max: self.max.map(|max| max.within_len(len)),
         }
     }
 }
 
-/// One bound per axis, as [`SizeRules`] is one rule per axis.
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
-pub struct Bounds {
-    pub x: Bound,
-    pub y: Bound,
-}
-
-impl Bounds {
-    pub const ANY: Self = Self {
-        x: Bound::ANY,
-        y: Bound::ANY,
-    };
-
-    pub fn from_axes(f: impl Fn(Axis) -> Bound) -> Self {
-        Self {
-            x: f(Axis::X),
-            y: f(Axis::Y),
-        }
-    }
-}
-
-impl_axis_index!(Bounds => Bound);
-
 impl From<LayoutLen> for SizeRule {
     fn from(len: LayoutLen) -> Self {
         Self::Exact(len)
     }
 }
 
-impl From<SizeRequest> for SizeRule {
-    fn from(request: SizeRequest) -> Self {
-        match request {
-            SizeRequest::Linear(len) => Self::Exact(len),
-            request => Self::Request(std::sync::Arc::new(request)),
-        }
-    }
-}
-
 impl From<Option<LayoutLen>> for SizeRule {
     fn from(len: Option<LayoutLen>) -> Self {
         len.map_or(Self::Free, Self::Exact)
@@ -195,35 +64,24 @@ impl From<Option<LayoutLen>> for SizeRule {
 
 /// One rule per axis, which is how a widget carries a length on one axis and
 /// leaves the other to whatever it draws.
-#[derive(Debug, Clone, PartialEq, Default)]
+#[derive(Debug, Clone, Copy, PartialEq, Default)]
 pub struct SizeRules {
     pub x: SizeRule,
     pub y: SizeRule,
 }
 
-impl_axis_index!(SizeRules => SizeRule);
+impl SizeRules {
+    pub fn axis(&self, axis: Axis) -> SizeRule {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
 
-/// What a widget's box is on each axis where something says so outright,
+    pub fn axis_mut(&mut self, axis: Axis) -> &mut SizeRule {
-/// before it is drawn: a rule beside it, or a hint it gives about itself.
+        match axis {
-/// Whoever draws the widget resolves these against its rel base.
+            Axis::X => &mut self.x,
-///
+            Axis::Y => &mut self.y,
-/// A [`Len`] rather than a [`LayoutLen`], because a share can never be one
-/// -- see [`LayoutLen::declared`].
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct Declared {
-    pub x: Option<Len>,
-    pub y: Option<Len>,
-}
-
-impl Declared {
-    pub const NONE: Self = Self { x: None, y: None };
-
-    pub fn from_axes(f: impl Fn(Axis) -> Option<Len>) -> Self {
-        Self {
-            x: f(Axis::X),
-            y: f(Axis::Y),
         }
     }
 }
-
-impl_axis_index!(Declared => Option<Len>);

core/src/widget/widgets.rs

@@ -1,8 +1,8 @@
 use std::sync::mpsc::{Receiver, Sender, channel};
 
 use crate::{
-    Axis, AxisAlign, IdLike, Len, RegionAlign, SizeRule, SizeRules, StrongWidget, WeakWidget,
+    Axis, AxisAlign, IdLike, RegionAlign, SizeRule, SizeRules, StrongWidget, WeakWidget, Widget,
-    Widget, WidgetData, WidgetId,
+    WidgetData, WidgetId,
     util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut},
 };
 
@@ -30,14 +30,6 @@ impl Widgets {
         !self.needs_redraw.is_empty()
     }
 
-    /// Marks this widget for the next frame to draw again, with nothing about
-    /// it changed. Taking a widget mutably marks it too, which is the ordinary
-    /// content-change signal; this is for a change the borrow cannot express,
-    /// and for asking for the same tree over again.
-    pub fn mark_for_redraw(&mut self, id: impl IdLike) {
-        self.needs_redraw.insert(id.id());
-    }
-
     pub fn get_dyn(&self, id: WidgetId) -> Option<&dyn Widget> {
         Some(self.vec.get(id)?.widget.as_ref())
     }
@@ -49,14 +41,14 @@ impl Widgets {
 
     /// get_dyn but dynamic borrow checking of widgets
     /// lets you do recursive (tree) operations, like the painter does
-    pub(crate) fn get_dyn_dynamic<'a>(&self, id: WidgetId) -> DynBorrower<'a, dyn Widget> {
+    pub(crate) fn get_dyn_dynamic<'a>(&self, id: WidgetId) -> WidgetWrapper<'a> {
         // SAFETY: must guarantee no other mutable references to this widget exist
         // done through the borrow variable
         let data = unsafe { forget_mut(to_mut(self.vec.get(id).unwrap())) };
         if data.borrowed {
             panic!("tried to mutably borrow the same widget twice");
         }
-        DynBorrower::new(data.widget.as_mut(), &mut data.borrowed)
+        WidgetWrapper::new(data.widget.as_mut(), &mut data.borrowed)
     }
 
     pub fn get<I: IdLike>(&self, id: &I) -> Option<&I::Widget>
@@ -129,7 +121,7 @@ impl Widgets {
 
     /// The length rules whoever draws this widget applies to its box.
     pub fn size_rules(&self, id: impl IdLike) -> SizeRules {
-        self.data(id).unwrap().size.clone()
+        self.data(id).unwrap().size
     }
 
     /// Sets one axis's rule. The widget is marked rather than its parent
@@ -138,29 +130,13 @@ impl Widgets {
     pub fn set_size_rule(&mut self, id: impl IdLike, axis: Axis, rule: SizeRule) {
         let id = id.id();
         let data = self.data_mut(id).unwrap();
-        if data.size[axis] == rule {
+        if *data.size.axis_mut(axis) == rule {
             return;
         }
-        data.size[axis] = rule;
+        *data.size.axis_mut(axis) = rule;
         self.needs_redraw.insert(id);
     }
 
-    /// Puts a floor under this widget's length on one axis, keeping a cap it
-    /// already had. See [`SizeRule::at_least`].
-    pub fn set_min_len(&mut self, id: impl IdLike, axis: Axis, min: Len) {
-        let id = id.id();
-        let rule = self.size_rules(id)[axis].at_least(min);
-        self.set_size_rule(id, axis, rule);
-    }
-
-    /// Puts a cap over it, keeping a floor it already had. See
-    /// [`SizeRule::at_most`].
-    pub fn set_max_len(&mut self, id: impl IdLike, axis: Axis, max: Len) {
-        let id = id.id();
-        let rule = self.size_rules(id)[axis].at_most(max);
-        self.set_size_rule(id, axis, rule);
-    }
-
     /// Where this widget sits in a box longer than the length it takes.
     pub fn alignment(&self, id: impl IdLike) -> RegionAlign {
         self.data(id).unwrap().align
@@ -171,14 +147,14 @@ impl Widgets {
     pub fn set_alignment(&mut self, id: impl IdLike, axis: Axis, align: AxisAlign) {
         let id = id.id();
         let data = self.data_mut(id).unwrap();
-        if data.align[axis] == align {
+        if *data.align.axis_mut(axis) == align {
             return;
         }
-        data.align[axis] = align;
+        *data.align.axis_mut(axis) = align;
         self.needs_redraw.insert(id);
     }
 
-    /// Both axes at once.
+    /// Both axes at once, for a caller holding a pair.
     pub fn set_size_rules(
         &mut self,
         id: impl IdLike,
@@ -212,6 +188,8 @@ impl Default for Widgets {
     }
 }
 
+pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>;
+
 impl<I: IdLike> std::ops::Index<I> for Widgets
 where
     I::Widget: Sized + Widget,

macro/src/lib.rs

@@ -18,7 +18,6 @@ struct Input {
 }
 
 struct InputFn {
-    attrs: Vec<Attribute>,
     sig: Signature,
     body: Block,
 }
@@ -33,10 +32,9 @@ impl Parse for Input {
         input.parse::<Token![;]>()?;
         let mut fns = Vec::new();
         while !input.is_empty() {
-            let attrs = input.call(Attribute::parse_outer)?;
             let sig = input.parse()?;
             let body = input.parse()?;
-            fns.push(InputFn { attrs, sig, body })
+            fns.push(InputFn { sig, body })
         }
         if !input.is_empty() {
             input.error("function expected");
@@ -61,15 +59,10 @@ pub fn widget_trait(input: TokenStream) -> TokenStream {
         fns,
     } = parse_macro_input!(input as Input);
 
-    // What a method says about itself belongs on the trait, where a reader
+    let sigs: Vec<_> = fns.iter().map(|f| f.sig.clone()).collect();
-    // looks it up; the implementation is the same text and says it again.
-    let sigs: Vec<_> = fns
-        .iter()
-        .map(|InputFn { attrs, sig, .. }| quote! { #(#attrs)* #sig })
-        .collect();
     let impls: Vec<_> = fns
         .iter()
-        .map(|InputFn { attrs, sig, body }| quote! { #(#attrs)* #sig #body })
+        .map(|InputFn { sig, body }| quote! { #sig #body })
         .collect();
 
     let Some(GenericParam::Type(state)) = generics.params.first() else {

scripts/run-headless.sh

@@ -106,16 +106,11 @@ export WAYLAND_DISPLAY
 
 echo "run-headless: $WAYLAND_DISPLAY (sway $(swaymsg -t get_version --raw | sed -n 's/.*"human_readable":"\([^"]*\)".*/\1/p'))" >&2
 
-# The extent `replay-touch` positions against, so a script's coordinates are
+swaymsg output HEADLESS-1 mode "$mode" >/dev/null
-# the output's own pixels. Set beside every mode change, since a gesture
+# The extent `replay-touch` positions against, so a script's coordinates
-# scaled against a mode the output no longer has lands somewhere else and
+# are the output's own pixels.
-# still looks like a run that worked.
+out_w=${mode%x*}
-set_mode() {
+out_h=${mode#*x}; out_h=${out_h%@*}
-    swaymsg output HEADLESS-1 mode "$1" >/dev/null
-    out_w=${1%x*}
-    out_h=${1#*x}; out_h=${out_h%@*}
-}
-set_mode "$mode"
 
 # Built before the app starts, so a compile error is not reported as a
 # window that failed to move.
@@ -154,7 +149,7 @@ while [ $i -lt "$((seconds * 2))" ]; do
 done
 
 if [ -n "$resize" ] && kill -0 "$pid" 2>/dev/null; then
-    set_mode "$resize"
+    swaymsg output HEADLESS-1 mode "$resize" >/dev/null
     echo "run-headless: resized to $resize" >&2
     sleep 2
 fi

src/default/attr.rs

@@ -15,10 +15,9 @@ where
             let region = ctx.data.render.window_region(&id).unwrap();
             let id_pos = region.top_left;
             let container_pos = ctx.data.render.window_region(&container).unwrap().top_left;
-            // The two regions are on the grid and the pointer is not, so the
+            // The pointer arrives from the platform in floats; everything
-            // step between them is taken there and the pointer keeps the
+            // it is compared against is on the grid.
-            // precision the platform gave it.
+            let pos = (PxVec2::from_f32(ctx.data.pos) + container_pos - id_pos).to_f32();
-            let pos = ctx.data.pos + (container_pos - id_pos).to_f32();
             let size = region.size().to_f32();
             select(
                 rsc,

src/default/render.rs

@@ -22,12 +22,12 @@ impl UiRenderer {
     }
 
     pub fn draw(&mut self) {
-        let (output, suboptimal) = match self.surface.get_current_texture() {
+        let output = match self.surface.get_current_texture() {
-            CurrentSurfaceTexture::Success(texture) => (texture, false),
+            CurrentSurfaceTexture::Success(texture) => texture,
-            // Used for this frame, and the swapchain rebuilt after it has
+            CurrentSurfaceTexture::Suboptimal(texture) => {
-            // been presented: configuring the surface while a texture it
+                self.surface.configure(&self.device, &self.config);
-            // handed out is still alive panics.
+                texture
-            CurrentSurfaceTexture::Suboptimal(texture) => (texture, true),
+            }
             CurrentSurfaceTexture::Outdated | CurrentSurfaceTexture::Lost => {
                 self.surface.configure(&self.device, &self.config);
                 return;
@@ -60,9 +60,6 @@ impl UiRenderer {
         self.queue.submit(std::iter::once(encoder.finish()));
         self.window.pre_present_notify();
         self.queue.present(output);
-        if suboptimal {
-            self.surface.configure(&self.device, &self.config);
-        }
     }
 
     pub fn resize(&mut self, size: &PhysicalSize<u32>) {

src/random.rs

@@ -8,16 +8,23 @@
 use crate::prelude::*;
 use std::collections::HashMap;
 
+/// The declared lengths of one widget carrying a size rule, by axis.
+pub type Lens = [Option<LayoutLen>; 2];
+
+/// Where one widget carrying an alignment sits, by axis. `None` uses the
+/// centered default.
+pub type Aligns = [Option<AxisAlign>; 2];
+
 /// What a test changes between two trees grown from the same seed, so the
 /// warm one can be mutated and the cold one grown that way to begin with.
 #[derive(Default)]
 pub struct Edits {
     /// Declared sizes, by the order the rules were put on.
-    pub sizes: HashMap<usize, SizeRules>,
+    pub sizes: HashMap<usize, Lens>,
     /// Which children a span has, by the order the spans were made.
     pub spans: HashMap<usize, SpanEdit>,
     /// Alignments, by the order they were put on.
-    pub aligns: HashMap<usize, Align>,
+    pub aligns: HashMap<usize, Aligns>,
     /// Which widgets own a movable region, by the order they were offered
     /// one. Region nodes change what a move writes and how deep a primitive's
     /// chain is, so a tree that never grows one leaves both untested.
@@ -111,9 +118,9 @@ pub struct Branch {
 impl Widget for Branch {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let cut = Len::from_parts(Rel::ZERO, Px::from_int(40));
-        let top = UiSpan::new(Len::ZERO, cut).shifted_desc();
+        let top = Place::Within(Part::From(UiSpan::new(Len::ZERO, cut)));
         let measured = painter
-            .widget_at(&self.probe, top.on_axis(Axis::Y))
+            .widget_at(&self.probe, [None; 2], [Place::Within(Part::All), top])
             .len(Axis::X);
         let len = measured.apply_leftover();
         let px = painter.to_px(len, Axis::X);
@@ -127,11 +134,11 @@ impl Widget for Branch {
         };
         painter.window_holds(Axis::X, holds.through(len));
 
-        let below = UiSpan::new(cut, painter.region_len(Axis::Y)).shifted_desc();
+        let below = Place::Within(Part::From(UiSpan::new(cut, painter.extent_len(Axis::Y))));
-        let place = below.on_axis(Axis::Y);
+        let place = [Place::Within(Part::All), below];
         match px > threshold {
-            true => painter.widget_at(&self.wide, place),
+            true => painter.widget_at(&self.wide, [None; 2], place),
-            false => painter.widget_at(&self.narrow, place),
+            false => painter.widget_at(&self.narrow, [None; 2], place),
         };
         Size::LEFTOVER
     }
@@ -169,11 +176,9 @@ pub struct Plan {
     /// it one and the offer is taken or declined; a second offer to the same
     /// widget is dropped, because two rules on one widget would settle in the
     /// order they were applied rather than in grow order.
-    pub size: Option<SizeRules>,
+    pub size: Option<Lens>,
-    /// The alignment it carries, under the same one-offer rule. An axis left
+    /// The alignment it carries, under the same one-offer rule.
-    /// out takes the centered default, which is what [`RegionAlign`] reads it
+    pub align: Option<Aligns>,
-    /// as.
-    pub align: Option<Align>,
     /// Whether it was offered a movable region of its own and what it
     /// answered. `Some(false)` is an offer declined, which still uses up the
     /// one offer, where `None` is an offer never made.
@@ -190,9 +195,6 @@ pub enum Kind {
         color: usize,
         alpha: u8,
     },
-    /// The one leaf whose own length is a number of pixels it knows before it
-    /// is drawn, which is the hint a rule beside it has to win over.
-    Image,
     /// Scrolling reads the pixel length of its box, which nothing else here
     /// does, and gives its child a box longer than its own.
     Scroll {
@@ -292,7 +294,7 @@ impl Plan {
                 align: None,
                 ..self.clone()
             }),
-            self.size.as_ref().map(|_| Plan {
+            self.size.map(|_| Plan {
                 size: None,
                 ..self.clone()
             }),
@@ -373,7 +375,7 @@ impl Plan {
             }
             if plan.size.is_some() {
                 if let Some(lens) = edits.sizes.get(&sized) {
-                    plan.size = Some(lens.clone());
+                    plan.size = Some(*lens);
                 }
                 sized += 1;
             }
@@ -446,11 +448,9 @@ impl Kind {
         }
         match self {
             // The one leaf that reads the width it is given, then the one
-            // that does not, then the one that measures nothing at all. A
+            // that does not, then the one that measures nothing at all.
-            // picture measures nothing either, but its length is its own, so
-            // it steps to the leaf that takes whatever it is given.
             Kind::Wrapped => out.push(Kind::OneLine),
-            Kind::OneLine | Kind::Image => out.push(Kind::Rect {
+            Kind::OneLine => out.push(Kind::Rect {
                 color: 0,
                 alpha: 255,
             }),
@@ -632,10 +632,9 @@ struct Sow<'a> {
 
 impl Sow<'_> {
     fn leaf(&mut self) -> Plan {
-        Plan::bare(match self.rng.below(5) {
+        Plan::bare(match self.rng.below(4) {
             0 => Kind::Wrapped,
             1 => Kind::OneLine,
-            2 => Kind::Image,
             _ => {
                 let color = self.rng.below(COLORS.len());
                 let alpha = (self.rng.below(5) * 63) as u8;
@@ -644,49 +643,15 @@ impl Sow<'_> {
         })
     }
 
-    fn len(&mut self) -> LayoutLen {
+    fn len(&mut self) -> Option<LayoutLen> {
-        LayoutLen::px(20.0 + self.rng.below(180) as f32)
+        match self.rng.below(4) {
-    }
+            0 => Some(LayoutLen::px(20.0 + self.rng.below(180) as f32)),
-
+            1 => Some(LayoutLen::LEFTOVER),
-    /// A length of a box rather than a length of the window, which is what a
+            _ => None,
-    /// bound is.
-    ///
-    /// Pixels only, for now. A fraction in a bound is resolved against the rel
-    /// base the widget was asked with, and `place_at` hands a parent a
-    /// retained answer without checking that the answer still holds for the
-    /// rel base this place gives -- so a fraction resolved against one rel
-    /// base survives into another. Seeds 4 (shuffle-all-but-first) and 196
-    /// (resize-size) at depth 5 are where that showed; both pass with pixels.
-    /// The hole is older than bounds -- an `Exact` rule that is a fraction
-    /// can reach it too -- and closing it is a check at the re-place site.
-    fn bound(&mut self) -> Len {
-        Len::px(20.0 + self.rng.below(180) as f32)
-    }
-
-    fn rule(&mut self) -> SizeRule {
-        match self.rng.below(8) {
-            0 | 1 => self.len().into(),
-            2 => LayoutLen::LEFTOVER.into(),
-            3 => SizeRule::Min(self.bound()),
-            4 => SizeRule::Max(self.bound()),
-            // Both in pixels, so one can be put under the other: a floor and
-            // a cap that change sides with the window bound nothing, which
-            // is a caller's bug rather than a tree to grow.
-            5 => {
-                let (a, b) = (
-                    Px::from_f32(20.0 + self.rng.below(180) as f32),
-                    Px::from_f32(20.0 + self.rng.below(180) as f32),
-                );
-                SizeRule::Clamp {
-                    min: Len::px(a.min(b).to_f32()),
-                    max: Len::px(a.max(b).to_f32()),
-                }
-            }
-            _ => SizeRule::Free,
         }
     }
 
-    fn align(&mut self) -> Align {
+    fn align(&mut self) -> Aligns {
         let axis = |s: &mut Self| match s.rng.below(4) {
             0 => None,
             1 => Some(AxisAlign::NEG),
@@ -696,27 +661,21 @@ impl Sow<'_> {
         let (x, y) = (axis(self), axis(self));
         // Aligning on neither axis leaves the branch unexercised.
         match x.is_none() && y.is_none() {
-            true => Align {
+            true => [Some(AxisAlign::CENTER), y],
-                x: Some(AxisAlign::CENTER),
+            false => [x, y],
-                y,
-            },
-            false => Align { x, y },
         }
     }
 
     /// A declared size over half the tree, kept where a test can change it.
     fn sized(&mut self, inner: &mut Plan) {
         let take = self.rng.chance();
-        let lens = SizeRules {
+        let lens = [self.len(), self.len()];
-            x: self.rule(),
-            y: self.rule(),
-        };
         if !take || inner.size.is_some() {
             return;
         }
         let idx = self.sized;
         self.sized += 1;
-        inner.size = Some(self.edits.sizes.get(&idx).cloned().unwrap_or(lens));
+        inner.size = Some(self.edits.sizes.get(&idx).copied().unwrap_or(lens));
     }
 
     /// An alignment over some of the tree, kept where a test can change it.
@@ -814,6 +773,10 @@ impl Sow<'_> {
         self.spans += 1;
         let edit = self.edits.spans.get(&idx).cloned().unwrap_or_default();
         let dir = self.rng.below(4);
+        // A row takes the height it is given rather than its tallest child,
+        // which is a rule beside it. Derived from an existing choice and
+        // consuming no randomness: a seed must keep growing the same tree
+        // when the generator gains another configuration.
         let gap = self.rng.below(3) as i32 * 4;
         let grown: Vec<usize> = (0..children.len()).collect();
         let order = span_edited(&grown, children.len(), spares.len(), &edit);
@@ -833,7 +796,6 @@ pub fn build<Rsc: UiRsc + 'static>(rsc: &mut Rsc, plan: &Plan) -> (StrongWidget,
     let mut build = Build {
         rsc,
         tree: Tree::default(),
-        checkerboard: None,
     };
     let root = build.node(plan);
     (root, build.tree)
@@ -842,25 +804,23 @@ pub fn build<Rsc: UiRsc + 'static>(rsc: &mut Rsc, plan: &Plan) -> (StrongWidget,
 struct Build<'a, Rsc> {
     rsc: &'a mut Rsc,
     tree: Tree,
-    /// The checkerboard, uploaded when the first image in this tree is built.
-    /// A handle is a reference to the texture, so every image after that one
-    /// clones this rather than uploading the same picture again.
-    checkerboard: Option<TextureHandle>,
 }
 
 impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
     fn node(&mut self, plan: &Plan) -> StrongWidget {
         let built = self.kind(&plan.kind);
         let id = built.id();
-        if let Some(lens) = plan.size.clone() {
+        if let Some(lens) = plan.size {
-            self.rsc.ui_mut().widgets.set_size_rules(id, lens.x, lens.y);
+            self.rsc
+                .ui_mut()
+                .widgets
+                .set_size_rules(id, lens[0], lens[1]);
             self.tree.sized.push(id);
         }
         if let Some(align) = plan.align {
-            let resolved = RegionAlign::from(align);
             let widgets = &mut self.rsc.ui_mut().widgets;
-            for axis in Axis::BOTH {
+            for (axis, align) in [Axis::X, Axis::Y].into_iter().zip(align) {
-                widgets.set_alignment(id, axis, resolved[axis]);
+                widgets.set_alignment(id, axis, align.unwrap_or_default());
             }
             self.tree.aligned.push(id);
         }
@@ -871,20 +831,6 @@ impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
         built
     }
 
-    /// The one picture the generated trees draw: a 64x64 checkerboard of purple
-    /// and black in 8 px cells. Committed rather than drawn here, so that one
-    /// seed is one tree whatever anything else does, and included rather than
-    /// opened, so that growing a tree does not depend on a working directory.
-    fn checkerboard(&mut self) -> TextureHandle {
-        if self.checkerboard.is_none() {
-            let image = include_bytes!("assets/checkerboard.png")
-                .get_image()
-                .expect("the checkerboard is committed beside this file");
-            self.checkerboard = Some(self.rsc.ui_mut().textures.add(image));
-        }
-        self.checkerboard.clone().unwrap()
-    }
-
     fn kind(&mut self, kind: &Kind) -> StrongWidget {
         let id: StrongWidget = match kind {
             Kind::Wrapped => wtext(WORDS).size(16).wrap(true).add_strong(self.rsc),
@@ -893,7 +839,6 @@ impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
                 .wrap(false)
                 .add_strong(self.rsc),
             Kind::Rect { color, alpha } => rect(COLORS[*color].alpha(*alpha)).add_strong(self.rsc),
-            Kind::Image => Image::new(self.checkerboard()).add_strong(self.rsc),
             Kind::Scroll { axis, inner } => {
                 let inner = self.node(inner);
                 let id = Scroll::new(inner, *axis).add(self.rsc);
@@ -970,10 +915,6 @@ impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
                     gap: Px::from_int(*gap),
                 }
                 .add(self.rsc);
-                // A row takes the height it is given rather than its tallest
-                // child, which is a rule beside the span rather than anything
-                // it draws. Derived from `dir` rather than stored, so a plan
-                // that says the direction says this too.
                 if dir.axis == Axis::X {
                     self.rsc
                         .widgets_mut()

src/widget/image.rs

@@ -12,16 +12,7 @@ impl Widget for Image {
     }
 
     fn size_hint(&self, axis: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::px(self.handle.size()[axis]))
+        Some(LayoutLen::px(self.handle.size().axis(axis)))
-    }
-}
-
-impl Image {
-    /// One texture already uploaded, for a caller holding its handle: [`image()`]
-    /// uploads what it is given, and several widgets showing one picture want
-    /// one upload and one slot between them.
-    pub fn new(handle: TextureHandle) -> Self {
-        Self { handle }
     }
 }
 

src/widget/position/layer.rs

@@ -6,10 +6,6 @@ pub struct LayerOffset {
 }
 
 impl Widget for LayerOffset {
-    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
-        requests.widget(&self.inner, axis)
-    }
-
     fn draw(&mut self, painter: &mut Painter) -> Size {
         for _ in 0..self.offset {
             painter.next_layer();

src/widget/position/max_size.rs

@@ -1,68 +0,0 @@
-use crate::prelude::*;
-
-/// Asks its child in the shorter of a cap and the box this widget was given,
-/// and answers what the child used, held to the same cap.
-///
-/// A cap on the box is a widget rather than a [`SizeRule`] because a box is
-/// whoever asked's to decide: a rule that read the box it was given would be
-/// decided again by every path that hands a widget one, including the ones
-/// that re-place a drawing without asking it anything, and the decision would
-/// then depend on which path arrived last. A widget is drawn again whenever
-/// its own box changes, so the comparison is made where the answer can be
-/// kept -- `longer_than` narrows the windows this drawing holds for, and
-/// `holds` says the box lengths.
-///
-/// The box is what a text wraps at and what a scroll takes its viewport from,
-/// which is why capping the answer alone is not the same thing.
-pub struct MaxSize {
-    pub inner: StrongWidget,
-    pub x: Option<Len>,
-    pub y: Option<Len>,
-}
-
-impl MaxSize {
-    fn max(&self, axis: Axis) -> Option<Len> {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-}
-
-impl Widget for MaxSize {
-    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
-        let inner = requests.widget(&self.inner, axis)?;
-        Some(match self.max(axis) {
-            Some(max) => requests.min(inner, max.into()),
-            None => inner,
-        })
-    }
-
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let align = painter.alignment();
-        let mut region = UiRegion::FULL;
-        for axis in Axis::BOTH {
-            let Some(max) = self.max(axis) else {
-                continue;
-            };
-            let own = painter.region_len(axis);
-            if painter.longer_than(own, max, axis) {
-                region[axis] = max.align(align[axis]);
-            }
-        }
-        let mut size = painter.widget_at(&self.inner, region).size();
-        for axis in Axis::BOTH {
-            // The child may draw past the box it was given -- a text too tall
-            // for it -- and the cap is a promise about the length as well. A
-            // share passes through: it is a length only to whoever divides
-            // one, and that is this widget's parent rather than this widget,
-            // which has already given the share the box the cap allows.
-            if let Some(max) = self.max(axis)
-                && painter.longer_than(size[axis].without_leftover(), max, axis)
-            {
-                size[axis] = max.into();
-            }
-        }
-        size
-    }
-}

src/widget/position/mod.rs

@@ -1,5 +1,4 @@
 mod layer;
-mod max_size;
 mod offset;
 mod pad;
 mod scroll;
@@ -7,7 +6,6 @@ mod span;
 mod stack;
 
 pub use layer::*;
-pub use max_size::*;
 pub use offset::*;
 pub use pad::*;
 pub use scroll::*;

src/widget/position/offset.rs

@@ -6,13 +6,15 @@ pub struct Offset {
 }
 
 impl Widget for Offset {
-    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
-        requests.widget(&self.inner, axis)
-    }
-
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter
+        // The whole of this widget's box, moved: the frame passes through, so
-            .widget_at(&self.inner, UiRegion::FULL.offset(self.amt))
+        // what the child declares or reports means the same as it would
-            .size()
+        // without the offset.
+        let moved = |len: Len, amt: Len| Place::Within(Part::From(UiSpan::new(amt, len + amt)));
+        let place = [
+            moved(painter.extent_len(Axis::X), self.amt.x),
+            moved(painter.extent_len(Axis::Y), self.amt.y),
+        ];
+        painter.widget_at(&self.inner, [None; 2], place).size()
     }
 }

src/widget/position/pad.rs

@@ -6,14 +6,6 @@ pub struct Pad {
 }
 
 impl Widget for Pad {
-    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
-        let padding = match axis {
-            Axis::X => self.padding.left + self.padding.right,
-            Axis::Y => self.padding.top + self.padding.bottom,
-        };
-        requests.inset(&self.inner, axis, padding)
-    }
-
     fn draw(&mut self, painter: &mut Painter) -> Size {
         // The inner's own alignment, not the near edge. This reports the
         // inner's size plus the padding, so where the box is that answer the
@@ -22,12 +14,31 @@ impl Widget for Pad {
         // widget -- the slack is the inner's to sit in, and forcing the near
         // edge pinned it to a corner it had not asked for.
         //
-        // Padding is an inset of both: it comes off the rel base, so `rel(1)`
+        // Padding is an inset of both: it comes off the frame, so `rel(1)`
         // under it fills this widget rather than overflowing it by the
         // padding, and it comes off the box, so what is drawn sits inside.
         // The two stay distinct -- the box can be narrower still, where a row
         // asked this widget in the room left, and a text wraps at that.
-        let inner = painter.widget_at(&self.inner, self.padding.region()).size();
+        let inset = |lead: Px, trail: Px| {
+            Place::Within(Part::Inset {
+                lead: Len::from_parts(Rel::ZERO, lead),
+                trail: Len::from_parts(Rel::ZERO, trail),
+            })
+        };
+        let place = [
+            inset(self.padding.left, self.padding.right),
+            inset(self.padding.top, self.padding.bottom),
+        ];
+        // Read from this widget's own frame rather than written as a
+        // fraction of it: a frame is a length of the window like everything
+        // else here, and taking the padding off is the whole of what this
+        // widget does to it.
+        let narrow = [
+            (Axis::X, self.padding.left + self.padding.right),
+            (Axis::Y, self.padding.top + self.padding.bottom),
+        ]
+        .map(|(axis, pixels)| Some(painter.frame_len(axis) - Len::from_parts(Rel::ZERO, pixels)));
+        let inner = painter.widget_at(&self.inner, narrow, place).size();
         Size {
             x: LayoutLen {
                 px: inner.x.px + self.padding.left + self.padding.right,

src/widget/position/scroll.rs

@@ -14,56 +14,58 @@ impl Widget for Scroll {
         let container_len = painter.px_len(self.axis);
         // Asked in the whole viewport, then put at the scrolled offset.
         let answer_len = painter
-            .widget_at(&self.inner, PlaceDesc::WHOLE.fills())
+            .widget_at(&self.inner, [None; 2], [Place::Fill(Part::All); 2])
             .len(self.axis);
-        let answer_px = painter.to_px(answer_len.without_leftover(), self.axis);
+        let fixed = painter.to_px(Len::from_parts(answer_len.rel, answer_len.px), self.axis);
         self.container_len = container_len;
-        self.content_len = answer_px.max(container_len);
+        self.content_len = fixed.max(container_len);
 
         if self.snap_end {
             self.amt = self.content_len - self.container_len;
         }
         self.update_amt();
-        // Reading the box in pixels above holds this drawing to that one
+        let align = painter.alignment().axis(self.axis);
-        // length, so these two say where it holds more widely.
+        // Content of a fixed length that fits sits at the start of any box it
-        //
+        // fits in -- but only anchored there. Anywhere else it is a part of
-        // Content of a fixed length that fits is handed the whole box below,
+        // the room left over, so it moves with every length the box takes and
-        // and nothing here reads the box again, so every longer box gives the
+        // the drawing holds for that length alone. One scrolled part way sits
-        // same drawing: it holds from the length the content needs upwards,
+        // where it is until the box shrinks past what is left of it. Kept to
-        // and shrinking past that is what changes it. Where it sits in a box
+        // the end, it moves with every length.
-        // longer than itself is not this widget's to say -- placing its
+        let fixed_len = answer_len.rel == Rel::ZERO && answer_len.leftover == Weight::ZERO;
-        // answer in the whole box is its own alignment, and that placement is
+        if fixed_len && self.content_len <= self.container_len && align == AxisAlign::NEG {
-        // a fraction of the box, so it holds at every length too.
+            painter.holds(self.axis, fixed..=Px::MAX);
-        //
+        } else if fixed_len && !self.snap_end {
-        // One scrolled part way sits where it is until the box shrinks past
-        // what is left of it. Kept to the end, it moves with every length.
-        let answer_is_px = answer_len.is_px();
-        if answer_is_px && self.content_len <= self.container_len {
-            painter.holds(self.axis, answer_px..=Px::MAX);
-        } else if answer_is_px && !self.snap_end {
             let left = self.content_len - self.amt;
             painter.holds(self.axis, Px::MIN..=left);
         }
 
-        // Content that fills the viewport is the viewport, and is handed back
+        // Content shorter than the viewport has room to sit in, and where it
-        // as it came -- it has nothing to scroll through, so the clamp above
+        // sits is this widget's own alignment -- the same property that would
-        // has already put `amt` at zero. Writing the same box as its own
+        // have placed the whole scroll in a box longer than it.
-        // length in pixels is the same box in another form, and the two do
+        let slack = (self.container_len - self.content_len).max(Px::ZERO);
-        // not round alike: a part centred in `rel 1` lands a step from one
+        let anchor = slack.mul(align.rel());
-        // centred in `px 900`, since halving a difference is not halving each
+        // Content that fills the viewport and has not been scrolled is the
-        // part of it.
+        // viewport, and is handed back as it came. Writing the same box as
-        let content = match self.content_len > self.container_len {
+        // its own length in pixels is the same box in another form, and the
+        // two do not round alike: a part centred in `rel 1` lands a step from
+        // one centred in `px 900`, since halving a difference is not halving
+        // each part of it.
+        let moved = anchor != Px::ZERO || self.amt != Px::ZERO;
+        let content = match moved || self.content_len != self.container_len {
             true => {
-                let start = Len::from_parts(Rel::ZERO, -self.amt);
+                let start = Len::from_parts(Rel::ZERO, anchor - self.amt);
-                UiSpan::new(start, start.offset(self.content_len)).shifted_desc()
+                Part::From(UiSpan::new(start, start.offset(self.content_len)))
             }
-            false => PlaceDescAxis::WHOLE,
+            false => Part::All,
         };
-        // The viewport is the inner's rel base, so a fraction it declares or
+        // The viewport is the inner's frame, so a fraction it declares or
         // reports is a fraction of what is on screen rather than of the
         // content box its own answer decided. Where it goes is the content
         // box, scrolled: its drawing moved there, not made again there.
-        painter.place_at(&self.inner, content.on_axis(self.axis).fills());
+        painter.place_at(
+            &self.inner,
+            self.axis.pair(Place::Fill(content), Place::Fill(Part::All)),
+        );
         // What it occupies is its box, on both axes: it clips its content to
         // that box, so it can neither take less of one nor honestly ask for
         // more. The content's length is what it scrolls through, not what it

src/widget/position/span.rs

@@ -8,81 +8,106 @@ pub struct Span {
 }
 
 impl Widget for Span {
-    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
-        if axis != self.dir.axis {
-            // A share can be hidden when the other axis has no room. Its
-            // cross-axis length then contributes nothing to the drawn answer.
-            return None;
-        }
-        let mut total = RequestedLen::from(Len::from_parts(
-            Rel::ZERO,
-            self.gap
-                .mul_int(self.children.len().saturating_sub(1) as i32),
-        ));
-        for child in &self.children {
-            let child = requests.widget(child, axis)?;
-            total = requests.sum(total, child);
-        }
-        Some(total)
-    }
-
     fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.with_requests(|painter, lens, values| self.layout(painter, lens, values))
-    }
-}
-
-impl Span {
-    fn layout(
-        &self,
-        painter: &mut Painter,
-        lens: &mut Vec<RequestedLen>,
-        values: &mut Vec<Px>,
-    ) -> Size {
         let axis = self.dir.axis;
-        // The row this span lays its children out along, as a length of the
+        // The room left from the cursor to the row's end, said without the
-        // rel base they are laid out against. Where it starts is nothing's
+        // row's length: a child measured in it does not make this drawing
-        // business -- a slot is a length from there -- so what this reads is
+        // depend on how long the row is.
-        // the length alone.
+        let room_from = |cursor: Len| match self.dir.sign {
-        let row = painter.region_len(axis);
+            Sign::Pos => Part::Inset {
-        self.collect(painter, row, lens, true);
+                lead: cursor,
+                trail: Len::ZERO,
+            },
+            Sign::Neg => Part::Inset {
+                lead: Len::ZERO,
+                trail: cursor,
+            },
+        };
+        // Across itself the child sits where its own alignment says, in the
+        // whole of the row: a span is what contains its children there, and
+        // nothing divides that axis.
+        let across = Place::Within(Part::All);
+        // A length for every child before their final slots are chosen: from
+        // a hint where one says, and from drawing otherwise. The frame passes
+        // through unchanged, so `rel(0.5)` is half the area this span was
+        // given whatever else is in it and wherever this child sits among
+        // them; what a drawn child is asked in is the room left from the
+        // cursor, because a text has to wrap at the width actually there.
+        // This is the one ask a drawn fixed child gets: its slot is its
+        // answer, and the drawing is moved there once the shares are known.
+        // A hinted child is asked once, in its slot.
+        let mut cursor = Len::rel_min();
+        let mut lens = Vec::with_capacity(self.children.len());
+        let mut measured = Vec::with_capacity(self.children.len());
+        for child in &self.children {
+            let size = match painter.size_hint(child, axis) {
+                Some(len) => {
+                    measured.push(None);
+                    len
+                }
+                None => {
+                    let room = Place::Within(room_from(cursor));
+                    let size = painter
+                        .widget_at(child, [None; 2], axis.pair(room, across))
+                        .size();
+                    measured.push(Some(size));
+                    size.axis(axis)
+                }
+            };
+            let len = size;
+            cursor.px += len.px + self.gap;
+            cursor.rel += len.rel;
+            lens.push(len);
+        }
+
         let gaps = self
             .gap
             .mul_int(self.children.len().saturating_sub(1) as i32);
-        let fixed = lens
+        let total = lens.iter().fold(
-            .iter()
-            .try_fold(Len::from_parts(Rel::ZERO, gaps), |sum, len| {
-                Some(sum + len.linear()?.without_leftover())
-            });
-        if let Some(fixed) = fixed
-            && lens.iter().any(|len| len.has_leftover())
-            && !painter.longer_than(row, fixed, axis)
-        {
-            // With no share to assign, intrinsic drawings keep the remaining
-            // offer, including overflow. Their answer is only moved into a slot.
-            self.collect(painter, row, lens, false);
-        }
-        let nonlinear = lens.iter().any(|len| len.linear().is_none());
-        if nonlinear {
-            painter.allocate(lens, row - Len::from_parts(Rel::ZERO, gaps), axis, values);
-        }
-        let allocated = nonlinear.then_some(&values);
-        let total = match &allocated {
-            Some(allocated) => LayoutLen {
-                px: allocated.iter().fold(gaps, |sum, len| sum + *len),
-                ..LayoutLen::ZERO
-            },
-            None => lens.iter().fold(
             LayoutLen {
                 px: gaps,
                 ..LayoutLen::ZERO
             },
-                |sum, len| sum + len.linear().unwrap(),
+            |sum, len| sum + *len,
-            ),
+        );
+
+        // The row: this span's own box as a length of the window, read only
+        // where a slot depends on it -- shares divide what is left of it,
+        // and a negative row counts from its end. Reading it pins the
+        // drawing to this length; a positive row of fixed children is not
+        // pinned and holds for any length its children do. Its start is
+        // nothing's business: a slot is a length from it.
+        let far = (total.leftover > Weight::ZERO || self.dir.sign == Sign::Neg)
+            .then(|| painter.extent_len(axis));
+        let along = |from: Len, to: Len| match self.dir.sign {
+            Sign::Pos => UiSpan::new(from, to),
+            Sign::Neg => {
+                let far = far.expect("a negative row reads its length");
+                UiSpan::new(far - to, far - from)
+            }
         };
-        let all_fixed = total.without_leftover();
+        // What is left for the shares to divide: the row less everything
-        let room = row - all_fixed;
+        // fixed, as a length of the frame rather than a number of pixels.
-        let any_leftover = total.leftover > Weight::ZERO;
+        // Nothing where there are no shares, and nothing reads it there.
-        let has_room = any_leftover && painter.longer_than(row, all_fixed, axis);
+        let room = far.map_or(Len::ZERO, |far| far - Len::from_parts(total.rel, total.px));
+        // Whether anything is left over is a question in pixels: `rel(0.5)`
+        // beside 300 px is full at 600 and overfull at 400. Asked of `room`
+        // itself, and answered back through the same expression, so the
+        // boundary is the drawing's own and not a second way of finding it:
+        // the three cases a rounded division needed -- the fixed parts
+        // growing slower than the box, faster, or exactly with it -- are the
+        // sign of `room.rel`, which `through` already reads. What the
+        // generated oracle checks is the consequence, since which children
+        // exist at all turns on this.
+        let mut shares = false;
+        if total.leftover > Weight::ZERO {
+            shares = painter.to_px(room, axis) > Px::ZERO;
+            let holds = match shares {
+                true => Holds::from(Px::STEP..=Px::MAX),
+                false => Holds::from(Px::MIN..=Px::ZERO),
+            };
+            painter.window_holds(axis, holds.through(room));
+        }
 
         // Across itself a span is as long as its longest child -- unless a
         // rule beside it gives that length outright, and then reading them
@@ -92,126 +117,94 @@ impl Span {
         let shrinks = !painter.has_exact_size(!axis);
         // What the fixed parts and the gaps before here take, which is a sum
         // of lengths and exact, and how much of the leftover weight is
-        // spoken for. Both ends of a slot are read from those two rather
+        // spoken for. A position is one from the other rather than a step
-        // than stepped from the last child: the share of the room is
+        // from the last child: the share of the room is rounded, and taking
-        // rounded, and taking each end from the one before it would carry
+        // each from the one before it would carry every rounding along the
-        // every rounding along the row.
+        // row.
-        let mut fixed = Len::ZERO;
+        let mut fixed = Len::rel_min();
         let mut taken = Weight::ZERO;
+        let mut start = Len::rel_min();
         let mut ortho = LayoutLen::ZERO;
-        // Nothing divides the room where no child asked for any of it, and a
+        for ((child, len), measured) in self.children.iter().zip(&lens).zip(&measured) {
-        // ratio of a whole of nothing has no answer.
+            let len = *len;
-        let reached = |fixed: Len, taken: Weight| match any_leftover {
-            false => fixed,
-            true => fixed + room.scale(Rel::ratio(taken, total.leftover)),
-        };
-        for (index, (child, request)) in self.children.iter().zip(lens.iter()).enumerate() {
-            let len = match &allocated {
-                Some(allocated) => LayoutLen {
-                    px: allocated[index],
-                    ..LayoutLen::ZERO
-                },
-                None => request.linear().unwrap(),
-            };
-            let shares = match &allocated {
-                Some(_) => request.has_leftover(),
-                None => len.leftover > Weight::ZERO && has_room,
-            };
             // A child asking for nothing but a part of what is left over,
             // when nothing is, is not drawn at all. One that also asked for
             // pixels or a fraction keeps those and overflows.
-            if (len.is_only_leftover() && !has_room)
+            if len.leftover > Weight::ZERO && len.px == Px::ZERO && len.rel == Rel::ZERO && !shares
-                || (allocated.is_some() && shares && len.px == Px::ZERO)
             {
                 painter.undraw(child);
                 fixed.px += self.gap;
                 continue;
             }
-            let from = reached(fixed, taken);
+            let from = start;
-            if shares {
+            if len.leftover > Weight::ZERO && shares {
                 taken += len.leftover;
             }
-            fixed += len.without_leftover();
+            fixed.px += len.px;
-            let to = reached(fixed, taken);
+            fixed.rel += len.rel;
+            start = shared(fixed, taken, total.leftover, room);
             // Along the row the span says where the child goes, and that slot
             // is the child's box outright rather than something to place an
             // answer inside again. A share is decided here and nowhere
-            // else: its slot narrows its rel base, and the child is asked in
+            // else: its slot narrows its frame, and the child is asked in
             // it, since a text wraps at the width it is actually given. A
             // fixed child's slot is its own answer, so a drawing made in the
             // room is put there as it is, and one not made yet is made here.
-            let slot = self.slot(row, from, to);
+            let slot = along(from, start);
-            let mut place = slot.shifted_desc().allocated().on_axis(axis);
+            let place = axis.pair(Place::Fill(Part::From(slot)), across);
-            if shares {
+            let mut narrow = [None; 2];
-                place = place.rel_base(axis, slot.len());
+            if len.leftover > Weight::ZERO && shares {
+                narrow[axis as usize] = Some(slot.len());
             }
-            let used = painter.place_at(child, place).len(!axis);
+            let used = match (measured, narrow[axis as usize]) {
+                (Some(size), None) => {
+                    painter.place_at(child, place);
+                    size.axis(!axis)
+                }
+                _ => painter.widget_at(child, narrow, place).len(!axis),
+            };
             if shrinks {
                 // Choosing between a fixed and a relative length from the
                 // span's own eventual width admits multiple fixed points.
-                // A scalable child therefore makes the span scalable too;
+                // A scalable child therefore makes Children scalable too;
                 // only fixed children are compared with one another.
-                if !used.is_px() {
+                if used.rel != Rel::ZERO || used.leftover != Weight::ZERO {
                     ortho = LayoutLen::LEFTOVER;
                 } else if ortho.leftover == Weight::ZERO {
                     ortho.px = ortho.px.max(used.px);
                 }
             }
             fixed.px += self.gap;
+            start = shared(fixed, taken, total.leftover, room);
         }
 
-        // Discovery carries nested requests to the allocating ancestor. The
+        // Carried whole rather than collapsed to one share: a span that sizes
-        // draw still returns an ordinary Size for callers measuring content.
+        // from its children does not resolve `leftover`, it passes the weight up,
+        // so nesting spans divides the same space rather than re-dividing a
+        // share of it. Four `leftover(1)` children under two spans under one span
+        // get a quarter each, which collapsing to `leftover(1)` per level does
+        // not give. Resolution happens at the nearest ancestor with a length,
+        // and the root always has one.
+        let along = total;
         let ortho = match shrinks {
             true => ortho,
             false => LayoutLen::rel(1.0),
         };
-        Size::from_axis(axis, total, ortho)
+        Size::from_axis(axis, along, ortho)
     }
 }
 
+/// Where a row has reached: everything fixed before this point, which is a
+/// sum and exact, plus the share of the room the weights so far are worth,
+/// which is one rounding wherever it is asked for.
+fn shared(fixed: Len, taken: Weight, weight: Weight, room: Len) -> Len {
+    if taken == Weight::ZERO {
+        return fixed;
+    }
+    fixed + room.scale(Rel::ratio(taken, weight))
+}
+
 impl Span {
-    fn collect(
-        &self,
-        painter: &mut Painter,
-        row: Len,
-        lens: &mut Vec<RequestedLen>,
-        discover: bool,
-    ) {
-        let axis = self.dir.axis;
-        let mut cursor = Len::ZERO;
-        lens.clear();
-        for child in &self.children {
-            let request = if discover {
-                painter.size_request(child, axis)
-            } else {
-                painter.size_hint(child, axis).map(Into::into)
-            };
-            let len = match request {
-                Some(len) => len,
-                None => {
-                    let room = self.slot(row, cursor, row).shifted_desc().on_axis(axis);
-                    let len = painter.widget_at(child, room).len(axis);
-                    painter.measured_request(child, axis, len)
-                }
-            };
-            cursor += painter.minimum_request(&len, axis);
-            cursor.px += self.gap;
-            lens.push(len);
-        }
-    }
-
-    /// The stretch of the row between two distances from where this span
-    /// starts laying children out, as a span of its own box. A negative
-    /// direction lays out from the far end, so the same two distances mirror
-    /// in a row `row` long.
-    fn slot(&self, row: Len, from: Len, to: Len) -> UiSpan {
-        match self.dir.sign {
-            Sign::Pos => from.to(to),
-            Sign::Neg => (row - to).to(row - from),
-        }
-    }
-
     pub fn empty(dir: Dir) -> Self {
         Self {
             children: Vec::new(),

src/widget/position/stack.rs

@@ -8,16 +8,6 @@ pub struct Stack {
 }
 
 impl Widget for Stack {
-    fn size_request(&self, requests: &mut SizeRequests, axis: Axis) -> Option<RequestedLen> {
-        match self.size {
-            StackSize::Default => Some(LayoutLen::LEFTOVER.into()),
-            StackSize::Child(i) => match self.children.get(i) {
-                Some(child) => requests.widget(child, axis),
-                None => Some(LayoutLen::LEFTOVER.into()),
-            },
-        }
-    }
-
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let sizing = match self.size {
             StackSize::Default => None,
@@ -32,7 +22,9 @@ impl Widget for Stack {
             // drawing belongs to the layer it was made on.
             Some((i, child)) => {
                 painter.child_layer_at(i);
-                painter.widget_at(child, PlaceDesc::WHOLE.fills()).size()
+                painter
+                    .widget_at(child, [None; 2], [Place::Fill(Part::All); 2])
+                    .size()
             }
             None => Size::LEFTOVER,
         };
@@ -41,11 +33,11 @@ impl Widget for Stack {
         // fraction under them is a fraction of it. A share leaves the axis
         // to whoever gave the stack its box. Where a child sits in a box
         // bigger than itself is its own business.
-        let place = PlaceDesc::from_axes(|axis| {
+        let place = [Axis::X, Axis::Y].map(|axis| {
-            let len = size[axis];
+            let len = size.axis(axis);
             match len.leftover == Weight::ZERO {
-                true => len.without_leftover().as_desc().fills(),
+                true => Place::Fill(Part::Sized(Len::from_parts(len.rel, len.px))),
-                false => PlaceDescAxis::WHOLE,
+                false => Place::Within(Part::All),
             }
         });
         for (i, child) in self.children.iter().enumerate() {
@@ -53,7 +45,7 @@ impl Widget for Stack {
                 continue;
             }
             painter.child_layer_at(i);
-            painter.widget_at(child, place);
+            painter.widget_at(child, [None; 2], place);
         }
         size
     }

src/widget/text/edit.rs

@@ -321,10 +321,12 @@ impl<'a> TextEditCtx<'a> {
         let old = (self.text.view.buf.text().to_string(), self.text.selection);
         let mut undo = false;
         let res = self.apply_event_inner(event, modifiers, &mut undo);
-        if undo && let Some((old, selection)) = self.text.history.pop() {
+        if undo {
+            if let Some((old, selection)) = self.text.history.pop() {
                 self.set(&old);
                 self.text.selection = selection;
                 self.clamp_selection_to_layout();
+            }
         } else if self.text.view.buf.text() != old.0 {
             self.text.history.push(old);
         }

src/widget/trait_fns.rs

@@ -19,8 +19,8 @@ widget_trait! {
         move |state| {
             let id = self.add(state);
             let widgets = &mut state.ui_mut().widgets;
-            for axis in Axis::BOTH {
+            for (axis, align) in [(Axis::X, align.x), (Axis::Y, align.y)] {
-                if let Some(align) = align[axis] {
+                if let Some(align) = align {
                     widgets.set_alignment(id, axis, align);
                 }
             }
@@ -59,70 +59,26 @@ widget_trait! {
         }
     }
 
-    fn width(self, len: impl Into<SizeRequest>) -> impl WidgetIdFn<Rsc, WL::Widget> {
+    fn width(self, len: impl Into<LayoutLen>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let len = len.into();
         move |state| {
             let id = self.add(state);
             state
                 .ui_mut()
                 .widgets
-                .set_size_rule(id, Axis::X, SizeRule::from(len));
+                .set_size_rule(id, Axis::X, SizeRule::Exact(len));
             id
         }
     }
 
-    /// Answers at least this wide, whatever it drew: a rule beside the
+    fn height(self, len: impl Into<LayoutLen>) -> impl WidgetIdFn<Rsc, WL::Widget> {
-    /// widget, so what a row gives it is at least this even where the widget
-    /// itself wanted less. The box it draws in is untouched -- for that, see
-    /// [`MaxSize`].
-    fn min_width(self, len: impl Into<Len>) -> impl WidgetIdFn<Rsc, WL::Widget> {
-        let len = len.into();
-        move |state| {
-            let id = self.add(state);
-            state.ui_mut().widgets.set_min_len(id, Axis::X, len);
-            id
-        }
-    }
-
-    fn min_height(self, len: impl Into<Len>) -> impl WidgetIdFn<Rsc, WL::Widget> {
-        let len = len.into();
-        move |state| {
-            let id = self.add(state);
-            state.ui_mut().widgets.set_min_len(id, Axis::Y, len);
-            id
-        }
-    }
-
-    /// Puts this in a [`MaxSize`]: it is asked in the shorter of the cap and
-    /// the box that widget was given, and is as long as it used, held to the
-    /// cap. A widget rather than a rule because the box is whoever asked's to
-    /// decide -- see [`MaxSize`].
-    fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
-        let len = len.into();
-        move |state| MaxSize {
-            inner: self.add_strong(state),
-            x: Some(len),
-            y: None,
-        }
-    }
-
-    fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
-        let len = len.into();
-        move |state| MaxSize {
-            inner: self.add_strong(state),
-            x: None,
-            y: Some(len),
-        }
-    }
-
-    fn height(self, len: impl Into<SizeRequest>) -> impl WidgetIdFn<Rsc, WL::Widget> {
         let len = len.into();
         move |state| {
             let id = self.add(state);
             state
                 .ui_mut()
                 .widgets
-                .set_size_rule(id, Axis::Y, SizeRule::from(len));
+                .set_size_rule(id, Axis::Y, SizeRule::Exact(len));
             id
         }
     }

src/widget/wrapper.rs

@@ -9,7 +9,6 @@ use std::marker::Unsize;
 ///
 /// Its child is optional so it can also be the swappable slot a tab bar
 /// needs, which is what it was written for.
-#[derive(Default)]
 pub struct Wrapper {
     pub inner: Option<StrongWidget>,
 }
@@ -27,7 +26,11 @@ impl Wrapper {
     pub fn new() -> Self {
         Self::default()
     }
-
+    pub fn empty() -> Self {
+        Self {
+            inner: Default::default(),
+        }
+    }
     pub fn set<W: ?Sized + Unsize<dyn Widget>>(&mut self, to: StrongWidget<W>) {
         self.inner = Some(to)
     }
@@ -39,3 +42,9 @@ impl Wrapper {
         self.inner.replace(to)
     }
 }
+
+impl Default for Wrapper {
+    fn default() -> Self {
+        Self::empty()
+    }
+}

tests/allocation_cost.rs

@@ -1,80 +0,0 @@
-use iris::{harness::Harness, prelude::*};
-use std::{
-    alloc::{GlobalAlloc, Layout, System},
-    cell::Cell,
-};
-
-struct Counting;
-thread_local! {
-    static COUNT: Cell<Option<usize>> = const { Cell::new(None) };
-}
-fn count() {
-    COUNT.with(|count| {
-        if let Some(n) = count.get() {
-            count.set(Some(n + 1));
-        }
-    });
-}
-// The wrapper preserves System's allocation and deallocation contracts;
-// observing calls here also counts allocations hidden inside layout helpers.
-unsafe impl GlobalAlloc for Counting {
-    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        count();
-        unsafe { System.alloc(layout) }
-    }
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        unsafe { System.dealloc(ptr, layout) }
-    }
-    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, size: usize) -> *mut u8 {
-        count();
-        unsafe { System.realloc(ptr, layout, size) }
-    }
-}
-#[global_allocator]
-static ALLOCATOR: Counting = Counting;
-
-#[test]
-fn unchanged_tree_reuses_layout_storage() {
-    for deferred in [false, true] {
-        let mut h = Harness::new((600, 200));
-        let mut children: Vec<StrongWidget> = Vec::new();
-        for _ in 0..8 {
-            let a = rect(Color::RED).add(&mut h.rsc);
-            if deferred {
-                h.rsc
-                    .widgets_mut()
-                    .set_size_rule(a, Axis::X, leftover(1).clamp(20, 80).into());
-            }
-            let row = (a, rect(Color::BLUE))
-                .span(Dir::RIGHT)
-                .add_strong(&mut h.rsc);
-            children.push(row);
-        }
-        let root = h.rsc.widgets_mut().add_strong(Span {
-            children,
-            dir: Dir::DOWN,
-            gap: Px::ZERO,
-        });
-        h.state.root = Some(root);
-        h.frame();
-        let ids: Vec<_> = h.render.active.keys().copied().collect();
-        for frame in 0..8 {
-            for &id in &ids {
-                h.rsc.widgets_mut().mark_for_redraw(id);
-            }
-            h.resize((600 + frame % 2, 200));
-            h.frame();
-        }
-        COUNT.set(Some(0));
-        for frame in 0..100 {
-            for &id in &ids {
-                h.rsc.widgets_mut().mark_for_redraw(id);
-            }
-            h.resize((600 + frame % 2, 200));
-            h.frame();
-        }
-        let allocations = COUNT.replace(None).unwrap();
-        println!("deferred={deferred}: {allocations} allocations over 100 resize frames");
-        assert_eq!(allocations, 0);
-    }
-}

tests/cases/deferred.rs

@@ -1,381 +0,0 @@
-use std::{cell::Cell, rc::Rc};
-
-use iris::harness::{Harness, assert_corners};
-use iris::prelude::*;
-
-struct Counted {
-    draws: Rc<Cell<usize>>,
-}
-
-impl Widget for Counted {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.draws.set(self.draws.get() + 1);
-        painter.px_size();
-        painter.primitive(RectPrimitive::color(Color::RED));
-        Size::LEFTOVER
-    }
-
-    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::LEFTOVER)
-    }
-}
-
-#[test]
-fn a_capped_share_returns_room_to_its_sibling() {
-    let mut h = Harness::new((300, 100));
-    let first = rect(Color::RED).max_width(80).add(&mut h.rsc);
-    let second = rect(Color::BLUE).add(&mut h.rsc);
-    h.set_root((first, second).span(Dir::RIGHT));
-    assert_corners!(h, first, (0, 0), (80, 100));
-    assert_corners!(h, second, (80, 0), (300, 100));
-    h.resize((100, 100));
-    h.frame();
-    assert_corners!(h, first, (0, 0), (50, 100));
-    assert_corners!(h, second, (50, 0), (100, 100));
-    h.resize((300, 100));
-    h.frame();
-    assert_corners!(h, first, (0, 0), (80, 100));
-    assert_corners!(h, second, (80, 0), (300, 100));
-}
-
-#[test]
-fn nested_shares_are_discovered_without_provisional_paint() {
-    let mut h = Harness::new((400, 100));
-    let draws = Rc::new(Cell::new(0));
-    let leaf = h.rsc.ui_mut().widgets.add_strong(Counted {
-        draws: draws.clone(),
-    });
-    let leaf_id = leaf.id();
-    let mut inner: StrongWidget = leaf;
-    for _ in 0..8 {
-        let sibling = rect(Color::BLUE).add_strong(&mut h.rsc);
-        inner = h.rsc.ui_mut().widgets.add_strong(Span {
-            children: vec![inner, sibling],
-            dir: Dir::RIGHT,
-            gap: Px::ZERO,
-        });
-    }
-    h.state.root = Some(inner);
-    h.frame();
-    assert_eq!(draws.get(), 1);
-    assert!(h.region(&leaf_id).is_some());
-    h.resize((800, 100));
-    h.frame();
-    assert_eq!(draws.get(), 2);
-}
-
-#[test]
-fn nested_bounds_are_resolved_in_the_outer_allocation() {
-    let mut h = Harness::new((300, 100));
-    let a = rect(Color::RED).max_width(40).add(&mut h.rsc);
-    let b = rect(Color::GREEN).max_width(60).add(&mut h.rsc);
-    let inner = (a, b).span(Dir::RIGHT).add(&mut h.rsc);
-    let tail = rect(Color::BLUE).add(&mut h.rsc);
-    h.set_root((inner, tail).span(Dir::RIGHT));
-    assert_corners!(h, a, (0, 0), (40, 100));
-    assert_corners!(h, b, (40, 0), (100, 100));
-    assert_corners!(h, tail, (100, 0), (300, 100));
-}
-
-#[test]
-fn request_edits_in_a_nested_child_reach_the_allocator() {
-    let mut h = Harness::new((300, 100));
-    let a = rect(Color::RED).max_width(80).add(&mut h.rsc);
-    let inner = (a,).span(Dir::RIGHT).add(&mut h.rsc);
-    let tail = rect(Color::BLUE).add(&mut h.rsc);
-    h.set_root((inner, tail).span(Dir::RIGHT));
-    h.rsc.ui_mut().widgets.get_mut(&a).unwrap().x = Some(Len::px(40.0));
-    h.frame();
-    assert_corners!(h, a, (0, 0), (40, 100));
-    assert_corners!(h, tail, (40, 0), (300, 100));
-}
-
-#[test]
-fn adding_a_bound_to_a_previously_unbounded_share_reallocates_the_row() {
-    let mut h = Harness::new((300, 100));
-    let a = rect(Color::RED).add(&mut h.rsc);
-    let b = rect(Color::BLUE).add(&mut h.rsc);
-    h.set_root((a, b).span(Dir::RIGHT));
-    h.resize((400, 100));
-    h.frame();
-    h.rsc
-        .widgets_mut()
-        .set_size_rule(a, Axis::X, SizeRule::Max(Len::px(80.0)));
-    h.frame();
-    assert_corners!(h, a, (0, 0), (80, 100));
-    assert_corners!(h, b, (80, 0), (400, 100));
-}
-
-#[test]
-fn a_deferred_comparison_can_compare_two_different_weights() {
-    let a = SizeRequest::from(leftover(1.0) + px(30.0)).min(leftover(2.0));
-    let b = SizeRequest::from(leftover(1.0)).clamp(px(20.0), px(100.0));
-    let mut h = Harness::new((60, 100));
-    let a = rect(Color::RED).width(a).add(&mut h.rsc);
-    let b = rect(Color::BLUE).width(b).add(&mut h.rsc);
-    h.set_root((a, b).span(Dir::RIGHT));
-    assert_corners!(h, a, (0, 0), (40, 100));
-    assert_corners!(h, b, (40, 0), (60, 100));
-    h.resize((300, 100));
-    h.frame();
-    assert_corners!(h, a, (0, 0), (200, 100));
-    assert_corners!(h, b, (200, 0), (300, 100));
-}
-
-#[test]
-fn a_length_expression_is_resolved_before_wrapping_text() {
-    let mut h = Harness::new((300, 500));
-    let text = wtext("one two three four five six seven eight nine ten")
-        .size(16)
-        .wrap(true)
-        .width(leftover(1).clamp(40, 80))
-        .add(&mut h.rsc);
-    let other = rect(Color::BLUE).add(&mut h.rsc);
-    h.set_root((text, other).span(Dir::RIGHT));
-    let box_ = h.region(&text).unwrap();
-    assert_eq!(box_.top_left.x, Px::ZERO);
-    assert_eq!(box_.bot_right.x, Px::from_int(80));
-    assert!(box_.bot_right.y - box_.top_left.y > Px::from_int(30));
-    assert_corners!(h, other, (80, 0), (300, 500));
-}
-
-#[test]
-fn relative_bounds_keep_the_allocators_base() {
-    let mut h = Harness::new((300, 100));
-    let head = rect(Color::BLUE).width(30).add(&mut h.rsc);
-    let bounded = rect(Color::RED)
-        .width(leftover(1).min(rel(0.25)))
-        .add(&mut h.rsc);
-    let tail = rect(Color::GREEN).add(&mut h.rsc);
-    h.set_root((head, bounded, tail).span(Dir::RIGHT));
-    assert_corners!(h, bounded, (30, 0), (105, 100));
-    assert_corners!(h, tail, (105, 0), (300, 100));
-    h.resize((400, 100));
-    h.frame();
-    assert_corners!(h, bounded, (30, 0), (130, 100));
-    assert_corners!(h, tail, (130, 0), (400, 100));
-}
-
-#[test]
-fn the_root_resolves_a_deferred_request_again_after_resize() {
-    let mut h = Harness::new((300, 100));
-    let bounded = rect(Color::RED)
-        .width(leftover(1).min(rel(0.25)))
-        .add(&mut h.rsc);
-    h.set_root(bounded);
-    assert_corners!(h, bounded, (112.5, 0), (187.5, 100));
-    h.resize((400, 100));
-    h.frame();
-    assert_corners!(h, bounded, (150, 0), (250, 100));
-}
-
-#[test]
-fn filling_a_stack_does_not_mean_its_sizing_child_was_already_allocated() {
-    let mut h = Harness::new((300, 100));
-    let child = rect(Color::RED).width(leftover(1).min(80)).add(&mut h.rsc);
-    let overlay = rect(Color::BLUE).add(&mut h.rsc);
-    let children: Vec<StrongWidget> =
-        vec![child.add_strong(&mut h.rsc), overlay.add_strong(&mut h.rsc)];
-    h.set_root(Stack {
-        children,
-        size: StackSize::Child(0),
-    });
-    assert_corners!(h, child, (110, 0), (190, 100));
-    assert_corners!(h, overlay, (110, 0), (190, 100));
-}
-
-struct Unhinted;
-impl Widget for Unhinted {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.px_size();
-        painter.primitive(RectPrimitive::color(Color::RED));
-        Size::LEFTOVER
-    }
-}
-
-#[test]
-fn bounds_also_apply_to_shares_discovered_by_drawing() {
-    let mut h = Harness::new((300, 100));
-    let a = h.rsc.widgets_mut().add_strong(Unhinted);
-    h.rsc
-        .widgets_mut()
-        .set_size_rule(a.id(), Axis::X, SizeRule::Max(Len::px(80.0)));
-    let id = a.id();
-    let b = rect(Color::BLUE).add_strong(&mut h.rsc);
-    let b_id = b.id();
-    h.state.root = Some(h.rsc.widgets_mut().add_strong(Span {
-        children: vec![a, b],
-        dir: Dir::RIGHT,
-        gap: Px::ZERO,
-    }));
-    h.frame();
-    assert_corners!(h, id, (0, 0), (80, 100));
-    assert_corners!(h, b_id, (80, 0), (300, 100));
-    h.resize((100, 100));
-    h.frame();
-    assert_corners!(h, id, (0, 0), (50, 100));
-    assert_corners!(h, b_id, (50, 0), (100, 100));
-}
-
-#[test]
-fn comparisons_with_a_known_order_remain_plain_lengths() {
-    assert_eq!(leftover(2).max(leftover(5)), SizeRequest::from(leftover(5)));
-    assert_eq!(leftover(2).min(leftover(5)), SizeRequest::from(leftover(2)));
-    assert_eq!(
-        (px(10) + rel(0.5)).max(px(30) + rel(0.5)),
-        SizeRequest::from(px(30) + rel(0.5))
-    );
-    assert_eq!(LayoutLen::px(10).clamp(20, 80), SizeRequest::from(20));
-}
-
-#[test]
-fn a_measured_nested_share_keeps_its_comparison_for_the_outer_span() {
-    let mut h = Harness::new((300, 100));
-    let a = h.rsc.widgets_mut().add_strong(Unhinted);
-    let a_id = a.id();
-    h.rsc
-        .widgets_mut()
-        .set_size_rule(a_id, Axis::X, SizeRule::Max(Len::px(80.0)));
-    let b = rect(Color::BLUE).add_strong(&mut h.rsc);
-    let b_id = b.id();
-    let inner = h.rsc.widgets_mut().add_strong(Span {
-        children: vec![a, b],
-        dir: Dir::RIGHT,
-        gap: Px::ZERO,
-    });
-    let c = rect(Color::GREEN).add_strong(&mut h.rsc);
-    let c_id = c.id();
-    h.state.root = Some(h.rsc.widgets_mut().add_strong(Span {
-        children: vec![inner, c],
-        dir: Dir::RIGHT,
-        gap: Px::ZERO,
-    }));
-    h.frame();
-    assert_corners!(h, a_id, (0, 0), (80, 100));
-    assert_corners!(h, b_id, (80, 0), (190, 100));
-    assert_corners!(h, c_id, (190, 0), (300, 100));
-    h.rsc
-        .widgets_mut()
-        .mark_for_redraw(h.state.root.as_ref().unwrap().id());
-    h.frame();
-    assert_corners!(h, c_id, (190, 0), (300, 100));
-}
-
-struct Natural;
-impl Widget for Natural {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.primitive(RectPrimitive::color(Color::RED));
-        Size::from_axis(Axis::X, LayoutLen::px(64), LayoutLen::px(64))
-    }
-    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::px(64))
-    }
-}
-
-#[test]
-fn relative_bounds_on_a_hinted_child_track_the_offer_before_its_declared_size() {
-    fn tree(h: &mut Harness) -> WidgetId {
-        let natural = h.rsc.widgets_mut().add_strong(Natural);
-        let id = natural.id();
-        h.rsc
-            .widgets_mut()
-            .set_size_rule(id, Axis::X, SizeRule::Max(Len::rel(0.75)));
-        h.rsc.widgets_mut().set_size_rule(
-            id,
-            Axis::Y,
-            SizeRule::Clamp {
-                min: Len::rel(0.25),
-                max: Len::rel(0.75),
-            },
-        );
-        let inner = h.rsc.widgets_mut().add_strong(Stack {
-            children: vec![natural],
-            size: StackSize::Child(0),
-        });
-        let inner_id = inner.id();
-        let fill = rect(Color::BLUE).add_strong(&mut h.rsc);
-        let overlay = h.rsc.widgets_mut().add_strong(Stack {
-            children: vec![fill, inner],
-            size: StackSize::Child(0),
-        });
-        let share = rect(Color::GREEN).add_strong(&mut h.rsc);
-        let bounded = rect(Color::GREEN).add_strong(&mut h.rsc);
-        h.rsc.widgets_mut().set_size_rule(
-            bounded.id(),
-            Axis::X,
-            SizeRule::Clamp {
-                min: Len::rel(0.25),
-                max: Len::rel(0.75),
-            },
-        );
-        let fixed = wtext("one line, overflowing whatever it is given")
-            .size(16)
-            .wrap(false)
-            .add_strong(&mut h.rsc);
-        h.state.root = Some(h.rsc.widgets_mut().add_strong(Span {
-            children: vec![share, bounded, fixed, overlay],
-            dir: Dir::LEFT,
-            gap: Px::from_int(8),
-        }));
-        h.rsc.widgets_mut().set_size_rule(
-            h.state.root.as_ref().unwrap().id(),
-            Axis::Y,
-            LayoutLen::rel(1).into(),
-        );
-        h.frame();
-        inner_id
-    }
-    let mut warm = Harness::new((1920, 1200));
-    let a = tree(&mut warm);
-    warm.resize((640, 900));
-    warm.frame();
-    let mut cold = Harness::new((640, 900));
-    let b = tree(&mut cold);
-    assert_eq!(warm.region(&a), cold.region(&b));
-}
-
-#[test]
-fn a_bound_can_extend_an_explicit_share_request() {
-    let mut h = Harness::new((300, 100));
-    let a = rect(Color::RED)
-        .width(leftover(1))
-        .min_width(100)
-        .add(&mut h.rsc);
-    let b = rect(Color::BLUE).add(&mut h.rsc);
-    h.set_root((a, b).span(Dir::RIGHT));
-    assert_corners!(h, a, (0, 0), (150, 100));
-    h.resize((120, 100));
-    h.frame();
-    assert_corners!(h, a, (0, 0), (100, 100));
-    assert_corners!(h, b, (100, 0), (120, 100));
-}
-
-#[test]
-fn moving_scroll_content_preserves_its_resolved_expression_size() {
-    let mut h = Harness::new((300, 300));
-    let leaf = rect(Color::BLUE).add_strong(&mut h.rsc);
-    let leaf_id = leaf.id();
-    let content = h.rsc.widgets_mut().add_strong(Stack {
-        children: vec![leaf],
-        size: StackSize::Child(0),
-    });
-    let content_id = content.id();
-    h.rsc
-        .widgets_mut()
-        .set_size_rule(content_id, Axis::Y, leftover(1).min(120).into());
-    let scroll = h
-        .rsc
-        .widgets_mut()
-        .add_strong(Scroll::new(content, Axis::Y));
-    let scroll_id = scroll.id();
-    h.state.root = Some(scroll);
-    for _ in 0..3 {
-        h.rsc.widgets_mut().mark_for_redraw(scroll_id);
-        h.frame();
-        assert_corners!(h, content_id, (0, 90), (300, 210));
-        assert_corners!(h, leaf_id, (0, 90), (300, 210));
-    }
-    h.resize((300, 600));
-    h.frame();
-    assert_corners!(h, leaf_id, (0, 240), (300, 360));
-}

tests/cases/determinism.rs

@@ -22,17 +22,17 @@ struct BranchesOnMeasurement {
 impl Widget for BranchesOnMeasurement {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let cut = Len::from_parts(Rel::ZERO, Px::from_int(40));
-        let top = UiSpan::new(Len::ZERO, cut).shifted_desc();
+        let top = Place::Within(Part::From(UiSpan::new(Len::ZERO, cut)));
         let measured = painter
-            .widget_at(&self.probe, top.on_axis(Axis::Y))
+            .widget_at(&self.probe, [None; 2], [Place::Within(Part::All), top])
             .len(Axis::X);
         let px = painter.to_px(measured.apply_leftover(), Axis::X);
 
-        let below = UiSpan::new(cut, painter.region_len(Axis::Y)).shifted_desc();
+        let below = Place::Within(Part::From(UiSpan::new(cut, painter.extent_len(Axis::Y))));
-        let place = below.on_axis(Axis::Y);
+        let place = [Place::Within(Part::All), below];
         match px > Px::from_f32(self.threshold) {
-            true => painter.widget_at(&self.wide, place),
+            true => painter.widget_at(&self.wide, [None; 2], place),
-            false => painter.widget_at(&self.narrow, place),
+            false => painter.widget_at(&self.narrow, [None; 2], place),
         };
         Size::LEFTOVER
     }
@@ -69,8 +69,8 @@ fn a_branch_taken_on_a_measurement_holds_across_repaints() {
         assert_ne!(first, (false, false), "threshold {threshold}: neither drew");
 
         for frame in 0..4 {
-            h.rsc.widgets_mut().mark_for_redraw(wide);
+            h.rsc.widgets_mut().get_dyn_mut(wide);
-            h.rsc.widgets_mut().mark_for_redraw(narrow);
+            h.rsc.widgets_mut().get_dyn_mut(narrow);
             h.frame();
             assert_eq!(
                 taken(&h, wide, narrow),
@@ -88,7 +88,7 @@ fn a_branch_taken_on_a_measurement_is_the_one_a_cold_start_takes() {
         let (wide, narrow) = plant(&mut warm, threshold);
         warm.resize((640, 480));
         warm.frame();
-        warm.rsc.widgets_mut().mark_for_redraw(wide);
+        warm.rsc.widgets_mut().get_dyn_mut(wide);
         warm.frame();
 
         let mut cold = Harness::new((640, 480));

tests/cases/idempotence.rs

@@ -18,7 +18,7 @@ fn a_wrapping_text_in_a_span_settles_on_one_width() {
         let r = h.region(&t.id()).unwrap();
         widths.push(r.bot_right.x - r.top_left.x);
         // Redrawing it changes nothing about the state, so nothing may move.
-        h.rsc.widgets_mut().mark_for_redraw(t.id());
+        h.rsc.widgets_mut().get_dyn_mut(t.id());
         h.frame();
     }
     println!("widths over six frames: {widths:?}");

tests/cases/layout.rs

@@ -1,7 +1,5 @@
 //! Where a frame puts things, with no window to put them in.
 
-use std::{cell::Cell, rc::Rc};
-
 use iris::harness::{Harness, assert_corners};
 use iris::prelude::*;
 
@@ -110,7 +108,7 @@ const PARAGRAPH: &str = "Wrapping shapes one source into as many lines as the bo
 /// the icon's width, while a wrapping text beside it is asked in the room
 /// left, 900 - 24 - 32, and wraps there.
 #[test]
-fn padding_keeps_the_rel_base_distinct_from_the_room_left_in_a_row() {
+fn padding_keeps_the_frame_distinct_from_the_room_left_in_a_row() {
     let mut h = Harness::new((900, 200));
     let icon = rect(Color::RED).width(24).add(&mut h.rsc);
     let fill = rect(Color::GREEN).width(rel(1.0)).add(&mut h.rsc);
@@ -126,8 +124,8 @@ fn padding_keeps_the_rel_base_distinct_from_the_room_left_in_a_row() {
     h.set_root((icon, padded).span(Dir::RIGHT).width(rel(1.0)));
     let active = &h.render.active[&text.id()];
     let window = h.render.output_size().x;
-    let asked = active.region.x.len().to_px(window);
+    let asked = active.part.x.len().to_px(window);
-    assert_eq!(active.rel_base.x.to_px(window), Px::from_int(868));
+    assert_eq!(active.frame.x.to_px(window), Px::from_int(868));
     assert_eq!(asked, Px::from_int(844));
 }
 
@@ -157,7 +155,7 @@ fn a_share_inside_padding_fills_the_slot_it_was_given() {
 /// The same padding in a share instead: the slot is 450, so both the
 /// fraction and the wrap are the slot less the padding, and the two agree.
 #[test]
-fn padding_narrows_both_rel_base_and_box_inside_a_share() {
+fn padding_narrows_both_frame_and_box_inside_a_share() {
     let mut h = Harness::new((900, 200));
     let fill = rect(Color::GREEN).width(rel(1.0)).add(&mut h.rsc);
     let padded = fill.pad(16).width(leftover(1)).add(&mut h.rsc);
@@ -172,8 +170,8 @@ fn padding_narrows_both_rel_base_and_box_inside_a_share() {
     h.set_root((padded, other).span(Dir::RIGHT).width(rel(1.0)));
     let active = &h.render.active[&text.id()];
     let window = h.render.output_size().x;
-    assert_eq!(active.rel_base.x.to_px(window), Px::from_int(418));
+    assert_eq!(active.frame.x.to_px(window), Px::from_int(418));
-    assert_eq!(active.region.x.len().to_px(window), Px::from_int(418));
+    assert_eq!(active.part.x.len().to_px(window), Px::from_int(418));
 }
 
 #[test]
@@ -221,134 +219,6 @@ fn an_empty_widget_takes_a_share_of_a_span() {
     assert_corners!(h, right, (300, 0), (400, 200));
 }
 
-/// A widget with a natural pixel size, like an image, which records the box
-/// it was asked in so a test can see which length decided it.
-struct NaturalSize {
-    len: f32,
-    asked: Rc<Cell<f32>>,
-}
-
-impl Widget for NaturalSize {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.asked.set(painter.px_len(Axis::X).to_f32());
-        Size::px(Vec2::new(self.len, self.len))
-    }
-
-    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::px(self.len))
-    }
-}
-
-/// A rule wins over what the widget says about itself, and a share is a rule:
-/// it is a length only to whoever divides one, and nobody here does, so the
-/// widget is asked in the whole box rather than in the size it asked for.
-#[test]
-fn a_share_rule_beats_the_widgets_own_pixel_size() {
-    let mut h = Harness::new((400, 200));
-    let asked = Rc::new(Cell::new(0.0));
-    let natural = NaturalSize {
-        len: 50.0,
-        asked: asked.clone(),
-    }
-    .add(&mut h.rsc);
-    h.set_root(natural.wrapper());
-    assert_eq!(asked.get(), 50.0, "its hint gives it its own size");
-
-    h.set_len(natural, Axis::X, LayoutLen::LEFTOVER);
-    h.frame();
-
-    assert_eq!(asked.get(), 400.0, "the share is all of the box");
-}
-
-/// Every box a widget is given comes of one ask, and the window is one of
-/// them: the root is asked in it exactly as a child is asked in its parent's
-/// box, so a rule of its own reads the same way at either place.
-#[derive(Clone, Copy, Debug)]
-enum Asked {
-    Root,
-    Wrapped,
-    InASpan,
-}
-
-impl Asked {
-    const ALL: [Self; 3] = [Self::Root, Self::Wrapped, Self::InASpan];
-
-    /// The width the probe is given under this parent, in a 400 px window.
-    fn width(&self, rule: LayoutLen) -> Px {
-        let mut h = Harness::new((400, 200));
-        let probe = rect(Color::RED).add(&mut h.rsc);
-        h.set_len(probe, Axis::X, rule);
-        match self {
-            Self::Root => h.set_root(probe),
-            Self::Wrapped => h.set_root(probe.wrapper()),
-            Self::InASpan => h.set_root((probe,).span(Dir::RIGHT)),
-        }
-        h.region(&probe).unwrap().size().x
-    }
-}
-
-/// A share with pixels or a fraction beside it is the longer of the two: it
-/// fills what they leave of the box and overflows the box where they are
-/// longer than it. A parent that divides nothing gives the same length as a
-/// span with one child, because in both there is nobody else to divide with --
-/// and so does the window, which divides nothing either.
-#[test]
-fn a_share_is_a_minimum_wherever_nothing_divides_it() {
-    for (rule, want) in [
-        (LayoutLen::LEFTOVER, 400),
-        (LayoutLen::px(50.0) + LayoutLen::LEFTOVER, 400),
-        (LayoutLen::px(500.0) + LayoutLen::LEFTOVER, 500),
-        (LayoutLen::rel(0.5) + LayoutLen::LEFTOVER, 400),
-        (LayoutLen::rel(2.0) + LayoutLen::LEFTOVER, 800),
-        (LayoutLen::px(500.0), 500),
-    ] {
-        let want = Px::from_int(want);
-        for asked in Asked::ALL {
-            assert_eq!(asked.width(rule), want, "{rule:?} asked {asked:?}");
-        }
-    }
-}
-
-/// Which of the two is longer is a question in pixels, so the box is decided
-/// again wherever the answer can change: a window that crosses the length the
-/// pixels ask for, and the rule itself crossing it while the window holds
-/// still. The first is a range the drawing holds for; the second cannot be
-/// seen in what the widget declares, since a share declares nothing either
-/// way, so it reaches the parent as a length only the parent can resolve.
-#[test]
-fn a_share_past_the_box_is_decided_again_on_either_side_of_the_crossing() {
-    // At the root as well as under a parent: the comparison is the same one,
-    // and nothing above the root will make it again on its behalf, so the
-    // range it holds for is the root's own.
-    for wrapped in [false, true] {
-        let mut h = Harness::new((400, 200));
-        let probe = rect(Color::RED).add(&mut h.rsc);
-        h.set_len(probe, Axis::X, LayoutLen::px(500.0) + LayoutLen::LEFTOVER);
-        match wrapped {
-            true => h.set_root(probe.wrapper()),
-            false => h.set_root(probe),
-        }
-        let width = |h: &Harness| h.region(&probe).unwrap().size().x;
-        assert_eq!(width(&h), Px::from_int(500), "wrapped: {wrapped}");
-
-        h.resize((900, 200));
-        h.frame();
-        assert_eq!(width(&h), Px::from_int(900), "wrapped: {wrapped}");
-
-        h.resize((400, 200));
-        h.frame();
-        assert_eq!(width(&h), Px::from_int(500), "wrapped: {wrapped}");
-
-        h.set_len(probe, Axis::X, LayoutLen::px(50.0) + LayoutLen::LEFTOVER);
-        h.frame();
-        assert_eq!(width(&h), Px::from_int(400), "wrapped: {wrapped}");
-
-        h.set_len(probe, Axis::X, LayoutLen::px(500.0) + LayoutLen::LEFTOVER);
-        h.frame();
-        assert_eq!(width(&h), Px::from_int(500), "wrapped: {wrapped}");
-    }
-}
-
 #[test]
 fn a_child_drawn_twice_moves_once() {
     let mut h = Harness::new((400, 200));
@@ -630,11 +500,11 @@ fn a_row_of_equal_shares_fills_it_exactly() {
 /// a step of. Kept in step with `snap_floor` in `prelude.wgsl`.
 fn drawn_edges(h: &Harness, id: WidgetId, axis: Axis) -> (f32, f32) {
     let active = &h.render.active[&id];
-    let region = h.render.moves.resolve(active.move_idx, active.placement);
+    let region = h.render.moves.resolve(active.move_idx, active.extent);
-    let dim = h.size()[axis];
+    let dim = h.size().axis(axis);
     let snap = |v: f32| (v + Px::STEP.to_f32() * 0.5).floor();
     let edge = |s: Len| snap(s.rel.to_f32() * dim + s.px.to_f32());
-    let span = region[axis];
+    let span = region.axis(axis);
     (edge(span.start), edge(span.end))
 }
 
@@ -756,7 +626,7 @@ fn only_a_pure_leftover_child_disappears_when_nothing_is_left() {
     let mut h = Harness::new((100, 20));
     let fixed = rect(Color::RED).width(100).add(&mut h.rsc);
     let mixed = rect(Color::BLUE)
-        .width(LayoutLen::px(20.0) + LayoutLen::LEFTOVER)
+        .width(LayoutLen::px(20) + LayoutLen::LEFTOVER)
         .add(&mut h.rsc);
     h.set_root((fixed, mixed).span(Dir::RIGHT));
 
@@ -951,168 +821,3 @@ fn a_root_with_a_fraction_rule_is_that_fraction_of_the_window() {
     h.set_root(root);
     assert_eq!(h.region(&root).unwrap().size().x, Px::from_int(450));
 }
-
-#[test]
-fn a_collapsed_share_keeps_the_gaps_before_the_next_slot() {
-    for dir in [Dir::RIGHT, Dir::LEFT, Dir::DOWN, Dir::UP] {
-        for collapsed in [1, 2] {
-            let mut h = Harness::new((400, 400));
-            let head = rect(Color::RED).add(&mut h.rsc);
-            h.set_len(head, dir.axis, 200);
-            let tail = rect(Color::BLUE).add(&mut h.rsc);
-            let tail_len = 200 - 10 * (collapsed + 1);
-            h.set_len(tail, dir.axis, tail_len);
-            let mut children: Vec<StrongWidget> = vec![head.add_strong(&mut h.rsc)];
-            let mut shares = Vec::new();
-            for _ in 0..collapsed {
-                let share = rect(Color::GREEN).add(&mut h.rsc);
-                shares.push(share);
-                children.push(share.add_strong(&mut h.rsc));
-            }
-            children.push(tail.add_strong(&mut h.rsc));
-            h.set_root(Span {
-                children,
-                dir,
-                gap: Px::from_int(10),
-            });
-            for share in shares {
-                assert!(h.region(&share).is_none());
-            }
-            let region = h.region(&tail).unwrap();
-            let (from, to) = match dir.sign {
-                Sign::Pos => (400 - tail_len, 400),
-                Sign::Neg => (0, tail_len),
-            };
-            assert_eq!(region.top_left[dir.axis], Px::from_int(from));
-            assert_eq!(region.bot_right[dir.axis], Px::from_int(to));
-        }
-    }
-}
-
-/// The root is asked the way any child is, so what it says about itself is
-/// read there too: a root that opted into a region node gets one, where the
-/// path it used to have ignored the flag.
-#[test]
-fn a_region_node_root_is_a_region_node() {
-    let mut h = Harness::new((400, 200));
-    let probe = rect(Color::RED).add(&mut h.rsc);
-    let root = (probe,).span(Dir::RIGHT).region_node().add(&mut h.rsc);
-    h.set_root(root);
-    assert_eq!(h.region(&probe).unwrap().size().x, Px::from_int(400));
-
-    h.resize((900, 200));
-    h.frame();
-    assert_eq!(h.region(&probe).unwrap().size().x, Px::from_int(900));
-}
-
-/// A bound is a rule about what a widget answers: it holds the length that
-/// reaches whoever asked and leaves the box alone. Here the content is 400
-/// wide in a 250 window, so a cap cuts what the row reports and a floor
-/// raises it, while the rects inside stay where the 250 box put them.
-#[test]
-fn a_bound_holds_what_a_widget_answers() {
-    let row = |rule: SizeRule| {
-        let mut h = Harness::new((250, 200));
-        let left = rect(Color::RED).width(200).add(&mut h.rsc);
-        let right = rect(Color::BLUE).width(200).add(&mut h.rsc);
-        let row = (left, right).span(Dir::RIGHT).add(&mut h.rsc);
-        h.rsc.widgets_mut().set_size_rule(row, Axis::X, rule);
-        h.set_root(row);
-        (
-            h.region(&row).unwrap().size().x,
-            h.region(&left).unwrap().size().x,
-        )
-    };
-    let (capped, left) = row(SizeRule::Max(Len::px(300.0)));
-    assert_eq!(capped, Px::from_int(300), "the cap, not the 400 drawn");
-    assert_eq!(left, Px::from_int(200), "the box the children were given");
-
-    let (floored, _) = row(SizeRule::Min(Len::px(600.0)));
-    assert_eq!(floored, Px::from_int(600), "the floor, not the 400 drawn");
-
-    let (free, _) = row(SizeRule::Free);
-    assert_eq!(free, Px::from_int(400), "what it drew");
-}
-
-/// A cap on the box is `MaxSize`, which asks its child in the shorter of the
-/// cap and its own box. That is the box a text wraps at and a scroll takes
-/// its viewport from, so it cannot be had by holding the answer.
-#[test]
-fn a_cap_widget_asks_its_child_in_the_shorter_box() {
-    let mut h = Harness::new((400, 200));
-    // A fraction of its box, so it says what box it was asked in.
-    let fills = rect(Color::RED).width(rel(1.0)).add(&mut h.rsc);
-    let capped = fills.max_width(300).add(&mut h.rsc);
-    h.set_root(capped);
-
-    assert_eq!(h.region(&fills).unwrap().size().x, Px::from_int(300));
-    assert_eq!(
-        h.region(&capped).unwrap().size().x,
-        Px::from_int(300),
-        "as long as its child used"
-    );
-
-    // A child that asked for a share takes the box the cap allows, and the
-    // share itself passes up: whoever divides one is this widget's parent.
-    let mut h = Harness::new((400, 200));
-    let share = rect(Color::RED).add(&mut h.rsc);
-    let capped = share.max_width(300).add(&mut h.rsc);
-    h.set_root(capped);
-
-    assert_eq!(h.region(&share).unwrap().size().x, Px::from_int(300));
-    assert_eq!(h.region(&capped).unwrap().size().x, Px::from_int(400));
-}
-
-/// Which of the cap and the box is shorter is a question in pixels, so it is
-/// asked again wherever the answer can change -- and the widget asking it is
-/// drawn again whenever its own box is, which is what keeps the two in step.
-#[test]
-fn a_cap_widget_is_decided_again_on_either_side_of_the_crossing() {
-    let mut h = Harness::new((400, 200));
-    let probe = rect(Color::RED).add(&mut h.rsc);
-    h.set_root(probe.max_width(300));
-    let width = |h: &Harness| h.region(&probe).unwrap().size().x;
-    assert_eq!(width(&h), Px::from_int(300));
-
-    h.resize((250, 200));
-    h.frame();
-    assert_eq!(
-        width(&h),
-        Px::from_int(250),
-        "its box, which is under the cap"
-    );
-
-    h.resize((400, 200));
-    h.frame();
-    assert_eq!(width(&h), Px::from_int(300));
-}
-
-/// A fraction in a cap is a fraction of the box the widget capping it was
-/// given, which is the box a declared length of its own would be a fraction
-/// of -- not of the window, and not of what the cap itself decided.
-#[test]
-fn a_cap_is_a_fraction_of_the_box_it_was_given() {
-    let mut h = Harness::new((400, 200));
-    let probe = rect(Color::RED).add(&mut h.rsc);
-    h.set_root(probe.max_width(Len::rel(0.5)).pad(Padding::uniform(50)));
-
-    // Half of the 300 left by the padding, not half of the window.
-    assert_eq!(h.region(&probe).unwrap().size().x, Px::from_int(150));
-}
-
-/// A cap is a promise about the length as well as the box: a widget whose
-/// content is longer than the box it was given reports what it drew, and the
-/// cap holds that down even though it never decided the box.
-#[test]
-fn a_cap_holds_an_answer_that_overflowed_its_box() {
-    let mut h = Harness::new((250, 200));
-    let left = rect(Color::RED).width(200).add(&mut h.rsc);
-    let right = rect(Color::BLUE).width(200).add(&mut h.rsc);
-    let row = (left, right).span(Dir::RIGHT).add(&mut h.rsc);
-    h.rsc.widgets_mut().set_max_len(row, Axis::X, 300.into());
-    h.set_root(row);
-
-    // The box is the 250 window, which the cap of 300 leaves alone, and the
-    // row draws 400 of it. Its answer is the cap, and the window centres it.
-    assert_corners!(h, row, (-25, 0), (275, 200));
-}

tests/cases/plan.rs

@@ -5,9 +5,7 @@
 //! and the oracle another. And reducing a plan has to end, or a shrinker
 //! searching for the smallest counterexample never returns.
 
-use iris::harness::Harness;
+use iris::random::{Edits, Kind, Plan, Rng, SpanEdit, plan};
-use iris::prelude::*;
-use iris::random::{Edits, Kind, Plan, Rng, SpanEdit, grow, plan};
 use std::collections::HashMap;
 
 fn some_edits(seed: u64, of: &Plan) -> Edits {
@@ -27,27 +25,11 @@ fn some_edits(seed: u64, of: &Plan) -> Edits {
     Edits {
         sizes: pick(sized, &mut rng)
             .into_iter()
-            .map(|i| {
+            .map(|i| (i, [Some(LayoutLen::LEFTOVER), None]))
-                (
-                    i,
-                    SizeRules {
-                        x: SizeRule::Exact(LayoutLen::LEFTOVER),
-                        y: SizeRule::Free,
-                    },
-                )
-            })
             .collect(),
         aligns: pick(aligned, &mut rng)
             .into_iter()
-            .map(|i| {
+            .map(|i| (i, [Some(AxisAlign::POS), None]))
-                (
-                    i,
-                    Align {
-                        x: Some(AxisAlign::POS),
-                        y: None,
-                    },
-                )
-            })
             .collect(),
         nodes: pick(nodes, &mut rng)
             .into_iter()
@@ -69,6 +51,8 @@ fn some_edits(seed: u64, of: &Plan) -> Edits {
     }
 }
 
+use iris::prelude::*;
+
 /// The two routes to an edited tree are one tree. `plan` resolves edits out
 /// of the random stream as it draws; `edited` puts them on a tree that
 /// already exists, which is the only route a shrunk plan has, since no seed
@@ -86,13 +70,11 @@ fn editing_a_plan_is_growing_one_with_those_edits() {
     }
 }
 
-/// No simplification is larger, which is the half of "the shrinker stops" a
+/// Every simplification is strictly smaller, so taking them in turn reaches a
-/// widget count can see. Most are not smaller either -- a dropped alignment
+/// fixed point instead of circling. A shrinker that can return to a tree it
-/// and a simpler leaf both keep the count -- so what rules out circling is
+/// has already tried does not stop.
-/// that those are one-way too: a `Some` becomes a `None`, and a kind steps
-/// down a ladder with no way back up.
 #[test]
-fn no_simplification_of_a_plan_is_larger_than_it() {
+fn every_simplification_of_a_plan_is_smaller_than_it() {
     for seed in 1..=60 {
         let tree = plan(seed, 4, &Edits::default());
         let mut queue = vec![tree];
@@ -137,20 +119,3 @@ fn reducing_a_plan_all_the_way_ends() {
         );
     }
 }
-
-/// Every image in a tree is the same picture, and a handle is a reference to
-/// the texture rather than a copy of it, so one upload and one slot serve all
-/// of them however many a tree grows -- and the trees are grown in hundreds.
-#[test]
-fn a_tree_of_images_uploads_one_texture() {
-    let mut images = 0;
-    let mut tree = plan(1, 4, &Edits::default());
-    tree.walk_mut(&mut |p| images += (p.kind == Kind::Image) as usize);
-    assert!(images > 1, "a tree of {images} images tests nothing");
-
-    let mut h = Harness::new((900, 1200));
-    let (root, _) = grow(&mut h.rsc, 1, 4, &Edits::default());
-    h.state.root = Some(root);
-    h.frame();
-    assert_eq!(h.rsc.ui().textures.count(), 1);
-}

tests/cases/retained.rs

@@ -45,6 +45,7 @@ fn counted(h: &mut Harness, size: Size, reads_box: bool) -> (WeakWidget<Counted>
 
 struct Layered {
     children: [StrongWidget<Rect>; 2],
+    _revision: usize,
 }
 
 impl Widget for Layered {
@@ -64,10 +65,14 @@ fn a_redrawn_layered_widget_keeps_the_layer_it_was_entered_on() {
         rect(Color::RED).add_strong(&mut h.rsc),
         rect(Color::BLUE).add_strong(&mut h.rsc),
     ];
-    let root = Layered { children }.add(&mut h.rsc);
+    let root = Layered {
+        children,
+        _revision: 0,
+    }
+    .add(&mut h.rsc);
     h.set_root(root);
 
-    h.rsc.widgets_mut().mark_for_redraw(root.id());
+    h.rsc[root]._revision += 1;
     h.frame();
 
     let label = h.rsc.widgets().label(root.id());
@@ -120,7 +125,7 @@ fn moving_an_ordinary_subtree_remaps_its_mask() {
     let active = &h.render.active[&masked.id()];
     assert_eq!(
         h.rsc.ui().masks[active.mask.idx()].region,
-        UiRegion::new(UiSpan::new(Len::px(150.0), Len::FULL), UiSpan::FULL,)
+        UiRegion::new(UiSpan::new(Len::px(150.0), Len::rel_max()), UiSpan::FULL,)
     );
     assert_corners!(h, inner, (150, 0), (400, 200));
 }
@@ -176,9 +181,9 @@ fn a_repaint_that_keeps_its_size_does_not_relay_out() {
     h.set_root((first, second).span(Dir::RIGHT));
     let settled = draws.get();
 
-    // Marked with nothing about it changed, and it reports the same size
+    // Taking mutable access is the ordinary content-change signal. This
-    // either way, so the parent has nothing to lay out.
+    // widget returns the same size, so the parent has nothing to lay out.
-    h.rsc.widgets_mut().mark_for_redraw(first.id());
+    let _ = h.rsc.widgets_mut().get_dyn_mut(first.id());
     h.frame();
 
     assert_eq!(draws.get(), settled + 1);
@@ -193,7 +198,7 @@ fn a_span_child_survives_the_next_frame() {
     let bottom = rect(Color::BLUE).height(120).add(&mut h.rsc);
     h.set_root((top, bottom).span(Dir::DOWN));
 
-    h.rsc.widgets_mut().mark_for_redraw(top.id());
+    h.rsc.widgets_mut().get_dyn_mut(top.id());
     h.frame();
 
     assert_corners!(h, top, (0, 0), (400, 80));
@@ -209,7 +214,11 @@ impl Widget for FromHint {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let len = painter.size_hint(&self.inner, Axis::Y).unwrap();
         let top = UiSpan::new(Len::ZERO, Len::from_parts(Rel::ZERO, len.px));
-        painter.widget_at(&self.inner, top.shifted_desc().on_axis(Axis::Y));
+        painter.widget_at(
+            &self.inner,
+            [None; 2],
+            [Place::Within(Part::All), Place::Within(Part::From(top))],
+        );
         Size::LEFTOVER
     }
 }
@@ -655,7 +664,7 @@ fn a_masked_widget_redrawn_on_its_own_sets_its_mask_again() {
     let masked = inner.masked().add(&mut h.rsc);
     let other = rect(Color::RED).width(100).add(&mut h.rsc);
     h.set_root((other, masked).span(Dir::RIGHT));
-    h.rsc.widgets_mut().mark_for_redraw(masked.id());
+    h.rsc.widgets_mut().get_dyn_mut(masked.id());
     h.frame();
     assert_corners!(h, inner, (100, 0), (400, 200));
 }
@@ -769,17 +778,6 @@ fn a_subtree_that_changed_parents_settles_at_the_depth_it_moved_to() {
     );
 }
 
-/// Where a mask slot clips, in window pixels: the region it holds, carried
-/// through whatever move entry it hangs from. Taken by slot rather than by
-/// widget, so a test can name the slot it expects a redraw to keep.
-fn mask_bounds(h: &Harness, mask: MaskIdx) -> PixelRegion {
-    let mask = &h.rsc.ui().masks[mask.idx()];
-    h.render
-        .moves
-        .resolve(mask.move_idx, mask.region)
-        .to_px(h.render.output_size())
-}
-
 fn primitive_bounds(h: &Harness, id: WidgetId) -> Vec<PixelRegion> {
     h.render.active[&id]
         .primitives
@@ -799,7 +797,7 @@ fn primitive_bounds(h: &Harness, id: WidgetId) -> Vec<PixelRegion> {
 }
 
 #[test]
-fn changing_an_inherited_region_keeps_the_original_measurement_offer() {
+fn changing_an_inherited_extent_keeps_the_original_measurement_offer() {
     fn build(h: &mut Harness, width: i32, text: &str) -> (WeakWidget<Text>, WeakWidget<Rect>) {
         let first = rect(Color::RED).width(width).add(&mut h.rsc);
         let words = wtext(text).size(20).wrap(true).add(&mut h.rsc);
@@ -879,7 +877,11 @@ fn resizing_a_fixed_frame_recomposes_its_contents_without_drawing_them() {
         fn draw(&mut self, painter: &mut Painter) -> Size {
             painter.widget_at(
                 &self.child,
-                PlaceDesc::new(self.region.x.shifted_desc(), self.region.y.shifted_desc()),
+                [None; 2],
+                [
+                    Place::Within(Part::From(self.region.x)),
+                    Place::Within(Part::From(self.region.y)),
+                ],
             );
             Size::LEFTOVER
         }
@@ -925,10 +927,15 @@ fn resizing_a_fixed_frame_recomposes_its_contents_without_drawing_them() {
             primitive_bounds(&warm, leaf.id()),
             primitive_bounds(&cold, other.id())
         );
-        assert_eq!(
+        let mask = |h: &Harness, id: WidgetId| {
-            mask_bounds(&warm, warm.render.active[&leaf.id()].mask),
+            let active = &h.render.active[&id];
-            mask_bounds(&cold, cold.render.active[&other.id()].mask)
+            let mask = &h.rsc.ui().masks[active.mask.idx()];
-        );
+            h.render
+                .moves
+                .resolve(mask.move_idx, mask.region)
+                .to_px(h.render.output_size())
+        };
+        assert_eq!(mask(&warm, leaf.id()), mask(&cold, other.id()));
     }
 }
 
@@ -952,18 +959,18 @@ fn glyph_origins_compose_identically_when_drawn_and_when_retained() {
     }
     struct Frame {
         child: StrongWidget,
-        frame: UiRegion,
         region: UiRegion,
+        extent: UiRegion,
     }
     impl Widget for Frame {
         fn draw(&mut self, painter: &mut Painter) -> Size {
             painter.widget_at(
                 &self.child,
-                PlaceDesc::new(
+                [Some(self.region.x.len()), None],
-                    self.region.x.shifted_desc().fills(),
+                [
-                    self.region.y.shifted_desc().fills(),
+                    Place::Fill(Part::From(self.extent.x)),
-                )
+                    Place::Fill(Part::From(self.extent.y)),
-                .rel_base(Axis::X, self.frame.x.len()),
+                ],
             );
             Size::LEFTOVER
         }
@@ -979,15 +986,15 @@ fn glyph_origins_compose_identically_when_drawn_and_when_retained() {
         h.rsc.widgets_mut().set_region_node(text, node);
         let root = Frame {
             child: text.add_strong(&mut h.rsc),
-            frame: UiRegion::FULL,
             region: UiRegion::FULL,
+            extent: UiRegion::FULL,
         }
         .add(&mut h.rsc);
         h.set_root(root);
         for (start, end) in [(0.13, 0.83), (-0.17, 1.23), (0.31, 0.67)] {
             let before = draws.get();
-            h.rsc[root].frame.x = UiSpan::new(Len::px(13.125), Len::px(287.375));
+            h.rsc[root].region.x = UiSpan::new(Len::px(13.125), Len::px(287.375));
-            h.rsc[root].region = UiRegion::new(
+            h.rsc[root].extent = UiRegion::new(
                 UiSpan::new(Len::rel(start), Len::rel(end)),
                 UiSpan::new(Len::px(7.25), Len::rel(end)),
             );
@@ -995,7 +1002,7 @@ fn glyph_origins_compose_identically_when_drawn_and_when_retained() {
             assert_eq!(draws.get(), before);
             let retained = primitive_bounds(&h, text.id());
             assert!(!retained.is_empty());
-            h.rsc.widgets_mut().mark_for_redraw(text.id());
+            let _ = h.rsc.widgets_mut().get_dyn_mut(text.id());
             h.frame();
             assert!(draws.get() > before);
             assert_eq!(retained, primitive_bounds(&h, text.id()));
@@ -1110,7 +1117,7 @@ fn widening_and_restoring_a_contract_does_not_invalidate_its_reader() {
     assert_eq!(leaf_draws.get(), settled + 1);
 }
 #[test]
-fn padding_and_stack_boxes_follow_the_region_without_drawing_again() {
+fn padding_and_stack_boxes_follow_the_extent_without_drawing_again() {
     struct Observed<W> {
         widget: W,
         draws: Rc<Cell<usize>>,
@@ -1123,22 +1130,23 @@ fn padding_and_stack_boxes_follow_the_region_without_drawing_again() {
     }
     struct Frame {
         child: StrongWidget,
-        region: UiRegion,
+        extent: UiRegion,
     }
     impl Widget for Frame {
         fn draw(&mut self, painter: &mut Painter) -> Size {
             painter.widget_at(
                 &self.child,
-                PlaceDesc::new(
+                [None; 2],
-                    self.region.x.shifted_desc().fills(),
+                [
-                    self.region.y.shifted_desc().fills(),
+                    Place::Fill(Part::From(self.extent.x)),
-                ),
+                    Place::Fill(Part::From(self.extent.y)),
+                ],
             );
             Size::LEFTOVER
         }
     }
     for node in [false, true] {
-        let plant = |h: &mut Harness, region| {
+        let plant = |h: &mut Harness, extent| {
             let draws = Rc::new(Cell::new(0));
             let leaf = rect(Color::BLUE).masked().add(&mut h.rsc);
             h.rsc.widgets_mut().set_region_node(leaf, node);
@@ -1159,7 +1167,7 @@ fn padding_and_stack_boxes_follow_the_region_without_drawing_again() {
                 draws: draws.clone(),
             }
             .add_strong(&mut h.rsc);
-            let root = Frame { child: pad, region }.add(&mut h.rsc);
+            let root = Frame { child: pad, extent }.add(&mut h.rsc);
             h.set_root(root);
             (root, leaf, fixed, draws)
         };
@@ -1174,27 +1182,32 @@ fn padding_and_stack_boxes_follow_the_region_without_drawing_again() {
         let mut warm = Harness::new((403, 211));
         let (root, leaf, fixed, draws) = plant(&mut warm, at(0.13));
         for start in [0.13, -0.17, 0.31] {
-            let region = at(start);
+            let extent = at(start);
             let before = draws.get();
-            warm.rsc[root].region = region;
+            warm.rsc[root].extent = extent;
             warm.frame();
             assert_eq!(draws.get(), before);
             let mut cold = Harness::new((403, 211));
-            let (_, other, other_fixed, _) = plant(&mut cold, region);
+            let (_, other, other_fixed, _) = plant(&mut cold, extent);
             for (a, b) in [(leaf.id(), other.id()), (fixed.id(), other_fixed.id())] {
                 assert_eq!(warm.region(&a), cold.region(&b));
                 assert_eq!(primitive_bounds(&warm, a), primitive_bounds(&cold, b));
             }
-            assert_eq!(
+            let mask = |h: &Harness, id: WidgetId| {
-                mask_bounds(&warm, warm.render.active[&leaf.id()].mask),
+                let active = &h.render.active[&id];
-                mask_bounds(&cold, cold.render.active[&other.id()].mask)
+                let mask = &h.rsc.ui().masks[active.mask.idx()];
-            );
+                h.render
+                    .moves
+                    .resolve(mask.move_idx, mask.region)
+                    .to_px(h.render.output_size())
+            };
+            assert_eq!(mask(&warm, leaf.id()), mask(&cold, other.id()));
         }
     }
 }
 
 #[test]
-fn moving_a_childs_region_preserves_the_slot_chosen_from_its_measurement() {
+fn moving_an_extent_child_preserves_the_slot_chosen_from_its_measurement() {
     struct Measured;
     impl Widget for Measured {
         fn draw(&mut self, painter: &mut Painter) -> Size {
@@ -1211,12 +1224,14 @@ fn moving_a_childs_region_preserves_the_slot_chosen_from_its_measurement() {
         fn draw(&mut self, painter: &mut Painter) -> Size {
             painter.widget_at(
                 &self.child,
-                PlaceDesc::new(
+                [None; 2],
-                    UiSpan::new(Len::px(self.start), Len::px(self.start + 200.0))
+                [
-                        .shifted_desc()
+                    Place::Fill(Part::From(UiSpan::new(
-                        .fills(),
+                        Len::px(self.start),
-                    UiSpan::FULL.shifted_desc().fills(),
+                        Len::px(self.start + 200.0),
-                ),
+                    ))),
+                    Place::Fill(Part::From(UiSpan::FULL)),
+                ],
             );
             Size::LEFTOVER
         }
@@ -1241,7 +1256,7 @@ fn moving_a_childs_region_preserves_the_slot_chosen_from_its_measurement() {
 }
 
 #[test]
-fn changing_regions_keep_fractional_reports_and_numeric_dependencies_valid() {
+fn extent_frames_keep_fractional_reports_and_numeric_dependencies_valid() {
     struct Container {
         child: StrongWidget,
         region: UiRegion,
@@ -1251,14 +1266,18 @@ fn changing_regions_keep_fractional_reports_and_numeric_dependencies_valid() {
             painter
                 .widget_at(
                     &self.child,
-                    PlaceDesc::new(self.region.x.shifted_desc(), self.region.y.shifted_desc()),
+                    [None; 2],
+                    [
+                        Place::Within(Part::From(self.region.x)),
+                        Place::Within(Part::From(self.region.y)),
+                    ],
                 )
                 .size()
         }
     }
     struct Frame {
         child: StrongWidget,
-        region: UiRegion,
+        extent: UiRegion,
         answer: Rc<Cell<Size>>,
     }
     impl Widget for Frame {
@@ -1267,10 +1286,11 @@ fn changing_regions_keep_fractional_reports_and_numeric_dependencies_valid() {
                 painter
                     .widget_at(
                         &self.child,
-                        PlaceDesc::new(
+                        [None; 2],
-                            self.region.x.shifted_desc().fills(),
+                        [
-                            self.region.y.shifted_desc().fills(),
+                            Place::Fill(Part::From(self.extent.x)),
-                        ),
+                            Place::Fill(Part::From(self.extent.y)),
+                        ],
                     )
                     .size(),
             );
@@ -1282,7 +1302,7 @@ fn changing_regions_keep_fractional_reports_and_numeric_dependencies_valid() {
             UiRegion::FULL,
             UiRegion::new(UiSpan::new(Len::rel(0.13), Len::rel(0.79)), UiSpan::FULL),
         ] {
-            let plant = |h: &mut Harness, outer| {
+            let plant = |h: &mut Harness, extent| {
                 let size = if fractional {
                     Size {
                         x: rel(0.5),
@@ -1300,7 +1320,7 @@ fn changing_regions_keep_fractional_reports_and_numeric_dependencies_valid() {
                 let answer = Rc::new(Cell::new(Size::ZERO));
                 let root = Frame {
                     child,
-                    region: outer,
+                    extent,
                     answer: answer.clone(),
                 }
                 .add(&mut h.rsc);
@@ -1310,256 +1330,15 @@ fn changing_regions_keep_fractional_reports_and_numeric_dependencies_valid() {
             let mut warm = Harness::new((403, 211));
             let (root, leaf, answer) = plant(&mut warm, UiRegion::FULL);
             for width in [191.125, 297.25, 83.75] {
-                let region =
+                let extent =
                     UiRegion::new(UiSpan::new(Len::px(13.125), Len::px(width)), UiSpan::FULL);
-                warm.rsc[root].region = region;
+                warm.rsc[root].extent = extent;
                 warm.frame();
                 let mut cold = Harness::new((403, 211));
-                let (_, other, other_answer) = plant(&mut cold, region);
+                let (_, other, other_answer) = plant(&mut cold, extent);
                 assert_eq!(answer.get(), other_answer.get());
                 assert_eq!(warm.region(&leaf), cold.region(&other));
             }
         }
     }
 }
-
-struct OptionalMask {
-    inner: StrongWidget,
-    enabled: bool,
-}
-
-impl Widget for OptionalMask {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        if self.enabled {
-            painter.set_mask(UiRegion::FULL);
-        }
-        painter.widget(&self.inner);
-        Size::LEFTOVER
-    }
-}
-
-fn primitive_masks(h: &Harness, id: WidgetId) -> Vec<MaskIdx> {
-    h.render.active[&id]
-        .primitives
-        .iter()
-        .map(|primitive| {
-            let handle = &primitive.handle;
-            h.render.layers[handle.layer].primitives()[handle.kind as usize]
-                .as_ref()
-                .unwrap()
-                .instances()[handle.inst_idx]
-                .mask_idx
-        })
-        .collect()
-}
-
-#[test]
-fn a_redrawn_mask_keeps_reused_primitives_clipped_when_it_moves() {
-    for node in [false, true] {
-        let mut h = Harness::new((400, 200));
-        let first = rect(Color::RED).height(50).add(&mut h.rsc);
-        let inner = rect(Color::BLUE).add(&mut h.rsc);
-        let draws = Rc::new(Cell::new(0));
-        let child = Stretchy {
-            inner: inner.add_strong(&mut h.rsc),
-            draws: draws.clone(),
-        }
-        .add(&mut h.rsc);
-        let masked = child.masked().add(&mut h.rsc);
-        h.rsc.widgets_mut().set_region_node(masked, node);
-        h.set_root((first, masked).span(Dir::DOWN));
-        let mask = h.render.active[&masked.id()].mask;
-        let settled = draws.get();
-        h.rsc.widgets_mut().mark_for_redraw(masked.id());
-        h.frame();
-        assert_eq!(primitive_masks(&h, inner.id()), vec![mask]);
-        assert_eq!(draws.get(), settled, "a mask repaint must reuse its child");
-        assert_eq!(h.render.active[&masked.id()].mask, mask);
-        h.set_len(first, Axis::Y, 10);
-        h.frame();
-        assert_eq!(mask_bounds(&h, mask), h.region(&masked).unwrap());
-        assert_corners!(h, inner, (0, 10), (400, 200));
-    }
-}
-
-#[test]
-fn adding_and_removing_a_mask_updates_existing_primitives() {
-    let mut h = Harness::new((400, 200));
-    let inner = rect(Color::BLUE).add(&mut h.rsc);
-    let masked = OptionalMask {
-        inner: inner.add_strong(&mut h.rsc),
-        enabled: false,
-    }
-    .add(&mut h.rsc);
-    h.set_root(masked);
-    for enabled in [true, false, true, false] {
-        h.rsc[masked].enabled = enabled;
-        h.frame();
-        let mask = h.render.active[&masked.id()].mask;
-        assert_eq!(mask == MaskIdx::NONE, !enabled);
-        assert_eq!(primitive_masks(&h, inner.id()), vec![mask]);
-    }
-    assert_eq!(h.rsc.ui().masks.len(), 1, "retired slots must be reusable");
-}
-
-#[test]
-fn an_empty_masks_slot_is_released_when_the_mask_is_removed_or_undrawn() {
-    let mut h = Harness::new((400, 200));
-    let (inner, _) = counted(&mut h, Size::LEFTOVER, false);
-    let masked = OptionalMask {
-        inner: inner.add_strong(&mut h.rsc),
-        enabled: true,
-    }
-    .add(&mut h.rsc);
-    let row = (masked,).span(Dir::DOWN).add(&mut h.rsc);
-    h.set_root(row);
-    for _ in 0..3 {
-        h.rsc[masked].enabled = false;
-        h.frame();
-        h.rsc[masked].enabled = true;
-        h.frame();
-        let child = h.rsc[row].pop().unwrap();
-        h.frame();
-        h.rsc[row].push(child);
-        h.frame();
-    }
-    assert_eq!(h.rsc.ui().masks.len(), 1);
-}
-
-struct SharedChild(Rc<StrongWidget>);
-
-impl Widget for SharedChild {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.widget(self.0.as_ref()).size()
-    }
-}
-
-struct SwitchParent {
-    choices: [StrongWidget; 2],
-    choice: usize,
-}
-
-impl Widget for SwitchParent {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.widget(&self.choices[self.choice]).size()
-    }
-}
-
-#[test]
-fn a_redrawn_subtree_is_not_undrawn_by_the_parent_it_left() {
-    for node in [false, true] {
-        let mut h = Harness::new((400, 200));
-        let leaf = rect(Color::RED).width(40).add(&mut h.rsc);
-        let held: StrongWidget = leaf.add_strong(&mut h.rsc);
-        let shared = Rc::new(held);
-        let first = SharedChild(shared.clone()).add_strong(&mut h.rsc);
-        let second = SharedChild(shared).add_strong(&mut h.rsc);
-        h.rsc.widgets_mut().set_region_node(&second, node);
-        let root = SwitchParent {
-            choices: [first, second],
-            choice: 0,
-        }
-        .add(&mut h.rsc);
-        h.set_root(root);
-        let before = h.region(&leaf);
-        h.rsc[root].choice = 1;
-        h.frame();
-        assert_eq!(h.region(&leaf), before);
-    }
-}
-
-/// A leaf that reports less than the box it is given and states which lengths
-/// of that box its drawing holds for, so a test can widen the contract
-/// without changing the answer. It counts its draws, since what a kept
-/// contract costs is whether the parent has to make it draw again.
-struct Contracted {
-    holds: std::ops::RangeInclusive<Px>,
-    size: Size,
-    draws: Rc<Cell<usize>>,
-}
-
-impl Widget for Contracted {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.draws.set(self.draws.get() + 1);
-        painter.holds(Axis::X, self.holds.clone());
-        self.size
-    }
-}
-
-struct CountedParent {
-    inner: StrongWidget,
-    draws: Rc<Cell<usize>>,
-}
-
-impl Widget for CountedParent {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.draws.set(self.draws.get() + 1);
-        painter.widget(&self.inner).size()
-    }
-}
-
-#[test]
-fn widening_what_a_drawing_holds_for_does_not_relay_out_the_parent() {
-    let mut h = Harness::new((400, 200));
-    let child = Contracted {
-        holds: Px::from_int(300)..=Px::from_int(500),
-        size: Size::from((100, 200)),
-        draws: Rc::new(Cell::new(0)),
-    }
-    .add(&mut h.rsc);
-    let draws = Rc::new(Cell::new(0));
-    let root = CountedParent {
-        inner: child.upgrade(&mut h.rsc),
-        draws: draws.clone(),
-    }
-    .add(&mut h.rsc);
-    h.set_root(root);
-    let settled = draws.get();
-
-    // The same answer, good for more boxes than before, so the guarantee the
-    // parent kept still holds.
-    h.rsc[child].holds = Px::from_int(200)..=Px::from_int(600);
-    h.frame();
-
-    assert_eq!(
-        draws.get(),
-        settled,
-        "a wider contract for the same answer is not a change to lay out"
-    );
-}
-
-/// The other half of the rule above: a kept contract is the narrower one, so
-/// it is only worth keeping where it still holds. A window the old range is
-/// outside is not one its parent can be handed back, and keeping it there
-/// throws away the drawing the widget just made.
-#[test]
-fn a_contract_this_window_is_outside_is_not_kept() {
-    let mut h = Harness::new((400, 200));
-    let leaf_draws = Rc::new(Cell::new(0));
-    let child = Contracted {
-        holds: Px::from_int(300)..=Px::from_int(500),
-        size: Size::from((100, 200)),
-        draws: leaf_draws.clone(),
-    }
-    .add(&mut h.rsc);
-    let root = CountedParent {
-        inner: child.upgrade(&mut h.rsc),
-        draws: Rc::new(Cell::new(0)),
-    }
-    .add(&mut h.rsc);
-    h.set_root(root);
-
-    // Wide enough that the old contract leaves the new box out, and the leaf
-    // is marked in the same frame -- so it settles itself first and its
-    // parent draws afterwards, asking about what it settled.
-    h.resize((600, 200));
-    h.rsc[child].holds = Px::from_int(200)..=Px::from_int(700);
-    let settled = leaf_draws.get();
-    h.frame();
-
-    assert_eq!(
-        leaf_draws.get(),
-        settled + 1,
-        "the leaf settled once and its parent kept what it settled"
-    );
-}

tests/cases/scroll.rs

@@ -113,7 +113,7 @@ fn wrapping_content_beside_a_fixed_length_is_stable_warm_and_cold() {
 
     let mut warm = Harness::new((900, 300));
     let (text, content) = plant(&mut warm);
-    warm.rsc.widgets_mut().mark_for_redraw(text);
+    warm.rsc.widgets_mut().get_dyn_mut(text);
     warm.frame();
 
     let mut cold = Harness::new((900, 300));
@@ -142,8 +142,8 @@ fn a_clipping_widget_reporting_more_than_its_box_is_caught() {
     let mut h = Harness::new((100, 100));
     let tall = rect(Color::RED).height(400).add_strong(&mut h.rsc);
     let clipper = Clipper(tall).add(&mut h.rsc);
-    // `set_root` lays the tree out, so this is where it is caught.
     h.set_root(clipper);
+    h.frame();
 }
 
 /// Content that fits sits in the viewport, not in a box of the window's
@@ -161,26 +161,3 @@ fn content_that_fits_is_placed_in_the_viewport_and_not_in_the_window() {
     assert_corners!(h, scroll, (0, 100), (400, 400));
     assert_corners!(h, inner, (0, 225), (400, 275));
 }
-
-/// A cap narrows the box the widget is asked in, which is what a scroll
-/// measures its viewport from: the content scrolls within the cap rather than
-/// within the room the cap was cut from.
-#[test]
-fn a_capped_scroll_takes_its_viewport_from_the_cap() {
-    let mut h = Harness::new((400, 200));
-    let top = rect(Color::RED).height(200).add(&mut h.rsc);
-    let bottom = rect(Color::BLUE).height(200).add(&mut h.rsc);
-    let scroll = (top, bottom).span(Dir::DOWN).scrollable().add(&mut h.rsc);
-    let capped = scroll.max_height(100).add(&mut h.rsc);
-    h.set_root(capped);
-    h.move_to((200, 50));
-
-    // 400 of content in a viewport of 100, so 300 to scroll and the end
-    // showing: the top is 300 above the box, which the window centres.
-    assert_eq!(h.region(&scroll).unwrap().size().y, Px::from_int(100));
-    assert_corners!(h, top, (0, -250), (400, -50));
-
-    h.scroll((0, 1));
-    h.frame();
-    assert_corners!(h, top, (0, -200), (400, 0));
-}

tests/cases/unsettled.rs

@@ -9,45 +9,17 @@
 //! reached through a region node's own entry rather than through the offer
 //! that node was given. The last is a wrapping text handed back the width
 //! it measured, rounded to a step below the line it measured there.
-//!
-//! Each says which seed it was shrunk from, of the generator as it stood when
-//! it was found. Those numbers no longer grow those trees -- a seed names one
-//! only while the generator draws the same things in the same order, and the
-//! leaves have grown an image since -- so what is written out below is the
-//! record of the case, and the seed is where it came from.
-
-use std::collections::HashSet;
 
 use iris::harness::Harness;
 use iris::prelude::*;
 use iris::random::Branch;
 
-/// Every widget in the same place warm as cold, reported all at once: which
-/// of a dozen boxes moved is the whole of what a shrunk case has to say.
-///
-/// A list that names one widget twice is an error rather than a redundant
-/// check. `width`, `sized` and `align` give back the widget they were handed,
-/// so a fixture built through them can name one text three times, and then a
-/// case comparing six boxes compares four and says nothing about it. One
-/// fixture builds both lists, so checking the warm one checks both.
-#[track_caller]
 fn assert_same_regions(
     warm: &Harness,
     warm_ids: &[WidgetId],
     cold: &Harness,
     cold_ids: &[WidgetId],
 ) {
-    assert_eq!(
-        warm_ids.len(),
-        cold_ids.len(),
-        "the warm and cold fixtures list different widgets"
-    );
-    let named: HashSet<&WidgetId> = warm_ids.iter().collect();
-    assert_eq!(
-        named.len(),
-        warm_ids.len(),
-        "a widget is listed twice: {warm_ids:?}"
-    );
     let mut wrong = Vec::new();
     for (i, (&w, &c)) in warm_ids.iter().zip(cold_ids).enumerate() {
         let (got, want) = (warm.region(&w), cold.region(&c));
@@ -120,7 +92,7 @@ fn repainting_a_stack_uses_the_box_its_sizing_child_decided() {
     let mut warm = Harness::new((900, 1200));
     let ids = plant_stack_in_its_sizing_childs_box(&mut warm);
     for &id in &ids {
-        warm.rsc.widgets_mut().mark_for_redraw(id);
+        warm.rsc.widgets_mut().get_dyn_mut(id);
     }
     warm.frame();
 
@@ -216,31 +188,36 @@ fn reordering_nested_spans_keeps_the_answer_from_the_decided_box() {
     assert_same_regions(&warm, &ids, &cold, &cold_ids);
 }
 
-/// Four widgets, shrunk from a 402-widget tree the fuzzer found. Nothing about
+/// Six widgets, shrunk from a 402-widget tree the fuzzer found. Nothing about
 /// the tree changes -- every widget is marked for redraw and the frame is
 /// taken again -- so no box may move, and a warm frame has to land where a
 /// cold one does.
 fn plant(h: &mut Harness) -> Vec<WidgetId> {
     let plain = wtext("Wrapping").size(16).wrap(false).add(&mut h.rsc);
-    let wrapped = wtext("Wrapping shapes")
+    let wrapped = wtext("Wrapping shapes").size(16).wrap(true).add(&mut h.rsc);
-        .size(16)
+    let sized = wrapped.width(76).add(&mut h.rsc);
-        .wrap(true)
+    let aligned = sized;
-        .width(76)
-        .add(&mut h.rsc);
     h.rsc
         .widgets_mut()
-        .set_alignment(wrapped, Axis::X, AxisAlign::POS);
+        .set_alignment(sized, Axis::X, AxisAlign::POS);
     h.rsc
         .widgets_mut()
-        .set_alignment(wrapped, Axis::Y, AxisAlign::POS);
+        .set_alignment(sized, Axis::Y, AxisAlign::POS);
     let stack = Stack {
-        children: vec![plain.add_strong(&mut h.rsc), wrapped.add_strong(&mut h.rsc)],
+        children: vec![plain.add_strong(&mut h.rsc), aligned.add_strong(&mut h.rsc)],
         size: StackSize::Child(0),
     }
     .add(&mut h.rsc);
     let root = (stack,).span(Dir::RIGHT).add(&mut h.rsc);
     h.set_root(root);
-    vec![plain.id(), wrapped.id(), stack.id(), root.id()]
+    vec![
+        plain.id(),
+        wrapped.id(),
+        sized.id(),
+        aligned.id(),
+        stack.id(),
+        root.id(),
+    ]
 }
 
 /// The first frame does not reach the layout a second one does, so "cold" is
@@ -253,7 +230,7 @@ fn one_frame_is_enough() {
     let first = h.region(&ids[1]).unwrap();
     for _ in 0..3 {
         for &id in &ids {
-            h.rsc.widgets_mut().mark_for_redraw(id);
+            h.rsc.widgets_mut().get_dyn_mut(id);
         }
         h.frame();
     }
@@ -275,30 +252,46 @@ fn repainting_everything_moves_nothing() {
     let mut warm = Harness::new((640, 900));
     let ids = plant(&mut warm);
     for &id in &ids {
-        warm.rsc.widgets_mut().mark_for_redraw(id);
+        warm.rsc.widgets_mut().get_dyn_mut(id);
     }
     warm.frame();
 
     let mut cold = Harness::new((640, 900));
     let cold_ids = plant(&mut cold);
 
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+    let mut wrong = Vec::new();
+    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
+        let (got, want) = (warm.region(&w), cold.region(&c));
+        if got != want {
+            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
 }
 
-/// Four widgets, shrunk from 905. Everything inside the declared 189x176 box
+/// Six widgets, shrunk from 905. Everything inside the declared 189x176 box
 /// is the same size whatever the output is, so a resize may not change any of
 /// it -- but the text comes out 3.92px narrower warm than cold.
 fn plant_fixed(h: &mut Harness) -> Vec<WidgetId> {
     let words = "Wrapping shapes one source into as many lines as the box leaves";
     let text = wtext(words).size(16).wrap(true).add(&mut h.rsc);
+    let aligned = text;
     h.rsc
         .widgets_mut()
         .set_alignment(text, Axis::X, AxisAlign::NEG);
-    let inner = (text,).span(Dir::RIGHT).sized((189, 176)).add(&mut h.rsc);
+    let inner = (aligned,).span(Dir::RIGHT).add(&mut h.rsc);
+    let sized = inner.sized((189, 176)).add(&mut h.rsc);
     let filler = rect(Color::RED).add(&mut h.rsc);
-    let root = (filler, inner).span(Dir::RIGHT).add(&mut h.rsc);
+    let root = (filler, sized).span(Dir::RIGHT).add(&mut h.rsc);
     h.state.root = Some(root.add_strong(&mut h.rsc));
-    vec![text.id(), inner.id(), filler.id(), root.id()]
+    vec![
+        text.id(),
+        aligned.id(),
+        inner.id(),
+        sized.id(),
+        filler.id(),
+        root.id(),
+    ]
 }
 
 #[test]
@@ -313,10 +306,17 @@ fn a_resize_does_not_reach_inside_a_box_of_declared_pixels() {
     let cold_ids = plant_fixed(&mut cold);
     cold.frame();
 
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+    let mut wrong = Vec::new();
+    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
+        let (got, want) = (warm.region(&w), cold.region(&c));
+        if got != want {
+            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
 }
 
-/// Three widgets, shrunk from 486. A span's two children are swapped: warm by
+/// Four widgets, shrunk from 486. A span's two children are swapped: warm by
 /// moving them, cold by growing them that way. Same widgets, same sizes, one
 /// ends up 29.9px from where the other does.
 fn plant_pair(h: &mut Harness, swapped: bool) -> (Vec<WidgetId>, WeakWidget<Span>) {
@@ -340,11 +340,16 @@ fn plant_pair(h: &mut Harness, swapped: bool) -> (Vec<WidgetId>, WeakWidget<Span
         gap: Px::ZERO,
     }
     .add(&mut h.rsc);
+    let span_handle = span;
+    let aligned = span;
     h.rsc
         .widgets_mut()
         .set_alignment(span, Axis::X, AxisAlign::CENTER);
-    h.state.root = Some(span.add_strong(&mut h.rsc));
+    h.state.root = Some(aligned.add_strong(&mut h.rsc));
-    (vec![wrapped.id(), plain.id(), span.id()], span)
+    (
+        vec![wrapped.id(), plain.id(), span.id(), aligned.id()],
+        span_handle,
+    )
 }
 
 #[test]
@@ -359,10 +364,17 @@ fn swapping_two_children_lands_where_growing_them_that_way_does() {
     let (cold_ids, _) = plant_pair(&mut cold, true);
     cold.frame();
 
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+    let mut wrong = Vec::new();
+    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
+        let (got, want) = (warm.region(&w), cold.region(&c));
+        if got != want {
+            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
 }
 
-/// Seven widgets, shrunk from 80. The scroll decides how wide to make its
+/// Eight widgets, shrunk from 80. The scroll decides how wide to make its
 /// content from what the content says, and hands that box down through a
 /// pass-through; the span under it was given that box once, so nothing at its
 /// own edge says the box was its own answer.
@@ -381,7 +393,8 @@ fn plant_scrolled(h: &mut Harness, swapped: bool) -> (Vec<WidgetId>, [WeakWidget
         gap: Px::ZERO,
     }
     .add(&mut h.rsc);
-    let fixed = rect(Color::RED).width(87).add(&mut h.rsc);
+    let block = rect(Color::RED).add(&mut h.rsc);
+    let fixed = block.width(87).add(&mut h.rsc);
     let mut outer_children: Vec<StrongWidget> =
         vec![fixed.add_strong(&mut h.rsc), inner.add_strong(&mut h.rsc)];
     if swapped {
@@ -403,6 +416,7 @@ fn plant_scrolled(h: &mut Harness, swapped: bool) -> (Vec<WidgetId>, [WeakWidget
             text.id(),
             filler.id(),
             inner.id(),
+            block.id(),
             fixed.id(),
             outer.id(),
             through.id(),
@@ -426,7 +440,14 @@ fn a_span_given_the_box_its_answer_decided_matches_a_cold_layout() {
     let (cold_ids, _) = plant_scrolled(&mut cold, true);
     cold.frame();
 
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+    let mut wrong = Vec::new();
+    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
+        let (got, want) = (warm.region(&w), cold.region(&c));
+        if got != want {
+            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
 }
 
 /// Reports a width derived from the box it is asked in. Reading through the
@@ -450,10 +471,11 @@ impl Widget for Wider {
 fn plant_wider(h: &mut Harness, extra: f32) -> (WeakWidget<Wider>, WidgetId) {
     let content = Wider { extra }.add(&mut h.rsc);
     let scroll = Scroll::new(content.add_strong(&mut h.rsc), Axis::X).add(&mut h.rsc);
+    let root = scroll;
     h.rsc
         .widgets_mut()
         .set_alignment(scroll, Axis::X, AxisAlign::NEG);
-    h.set_root(scroll);
+    h.set_root(root);
     (content, scroll.id())
 }
 
@@ -545,7 +567,14 @@ fn a_box_that_only_rounds_past_its_fixed_children_leaves_nothing_over() {
     let (cold_ids, _) = plant_boundary(&mut cold, true);
     cold.frame();
 
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+    let mut wrong = Vec::new();
+    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
+        let (got, want) = (warm.region(&w), cold.region(&c));
+        if got != want {
+            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
 }
 
 /// Five widgets, shrunk by `tests/shrink.rs` from the 277 the oracle's seed
@@ -587,13 +616,20 @@ fn plant_nested_scrolls(h: &mut Harness) -> Vec<WidgetId> {
 fn redrawing_one_widget_does_not_move_what_scrolls_around_it() {
     let mut warm = Harness::new((900, 1200));
     let ids = plant_nested_scrolls(&mut warm);
-    warm.rsc.widgets_mut().mark_for_redraw(ids[0]);
+    warm.rsc.widgets_mut().get_dyn_mut(ids[0]);
     warm.frame();
 
     let mut cold = Harness::new((900, 1200));
     let cold_ids = plant_nested_scrolls(&mut cold);
 
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+    let mut wrong = Vec::new();
+    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
+        let (got, want) = (warm.region(&w), cold.region(&c));
+        if got != want {
+            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
 }
 
 /// Ten widgets, of the shape `tests/shrink.rs` reduces the oracle's seed 220
@@ -684,7 +720,14 @@ fn a_widget_under_a_region_node_is_asked_in_the_box_that_node_was_offered() {
     let (cold_ids, _) = plant_under_a_node(&mut cold, true);
     cold.frame();
 
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
+    let mut wrong = Vec::new();
+    for (i, (&w, &c)) in ids.iter().zip(&cold_ids).enumerate() {
+        let (got, want) = (warm.region(&w), cold.region(&c));
+        if got != want {
+            wrong.push(format!("widget {i}: warm {got:?} cold {want:?}"));
+        }
+    }
+    assert!(wrong.is_empty(), "{}", wrong.join("\n"));
 }
 
 const PARAGRAPH: &str = "Wrapping shapes one source into as many lines as the \
@@ -1024,32 +1067,3 @@ fn resizing_under_a_short_scroll_snaps_its_window_tall_content_again() {
 
     assert_same_regions(&warm, &ids, &cold, &cold_ids);
 }
-
-/// A scroll clamps its position against the box it is drawn in, so drawing it
-/// once at one viewport and again at another writes state the second draw then
-/// reads. That the answer is still the one a cold layout gives is a property
-/// of the clamp, not something the layout enforces.
-#[test]
-fn a_scrolled_view_resized_lands_where_a_cold_layout_puts_it() {
-    for amt in [10.0, 40.0, 90.0, 140.0] {
-        let mut warm = Harness::new((100, 100));
-        let (_, warm_scroll) = plant_wider(&mut warm, 100.0);
-        warm.move_to((50.0, 50.0));
-        warm.scroll((-amt, 0.0));
-        warm.frame();
-        warm.resize((160, 100));
-        warm.frame();
-
-        let mut cold = Harness::new((160, 100));
-        let (_, cold_scroll) = plant_wider(&mut cold, 100.0);
-        cold.move_to((50.0, 50.0));
-        cold.scroll((-amt, 0.0));
-        cold.frame();
-
-        assert_eq!(
-            warm.region(&warm_scroll),
-            cold.region(&cold_scroll),
-            "scrolled by {amt} then widened"
-        );
-    }
-}

tests/chain_cost.rs

@@ -11,6 +11,8 @@
 //! The instances are two pixels wide so that vertex work dominates; a chain
 //! walk that does not show up against small quads will not show up against
 //! anything.
+//!
+//! The instance is leaked deliberately, for the reason `draw_cost.rs` gives.
 
 use iris::prelude::*;
 use iris_core::{
@@ -19,9 +21,6 @@ use iris_core::{
 };
 use wgpu::{Color as GpuColor, *};
 
-#[path = "gpu/mod.rs"]
-mod gpu;
-
 const SIZE: u32 = 1024;
 const INSTANCES: usize = 200_000;
 const FRAMES: u32 = 20;
@@ -30,7 +29,18 @@ const FRAMES: u32 = 20;
 const BATCHES: u32 = 8;
 
 fn gpu() -> Option<(Device, Queue, f32)> {
-    let adapter = gpu::adapter()?;
+    let all = Instance::new(InstanceDescriptor::new_without_display_handle());
+    let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
+    {
+        Ok(_) => all,
+        Err(_) => Instance::new(InstanceDescriptor {
+            backends: Backends::GL,
+            ..InstanceDescriptor::new_without_display_handle()
+        }),
+    };
+    let instance: &'static Instance = Box::leak(Box::new(instance));
+    let adapter =
+        pollster::block_on(instance.request_adapter(&RequestAdapterOptions::default())).ok()?;
     if !adapter.features().contains(Features::TIMESTAMP_QUERY) {
         println!("no timestamp queries on {:?}", adapter.get_info().name);
         return None;
@@ -45,6 +55,20 @@ fn gpu() -> Option<(Device, Queue, f32)> {
     Some((device, queue, period))
 }
 
+fn config(format: TextureFormat) -> SurfaceConfiguration {
+    SurfaceConfiguration {
+        usage: TextureUsages::RENDER_ATTACHMENT,
+        format,
+        color_space: SurfaceColorSpace::Auto,
+        width: SIZE,
+        height: SIZE,
+        present_mode: PresentMode::Fifo,
+        desired_maximum_frame_latency: 2,
+        alpha_mode: CompositeAlphaMode::Auto,
+        view_formats: vec![],
+    }
+}
+
 /// A chain `depth` slots long, and instances that all resolve through its end.
 fn fill(ui: &mut UiData, render: &mut UiRenderState, depth: usize) {
     let kind = ui.primitives.kind::<RectPrimitive>();
@@ -79,7 +103,7 @@ fn fill(ui: &mut UiData, render: &mut UiRenderState, depth: usize) {
 /// Nanoseconds the pass took on the GPU, best of `BATCHES`.
 fn pass_cost(device: &Device, queue: &Queue, period: f32, depth: usize) -> f64 {
     let format = TextureFormat::Bgra8Unorm;
-    let mut node = UiRenderNode::new(device, &gpu::config(format, SIZE));
+    let mut node = UiRenderNode::new(device, &config(format));
     let mut ui = UiData::default();
     let mut render = UiRenderState::new();
     fill(&mut ui, &mut render, depth);

tests/deferred_generated.rs

@@ -1,67 +0,0 @@
-#[path = "scenario/mod.rs"]
-mod scenario;
-
-use iris::prelude::*;
-use iris::random::{Edits, Plan, plan};
-
-fn check_requests(edit: impl Fn(&mut Plan) + Sync) {
-    let count = scenario::env("IRIS_DEFERRED_SEEDS", 20_u64);
-    let depth = scenario::env("IRIS_DEFERRED_DEPTH", 4_usize);
-    let seeds = std::env::var("IRIS_DEFERRED_SEED")
-        .ok()
-        .and_then(|seed| seed.parse().ok())
-        .map_or_else(|| (1..=count).collect(), |seed| vec![seed]);
-    scenario::over_seeds(seeds, |seed| {
-        let mut grown = plan(seed, depth, &Edits::default());
-        edit(&mut grown);
-        for case in scenario::ALL {
-            if let Some(how) = scenario::diverges(&grown, case, seed) {
-                panic!(
-                    "request seed {seed} depth {depth} after {}: {how}",
-                    case.name()
-                );
-            }
-        }
-    });
-}
-
-#[test]
-fn deferred_requests_agree_warm_and_cold() {
-    check_requests(|grown| {
-        let mut index = 0;
-        grown.walk_mut(&mut |node| {
-            if let Some(rules) = &mut node.size {
-                for axis in Axis::BOTH {
-                    index += 1;
-                    rules[axis] = match index % 7 {
-                        0 => leftover(1).clamp(20, 120).into(),
-                        1 => leftover(1).min(rel(0.5)).into(),
-                        2 => (leftover(1) + px(30)).min(leftover(2)).into(),
-                        _ => rules[axis].clone(),
-                    };
-                }
-            }
-        });
-    });
-}
-
-#[test]
-fn relative_intrinsic_bounds_agree_warm_and_cold() {
-    check_requests(|grown| {
-        grown.walk_mut(&mut |node| {
-            if let Some(rules) = &mut node.size {
-                for axis in Axis::BOTH {
-                    rules[axis] = match rules[axis] {
-                        SizeRule::Min(_) => SizeRule::Min(Len::rel(0.25)),
-                        SizeRule::Max(_) => SizeRule::Max(Len::rel(0.75)),
-                        SizeRule::Clamp { .. } => SizeRule::Clamp {
-                            min: Len::rel(0.25),
-                            max: Len::rel(0.75),
-                        },
-                        ref rule => rule.clone(),
-                    };
-                }
-            }
-        });
-    });
-}

tests/draw_cost.rs

@@ -13,6 +13,10 @@
 //! That is how `PrimitiveRender` was measured against a match in the renderer:
 //! 6 instructions per list drawn, against the ~5,400 wgpu spends recording
 //! one.
+//!
+//! The instance is leaked deliberately. A Vulkan loader may unload the driver
+//! when the last one drops, which can fault as a thread that used it exits --
+//! and every test runs on a spawned thread.
 
 use std::time::Instant;
 
@@ -23,9 +27,6 @@ use iris_core::{
 };
 use wgpu::{Color as GpuColor, *};
 
-#[path = "gpu/mod.rs"]
-mod gpu;
-
 const SIZE: u32 = 1024;
 const FRAMES: u32 = 200;
 /// Reported as the best of this many batches, since the mean moves by more
@@ -33,11 +34,39 @@ const FRAMES: u32 = 200;
 const BATCHES: u32 = 8;
 
 fn gpu() -> Option<(Device, Queue)> {
-    let adapter = gpu::adapter()?;
+    // Probed rather than assumed: there may be no Vulkan adapter, and GL is
+    // what is left when there is not.
+    let all = Instance::new(InstanceDescriptor::new_without_display_handle());
+    let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
+    {
+        Ok(_) => all,
+        Err(_) => Instance::new(InstanceDescriptor {
+            backends: Backends::GL,
+            ..InstanceDescriptor::new_without_display_handle()
+        }),
+    };
+    // Leaked rather than dropped: see the note at the top of the file.
+    let instance: &'static Instance = Box::leak(Box::new(instance));
+    let adapter =
+        pollster::block_on(instance.request_adapter(&RequestAdapterOptions::default())).ok()?;
     println!("adapter: {:?}", adapter.get_info());
     pollster::block_on(adapter.request_device(&DeviceDescriptor::default())).ok()
 }
 
+fn config(format: TextureFormat) -> SurfaceConfiguration {
+    SurfaceConfiguration {
+        usage: TextureUsages::RENDER_ATTACHMENT,
+        format,
+        color_space: SurfaceColorSpace::Auto,
+        width: SIZE,
+        height: SIZE,
+        present_mode: PresentMode::Fifo,
+        desired_maximum_frame_latency: 2,
+        alpha_mode: CompositeAlphaMode::Auto,
+        view_formats: vec![],
+    }
+}
+
 /// Every layer draws all three primitives, so the renderer takes a different
 /// path for each list it walks -- which is the case a single-primitive layer
 /// would never exercise. Images are bound per instance, so there are few.
@@ -107,7 +136,7 @@ fn fill(
 
 fn frame_cost(device: &Device, queue: &Queue, layers: usize, per_layer: usize) -> f64 {
     let format = TextureFormat::Bgra8Unorm;
-    let mut node = UiRenderNode::new(device, &gpu::config(format, SIZE));
+    let mut node = UiRenderNode::new(device, &config(format));
     let mut ui = UiData::default();
     let mut render = UiRenderState::new();
     let _handles = fill(&mut ui, &mut render, layers, per_layer);

tests/generated.rs

@@ -14,7 +14,7 @@
 #[path = "scenario/mod.rs"]
 mod scenario;
 
-use iris::random::{Edits, Plan, plan};
+use iris::random::{Edits, plan};
 use scenario::{ALL, Case, diverges, env, over_seeds};
 
 /// How deep the generator branches. The generator widens two to four ways per
@@ -25,22 +25,15 @@ fn depth() -> usize {
     env("IRIS_GENERATED_DEPTH", 4)
 }
 
-/// The seeds the ordinary tests take: a corpus rather than a set of
+/// The seeds the ordinary tests take. Seven that have never failed; 86,
-/// regression cases, since a seed names a tree only for as long as the
+/// which a `Scroll` fixed point once settled differently on; and 20, which
-/// generator draws the same things in the same order. Adding images to the
+/// caught a locally redrawn widget being placed twice in the box its parent
-/// leaves moved every one of them, so 20 and 86 -- which once caught a widget
+/// had already placed it in.
-/// placed twice in a box its parent had already placed it in, and a `Scroll`
-/// fixed point settling differently -- no longer grow those trees. Both
-/// defects are pinned by the shrunk fixtures in `cases/unsettled.rs`, which
-/// are trees rather than numbers.
 const SEEDS: [u64; 10] = [1, 2, 3, 5, 8, 10, 13, 20, 86, 98];
 
 fn check(seed: u64, depth: usize, case: Case) {
-    check_plan(&plan(seed, depth, &Edits::default()), seed, depth, case);
+    let grown = plan(seed, depth, &Edits::default());
-}
+    if let Some(how) = diverges(&grown, case, seed) {
-
-fn check_plan(grown: &Plan, seed: u64, depth: usize, case: Case) {
-    if let Some(how) = diverges(grown, case, seed) {
         panic!(
             "seed {seed} at depth {depth} differs after {}: {how}\n\
              reduce it with SHRINK_SEED={seed} SHRINK_DEPTH={depth} \
@@ -51,50 +44,57 @@ fn check_plan(grown: &Plan, seed: u64, depth: usize, case: Case) {
     }
 }
 
-/// A test per case, and the list of which cases have one, from the same
+macro_rules! case {
-/// place. A case the ordinary suite leaves out runs only in the long scan,
+    ($name:ident, $case:expr) => {
-/// which nobody runs by hand.
-macro_rules! cases {
-    ($($name:ident = $case:expr,)*) => {
-        $(
         #[test]
         fn $name() {
             for seed in SEEDS {
                 check(seed, depth(), $case);
             }
         }
-        )*
-
-        const NAMED: [Case; [$($case,)*].len()] = [$($case,)*];
     };
 }
 
-cases! {
+case!(
-    many_widgets_redrawing_at_once_leaves_every_box_where_it_was = Case::RepaintSome,
+    many_widgets_redrawing_at_once_leaves_every_box_where_it_was,
-    everything_redrawing_at_once_leaves_every_box_where_it_was = Case::Repaint,
+    Case::RepaintSome
-    a_resize_lands_where_starting_at_that_size_would = Case::Resize,
+);
-    a_resize_and_a_repaint_land_where_starting_that_way_would = Case::ResizeRepaint,
+case!(
-    a_size_change_after_a_resize_lands_the_same_way = Case::ResizeSize,
+    everything_redrawing_at_once_leaves_every_box_where_it_was,
-    a_resize_after_a_size_change_lands_the_same_way = Case::SizeResize,
+    Case::Repaint
-    a_size_change_lands_where_growing_it_that_way_would = Case::Size,
+);
-    every_size_changing_at_once_lands_where_growing_it_that_way_would = Case::EverySize,
+case!(
-    an_alignment_change_lands_where_growing_it_that_way_would = Case::Align,
+    a_resize_lands_where_starting_at_that_size_would,
-    giving_and_taking_a_movable_region_rebuilds_what_resolves_it = Case::RegionNode,
+    Case::Resize
-    reordering_a_span_lands_where_growing_it_that_way_would = Case::Reorder,
+);
-}
+case!(
-
+    a_resize_and_a_repaint_land_where_starting_that_way_would,
-/// The shuffles are one test between them, so they are the only cases `ALL`
+    Case::ResizeRepaint
-/// may hold without a test of their own.
+);
-#[test]
+case!(
-fn every_case_runs_without_the_long_scan() {
+    a_size_change_after_a_resize_lands_the_same_way,
-    for case in ALL {
+    Case::ResizeSize
-        assert!(
+);
-            NAMED.contains(&case) || matches!(case, Case::Shuffle(_)),
+case!(
-            "{} runs only in the long seed scan; give it a case here",
+    a_size_change_lands_where_growing_it_that_way_would,
-            case.name()
+    Case::Size
-        );
+);
-    }
+case!(
-}
+    every_size_changing_at_once_lands_where_growing_it_that_way_would,
+    Case::EverySize
+);
+case!(
+    an_alignment_change_lands_where_growing_it_that_way_would,
+    Case::Align
+);
+case!(
+    giving_and_taking_a_movable_region_rebuilds_what_resolves_it,
+    Case::RegionNode
+);
+case!(
+    reordering_a_span_lands_where_growing_it_that_way_would,
+    Case::Reorder
+);
 
 #[test]
 fn adding_and_removing_span_children_lands_where_growing_it_that_way_would() {
@@ -108,7 +108,7 @@ fn adding_and_removing_span_children_lands_where_growing_it_that_way_would() {
 }
 
 #[test]
-#[ignore = "as many seeds as it is asked for, rather than the ten the others check"]
+#[ignore = "as many seeds as it is asked for, rather than the nine the others check"]
 fn a_long_run_of_seeds_agrees() {
     let depth = depth();
     let seeds: Vec<u64> = match std::env::var("IRIS_GENERATED_SEED")
@@ -119,9 +119,8 @@ fn a_long_run_of_seeds_agrees() {
         None => (1..=env("IRIS_GENERATED_SEEDS", 100_u64)).collect(),
     };
     over_seeds(seeds, |seed| {
-        let grown = plan(seed, depth, &Edits::default());
         for case in ALL {
-            check_plan(&grown, seed, depth, case);
+            check(seed, depth, case);
         }
     });
 }

tests/gpu/mod.rs

@@ -1,40 +0,0 @@
-//! The adapter and the surface configuration the GPU measurement rigs share,
-//! so the two cannot probe for a device in two different ways.
-
-use wgpu::*;
-
-/// An adapter on whatever this machine has, or `None` where there is none.
-///
-/// Probed rather than assumed: there may be no Vulkan adapter, and GL is what
-/// is left when there is not.
-///
-/// The instance is leaked deliberately. A Vulkan loader may unload the driver
-/// when the last one drops, which can fault as a thread that used it exits --
-/// and every test runs on a spawned thread.
-pub fn adapter() -> Option<Adapter> {
-    let all = Instance::new(InstanceDescriptor::new_without_display_handle());
-    let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
-    {
-        Ok(_) => all,
-        Err(_) => Instance::new(InstanceDescriptor {
-            backends: Backends::GL,
-            ..InstanceDescriptor::new_without_display_handle()
-        }),
-    };
-    let instance: &'static Instance = Box::leak(Box::new(instance));
-    pollster::block_on(instance.request_adapter(&RequestAdapterOptions::default())).ok()
-}
-
-pub fn config(format: TextureFormat, size: u32) -> SurfaceConfiguration {
-    SurfaceConfiguration {
-        usage: TextureUsages::RENDER_ATTACHMENT,
-        format,
-        color_space: SurfaceColorSpace::Auto,
-        width: size,
-        height: size,
-        present_mode: PresentMode::Fifo,
-        desired_maximum_frame_latency: 2,
-        alpha_mode: CompositeAlphaMode::Auto,
-        view_formats: vec![],
-    }
-}

tests/layout_diagnostics.rs

@@ -22,30 +22,6 @@ use std::time::Instant;
 
 const OUTPUT: (f32, f32) = (1920.0, 1200.0);
 
-/// A scroll whose content fits is the same drawing in every box it still
-/// fits in, so a longer or shorter one relays out nothing. Where the content
-/// sits in that box is decided by placing its answer in the whole of it,
-/// which is a fraction of the box and holds at every length -- so the
-/// contract must not turn on the alignment. It did, and at the default
-/// alignment, which is the middle, every box change redrew the scroll.
-#[cfg(feature = "layout-diagnostics")]
-#[test]
-fn a_fitting_scroll_holds_for_every_box_its_content_fits_in() {
-    use iris::core::layout_diagnostics as diag;
-
-    for align in [Align::TOP_LEFT, Align::CENTER, Align::BOT_RIGHT] {
-        let mut harness = Harness::new((400, 200));
-        let inner = rect(Color::RED).height(50).add(&mut harness.rsc);
-        harness.set_root(inner.scrollable().align(align));
-        harness.frame();
-        let _ = diag::take();
-        // Still far longer than the 50 the content needs.
-        harness.resize((400, 180));
-        harness.frame();
-        assert_eq!(diag::take().distinct_widgets(), 0, "{align:?}");
-    }
-}
-
 #[cfg(feature = "layout-diagnostics")]
 #[test]
 fn a_selected_widget_retains_its_layout_events() {
@@ -61,8 +37,8 @@ fn a_selected_widget_retains_its_layout_events() {
     diagnostics::trace_widget(leaf.id());
     let _ = diagnostics::take();
 
-    harness.rsc.widgets_mut().mark_for_redraw(root.id());
+    let _ = harness.rsc.widgets_mut().get_dyn_mut(root.id());
-    harness.rsc.widgets_mut().mark_for_redraw(leaf.id());
+    let _ = harness.rsc.widgets_mut().get_dyn_mut(leaf.id());
     harness.frame();
 
     let report = diagnostics::take();
@@ -219,6 +195,7 @@ fn layout_cost() {
         #[cfg(feature = "layout-diagnostics")]
         let _ = iris::core::layout_diagnostics::take();
         run("cold", 1, &mut harness, |_, _| {});
+        drop(tree);
     }
 
     if selected("repaint") {
@@ -226,7 +203,7 @@ fn layout_cost() {
         trace_selected(&tree);
         let leaf = tree.ids[0];
         run("repaint", frames, &mut harness, move |harness, _| {
-            harness.rsc.widgets_mut().mark_for_redraw(leaf);
+            let _ = harness.rsc.widgets_mut().get_dyn_mut(leaf);
         });
     }
 
@@ -241,7 +218,7 @@ fn layout_cost() {
         println!("marking {} of {} widgets", dirty.len(), tree.ids.len());
         run("many", frames, &mut harness, move |harness, _| {
             for &id in &dirty {
-                harness.rsc.widgets_mut().mark_for_redraw(id);
+                harness.rsc.widgets_mut().get_dyn_mut(id);
             }
         });
     }
@@ -274,5 +251,6 @@ fn layout_cost() {
         run("resize", frames, &mut harness, |harness, frame| {
             harness.resize((OUTPUT.0 - ((frame + 1) % 2) as f32 * 8.0, OUTPUT.1));
         });
+        drop(tree);
     }
 }

tests/layout_dump.rs

@@ -11,8 +11,7 @@
 //! it is not drawn.
 
 use iris::harness::Harness;
-use iris::prelude::{Axis, Bound, SizeRule};
+use iris::random::{Edits, grow};
-use iris::random::{Edits, build, plan};
 
 fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
     std::env::var(name)
@@ -29,19 +28,7 @@ fn every_cold_layout_is_printed() {
     let mut out = String::new();
     for seed in 1..=seeds {
         let mut harness = Harness::new((1920.0, 1200.0));
-        let mut plan = plan(seed, depth, &Edits::default());
+        let (root, tree) = grow(&mut harness.rsc, seed, depth, &Edits::default());
-        if std::env::var_os("IRIS_DUMP_UNBOUNDED").is_some() {
-            plan.walk_mut(&mut |node| {
-                if let Some(rules) = &mut node.size {
-                    for axis in Axis::BOTH {
-                        if rules[axis].bound() != Bound::ANY {
-                            rules[axis] = SizeRule::Free;
-                        }
-                    }
-                }
-            });
-        }
-        let (root, tree) = build(&mut harness.rsc, &plan);
         harness.state.root = Some(root);
         harness.frame();
         for (index, id) in tree.ids.iter().enumerate() {

tests/revision_cost.rs

@@ -194,9 +194,7 @@ fn text_memory() {
         h.frame();
     }
     report("after 40 resizes");
-    // Settled: the output holds still and one leaf repaints per frame. Marked
+    // Settled: the output holds still and one leaf repaints per frame.
-    // by taking it mutably because the revision at the top of this file has no
-    // `mark_for_redraw`, and the same source has to build against both.
     for _ in 0..10 {
         let _ = h.rsc.widgets_mut().get_dyn_mut(paragraphs[0]);
         h.frame();

tests/scenario/mod.rs

@@ -13,7 +13,7 @@
 
 use iris::harness::Harness;
 use iris::prelude::*;
-use iris::random::{Edits, Kind, Plan, Rng, SpanEdit, Tree, build};
+use iris::random::{Aligns, Edits, Kind, Lens, Plan, Rng, SpanEdit, Tree, build};
 use std::collections::HashMap;
 
 /// A seed per thread but one, since a seed grows, lays out and drops its tree
@@ -190,48 +190,35 @@ impl Case {
 
 fn mark(warm: &mut Harness, tree: &Tree, step: usize) {
     for &id in tree.ids.iter().step_by(step) {
-        warm.rsc.widgets_mut().mark_for_redraw(id);
+        warm.rsc.widgets_mut().get_dyn_mut(id);
     }
 }
 
-/// A length in pixels, or a cap over one: a rule that reads the box it is
+fn a_len(rng: &mut Rng) -> Option<LayoutLen> {
-/// given is the one a resize can change the effect of without changing the
+    Some(LayoutLen::px(20.0 + rng.below(180) as f32))
-/// rule, so a tree that never grows one leaves that unexercised.
-fn a_rule(rng: &mut Rng) -> SizeRule {
-    let len = Len::px(20.0 + rng.below(180) as f32);
-    match rng.below(4) {
-        0 => SizeRule::Max(len),
-        1 => SizeRule::Min(len),
-        _ => LayoutLen::from(len).into(),
-    }
 }
 
-fn resize_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> SizeRules {
+fn resize_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Lens {
-    let lens = SizeRules {
+    let lens = [a_len(rng), a_len(rng)];
-        x: a_rule(rng),
-        y: a_rule(rng),
-    };
     warm.rsc
         .widgets_mut()
-        .set_size_rules(tree.sized[idx], lens.x.clone(), lens.y.clone());
+        .set_size_rules(tree.sized[idx], lens[0], lens[1]);
     lens
 }
 
-fn realign_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Align {
+fn realign_one(warm: &mut Harness, tree: &Tree, idx: usize, rng: &mut Rng) -> Aligns {
     let side = |rng: &mut Rng| match rng.below(4) {
         0 => None,
         1 => Some(AxisAlign::NEG),
         2 => Some(AxisAlign::CENTER),
         _ => Some(AxisAlign::POS),
     };
-    let align = Align {
+    let align = [side(rng), side(rng)];
-        x: side(rng),
-        y: side(rng),
-    };
     let id = tree.aligned[idx];
-    let taken = RegionAlign::from(align);
+    for (axis, align) in [Axis::X, Axis::Y].into_iter().zip(align) {
-    for axis in Axis::BOTH {
+        warm.rsc
-        warm.rsc.widgets_mut().set_alignment(id, axis, taken[axis]);
+            .widgets_mut()
+            .set_alignment(id, axis, align.unwrap_or_default());
     }
     align
 }
@@ -357,17 +344,9 @@ fn change(case: Case, warm: &mut Harness, tree: &mut Tree, plan: &Plan, rng: &mu
 /// buildable from what the failure printed.
 fn describe(id: WidgetId, h: &Harness) -> String {
     let rules = h.rsc.widgets().size_rules(id);
-    // A bound prints as itself: a failure is reproduced from what it printed,
+    let rule = |r: SizeRule| match r.exact() {
-    // and a rule shown as "no rule" cannot be written out again.
+        Some(len) => format!("{len}"),
-    let rule = |r: SizeRule| match r {
+        None => "-".into(),
-        SizeRule::Free => "-".into(),
-        SizeRule::Exact(len) => format!("{len}"),
-        SizeRule::Request(request) => format!("{request:?}"),
-        SizeRule::Min(min) => format!(">{}", LayoutLen::from(min)),
-        SizeRule::Max(max) => format!("<{}", LayoutLen::from(max)),
-        SizeRule::Clamp { min, max } => {
-            format!(">{}<{}", LayoutLen::from(min), LayoutLen::from(max))
-        }
     };
     let align = h.rsc.widgets().alignment(id);
     let side = |a: AxisAlign| {
@@ -384,7 +363,7 @@ fn describe(id: WidgetId, h: &Harness) -> String {
     // A rule and an alignment are properties of whatever carries them, so
     // they print with that widget rather than as widgets of their own.
     let mut out = describe_widget(id, h);
-    if rules != SizeRules::default() {
+    if (rules.x, rules.y) != (SizeRule::Free, SizeRule::Free) {
         out += &format!("[x:{},y:{}]", rule(rules.x), rule(rules.y));
     }
     if align != RegionAlign::default() {
@@ -427,8 +406,8 @@ fn describe_widget(id: WidgetId, h: &Harness) -> String {
 fn record(id: WidgetId, h: &Harness) -> String {
     let active = &h.render.active[&id];
     format!(
-        "rel_base {} region {} placement {} size {}",
+        "frame {} ask {} box {} size {}",
-        active.rel_base, active.region, active.placement, active.size,
+        active.frame, active.part, active.extent, active.size,
     )
 }
 
@@ -465,6 +444,12 @@ pub fn diverges(plan: &Plan, case: Case, seed: u64) -> Option<String> {
     cold.state.root = Some(root);
     cold.frame();
 
+    let places: HashMap<WidgetId, usize> = tree
+        .ids
+        .iter()
+        .enumerate()
+        .map(|(i, &id)| (id, i))
+        .collect();
     let mut drawn = 0;
     for (i, (&w, &c)) in tree.ids.iter().zip(&cold_tree.ids).enumerate() {
         let (got, want) = (warm.region(&w), cold.region(&c));
@@ -472,12 +457,6 @@ pub fn diverges(plan: &Plan, case: Case, seed: u64) -> Option<String> {
         if got == want {
             continue;
         }
-        let places: HashMap<WidgetId, usize> = tree
-            .ids
-            .iter()
-            .enumerate()
-            .map(|(i, &id)| (id, i))
-            .collect();
         // Where two trees disagree is rarely where the cause is, so the
         // ancestry comes with it, marking the widgets that own a region.
         let mut chain = Vec::new();

tests/suite.rs

@@ -32,6 +32,3 @@ mod tasks;
 mod text_edit;
 #[path = "cases/unsettled.rs"]
 mod unsettled;
-
-#[path = "cases/deferred.rs"]
-mod deferred;

tests/trace_unsettled.rs

@@ -1,5 +1,5 @@
-//! Traces the four-widget trees in `unsettled.rs`, to see what box their text
+//! Traces the six-widget tree in `unsettled.rs`, to see what box its text is
-//! is actually drawn in on a first frame against a settled one.
+//! actually drawn in on a first frame against a settled one.
 
 #![cfg(feature = "layout-diagnostics")]
 
@@ -9,25 +9,30 @@ use iris::prelude::*;
 
 fn plant(h: &mut Harness) -> Vec<WidgetId> {
     let plain = wtext("Wrapping").size(16).wrap(false).add(&mut h.rsc);
-    let wrapped = wtext("Wrapping shapes")
+    let wrapped = wtext("Wrapping shapes").size(16).wrap(true).add(&mut h.rsc);
-        .size(16)
+    let sized = wrapped.width(76).add(&mut h.rsc);
-        .wrap(true)
+    let aligned = sized;
-        .width(76)
-        .add(&mut h.rsc);
     h.rsc
         .widgets_mut()
-        .set_alignment(wrapped, Axis::X, AxisAlign::POS);
+        .set_alignment(sized, Axis::X, AxisAlign::POS);
     h.rsc
         .widgets_mut()
-        .set_alignment(wrapped, Axis::Y, AxisAlign::POS);
+        .set_alignment(sized, Axis::Y, AxisAlign::POS);
     let stack = Stack {
-        children: vec![plain.add_strong(&mut h.rsc), wrapped.add_strong(&mut h.rsc)],
+        children: vec![plain.add_strong(&mut h.rsc), aligned.add_strong(&mut h.rsc)],
         size: StackSize::Child(0),
     }
     .add(&mut h.rsc);
     let root = (stack,).span(Dir::RIGHT).add(&mut h.rsc);
     h.state.root = Some(root.add_strong(&mut h.rsc));
-    vec![plain.id(), wrapped.id(), stack.id(), root.id()]
+    vec![
+        plain.id(),
+        wrapped.id(),
+        sized.id(),
+        aligned.id(),
+        stack.id(),
+        root.id(),
+    ]
 }
 
 fn dump(label: &str, report: &diag::Report, text: WidgetId) {
@@ -37,12 +42,12 @@ fn dump(label: &str, report: &diag::Report, text: WidgetId) {
             TraceEvent::DrawRequest {
                 id,
                 region,
-                region_px,
+                pixel_size,
                 ..
             } if *id == text => {
                 println!(
                     "  draw in {:.2}x{:.2}  region {region:?}",
-                    region_px.x, region_px.y
+                    pixel_size.x, pixel_size.y
                 )
             }
             TraceEvent::SizeReported { id, size } if *id == text => {
@@ -76,7 +81,7 @@ fn what_box_the_text_is_drawn_in() {
 
     for _ in 0..2 {
         for &id in &ids {
-            h.rsc.widgets_mut().mark_for_redraw(id);
+            h.rsc.widgets_mut().get_dyn_mut(id);
         }
         let _ = diag::take();
         h.frame();
@@ -88,14 +93,23 @@ fn what_box_the_text_is_drawn_in() {
 fn plant_fixed(h: &mut Harness) -> Vec<WidgetId> {
     let words = "Wrapping shapes one source into as many lines as the box leaves";
     let text = wtext(words).size(16).wrap(true).add(&mut h.rsc);
+    let aligned = text;
     h.rsc
         .widgets_mut()
         .set_alignment(text, Axis::X, AxisAlign::NEG);
-    let inner = (text,).span(Dir::RIGHT).sized((189, 176)).add(&mut h.rsc);
+    let inner = (aligned,).span(Dir::RIGHT).add(&mut h.rsc);
+    let sized = inner.sized((189, 176)).add(&mut h.rsc);
     let filler = rect(Color::RED).add(&mut h.rsc);
-    let root = (filler, inner).span(Dir::RIGHT).add(&mut h.rsc);
+    let root = (filler, sized).span(Dir::RIGHT).add(&mut h.rsc);
     h.state.root = Some(root.add_strong(&mut h.rsc));
-    vec![text.id(), inner.id(), filler.id(), root.id()]
+    vec![
+        text.id(),
+        aligned.id(),
+        inner.id(),
+        sized.id(),
+        filler.id(),
+        root.id(),
+    ]
 }
 
 #[test]