Keep the step 3/4 experiment as evidence

The worker's uncommitted attempt at evaluating children in parent-decided
boxes, preserved as it stood when it stopped: separate answer-only pixel
reads, per-child drawing contracts, provisional Fill asks in Span, and an
assertion that a placed drawing hold for its answer box. The suite passes
and every generated case stops on that assertion at Text. Not the
protocol; wip/one-ask is.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

TODO

@@ -14,13 +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

core/src/layout_diagnostics.rs

@@ -32,6 +32,7 @@ pub(crate) enum Counter {
     SizeReads,
     HintHits,
     HintMisses,
+    RetainedSizeHits,
     ReuseAttempts,
     ReuseExact,
     ReuseMoved,
@@ -41,6 +42,7 @@ pub(crate) enum Counter {
     ReuseOutside,
     ReuseWrongLayer,
     ReuseWrongNode,
+    PlaceRedraws,
     QueuePops,
     DepthReads,
     LocalRedraws,
@@ -53,12 +55,12 @@ pub(crate) enum Counter {
     TextBreaks,
     GlyphPlacements,
     OutsidePinnedLen,
-    OutsideRelBase,
+    OutsideFrame,
-    OutsideRegion,
+    OutsideExtent,
 }
 
 impl Counter {
-    const COUNT: usize = Self::OutsideRegion as usize + 1;
+    const COUNT: usize = Self::OutsideExtent as usize + 1;
 
     const NAMES: [&'static str; Self::COUNT] = [
         "updates",
@@ -68,6 +70,7 @@ impl Counter {
         "draw-result size reads",
         "hint hits",
         "hint misses",
+        "retained size hits",
         "reuse attempts",
         "reuse exact",
         "reuse moved",
@@ -77,6 +80,7 @@ impl Counter {
         "reuse: outside what it holds for",
         "reuse: another layer",
         "reuse: region-node choice changed",
+        "placed by redrawing",
         "redraw queue pops",
         "depth reads",
         "local redraws",
@@ -89,8 +93,8 @@ impl Counter {
         "text line breaks",
         "glyph placements",
         "reuse outside: the length it was pinned to",
-        "reuse outside: a rel base",
+        "reuse outside: a frame length",
-        "reuse outside: a region length",
+        "reuse outside: an extent length",
     ];
 }
 

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,4 +1,3 @@
-use crate::util::impl_axis_index;
 use crate::{Px, Rel};
 
 use super::*;
@@ -90,6 +89,20 @@ impl RegionAlign {
         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 {
@@ -218,5 +231,3 @@ impl RegionAlign {
         UiVec2::from(self)
     }
 }
-
-impl_axis_index!(RegionAlign => 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)]
@@ -54,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),
@@ -63,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 {
@@ -121,6 +148,3 @@ impl<T> BothAxis<T> {
         }
     }
 }
-
-impl_axis_index!({const SHIFT: u32} FixedVec2<SHIFT> => Fixed<SHIFT>);
-impl_axis_index!(Vec2 => f32);

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)]
@@ -119,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 {
@@ -145,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,
@@ -251,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 {
@@ -281,15 +294,6 @@ 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
     }
@@ -344,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(),
@@ -444,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/ui/active.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Declared, LayerId, LayoutHolds, MaskIdx, MoveIdx, PlaceDesc, RegionAlign, RetainedPrimitive,
+    LayerId, LayoutHolds, LayoutLen, MaskIdx, MoveIdx, Place, RegionAlign, RetainedPrimitive, Size,
-    Size, TextureHandle, UiRegion, UiVec2, WidgetId,
+    TextureHandle, UiRegion, WidgetId,
 };
 
 /// What is kept of a widget its parent has asked about. `drawn` says whether
@@ -9,34 +9,35 @@ use crate::{
 #[derive(Debug)]
 pub struct ActiveData {
     pub id: WidgetId,
-    /// Where its drawing goes, in its region node's coordinates.
+    /// Its frame in `parent_move`'s coordinates: what a fraction it declares
-    pub placement: UiRegion,
+    /// or reports is a fraction of, composed. Everything it draws sits inside
-    /// What a fraction declared or reported under this widget is a fraction
+    /// this by way of `extent`.
-    /// of, as a length of the window.
+    pub frame_abs: UiRegion,
-    pub rel_base: UiVec2,
+    /// Where its drawing goes, in the frame's own coordinates.
-    /// Where its drawing was put, and where it was asked. The two differ
+    pub extent: UiRegion,
-    /// where a container asks in one place and puts the answer in another --
+    /// That frame in its parent's frame coordinates, before composition:
-    /// a row measures from its cursor and puts the child in its slot. Each
+    /// forwarded whole by a transparent container, narrowed by a declared
-    /// carries the rel base that ask stated, so asking again from either is
+    /// length. Its length is the same on every ask, which is what
-    /// the same question it was.
+    /// a local redraw relies on to ask its parent's own question again.
-    pub placed: PlaceDesc,
+    pub frame: UiRegion,
-    pub asked: PlaceDesc,
+    /// What of its parent's extent the drawing was given, and what it was
-    /// The box it was asked in, in the parent's region-node coordinates: the
+    /// given at the parent's first ask of it -- the question a cold layout
-    /// box its drawing was made in and the one its contract is about. Its
+    /// asks. A part is a length from the extent's start, so an extent that
-    /// drawing is placed elsewhere by re-expression, never by asking again.
+    /// moved re-places every child by re-adding that start.
-    pub region: UiRegion,
+    pub place: [Place; 2],
+    pub offer_place: [Place; 2],
+    /// The box that ask gave it, in its frame's coordinates. Kept rather
+    /// than worked out again from where its parent's own box is now: a
+    /// parent drawn again in the box its own answer chose gives its children
+    /// boxes it never measured anything in, and the measurement this widget
+    /// answered is the one its parent's layout was built on.
+    pub offer_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<(Size, LayoutHolds)>,
-    /// Asked more than once in its parent's last draw -- measured in one box
+    /// What the widget said it used of its frame, the last time it drew.
-    /// 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
-    /// parent can ask either again.
-    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 frame and extent reads that this drawing holds for.
-    /// rel base and region it pinned.
     pub holds: LayoutHolds,
     pub drawn: bool,
     pub parent: Option<WidgetId>,
@@ -46,9 +47,8 @@ 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>,
     /// The children whose size this widget read while drawing.
@@ -56,15 +56,14 @@ pub struct ActiveData {
     /// 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 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 `frame_abs` uses.
-    /// widget 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.
@@ -78,10 +77,20 @@ pub struct ActiveData {
 }
 
 impl ActiveData {
-    /// What it answered when its parent asked, where it has been asked at
+    /// What it answered when its parent measured it, where it has been
-    /// all. Not `size`, which is what its last drawing reported: a drawing
+    /// measured at all. Not `size`, which is what its last drawing reported:
-    /// re-expressed in the box that answer chose is not a second answer.
+    /// a drawing made in the box that answer chose is answering a different
+    /// question.
     pub fn measured(&self) -> Option<Size> {
         self.answer.map(|(size, _)| size)
     }
+
+    /// Whether what it answered still stands for a frame of these pixel
+    /// lengths. The answer was given in the box its parent first asked
+    /// about, which is what it is checked against -- `holds` on the record
+    /// is about the box the answer then chose.
+    pub fn answers_at(&self, px: crate::PxVec2, part: UiRegion) -> bool {
+        self.answer
+            .is_some_and(|(_, holds)| holds.contains(px, part))
+    }
 }

core/src/ui/holds.rs

@@ -33,12 +33,6 @@ 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
-    /// 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),

core/src/ui/layout_holds.rs

@@ -1,109 +1,63 @@
-use crate::util::impl_axis_index;
+use crate::{Axis, Holds, Len, PxVec2, UiRegion};
-use crate::{Axis, Holds, Len, Px, PxVec2, UiRegion, UiVec2};
 
 const AXES: [Axis; 2] = [Axis::X, Axis::Y];
 
-/// What one evaluation of a widget depends on along one axis: the window
+/// What one evaluation of a widget depends on: the pixel lengths of its
-/// lengths its reads hold for, the pixel lengths of its own box, and the
+/// frame and of its own box that its drawing and its answer hold for, and
-/// symbolic lengths of that box and of its rel base where either one is what
+/// the symbolic length of its own box where it read one.
-/// it was expressed in.
 ///
-/// The symbolic lengths are pins rather than ranges: a container places its
+/// The symbolic length is a pin rather than a range: 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
+/// is. It reaches the parent only where the box it pinned is the parent's
-/// parent's own; anywhere else the parent chose that length itself, and a
+/// own; anywhere else the parent chose that length itself, and a widget
-/// widget pinned this way is checked when it is re-placed.
+/// 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,
-/// which is a different length wherever the rel base 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
-/// whatever the rel base 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 frame: [Holds; 2],
-    pub y: AxisHolds,
+    pub extent: [Holds; 2],
+    pub extent_len: [Option<Len>; 2],
 }
 
 impl LayoutHolds {
     pub const ANY: Self = Self {
-        x: AxisHolds::ANY,
+        frame: [Holds::ANY; 2],
-        y: AxisHolds::ANY,
+        extent: [Holds::ANY; 2],
+        extent_len: [None; 2],
     };
 
     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.frame[n] = self.frame[n].and(other.frame[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]
+            );
+            result.extent_len[n] = self.extent_len[n].or(other.extent_len[n]);
         }
+        result
     }
 
     pub fn covers(self, other: Self) -> bool {
-        self.x.covers(other.x) && self.y.covers(other.y)
+        (0..2).all(|n| {
+            self.frame[n].lo <= other.frame[n].lo
+                && self.frame[n].hi >= other.frame[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))
+        })
     }
 
-    pub fn contains(self, window: PxVec2, rel_base: UiVec2, region: UiRegion) -> bool {
+    pub fn contains(self, px: PxVec2, extent: UiRegion) -> bool {
-        AXES.into_iter()
+        AXES.into_iter().all(|axis| {
-            .all(|axis| self[axis].contains(window[axis], rel_base[axis], region[axis].len()))
+            let n = axis as usize;
+            let len = extent.axis(axis).len();
+            self.frame[n].contains(px.axis(axis))
+                && self.extent[n].contains(len.to_px(px.axis(axis)))
+                && self.extent_len[n].is_none_or(|pinned| pinned == len)
+        })
     }
 }
-
-impl_axis_index!(LayoutHolds => AxisHolds);

core/src/ui/painter.rs

@@ -1,14 +1,14 @@
 #[cfg(feature = "layout-diagnostics")]
 use crate::layout_diagnostics::{self as diag, Counter};
 use crate::{
-    Axis, Declared, Holds, LayoutHolds, LayoutLen, Len, PlaceDesc, Px, PxVec2, RegionAlign, Rel,
+    Axis, Holds, LayoutHolds, LayoutLen, Len, Part, Place, Px, PxVec2, RegionAlign, RenderedText,
-    RenderedText, RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData,
+    RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData, TextureHandle,
-    TextureHandle, UiRegion, UiRenderState, UiRsc, UiVec2, Weight, WidgetId, Widgets,
+    UiRegion, UiRenderState, UiRsc, UiSpan, UiVec2, Weight, WidgetId, Widgets,
     render::{
         GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveInst, PrimitiveKind,
         TexturePrimitive,
     },
-    ui::render_state::{DrawInfo, Placing},
+    ui::render_state::DrawInfo,
 };
 const AXES: [Axis; 2] = [Axis::X, Axis::Y];
 
@@ -17,36 +17,56 @@ pub struct Painter<'a> {
     pub(super) state: &'a mut UiRenderState,
     pub(super) rsc: &'a mut dyn UiRsc,
 
-    /// This widget's rel base, per axis: a length of the window, and what a
+    /// What a fraction this widget declares or reports is a fraction of, in
-    /// fraction it or anything under it declares or reports is a fraction
+    /// the coordinates of `move_idx`: forwarded from its parent unchanged
-    /// of. A length rather than a box, so padding can take from both the
+    /// through a span, a stack or a scroll, and narrowed only by what was
-    /// rel base and the box without either becoming the other.
+    /// decided above it -- a declared length, or the root. Its length
-    pub(super) rel_base: UiVec2,
+    /// is the same on every ask of the widget, which is what keeps a fraction
-    /// The box this widget was asked in, in its region node's coordinates:
+    /// under it from being resolved twice.
-    /// what it draws in, and what its children's places are parts of.
+    pub(super) frame: UiRegion,
-    pub(super) region: UiRegion,
+    /// Where this widget's drawing goes, in the frame's own coordinates.
-    /// The window in pixels. Frames and boxes become pixels against this one
+    /// Everything it writes is in these coordinates, and its children are
-    /// unit, regardless of region-node boundaries.
+    /// placed as parts of it.
-    pub(super) window: PxVec2,
+    pub(super) extent: UiRegion,
+    /// The extent's symbolic length where this draw read it, which makes the
+    /// drawing one that holds for that length alone -- the way reading a
+    /// length in pixels makes it hold for that number of pixels.
+    pub(super) extent_len: [Option<Len>; 2],
+    /// Symbolic box lengths read only to compute the answer. A container can
+    /// replace the provisional drawings used for that answer with drawings
+    /// in decided boxes, so this contract is independent of the final one.
+    pub(super) answer_extent_len: [Option<Len>; 2],
+    /// The frame in pixels, which its children's frames are a length of:
+    /// threaded down rather than composed back up the chain, so every length
+    /// in layout is one multiply from its parent's and [`Holds::through`]
+    /// inverts exactly that.
+    pub(super) px: PxVec2,
     pub(super) mask: MaskIdx,
     pub(super) textures: Vec<TextureHandle>,
     pub(super) primitives: Vec<RetainedPrimitive>,
     pub(super) mask_region: Option<UiRegion>,
-    /// The previous drawing's owned mask, available for this draw to reclaim.
-    pub(super) mask_slot: Option<MaskIdx>,
     /// Only children whose answers were read constrain this widget's answer.
     pub(super) answer_under: LayoutHolds,
     pub(super) children: Vec<WidgetId>,
+    /// The children asked about so far, so the first place each was asked in
+    /// is the one recorded as its offer.
+    pub(super) offered: Vec<WidgetId>,
+    /// Whether this draw is at the place its parent first asked about, which
+    /// makes the questions it asks the ones a cold layout asks and their
+    /// answers the ones to keep.
+    pub(super) at_offer: bool,
     /// The children whose size this widget read while drawing.
     pub(super) size_deps: Vec<WidgetId>,
-    /// What this draw itself reads, as against what its children's drawings
+    /// What this draw itself read of its frame in pixels, per axis: every
-    /// hold for: every window and every length of its own region until it
+    /// length until it reads one, then that one, unless it says otherwise.
-    /// reads one, then that one unless it says otherwise, and the rel base or
+    pub(super) frame_own: [Holds; 2],
-    /// region length it read symbolically, each of which makes the drawing
+    /// The same for its own box.
-    /// hold for that length alone.
+    pub(super) extent_own: [Holds; 2],
-    pub(super) own: LayoutHolds,
+    /// Pixel-box dependencies used only to compute the answer. These do not
-    /// What each child's drawing depends on. Asking a child again replaces
+    /// constrain a retained drawing placed inside that answer.
-    /// its drawing, so it replaces this too rather than narrowing it.
+    pub(super) answer_extent_own: [Holds; 2],
+    /// The final drawing kept for each child. Asking one child again replaces
+    /// its provisional drawing and therefore replaces this contract too.
     pub(super) under: Vec<(WidgetId, LayoutHolds)>,
     /// The movable region this widget's primitives are positioned through:
     /// its own when opted in, otherwise the nearest ancestor's.
@@ -70,10 +90,12 @@ impl<'a> Painter<'a> {
         self.write_resolved(kind, primitive, region, self.resolve(region));
     }
 
-    /// A box in this widget's region, composed into its region node's
+    /// A box in this widget's extent coordinates, composed into the
-    /// coordinates.
+    /// coordinates its move slot is in: through the extent, then through the
+    /// frame the extent is a part of. The same two steps a recomposition
+    /// replays, so a moved drawing lands where a cold one does.
     fn resolve(&self, region: UiRegion) -> UiRegion {
-        region.within(&self.region)
+        region.within(&self.extent).within(&self.frame)
     }
 
     fn write_resolved<P: Primitive>(
@@ -101,6 +123,7 @@ impl<'a> Painter<'a> {
 
     fn push_primitive(&mut self, h: RetainedPrimitive) {
         if self.mask != MaskIdx::NONE {
+            // TODO: I have no clue if this works at all :joy:
             self.rsc.ui_mut().masks.push_ref(self.mask);
         }
         self.primitives.push(h);
@@ -125,79 +148,74 @@ impl<'a> Painter<'a> {
         assert!(self.mask == MaskIdx::NONE);
         let resolved = self.resolve(region);
         let move_idx = self.move_idx;
-        let mask = Mask {
+        self.mask = self.rsc.ui_mut().masks.push(Mask {
             region: resolved,
             move_idx,
-        };
+        });
-        let masks = &mut self.rsc.ui_mut().masks;
-        self.mask = match self.mask_slot.take() {
-            Some(idx) => {
-                *masks.get_mut(idx) = mask;
-                idx
-            }
-            None => {
-                let idx = masks.push(mask);
-                // The owner keeps the slot alive even with no primitives.
-                masks.push_ref(idx);
-                idx
-            }
-        };
     }
 
-    /// Draws a widget in the whole of this widget's own box, with the rel
+    /// Draws a widget in the whole of this widget's own box, with the frame
-    /// base forwarded unchanged: what a container that is only a wrapper
+    /// forwarded unchanged: what a container that is only a wrapper around
-    /// around one child wants.
+    /// one child wants, and what every transparent container passes for the
+    /// frame.
     pub fn widget<'s, W: ?Sized>(&'s mut self, id: &'s StrongWidget<W>) -> DrawResult<'s, 'a, W> {
-        self.widget_at(id, UiRegion::FULL)
+        self.widget_at(id, UiRegion::FULL, [Place::Within(Part::All); 2])
     }
 
-    /// Resolves what the place says about the child's rel base into a length,
+    /// Draws a child, saying what its fractions are of and where its drawing
-    /// where that is this widget's own narrowed the way the region is. An
+    /// goes.
-    /// axis the region leaves whole is not read at all, so a wrapper that
-    /// only moves its child does not pin its drawing to a rel base.
-    fn state_rel_base(&mut self, mut place: PlaceDesc) -> PlaceDesc {
-        for axis in AXES {
-            if let Some(span) = place[axis].narrows_rel_base() {
-                let len = span.len();
-                let stated = (len != Len::FULL).then(|| len.within_len(self.rel_base(axis)));
-                place[axis] = place[axis].with_rel_base(stated);
-            }
-        }
-        place
-    }
-
-    /// Asks a child, saying what its fractions are of and where it is asked.
     ///
-    /// `place` says where the child goes and what its fractions are of:
+    /// `frame` is that reference, in this widget's own frame coordinates:
-    /// see [`PlaceDesc`]. A `UiRegion` converts into the common case, which
+    /// [`UiRegion::FULL`] forwards this widget's frame, which is what a
-    /// is a box of this widget's own with the answer placed inside it.
+    /// container that only divides room passes, so a fraction under it means
+    /// the same wherever it sits and however deeply it is nested. Narrowing
+    /// it is for what is decided from above, and a declared length narrows
+    /// it here.
     ///
-    /// The child draws once, in the region that comes of it, and its answer
+    /// `place` is where the drawing goes, per axis, as a part of this
-    /// is placed inside that region by re-expressing the drawing. Nothing is
+    /// widget's extent: see [`Place`]. A narrowed frame is its own extent,
-    /// drawn again in a box an answer chose; a container that puts the
+    /// since the narrowing is what said where the drawing goes.
-    /// answer somewhere else says so with [`Self::place_at`].
     pub fn widget_at<'s, W: ?Sized>(
         &'s mut self,
         id: &'s StrongWidget<W>,
-        place: impl Into<PlaceDesc>,
+        frame: UiRegion,
+        place: [Place; 2],
     ) -> DrawResult<'s, 'a, W> {
-        let place = self.state_rel_base(place.into());
         let region_node = self.rsc.widgets().is_region_node(id.id());
         let declared = self.declared_lens(id);
         let align = self.rsc.widgets().alignment(id.id());
-        let (rel_base, region) =
+        let (local, extent) = frame_and_extent(
-            place.rel_base_and_region(self.region, self.rel_base, declared, align);
+            frame,
+            part_of(self.extent, place),
+            narrowed_by(declared, frame),
+            align,
+        );
+        let within = match local == UiRegion::FULL {
+            true => self.frame,
+            false => local.within(&self.frame),
+        };
         #[cfg(feature = "layout-diagnostics")]
         if region_node {
             diag::bump(Counter::RegionNodeDraws);
-            diag::region_node(id.id(), self.id, region);
+            diag::region_node(id.id(), self.id, within);
         }
         // A child listed twice would be moved twice.
-        let re_asked = self.children.contains(&id.id());
+        if !self.children.contains(&id.id()) {
-        if !re_asked {
             self.children.push(id.id());
         }
-        let px = rel_base.to_px(self.window);
+        let first_ask = self.offer(id.id());
+        let offer_place = if first_ask {
+            place
+        } else {
+            self.state
+                .active
+                .get(&id.id())
+                .map_or(place, |a| a.offer_place)
+        };
+        let px = local.size().to_px(self.px);
+        // The answer and what it holds for, both about the place asked in.
+        // The child's record may say something else once its drawing has been
+        // placed: a drawing made again in its placed box holds for that box.
         let (size, answer_holds, holds) = self.state.draw_inner(
             id.id(),
             DrawInfo {
@@ -207,18 +225,18 @@ impl<'a> Painter<'a> {
                 parent_move: self.move_idx,
                 region_node,
                 mask: self.mask,
-                rel_base,
+                frame: local,
-                region,
+                frame_abs: within,
-                placed: place,
+                part: extent,
-                asked: place,
+                place,
-                re_asked,
+                offer_place,
                 px,
             },
             None,
             self.rsc,
         );
-        let holds = self.in_parent(holds, region, place, declared);
+        let compose = |holds| in_parent(holds, local, extent, place, declared);
-        let answer_holds = self.in_parent(answer_holds, region, place, declared);
+        let holds = compose(holds);
         match self.under.iter_mut().find(|(child, _)| *child == id.id()) {
             Some((_, kept)) => *kept = holds,
             None => self.under.push((id.id(), holds)),
@@ -226,8 +244,8 @@ impl<'a> Painter<'a> {
         DrawResult {
             child: id,
             painter: self,
-            size,
+            size: in_parent_frame(size, local.size(), declared),
-            answer_holds,
+            answer_holds: compose(answer_holds),
         }
     }
 
@@ -240,96 +258,53 @@ impl<'a> Painter<'a> {
         self.state.undraw_rec(id.id(), self.rsc);
     }
 
-    /// Puts a child in `place` of this widget's box, where that box is the
-    /// answer the child already gave: the drawing is re-expressed there
-    /// rather than made again -- what a row does once it knows every slot,
-    /// having measured each child from its cursor.
-    ///
-    /// A child this draw has not asked about, and one whose rel base this
-    /// narrows, is asked here instead: there is no answer to re-express, or
-    /// the question has changed. So a container that places every child the
-    /// same way says it once, and which of the two happens is this widget's
-    /// business rather than the caller's.
-    pub fn place_at<'s, W: ?Sized>(
-        &'s mut self,
-        id: &'s StrongWidget<W>,
-        place: impl Into<PlaceDesc>,
-    ) -> DrawResult<'s, 'a, W> {
-        let place = self.state_rel_base(place.into());
-        let states_rel_base = AXES
-            .iter()
-            .any(|&axis| place[axis].stated_rel_base().is_some());
-        if states_rel_base || !self.children.contains(&id.id()) {
-            return self.widget_at(id, place);
-        }
-        let at = self.placing();
-        self.state.place_in(id.id(), &at, place, self.rsc);
-        let active = &self.state.active[&id.id()];
-        let size = active.measured().unwrap_or(active.size);
-        DrawResult {
-            child: id,
-            painter: self,
-            size,
-            // Read where it was asked; moving it is not a second answer.
-            answer_holds: LayoutHolds::ANY,
-        }
-    }
-
-    /// This widget as the thing its children are placed within.
-    fn placing(&self) -> Placing {
-        Placing {
-            id: self.id,
-            region: self.region,
-            rel_base: self.rel_base,
-            window: self.window,
-            depth: self.depth,
-            move_idx: self.move_idx,
-            mask: self.mask,
-        }
-    }
-
     /// What a widget's rules declare its lengths to be, which whoever draws
-    /// it resolves into its rel base. Reading them depends on nothing -- the box
+    /// it resolves into its frame. Reading them depends on nothing -- the box
     /// that comes of them is kept on the child, and `redraw` compares it
     /// there.
-    fn declared_lens<W: ?Sized>(&self, id: &StrongWidget<W>) -> Declared {
+    fn declared_lens<W: ?Sized>(&self, id: &StrongWidget<W>) -> [Option<LayoutLen>; 2] {
-        self.rsc.widgets().declared_lens(id.id())
+        declared_lens(self.rsc.widgets(), id.id())
     }
 
-    /// What a child says its length is without being drawn, if it can say,
+    /// What a child says its length is without being drawn, if it can say.
-    /// as the length its draw would report: a fraction in it is resolved
+    /// Asking counts as reading its size.
-    /// against this widget's rel base, which is the rel base a child asked with
-    /// nothing narrowed gets. Asking counts as reading its size.
     pub fn size_hint<W: ?Sized>(&mut self, id: &StrongWidget<W>, axis: Axis) -> Option<LayoutLen> {
         let widgets = self.rsc.widgets();
         // A rule is the answer where there is one: it wins over whatever the
         // widget would draw, so it has to win over what the widget says too.
-        let hint = widgets.size_rules(id.id())[axis].exact().or_else(|| {
+        let hint = widgets.size_rules(id.id()).axis(axis).exact().or_else(|| {
             widgets
                 .get_dyn(id.id())
                 .and_then(|widget| widget.size_hint(axis))
         });
-        let rel_base = self.rel_base[axis];
-        let resolved = hint.map(|hint| hint.within_len(rel_base));
         #[cfg(feature = "layout-diagnostics")]
-        {
+        diag::hint_read(id.id(), self.id, axis, hint);
-            diag::hint_read(id.id(), self.id, axis, resolved);
+        match hint {
-            diag::bump(match resolved {
+            Some(hint) => {
-                Some(_) => Counter::HintHits,
+                #[cfg(feature = "layout-diagnostics")]
-                None => Counter::HintMisses,
+                diag::bump(Counter::HintHits);
-            });
-        }
-        if let Some(hint) = hint {
                 self.depend_on(id);
-            // Resolving a fraction against this rel base makes this draw a
+                Some(hint)
-            // function of the rel base's length. The fraction to ask about is
+            }
-            // the child's own: resolved against a rel base of pixels, none is
+            None => {
-            // left to see it by.
+                #[cfg(feature = "layout-diagnostics")]
-            if hint.rel != Rel::ZERO {
+                diag::bump(Counter::HintMisses);
-                self.own[axis].rel_base = Some(rel_base);
+                None
             }
         }
-        resolved
+    }
+
+    /// Whether this is the first box a child is asked about in during a draw
+    /// that is itself the one its parent measured -- the question a cold
+    /// layout asks, whose answer is the one to keep. A drawing made again in
+    /// a box chosen from an answer asks about that box instead, and what it
+    /// hears back is not a measurement of anything.
+    fn offer(&mut self, child: WidgetId) -> bool {
+        if !self.at_offer || self.offered.contains(&child) {
+            return false;
+        }
+        self.offered.push(child);
+        true
     }
 
     fn depend_on<W: ?Sized>(&mut self, child: &StrongWidget<W>) {
@@ -350,11 +325,11 @@ impl<'a> Painter<'a> {
         ui.text.render(buffer, attrs, width)
     }
 
-    /// Writes glyphs in the selected rel base or region coordinates.
+    /// Writes glyphs in the selected frame or extent coordinates.
     // TODO: merge the text methods into the primitive ones.
     pub fn glyphs(&mut self, text: &RenderedText, origin: UiRegion) {
         // Glyph offsets and sizes are pixels, which compose additively.
-        // Only the shared origin needs composing through the region.
+        // Only the shared origin needs composing through the extent.
         let resolved = self.resolve(origin);
         let kind = self.rsc.ui_mut().primitives.kind::<GlyphPrimitive>();
         for glyph in text.glyphs.iter() {
@@ -386,28 +361,39 @@ impl<'a> Painter<'a> {
     }
 
     /// The symbolic length of this widget's own box along one axis, in the
-    /// lengths of its rel base that it places its children in. Reading it pins
+    /// lengths of its frame that it places its children in. Reading it pins
     /// the drawing to that length -- and to nothing about where the box
     /// starts, which is what lets a container move without being drawn
     /// again. One axis at a time, because a container that divides one axis
     /// holds for any length of the other.
-    pub fn region_len(&mut self, axis: Axis) -> Len {
+    pub fn extent_len(&mut self, axis: Axis) -> Len {
-        let len = self.region[axis].len();
+        let len = self.extent.axis(axis).len();
-        self.own[axis].region_len = Some(len);
+        self.extent_len[axis as usize] = Some(len);
+        self.answer_extent_len[axis as usize] = Some(len);
         len
     }
 
-    /// This widget's rel base along one axis: what a fraction it or anything
+    /// The symbolic length used to compute this widget's answer, where the
-    /// under it declares or reports is a fraction of. A container reads it
+    /// final drawing itself is rebuilt without depending on that length.
-    /// to hand a length of it down -- padding, which takes its pixels off.
+    pub fn answer_extent_len(&mut self, axis: Axis) -> Len {
-    /// Reading it pins the drawing to that rel base, the way
+        let len = self.extent.axis(axis).len();
-    /// [`Self::region_len`] pins it to the box.
+        self.answer_extent_len[axis as usize] = Some(len);
-    pub fn rel_base(&mut self, axis: Axis) -> Len {
-        let len = self.rel_base[axis];
-        self.own[axis].rel_base = Some(len);
         len
     }
 
+    /// Says that the final drawing uses a symbolic length already read for
+    /// the answer.
+    pub fn drawing_uses_extent_len(&mut self, axis: Axis, len: Len) {
+        debug_assert_eq!(self.extent.axis(axis).len(), len);
+        self.extent_len[axis as usize] = Some(len);
+    }
+
+    /// A part of this widget's box, expressed in its frame coordinates so it
+    /// can be used as a child frame decided here.
+    pub fn extent_part(&self, axis: Axis, part: Part) -> UiSpan {
+        part.of(*self.extent.axis(axis))
+    }
+
     /// Where this widget sits in a box longer than the length it takes. A
     /// widget that positions its own content reads it to place that content
     /// the way the box around it would have placed the widget.
@@ -425,7 +411,10 @@ impl<'a> Painter<'a> {
     /// worth anything, since reading one is also what makes its own size
     /// depend on it.
     pub fn has_exact_size(&self, axis: Axis) -> bool {
-        self.rsc.widgets().size_rules(self.id)[axis]
+        self.rsc
+            .widgets()
+            .size_rules(self.id)
+            .axis(axis)
             .exact()
             .is_some()
     }
@@ -436,16 +425,35 @@ impl<'a> Painter<'a> {
         PxVec2::new(self.px_len(Axis::X), self.px_len(Axis::Y))
     }
 
+    /// This widget's own box in pixels, used only to compute its answer.
+    pub fn answer_px_size(&mut self) -> PxVec2 {
+        PxVec2::new(
+            self.answer_px_len(Axis::X),
+            self.answer_px_len(Axis::Y),
+        )
+    }
+
     /// One axis of this widget's own box in pixels. Prefer this to
     /// [`Self::px_size`] when the other axis cannot affect the drawing.
     pub fn px_len(&mut self, axis: Axis) -> Px {
-        let len = self.region[axis].len();
+        let part = self.extent.axis(axis).len();
-        let px = len.to_px(self.window[axis]);
+        let len = part.to_px(self.px.axis(axis));
-        let own = &mut self.own[axis].region;
+        let own = &mut self.extent_own[axis as usize];
         if *own == Holds::ANY {
-            *own = Holds::at(px);
+            *own = Holds::at(len);
         }
-        px
+        len
+    }
+
+    /// One pixel length used only to compute this widget's answer. The final
+    /// drawing may be retained when that answer is placed in another box.
+    pub fn answer_px_len(&mut self, axis: Axis) -> Px {
+        let len = self.extent.axis(axis).len().to_px(self.px.axis(axis));
+        let own = &mut self.answer_extent_own[axis as usize];
+        if *own == Holds::ANY {
+            *own = Holds::at(len);
+        }
+        len
     }
 
     /// The lengths of this widget's own box on `axis` that what it is drawing
@@ -453,45 +461,41 @@ impl<'a> Painter<'a> {
     /// of the box, and the same reported size. A widget that read its length
     /// in pixels holds for that one alone until it says otherwise.
     pub fn holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
-        let len = self.region[axis].len();
+        let part = self.extent.axis(axis).len();
         let holds = holds.into();
         debug_assert!(
-            holds.contains(len.to_px(self.window[axis])),
+            holds.contains(part.to_px(self.px.axis(axis))),
             "'{}' ({:?}) says its drawing holds for lengths that leave out its own box",
             self.label(),
             self.id
         );
-        self.own[axis].region = holds;
+        self.extent_own[axis as usize] = holds;
     }
 
-    /// A window length in pixels, which is what every length in layout is
+    /// One axis of this widget's frame in pixels -- what a fraction of its
-    /// measured in. Reading one pins the drawing to this window wherever the
+    /// area resolves against, and so what a container divides among its
-    /// length is a fraction of it; one that is only pixels is that many
+    /// children. Its own box is a part of this one.
-    /// pixels in any window and pins nothing.
+    pub fn frame_px_len(&mut self, axis: Axis) -> Px {
-    pub fn to_px(&mut self, len: Len, axis: Axis) -> Px {
+        let len = self.px.axis(axis);
-        let window = self.window[axis];
+        let own = &mut self.frame_own[axis as usize];
-        if len.rel != Rel::ZERO {
-            let own = &mut self.own[axis].window;
         if *own == Holds::ANY {
-                *own = Holds::at(window);
+            *own = Holds::at(len);
         }
-        }
+        len
-        len.to_px(window)
     }
 
-    /// The windows this drawing holds for, stated rather than taken: a
+    /// [`Self::holds`] stated about the frame rather than about this
-    /// container that branched on a length in pixels says which side of the
+    /// widget's own box, for a container whose drawing turns on what its
-    /// boundary it was on, which is wider than the one window reading that
+    /// fractions are of rather than on the part of it it took.
-    /// length pins, and replaces it.
+    pub fn frame_holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
-    pub fn window_holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
         let holds = holds.into();
         debug_assert!(
-            holds.contains(self.window[axis]),
+            holds.contains(self.px.axis(axis)),
-            "'{}' ({:?}) says its drawing holds for windows that leave out this one",
+            "'{}' ({:?}) says its drawing holds for lengths that leave out its frame",
             self.label(),
             self.id
         );
-        self.own[axis].window = holds;
+        self.frame_own[axis as usize] = holds;
     }
 
     pub fn text_data(&mut self) -> &mut TextData {
@@ -550,7 +554,7 @@ impl<W: ?Sized> DrawResult<'_, '_, W> {
     }
 
     pub fn len(self, axis: Axis) -> LayoutLen {
-        self.size()[axis]
+        self.size().axis(axis)
     }
 }
 
@@ -579,164 +583,187 @@ impl PrimitiveLike for &TextureHandle {
     }
 }
 
-/// Moves what a child depends on into this widget's own terms: this
+/// What a child depends on, said about the boxes the widget that drew it
-/// method's `impl` block is where a `Painter`'s own boxes are, so it takes
+/// has rather than the ones the child was given.
-/// only what the child was asked with.
+///
-impl Painter<'_> {
+/// `frame` is the child's frame in this widget's frame coordinates and
-    /// Window ranges are already about the one unit and combine directly.
+/// `extent` the box it was given, in the child's own frame coordinates. Both
-    /// A rel base pin becomes this widget's own rel base wherever a length of it
+/// reach it as one length, so what it holds for maps back through that
-    /// is what reached the child; where only pixels did, no length of this
+/// length exactly -- and where the box it was given is this widget's own,
-    /// rel base can change the child's and the pin stops here.
+/// what it says about that box is what this widget can say about its own.
-    ///
+pub(crate) fn in_parent(
-    /// A child's validity maps back through the part of this widget's box,
-    /// where the box the child was asked in is that part; a declared length
-    /// places the box inside the part instead, and then only that length
-    /// reaches the child. A narrowed rel base is not one of these: it decides
-    /// what fractions under the child mean and leaves the box the part it
-    /// was given.
-    fn in_parent(
-        &self,
     holds: LayoutHolds,
-        region: UiRegion,
+    frame: UiRegion,
-        place: PlaceDesc,
+    extent: UiRegion,
-        declared: Declared,
+    place: [Place; 2],
-    ) -> LayoutHolds {
+    declared: [Option<LayoutLen>; 2],
+) -> LayoutHolds {
     let mut result = LayoutHolds::ANY;
     for axis in AXES {
-            let declared = declared[axis];
+        let n = axis as usize;
-            let holds = holds[axis];
+        let frame_len = frame.axis(axis).len();
-            let result = &mut result[axis];
+        result.frame[n] = holds.frame[n].through(frame_len);
-            // Every read became pixels against the window, so a range on
+        match (place[n].part(), declared[n]) {
-            // it is already in this widget's terms.
+            // Its box is this widget's own, or a part of it in that box's
-            result.window = holds.window;
+            // own lengths: so what it holds for is a range on this widget's
-            let at = place[axis];
+            // own box, which is what lets that box move without a redraw. A
-            let reaches = at.stated_rel_base().is_none()
+            // length it pinned is this widget's length wherever the part is
-                && !at.is_sized()
+            // the whole of it, and pins the same way.
-                && declared.is_none_or(|len| len.rel != Rel::ZERO);
+            (Part::All, None) if *frame.axis(axis) == UiSpan::FULL => {
-            result.rel_base = holds.rel_base.and(reaches.then(|| self.rel_base[axis]));
+                result.extent[n] = holds.extent[n];
-            match (at.within_span(), declared.is_some()) {
+                result.extent_len[n] = holds.extent_len[n];
-                // Its box is a part of this widget's own box, in that box's
-                // own lengths, so what it holds for maps back through that
-                // part into a range on this widget's box. A length it pinned
-                // is this widget's length less the part's pixels where the
-                // part is the whole of the box less pixels, which is the one
-                // shape that inverts exactly; any other part pins this
-                // widget's own length.
-                (Some(span), false) => {
-                    let part_len = span.len();
-                    result.region = holds.region.through(part_len);
-                    result.region_len = holds.region_len.map(|pinned| match part_len.rel {
-                        Rel::ONE => pinned - Len::from_parts(Rel::ZERO, part_len.px),
-                        _ => self.region[axis].len(),
-                    });
             }
-                // Its box is a length this widget decided, from its own
+            // Its box is a part of this widget's own box, in that box's own
-                // rel base or from a sibling's answer: no length of this
+            // lengths, so what it holds for maps back through that part into
-                // widget's box reaches it, so what it holds for is a range
+            // a range on this widget's box.
-                // on the window and none of it on that box.
+            (Part::Of(span), None) => {
+                result.extent[n] = holds.extent[n].through(span.len());
+            }
+            // Its box is a part of this widget's frame: a length of the
+            // frame is all that reaches it, so what it holds for is a range
+            // on the frame and none of it on this widget's own box.
             _ => {
-                    result.window = result.window.and(holds.region.through(region[axis].len()));
+                result.frame[n] = result.frame[n].and(
+                    holds.extent[n]
+                        .through(extent.axis(axis).len())
+                        .through(frame_len),
+                );
             }
         }
     }
     result
-    }
 }
 
-impl Widgets {
+/// A child's answer as lengths of the parent's own region. A widget reports
-    /// What a widget's box is where a rule or its own hint says so outright.
+/// a fraction of its own region, and `of` is that region as a length of this
-    pub(crate) fn declared_lens(&self, id: WidgetId) -> Declared {
+/// one. Pixels come through untouched, being that many pixels wherever they
-        let rules = self.size_rules(id);
+/// end up. A declared axis is already the parent's: it resolved the rule in
-        let widget = self.get_dyn(id);
+/// its own region, and the rule is what the report says.
-        Declared::from_axes(|axis| {
+fn in_parent_frame(size: Size, of: UiVec2, declared: [Option<LayoutLen>; 2]) -> Size {
-            rules[axis].declared().or_else(|| {
+    let mut size = size;
-                // A hint still narrows the box where no rule does, which is
+    for (axis, declared) in AXES.into_iter().zip(declared) {
-                // how a widget with a natural pixel size -- an image, a gap
+        if declared.is_none() {
-                // -- gets that size rather than the whole offer. That is the
+            *size.axis_mut(axis) = size.axis(axis).within_len(of.axis(axis));
-                // offer's business rather than a declaration's, and this
+        }
-                // falls away once a widget occupies its reported size inside
+    }
-                // the box it was offered.
+    size
+}
+
+/// What a widget declares a length of its box to be. `leftover` is not one: a
+/// share of what is left over is only a length to the widget dividing one,
+/// so it passes up in the size instead.
+pub(crate) fn declared_lens(widgets: &Widgets, id: WidgetId) -> [Option<LayoutLen>; 2] {
+    let rules = widgets.size_rules(id);
+    let widget = widgets.get_dyn(id);
+    AXES.map(|axis| {
+        rules.axis(axis).declared().or_else(|| {
+            // A hint still narrows the box where no rule does, which is how a
+            // widget with a natural pixel size -- an image, a gap -- gets that
+            // size rather than the whole offer. That is the offer's business
+            // rather than a declaration's, and this falls away once a widget
+            // occupies its reported size inside the box it was offered.
             widget
                 .and_then(|widget| widget.size_hint(axis))
-                    .and_then(LayoutLen::declared)
+                .filter(|len| len.leftover == Weight::ZERO)
         })
     })
-    }
 }
 
-impl LayoutLen {
+/// Whether what a widget reported along an axis is the whole of the box it
-    /// Whether what a widget reported along an axis is the whole of the box
+/// is in rather than a part to be placed inside it. A share fills, because a
-    /// it is in rather than a part to be placed inside it. A share fills,
+/// share is a length only to whoever divides one, and whoever did is the one
-    /// because a share is a length only to whoever divides one, and whoever
+/// that handed down this box. A declared axis does too: the rule already gave
-    /// did is the one that handed down this box. A declared axis does too:
+/// the region its length, and the rule's length is what the widget reports
-    /// the rule already gave the region its length, and the rule's length is
+/// there. And an axis the parent decided from the answer is
-    /// what the widget reports there. And an axis the parent decided from
+/// the answer already.
-    /// the answer is the answer already.
+pub(crate) fn fills(reported: LayoutLen, declared: Option<LayoutLen>, decided: bool) -> bool {
-    pub(crate) fn fills(self, declared: Option<Len>, decided: bool) -> bool {
+    reported.leftover != Weight::ZERO || declared.is_some() || decided
-        self.leftover != Weight::ZERO || declared.is_some() || decided
-    }
 }
 
 /// Where a widget's drawing goes inside the part its parent gave it: what
 /// it reported, on the side of the part its alignment says, and the whole
 /// part wherever the answer fills it.
 ///
-/// The length it reported is a length of its rel base, and the part is one too,
+/// The length it reported is a length of its frame, and the part is one too,
 /// so this takes one from the other rather than composing it into the part.
 /// That is what makes a fraction the same fraction wherever the part it is
 /// placed in sits and however long it is -- the fraction is resolved once,
-/// here, against the rel base it was reported of.
+/// here, against the frame it was reported of.
-impl PlaceDesc {
+pub(crate) fn placed_extent(
-    pub(crate) fn placement(
+    part: UiRegion,
-        self,
-        region: UiRegion,
     size: Size,
-        declared: Declared,
+    declared: [Option<LayoutLen>; 2],
+    fill: [bool; 2],
     align: RegionAlign,
-    ) -> UiRegion {
+) -> UiRegion {
-        let mut placed = region;
+    let mut placed = part;
     for axis in AXES {
-            let reported = size[axis];
+        let n = axis as usize;
-            if reported.fills(declared[axis], self[axis].does_fill()) {
+        let reported = size.axis(axis);
+        if fills(reported, declared[n], fill[n]) {
             continue;
         }
-            placed[axis] = placed[axis].place(reported.without_leftover(), align[axis]);
+        let len = Len::from_parts(reported.rel, reported.px);
+        let span = placed.axis_mut(axis);
+        span.start += (span.len() - len).scale(align.axis(axis).rel());
+        span.end = span.start + len;
     }
     placed
+}
+
+/// The part of a widget's own box a `place` names, in the coordinates that
+/// box is in.
+pub(crate) fn part_of(extent: UiRegion, place: [Place; 2]) -> UiRegion {
+    let mut part = extent;
+    for axis in AXES {
+        *part.axis_mut(axis) = place[axis as usize].part().of(*extent.axis(axis));
     }
+    part
+}
 
-    /// The rel base length and the box a child is asked in, in the coordinates the
+/// The length a rule gives a child's frame, per axis: a fraction in it is a
-    /// widget asking draws in.
+/// fraction of the frame the child was given, which is the one length the
-    ///
+/// rule can mean.
-    /// `own` is that widget's own box, and `place` what of it the child is
+pub(crate) fn narrowed_by(declared: [Option<LayoutLen>; 2], frame: UiRegion) -> [Option<Len>; 2] {
-    /// given, including any rel base it states -- a row's slot, or padding's rel
+    AXES.map(|axis| {
-    /// base less its pixels. That is a window length, like every other length
+        declared[axis as usize]
-    /// here, since a slot of a row is not a fraction of anything the row can
+            .map(|len| Len::from_parts(len.rel, len.px).within_len(frame.axis(axis).len()))
-    /// name. The child's declaration is a fraction of whichever reached it, and
+    })
-    /// is the only one that also places the box: a box the caller decided is
+}
-    /// what `place` names.
+
-    pub(crate) fn rel_base_and_region(
+/// The frame a child is asked in and the box its drawing goes in, both in
-        self,
+/// the coordinates of the widget asking.
-        own: UiRegion,
+///
-        parent_rel_base: UiVec2,
+/// `frame` is what the caller said the child's fractions are of, and `part`
-        declared: Declared,
+/// what of the caller's own box the drawing takes. `narrow` is the length a
+/// declared rule gives the frame, which makes the frame the box the drawing
+/// goes in -- a rule is what decided where it goes, and there is nothing
+/// left to place inside it. A caller that narrowed the frame itself said the
+/// same thing.
+///
+/// The length is the caller's to supply so that a widget asked again gets
+/// the frame it already has rather than a second resolution of its rule.
+pub(crate) fn frame_and_extent(
+    mut frame: UiRegion,
+    part: UiRegion,
+    narrow: [Option<Len>; 2],
     align: RegionAlign,
-    ) -> (UiVec2, UiRegion) {
+) -> (UiRegion, UiRegion) {
-        let given = self.of(own, align);
+    let mut extent = part;
-        let mut rel_base = parent_rel_base;
+    for (axis, narrow) in AXES.into_iter().zip(narrow) {
-        let mut region = given;
+        let span = frame.axis_mut(axis);
-        for axis in AXES {
+        let narrowed = match narrow {
-            let base = self[axis]
+            Some(len) => {
-                .stated_rel_base()
+                let slot = part.axis(axis);
-                .unwrap_or_else(|| parent_rel_base[axis]);
+                let start = slot.start + (slot.len() - len).scale(align.axis(axis).rel());
-            let len = declared[axis]
+                *span = UiSpan::new(start, start + len);
-                .map(|len| len.within_len(base))
+                true
-                .unwrap_or(base);
-            rel_base[axis] = len;
-            if declared[axis].is_some() {
-                region[axis] = given[axis].place(len, align[axis]);
             }
+            None => *span != UiSpan::FULL,
+        };
+        if narrowed {
+            *extent.axis_mut(axis) = UiSpan::FULL;
         }
-        (rel_base, region)
     }
+    (frame, extent)
 }

core/src/ui/place.rs

@@ -1,243 +1,54 @@
-use crate::util::impl_axis_index;
+use crate::{PrimitiveHandle, UiRegion, UiSpan};
-use crate::{Axis, AxisAlign, Len, PrimitiveHandle, RegionAlign, UiRegion, UiSpan};
 
-/// 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 {
-    span: PlaceSpan,
+    /// The whole of it.
-    fills: bool,
+    All,
-    rel_base: RelBase,
+    /// Frame lengths from where the box starts, which is what a container
+    /// dividing room among its children speaks: a child's report is a length
+    /// of the frame, so the cursor that sums those reports is one too. A
+    /// moved box re-places every child by re-adding its start, exactly.
+    From(UiSpan),
+    /// A part of the box in its own coordinates, which is what a container
+    /// that insets one speaks: taking eleven pixels off the end needs no
+    /// length, where saying the same thing in frame lengths would make the
+    /// container read its own box -- and a box chosen from its own answer
+    /// then feeds back into the answer.
+    Of(UiSpan),
 }
 
+impl Part {
+    /// Where it lands in the coordinates `extent` is in.
+    pub(crate) fn of(self, extent: UiSpan) -> UiSpan {
+        match self {
+            Self::All => extent,
+            Self::From(span) => UiSpan::new(extent.start + span.start, extent.start + span.end),
+            Self::Of(span) => span.within(&extent),
+        }
+    }
+}
+
+/// Where a child goes along one axis, as a part of this widget's box.
 #[derive(Clone, Copy, Debug, PartialEq)]
-enum PlaceSpan {
+pub enum Place {
-    Within(UiSpan),
+    /// The child's answer, aligned inside the part by the child's alignment.
-    Shifted(UiSpan),
+    Within(Part),
-    Sized(Len),
+    /// Exactly the part; the answer is not placed inside it again.
+    Fill(Part),
 }
 
-/// What a child's fractions are of, where the caller has not named a length.
+impl Place {
-#[derive(Clone, Copy, Debug, PartialEq)]
+    pub(crate) fn part(self) -> Part {
-enum RelBase {
+        match self {
-    /// The caller's own, unchanged.
+            Self::Within(part) | Self::Fill(part) => part,
-    Inherit,
-    /// The caller's own, narrowed the way the region is.
-    WithRegion,
-    /// This length of the window.
-    Len(Len),
-}
-
-impl PlaceDescAxis {
-    /// The whole of the caller's box.
-    pub const WHOLE: Self = UiSpan::FULL.within_desc();
-
-    /// 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.fills = true;
-        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
-    }
-
-    /// Whether the region is the placement outright, rather than a box the
-    /// answer is placed inside.
-    pub(crate) const fn does_fill(self) -> bool {
-        self.fills
-    }
-
-    /// Where it lands in the coordinates `own` is in.
-    pub(crate) 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),
         }
     }
 
-    /// The child's rel base, where this says one outright. `None` forwards
+    /// Whether the part is the drawing's box outright, rather than the box
-    /// the caller's own, and [`RelBase::WithRegion`] is resolved by whoever
+    /// the answer is placed inside.
-    /// can read that rel base, so it does not reach here.
+    pub(crate) fn fills(self) -> bool {
-    pub(crate) const fn stated_rel_base(self) -> Option<Len> {
+        matches!(self, Self::Fill(_))
-        match self.rel_base {
-            RelBase::Len(len) => Some(len),
-            _ => None,
-        }
-    }
-
-    /// The length this narrows the caller's rel base by, where it does.
-    /// `None` leaves that rel base alone, and reading it is then a
-    /// dependency the caller does not take.
-    pub(crate) const fn narrows_rel_base(self) -> Option<UiSpan> {
-        match (self.rel_base, self.span) {
-            (RelBase::WithRegion, PlaceSpan::Within(span)) => Some(span),
-            _ => None,
-        }
-    }
-
-    /// The span it composes into the caller's box, where that is what it
-    /// does: the one case whose validity maps back through the part.
-    pub(crate) const fn within_span(self) -> Option<UiSpan> {
-        match self.span {
-            PlaceSpan::Within(span) => Some(span),
-            _ => None,
-        }
-    }
-
-    /// Whether the caller decided this length rather than a place along its
-    /// own box, which is what stops its length reaching the child at all.
-    pub(crate) const fn is_sized(self) -> bool {
-        matches!(self.span, PlaceSpan::Sized(_))
-    }
-
-    /// The same, with its rel base stated outright.
-    pub(crate) const fn with_rel_base(mut self, len: Option<Len>) -> Self {
-        self.rel_base = match len {
-            Some(len) => RelBase::Len(len),
-            None => RelBase::Inherit,
-        };
-        self
-    }
-}
-
-/// 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`].
-    pub const fn fills(self) -> Self {
-        Self::new(self.x.fills(), self.y.fills())
-    }
-
-    /// 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
-    }
-
-    /// The box each axis names, in the coordinates `own` is in.
-    pub(crate) 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),
-            fills: false,
-            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),
-            fills: false,
-            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),
-            fills: false,
-            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)
     }
 }
 
@@ -248,5 +59,3 @@ pub struct RetainedPrimitive {
     pub handle: PrimitiveHandle,
     pub region: UiRegion,
 }
-
-impl_axis_index!(PlaceDesc => PlaceDescAxis);

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/size_rule.rs

@@ -1,5 +1,4 @@
-use crate::util::impl_axis_index;
+use crate::{Axis, LayoutLen, Weight};
-use crate::{Axis, LayoutLen, Len};
 
 /// 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.
@@ -20,9 +19,14 @@ pub enum SizeRule {
 
 impl SizeRule {
     /// 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(LayoutLen::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 --
@@ -66,29 +70,18 @@ pub struct SizeRules {
     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

@@ -130,10 +130,10 @@ 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);
     }
 
@@ -147,10 +147,10 @@ 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);
     }
 

src/random.rs

@@ -118,34 +118,20 @@ 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, UiRegion::FULL, [Place::Within(Part::All), top])
             .len(Axis::X);
-        let len = measured.apply_leftover();
+        let px = measured.apply_leftover().to_px(painter.px_len(Axis::X));
-        let px = painter.to_px(len, Axis::X);
-        // The range it actually branched on, said the way a container says
-        // one: pinning the window instead would redraw this widget on every
-        // resize, which is a fixture that never exercises reuse.
-        let threshold = Px::from_f32(self.threshold);
-        let holds = match px > threshold {
-            true => Holds::from(threshold + Px::STEP..=Px::MAX),
-            false => Holds::from(Px::MIN..=threshold),
-        };
-        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::Of(UiSpan::new(cut, Len::FULL)));
-        let place = below.on_axis(Axis::Y);
+        let place = [Place::Within(Part::All), below];
-        match px > threshold {
+        match px > Px::from_f32(self.threshold) {
-            true => painter.widget_at(&self.wide, place),
+            true => painter.widget_at(&self.wide, UiRegion::FULL, place),
-            false => painter.widget_at(&self.narrow, place),
+            false => painter.widget_at(&self.narrow, UiRegion::FULL, place),
         };
         Size::LEFTOVER
     }
-
-    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::LEFTOVER)
-    }
 }
 
 pub struct Spanned {

src/widget/image.rs

@@ -12,7 +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)))
     }
 }
 

src/widget/mask.rs

@@ -15,8 +15,4 @@ impl Widget for Masked {
         // draw, and the framework would place the drawing it clipped away.
         Size::LEFTOVER
     }
-
-    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::LEFTOVER)
-    }
 }

src/widget/position/offset.rs

@@ -7,8 +7,14 @@ pub struct Offset {
 
 impl Widget for Offset {
     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, UiRegion::FULL, place).size()
     }
 }

src/widget/position/pad.rs

@@ -14,12 +14,23 @@ 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)`
+        // The padding goes around what it pads: the frame passes through, so
-        // under it fills this widget rather than overflowing it by the
+        // the inner's fractions mean what they would without it, and only
-        // padding, and it comes off the box, so what is drawn sits inside.
+        // the box it draws in is moved in by the pixels. Said as a part of
-        // The two stay distinct -- the box can be narrower still, where a row
+        // this widget's own box in that box's own lengths, so nothing here
-        // asked this widget in the room left, and a text wraps at that.
+        // reads how long the box is -- and a box chosen from this widget's
-        let inner = painter.widget_at(&self.inner, self.padding.region()).size();
+        // own answer therefore does not feed back into that answer.
+        let inset = |lead: Px, trail: Px| {
+            Place::Within(Part::Of(UiSpan::new(
+                Len::from_parts(Rel::ZERO, lead),
+                Len::from_parts(Rel::ONE, -trail),
+            )))
+        };
+        let place = [
+            inset(self.padding.left, self.padding.right),
+            inset(self.padding.top, self.padding.bottom),
+        ];
+        let inner = painter.widget_at(&self.inner, UiRegion::FULL, place).size();
         Size {
             x: LayoutLen {
                 px: inner.x.px + self.padding.left + self.padding.right,

src/widget/position/scroll.rs

@@ -12,11 +12,12 @@ pub struct Scroll {
 impl Widget for Scroll {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let container_len = painter.px_len(self.axis);
-        // Asked in the whole viewport, then put at the scrolled offset.
+        // Measured in the whole viewport, then drawn at the scrolled offset.
+        let whole = UiRegion::FULL;
         let answer_len = painter
-            .widget_at(&self.inner, PlaceDesc::WHOLE.fills())
+            .widget_at(&self.inner, whole, [Place::Fill(Part::All); 2])
             .len(self.axis);
-        let fixed = painter.to_px(answer_len.without_leftover(), self.axis);
+        let fixed = Len::from_parts(answer_len.rel, answer_len.px).to_px(container_len);
         self.container_len = container_len;
         self.content_len = fixed.max(container_len);
 
@@ -24,14 +25,14 @@ impl Widget for Scroll {
             self.amt = self.content_len - self.container_len;
         }
         self.update_amt();
-        let align = painter.alignment()[self.axis];
+        let align = painter.alignment().axis(self.axis);
         // 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
         // the room left over, so it moves with every length the box takes and
         // the drawing holds for that length alone. 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 fixed_len = answer_len.is_px();
+        let fixed_len = answer_len.rel == Rel::ZERO && answer_len.leftover == Weight::ZERO;
         if fixed_len && self.content_len <= self.container_len && align == AxisAlign::NEG {
             painter.holds(self.axis, fixed..=Px::MAX);
         } else if fixed_len && !self.snap_end {
@@ -44,6 +45,7 @@ impl Widget for Scroll {
         // have placed the whole scroll in a box longer than it.
         let slack = (self.container_len - self.content_len).max(Px::ZERO);
         let anchor = slack.mul(align.rel());
+        let mut content = UiSpan::FULL;
         // Content that fills the viewport and has not been scrolled is the
         // viewport, and is handed back as it came. Writing the same box as
         // its own length in pixels is the same box in another form, and the
@@ -51,28 +53,26 @@ impl Widget for Scroll {
         // 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 {
+        if moved || self.content_len != self.container_len {
-            true => {
             let start = Len::from_parts(Rel::ZERO, anchor - self.amt);
-                UiSpan::new(start, start.offset(self.content_len)).shifted_desc()
+            content = UiSpan::new(start, start.offset(self.content_len));
         }
-            false => PlaceDescAxis::WHOLE,
+        // The viewport is the inner's frame, so a fraction it declares or
-        };
-        // The viewport is the inner's rel base, 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
+        // content box its own answer decided. Where it is drawn is the
-        // box, scrolled: its drawing moved there, not made again there.
+        // content box, scrolled.
-        painter.place_at(&self.inner, content.on_axis(self.axis).fills());
+        painter.widget_at(
+            &self.inner,
+            whole,
+            self.axis
+                .pair(Place::Fill(Part::From(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
         // is.
         Size::LEFTOVER
     }
-
-    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::LEFTOVER)
-    }
 }
 
 impl Scroll {

src/widget/position/span.rs

@@ -10,33 +10,30 @@ pub struct Span {
 impl Widget for Span {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         let axis = self.dir.axis;
-        // The row: this span's own box, as a length of the rel base its children
+        // The row: this span's own box, as a length of the frame its children
         // are laid out against. Its start is nothing's business -- a slot is
         // a length from it -- so what this reads is the length alone.
-        let far = painter.region_len(axis);
+        let far = painter.answer_extent_len(axis);
-        let along = |from: Len, to: Len| match self.dir.sign {
+        let measure_along = |from: Len, to: Len| match self.dir.sign {
             Sign::Pos => UiSpan::new(from, to),
             Sign::Neg => UiSpan::new(far - to, far - from),
         };
-        // A length for every child before their final slots are chosen: from
+        // Across itself the child sits where its own alignment says, in the
-        // a hint where one says, and from drawing otherwise. The rel base passes
+        // whole of the row: a span is what contains its children there, and
-        // through unchanged, so `rel(0.5)` is half the area this span was
+        // nothing divides that axis.
-        // given whatever else is in it and wherever this child sits among
+        let across = Place::Within(Part::All);
-        // them; what a drawn child is asked in is the room left from the
+        // A length for every child before their final slots are chosen. The
-        // cursor, because a text has to wrap at the width actually there.
+        // 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 it is drawn in is the room left from the cursor,
+        // because a text has to wrap at the width actually there.
         let mut cursor = Len::rel_min();
         let mut lens = Vec::with_capacity(self.children.len());
         for child in &self.children {
-            let len = match painter.size_hint(child, axis) {
+            let room = Place::Fill(Part::From(measure_along(cursor, far)));
-                Some(len) => len,
+            let len = painter
-                None => {
+                .widget_at(child, UiRegion::FULL, axis.pair(room, across))
-                    // Across itself the child sits where its own alignment
+                .len(axis);
-                    // says, in the whole of the row: a span is what contains
-                    // its children there, and nothing divides that axis.
-                    let room = along(cursor, far).shifted_desc().on_axis(axis);
-                    painter.widget_at(child, room).len(axis)
-                }
-            };
             cursor.px += len.px + self.gap;
             cursor.rel += len.rel;
             lens.push(len);
@@ -53,9 +50,10 @@ impl Widget for Span {
             |sum, len| sum + *len,
         );
 
+        let fixed_total = Len::from_parts(total.rel, total.px);
         // What is left for the shares to divide: the row less everything
-        // fixed, as a length of the rel base rather than a number of pixels.
+        // fixed, as a length of the frame rather than a number of pixels.
-        let room = far - total.without_leftover();
+        let room = far - fixed_total;
         // 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
@@ -67,14 +65,26 @@ impl Widget for Span {
         // exist at all turns on this.
         let mut shares = false;
         if total.leftover > Weight::ZERO {
-            shares = painter.to_px(room, axis) > Px::ZERO;
+            shares = room.to_px(painter.frame_px_len(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));
+            painter.frame_holds(axis, holds.through(room));
         }
 
+        if shares {
+            painter.drawing_uses_extent_len(axis, far);
+        }
+        let drawing_far = match shares {
+            true => far,
+            false => fixed_total,
+        };
+        let along = |from: Len, to: Len| match self.dir.sign {
+            Sign::Pos => UiSpan::new(from, to),
+            Sign::Neg => UiSpan::new(drawing_far - to, drawing_far - from),
+        };
+
         // Across itself a span is as long as its longest child -- unless a
         // rule beside it gives that length outright, and then reading them
         // answers nothing and makes its size depend on theirs for it. A rule
@@ -91,52 +101,53 @@ impl Widget for Span {
         let mut taken = Weight::ZERO;
         let mut start = Len::rel_min();
         let mut ortho = LayoutLen::ZERO;
-        let shared = |fixed: Len, taken: Weight| match taken == Weight::ZERO {
+        for (child, len) in self.children.iter().zip(&lens) {
-            true => fixed,
-            false => fixed + room.scale(Rel::ratio(taken, total.leftover)),
-        };
-        for (child, &len) in self.children.iter().zip(&lens) {
             // 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() && !shares {
+            if len.leftover > Weight::ZERO && len.px == Px::ZERO && len.rel == Rel::ZERO && !shares
+            {
                 painter.undraw(child);
                 fixed.px += self.gap;
-                start = shared(fixed, taken);
                 continue;
             }
             let from = start;
             if len.leftover > Weight::ZERO && shares {
                 taken += len.leftover;
             }
-            fixed += len.without_leftover();
+            fixed.px += len.px;
-            start = shared(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
+            // is the drawing's box outright rather than something to place an
-            // answer inside again. A share is decided here and nowhere
+            // answer inside again.
-            // else: its slot narrows its rel base, and the child is asked in
+            let span = along(from, start);
-            // it, since a text wraps at the width it is actually given. A
+            let (frame, slot) = match len.leftover > Weight::ZERO && shares {
-            // fixed child's slot is its own answer, so a drawing made in the
+                true => (
-            // room is put there as it is, and one not made yet is made here.
+                    UiRegion::from_axis(
-            let slot = along(from, start);
+                        axis,
-            let mut place = slot.shifted_desc().fills().on_axis(axis);
+                        painter.extent_part(axis, Part::From(span)),
-            if len.leftover > Weight::ZERO && shares {
+                        UiSpan::FULL,
-                place = place.rel_base(axis, slot.len());
+                    ),
-            }
+                    Place::Fill(Part::All),
-            let used = painter.place_at(child, place).len(!axis);
+                ),
+                false => (UiRegion::FULL, Place::Fill(Part::From(span))),
+            };
+            let placed = painter.widget_at(child, frame, axis.pair(slot, across));
             if shrinks {
+                let used = placed.len(!axis);
                 // Choosing between a fixed and a relative length from the
                 // span's own eventual width admits multiple fixed points.
                 // 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);
+            start = shared(fixed, taken, total.leftover, room);
         }
 
         // Carried whole rather than collapsed to one share: a span that sizes
@@ -155,6 +166,16 @@ impl Widget for Span {
     }
 }
 
+/// 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 {
     pub fn empty(dir: Dir) -> Self {
         Self {

src/widget/position/stack.rs

@@ -22,40 +22,29 @@ 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, UiRegion::FULL, [Place::Fill(Part::All); 2])
+                    .size()
             }
             None => Size::LEFTOVER,
         };
-        // Every other child gets the box the sizing child decided: the
-        // stack is that length, so that is the box they are asked in, and a
-        // 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 len = size[axis];
-            match len.leftover == Weight::ZERO {
-                true => len.without_leftover().as_desc().fills(),
-                false => PlaceDescAxis::WHOLE,
-            }
-        });
         for (i, child) in self.children.iter().enumerate() {
             if sizing == Some(i) {
                 continue;
             }
             painter.child_layer_at(i);
-            painter.widget_at(child, place);
+            let place = [Axis::X, Axis::Y].map(|axis| {
+                let len = size.axis(axis);
+                let part = match len.leftover > Weight::ZERO {
+                    true => Part::All,
+                    false => Part::From(UiSpan::new(Len::ZERO, Len::from_parts(len.rel, len.px))),
+                };
+                Place::Within(part)
+            });
+            painter.widget_at(child, UiRegion::FULL, place);
         }
         size
     }
-
-    /// Without a sizing child a stack is whatever box it is given, which it
-    /// can say without drawing anything.
-    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
-        match self.size {
-            StackSize::Default => Some(LayoutLen::LEFTOVER),
-            StackSize::Child(_) => None,
-        }
-    }
 }
 
 #[derive(Default, Debug)]

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, UiRegion::FULL, [Place::Within(Part::All), top])
             .len(Axis::X);
-        let px = painter.to_px(measured.apply_leftover(), Axis::X);
+        let px = measured.apply_leftover().to_px(painter.px_len(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, UiRegion::FULL, place),
-            false => painter.widget_at(&self.narrow, place),
+            false => painter.widget_at(&self.narrow, UiRegion::FULL, place),
         };
         Size::LEFTOVER
     }

tests/cases/layout.rs

@@ -83,8 +83,10 @@ fn a_text_in_a_span_wraps_at_the_room_left_rather_than_the_whole_row() {
     assert!(crowded > whole_row, "{crowded} against {whole_row}");
 }
 
-/// Padding is an inset: it narrows the frame a fraction resolves against and
+/// The same reading through a pad: padding goes around what it pads and
-/// adds itself back to the padded widget's reported length.
+/// does not narrow what a fraction under it is a fraction of, so half of the
+/// window plus the padding is what the pad takes and where the next child
+/// starts.
 #[test]
 fn a_pad_puts_its_padding_around_a_fraction_of_the_whole_box() {
     let mut h = Harness::new((400, 100));
@@ -95,83 +97,9 @@ fn a_pad_puts_its_padding_around_a_fraction_of_the_whole_box() {
     // placed inside it by its own alignment, which is not what is under test.
     h.set_root((padded, tail).span(Dir::RIGHT).width(rel(1.0)));
 
-    assert_corners!(h, inner, (10, 10), (200, 90));
+    assert_corners!(h, inner, (10, 10), (210, 90));
-    assert_corners!(h, padded, (0, 0), (210, 100));
+    assert_corners!(h, padded, (0, 0), (220, 100));
-    assert_corners!(h, tail, (210, 0), (310, 100));
+    assert_corners!(h, tail, (220, 0), (320, 100));
-}
-
-const PARAGRAPH: &str = "Wrapping shapes one source into as many lines as the box \
-    leaves room for, so a paragraph's height is an answer and not a setting.";
-
-/// The worked example of what padding insets: in a 900 px row after a 24 px
-/// icon, a `rel(1.0)` inside `pad(16)` is 900 - 32 and overflows the row by
-/// 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() {
-    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);
-    let padded = fill.pad(16).add(&mut h.rsc);
-    h.set_root((icon, padded).span(Dir::RIGHT).width(rel(1.0)));
-    let fill_width = h.region(&fill).unwrap().size().x;
-    assert_eq!(fill_width, Px::from_int(868));
-
-    let mut h = Harness::new((900, 200));
-    let icon = rect(Color::RED).width(24).add(&mut h.rsc);
-    let text = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
-    let padded = text.pad(16).add(&mut h.rsc);
-    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);
-    assert_eq!(active.rel_base.x.to_px(window), Px::from_int(868));
-    assert_eq!(asked, Px::from_int(844));
-}
-
-/// The other way round: a share inside padding. A slot is a length of the
-/// row, which is already the padded width, so what the span decided reaches
-/// the child as it stands -- taking the padding off a second time would make
-/// `rel(1.0)` in the slot shorter than the slot.
-#[test]
-fn a_share_inside_padding_fills_the_slot_it_was_given() {
-    let mut h = Harness::new((900, 200));
-    let fill = rect(Color::GREEN).width(rel(1.0)).add(&mut h.rsc);
-    let first = Span {
-        children: vec![fill.add_strong(&mut h.rsc)],
-        dir: Dir::RIGHT,
-        gap: Px::ZERO,
-    }
-    .width(leftover(1))
-    .add(&mut h.rsc);
-    let second = rect(Color::BLUE).width(leftover(1)).add(&mut h.rsc);
-    let row = (first, second).span(Dir::RIGHT).add(&mut h.rsc);
-    h.set_root(row.pad(16));
-
-    assert_eq!(h.region(&first).unwrap().size().x, Px::from_int(434));
-    assert_eq!(h.region(&fill).unwrap().size().x, Px::from_int(434));
-}
-
-/// 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() {
-    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);
-    let other = rect(Color::BLUE).width(leftover(1)).add(&mut h.rsc);
-    h.set_root((padded, other).span(Dir::RIGHT).width(rel(1.0)));
-    assert_eq!(h.region(&fill).unwrap().size().x, Px::from_int(418));
-
-    let mut h = Harness::new((900, 200));
-    let text = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
-    let padded = text.pad(16).width(leftover(1)).add(&mut h.rsc);
-    let other = rect(Color::BLUE).width(leftover(1)).add(&mut h.rsc);
-    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.region.x.len().to_px(window), Px::from_int(418));
 }
 
 #[test]
@@ -500,11 +428,12 @@ 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 drawn = active.extent.within(&active.frame_abs);
-    let dim = h.size()[axis];
+    let region = h.render.moves.resolve(active.parent_move, drawn);
+    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))
 }
 
@@ -811,50 +740,3 @@ fn a_fixed_child_is_centered_in_its_wrappers_share() {
     assert_corners!(h, wrapper, (200, 0), (900, 400));
     assert_corners!(h, leaf, (500, 150), (600, 250));
 }
-
-/// The root's frame is the window and its rule is a fraction of that, which
-/// is one resolution and not two: nothing above it narrowed anything.
-#[test]
-fn a_root_with_a_fraction_rule_is_that_fraction_of_the_window() {
-    let mut h = Harness::new((900, 200));
-    let root = rect(Color::RED).width(rel(0.5)).add(&mut h.rsc);
-    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));
-        }
-    }
-}

tests/cases/retained.rs

@@ -12,6 +12,7 @@ struct Counted {
     draws: Rc<Cell<usize>>,
     size: Size,
     reads_box: bool,
+    reads_answer_box: bool,
 }
 
 impl Widget for Counted {
@@ -19,6 +20,8 @@ impl Widget for Counted {
         self.draws.set(self.draws.get() + 1);
         if self.reads_box {
             painter.px_size();
+        } else if self.reads_answer_box {
+            painter.answer_px_size();
         }
         self.size
     }
@@ -38,11 +41,18 @@ fn counted(h: &mut Harness, size: Size, reads_box: bool) -> (WeakWidget<Counted>
         draws: draws.clone(),
         size,
         reads_box,
+        reads_answer_box: false,
     }
     .add(&mut h.rsc);
     (id, Counts(draws))
 }
 
+fn answer_counted(h: &mut Harness, size: Size) -> (WeakWidget<Counted>, Counts) {
+    let (id, draws) = counted(h, size, false);
+    h.rsc[id].reads_answer_box = true;
+    (id, draws)
+}
+
 struct Layered {
     children: [StrongWidget<Rect>; 2],
     _revision: usize,
@@ -156,9 +166,9 @@ fn a_span_child_that_declares_its_length_is_drawn_once() {
     h.set_root((hinted, asked).span(Dir::RIGHT));
 
     assert_eq!(told_draws.get(), 1);
-    // Asked once, from the cursor; its slot is its answer and the drawing is
+    // Its final slot is a parent decision, so it is evaluated there after
-    // moved there.
+    // the provisional ask established its length.
-    assert_eq!(asked_draws.get(), 1);
+    assert_eq!(asked_draws.get(), 2);
 }
 
 #[test]
@@ -214,7 +224,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,
+            UiRegion::FULL,
+            [Place::Within(Part::All), Place::Within(Part::From(top))],
+        );
         Size::LEFTOVER
     }
 }
@@ -236,7 +250,7 @@ fn a_parent_that_only_read_a_hint_relays_out_when_the_hint_changes() {
     assert_corners!(h, inner, (0, 0), (400, 120));
 }
 
-/// Reads its box's size, which nothing but its own draw can put right.
+/// Reads its box's size to compute its answer.
 struct ReadsBox {
     draws: Rc<Cell<usize>>,
 }
@@ -244,25 +258,36 @@ struct ReadsBox {
 impl Widget for ReadsBox {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         self.draws.set(self.draws.get() + 1);
-        Size::from_px(painter.px_size().div_int(4))
+        Size::from_px(painter.answer_px_size().div_int(4))
     }
 }
 
 /// Reads its box across one axis only, so its drawing holds for a taller
 /// box on its own and only a wider one is worth a draw.
 ///
-/// Both of these report a quarter of what they read. The quarter-sized box
+/// Both report a quarter of what they read. Their empty drawings are
-/// the answer places them in is not a question: the drawing is moved there,
+/// independent of that read, so a changed question costs one draw.
-/// so each length they are asked at costs one draw.
 struct ReadsWidth {
     draws: Rc<Cell<usize>>,
 }
 
+struct ReadsDrawingWidth {
+    draws: Rc<Cell<usize>>,
+}
+
+impl Widget for ReadsDrawingWidth {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        self.draws.set(self.draws.get() + 1);
+        painter.px_len(Axis::X);
+        Size::LEFTOVER
+    }
+}
+
 impl Widget for ReadsWidth {
     fn draw(&mut self, painter: &mut Painter) -> Size {
         self.draws.set(self.draws.get() + 1);
         Size::from_px(PxVec2::new(
-            painter.px_len(Axis::X).div_int(4),
+            painter.answer_px_len(Axis::X).div_int(4),
             Px::from_int(20),
         ))
     }
@@ -318,6 +343,7 @@ fn a_row_moves_what_follows_a_child_that_grew_rather_than_drawing_it() {
             draws: ruled.clone(),
             size: Size::LEFTOVER,
             reads_box: false,
+            reads_answer_box: false,
         };
         let second = match declared {
             true => second.width(rel(0.25)).add(&mut h.rsc),
@@ -495,7 +521,7 @@ fn a_change_two_levels_under_its_reader_still_reaches_it() {
     // Every wrapper up to the outer pad read the size below it, so the outer
     // pad is what draws again -- and the span it hands the box to is the same
     // size as before, which is what lets a draw reuse its way past the leaf.
-    let (leaf, _) = counted(&mut h, Size::px((100, 100).into()), true);
+    let (leaf, _) = counted(&mut h, Size::px((100, 100).into()), false);
     let padded = leaf.pad(10).add(&mut h.rsc);
     let below = rect(Color::RED).add(&mut h.rsc);
     h.set_root((padded, below).span(Dir::DOWN).pad(12));
@@ -793,7 +819,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);
@@ -873,7 +899,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()),
+                UiRegion::FULL,
+                [
+                    Place::Within(Part::From(self.region.x)),
+                    Place::Within(Part::From(self.region.y)),
+                ],
             );
             Size::LEFTOVER
         }
@@ -951,18 +981,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(
+                self.region,
-                    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
         }
@@ -978,15 +1008,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)),
             );
@@ -1057,7 +1087,7 @@ fn a_declared_size_change_stops_at_an_independent_parent() {
 fn an_unmeasured_child_still_invalidates_its_parents_drawing_on_resize() {
     let mut h = Harness::new((400, 200));
     let draws = Rc::new(Cell::new(0));
-    let leaf = ReadsWidth {
+    let leaf = ReadsDrawingWidth {
         draws: draws.clone(),
     }
     .add(&mut h.rsc);
@@ -1068,7 +1098,7 @@ fn an_unmeasured_child_still_invalidates_its_parents_drawing_on_resize() {
     h.frame();
 
     assert!(draws.get() > settled);
-    assert_corners!(h, leaf, (300, 90), (500, 110));
+    assert_corners!(h, leaf, (0, 0), (800, 200));
 }
 
 #[test]
@@ -1109,7 +1139,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>>,
@@ -1122,22 +1152,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(
+                UiRegion::FULL,
-                    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);
@@ -1158,7 +1189,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)
         };
@@ -1173,13 +1204,13 @@ 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));
@@ -1198,11 +1229,11 @@ fn padding_and_stack_boxes_follow_the_region_without_drawing_again() {
 }
 
 #[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 {
-            let width = painter.px_len(Axis::X);
+            let width = painter.answer_px_len(Axis::X);
             painter.primitive(RectPrimitive::color(Color::BLUE));
             Size::from((80, if width > Px::from_int(100) { 40 } else { 60 }))
         }
@@ -1215,12 +1246,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(
+                UiRegion::FULL,
-                    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
         }
@@ -1245,7 +1278,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,
@@ -1255,14 +1288,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()),
+                    UiRegion::FULL,
+                    [
+                        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 {
@@ -1271,10 +1308,11 @@ fn changing_regions_keep_fractional_reports_and_numeric_dependencies_valid() {
                 painter
                     .widget_at(
                         &self.child,
-                        PlaceDesc::new(
+                        UiRegion::FULL,
-                            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(),
             );
@@ -1286,7 +1324,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),
@@ -1295,7 +1333,10 @@ fn changing_regions_keep_fractional_reports_and_numeric_dependencies_valid() {
                 } else {
                     Size::from((80, 27))
                 };
-                let (leaf, _) = counted(h, size, !fractional);
+                let (leaf, _) = match fractional {
+                    true => counted(h, size, false),
+                    false => answer_counted(h, size),
+                };
                 let child = Container {
                     child: leaf.add_strong(&mut h.rsc),
                     region,
@@ -1304,7 +1345,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);
@@ -1314,166 +1355,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().get_dyn_mut(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();
-        let clip = h.rsc.ui().masks[mask.idx()];
-        let clip = h
-            .render
-            .moves
-            .resolve(clip.move_idx, clip.region)
-            .to_px(h.render.output_size());
-        assert_eq!(clip, 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);
-    }
-}

tests/cases/scroll.rs

@@ -145,19 +145,3 @@ fn a_clipping_widget_reporting_more_than_its_box_is_caught() {
     h.set_root(clipper);
     h.frame();
 }
-
-/// Content that fits sits in the viewport, not in a box of the window's
-/// length anchored at the viewport's start. `Part::From` takes window
-/// lengths, so a `rel(1.0)` span in one is the window, and only a scroll
-/// filling the window would land right.
-#[test]
-fn content_that_fits_is_placed_in_the_viewport_and_not_in_the_window() {
-    let mut h = Harness::new((400, 400));
-    let head = rect(Color::RED).height(100).add(&mut h.rsc);
-    let inner = rect(Color::BLUE).height(50).add(&mut h.rsc);
-    let scroll = Scroll::new(inner.add_strong(&mut h.rsc), Axis::Y).add(&mut h.rsc);
-    h.set_root((head, scroll).span(Dir::DOWN));
-
-    assert_corners!(h, scroll, (0, 100), (400, 400));
-    assert_corners!(h, inner, (0, 225), (400, 275));
-}

tests/cases/unsettled.rs

@@ -733,51 +733,6 @@ fn a_widget_under_a_region_node_is_asked_in_the_box_that_node_was_offered() {
 const PARAGRAPH: &str = "Wrapping shapes one source into as many lines as the \
     box leaves room for, so a paragraph's height is an answer and not a setting.";
 
-fn plant_stack_resized_from_free(h: &mut Harness, fixed: bool) -> (Vec<WidgetId>, WidgetId) {
-    let sizing = rect(Color::CYAN.alpha(126)).add(&mut h.rsc);
-    h.rsc.widgets_mut().set_size_rules(sizing.id(), None, None);
-    if fixed {
-        h.rsc.widgets_mut().set_size_rules(
-            sizing.id(),
-            Some(LayoutLen::px(112)),
-            Some(LayoutLen::px(101)),
-        );
-    }
-    let text = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
-    let pad = Pad {
-        padding: Padding::ZERO,
-        inner: text.add_strong(&mut h.rsc),
-    }
-    .add(&mut h.rsc);
-    let stack = Stack {
-        children: vec![sizing.add_strong(&mut h.rsc), pad.add_strong(&mut h.rsc)],
-        size: StackSize::Child(0),
-    }
-    .add(&mut h.rsc);
-    h.set_root(stack);
-    (
-        vec![sizing.id(), text.id(), pad.id(), stack.id()],
-        sizing.id(),
-    )
-}
-
-#[test]
-fn fixing_a_stacks_sizing_child_repositions_its_overlay() {
-    let mut warm = Harness::new((900, 1200));
-    let (ids, sizing) = plant_stack_resized_from_free(&mut warm, false);
-    warm.frame();
-    warm.rsc.widgets_mut().set_size_rules(
-        sizing,
-        Some(LayoutLen::px(112)),
-        Some(LayoutLen::px(101)),
-    );
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let (cold_ids, _) = plant_stack_resized_from_free(&mut cold, true);
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-}
-
 /// Eight widgets, shrunk from a 118-widget tree (seed 1121, depth 4,
 /// `shuffle-swap-for-three`). The stack takes its size from the span above,
 /// the span takes its width from the longest line of the texts in it, and
@@ -891,179 +846,3 @@ fn adding_text_to_a_reverse_row_keeps_its_shared_height() {
     let (_, other, _) = build(&mut cold, true);
     assert_eq!(warm.region(&shared), cold.region(&other));
 }
-
-/// Nine widgets, shrunk from seed 946 at depth 6. The column is a share of
-/// the row while its rect has room to draw and a fixed width once it has
-/// not, so the row asks it twice: in the room, where it answers a share,
-/// and in its slot, where it answers its text's width. Emptying the column
-/// changes only the first answer. A local redraw that asked only the second
-/// question kept the row as it was; the column has to defer to the row.
-fn plant_column_that_is_a_share_only_while_its_rect_fits(
-    h: &mut Harness,
-    emptied: bool,
-) -> (Vec<WidgetId>, WeakWidget<Span>, Vec<StrongWidget>) {
-    let first = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
-    let filler = rect(Color::CYAN.alpha(126)).add(&mut h.rsc);
-    let second = wtext(PARAGRAPH).size(16).wrap(true).add(&mut h.rsc);
-    let mut spare: Vec<StrongWidget> =
-        vec![filler.add_strong(&mut h.rsc), second.add_strong(&mut h.rsc)];
-    let mut children: Vec<StrongWidget> = vec![first.add_strong(&mut h.rsc)];
-    if !emptied {
-        children.append(&mut spare);
-    }
-    let column = Span {
-        children,
-        dir: Dir::DOWN,
-        gap: Px::ZERO,
-    }
-    .height(159)
-    .add(&mut h.rsc);
-    let left = rect(Color::MAGENTA.alpha(189)).add(&mut h.rsc);
-    let right = rect(Color::BLUE.alpha(0)).add(&mut h.rsc);
-    let row = Span {
-        children: vec![
-            left.add_strong(&mut h.rsc),
-            column.add_strong(&mut h.rsc),
-            right.add_strong(&mut h.rsc),
-        ],
-        dir: Dir::RIGHT,
-        gap: Px::ZERO,
-    }
-    .add(&mut h.rsc);
-    let end = rect(Color::MAGENTA.alpha(189)).add(&mut h.rsc);
-    let root = Span {
-        children: vec![end.add_strong(&mut h.rsc), row.add_strong(&mut h.rsc)],
-        dir: Dir::LEFT,
-        gap: Px::ZERO,
-    }
-    .add(&mut h.rsc);
-    h.set_root(root);
-    (
-        vec![
-            first.id(),
-            filler.id(),
-            second.id(),
-            column.id(),
-            left.id(),
-            right.id(),
-            row.id(),
-            end.id(),
-            root.id(),
-        ],
-        column,
-        spare,
-    )
-}
-
-#[test]
-fn emptying_a_column_the_row_asked_twice_asks_the_row_again() {
-    let mut warm = Harness::new((900, 1200));
-    let (ids, column, _spare) =
-        plant_column_that_is_a_share_only_while_its_rect_fits(&mut warm, false);
-    warm.frame();
-    // Kept alive: dropping the last share of a widget frees its id.
-    let _removed: Vec<StrongWidget> = warm.rsc[column].children.drain(1..).collect();
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let (cold_ids, _, _spare) =
-        plant_column_that_is_a_share_only_while_its_rect_fits(&mut cold, true);
-    cold.frame();
-
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-}
-
-/// Six widgets, shrunk from seed 59 at depth 5 (`resize-size`). The column
-/// divides the box it is given between two shares, so its drawing holds for
-/// that box's length alone, and the pads above it pass that dependency up:
-/// each one's box is a part of the box it was asked in. Padding narrowing
-/// the frame it hands down does not change that, and while it was taken to,
-/// changing the rule over the pads relocated the column's drawing into the
-/// new box instead of dividing it again.
-fn plant_two_shares_under_two_pads(h: &mut Harness, height: f32) -> Vec<WidgetId> {
-    let top = rect(Color::CYAN.alpha(126)).add(&mut h.rsc);
-    let bottom = rect(Color::RED).add(&mut h.rsc);
-    let column = (top, bottom).span(Dir::DOWN).add(&mut h.rsc);
-    let inner = Pad {
-        padding: Padding::ZERO,
-        inner: column.add_strong(&mut h.rsc),
-    }
-    .add(&mut h.rsc);
-    let outer = Pad {
-        padding: Padding::ZERO,
-        inner: inner.add_strong(&mut h.rsc),
-    }
-    .height(height)
-    .add(&mut h.rsc);
-    let beside = rect(Color::BLUE).add(&mut h.rsc);
-    h.set_root((outer, beside).span(Dir::RIGHT));
-    vec![
-        top.id(),
-        bottom.id(),
-        column.id(),
-        inner.id(),
-        outer.id(),
-        beside.id(),
-    ]
-}
-
-#[test]
-fn changing_a_rule_over_two_pads_divides_the_column_again() {
-    let mut warm = Harness::new((900, 1200));
-    let ids = plant_two_shares_under_two_pads(&mut warm, 88.0);
-    warm.frame();
-    warm.rsc
-        .widgets_mut()
-        .set_size_rules(ids[4], None, Some(LayoutLen::px(105)));
-    warm.frame();
-
-    let mut cold = Harness::new((900, 1200));
-    let cold_ids = plant_two_shares_under_two_pads(&mut cold, 105.0);
-    cold.frame();
-
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-}
-
-/// Six widgets, shrunk from seed 942 at depth 6 (`resize`). A `Branch` asks
-/// its probe in the top 40 px of its box and forwards the frame, so the
-/// scroll's own box is 40 px tall whatever the window is -- but its content
-/// is as tall as the frame, which is the window, and a scroll kept to its
-/// end has to be told when that changes. Resolving a length against the
-/// window is what reads it, so that is where the dependency is taken.
-fn plant_a_window_tall_column_in_a_short_scroll(h: &mut Harness) -> Vec<WidgetId> {
-    let leaf = rect(Color::RED).add(&mut h.rsc);
-    let column = Span {
-        children: vec![leaf.add_strong(&mut h.rsc)],
-        dir: Dir::RIGHT,
-        gap: Px::ZERO,
-    }
-    .height(rel(1.0))
-    .add(&mut h.rsc);
-    let scroll = Scroll::new(column.add_strong(&mut h.rsc), Axis::Y).add(&mut h.rsc);
-    let wide = rect(Color::BLUE).add(&mut h.rsc);
-    let narrow = rect(Color::GREEN).add(&mut h.rsc);
-    let root = Branch {
-        probe: scroll.add_strong(&mut h.rsc),
-        wide: wide.add_strong(&mut h.rsc),
-        narrow: narrow.add_strong(&mut h.rsc),
-        threshold: 55.0,
-    }
-    .add(&mut h.rsc);
-    h.set_root(root);
-    vec![leaf.id(), column.id(), scroll.id(), root.id()]
-}
-
-#[test]
-fn resizing_under_a_short_scroll_snaps_its_window_tall_content_again() {
-    let mut warm = Harness::new((1920, 1200));
-    let ids = plant_a_window_tall_column_in_a_short_scroll(&mut warm);
-    warm.frame();
-    warm.resize((640, 900));
-    warm.frame();
-
-    let mut cold = Harness::new((640, 900));
-    let cold_ids = plant_a_window_tall_column_in_a_short_scroll(&mut cold);
-    cold.frame();
-
-    assert_same_regions(&warm, &ids, &cold, &cold_ids);
-}

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
@@ -32,11 +32,8 @@ fn depth() -> usize {
 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} \
@@ -122,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/layout_dump.rs

@@ -1,42 +0,0 @@
-//! Prints where a cold layout puts every widget of many grown trees, so two
-//! commits can be compared on cold layout alone. The warm/cold oracle cannot
-//! see a change that moves cold layout, since both of its sides move; this
-//! can, by diffing its output across the change:
-//!
-//!     IRIS_DUMP_SEEDS=400 IRIS_DUMP_DEPTH=5 cargo test --release \
-//!       --test layout_dump -- --ignored --nocapture > /tmp/before.txt
-//!
-//! then the same after, and `diff` the two. A line is one widget: the seed,
-//! its index in creation order, and its box in window pixels, or `-` where
-//! it is not drawn.
-
-use iris::harness::Harness;
-use iris::random::{Edits, grow};
-
-fn env<T: std::str::FromStr>(name: &str, fallback: T) -> T {
-    std::env::var(name)
-        .ok()
-        .and_then(|value| value.parse().ok())
-        .unwrap_or(fallback)
-}
-
-#[test]
-#[ignore = "a dump to diff across commits, not a check"]
-fn every_cold_layout_is_printed() {
-    let seeds = env("IRIS_DUMP_SEEDS", 400_u64);
-    let depth = env("IRIS_DUMP_DEPTH", 5_usize);
-    let mut out = String::new();
-    for seed in 1..=seeds {
-        let mut harness = Harness::new((1920.0, 1200.0));
-        let (root, tree) = grow(&mut harness.rsc, seed, depth, &Edits::default());
-        harness.state.root = Some(root);
-        harness.frame();
-        for (index, id) in tree.ids.iter().enumerate() {
-            match harness.region(id) {
-                Some(region) => out.push_str(&format!("{seed} {index} {region:?}\n")),
-                None => out.push_str(&format!("{seed} {index} -\n")),
-            }
-        }
-    }
-    print!("{out}");
-}

tests/scenario/mod.rs

@@ -103,11 +103,6 @@ pub enum Case {
     /// A resize and then a size change, so a retained answer is asked to
     /// survive two different kinds of invalidation in a row.
     ResizeSize,
-    /// A size change and then a resize, which is the other order and not the
-    /// same test: a length answered as a fraction of one box and kept as a
-    /// fraction of another agrees at the size it was changed at and parts
-    /// from it at every other one.
-    SizeResize,
     /// A few declared sizes.
     Size,
     /// Every declared size at once, so every reader of a size has a changed
@@ -124,13 +119,12 @@ pub enum Case {
     Shuffle(Shuffle),
 }
 
-pub const ALL: [Case; 16] = [
+pub const ALL: [Case; 15] = [
     Case::Repaint,
     Case::RepaintSome,
     Case::Resize,
     Case::ResizeRepaint,
     Case::ResizeSize,
-    Case::SizeResize,
     Case::Size,
     Case::EverySize,
     Case::Align,
@@ -152,7 +146,6 @@ impl Case {
             Self::Resize => "resize",
             Self::ResizeRepaint => "resize-repaint",
             Self::ResizeSize => "resize-size",
-            Self::SizeResize => "size-resize",
             Self::Size => "size",
             Self::EverySize => "every-size",
             Self::Align => "align",
@@ -177,15 +170,6 @@ impl Case {
             _ => (STILL, STILL),
         }
     }
-
-    /// The window the warm tree is taken to after the change, where the case
-    /// is about what the change left behind rather than about the change.
-    fn then_resize(self) -> Option<(f32, f32)> {
-        match self {
-            Self::SizeResize => Some(INNER),
-            _ => None,
-        }
-    }
 }
 
 fn mark(warm: &mut Harness, tree: &Tree, step: usize) {
@@ -300,7 +284,7 @@ fn change(case: Case, warm: &mut Harness, tree: &mut Tree, plan: &Plan, rng: &mu
             warm.frame();
             return out;
         }
-        Case::Size | Case::ResizeSize | Case::SizeResize => Edits {
+        Case::Size | Case::ResizeSize => Edits {
             sizes: some_sizes(warm, tree, rng),
             ..Default::default()
         },
@@ -400,17 +384,6 @@ fn describe_widget(id: WidgetId, h: &Harness) -> String {
     label
 }
 
-/// One widget's layout as it stands: the frame its fractions resolved
-/// against, the box it was asked in, the box its drawing went in, and what
-/// it reported. In window units, which is what both trees are in.
-fn record(id: WidgetId, h: &Harness) -> String {
-    let active = &h.render.active[&id];
-    format!(
-        "rel_base {} region {} placement {} size {}",
-        active.rel_base, active.region, active.placement, active.size,
-    )
-}
-
 /// Runs `case` on the tree `plan` describes, warm and cold, and says where
 /// the two disagree. `seed` chooses only the values a case picks at random,
 /// so one plan under one case is one comparison however it was reached.
@@ -427,17 +400,6 @@ pub fn diverges(plan: &Plan, case: Case, seed: u64) -> Option<String> {
         warm.frame();
     }
     let cold_plan = change(case, &mut warm, &mut tree, plan, &mut Rng::new(seed));
-    // Whatever the change left, seen at another window: an answer kept as a
-    // fraction of the wrong length is the same number of pixels where it was
-    // made and a different one everywhere else.
-    let end = match case.then_resize() {
-        Some(after) => {
-            warm.resize(after);
-            warm.frame();
-            after
-        }
-        None => end,
-    };
 
     let mut cold = Harness::new(end);
     let (root, cold_tree) = build(&mut cold.rsc, &cold_plan);
@@ -451,16 +413,9 @@ 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();
-        let mut records = Vec::new();
         let mut at = Some(w);
         while let Some(id) = at {
             let active = &warm.render.active[&id];
@@ -469,22 +424,11 @@ pub fn diverges(plan: &Plan, case: Case, seed: u64) -> Option<String> {
                 false => "*",
             };
             chain.push(format!("{}{node}", describe(id, &warm)));
-            // What each level was asked in on both sides, since the level
-            // where the two stop agreeing is the one to look at rather than
-            // the leaf that reported the difference.
-            let cold_id = places.get(&id).and_then(|&i| cold_tree.ids.get(i));
-            records.push(format!(
-                "    {}\n      warm {}\n      cold {}",
-                describe(id, &warm),
-                record(id, &warm),
-                cold_id.map_or("-".into(), |&id| record(id, &cold)),
-            ));
             at = active.parent;
         }
         return Some(format!(
-            "widget {i}\n  warm {got:?}\n  cold {want:?}\n  {}\n{}",
+            "widget {i}\n  warm {got:?}\n  cold {want:?}\n  {}",
-            chain.join(" < "),
+            chain.join(" < ")
-            records.join("\n"),
         ));
     }
     match drawn {

tests/shrink.rs

@@ -70,14 +70,10 @@ fn no_grown_tree_lays_out_differently_warm_than_cold() {
     over_seeds(seeds, |seed| {
         let grown = plan(seed, depth, &Edits::default());
         for &case in &cases {
-            if diverges(&grown, case, seed).is_none() {
+            let Some(how) = diverges(&grown, case, seed) else {
                 continue;
-            }
+            };
             let small = shrink(grown.clone(), case, seed);
-            // Described from the shrunk tree: the grown tree's chain names
-            // widgets that are no longer there, and the ancestry of the
-            // failure is what a test is written from.
-            let how = diverges(&small, case, seed).unwrap_or_default();
             println!(
                 "seed {seed} case {}: {how}\ngrown {} widgets, shrank to {}\n{small:#?}",
                 case.name(),