Size a widget while drawing it, not in a pass of its own

`desired_width`/`desired_height`, `WidgetAxisFns`, `SizeCtx` and the size
cache are gone. A widget states what it used with `Painter::set_size`
while it draws, and `Painter::widget` hands back a `DrawResult` whose
`size()` both reads the child and records that this widget's size depends
on it. Reading nothing keeps the parent independent of what the child came
to.

`Span` is what the change is for. It takes each child's `size_hint` where
there is one, draws only the children that cannot answer, allocates the
flexible space, then places everything -- which deletes `desired_ortho`,
whose own comment said it "literally copies draw ... which makes this slow
and not cool".

Invalidation follows the dependency edges the draw recorded: a widget that
needs redrawing hands off to the highest ancestor that read its size,
instead of re-running a measurement to find out whether anything changed.

`Widget::size_dependence(axis)` says how much of its box a widget's
drawing depends on -- none of it, its own extent, or the whole box -- so
the retained path can keep a drawing and write a new box into it. Asked
per axis, because wrapped text depends on the width it is offered and not
on the height. `Internal` does not yet buy more than `External`: keeping a
drawing when only the room around it changed is a translation, which waits
for the move chain.

`tests/retained.rs` covers the second frame rather than the first, which
is where the bugs were: a placed child that was not recorded as one got
pruned as departed on the next draw.

`examples/text.rs` is new, since wrapping was the one thing here with no
way to see it on its own.

core/src/event/manager.rs

@@ -79,6 +79,7 @@ type EventData<Rsc, E> = (E, Rc<dyn for<'a> EventFn<Rsc, <E as Event>::Data<'a>>
 pub struct TypeEventManager<Rsc: HasEvents, E: Event> {
     // TODO: reduce visiblity!!
     pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
+    pub global: E::Global,
     map: HashMap<WidgetId, Vec<EventData<Rsc, E>>>,
 }
 
@@ -107,6 +108,7 @@ impl<Rsc: HasEvents, E: Event> Default for TypeEventManager<Rsc, E> {
     fn default() -> Self {
         Self {
             active: Default::default(),
+            global: Default::default(),
             map: Default::default(),
         }
     }
@@ -138,11 +140,13 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
     pub fn run_fn<'a>(
         &mut self,
         id: impl IdLike,
-    ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) + 'a {
+    ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) -> bool + 'a {
         let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
         move |ctx, rsc| {
+            let mut consumed = false;
             for (e, f) in fs {
                 if let Some(data) = e.should_run(&ctx.data) {
+                    consumed |= e.consumes(&data);
                     f(
                         EventCtx {
                             state: ctx.state,
@@ -152,6 +156,7 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
                     )
                 }
             }
+            consumed
         }
     }
 }

core/src/event/mod.rs

@@ -9,10 +9,19 @@ pub use rsc::*;
 pub trait Event: Sized + 'static + Clone {
     type Data<'a>: Clone = ();
     type State: Default = ();
+    /// State the whole event type keeps, rather than one copy per widget.
+    type Global: Default = ();
     #[allow(unused_variables)]
     fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option<Self::Data<'a>> {
         Some(data.clone())
     }
+
+    /// Whether having run on this data uses up whatever triggered it, so
+    /// nothing further should see it.
+    #[allow(unused_variables)]
+    fn consumes(&self, data: &Self::Data<'_>) -> bool {
+        false
+    }
 }
 
 pub trait EventLike {

core/src/event/rsc.rs

@@ -21,12 +21,13 @@ pub trait HasEvents: Sized + UiRsc + HasState {
 }
 
 pub trait RunEvents: HasEvents {
+    /// Whether anything that ran used up what triggered it.
     fn run_event<E: EventLike>(
         &mut self,
         id: impl IdLike,
         data: <E::Event as Event>::Data<'_>,
         state: &mut Self::State,
-    ) {
+    ) -> bool {
         let f = self.events_mut().get_type::<E>().run_fn(id);
         f(EventCtx { state, data }, self)
     }

core/src/ui/active.rs

@@ -1,14 +1,18 @@
-use crate::{LayerId, MaskIdx, PrimitiveHandle, TextureHandle, UiRegion, WidgetId};
+use crate::{LayerId, MaskIdx, PrimitiveHandle, Size, TextureHandle, UiRegion, WidgetId};
 
 /// important non rendering data for retained drawing
 #[derive(Debug)]
 pub struct ActiveData {
     pub id: WidgetId,
     pub region: UiRegion,
+    /// What the widget said it used of `region`, the last time it drew.
+    pub size: Size,
     pub parent: Option<WidgetId>,
     pub textures: Vec<TextureHandle>,
     pub primitives: Vec<PrimitiveHandle>,
     pub children: Vec<WidgetId>,
+    /// The children whose size this widget read while drawing.
+    pub size_deps: Vec<WidgetId>,
     pub mask: MaskIdx,
     pub layer: LayerId,
 }

core/src/ui/cache.rs

@@ -1,18 +0,0 @@
-use crate::{BothAxis, Len, UiVec2, WidgetId, util::HashMap};
-
-#[derive(Default)]
-pub struct Cache {
-    pub size: BothAxis<HashMap<WidgetId, (UiVec2, Len)>>,
-}
-
-impl Cache {
-    pub fn remove(&mut self, id: WidgetId) {
-        self.size.x.remove(&id);
-        self.size.y.remove(&id);
-    }
-
-    pub fn clear(&mut self) {
-        self.size.x.clear();
-        self.size.y.clear();
-    }
-}

core/src/ui/mod.rs

@@ -3,15 +3,12 @@ use crate::{
 };
 
 mod active;
-mod cache;
 mod painter;
 mod render_state;
-mod size;
 
 pub use active::*;
 pub use painter::{Painter, PrimitiveLike};
 pub use render_state::*;
-pub use size::*;
 
 #[derive(Default)]
 pub struct UiData {

core/src/ui/painter.rs

@@ -1,6 +1,6 @@
 use crate::{
-    Axis, Len, RenderedText, Size, SizeCtx, StrongWidget, TextAttrs, TextBuffer, TextData,
-    TextureHandle, UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, Widget, WidgetId,
+    Axis, Len, RenderedText, Size, StrongWidget, TextAttrs, TextBuffer, TextData, TextureHandle,
+    UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, WidgetId,
     render::{
         GlyphPrimitive, Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, PrimitiveKind,
         TexturePrimitive,
@@ -18,6 +18,9 @@ pub struct Painter<'a> {
     pub(super) textures: Vec<TextureHandle>,
     pub(super) primitives: Vec<PrimitiveHandle>,
     pub(super) children: Vec<WidgetId>,
+    /// The children whose size this widget read while drawing.
+    pub(super) size_deps: Vec<WidgetId>,
+    pub(super) size: Option<Size>,
     pub layer: usize,
     pub(super) id: WidgetId,
 }
@@ -67,20 +70,40 @@ impl<'a> Painter<'a> {
         self.mask = self.rsc.ui_mut().masks.push(Mask { region });
     }
 
+    /// States what this widget uses of the box it was handed, once per draw.
+    /// This is the size a parent reads.
+    pub fn set_size(&mut self, size: impl Into<Size>) {
+        debug_assert!(
+            self.size.is_none(),
+            "{} set its size twice in one draw",
+            self.label(),
+        );
+        self.size = Some(size.into());
+    }
+
     /// Draws a widget within this widget's region.
-    pub fn widget<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
-        self.widget_at(id, self.region);
+    pub fn widget<W: ?Sized>(&mut self, id: &StrongWidget<W>) -> DrawResult<'_, 'a> {
+        self.widget_at(id, self.region)
     }
 
     /// Draws a widget somewhere within this one.
     /// Useful for drawing child widgets in select areas.
-    pub fn widget_within<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) {
-        self.widget_at(id, region.within(&self.region));
+    pub fn widget_within<W: ?Sized>(
+        &mut self,
+        id: &StrongWidget<W>,
+        region: UiRegion,
+    ) -> DrawResult<'_, 'a> {
+        let region = region.within(&self.region);
+        self.widget_at(id, region)
     }
 
-    fn widget_at<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) {
+    fn widget_at<W: ?Sized>(
+        &mut self,
+        id: &StrongWidget<W>,
+        region: UiRegion,
+    ) -> DrawResult<'_, 'a> {
         self.children.push(id.id());
-        self.state.draw_inner(
+        let size = self.state.draw_inner(
             self.layer,
             id.id(),
             region,
@@ -89,6 +112,44 @@ impl<'a> Painter<'a> {
             None,
             self.rsc,
         );
+        DrawResult {
+            child: id.id(),
+            painter: self,
+            size,
+        }
+    }
+
+    /// What a child says its length is without being drawn, if it can say.
+    pub fn size_hint<W: ?Sized>(&self, id: &StrongWidget<W>, axis: Axis) -> Option<Len> {
+        self.rsc.widgets().get_dyn(id.id())?.size_hint(axis)
+    }
+
+    /// Gives a child its final box once this widget knows what that is,
+    /// keeping the drawing it already has where it can.
+    pub fn place<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) -> Size {
+        let region = region.within(&self.region);
+        let id = id.id();
+        // Choosing a child's box depends on its size, from a draw or a hint.
+        // Claiming it is separate: one left out of `children` is removed.
+        if !self.size_deps.contains(&id) {
+            self.size_deps.push(id);
+        }
+        if !self.children.contains(&id) {
+            self.children.push(id);
+        }
+        if self.state.active.contains_key(&id) {
+            return self.state.place(id, region, self.rsc);
+        }
+        // Not drawn yet: its length came from a hint, so this is its one draw.
+        self.state.draw_inner(
+            self.layer,
+            id,
+            region,
+            Some(self.id),
+            self.mask,
+            None,
+            self.rsc,
+        )
     }
 
     pub fn render_text(
@@ -129,17 +190,6 @@ impl<'a> Painter<'a> {
         self.region
     }
 
-    pub fn size<W: ?Sized + Widget>(&mut self, id: &StrongWidget<W>) -> Size {
-        self.size_ctx().size(id)
-    }
-
-    pub fn len_axis<W: ?Sized + Widget>(&mut self, id: &StrongWidget<W>, axis: Axis) -> Len {
-        match axis {
-            Axis::X => self.size_ctx().width(id),
-            Axis::Y => self.size_ctx().height(id),
-        }
-    }
-
     pub fn output_size(&self) -> Vec2 {
         self.state.output_size
     }
@@ -167,9 +217,25 @@ impl<'a> Painter<'a> {
     pub fn id(&self) -> &WidgetId {
         &self.id
     }
+}
 
-    pub fn size_ctx(&mut self) -> SizeCtx<'_> {
-        self.state.size_ctx(self.id, self.region.size(), self.rsc)
+/// A child that has just been drawn. Reading its size records that this
+/// widget's own size depends on it; dropping it without reading draws the
+/// child and leaves the parent independent of what it came to.
+pub struct DrawResult<'p, 'a> {
+    painter: &'p mut Painter<'a>,
+    child: WidgetId,
+    size: Size,
+}
+
+impl DrawResult<'_, '_> {
+    pub fn size(self) -> Size {
+        self.painter.size_deps.push(self.child);
+        self.size
+    }
+
+    pub fn len(self, axis: Axis) -> Len {
+        self.size().axis(axis)
     }
 }
 

core/src/ui/render_state.rs

@@ -1,7 +1,6 @@
 use crate::{
-    ActiveData, Axis, DrawLayers, IdLike, MaskIdx, Painter, PixelRegion, SizeCtx, StrongWidget,
-    UiRegion, UiRsc, UiVec2, WidgetId, Widgets,
-    ui::cache::Cache,
+    ActiveData, Axis, DrawLayers, IdLike, MaskIdx, Painter, PixelRegion, Size, SizeDependence,
+    StrongWidget, UiRegion, UiRsc, WidgetId, Widgets,
     util::{HashMap, HashSet, Vec2, forget_ref},
 };
 
@@ -9,7 +8,6 @@ pub struct UiRenderState {
     pub active: HashMap<WidgetId, ActiveData>,
     pub layers: DrawLayers,
     pub(super) output_size: Vec2,
-    pub cache: Cache,
 
     old_root: Option<WidgetId>,
     resized: bool,
@@ -21,7 +19,6 @@ impl UiRenderState {
         Self {
             active: Default::default(),
             layers: Default::default(),
-            cache: Default::default(),
             output_size: Vec2::ZERO,
             old_root: None,
             resized: false,
@@ -84,19 +81,11 @@ impl UiRenderState {
         mask: MaskIdx,
         old_children: Option<Vec<WidgetId>>,
         rsc: &mut dyn UiRsc,
-    ) {
+    ) -> Size {
         let mut old_children = old_children.unwrap_or_default();
-        if let Some(active) = self.active.get_mut(&id)
-            && !rsc.widgets().needs_redraw.contains(&id)
-        {
-            // check to see if we can skip drawing first
-            if active.region == region {
-                return;
-            } else if active.region.size() == region.size() {
-                // TODO: epsilon?
-                let from = active.region;
-                self.mov(id, from, region);
-                return;
+        if self.active.contains_key(&id) {
+            if let Some(size) = self.try_reuse(id, region, rsc) {
+                return size;
             }
             // if not, then maintain resize and track old children to remove unneeded
             let active = self.remove(id, false, rsc).unwrap();
@@ -115,6 +104,8 @@ impl UiRenderState {
             textures: Vec::new(),
             primitives: Vec::new(),
             children: Vec::new(),
+            size_deps: Vec::new(),
+            size: None,
             rsc,
         };
 
@@ -130,18 +121,34 @@ impl UiRenderState {
             textures,
             primitives,
             children,
+            size_deps,
+            size,
             layer,
             id,
         } = painter;
 
+        let size = size.unwrap_or_else(|| {
+            panic!(
+                "'{}' ({id:?}) drew without a size; every widget calls Painter::set_size",
+                rsc.widgets().label(id)
+            )
+        });
+        debug_assert!(
+            Self::hints_agree(id, size, rsc),
+            "'{}' ({id:?}) drew a size its size_hint disagrees with",
+            rsc.widgets().label(id)
+        );
+
         // add to active
         let active = ActiveData {
             id,
             region,
+            size,
             parent,
             textures,
             primitives,
             children,
+            size_deps,
             mask,
             layer,
         };
@@ -155,6 +162,86 @@ impl UiRenderState {
 
         rsc.on_draw(&active);
         self.active.insert(id, active);
+        size
+    }
+
+    /// Gives an already drawn widget a new box, keeping its drawing if it can
+    /// and drawing it again if it cannot.
+    pub(super) fn place(&mut self, id: WidgetId, region: UiRegion, rsc: &mut dyn UiRsc) -> Size {
+        if let Some(size) = self.try_reuse(id, region, rsc) {
+            return size;
+        }
+        let Some(active) = self.remove(id, false, rsc) else {
+            return Size::ZERO;
+        };
+        self.draw_inner(
+            active.layer,
+            id,
+            region,
+            active.parent,
+            active.mask,
+            Some(active.children),
+            rsc,
+        )
+    }
+
+    /// The drawing a widget already has, kept for a new box if the box has not
+    /// changed in a way it depends on.
+    fn try_reuse(&mut self, id: WidgetId, region: UiRegion, rsc: &dyn UiRsc) -> Option<Size> {
+        if rsc.widgets().needs_redraw.contains(&id) {
+            return None;
+        }
+        let active = self.active.get(&id)?;
+        let (size, was) = (active.size, active.region);
+        if was == region {
+            return Some(size);
+        }
+        // TODO: epsilon?
+        if was.size() == region.size() {
+            self.mov(id, was, region);
+            return Some(size);
+        }
+        if self.reusable(id, region, rsc) {
+            // Its drawing stands; the box is written into the primitives.
+            self.mov(id, was, region);
+            return Some(size);
+        }
+        None
+    }
+
+    /// Whether the widget can keep the drawing it has and be given `region`
+    /// instead, asked one axis at a time: a change on an axis it does not
+    /// depend on costs nothing, whatever it depends on elsewhere.
+    fn reusable(&self, id: WidgetId, mut region: UiRegion, rsc: &dyn UiRsc) -> bool {
+        let Some(active) = self.active.get(&id) else {
+            return false;
+        };
+        let Some(widget) = rsc.widgets().get_dyn(id) else {
+            return false;
+        };
+        let mut was = active.region;
+        [Axis::X, Axis::Y].into_iter().all(|axis| {
+            let offered = region.axis_mut(axis).len();
+            let had = was.axis_mut(axis).len();
+            match widget.size_dependence(axis) {
+                SizeDependence::None => true,
+                // `Internal` could also keep its drawing when only the room
+                // around it changed, but that is a translation rather than a
+                // remap, so it waits for the move chain.
+                SizeDependence::Internal | SizeDependence::External => offered == had,
+            }
+        })
+    }
+
+    fn hints_agree(id: WidgetId, size: Size, rsc: &dyn UiRsc) -> bool {
+        let Some(widget) = rsc.widgets().get_dyn(id) else {
+            return true;
+        };
+        [Axis::X, Axis::Y].into_iter().all(|axis| {
+            widget
+                .size_hint(axis)
+                .is_none_or(|hint| hint == size.axis(axis))
+        })
     }
 
     fn mov(&mut self, id: WidgetId, from: UiRegion, to: UiRegion) {
@@ -191,7 +278,6 @@ impl UiRenderState {
     }
 
     fn remove_rec(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) -> Option<ActiveData> {
-        self.cache.remove(id);
         let inst = self.remove(id, true, rsc);
         if let Some(inst) = &inst {
             for c in &inst.children {
@@ -205,7 +291,6 @@ impl UiRenderState {
         for (_, active) in self.active.drain() {
             rsc.on_undraw(&active);
         }
-        self.cache.clear();
         self.layers.clear();
         rsc.widgets_mut().needs_redraw.clear();
         rsc.free();
@@ -267,19 +352,11 @@ impl UiRenderState {
     pub fn redraw(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) {
         rsc.widgets_mut().needs_redraw.remove(&id);
         self.draw_started.remove(&id);
-        // check if parent depends on the desired size of this, if so then redraw it first
-        for axis in [Axis::X, Axis::Y] {
-            if let Some(&(outer, old)) = self.cache.size.axis_dyn(axis).get(&id)
-                && let Some(current) = self.active.get(&id)
-                && let Some(pid) = current.parent
-            {
-                self.cache.size.axis_dyn(axis).remove(&id);
-                let new = self.size_ctx(id, outer, rsc).len_axis(id, axis);
-                self.cache.size.axis_dyn(axis).insert(id, (outer, new));
-                if new != old {
-                    self.redraw(pid, rsc);
-                }
-            }
+        // Whoever read this widget's size may be a different size now, so the
+        // highest reader is what draws; it reaches this one on the way down.
+        if let Some(top) = self.highest_reader(id) {
+            self.redraw(top, rsc);
+            return;
         }
 
         if self.draw_started.contains(&id) {
@@ -301,22 +378,22 @@ impl UiRenderState {
         );
     }
 
-    pub(super) fn size_ctx<'b>(
-        &'b mut self,
-        source: WidgetId,
-        outer: UiVec2,
-        rsc: &'b mut dyn UiRsc,
-    ) -> SizeCtx<'b> {
-        let ui = rsc.ui_mut();
-        SizeCtx {
-            source,
-            cache: &mut self.cache,
-            text: &mut ui.text,
-            widgets: &ui.widgets,
-            outer,
-            output_size: self.output_size,
-            id: source,
+    /// The furthest ancestor that read this widget's size, directly or through
+    /// widgets that did the same.
+    fn highest_reader(&self, id: WidgetId) -> Option<WidgetId> {
+        let mut top = None;
+        let mut at = id;
+        while let Some(active) = self.active.get(&at)
+            && let Some(parent) = active.parent
+            && self
+                .active
+                .get(&parent)
+                .is_some_and(|p| p.size_deps.contains(&at))
+        {
+            top = Some(parent);
+            at = parent;
         }
+        top
     }
 }
 

core/src/ui/size.rs

@@ -1,89 +0,0 @@
-use crate::{
-    Axis, AxisT, IdLike, Len, RenderedText, Size, TextAttrs, TextBuffer, TextData, UiVec2,
-    WidgetAxisFns, WidgetId, Widgets, XAxis, YAxis, ui::cache::Cache, util::Vec2,
-};
-
-pub struct SizeCtx<'a> {
-    pub text: &'a mut TextData,
-    pub(super) source: WidgetId,
-    pub(super) widgets: &'a Widgets,
-    pub(super) cache: &'a mut Cache,
-    /// TODO: should this be pub? rn used for sized
-    pub outer: UiVec2,
-    pub(super) output_size: Vec2,
-    pub(super) id: WidgetId,
-}
-
-impl SizeCtx<'_> {
-    pub fn id(&self) -> &WidgetId {
-        &self.id
-    }
-
-    pub fn source(&self) -> &WidgetId {
-        &self.source
-    }
-
-    pub(super) fn len_inner<A: const AxisT>(&mut self, id: WidgetId) -> Len {
-        if let Some((_, len)) = self.cache.size.axis::<A>().get(&id) {
-            return *len;
-        }
-        let len = self
-            .widgets
-            .get_dyn_dynamic(id)
-            .desired_len::<A>(&mut SizeCtx {
-                text: self.text,
-                source: self.source,
-                widgets: self.widgets,
-                cache: self.cache,
-                outer: self.outer,
-                output_size: self.output_size,
-                id,
-            });
-        self.cache.size.axis::<A>().insert(id, (self.outer, len));
-        len
-    }
-
-    pub fn width(&mut self, id: impl IdLike) -> Len {
-        self.len_inner::<XAxis>(id.id())
-    }
-
-    pub fn height(&mut self, id: impl IdLike) -> Len {
-        self.len_inner::<YAxis>(id.id())
-    }
-
-    pub fn len_axis(&mut self, id: impl IdLike, axis: Axis) -> Len {
-        match axis {
-            Axis::X => self.width(id),
-            Axis::Y => self.height(id),
-        }
-    }
-
-    pub fn size(&mut self, id: impl IdLike) -> Size {
-        let id = id.id();
-        Size {
-            x: self.width(id),
-            y: self.height(id),
-        }
-    }
-
-    pub fn px_size(&mut self) -> Vec2 {
-        self.outer.to_abs(self.output_size)
-    }
-
-    pub fn output_size(&mut self) -> Vec2 {
-        self.output_size
-    }
-
-    pub fn draw_text(
-        &mut self,
-        buffer: &mut TextBuffer,
-        attrs: &TextAttrs,
-        width: Option<f32>,
-    ) -> RenderedText {
-        self.text.render(buffer, attrs, width)
-    }
-
-    pub fn label(&self, id: WidgetId) -> &String {
-        self.widgets.label(id)
-    }
-}

core/src/widget/mod.rs

@@ -1,4 +1,4 @@
-use crate::{Axis, AxisT, Len, Painter, SizeCtx};
+use crate::{Axis, Len, Painter, Size};
 use std::any::Any;
 
 mod data;
@@ -15,32 +15,49 @@ pub use tag::*;
 pub use view::*;
 pub use widgets::*;
 
+/// How much of the box a widget was handed its drawing depends on, and so
+/// what has to change before it must be drawn again. Asked per axis, because
+/// wrapped text depends on the width it is offered and not on the height.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum SizeDependence {
+    /// None of it: the box only says where the primitives go, so a new one is
+    /// written into them instead of drawn.
+    None,
+    /// Its own extent, whatever box that sits in. Reusable in any box that
+    /// leaves that extent unchanged, including a larger one it does not fill.
+    #[default]
+    Internal,
+    /// The extent of the box itself, used or not.
+    External,
+}
+
 pub trait Widget: Any {
+    /// Draws the widget, and states what it used with `Painter::set_size`.
     fn draw(&mut self, painter: &mut Painter);
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len;
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len;
-}
 
-pub trait WidgetAxisFns {
-    fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len;
-}
+    /// An exact length the widget can give without a painter or its children.
+    /// Optional, and saves a draw rather than changing one: a hint that
+    /// disagrees with the eventual draw fails a debug assertion.
+    fn size_hint(&self, _axis: Axis) -> Option<Len> {
+        None
+    }
 
-impl<W: Widget + ?Sized> WidgetAxisFns for W {
-    fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len {
-        match A::get() {
-            Axis::X => self.desired_width(ctx),
-            Axis::Y => self.desired_height(ctx),
-        }
+    fn size_dependence(&self, _axis: Axis) -> SizeDependence {
+        SizeDependence::Internal
     }
 }
 
 impl Widget for () {
-    fn draw(&mut self, _: &mut Painter) {}
-    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
-        Len::ZERO
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.set_size(Size::ZERO);
     }
-    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
-        Len::ZERO
+
+    fn size_hint(&self, _axis: Axis) -> Option<Len> {
+        Some(Len::ZERO)
+    }
+
+    fn size_dependence(&self, _axis: Axis) -> SizeDependence {
+        SizeDependence::None
     }
 }
 

examples/text.rs

@@ -0,0 +1,63 @@
+//! Text sizing: wrapped text reads the width it is offered, fixed text does
+//! not, and both report a height their container lays out around.
+
+use iris::prelude::*;
+
+fn main() {
+    DefaultApp::<State>::run();
+}
+
+#[derive(DefaultUiState)]
+struct State {
+    ui_state: DefaultUiState,
+}
+
+const SAMPLE: &str = "Wrapping shapes one source into as many lines as its container \
+    leaves room for, so the height of a paragraph is an answer rather than a setting, and \
+    the same words in a narrower box come back taller. Resize the window and watch the \
+    text below reflow into a different number of lines while nothing about it changes.";
+
+impl DefaultAppState for State {
+    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
+        let panel = || rect(Color::WHITE.darker(0.85));
+
+        let wrapped = wtext(SAMPLE)
+            .size(28)
+            .wrap(true)
+            .text_align(Align::LEFT)
+            .pad(16)
+            .background(panel());
+
+        let aligned = (
+            wtext("left").size(24).text_align(Align::LEFT),
+            wtext("centred").size(24).text_align(Align::CENTER),
+            wtext("right").size(24).text_align(Align::RIGHT),
+        )
+            .span(Dir::DOWN)
+            .gap(8)
+            .pad(16)
+            .background(panel());
+
+        // The same words in half the width, which is a different number of
+        // lines and so a different height. A declared width only holds along
+        // a span's own axis, hence the row.
+        let narrow = (
+            wtext(SAMPLE)
+                .size(20)
+                .wrap(true)
+                .pad(16)
+                .background(panel())
+                .align(Align::TOP)
+                .width(rel(0.5)),
+            rect(Color::WHITE.darker(0.95)),
+        )
+            .span(Dir::RIGHT);
+
+        (wrapped, aligned, narrow)
+            .span(Dir::DOWN)
+            .gap(12)
+            .pad(12)
+            .set_root(rsc, &mut ui_state);
+        Self { ui_state }
+    }
+}

src/default/mod.rs

@@ -235,8 +235,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
             ui_state.focus = None;
         }
         if input_changed {
-            let window_size = ui_state.window_size();
-            render.run_sensors(rsc, state, cursor_state, window_size);
+            render.run_sensors(rsc, state, cursor_state);
         }
         let ui_state = state.default_state_mut();
         if old != ui_state.focus

src/default/sense.rs

@@ -4,14 +4,14 @@ use std::{
     rc::Rc,
 };
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum CursorButton {
     Left,
     Right,
     Middle,
 }
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub enum CursorSense {
     PressStart(CursorButton),
     Pressing(CursorButton),
@@ -27,7 +27,7 @@ pub struct CursorSenses(Vec<CursorSense>);
 
 impl Event for CursorSenses {
     type Data<'a> = CursorData<'a>;
-    type State = SensorState;
+    type Global = Hovered;
     fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option<Self::Data<'a>> {
         if let Some(sense) = should_run(self, &data.cursor, data.hover) {
             let mut data = data.clone();
@@ -37,6 +37,24 @@ impl Event for CursorSenses {
             None
         }
     }
+
+    /// A press or a scroll is used up by whatever answered it, so it stops
+    /// there. Hovering is not: a cursor resting somewhere goes on resting.
+    fn consumes(&self, data: &Self::Data<'_>) -> bool {
+        !data.sense.position_only()
+    }
+}
+
+/// Who the cursor was inside, before and after an input. The difference is
+/// whose hover has ended -- including a widget a higher layer has covered,
+/// which the walk stops before reaching.
+///
+/// Two buffers that swap rather than one rebuilt, so an input allocates
+/// nothing once they have grown.
+#[derive(Default)]
+pub struct Hovered {
+    was: Vec<WidgetId>,
+    now: Vec<WidgetId>,
 }
 
 impl CursorSense {
@@ -52,6 +70,12 @@ impl CursorSense {
     pub fn is_dragging(&self) -> bool {
         matches!(self, CursorSense::Pressing(CursorButton::Left))
     }
+
+    /// False if the sense is a button or a scroll, true if it is only about
+    /// where the cursor is.
+    fn position_only(&self) -> bool {
+        matches!(self, Self::HoverStart | Self::Hovering | Self::HoverEnd)
+    }
 }
 
 #[derive(Default, Clone)]
@@ -96,6 +120,12 @@ impl CursorButtons {
 }
 
 impl CursorState {
+    /// True if the cursor is only reporting where it is: no button and no
+    /// scroll this frame.
+    pub fn position_only(&self) -> bool {
+        self.scroll_delta == Vec2::ZERO && self.buttons.iter().all(|(_, state)| state.is_off())
+    }
+
     pub fn end_frame(&mut self) {
         self.buttons.end_frame();
         self.scroll_delta = Vec2::ZERO;
@@ -123,11 +153,6 @@ pub struct Sensor<Ctx: HasEvents, Data> {
 
 pub type SenseShape = UiRegion;
 
-#[derive(Default, Debug)]
-pub struct SensorState {
-    pub hover: ActivationState,
-}
-
 #[derive(Clone)]
 pub struct CursorData<'a> {
     /// where this widget was hit
@@ -147,7 +172,6 @@ pub trait SensorUi {
         rsc: &mut Rsc,
         state: &mut Rsc::State,
         cursor: CursorState,
-        window_size: Vec2,
     );
 }
 
@@ -157,54 +181,98 @@ impl SensorUi for UiRenderState {
         rsc: &mut Rsc,
         state: &mut Rsc::State,
         cursor: CursorState,
-        window_size: Vec2,
     ) {
         // in order to remove this take, need to store active list in UiRenderState somehow
         // this would probably be done through a generic parameter that adds yet another rsc /
         // state like thing, but local to render state, and is passed to UiRsc events so you can
         // update it there?
-        let mut active = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().active);
+        let active = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().active);
+        let mut hovered = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().global);
+        hovered.now.clear();
+        let position_only = cursor.position_only();
+        let region_of = |id| self.window_region(&id);
+
         for layer in self.layers.indices().rev() {
-            let mut sensed = false;
-            for (id, sensor) in active.get_mut(&layer).into_flat_iter() {
-                let shape = self.active.get(id).unwrap().region;
-                let region = shape.to_px(window_size);
-                let in_shape = cursor.exists && region.contains(cursor.pos);
-                sensor.hover.update(in_shape);
-                if sensor.hover == ActivationState::Off {
+            let mut consumed = false;
+            for id in active.get(&layer).into_flat_iter().map(|(id, _)| *id) {
+                let Some(region) = region_of(id) else {
+                    continue;
+                };
+                if !cursor.exists || !region.contains(cursor.pos) {
                     continue;
                 }
-                sensed = true;
-
-                let cursor = cursor.clone();
-
-                let data = CursorData {
-                    pos: cursor.pos - region.top_left,
-                    size: region.bot_right - region.top_left,
-                    scroll_delta: cursor.scroll_delta,
-                    hover: sensor.hover,
-                    cursor,
-                    // this does not have any meaning;
-                    // might wanna set up Event to have a prepare stage
-                    sense: CursorSense::Hovering,
-                    render: self,
+                hovered.now.push(id);
+                let hover = match hovered.was.contains(&id) {
+                    true => ActivationState::On,
+                    false => ActivationState::Start,
                 };
-                rsc.run_event::<CursorSense>(*id, data, state);
+                // A press or a scroll stops where something answered it, so a
+                // button over a list does not swallow the list's scrolling.
+                consumed |= deliver(self, rsc, state, id, hover, &cursor, region);
+                // A cursor doing neither stops at whatever it is over, so
+                // hovering does not reach through.
+                consumed |= position_only;
             }
-            if sensed {
+            // Applied after the layer, never during it: senses on one layer do
+            // not block each other.
+            if consumed {
                 break;
             }
         }
-        rsc.events_mut().get_type::<CursorSense>().active = active;
+
+        // Whatever the cursor was inside and is not now, whether it left or a
+        // layer above took the input before the walk reached it. A widget that
+        // stopped being drawn has no region to report and is simply dropped.
+        for &id in &hovered.was {
+            if !hovered.now.contains(&id)
+                && let Some(region) = region_of(id)
+            {
+                deliver(self, rsc, state, id, ActivationState::End, &cursor, region);
+            }
+        }
+        std::mem::swap(&mut hovered.was, &mut hovered.now);
+
+        let senses = rsc.events_mut().get_type::<CursorSense>();
+        senses.active = active;
+        senses.global = hovered;
     }
 }
 
+/// Runs one widget's cursor senses, and says whether they used up the input.
+fn deliver<Rsc: HasEvents>(
+    render: &UiRenderState,
+    rsc: &mut Rsc,
+    state: &mut Rsc::State,
+    id: WidgetId,
+    hover: ActivationState,
+    cursor: &CursorState,
+    region: PixelRegion,
+) -> bool {
+    let data = CursorData {
+        pos: cursor.pos - region.top_left,
+        size: region.bot_right - region.top_left,
+        scroll_delta: cursor.scroll_delta,
+        hover,
+        cursor: cursor.clone(),
+        // this does not have any meaning;
+        // might wanna set up Event to have a prepare stage
+        sense: CursorSense::Hovering,
+        render,
+    };
+    rsc.run_event::<CursorSense>(id, data, state)
+}
+
 pub fn should_run(
     senses: &CursorSenses,
     cursor: &CursorState,
     hover: ActivationState,
 ) -> Option<CursorSense> {
     for sense in senses.iter() {
+        // A widget the cursor is no longer inside senses only its position:
+        // the press that ended its hover landed on something else.
+        if !hover.is_on() && !sense.position_only() {
+            continue;
+        }
         if match sense {
             CursorSense::PressStart(button) => cursor.buttons.select(button).is_start(),
             CursorSense::Pressing(button) => cursor.buttons.select(button).is_on(),

src/harness.rs

@@ -173,9 +173,8 @@ impl Harness {
     /// window delivers input against too.
     fn sense(&mut self) {
         let cursor = self.cursor.clone();
-        let size = self.render.output_size();
         self.render
-            .run_sensors(&mut self.rsc, &mut self.state, cursor, size);
+            .run_sensors(&mut self.rsc, &mut self.state, cursor);
         self.cursor.end_frame();
     }
 }

src/widget/image.rs

@@ -8,14 +8,15 @@ pub struct Image {
 impl Widget for Image {
     fn draw(&mut self, painter: &mut Painter) {
         painter.primitive(&self.handle);
+        painter.set_size(Size::abs(self.handle.size()));
     }
 
-    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
-        Len::abs(self.handle.size().x)
+    fn size_hint(&self, axis: Axis) -> Option<Len> {
+        Some(Len::abs(self.handle.size().axis(axis)))
     }
 
-    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
-        Len::abs(self.handle.size().y)
+    fn size_dependence(&self, _: Axis) -> SizeDependence {
+        SizeDependence::None
     }
 }
 

src/widget/mask.rs

@@ -7,14 +7,12 @@ pub struct Masked {
 impl Widget for Masked {
     fn draw(&mut self, painter: &mut Painter) {
         painter.set_mask(painter.region());
-        painter.widget(&self.inner);
+        let size = painter.widget(&self.inner).size();
+        painter.set_size(size);
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.width(&self.inner)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.height(&self.inner)
+    /// It clips to the box it was given, not to the part its child used.
+    fn size_dependence(&self, _: Axis) -> SizeDependence {
+        SizeDependence::External
     }
 }

src/widget/position/align.rs

@@ -7,29 +7,16 @@ pub struct Aligned {
 
 impl Widget for Aligned {
     fn draw(&mut self, painter: &mut Painter) {
+        // Drawn where it may be too big, then given its aligned box once its
+        // size is known.
+        let size = painter.widget(&self.inner).size();
         let region = match self.align.tuple() {
-            (Some(x), Some(y)) => painter
-                .size(&self.inner)
-                .to_uivec2()
-                .align(RegionAlign { x, y }),
-            (Some(x), None) => {
-                let x = painter.size_ctx().width(&self.inner).apply_rest().align(x);
-                UiRegion::new(x, UiSpan::FULL)
-            }
-            (None, Some(y)) => {
-                let y = painter.size_ctx().height(&self.inner).apply_rest().align(y);
-                UiRegion::new(UiSpan::FULL, y)
-            }
+            (Some(x), Some(y)) => size.to_uivec2().align(RegionAlign { x, y }),
+            (Some(x), None) => UiRegion::new(size.x.apply_rest().align(x), UiSpan::FULL),
+            (None, Some(y)) => UiRegion::new(UiSpan::FULL, size.y.apply_rest().align(y)),
             (None, None) => UiRegion::FULL,
         };
-        painter.widget_within(&self.inner, region);
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.width(&self.inner)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.height(&self.inner)
+        painter.place(&self.inner, region);
+        painter.set_size(size);
     }
 }

src/widget/position/layer.rs

@@ -10,14 +10,7 @@ impl Widget for LayerOffset {
         for _ in 0..self.offset {
             painter.next_layer();
         }
-        painter.widget(&self.inner);
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.width(&self.inner)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.height(&self.inner)
+        let size = painter.widget(&self.inner).size();
+        painter.set_size(size);
     }
 }

src/widget/position/max_size.rs

@@ -6,43 +6,22 @@ pub struct MaxSize {
     pub y: Option<Len>,
 }
 
-impl MaxSize {
-    fn apply_to_outer(&self, ctx: &mut SizeCtx) {
-        if let Some(x) = self.x {
-            ctx.outer.x.select_len(x.apply_rest());
-        }
-        if let Some(y) = self.y {
-            ctx.outer.y.select_len(y.apply_rest());
-        }
-    }
-}
+impl MaxSize {}
 
 impl Widget for MaxSize {
     fn draw(&mut self, painter: &mut Painter) {
-        painter.widget(&self.inner);
+        let child = painter.widget(&self.inner).size();
+        let output = painter.output_size();
+        painter.set_size(Size {
+            x: capped(child.x, self.x, output.x),
+            y: capped(child.y, self.y, output.y),
+        });
     }
+}
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.apply_to_outer(ctx);
-        let width = ctx.width(&self.inner);
-        if let Some(x) = self.x {
-            let width_px = width.apply_rest().to_abs(ctx.output_size().x);
-            let x_px = x.apply_rest().to_abs(ctx.output_size().x);
-            if width_px > x_px { x } else { width }
-        } else {
-            width
-        }
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.apply_to_outer(ctx);
-        let height = ctx.height(&self.inner);
-        if let Some(y) = self.y {
-            let height_px = height.apply_rest().to_abs(ctx.output_size().y);
-            let y_px = y.apply_rest().to_abs(ctx.output_size().y);
-            if height_px > y_px { y } else { height }
-        } else {
-            height
-        }
+fn capped(len: Len, max: Option<Len>, output: f32) -> Len {
+    match max {
+        Some(max) if len.apply_rest().to_abs(output) > max.apply_rest().to_abs(output) => max,
+        _ => len,
     }
 }

src/widget/position/offset.rs

@@ -8,14 +8,7 @@ pub struct Offset {
 impl Widget for Offset {
     fn draw(&mut self, painter: &mut Painter) {
         let region = UiRegion::FULL.offset(self.amt);
-        painter.widget_within(&self.inner, region);
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.width(&self.inner)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.height(&self.inner)
+        let size = painter.widget_within(&self.inner, region).size();
+        painter.set_size(size);
     }
 }

src/widget/position/pad.rs

@@ -7,27 +7,19 @@ pub struct Pad {
 
 impl Widget for Pad {
     fn draw(&mut self, painter: &mut Painter) {
-        painter.widget_within(&self.inner, self.padding.region());
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        let width = self.padding.left + self.padding.right;
-        let height = self.padding.top + self.padding.bottom;
-        ctx.outer.x.abs -= width;
-        ctx.outer.y.abs -= height;
-        let mut size = ctx.width(&self.inner);
-        size.abs += width;
-        size
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        let width = self.padding.left + self.padding.right;
-        let height = self.padding.top + self.padding.bottom;
-        ctx.outer.x.abs -= width;
-        ctx.outer.y.abs -= height;
-        let mut size = ctx.height(&self.inner);
-        size.abs += height;
-        size
+        let inner = painter
+            .widget_within(&self.inner, self.padding.region())
+            .size();
+        painter.set_size(Size {
+            x: Len {
+                abs: inner.x.abs + self.padding.left + self.padding.right,
+                ..inner.x
+            },
+            y: Len {
+                abs: inner.y.abs + self.padding.top + self.padding.bottom,
+                ..inner.y
+            },
+        });
     }
 }
 

src/widget/position/scroll.rs

@@ -13,8 +13,11 @@ impl Widget for Scroll {
     fn draw(&mut self, painter: &mut Painter) {
         let output_len = painter.output_size().axis(self.axis);
         let container_len = painter.region().axis(self.axis).len();
-        let content_len = painter
-            .len_axis(&self.inner, self.axis)
+        // Drawn in the whole container to learn its length, then placed at
+        // the scrolled offset.
+        let child = painter.widget(&self.inner).size();
+        let content_len = child
+            .axis(self.axis)
             .apply_rest()
             .within_len(container_len)
             .to_abs(output_len);
@@ -28,15 +31,8 @@ impl Widget for Scroll {
 
         let mut region = UiRegion::FULL.offset(Vec2::from_axis(self.axis, -self.amt, 0.0));
         region.axis_mut(self.axis).end = region.axis(self.axis).start.offset(self.content_len);
-        painter.widget_within(&self.inner, region);
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.width(&self.inner)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.height(&self.inner)
+        painter.place(&self.inner, region);
+        painter.set_size(child);
     }
 }
 

src/widget/position/set_size.rs

@@ -6,29 +6,23 @@ pub struct SetSize {
     pub y: Option<Len>,
 }
 
-impl SetSize {
-    fn apply_to_outer(&self, ctx: &mut SizeCtx) {
-        if let Some(x) = self.x {
-            ctx.outer.x.select_len(x.apply_rest());
-        }
-        if let Some(y) = self.y {
-            ctx.outer.y.select_len(y.apply_rest());
-        }
-    }
-}
+impl SetSize {}
 
 impl Widget for SetSize {
     fn draw(&mut self, painter: &mut Painter) {
-        painter.widget(&self.inner);
+        let child = painter.widget(&self.inner).size();
+        painter.set_size(Size {
+            x: self.x.unwrap_or(child.x),
+            y: self.y.unwrap_or(child.y),
+        });
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.apply_to_outer(ctx);
-        self.x.unwrap_or_else(|| ctx.width(&self.inner))
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.apply_to_outer(ctx);
-        self.y.unwrap_or_else(|| ctx.height(&self.inner))
+    /// A declared axis is known without looking at the child, which is what
+    /// lets a span lay out around `.height(rest(1))` without drawing it.
+    fn size_hint(&self, axis: Axis) -> Option<Len> {
+        match axis {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
     }
 }

src/widget/position/span.rs

@@ -9,12 +9,26 @@ pub struct Span {
 
 impl Widget for Span {
     fn draw(&mut self, painter: &mut Painter) {
-        let total = self.len_sum(&mut painter.size_ctx());
+        let axis = self.dir.axis;
+        // A length for every child before any is placed: from its own hint
+        // where it has one, and from drawing it where it does not.
+        let lens: Vec<Len> = self
+            .children
+            .iter()
+            .map(|child| match painter.size_hint(child, axis) {
+                Some(len) => len,
+                None => painter.widget(child).len(axis),
+            })
+            .collect();
+
+        let gap = self.gap * self.children.len().saturating_sub(1) as f32;
+        let total = lens.iter().fold(Len::abs(gap), |sum, len| sum + *len);
+
         let mut start = UiScalar::rel_min();
-        for child in &self.children {
+        let mut ortho = Len::ZERO;
+        for (child, len) in self.children.iter().zip(&lens) {
             let mut span = UiSpan::FULL;
             span.start = start;
-            let len = painter.len_axis(child, self.dir.axis);
             if len.rest > 0.0 {
                 let offset = UiScalar::new(total.rel, total.abs);
                 let rel_end = UiScalar::rel(len.rest / total.rest);
@@ -24,27 +38,25 @@ impl Widget for Span {
             start.abs += len.abs;
             start.rel += len.rel;
             span.end = start;
-            let mut child_region = UiRegion::from_axis(self.dir.axis, span, UiSpan::FULL);
+            let mut region = UiRegion::from_axis(axis, span, UiSpan::FULL);
             if self.dir.sign == Sign::Neg {
-                child_region.flip(self.dir.axis);
+                region.flip(axis);
+            }
+            let used = painter.place(child, region).axis(!axis);
+            // TODO: rel shouldn't do this, but no easy way before actually calculating pixels
+            if used.rel > 0.0 || used.rest > 0.0 {
+                ortho = Len::REST;
+            } else if ortho.rest == 0.0 {
+                ortho.abs = ortho.abs.max(used.abs);
             }
-            painter.widget_within(child, child_region);
             start.abs += self.gap;
         }
-    }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        match self.dir.axis {
-            Axis::X => self.desired_len(ctx),
-            Axis::Y => self.desired_ortho(ctx),
-        }
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        match self.dir.axis {
-            Axis::X => self.desired_ortho(ctx),
-            Axis::Y => self.desired_len(ctx),
-        }
+        let along = match total.rest == 0.0 && total.rel == 0.0 {
+            true => total,
+            false => Len::default(),
+        };
+        painter.set_size(Size::from_axis(axis, along, ortho));
     }
 }
 
@@ -69,87 +81,6 @@ impl Span {
     pub fn pop(&mut self) -> Option<StrongWidget> {
         self.children.pop()
     }
-
-    fn len_sum(&mut self, ctx: &mut SizeCtx) -> Len {
-        let gap = self.gap * self.children.len().saturating_sub(1) as f32;
-        self.children.iter().fold(Len::abs(gap), |mut s, id| {
-            // it's tempting to subtract the abs & rel from the ctx outer,
-            // but that would create inconsistent sizing if you put
-            // a rest first vs last & only speed up in one direction.
-            // I think this is only solvable by restricting how you can
-            // compute size, bc currently you need child to define parent's
-            // sectioning and you need parent's sectioning to define child.
-            // Fortunately, that doesn't matter in most cases
-            let len = ctx.len_axis(id, self.dir.axis);
-            s += len;
-            s
-        })
-    }
-
-    fn desired_len(&mut self, ctx: &mut SizeCtx) -> Len {
-        let len = self.len_sum(ctx);
-        if len.rest == 0.0 && len.rel == 0.0 {
-            len
-        } else {
-            Len::default()
-        }
-    }
-
-    fn desired_ortho(&mut self, ctx: &mut SizeCtx) -> Len {
-        // this is a weird hack to get text wrapping to work properly when in a downward span
-        // the correct solution here is to add a function to widget that lets them
-        // request that ctx.outer has an axis "resolved" before checking the other,
-        // and panicking or warning if two request opposite axis (unsolvable in that case)
-        let outer = ctx.outer.axis(self.dir.axis);
-        if self.dir.axis == Axis::X {
-            // so....... this literally copies draw so that the lengths are correctly set in the
-            // context, which makes this slow and not cool
-            let total = self.len_sum(ctx);
-            let mut start = UiScalar::rel_min();
-            let mut ortho_len = Len::ZERO;
-            for child in &self.children {
-                let mut span = UiSpan::FULL;
-                span.start = start;
-                let len = ctx.len_axis(child, self.dir.axis);
-                if len.rest > 0.0 {
-                    let offset = UiScalar::new(total.rel, total.abs);
-                    let rel_end = UiScalar::rel(len.rest / total.rest);
-                    let end = (UiScalar::rel_max() + start) - offset;
-                    start = rel_end.within(&start.to(end));
-                }
-                start.abs += len.abs;
-                start.rel += len.rel;
-                span.end = start;
-
-                let scalar = span.len();
-                *ctx.outer.axis_mut(self.dir.axis) = outer.select_len(scalar);
-                let ortho = ctx.len_axis(child, !self.dir.axis);
-                // TODO: rel shouldn't do this, but no easy way before actually calculating pixels
-                if ortho.rel > 0.0 || ortho.rest > 0.0 {
-                    ortho_len.rest = 1.0;
-                    ortho_len.abs = 0.0;
-                    break;
-                }
-                ortho_len.abs = ortho_len.abs.max(ortho.abs);
-                start.abs += self.gap;
-            }
-            ortho_len
-        } else {
-            let mut ortho_len = Len::ZERO;
-            let ortho = !self.dir.axis;
-            for child in &self.children {
-                let len = ctx.len_axis(child, ortho);
-                // TODO: rel shouldn't do this, but no easy way before actually calculating pixels
-                if len.rel > 0.0 || len.rest > 0.0 {
-                    ortho_len.rest = 1.0;
-                    ortho_len.abs = 0.0;
-                    break;
-                }
-                ortho_len.abs = ortho_len.abs.max(len.abs);
-            }
-            ortho_len
-        }
-    }
 }
 
 pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {

src/widget/position/stack.rs

@@ -9,29 +9,24 @@ pub struct Stack {
 
 impl Widget for Stack {
     fn draw(&mut self, painter: &mut Painter) {
-        let mut iter = self.children.iter();
-        if let Some(child) = iter.next() {
-            painter.child_layer();
-            painter.widget(child);
-        }
-        for child in iter {
-            painter.next_layer();
-            painter.widget(child);
-        }
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        match self.size {
-            StackSize::Default => Len::default(),
-            StackSize::Child(i) => ctx.width(&self.children[i]),
-        }
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        match self.size {
-            StackSize::Default => Len::default(),
-            StackSize::Child(i) => ctx.height(&self.children[i]),
+        let sizing = match self.size {
+            StackSize::Default => None,
+            StackSize::Child(i) => Some(i),
+        };
+        let mut size = Size::default();
+        for (i, child) in self.children.iter().enumerate() {
+            match i {
+                0 => painter.child_layer(),
+                _ => painter.next_layer(),
+            }
+            let drawn = painter.widget(child);
+            // Only the child that sizes the stack is read, so the others
+            // changing size does not redraw it.
+            if sizing == Some(i) {
+                size = drawn.size();
+            }
         }
+        painter.set_size(size);
     }
 }
 

src/widget/ptr.rs

@@ -7,25 +7,11 @@ pub struct WidgetPtr {
 
 impl Widget for WidgetPtr {
     fn draw(&mut self, painter: &mut Painter) {
-        if let Some(id) = &self.inner {
-            painter.widget(id);
-        }
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(id) = &self.inner {
-            ctx.width(id)
-        } else {
-            Len::ZERO
-        }
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(id) = &self.inner {
-            ctx.height(id)
-        } else {
-            Len::ZERO
-        }
+        let size = match &self.inner {
+            Some(id) => painter.widget(id).size(),
+            None => Size::ZERO,
+        };
+        painter.set_size(size);
     }
 }
 

src/widget/rect.rs

@@ -35,14 +35,16 @@ impl Widget for Rect {
             thickness: self.thickness,
             inner_radius: self.inner_radius,
         });
+        painter.set_size(Size::REST);
     }
 
-    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
-        Len::rest(1)
+    fn size_hint(&self, _: Axis) -> Option<Len> {
+        Some(Len::REST)
     }
 
-    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
-        Len::rest(1)
+    /// Its box is its primitive's own region, so a new one is written there.
+    fn size_dependence(&self, _: Axis) -> SizeDependence {
+        SizeDependence::None
     }
 }
 

src/widget/text/edit.rs

@@ -58,7 +58,8 @@ impl Widget for TextEdit {
     fn draw(&mut self, painter: &mut Painter) {
         let base = painter.layer;
         painter.child_layer();
-        self.view.draw(painter);
+        let (_, size) = self.view.draw(painter);
+        painter.set_size(size);
         painter.layer = base;
         let region = self.region();
 
@@ -87,12 +88,8 @@ impl Widget for TextEdit {
         );
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.view.desired_width(ctx)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.view.desired_height(ctx)
+    fn size_dependence(&self, axis: Axis) -> SizeDependence {
+        self.view.size_dependence(axis)
     }
 }
 

src/widget/text/mod.rs

@@ -52,15 +52,15 @@ impl TextView {
             .align(self.align)
     }
 
-    fn render(&mut self, ctx: &mut SizeCtx) -> &RenderedText {
+    fn render(&mut self, painter: &mut Painter) -> &RenderedText {
         let width = if self.attrs.wrap {
-            Some(ctx.px_size().x)
+            Some(painter.px_size().x)
         } else {
             None
         };
         if width != self.width || self.tex.is_none() || self.attrs.changed || self.buf.changed {
             self.width = width;
-            self.tex = Some(ctx.draw_text(&mut self.buf, &self.attrs, width));
+            self.tex = Some(painter.render_text(&mut self.buf, &self.attrs, width));
             self.attrs.changed = false;
             self.buf.changed = false;
         }
@@ -69,39 +69,33 @@ impl TextView {
     pub fn tex(&self) -> Option<&RenderedText> {
         self.tex.as_ref()
     }
-    pub fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        if self.is_empty()
-            && let Some(hint) = &self.hint
-        {
-            ctx.width(hint)
-        } else {
-            Len::abs(self.render(ctx).size.x)
-        }
-    }
-    pub fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        if self.is_empty()
-            && let Some(hint) = &self.hint
-        {
-            ctx.height(hint)
-        } else {
-            Len::abs(self.render(ctx).size.y)
-        }
-    }
-    pub fn draw(&mut self, painter: &mut Painter) -> UiRegion {
+    /// Draws the text, and says where the glyphs went and what they use.
+    pub fn draw(&mut self, painter: &mut Painter) -> (UiRegion, Size) {
         let align = self.align;
         if self.is_empty() && self.hint.is_some() {
-            let region = self.render(&mut painter.size_ctx()).size.align(align);
-            if let Some(hint) = &self.hint {
-                painter.widget(hint);
-            }
-            return region;
+            let region = self.render(painter).size.align(align);
+            let size = match &self.hint {
+                Some(hint) => painter.widget(hint).size(),
+                None => Size::ZERO,
+            };
+            return (region, size);
         }
 
-        let tex = self.render(&mut painter.size_ctx());
+        let tex = self.render(painter);
         let region = tex.size.align(align);
+        let size = Size::abs(tex.size);
         let within = region.within(&painter.region());
         painter.glyphs(tex, within);
-        region
+        (region, size)
+    }
+
+    /// Wrapping reads the width it is offered, so a wider box reshapes it; a
+    /// taller one never does.
+    pub fn size_dependence(&self, axis: Axis) -> SizeDependence {
+        match axis == Axis::X && self.attrs.wrap {
+            true => SizeDependence::External,
+            false => SizeDependence::Internal,
+        }
     }
 
     pub fn content(&self) -> String {
@@ -117,7 +111,7 @@ impl Text {
             content: content.into(),
         }
     }
-    fn update_buf(&mut self, _ctx: &mut SizeCtx) {
+    fn update_buf(&mut self) {
         if self.content.changed {
             self.content.changed = false;
             self.view.buf.set_text(self.content.as_str());
@@ -127,18 +121,13 @@ impl Text {
 
 impl Widget for Text {
     fn draw(&mut self, painter: &mut Painter) {
-        self.update_buf(&mut painter.size_ctx());
-        self.view.draw(painter);
+        self.update_buf();
+        let (_, size) = self.view.draw(painter);
+        painter.set_size(size);
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.update_buf(ctx);
-        self.view.desired_width(ctx)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.update_buf(ctx);
-        self.view.desired_height(ctx)
+    fn size_dependence(&self, axis: Axis) -> SizeDependence {
+        self.view.size_dependence(axis)
     }
 }
 

tests/pointer_routing.rs

@@ -0,0 +1,225 @@
+//! Input across layers: what stops at a layer, what passes through it, and
+//! where hovering stops.
+
+use std::{cell::RefCell, rc::Rc};
+
+use iris::harness::Harness;
+use iris::prelude::*;
+
+const WINDOW: f32 = 100.0;
+
+/// Every sense that has fired on one widget since it was last read.
+#[derive(Default, Clone)]
+struct Fired(Rc<RefCell<Vec<CursorSense>>>);
+
+impl Fired {
+    fn take(&self) -> Vec<CursorSense> {
+        std::mem::take(&mut self.0.borrow_mut())
+    }
+}
+
+/// A widget filling whatever it is given, recording the senses it is sent.
+fn listener(h: &mut Harness, senses: impl Into<CursorSenses>) -> (WeakWidget<Rect>, Fired) {
+    let fired = Fired::default();
+    let record = fired.clone();
+    let id = rect(Color::WHITE)
+        .on(senses.into(), move |ctx, _| {
+            record.0.borrow_mut().push(ctx.data.sense)
+        })
+        .add(&mut h.rsc);
+    (id, fired)
+}
+
+/// A widget with no senses of its own, to leave a gap beside one that has.
+fn blank(h: &mut Harness) -> WeakWidget<Rect> {
+    rect(Color::WHITE).add(&mut h.rsc)
+}
+
+fn harness() -> Harness {
+    Harness::new((WINDOW, WINDOW))
+}
+
+#[test]
+fn hover_stops_at_the_topmost_widget() {
+    let mut h = harness();
+    let (bottom, bottom_hover) = listener(&mut h, CursorSense::HoverStart);
+    let (middle, middle_hover) = listener(&mut h, CursorSense::HoverStart);
+    let (top, top_hover) = listener(&mut h, CursorSense::HoverStart);
+    h.set_root((bottom, middle, top).stack());
+
+    h.move_to((50, 50));
+
+    assert_eq!(top_hover.take(), [CursorSense::HoverStart]);
+    assert_eq!(
+        middle_hover.take(),
+        [],
+        "hover is not shared with a layer below"
+    );
+    assert_eq!(bottom_hover.take(), []);
+}
+
+#[test]
+fn a_scroll_passes_through_every_widget_that_does_not_want_it() {
+    let mut h = harness();
+    let (list, scrolled) = listener(&mut h, CursorSense::Scroll);
+    let (button, clicked) = listener(&mut h, CursorSense::click());
+    let (overlay, overlay_clicked) = listener(&mut h, CursorSense::click());
+    h.set_root((list, button, overlay).stack());
+
+    h.move_to((50, 50));
+    h.scroll((0, 10));
+
+    assert_eq!(
+        scrolled.take(),
+        [CursorSense::Scroll],
+        "two layers of click-only widgets do not stop a scroll"
+    );
+    assert_eq!(clicked.take(), []);
+    assert_eq!(overlay_clicked.take(), []);
+}
+
+#[test]
+fn hovering_a_button_above_does_not_stop_a_later_scroll() {
+    let mut h = harness();
+    let (list, scrolled) = listener(&mut h, CursorSense::Scroll);
+    let (button, _clicked) = listener(&mut h, CursorSense::click());
+    h.set_root((list, button).stack());
+
+    // The hover arrives in its own frame, as a window delivers it.
+    h.move_to((50, 50));
+    assert_eq!(scrolled.take(), []);
+
+    h.scroll((0, 10));
+    assert_eq!(
+        scrolled.take(),
+        [CursorSense::Scroll],
+        "a hover already resting on the button must not consume the wheel"
+    );
+}
+
+#[test]
+fn only_the_topmost_listener_takes_a_press() {
+    let mut h = harness();
+    let (below, below_clicked) = listener(&mut h, CursorSense::click());
+    let (above, above_clicked) = listener(&mut h, CursorSense::click());
+    h.set_root((below, above).stack());
+
+    h.click((50, 50));
+
+    assert_eq!(above_clicked.take(), [CursorSense::click()]);
+    assert_eq!(below_clicked.take(), [], "one press goes to one widget");
+}
+
+#[test]
+fn a_press_beside_the_button_reaches_the_layer_below() {
+    let mut h = harness();
+    let (list, list_clicked) = listener(&mut h, CursorSense::click());
+    // The row above the list covers it, but only its left half is the button.
+    let (button, button_clicked) = listener(&mut h, CursorSense::click());
+    let row = (button, blank(&mut h)).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root((list, row).stack());
+
+    h.click((20, 50));
+    assert_eq!(button_clicked.take(), [CursorSense::click()]);
+    assert_eq!(list_clicked.take(), []);
+
+    h.click((80, 50));
+    assert_eq!(button_clicked.take(), [], "the cursor is not on the button");
+    assert_eq!(
+        list_clicked.take(),
+        [CursorSense::click()],
+        "a press beside the button belongs to what is under it"
+    );
+}
+
+#[test]
+fn leaving_a_widget_still_ends_its_hover() {
+    let mut h = harness();
+    let (widget, hover) = listener(&mut h, CursorSense::HoverStart | CursorSense::HoverEnd);
+    h.set_root(widget);
+
+    h.move_to((50, 50));
+    assert_eq!(hover.take(), [CursorSense::HoverStart]);
+
+    h.leave();
+    assert_eq!(hover.take(), [CursorSense::HoverEnd]);
+}
+
+#[test]
+fn leaving_a_widget_does_not_block_the_layer_below() {
+    let mut h = harness();
+    let (below, below_hover) = listener(&mut h, CursorSense::HoverStart);
+    // Only the left half of the layer above is a widget, so the cursor can
+    // leave it without leaving the one underneath.
+    let (above, above_hover) = listener(&mut h, CursorSense::HoverStart | CursorSense::HoverEnd);
+    let row = (above, blank(&mut h)).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root((below, row).stack());
+
+    h.move_to((20, 50));
+    assert_eq!(above_hover.take(), [CursorSense::HoverStart]);
+    assert_eq!(below_hover.take(), [], "the layer above is over it");
+
+    h.move_to((80, 50));
+    assert_eq!(above_hover.take(), [CursorSense::HoverEnd]);
+    assert_eq!(
+        below_hover.take(),
+        [CursorSense::HoverStart],
+        "ending a hover above must not stop the hover below"
+    );
+}
+
+#[test]
+fn covering_a_widget_ends_its_hover() {
+    let mut h = harness();
+    let (below, below_hover) = listener(&mut h, CursorSense::HoverStart | CursorSense::HoverEnd);
+    let (above, above_hover) = listener(&mut h, CursorSense::HoverStart);
+    let row = (above, blank(&mut h)).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root((below, row).stack());
+
+    h.move_to((80, 50));
+    assert_eq!(below_hover.take(), [CursorSense::HoverStart]);
+
+    h.move_to((20, 50));
+    assert_eq!(above_hover.take(), [CursorSense::HoverStart]);
+    assert_eq!(
+        below_hover.take(),
+        [CursorSense::HoverEnd],
+        "a widget covered by one that took the input is no longer hovered"
+    );
+
+    h.move_to((80, 50));
+    assert_eq!(
+        below_hover.take(),
+        [CursorSense::HoverStart],
+        "uncovering it hovers it again"
+    );
+}
+
+#[test]
+fn hover_starts_and_ends_once_each() {
+    let mut h = harness();
+    // Only the left half is the widget, so the cursor can leave it without
+    // leaving the window.
+    let (widget, hover) = listener(&mut h, CursorSense::HoverStart | CursorSense::HoverEnd);
+    let row = (widget, blank(&mut h)).span(Dir::RIGHT).add(&mut h.rsc);
+    h.set_root(row);
+
+    h.move_to((20, 50));
+    assert_eq!(hover.take(), [CursorSense::HoverStart]);
+
+    h.move_to((30, 50));
+    assert_eq!(hover.take(), [], "staying inside is not a second start");
+
+    h.move_to((80, 50));
+    assert_eq!(hover.take(), [CursorSense::HoverEnd]);
+
+    h.move_to((90, 50));
+    assert_eq!(hover.take(), [], "an ended hover does not end again");
+
+    h.move_to((20, 50));
+    assert_eq!(
+        hover.take(),
+        [CursorSense::HoverStart],
+        "re-entering starts it"
+    );
+}

tests/retained.rs

@@ -0,0 +1,137 @@
+//! What a second frame draws again, and what it keeps.
+
+use std::{cell::Cell, rc::Rc};
+
+use iris::harness::{Harness, assert_corners};
+use iris::prelude::*;
+
+/// A leaf that counts its draws and reports whatever size it is given, so a
+/// test can see what the retained path skipped.
+struct Counted {
+    draws: Rc<Cell<usize>>,
+    size: Size,
+    dependence: SizeDependence,
+}
+
+impl Widget for Counted {
+    fn draw(&mut self, painter: &mut Painter) {
+        self.draws.set(self.draws.get() + 1);
+        painter.set_size(self.size);
+    }
+
+    fn size_dependence(&self, _: Axis) -> SizeDependence {
+        self.dependence
+    }
+}
+
+struct Counts(Rc<Cell<usize>>);
+
+impl Counts {
+    fn get(&self) -> usize {
+        self.0.get()
+    }
+}
+
+fn counted(
+    h: &mut Harness,
+    size: Size,
+    dependence: SizeDependence,
+) -> (WeakWidget<Counted>, Counts) {
+    let draws = Rc::new(Cell::new(0));
+    let id = Counted {
+        draws: draws.clone(),
+        size,
+        dependence,
+    }
+    .add(&mut h.rsc);
+    (id, Counts(draws))
+}
+
+/// A fixed-width leaf beside one that takes the rest, so changing the first
+/// hands the second a different box without the output changing.
+fn pair(h: &mut Harness, rest: SizeDependence) -> (WeakWidget<Counted>, Counts, WidgetId) {
+    let (first, _) = counted(h, Size::from((100, 200)), SizeDependence::Internal);
+    let (second, draws) = counted(h, Size::REST, rest);
+    h.set_root((first, second).span(Dir::RIGHT));
+    (first, draws, second.id())
+}
+
+#[test]
+fn a_leaf_that_ignores_its_box_is_not_drawn_again_when_the_box_changes() {
+    let mut h = Harness::new((400, 200));
+    let (first, draws, second) = pair(&mut h, SizeDependence::None);
+    let settled = draws.get();
+    assert_corners!(h, second, (100, 0), (400, 200));
+
+    h.rsc[first].size = Size::from((150, 200));
+    h.frame();
+
+    assert_eq!(
+        draws.get(),
+        settled,
+        "its box is a field to write, not a reason to draw"
+    );
+    assert_corners!(h, second, (150, 0), (400, 200));
+}
+
+#[test]
+fn a_leaf_that_depends_on_its_box_is_drawn_again_when_the_box_changes() {
+    let mut h = Harness::new((400, 200));
+    let (first, draws, second) = pair(&mut h, SizeDependence::External);
+    let settled = draws.get();
+
+    h.rsc[first].size = Size::from((150, 200));
+    h.frame();
+
+    // Twice: once for the span to measure it, once for its real box. A child
+    // that can hint its length is spared the first, and a smaller number here
+    // means someone has made that cheaper rather than broken it.
+    assert_eq!(draws.get(), settled + 2);
+    assert_corners!(h, second, (150, 0), (400, 200));
+}
+
+#[test]
+fn a_span_child_that_declares_its_length_is_drawn_once() {
+    let mut h = Harness::new((400, 200));
+    let (told, told_draws) = counted(&mut h, Size::from((100, 200)), SizeDependence::Internal);
+    let (asked, asked_draws) = counted(&mut h, Size::from((100, 200)), SizeDependence::Internal);
+    // The span takes one child's length from its hint and has to draw the
+    // other to find out, so only the second is drawn before it is placed.
+    let hinted = told.width(100).add(&mut h.rsc);
+    h.set_root((hinted, asked).span(Dir::RIGHT));
+
+    assert_eq!(told_draws.get(), 1);
+    assert_eq!(
+        asked_draws.get(),
+        2,
+        "drawn to be measured, then again to be placed"
+    );
+}
+
+#[test]
+fn a_span_relays_out_when_a_child_it_measured_changes() {
+    let mut h = Harness::new((400, 200));
+    let (first, _, second) = pair(&mut h, SizeDependence::Internal);
+
+    h.rsc[first].size = Size::from((250, 200));
+    h.frame();
+
+    assert_corners!(h, first, (0, 0), (250, 200));
+    assert_corners!(h, second, (250, 0), (400, 200));
+}
+
+#[test]
+fn a_placed_child_survives_the_next_frame() {
+    let mut h = Harness::new((400, 200));
+    // Both children declare a length, so the span places them from their hints
+    // rather than drawing them to find out.
+    let top = rect(Color::RED).height(80).add(&mut h.rsc);
+    let bottom = rect(Color::BLUE).height(120).add(&mut h.rsc);
+    h.set_root((top, bottom).span(Dir::DOWN));
+
+    h.rsc.widgets_mut().get_dyn_mut(top.id());
+    h.frame();
+
+    assert_corners!(h, top, (0, 0), (400, 80));
+    assert_corners!(h, bottom, (0, 80), (400, 200));
+}