Drop the bind group ordering comment

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Cargo.toml

@@ -20,7 +20,7 @@ tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread"] }
 tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread", "time"] }
 
 [workspace]
-members = ["core", "macro", "rig-input"]
+members = ["core", "macro"]
 
 [workspace.package]
 version = "0.1.0"
@@ -29,9 +29,9 @@ edition = "2024"
 [workspace.dependencies]
 pollster = "0.4.0"
 winit = "0.30.12"
-wgpu = "30.0.1"
+wgpu = "28.0.0"
 bytemuck = "1.23.1"
-image = "0.25.10"
+image = "0.25.6"
 parley = "0.11.1"
 swash = "0.2.10"
 fxhash = "0.2.1"
@@ -40,5 +40,3 @@ arboard = "3.6.1"
 iris-core = { path = "core" }
 iris-macro = { path = "macro" }
 tokio = "1.49.0"
-wayland-client = "0.31.15"
-wayland-protocols-wlr = { version = "0.3.12", features = ["client"] }

core/src/event/manager.rs

@@ -79,7 +79,6 @@ 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>>>,
 }
 
@@ -108,7 +107,6 @@ impl<Rsc: HasEvents, E: Event> Default for TypeEventManager<Rsc, E> {
     fn default() -> Self {
         Self {
             active: Default::default(),
-            global: Default::default(),
             map: Default::default(),
         }
     }
@@ -140,13 +138,11 @@ 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) -> bool + 'a {
+    ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) + '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,
@@ -156,7 +152,6 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
                     )
                 }
             }
-            consumed
         }
     }
 }

core/src/event/mod.rs

@@ -9,19 +9,10 @@ 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,13 +21,12 @@ 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/orientation/pos.rs

@@ -56,6 +56,13 @@ impl UiVec2 {
         }
     }
 
+    pub const fn outside(&self, region: &UiRegion) -> UiVec2 {
+        UiVec2 {
+            x: self.x.outside(&region.x),
+            y: self.y.outside(&region.y),
+        }
+    }
+
     pub fn axis_mut(&mut self, axis: Axis) -> &mut UiScalar {
         match axis {
             Axis::X => &mut self.x,
@@ -202,12 +209,10 @@ impl UiScalar {
         }
     }
 
-    /// Undoes `within`, and `None` where the span has a fixed length: every
-    /// fraction of it lands on the same `rel`, so none can be told apart.
-    pub fn outside(&self, span: &UiSpan) -> Option<Self> {
-        let rel = self.rel.lerp_inv(span.start.rel, span.end.rel)?;
+    pub const fn outside(&self, span: &UiSpan) -> Self {
+        let rel = self.rel.lerp_inv(span.start.rel, span.end.rel);
         let abs = self.abs - rel.lerp(span.start.abs, span.end.abs);
-        Some(Self { rel, abs })
+        Self { rel, abs }
     }
 
     pub fn within_len(&self, len: UiScalar) -> Self {
@@ -278,11 +283,11 @@ impl UiSpan {
         }
     }
 
-    pub fn outside(&self, parent: &Self) -> Option<Self> {
-        Some(Self {
-            start: self.start.outside(parent)?,
-            end: self.end.outside(parent)?,
-        })
+    pub const fn outside(&self, parent: &Self) -> Self {
+        Self {
+            start: self.start.outside(parent),
+            end: self.end.outside(parent),
+        }
     }
 
     pub const fn len(&self) -> UiScalar {
@@ -319,7 +324,14 @@ impl UiRegion {
             y: self.y.within(&parent.y),
         }
     }
-    pub const fn axis(&self, axis: Axis) -> &UiSpan {
+    pub const fn outside(&self, parent: &Self) -> Self {
+        Self {
+            x: self.x.outside(&parent.x),
+            y: self.y.outside(&parent.y),
+        }
+    }
+
+    pub const fn axis(&mut self, axis: Axis) -> &UiSpan {
         match axis {
             Axis::X => &self.x,
             Axis::Y => &self.y,
@@ -397,50 +409,6 @@ impl UiRegion {
     }
 }
 
-/// Taking a drawing out of one box and putting it in another, checked once
-/// for a whole subtree so that applying it cannot fail.
-///
-/// A box of a fixed length holds each part as an offset from its start rather
-/// than as a fraction of it, so those parts can be carried to a box of the
-/// same length but never stretched to a different one.
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct Remap {
-    from: UiRegion,
-    to: UiRegion,
-}
-
-impl Remap {
-    pub fn new(from: UiRegion, to: UiRegion) -> Option<Self> {
-        [Axis::X, Axis::Y]
-            .into_iter()
-            .all(|axis| {
-                let (from, to) = (from.axis(axis), to.axis(axis));
-                from.start.rel != from.end.rel || from.len() == to.len()
-            })
-            .then_some(Self { from, to })
-    }
-
-    pub fn apply(&self, region: UiRegion) -> UiRegion {
-        UiRegion {
-            x: Self::span(region.x, self.from.x, self.to.x),
-            y: Self::span(region.y, self.from.y, self.to.y),
-        }
-    }
-
-    fn span(span: UiSpan, from: UiSpan, to: UiSpan) -> UiSpan {
-        match span.outside(&from) {
-            Some(out) => out.within(&to),
-            // `new` admits this only where the two are the same length, so
-            // the difference between their starts is the whole move.
-            None => {
-                let mut span = span;
-                span.shift(to.start - from.start);
-                span
-            }
-        }
-    }
-}
-
 impl Display for UiRegion {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
@@ -453,7 +421,7 @@ impl Display for UiRegion {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug)]
 pub struct PixelRegion {
     pub top_left: Vec2,
     pub bot_right: Vec2,

core/src/render/mod.rs

@@ -186,8 +186,8 @@ impl UiRenderNode {
         for source in &registry.sources()[self.primitives.len()..] {
             let render = (source.render)(device, queue);
             let data_layout = Self::data_layout(device, source.stride);
-            let mut groups = vec![Some(&self.shared_layout), Some(&data_layout)];
-            groups.extend(render.layout().map(Some));
+            let mut groups = vec![&self.shared_layout, &data_layout];
+            groups.extend(render.layout());
             let layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
                 label: Some(source.label),
                 bind_group_layouts: &groups,
@@ -219,7 +219,7 @@ impl UiRenderNode {
             vertex: VertexState {
                 module: &module,
                 entry_point: Some("vs_main"),
-                buffers: &[Some(PrimitiveInstance::desc())],
+                buffers: &[PrimitiveInstance::desc()],
                 compilation_options: Default::default(),
             },
             fragment: Some(FragmentState {

core/src/ui/active.rs

@@ -1,20 +1,14 @@
-use crate::{LayerId, MaskIdx, PrimitiveHandle, Size, TextureHandle, UiRegion, WidgetId};
+use crate::{LayerId, MaskIdx, PrimitiveHandle, 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>,
-    /// Whether it read the output's size, and so is wrong when that changes.
-    pub reads_output: bool,
     pub mask: MaskIdx,
     pub layer: LayerId,
 }

core/src/ui/cache.rs

@@ -0,0 +1,18 @@
+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,12 +3,15 @@ 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, StrongWidget, TextAttrs, TextBuffer, TextData, TextureHandle,
-    UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, WidgetId,
+    Axis, Len, RenderedText, Size, SizeCtx, StrongWidget, TextAttrs, TextBuffer, TextData,
+    TextureHandle, UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, Widget, WidgetId,
     render::{
         GlyphPrimitive, Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, PrimitiveKind,
         TexturePrimitive,
@@ -18,9 +18,6 @@ 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) reads_output: bool,
     pub layer: usize,
     pub(super) id: WidgetId,
 }
@@ -71,31 +68,19 @@ impl<'a> Painter<'a> {
     }
 
     /// Draws a widget within this widget's region.
-    pub fn widget<'s, W: ?Sized>(&'s mut self, id: &'s StrongWidget<W>) -> DrawResult<'s, 'a, W> {
-        self.widget_at(id, self.region)
+    pub fn widget<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
+        self.widget_at(id, self.region);
     }
 
-    /// Draws a widget somewhere within this one. Drawing one a second time
-    /// gives it a new box, keeping the drawing it already has where it can.
-    pub fn widget_within<'s, W: ?Sized>(
-        &'s mut self,
-        id: &'s StrongWidget<W>,
-        region: UiRegion,
-    ) -> DrawResult<'s, 'a, W> {
-        let region = region.within(&self.region);
-        self.widget_at(id, 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));
     }
 
-    fn widget_at<'s, W: ?Sized>(
-        &'s mut self,
-        id: &'s StrongWidget<W>,
-        region: UiRegion,
-    ) -> DrawResult<'s, 'a, W> {
-        // A child listed twice would be moved twice.
-        if !self.children.contains(&id.id()) {
+    fn widget_at<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) {
         self.children.push(id.id());
-        }
-        let size = self.state.draw_inner(
+        self.state.draw_inner(
             self.layer,
             id.id(),
             region,
@@ -104,25 +89,6 @@ impl<'a> Painter<'a> {
             None,
             self.rsc,
         );
-        DrawResult {
-            child: id,
-            painter: self,
-            size,
-        }
-    }
-
-    /// What a child says its length is without being drawn, if it can say.
-    /// Asking counts as reading its size.
-    pub fn size_hint<W: ?Sized>(&mut self, id: &StrongWidget<W>, axis: Axis) -> Option<Len> {
-        let hint = self.rsc.widgets().get_dyn(id.id())?.size_hint(axis)?;
-        self.depend_on_size(id);
-        Some(hint)
-    }
-
-    fn depend_on_size<W: ?Sized>(&mut self, child: &StrongWidget<W>) {
-        if !self.size_deps.contains(&child.id()) {
-            self.size_deps.push(child.id());
-        }
     }
 
     pub fn render_text(
@@ -163,17 +129,22 @@ impl<'a> Painter<'a> {
         self.region
     }
 
-    /// The output's size in pixels. A widget that reads it draws again when
-    /// the output changes, since nothing else can put that right.
-    pub fn output_size(&mut self) -> Vec2 {
-        self.reads_output = true;
+    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
     }
 
-    /// This widget's box in pixels. Resolved against the output's size, so a
-    /// widget that reads it draws again when the output changes.
     pub fn px_size(&mut self) -> Vec2 {
-        self.reads_output = true;
         self.region.size().to_abs(self.state.output_size)
     }
 
@@ -196,25 +167,9 @@ impl<'a> Painter<'a> {
     pub fn id(&self) -> &WidgetId {
         &self.id
     }
-}
 
-/// 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, W: ?Sized> {
-    painter: &'p mut Painter<'a>,
-    child: &'p StrongWidget<W>,
-    size: Size,
-}
-
-impl<W: ?Sized> DrawResult<'_, '_, W> {
-    pub fn size(self) -> Size {
-        self.painter.depend_on_size(self.child);
-        self.size
-    }
-
-    pub fn len(self, axis: Axis) -> Len {
-        self.size().axis(axis)
+    pub fn size_ctx(&mut self) -> SizeCtx<'_> {
+        self.state.size_ctx(self.id, self.region.size(), self.rsc)
     }
 }
 

core/src/ui/render_state.rs

@@ -1,6 +1,7 @@
 use crate::{
-    ActiveData, Axis, DrawLayers, IdLike, MaskIdx, OnResize, Painter, PixelRegion, Remap, Size,
-    StrongWidget, UiRegion, UiRsc, WidgetId, Widgets,
+    ActiveData, Axis, DrawLayers, IdLike, MaskIdx, Painter, PixelRegion, SizeCtx, StrongWidget,
+    UiRegion, UiRsc, UiVec2, WidgetId, Widgets,
+    ui::cache::Cache,
     util::{HashMap, HashSet, Vec2, forget_ref},
 };
 
@@ -8,6 +9,7 @@ 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,
@@ -19,6 +21,7 @@ impl UiRenderState {
         Self {
             active: Default::default(),
             layers: Default::default(),
+            cache: Default::default(),
             output_size: Vec2::ZERO,
             old_root: None,
             resized: false,
@@ -31,10 +34,6 @@ impl UiRenderState {
         self.resized = true;
     }
 
-    pub fn output_size(&self) -> Vec2 {
-        self.output_size
-    }
-
     pub fn update<'a>(&mut self, root: impl Into<Option<&'a StrongWidget>>, rsc: &mut dyn UiRsc) {
         // safety mechanism for memory leaks; might wanna return a result instead so user can
         // decide whether to panic or not
@@ -53,21 +52,11 @@ impl UiRenderState {
             );
         }
         let root = root.into();
-        if self.root_changed(root) {
+        if self.needs_full_redraw(root) {
             self.redraw_all(root, rsc);
             self.old_root = root.map(|r| r.id());
-        } else if self.resized {
-            // A region is a fraction of the output plus an offset, resolved
-            // against the window in the shader, so a resize moves the whole
-            // drawing on its own. Only a widget that read pixels can be wrong.
-            for (&id, active) in &self.active {
-                if active.reads_output {
-                    rsc.widgets_mut().needs_redraw.insert(id);
-                }
-            }
-        }
             self.resized = false;
-        if rsc.widgets().has_updates() {
+        } else if rsc.widgets().has_updates() {
             self.redraw_updates(rsc);
         }
     }
@@ -91,11 +80,19 @@ impl UiRenderState {
         mask: MaskIdx,
         old_children: Option<Vec<WidgetId>>,
         rsc: &mut dyn UiRsc,
-    ) -> Size {
+    ) {
         let mut old_children = old_children.unwrap_or_default();
-        if self.active.contains_key(&id) {
-            if let Some(size) = self.try_reuse(id, region, rsc) {
-                return size;
+        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 not, then maintain resize and track old children to remove unneeded
             let active = self.remove(id, false, rsc).unwrap();
@@ -103,7 +100,6 @@ impl UiRenderState {
         }
 
         // draw widget
-        rsc.widgets_mut().needs_redraw.remove(&id);
         self.draw_started.insert(id);
 
         let mut painter = Painter {
@@ -115,13 +111,11 @@ impl UiRenderState {
             textures: Vec::new(),
             primitives: Vec::new(),
             children: Vec::new(),
-            size_deps: Vec::new(),
-            reads_output: false,
             rsc,
         };
 
         let mut widget = painter.rsc.widgets().get_dyn_dynamic(id);
-        let size = widget.draw(&mut painter);
+        widget.draw(&mut painter);
         drop(widget);
 
         let Painter {
@@ -132,29 +126,18 @@ impl UiRenderState {
             textures,
             primitives,
             children,
-            size_deps,
-            reads_output,
             layer,
             id,
         } = painter;
 
-        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,
-            reads_output,
             mask,
             layer,
         };
@@ -168,77 +151,19 @@ impl UiRenderState {
 
         rsc.on_draw(&active);
         self.active.insert(id, active);
-        size
     }
 
-    /// 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, old) = (active.size, active.region);
-        if old == region {
-            return Some(size);
-        }
-        // TODO: epsilon?
-        if old.size() != region.size() && !self.reusable(id, region, rsc) {
-            return None;
-        }
-        // Its drawing stands, if the new box can be reached from the old one.
-        self.mov(id, &Remap::new(old, region)?);
-        Some(size)
-    }
-
-    /// 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, 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;
-        };
-        [Axis::X, Axis::Y].into_iter().all(|axis| {
-            let offered = region.axis(axis).len();
-            let had = active.region.axis(axis).len();
-            match widget.on_resize(axis) {
-                OnResize::Scale => true,
-                // `Translate` is not acted on yet, and cannot be until a
-                // drawing can sit somewhere other than its box. `region` is
-                // both the box a widget was given and the box its primitives
-                // are in, and `mov` remaps from it -- so carrying a drawing at
-                // its old size while the box grows makes the next move stretch
-                // it. The offset chain is what separates the two.
-                OnResize::Translate | OnResize::Redraw => 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, remap: &Remap) {
+    fn mov(&mut self, id: WidgetId, from: UiRegion, to: UiRegion) {
         let active = self.active.get_mut(&id).unwrap();
         for h in &active.primitives {
             let region = self.layers[h.layer].region_mut(h);
-            *region = remap.apply(*region);
+            *region = region.outside(&from).within(&to);
         }
-        active.region = remap.apply(active.region);
+        active.region = active.region.outside(&from).within(&to);
         // SAFETY: children cannot be recursive
         let children = unsafe { forget_ref(&active.children) };
         for child in children {
-            self.mov(*child, remap);
+            self.mov(*child, from, to);
         }
     }
 
@@ -262,6 +187,7 @@ 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 {
@@ -275,6 +201,7 @@ 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();
@@ -291,12 +218,17 @@ impl UiRenderState {
         root.into().map(|r| r.id()) != self.old_root
     }
 
+    // Scheduling and drawing must use the same full-redraw predicate.
+    fn needs_full_redraw<'a>(&self, root: impl Into<Option<&'a StrongWidget>>) -> bool {
+        self.root_changed(root) || self.resized
+    }
+
     pub fn needs_redraw<'a>(
         &self,
         root: impl Into<Option<&'a StrongWidget>>,
         widgets: &Widgets,
     ) -> bool {
-        self.root_changed(root) || self.resized || widgets.has_updates()
+        self.needs_full_redraw(root) || widgets.has_updates()
     }
 
     pub fn active_widgets(&self) -> usize {
@@ -329,19 +261,22 @@ impl UiRenderState {
 
     /// redraws a widget that's currently active (drawn)
     pub fn redraw(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) {
+        rsc.widgets_mut().needs_redraw.remove(&id);
         self.draw_started.remove(&id);
-        // Whoever read this widget's size may be a different size now, so the
-        // highest reader is what draws. Everything between the two is marked
-        // as well: their own boxes have not changed, so the mark is the only
-        // thing stopping the draw reusing its way past this widget.
-        if let Some(top) = self.mark_readers(id, rsc) {
-            self.redraw(top, rsc);
-            // Cleared by that draw if it reached here; if it did not, this is
-            // no longer drawn and asking again would not end.
-            rsc.widgets_mut().needs_redraw.remove(&id);
-            return;
+        // 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);
+                }
+            }
         }
-        rsc.widgets_mut().needs_redraw.remove(&id);
 
         if self.draw_started.contains(&id) {
             return;
@@ -362,23 +297,22 @@ impl UiRenderState {
         );
     }
 
-    /// The furthest ancestor that read this widget's size, directly or through
-    /// widgets that did the same, marking everything below it on the way.
-    fn mark_readers(&self, id: WidgetId, rsc: &mut dyn UiRsc) -> 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))
-        {
-            rsc.widgets_mut().needs_redraw.insert(at);
-            top = Some(parent);
-            at = parent;
+    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,
         }
-        top
     }
 }
 

core/src/ui/size.rs

@@ -0,0 +1,89 @@
+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/util/math.rs

@@ -1,21 +1,33 @@
-pub const trait LerpUtil: Sized {
+use std::ops::*;
+
+pub const trait LerpUtil {
     fn lerp(self, from: Self, to: Self) -> Self;
-    fn lerp_inv(self, from: Self, to: Self) -> Option<Self>;
+    fn lerp_inv(self, from: Self, to: Self) -> Self;
 }
 
-const impl LerpUtil for f32 {
+pub const trait DivOr {
+    fn div_or(self, rhs: Self, other: Self) -> Self;
+}
+
+const impl DivOr for f32 {
+    fn div_or(self, rhs: Self, other: Self) -> Self {
+        let res = self / rhs;
+        if res.is_nan() { other } else { res }
+    }
+}
+
+const impl<
+    T: const Add<Output = T> + const Sub<Output = T> + const Mul<Output = T> + const DivOr + Copy,
+> LerpUtil for T
+{
     /// linear interpolation
     /// from * (1.0 - self) + to * self
     fn lerp(self, from: Self, to: Self) -> Self {
         from + (to - from) * self
     }
-    /// inverse of lerp, and `None` where `from` and `to` are the same point:
-    /// every input lerps to it, so there is no one answer to come back to.
-    fn lerp_inv(self, from: Self, to: Self) -> Option<Self> {
-        match to == from {
-            true => None,
-            false => Some((self - from) / (to - from)),
-        }
+    /// inverse of lerp
+    fn lerp_inv(self, from: Self, to: Self) -> Self {
+        (self - from).div_or(to - from, from)
     }
 }
 

core/src/util/vec2.rs

@@ -1,4 +1,4 @@
-use crate::util::impl_op;
+use crate::util::{DivOr, impl_op};
 use std::{hash::Hash, ops::*};
 
 #[repr(C)]
@@ -67,6 +67,15 @@ impl_op!(Vec2 Sub sub; x y);
 impl_op!(Vec2 Mul mul; x y);
 impl_op!(Vec2 Div div; x y);
 
+const impl DivOr for Vec2 {
+    fn div_or(self, rhs: Self, other: Self) -> Self {
+        Self {
+            x: self.x.div_or(rhs.x, other.x),
+            y: self.y.div_or(rhs.y, other.y),
+        }
+    }
+}
+
 impl Neg for Vec2 {
     type Output = Self;
 

core/src/widget/mod.rs

@@ -1,4 +1,4 @@
-use crate::{Axis, Len, Painter, Size};
+use crate::{Axis, AxisT, Len, Painter, SizeCtx};
 use std::any::Any;
 
 mod data;
@@ -15,45 +15,32 @@ pub use tag::*;
 pub use view::*;
 pub use widgets::*;
 
-/// What may be done to a widget's drawing when the box it was given changes
-/// on this axis, instead of drawing it again. Asked per axis, because wrapped
-/// text reads the width it is offered and not the height.
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub enum OnResize {
-    Scale,
-    Translate,
-    #[default]
-    Redraw,
-}
-
 pub trait Widget: Any {
-    /// Draws the widget, and returns what it used of the box it was given.
-    fn draw(&mut self, painter: &mut Painter) -> Size;
-
-    /// 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
+    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;
 }
 
-    fn on_resize(&self, _axis: Axis) -> OnResize {
-        OnResize::default()
+pub trait WidgetAxisFns {
+    fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len;
+}
+
+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),
+        }
     }
 }
 
 impl Widget for () {
-    /// A gap: nothing drawn, at the default length, so a span gives it a share.
-    fn draw(&mut self, _: &mut Painter) -> Size {
-        Size::default()
+    fn draw(&mut self, _: &mut Painter) {}
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::ZERO
     }
-
-    fn size_hint(&self, _axis: Axis) -> Option<Len> {
-        Some(Len::default())
-    }
-
-    fn on_resize(&self, _axis: Axis) -> OnResize {
-        OnResize::Scale
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::ZERO
     }
 }
 

examples/minimal.rs

@@ -10,7 +10,11 @@ struct State {
 }
 
 impl DefaultAppState for State {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
+    fn new(
+        mut ui_state: DefaultUiState,
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
         rect(Color::RED).set_root(rsc, &mut ui_state);
         Self { ui_state }
     }

examples/tabs/main.rs

@@ -15,7 +15,11 @@ pub struct Client {
 }
 
 impl DefaultAppState for Client {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
+    fn new(
+        mut ui_state: DefaultUiState,
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
         let rrect = rect(Color::WHITE).radius(20);
         let pad_test = (
             rrect.color(Color::BLUE),

examples/task.rs

@@ -11,7 +11,11 @@ struct State {
 }
 
 impl DefaultAppState for State {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
+    fn new(
+        mut ui_state: DefaultUiState,
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
         let rect = rect(Color::RED).add(rsc);
         rect.task_on(CursorSense::click(), async move |mut ctx| {
             tokio::time::sleep(Duration::from_secs(1)).await;

examples/text.rs

@@ -1,63 +0,0 @@
-//! 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 }
-    }
-}

examples/view.rs

@@ -36,7 +36,11 @@ impl Test {
 }
 
 impl DefaultAppState for State {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
+    fn new(
+        mut ui_state: DefaultUiState,
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
         let test = Test::new(rsc);
 
         test.on(CursorSense::click(), move |_, rsc| {

rig-input/Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "rig-input"
-version.workspace = true
-edition.workspace = true
-
-# Replays `.touch` recordings through Wayland's virtual-pointer protocol;
-# headless sway has no input devices for coordinate-driving tools to move.
-[[bin]]
-name = "replay-touch"
-path = "src/main.rs"
-
-[dependencies]
-# Share the harness parser so both ways of replaying read a file the same.
-iris = { path = ".." }
-wayland-client = { workspace = true }
-wayland-protocols-wlr = { workspace = true }

rig-input/src/main.rs

@@ -1,141 +0,0 @@
-use iris::harness::{TouchAction, TouchScript};
-use std::time::Duration;
-use wayland_client::protocol::wl_pointer::ButtonState;
-use wayland_client::protocol::{wl_registry, wl_seat};
-use wayland_client::{Connection, Dispatch, QueueHandle, delegate_noop};
-use wayland_protocols_wlr::virtual_pointer::v1::client::{
-    zwlr_virtual_pointer_manager_v1::ZwlrVirtualPointerManagerV1,
-    zwlr_virtual_pointer_v1::ZwlrVirtualPointerV1,
-};
-
-const BTN_LEFT: u32 = 0x110;
-
-const SETTLE: Duration = Duration::from_millis(200);
-
-#[derive(Default)]
-struct Globals {
-    seat: Option<wl_seat::WlSeat>,
-    manager: Option<ZwlrVirtualPointerManagerV1>,
-}
-
-impl Dispatch<wl_registry::WlRegistry, ()> for Globals {
-    fn event(
-        state: &mut Self,
-        registry: &wl_registry::WlRegistry,
-        event: wl_registry::Event,
-        _: &(),
-        _: &Connection,
-        qh: &QueueHandle<Self>,
-    ) {
-        let wl_registry::Event::Global {
-            name,
-            interface,
-            version,
-        } = event
-        else {
-            return;
-        };
-        match interface.as_str() {
-            "wl_seat" => {
-                state.seat = Some(registry.bind(name, version.min(7), qh, ()));
-            }
-            "zwlr_virtual_pointer_manager_v1" => {
-                state.manager = Some(registry.bind(name, version.min(2), qh, ()));
-            }
-            _ => {}
-        }
-    }
-}
-
-delegate_noop!(Globals: ignore wl_seat::WlSeat);
-delegate_noop!(Globals: ZwlrVirtualPointerManagerV1);
-delegate_noop!(Globals: ZwlrVirtualPointerV1);
-
-fn main() {
-    let args: Vec<String> = std::env::args().skip(1).collect();
-    let [width, height, path] = args.as_slice() else {
-        eprintln!("usage: replay-touch WIDTH HEIGHT FILE");
-        std::process::exit(2);
-    };
-    let (width, height) = (parse(width, "WIDTH"), parse(height, "HEIGHT"));
-    let text = std::fs::read_to_string(path)
-        .unwrap_or_else(|e| fail(&format!("could not read {path}: {e}")));
-    let script = TouchScript::parse(&text).unwrap_or_else(|e| fail(&e));
-
-    let conn = Connection::connect_to_env().unwrap_or_else(|e| {
-        fail(&format!(
-            "no wayland display ({e}); is WAYLAND_DISPLAY set?"
-        ))
-    });
-    let mut queue = conn.new_event_queue();
-    let qh = queue.handle();
-    let display = conn.display();
-    display.get_registry(&qh, ());
-    let mut globals = Globals::default();
-    queue
-        .roundtrip(&mut globals)
-        .unwrap_or_else(|e| fail(&format!("wayland roundtrip failed: {e}")));
-
-    let manager = globals.manager.as_ref().unwrap_or_else(|| {
-        fail(
-            "this compositor does not offer zwlr_virtual_pointer_manager_v1, so a pointer cannot \
-             be synthesised; sway and every wlroots compositor do",
-        )
-    });
-    let pointer = manager.create_virtual_pointer(globals.seat.as_ref(), &qh, ());
-
-    // Put the pointer where the gesture starts and let the compositor
-    // settle before anything is pressed. Without this the press is
-    // dropped: sway has just learned about this pointer, and a button
-    // sent in the same breath as the motion that first puts it over a
-    // window arrives before there is a focused surface to send it to --
-    // winit sees `CursorEntered`, the moves and the *release*, never the
-    // press, so the gesture reads as a hover and nothing scrolls. Found
-    // by printing winit's own events; the settle is what fixed it.
-    if let Some(first) = script.samples.first() {
-        pointer.motion_absolute(0, first.pos.x as u32, first.pos.y as u32, width, height);
-        pointer.frame();
-        conn.flush()
-            .unwrap_or_else(|e| fail(&format!("flush: {e}")));
-        std::thread::sleep(SETTLE);
-    }
-
-    let mut previous = 0;
-    for sample in &script.samples {
-        std::thread::sleep(Duration::from_millis(sample.t_ms - previous));
-        previous = sample.t_ms;
-        let t = sample.t_ms as u32;
-        pointer.motion_absolute(t, sample.pos.x as u32, sample.pos.y as u32, width, height);
-        pointer.frame();
-        // The button goes in a frame of its own, *after* the motion has
-        // been committed. Sent in the same frame as the motion that
-        // first puts the pointer over the window, sway drops it: the
-        // client sees `CursorEntered` and the moves but never a
-        // `MouseInput { state: Pressed }`, so the whole gesture reads as
-        // a hover and nothing scrolls. Found exactly that way, by
-        // printing winit's events.
-        let state = match sample.action {
-            TouchAction::Down => Some(ButtonState::Pressed),
-            TouchAction::Up => Some(ButtonState::Released),
-            TouchAction::Move => None,
-        };
-        if let Some(state) = state {
-            pointer.button(t, BTN_LEFT, state);
-            pointer.frame();
-        }
-        conn.flush()
-            .unwrap_or_else(|e| fail(&format!("flush: {e}")));
-    }
-    pointer.destroy();
-    conn.flush().ok();
-}
-
-fn parse(text: &str, what: &str) -> u32 {
-    text.parse()
-        .unwrap_or_else(|_| fail(&format!("{what} is not a whole number: {text:?}")))
-}
-
-fn fail(message: &str) -> ! {
-    eprintln!("replay-touch: {message}");
-    std::process::exit(1);
-}

scripts/headless.conf

@@ -1,14 +0,0 @@
-# The compositor `scripts/run-headless.sh` starts, so that an example has a
-# surface where there is no display. Nothing here is meant to be looked at
-# directly; `grim` is.
-#
-# No Xwayland: winit talks Wayland natively, so an X server is a second thing
-# to go wrong for no gain.
-xwayland disable
-
-# The default output, overridden per run by `--mode`. Larger than the window
-# an example opens, so nothing is scaled or clipped.
-output HEADLESS-1 mode 1920x1200@60Hz
-
-default_border none
-focus_follows_mouse no

scripts/run-headless.sh

@@ -1,170 +0,0 @@
-#!/bin/sh
-# Run an iris example on a machine with no display.
-#
-#   ./scripts/run-headless.sh tabs
-#   ./scripts/run-headless.sh tabs --shot /tmp/tabs.png --seconds 4
-#   ./scripts/run-headless.sh tabs --replay taps.touch --shot /tmp/tabs.png
-#   ./scripts/run-headless.sh app --dir ../elsewhere --mode 1080x2424@120Hz
-#
-# `--dir DIR` names the workspace to build in, defaulting to this one, so a
-# project that depends on iris can be run through the same rig. `--bin` runs a
-# crate binary rather than an example, and takes its own argv from
-# `$RUN_HEADLESS_ARGS`, word-split on purpose.
-#
-# `--mode` sets the output, for running something at a size other than a
-# desktop's -- a phone's, say. Set every run rather than only when it changes:
-# the compositor is reused between runs, so a default-shaped run after a
-# custom one would otherwise inherit the other's output and quietly screenshot
-# the wrong size.
-#
-# `--replay FILE` drives a `.touch` recording into the window through
-# `replay-touch`, which reads it with the same parser `iris::harness` uses. A
-# recording is `<ms> down|move|up <x> <y>` in the output's own pixels. With
-# `--shot` it also writes `<shot>-before.png` from just before the gesture,
-# since "it moved" is a claim about two pictures.
-#
-# What it supplies is a compositor for winit to open a surface on: a headless
-# sway, and `grim` to screenshot it. Sway gets its own socket and runtime
-# directory rather than joining whatever else is running, because it tiles --
-# adding a window to someone else's compositor resizes theirs.
-set -eu
-
-need() {
-    command -v "$1" >/dev/null 2>&1 || {
-        echo "run-headless: $1 is not installed ($2)" >&2
-        exit 127
-    }
-}
-need sway "the compositor an example opens its window on"
-need swaymsg "sway's control socket"
-
-scripts=$(cd "$(dirname "$0")" && pwd)
-root=$(cd "$scripts/.." && pwd)
-workdir="$root"
-cd "$root"
-run="${XDG_RUNTIME_DIR:-/tmp}/iris-headless"
-seconds=3
-shot=""
-replay=""
-example=""
-kind=example
-mode=1920x1200@60Hz
-
-
-while [ $# -gt 0 ]; do
-    case "$1" in
-        --shot) shot=$2; shift 2 ;;
-        --seconds) seconds=$2; shift 2 ;;
-        --bin) kind=bin; shift ;;
-        --mode) mode=$2; shift 2 ;;
-        --replay) replay=$2; shift 2 ;;
-        --dir) workdir=$(cd "$2" && pwd); shift 2 ;;
-        --) shift; break ;;
-        *) example=$1; shift ;;
-    esac
-done
-[ -n "$example" ] || { echo "usage: $0 NAME [--bin] [--dir DIR] [--mode WxH@Hz] [--replay TOUCH] [--shot PNG] [--seconds N] [-- cargo args]" >&2; exit 2; }
-[ -z "$replay" ] || [ -f "$replay" ] || { echo "run-headless: no touch script at $replay" >&2; exit 2; }
-[ -z "$shot" ] || need grim "the screenshot --shot writes"
-
-mkdir -p "$run"
-export SWAYSOCK="$run/sway.sock"
-
-# Named rather than left to sway's pid-based default, so a second run reuses
-# this compositor instead of starting another beside it.
-if ! swaymsg -t get_version >/dev/null 2>&1; then
-    rm -f "$SWAYSOCK"
-    WLR_BACKENDS=headless WLR_LIBINPUT_NO_DEVICES=1 LIBSEAT_BACKEND=noop \
-        setsid sway -c "$scripts/headless.conf" >"$run/sway.log" 2>&1 &
-    i=0
-    while [ $i -lt 20 ]; do
-        swaymsg -t get_version >/dev/null 2>&1 && break
-        i=$((i + 1)); sleep 0.5
-    done
-    swaymsg -t get_version >/dev/null 2>&1 || {
-        echo "run-headless: compositor did not start; see $run/sway.log" >&2
-        exit 1
-    }
-fi
-
-rm -f "$run/display"
-swaymsg exec -- "sh -c 'printf %s \"\$WAYLAND_DISPLAY\" > $run/display'" >/dev/null
-i=0
-while [ $i -lt 20 ]; do
-    [ -s "$run/display" ] && break
-    i=$((i + 1)); sleep 0.5
-done
-[ -s "$run/display" ] || { echo "run-headless: could not read WAYLAND_DISPLAY" >&2; exit 1; }
-WAYLAND_DISPLAY=$(cat "$run/display")
-export WAYLAND_DISPLAY
-
-echo "run-headless: $WAYLAND_DISPLAY (sway $(swaymsg -t get_version --raw | sed -n 's/.*"human_readable":"\([^"]*\)".*/\1/p'))" >&2
-
-swaymsg output HEADLESS-1 mode "$mode" >/dev/null
-# The extent `replay-touch` positions against, so a script's coordinates
-# are the output's own pixels.
-out_w=${mode%x*}
-out_h=${mode#*x}; out_h=${out_h%@*}
-
-# Built before the app starts, so a compile error is not reported as a
-# window that failed to move.
-[ -z "$replay" ] || (cd "$root" && cargo build --bin replay-touch -p rig-input) >&2
-
-cd "$workdir"
-if [ "$kind" = bin ]; then
-    cargo build --bin "$example" "$@" >&2
-    bin="$workdir/target/debug/$example"
-else
-    cargo build --example "$example" "$@" >&2
-    bin="$workdir/target/debug/examples/$example"
-fi
-
-# Deliberately word-split: this is the binary's own argv, not a single path.
-# shellcheck disable=SC2086
-"$bin" ${RUN_HEADLESS_ARGS:-} >"$run/$example.log" 2>&1 &
-pid=$!
-trap 'kill "$pid" 2>/dev/null || true' EXIT INT TERM
-
-# Wait for the window to be mapped rather than for a number of seconds. A
-# fixed sleep took an all-black screenshot the first time this ran, when sway
-# had started in the same invocation and had not composited its output yet --
-# which is indistinguishable from an app that draws nothing.
-i=0
-while [ $i -lt 40 ]; do
-    kill -0 "$pid" 2>/dev/null || break
-    swaymsg -t get_tree --raw 2>/dev/null | grep -q "\"pid\":$pid," && break
-    i=$((i + 1)); sleep 0.25
-done
-
-i=0
-while [ $i -lt "$((seconds * 2))" ]; do
-    kill -0 "$pid" 2>/dev/null || break
-    i=$((i + 1)); sleep 0.5
-done
-
-if [ -n "$replay" ] && kill -0 "$pid" 2>/dev/null; then
-    if [ -n "$shot" ]; then
-        grim "${shot%.png}-before.png"
-        echo "run-headless: wrote ${shot%.png}-before.png (before the gesture)" >&2
-    fi
-    "$root/target/debug/replay-touch" "$out_w" "$out_h" "$replay"
-    # A fling outlives the finger: the gesture's own last sample is not
-    # when the list stops. Long enough for Android's spline to settle
-    # (`FlingCalculator::duration` tops out around a second and a half).
-    sleep 2
-fi
-
-if kill -0 "$pid" 2>/dev/null; then
-    [ -n "$shot" ] && grim "$shot" && echo "run-headless: wrote $shot" >&2
-    kill "$pid" 2>/dev/null || true
-    wait "$pid" 2>/dev/null || true
-    status=0
-else
-    wait "$pid" 2>/dev/null || status=$?
-    echo "run-headless: $example exited early (status ${status:-0})" >&2
-    status=${status:-1}
-fi
-
-echo "--- $example output ---" >&2
-cat "$run/$example.log" >&2
-exit "$status"

src/default/mod.rs

@@ -1,6 +1,10 @@
 use crate::prelude::*;
 use arboard::Clipboard;
-use std::{marker::PhantomData, sync::Arc, time::Instant};
+use std::{
+    marker::{PhantomData, Sized},
+    sync::Arc,
+    time::Instant,
+};
 use winit::{
     event::{Ime, WindowEvent},
     event_loop::{ActiveEventLoop, EventLoopProxy},
@@ -25,35 +29,7 @@ pub use sense::*;
 pub use state::*;
 pub use task::*;
 
-/// Sends an application's own events to its event loop. It wraps the proxy
-/// rather than being one because task updates travel the same way: what an
-/// application sends is its `Event`, not the loop's whole message type.
-pub struct Proxy<State: DefaultAppState>(EventLoopProxy<DefaultEvent<State>>);
-
-impl<State: DefaultAppState> Clone for Proxy<State> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<State: DefaultAppState> Proxy<State> {
-    pub fn send_event(&self, event: State::Event) {
-        let _ = self.0.send_event(DefaultEvent::User(event));
-    }
-}
-
-/// What the event loop carries: the application's own events, and the
-/// updates tasks send back to the ui thread.
-pub enum DefaultEvent<State: DefaultAppState> {
-    User(State::Event),
-    Update(Box<dyn TaskUpdate<DefaultRsc<State>>>),
-}
-
-impl<State: DefaultAppState> TaskQueue<DefaultRsc<State>> for Proxy<State> {
-    fn send(&self, update: Box<dyn TaskUpdate<DefaultRsc<State>>>) {
-        let _ = self.0.send_event(DefaultEvent::Update(update));
-    }
-}
+pub type Proxy<Event> = EventLoopProxy<Event>;
 
 pub struct DefaultUiState {
     pub root: Option<StrongWidget>,
@@ -94,8 +70,9 @@ pub trait HasDefaultUiState: Sized + 'static {
 }
 
 pub trait DefaultAppState: HasDefaultUiState {
-    type Event: Send = ();
-    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self>) -> Self;
+    type Event = ();
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self::Event>)
+    -> Self;
     #[allow(unused_variables)]
     fn event(
         &mut self,
@@ -128,14 +105,18 @@ pub struct DefaultRsc<State: 'static> {
 }
 
 impl<State> DefaultRsc<State> {
-    pub fn init(queue: Arc<dyn TaskQueue<Self>>) -> Self {
+    fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Self>) {
+        let (tasks, recv) = Tasks::init(window);
+        (
             Self {
                 ui: Default::default(),
                 events: Default::default(),
-            tasks: Tasks::init(queue),
+                tasks,
                 state: Default::default(),
                 _state: Default::default(),
-        }
+            },
+            recv,
+        )
     }
 
     pub fn create_state<T: 'static>(&mut self, id: impl IdLike, data: T) -> WeakState<T> {
@@ -200,32 +181,43 @@ pub struct DefaultApp<State: DefaultAppState> {
     rsc: DefaultRsc<State>,
     render: UiRenderState,
     state: State,
+    task_recv: TaskMsgReceiver<DefaultRsc<State>>,
 }
 
 impl<State: DefaultAppState> AppState for DefaultApp<State> {
-    type Event = DefaultEvent<State>;
+    type Event = State::Event;
 
     fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
         let window = event_loop
             .create_window(State::window_attributes())
             .unwrap();
         let default_state = DefaultUiState::new(window);
-        let mut rsc = DefaultRsc::init(Arc::new(Proxy(proxy.clone())));
-        let state = State::new(default_state, &mut rsc, Proxy(proxy));
+        let (mut rsc, task_recv) = DefaultRsc::init(default_state.window.clone());
+        let state = State::new(default_state, &mut rsc, proxy);
         let render = UiRenderState::new();
-        Self { rsc, state, render }
+        Self {
+            rsc,
+            state,
+            render,
+            task_recv,
+        }
     }
 
     fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
-        match event {
-            DefaultEvent::User(event) => self.state.event(event, &mut self.rsc, &mut self.render),
-            DefaultEvent::Update(update) => update(&mut self.state, &mut self.rsc),
-        }
-        self.request_redraw_if_needed();
+        self.state.event(event, &mut self.rsc, &mut self.render);
     }
 
     fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
-        let Self { rsc, render, state } = self;
+        let Self {
+            rsc,
+            render,
+            state,
+            task_recv,
+        } = self;
+
+        for update in task_recv.try_iter() {
+            update(state, rsc);
+        }
 
         let ui_state = state.default_state_mut();
         let input_changed = ui_state.input.event(&event);
@@ -235,7 +227,8 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
             ui_state.focus = None;
         }
         if input_changed {
-            render.run_sensors(rsc, state, cursor_state);
+            let window_size = ui_state.window_size();
+            render.run_sensors(rsc, state, cursor_state, window_size);
         }
         let ui_state = state.default_state_mut();
         if old != ui_state.focus
@@ -304,8 +297,11 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
             _ => (),
         }
         state.window_event(event, rsc, render);
-        self.request_redraw_if_needed();
-        self.state.default_state_mut().input.end_frame();
+        let ui_state = self.state.default_state_mut();
+        if render.needs_redraw(&ui_state.root, rsc.widgets()) {
+            ui_state.renderer.window().request_redraw();
+        }
+        ui_state.input.end_frame();
     }
 
     fn exit(&mut self) {
@@ -313,15 +309,6 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
     }
 }
 
-impl<State: DefaultAppState> DefaultApp<State> {
-    fn request_redraw_if_needed(&mut self) {
-        let ui_state = self.state.default_state_mut();
-        if self.render.needs_redraw(&ui_state.root, self.rsc.widgets()) {
-            ui_state.renderer.window().request_redraw();
-        }
-    }
-}
-
 pub trait RscIdx<Rsc> {
     type Output;
     fn get(self, rsc: &Rsc) -> &Self::Output;

src/default/render.rs

@@ -22,20 +22,7 @@ impl UiRenderer {
     }
 
     pub fn draw(&mut self) {
-        let output = match self.surface.get_current_texture() {
-            CurrentSurfaceTexture::Success(texture) => texture,
-            CurrentSurfaceTexture::Suboptimal(texture) => {
-                self.surface.configure(&self.device, &self.config);
-                texture
-            }
-            CurrentSurfaceTexture::Outdated | CurrentSurfaceTexture::Lost => {
-                self.surface.configure(&self.device, &self.config);
-                return;
-            }
-            CurrentSurfaceTexture::Timeout
-            | CurrentSurfaceTexture::Occluded
-            | CurrentSurfaceTexture::Validation => return,
-        };
+        let output = self.surface.get_current_texture().unwrap();
         let view = output
             .texture
             .create_view(&TextureViewDescriptor::default());
@@ -59,7 +46,7 @@ impl UiRenderer {
 
         self.queue.submit(std::iter::once(encoder.finish()));
         self.window.pre_present_notify();
-        self.queue.present(output);
+        output.present();
     }
 
     pub fn resize(&mut self, size: &PhysicalSize<u32>) {
@@ -78,10 +65,9 @@ impl UiRenderer {
     pub fn new(window: Arc<Window>) -> Self {
         let size = window.inner_size();
 
-        let instance = Instance::new(InstanceDescriptor {
+        let instance = Instance::new(&InstanceDescriptor {
             backends: Backends::PRIMARY,
-            display: Some(Box::new(window.clone())),
-            ..InstanceDescriptor::new_without_display_handle()
+            ..Default::default()
         });
 
         let surface = instance
@@ -93,7 +79,6 @@ impl UiRenderer {
                 power_preference: PowerPreference::default(),
                 compatible_surface: Some(&surface),
                 force_fallback_adapter: false,
-                apply_limit_buckets: false,
             })
             .block_on()
             .expect("Could not get adapter!");
@@ -120,7 +105,6 @@ impl UiRenderer {
         let config = SurfaceConfiguration {
             usage: TextureUsages::RENDER_ATTACHMENT,
             format: surface_format,
-            color_space: SurfaceColorSpace::Auto,
             width: size.width,
             height: size.height,
             present_mode: PresentMode::AutoVsync,

src/default/sense.rs

@@ -4,14 +4,14 @@ use std::{
     rc::Rc,
 };
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq)]
 pub enum CursorButton {
     Left,
     Right,
     Middle,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(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 Global = Hovered;
+    type State = SensorState;
     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,24 +37,6 @@ 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 {
@@ -70,12 +52,6 @@ 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)]
@@ -120,12 +96,6 @@ 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;
@@ -153,6 +123,11 @@ 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
@@ -172,6 +147,7 @@ pub trait SensorUi {
         rsc: &mut Rsc,
         state: &mut Rsc::State,
         cursor: CursorState,
+        window_size: Vec2,
     );
 }
 
@@ -181,85 +157,46 @@ 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 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);
-
+        let mut active = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().active);
         for layer in self.layers.indices().rev() {
-            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) {
+            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 {
                     continue;
                 }
-                hovered.now.push(id);
-                let hover = match hovered.was.contains(&id) {
-                    true => ActivationState::On,
-                    false => ActivationState::Start,
-                };
-                // 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;
-            }
-            // Applied after the layer, never during it: senses on one layer do
-            // not block each other.
-            if consumed {
-                break;
-            }
-        }
+                sensed = true;
 
-        // 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 cursor = cursor.clone();
 
-        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(),
+                    hover: sensor.hover,
+                    cursor,
                     // this does not have any meaning;
                     // might wanna set up Event to have a prepare stage
                     sense: CursorSense::Hovering,
-        render,
+                    render: self,
                 };
-    rsc.run_event::<CursorSense>(id, data, state)
+                rsc.run_event::<CursorSense>(*id, data, state);
+            }
+            if sensed {
+                break;
+            }
+        }
+        rsc.events_mut().get_type::<CursorSense>().active = active;
+    }
 }
 
 pub fn should_run(
@@ -268,11 +205,6 @@ pub fn should_run(
     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/default/task.rs

@@ -1,5 +1,11 @@
 use iris_core::HasState;
-use std::{pin::Pin, sync::Arc};
+use std::{
+    pin::Pin,
+    sync::{
+        Arc,
+        mpsc::{Receiver as SyncReceiver, Sender as SyncSender, channel as sync_channel},
+    },
+};
 use tokio::{
     runtime::Runtime,
     sync::mpsc::{
@@ -7,52 +13,64 @@ use tokio::{
         unbounded_channel as async_channel,
     },
 };
+use winit::window::Window;
+
+pub type TaskMsgSender<Rsc> = SyncSender<Box<dyn TaskUpdate<Rsc>>>;
+pub type TaskMsgReceiver<Rsc> = SyncReceiver<Box<dyn TaskUpdate<Rsc>>>;
 
 pub trait TaskUpdate<Rsc: HasState>: FnOnce(&mut Rsc::State, &mut Rsc) + Send {}
 impl<F: FnOnce(&mut Rsc::State, &mut Rsc) + Send, Rsc: HasState> TaskUpdate<Rsc> for F {}
 
-/// Hands an update from a task to the thread that owns the ui. Delivery and
-/// waking are one act: a host posts the update as a message its loop already
-/// carries, so nothing has to wake the loop separately, or claim a redraw to
-/// be looked at.
-pub trait TaskQueue<Rsc: HasState>: Send + Sync + 'static {
-    fn send(&self, update: Box<dyn TaskUpdate<Rsc>>);
-}
-
 pub struct Tasks<Rsc: HasState> {
     start: AsyncSender<BoxTask>,
-    queue: Arc<dyn TaskQueue<Rsc>>,
+    window: Arc<Window>,
+    msg_send: SyncSender<Box<dyn TaskUpdate<Rsc>>>,
 }
 
 pub struct TaskCtx<Rsc: HasState> {
-    queue: Arc<dyn TaskQueue<Rsc>>,
+    send: TaskMsgSender<Rsc>,
 }
 
 impl<Rsc: HasState> TaskCtx<Rsc> {
     pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
-        self.queue.send(Box::new(f));
+        let _ = self.send.send(Box::new(f));
+    }
+}
+impl<Rsc: HasState + 'static> TaskCtx<Rsc> {
+    fn new(send: TaskMsgSender<Rsc>) -> Self {
+        Self { send }
     }
 }
 
 type BoxTask = Pin<Box<dyn Future<Output = ()> + Send>>;
 
 impl<Rsc: HasState> Tasks<Rsc> {
-    pub fn init(queue: Arc<dyn TaskQueue<Rsc>>) -> Self {
+    pub fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Rsc>) {
         let (start, start_recv) = async_channel();
+        let (msgs, msgs_recv) = sync_channel();
         std::thread::spawn(|| {
             let rt = Runtime::new().unwrap();
             rt.block_on(listen(start_recv))
         });
-        Self { start, queue }
+        (
+            Self {
+                start,
+                msg_send: msgs,
+                window,
+            },
+            msgs_recv,
+        )
     }
 
     pub fn spawn<F: AsyncFnOnce(TaskCtx<Rsc>) + 'static + std::marker::Send>(&mut self, task: F)
     where
         F::CallOnceFuture: Send,
     {
-        let queue = self.queue.clone();
+        let send = self.msg_send.clone();
+        let window = self.window.clone();
         let _ = self.start.send(Box::pin(async move {
-            task(TaskCtx { queue }).await;
+            task(TaskCtx::new(send)).await;
+            window.request_redraw();
         }));
     }
 }

src/harness.rs

@@ -1,320 +0,0 @@
-//! A ui with no window: build a tree, run frames, move a pointer, and read
-//! back where widgets landed.
-//!
-//! It does not draw. A claim about pixels still needs a real surface.
-
-use crate::prelude::*;
-use std::{
-    sync::{
-        Arc,
-        mpsc::{Receiver, SyncSender, sync_channel},
-    },
-    time::Duration,
-};
-
-/// There is no loop here to post to, so updates queue until the test asks
-/// for them.
-struct Queue(SyncSender<Box<dyn TaskUpdate<DefaultRsc<HarnessState>>>>);
-
-impl TaskQueue<DefaultRsc<HarnessState>> for Queue {
-    fn send(&self, update: Box<dyn TaskUpdate<DefaultRsc<HarnessState>>>) {
-        let _ = self.0.send(update);
-    }
-}
-
-/// `assert_eq!` for where a frame put a widget, written as its two corners.
-#[macro_export]
-macro_rules! assert_corners {
-    ($harness:expr, $id:expr, ($x0:expr, $y0:expr), ($x1:expr, $y1:expr)) => {
-        assert_eq!(
-            $harness.region(&$id).expect("widget drew nothing"),
-            $crate::core::PixelRegion {
-                top_left: $crate::core::util::Vec2::new($x0 as f32, $y0 as f32),
-                bot_right: $crate::core::util::Vec2::new($x1 as f32, $y1 as f32),
-            }
-        );
-    };
-}
-pub use crate::assert_corners;
-
-/// One replayed pointer sample, cut down to what a window delivers: where the
-/// pointer is, and whether the button changed.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum TouchAction {
-    Down,
-    Move,
-    Up,
-}
-
-impl TouchAction {
-    fn parse(word: &str) -> Option<Self> {
-        match word {
-            "down" => Some(Self::Down),
-            "move" => Some(Self::Move),
-            "up" => Some(Self::Up),
-            _ => None,
-        }
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct TouchSample {
-    pub t_ms: u64,
-    pub action: TouchAction,
-    pub pos: Vec2,
-}
-
-/// A recorded gesture, in the output's own pixels: `<ms> down|move|up <x> <y>`
-/// a line, `#` to end of line ignored.
-///
-/// One parser for both ways of replaying a recording -- into a harness, and
-/// into a real window -- so the two cannot read the same file differently.
-pub struct TouchScript {
-    pub samples: Vec<TouchSample>,
-}
-
-impl TouchScript {
-    pub fn parse(text: &str) -> Result<Self, String> {
-        let mut samples: Vec<TouchSample> = Vec::new();
-        for (i, line) in text.lines().enumerate() {
-            let line = line.split('#').next().unwrap_or("").trim();
-            if line.is_empty() {
-                continue;
-            }
-            let at = |what: &str| format!("touch script line {}: {what}: {line:?}", i + 1);
-            let mut words = line.split_whitespace();
-            let (Some(t), Some(action), Some(x), Some(y), None) = (
-                words.next(),
-                words.next(),
-                words.next(),
-                words.next(),
-                words.next(),
-            ) else {
-                return Err(at("expected `t_ms action x y`"));
-            };
-            let t_ms: u64 = t.parse().map_err(|_| at("t_ms is not a whole number"))?;
-            let action =
-                TouchAction::parse(action).ok_or_else(|| at("action is not down/move/up"))?;
-            let x: f32 = x.parse().map_err(|_| at("x is not a number"))?;
-            let y: f32 = y.parse().map_err(|_| at("y is not a number"))?;
-            if let Some(last) = samples.last()
-                && t_ms < last.t_ms
-            {
-                return Err(at("samples must be in time order"));
-            }
-            samples.push(TouchSample {
-                t_ms,
-                action,
-                pos: Vec2::new(x, y),
-            });
-        }
-        Ok(Self { samples })
-    }
-}
-
-#[derive(Default)]
-pub struct HarnessState {
-    pub root: Option<StrongWidget>,
-}
-
-impl HasRoot for HarnessState {
-    fn set_root(&mut self, root: StrongWidget) {
-        self.root = Some(root);
-    }
-}
-
-pub struct Harness {
-    pub rsc: DefaultRsc<HarnessState>,
-    pub render: UiRenderState,
-    pub state: HarnessState,
-    updates: Receiver<Box<dyn TaskUpdate<DefaultRsc<HarnessState>>>>,
-    cursor: CursorState,
-}
-
-impl Harness {
-    /// `size` is the output in physical pixels.
-    pub fn new(size: impl Into<Vec2>) -> Self {
-        // A `TaskQueue` must be `Sync`, which `mpsc::Sender` is not; the
-        // bound that comes with `SyncSender` is far past anything a test
-        // leaves unread.
-        let (send, updates) = sync_channel(1024);
-        let rsc = DefaultRsc::init(Arc::new(Queue(send)));
-        let mut render = UiRenderState::new();
-        render.resize(size);
-        Self {
-            rsc,
-            render,
-            state: HarnessState::default(),
-            updates,
-            cursor: CursorState::default(),
-        }
-    }
-
-    pub fn size(&self) -> Vec2 {
-        self.render.output_size()
-    }
-
-    pub fn resize(&mut self, size: impl Into<Vec2>) {
-        self.render.resize(size);
-    }
-
-    /// Sets the root and lays it out, so a pointer event has something to hit.
-    pub fn set_root<T>(&mut self, widget: impl WidgetLike<DefaultRsc<HarnessState>, T>) {
-        widget.set_root(&mut self.rsc, &mut self.state);
-        self.frame();
-    }
-
-    pub fn needs_redraw(&self) -> bool {
-        self.render
-            .needs_redraw(&self.state.root, self.rsc.widgets())
-    }
-
-    pub fn apply_updates(&mut self) -> usize {
-        let mut applied = 0;
-        while let Ok(update) = self.updates.try_recv() {
-            update(&mut self.state, &mut self.rsc);
-            applied += 1;
-        }
-        applied
-    }
-
-    /// Waits for a task's first update, then applies everything waiting.
-    /// False if none arrived in time.
-    #[must_use]
-    pub fn await_update(&mut self, timeout: Duration) -> bool {
-        let Ok(update) = self.updates.recv_timeout(timeout) else {
-            return false;
-        };
-        update(&mut self.state, &mut self.rsc);
-        self.apply_updates();
-        true
-    }
-
-    /// Lays the tree out and builds its primitives.
-    pub fn frame(&mut self) {
-        self.apply_updates();
-        self.render.update(&self.state.root, &mut self.rsc);
-    }
-
-    /// Where the last frame put a widget, or `None` if it drew nothing.
-    pub fn region(&self, id: &impl IdLike) -> Option<PixelRegion> {
-        self.render.window_region(id)
-    }
-
-    pub fn move_to(&mut self, pos: impl Into<Vec2>) {
-        self.cursor.pos = pos.into();
-        self.cursor.exists = true;
-        self.sense();
-    }
-
-    pub fn leave(&mut self) {
-        self.cursor.exists = false;
-        self.sense();
-    }
-
-    pub fn press(&mut self, button: CursorButton) {
-        self.button(button).update(true);
-        self.sense();
-    }
-
-    pub fn release(&mut self, button: CursorButton) {
-        self.button(button).update(false);
-        self.sense();
-    }
-
-    /// A wheel carries no position, so this goes wherever the cursor was last
-    /// moved to -- nowhere, until it has been moved.
-    pub fn scroll(&mut self, delta: impl Into<Vec2>) {
-        self.cursor.scroll_delta = delta.into();
-        self.sense();
-    }
-
-    pub fn click(&mut self, pos: impl Into<Vec2>) {
-        self.move_to(pos);
-        self.press(CursorButton::Left);
-        self.release(CursorButton::Left);
-    }
-
-    /// Drives a recorded gesture through the harness.
-    pub fn replay(&mut self, script: &TouchScript) {
-        for sample in &script.samples {
-            match sample.action {
-                TouchAction::Down => {
-                    self.move_to(sample.pos);
-                    self.press(CursorButton::Left);
-                }
-                TouchAction::Move => self.move_to(sample.pos),
-                TouchAction::Up => {
-                    self.move_to(sample.pos);
-                    self.release(CursorButton::Left);
-                }
-            }
-        }
-    }
-
-    fn button(&mut self, button: CursorButton) -> &mut ActivationState {
-        let buttons = &mut self.cursor.buttons;
-        match button {
-            CursorButton::Left => &mut buttons.left,
-            CursorButton::Middle => &mut buttons.middle,
-            CursorButton::Right => &mut buttons.right,
-        }
-    }
-
-    /// Dispatches against the layout of the last frame, which is what a
-    /// window delivers input against too.
-    fn sense(&mut self) {
-        let cursor = self.cursor.clone();
-        self.render
-            .run_sensors(&mut self.rsc, &mut self.state, cursor);
-        self.cursor.end_frame();
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn parse(text: &str) -> Result<Vec<(u64, TouchAction, f32, f32)>, String> {
-        Ok(TouchScript::parse(text)?
-            .samples
-            .iter()
-            .map(|s| (s.t_ms, s.action, s.pos.x, s.pos.y))
-            .collect())
-    }
-
-    #[test]
-    fn a_recording_is_time_action_and_a_point() {
-        assert_eq!(
-            parse("0 down 10 20\n16 move 10.5 24\n32 up 10.5 24").unwrap(),
-            [
-                (0, TouchAction::Down, 10.0, 20.0),
-                (16, TouchAction::Move, 10.5, 24.0),
-                (32, TouchAction::Up, 10.5, 24.0),
-            ]
-        );
-    }
-
-    #[test]
-    fn blank_lines_and_comments_are_not_samples() {
-        assert_eq!(
-            parse("# a flick\n\n 0 down 1 2   # the finger lands\n\n").unwrap(),
-            [(0, TouchAction::Down, 1.0, 2.0)]
-        );
-    }
-
-    #[test]
-    fn a_recording_that_goes_backwards_is_rejected() {
-        // Replay waits out the gap between samples, so time running backwards
-        // would silently become no wait at all.
-        let err = parse("16 down 1 2\n0 up 1 2").unwrap_err();
-        assert!(err.contains("time order"), "{err}");
-    }
-
-    #[test]
-    fn a_line_that_is_not_a_sample_says_which_line() {
-        let err = parse("0 down 1 2\n16 wiggle 1 2").unwrap_err();
-        assert!(err.contains("line 2"), "{err}");
-        assert!(err.contains("down/move/up"), "{err}");
-    }
-}

src/lib.rs

@@ -7,7 +7,6 @@
 
 pub mod default;
 pub mod event;
-pub mod harness;
 pub mod widget;
 
 pub use iris_core as core;

src/widget/image.rs

@@ -6,17 +6,16 @@ pub struct Image {
 }
 
 impl Widget for Image {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         painter.primitive(&self.handle);
-        Size::abs(self.handle.size())
     }
 
-    fn size_hint(&self, axis: Axis) -> Option<Len> {
-        Some(Len::abs(self.handle.size().axis(axis)))
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::abs(self.handle.size().x)
     }
 
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::abs(self.handle.size().y)
     }
 }
 

src/widget/mask.rs

@@ -5,13 +5,16 @@ pub struct Masked {
 }
 
 impl Widget for Masked {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         painter.set_mask(painter.region());
-        painter.widget(&self.inner).size()
+        painter.widget(&self.inner);
     }
 
-    /// It clips to the box it was given, not to the part its child used.
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Redraw
+    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)
     }
 }

src/widget/position/align.rs

@@ -6,17 +6,30 @@ pub struct Aligned {
 }
 
 impl Widget for Aligned {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        // Drawn where it may be too big, then given its aligned box once its
-        // size is known.
-        let size = painter.widget(&self.inner).size();
+    fn draw(&mut self, painter: &mut Painter) {
         let region = match self.align.tuple() {
-            (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)),
+            (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)
+            }
             (None, None) => UiRegion::FULL,
         };
         painter.widget_within(&self.inner, region);
-        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)
     }
 }

src/widget/position/layer.rs

@@ -6,10 +6,18 @@ pub struct LayerOffset {
 }
 
 impl Widget for LayerOffset {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         for _ in 0..self.offset {
             painter.next_layer();
         }
-        painter.widget(&self.inner).size()
+        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)
     }
 }

src/widget/position/max_size.rs

@@ -6,20 +6,43 @@ pub struct MaxSize {
     pub y: Option<Len>,
 }
 
-impl Widget for MaxSize {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let child = painter.widget(&self.inner).size();
-        let output = painter.output_size();
-        Size {
-            x: capped(child.x, self.x, output.x),
-            y: capped(child.y, self.y, output.y),
+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());
         }
     }
 }
 
-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,
+impl Widget for MaxSize {
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.widget(&self.inner);
+    }
+
+    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
+        }
     }
 }

src/widget/position/mod.rs

@@ -4,7 +4,7 @@ mod max_size;
 mod offset;
 mod pad;
 mod scroll;
-mod set_size;
+mod sized;
 mod span;
 mod stack;
 
@@ -14,6 +14,6 @@ pub use max_size::*;
 pub use offset::*;
 pub use pad::*;
 pub use scroll::*;
-pub use set_size::*;
+pub use sized::*;
 pub use span::*;
 pub use stack::*;

src/widget/position/offset.rs

@@ -6,8 +6,16 @@ pub struct Offset {
 }
 
 impl Widget for Offset {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         let region = UiRegion::FULL.offset(self.amt);
-        painter.widget_within(&self.inner, region).size()
+        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)
     }
 }

src/widget/position/pad.rs

@@ -6,20 +6,28 @@ pub struct Pad {
 }
 
 impl Widget for Pad {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let inner = painter
-            .widget_within(&self.inner, self.padding.region())
-            .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
-            },
+    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
     }
 }
 

src/widget/position/scroll.rs

@@ -10,14 +10,11 @@ pub struct Scroll {
 }
 
 impl Widget for Scroll {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    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();
-        // 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)
+        let content_len = painter
+            .len_axis(&self.inner, self.axis)
             .apply_rest()
             .within_len(container_len)
             .to_abs(output_len);
@@ -32,7 +29,14 @@ 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);
-        child
+    }
+
+    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)
     }
 }
 

src/widget/position/set_size.rs

@@ -1,26 +0,0 @@
-use crate::prelude::*;
-
-pub struct SetSize {
-    pub inner: StrongWidget,
-    pub x: Option<Len>,
-    pub y: Option<Len>,
-}
-
-impl Widget for SetSize {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let child = painter.widget(&self.inner).size();
-        Size {
-            x: self.x.unwrap_or(child.x),
-            y: self.y.unwrap_or(child.y),
-        }
-    }
-
-    /// 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/sized.rs

@@ -0,0 +1,34 @@
+use crate::prelude::*;
+
+pub struct Sized {
+    pub inner: StrongWidget,
+    pub x: Option<Len>,
+    pub y: Option<Len>,
+}
+
+impl Sized {
+    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 Widget for Sized {
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.widget(&self.inner);
+    }
+
+    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))
+    }
+}

src/widget/position/span.rs

@@ -8,27 +8,13 @@ pub struct Span {
 }
 
 impl Widget for Span {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        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);
-
+    fn draw(&mut self, painter: &mut Painter) {
+        let total = self.len_sum(&mut painter.size_ctx());
         let mut start = UiScalar::rel_min();
-        let mut ortho = Len::ZERO;
-        for (child, len) in self.children.iter().zip(&lens) {
+        for child in &self.children {
             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);
@@ -38,25 +24,27 @@ impl Widget for Span {
             start.abs += len.abs;
             start.rel += len.rel;
             span.end = start;
-            let mut region = UiRegion::from_axis(axis, span, UiSpan::FULL);
+            let mut child_region = UiRegion::from_axis(self.dir.axis, span, UiSpan::FULL);
             if self.dir.sign == Sign::Neg {
-                region.flip(axis);
-            }
-            let used = painter.widget_within(child, region).size().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);
+                child_region.flip(self.dir.axis);
             }
+            painter.widget_within(child, child_region);
             start.abs += self.gap;
         }
+    }
 
-        let along = match total.rest == 0.0 && total.rel == 0.0 {
-            true => total,
-            false => Len::default(),
-        };
-        Size::from_axis(axis, along, ortho)
+    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),
+        }
     }
 }
 
@@ -81,6 +69,87 @@ 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

@@ -8,25 +8,30 @@ pub struct Stack {
 }
 
 impl Widget for Stack {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        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(),
+    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);
         }
-            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();
+        for child in iter {
+            painter.next_layer();
+            painter.widget(child);
         }
     }
-        size
+
+    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]),
+        }
     }
 }
 

src/widget/ptr.rs

@@ -1,15 +1,30 @@
 use crate::prelude::*;
-use std::marker::Unsize;
+use std::marker::{Sized, Unsize};
 
 pub struct WidgetPtr {
     pub inner: Option<StrongWidget>,
 }
 
 impl Widget for WidgetPtr {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        match &self.inner {
-            Some(id) => painter.widget(id).size(),
-            None => Size::default(),
+    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
         }
     }
 }

src/widget/rect.rs

@@ -28,23 +28,21 @@ impl Rect {
 }
 
 impl Widget for Rect {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         painter.primitive(RectPrimitive {
             color: self.color,
             radius: self.radius,
             thickness: self.thickness,
             inner_radius: self.inner_radius,
         });
-        Size::REST
     }
 
-    fn size_hint(&self, _: Axis) -> Option<Len> {
-        Some(Len::REST)
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::rest(1)
     }
 
-    /// Its box is its primitive's own region, so a new one is written there.
-    fn on_resize(&self, _: Axis) -> OnResize {
-        OnResize::Scale
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::rest(1)
     }
 }
 

src/widget/text/build.rs

@@ -1,5 +1,5 @@
 use crate::prelude::*;
-use std::marker::PhantomData;
+use std::marker::{PhantomData, Sized};
 
 pub struct TextBuilder<State, O = TextOutput, H: WidgetOption<State> = ()> {
     pub content: String,

src/widget/text/edit.rs

@@ -55,47 +55,44 @@ impl TextEdit {
 }
 
 impl Widget for TextEdit {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         let base = painter.layer;
         painter.child_layer();
-        let (_, size) = self.view.draw(painter);
+        self.view.draw(painter);
         painter.layer = base;
         let region = self.region();
 
         let Some(selection) = self.selection else {
-            return size;
+            return;
         };
         let layout = self.view.buf.layout();
 
         // parley reports selection as boxes in layout space, so bidi and
         // wrapped lines come out right without this code knowing about either.
         for (rect, _) in selection.geometry(layout) {
-            let rect_size = vec2(rect.width() as f32, rect.height() as f32);
+            let size = vec2(rect.width() as f32, rect.height() as f32);
             let top_left = vec2(rect.x0 as f32, rect.y0 as f32);
             painter.primitive_within(
                 RectPrimitive::color(Color::SKY),
-                rect_size
-                    .align(Align::TOP_LEFT)
-                    .offset(top_left)
-                    .within(&region),
+                size.align(Align::TOP_LEFT).offset(top_left).within(&region),
             );
         }
 
         let caret = selection.focus().geometry(layout, CARET_WIDTH);
-        let caret_size = vec2(caret.width() as f32, caret.height() as f32);
+        let size = vec2(caret.width() as f32, caret.height() as f32);
         let top_left = vec2(caret.x0 as f32, caret.y0 as f32);
         painter.primitive_within(
             RectPrimitive::color(Color::WHITE),
-            caret_size
-                .align(Align::TOP_LEFT)
-                .offset(top_left)
-                .within(&region),
+            size.align(Align::TOP_LEFT).offset(top_left).within(&region),
         );
-        size
     }
 
-    fn on_resize(&self, axis: Axis) -> OnResize {
-        self.view.on_resize(axis)
+    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)
     }
 }
 

src/widget/text/mod.rs

@@ -52,15 +52,15 @@ impl TextView {
             .align(self.align)
     }
 
-    fn render(&mut self, painter: &mut Painter) -> &RenderedText {
+    fn render(&mut self, ctx: &mut SizeCtx) -> &RenderedText {
         let width = if self.attrs.wrap {
-            Some(painter.px_size().x)
+            Some(ctx.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(painter.render_text(&mut self.buf, &self.attrs, width));
+            self.tex = Some(ctx.draw_text(&mut self.buf, &self.attrs, width));
             self.attrs.changed = false;
             self.buf.changed = false;
         }
@@ -69,40 +69,39 @@ impl TextView {
     pub fn tex(&self) -> Option<&RenderedText> {
         self.tex.as_ref()
     }
-    /// Draws the text, and says where the glyphs went and what they use.
-    pub fn draw(&mut self, painter: &mut Painter) -> (UiRegion, Size) {
+    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 {
         let align = self.align;
         if self.is_empty() && self.hint.is_some() {
-            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 region = self.render(&mut painter.size_ctx()).size.align(align);
+            if let Some(hint) = &self.hint {
+                painter.widget(hint);
+            }
+            return region;
         }
 
-        let tex = self.render(painter);
+        let tex = self.render(&mut painter.size_ctx());
         let region = tex.size.align(align);
-        let size = Size::abs(tex.size);
         let within = region.within(&painter.region());
         painter.glyphs(tex, within);
-        (region, size)
-    }
-
-    /// Wrapping reads the width it is offered, so a wider box reshapes it and
-    /// a taller one does not. Alignment matters too, and separately: glyphs
-    /// anchored to the start of an axis stay put when that extent changes,
-    /// but centred or end-aligned ones move even though the shaping stands.
-    pub fn on_resize(&self, axis: Axis) -> OnResize {
-        let reshapes = axis == Axis::X && self.attrs.wrap;
-        let anchored = match axis {
-            Axis::X => self.align.x,
-            Axis::Y => self.align.y,
-        } == AxisAlign::Neg;
-        match reshapes || !anchored {
-            true => OnResize::Redraw,
-            false => OnResize::Translate,
-        }
+        region
     }
 
     pub fn content(&self) -> String {
@@ -118,7 +117,7 @@ impl Text {
             content: content.into(),
         }
     }
-    fn update_buf(&mut self) {
+    fn update_buf(&mut self, _ctx: &mut SizeCtx) {
         if self.content.changed {
             self.content.changed = false;
             self.view.buf.set_text(self.content.as_str());
@@ -127,13 +126,19 @@ impl Text {
 }
 
 impl Widget for Text {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.update_buf();
-        self.view.draw(painter).1
+    fn draw(&mut self, painter: &mut Painter) {
+        self.update_buf(&mut painter.size_ctx());
+        self.view.draw(painter);
     }
 
-    fn on_resize(&self, axis: Axis) -> OnResize {
-        self.view.on_resize(axis)
+    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)
     }
 }
 

src/widget/trait_fns.rs

@@ -31,9 +31,9 @@ widget_trait! {
         }
     }
 
-    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, SetSize> {
+    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, Sized> {
         let size = size.into();
-        move |state| SetSize {
+        move |state| Sized {
             inner: self.add_strong(state),
             x: Some(size.x),
             y: Some(size.y),
@@ -58,18 +58,18 @@ widget_trait! {
         }
     }
 
-    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
+    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
         let len = len.into();
-        move |state| SetSize {
+        move |state| Sized {
             inner: self.add_strong(state),
             x: Some(len),
             y: None,
         }
     }
 
-    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
+    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
         let len = len.into();
-        move |state| SetSize {
+        move |state| Sized {
             inner: self.add_strong(state),
             x: None,
             y: Some(len),

tests/draw_cost.rs

@@ -4,19 +4,20 @@
 //!
 //!     cargo test --release --test draw_cost -- --ignored --nocapture
 //!
-//! Wall time is the wrong number to read for anything under a few percent --
-//! it varied by 2x between runs of one unchanged binary where instructions
-//! retired varied by 0.1%. Count those instead:
+//! **Read the instruction count, not the clock.** Wall time here swings by 2x
+//! between runs of one binary on this machine -- more under `cargo test` than
+//! run directly -- while instructions retired are stable to 0.1%:
 //!
 //!     perf stat -e instructions:u target/release/.../draw_cost-* --ignored
 //!
-//! That is how `PrimitiveRender` was measured against a match in the renderer:
-//! 6 instructions per list drawn, against the ~5,400 wgpu spends recording
-//! one.
+//! Measured that way on 2026-09-13, drawing each primitive through its own
+//! `PrimitiveRender` rather than a match in the renderer costs **6
+//! instructions per list drawn**, which is 0.1% of a frame at both 256 and
+//! 1024 layers. Recording one list into the pass costs wgpu ~5,400.
 //!
-//! The instance is leaked deliberately. A Vulkan loader may unload the driver
-//! when the last one drops, which can fault as a thread that used it exits --
-//! and every test runs on a spawned thread.
+//! The instance is leaked on purpose. Dropping the last one makes the Vulkan
+//! loader unload Mesa's ICD, which faults when a thread that touched Vulkan
+//! exits -- and libtest runs every test on a spawned thread.
 
 use std::time::Instant;
 
@@ -29,20 +30,20 @@ use wgpu::{Color as GpuColor, *};
 
 const SIZE: u32 = 1024;
 const FRAMES: u32 = 200;
-/// Reported as the best of this many batches, since the mean moves by more
-/// than the thing being measured.
+/// Reported as the best of this many batches. The mean moves by 15% between
+/// runs on this machine, which is more than the thing being measured.
 const BATCHES: u32 = 8;
 
 fn gpu() -> Option<(Device, Queue)> {
-    // Probed rather than assumed: there may be no Vulkan adapter, and GL is
-    // what is left when there is not.
-    let all = Instance::new(InstanceDescriptor::new_without_display_handle());
+    // Probed rather than assumed: this machine's Vulkan device comes and goes,
+    // and GL is what is left when it is gone.
+    let all = Instance::new(&InstanceDescriptor::default());
     let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
     {
         Ok(_) => all,
-        Err(_) => Instance::new(InstanceDescriptor {
+        Err(_) => Instance::new(&InstanceDescriptor {
             backends: Backends::GL,
-            ..InstanceDescriptor::new_without_display_handle()
+            ..Default::default()
         }),
     };
     // Leaked rather than dropped: see the note at the top of the file.
@@ -57,7 +58,6 @@ fn config(format: TextureFormat) -> SurfaceConfiguration {
     SurfaceConfiguration {
         usage: TextureUsages::RENDER_ATTACHMENT,
         format,
-        color_space: SurfaceColorSpace::Auto,
         width: SIZE,
         height: SIZE,
         present_mode: PresentMode::Fifo,

tests/layout.rs

@@ -1,111 +0,0 @@
-//! Where a frame puts things, with no window to put them in.
-
-use iris::harness::{Harness, assert_corners};
-use iris::prelude::*;
-
-/// A fixed 100 wide, and the rest of the 400 to its neighbour.
-fn two_rects(h: &mut Harness) -> (WidgetId, WidgetId) {
-    let left = rect(Color::RED).width(100).add(&mut h.rsc);
-    let right = rect(Color::BLUE).add(&mut h.rsc);
-    h.set_root((left, right).span(Dir::RIGHT));
-    (left.id(), right.id())
-}
-
-#[test]
-fn a_span_gives_each_child_the_width_it_asked_for() {
-    let mut h = Harness::new((400, 200));
-    let (left, right) = two_rects(&mut h);
-
-    assert_corners!(h, left, (0, 0), (100, 200));
-    assert_corners!(h, right, (100, 0), (400, 200));
-}
-
-#[test]
-fn resizing_relays_out_against_the_new_output() {
-    let mut h = Harness::new((400, 200));
-    let (left, right) = two_rects(&mut h);
-
-    h.resize((800, 100));
-    assert!(h.needs_redraw());
-    h.frame();
-
-    assert_corners!(h, left, (0, 0), (100, 100));
-    assert_corners!(h, right, (100, 0), (800, 100));
-}
-
-#[test]
-fn an_empty_widget_takes_a_share_of_a_span() {
-    let mut h = Harness::new((400, 200));
-    let gap = ().add(&mut h.rsc);
-    let right = rect(Color::BLUE).width(100).add(&mut h.rsc);
-    h.set_root((gap, right).span(Dir::RIGHT));
-
-    assert_corners!(h, gap, (0, 0), (300, 200));
-    assert_corners!(h, right, (300, 0), (400, 200));
-}
-
-#[test]
-fn a_child_drawn_twice_moves_once() {
-    let mut h = Harness::new((400, 200));
-    // `Aligned` draws its child twice; listing it twice would move it twice.
-    let inner = rect(Color::BLUE).add(&mut h.rsc);
-    let centered = inner.center().width(200).add(&mut h.rsc);
-    let left = rect(Color::RED).width(100).add(&mut h.rsc);
-    h.set_root((left, centered).span(Dir::RIGHT));
-    assert_corners!(h, inner, (100, 0), (300, 200));
-
-    h.rsc[left].x = Some(Len::abs(150));
-    h.frame();
-
-    assert_corners!(h, inner, (150, 0), (350, 200));
-}
-
-#[test]
-fn a_resize_lands_where_a_cold_start_would() {
-    let build = |h: &mut Harness| {
-        let para = wtext(
-            "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.",
-        )
-        .size(20)
-        .wrap(true)
-        .pad(16)
-        .add(&mut h.rsc);
-        let below = rect(Color::RED).add(&mut h.rsc);
-        let root = (para, below).span(Dir::DOWN).pad(12);
-        h.set_root(root);
-        (para, below)
-    };
-
-    let mut cold = Harness::new((900, 1200));
-    let (cold_para, cold_below) = build(&mut cold);
-
-    let mut resized = Harness::new((1920, 1200));
-    let (para, below) = build(&mut resized);
-    resized.resize((900, 1200));
-    resized.frame();
-
-    assert_eq!(resized.region(&para), cold.region(&cold_para), "paragraph");
-    assert_eq!(resized.region(&below), cold.region(&cold_below), "below");
-}
-
-#[test]
-fn a_fixed_box_is_drawn_again_rather_than_stretched() {
-    let mut h = Harness::new((400, 400));
-    // The panel fills a stack sized by its sibling, so it is drawn in the
-    // whole box and then placed in the shorter one. Reusing it in that fixed
-    // box afterwards would leave it whatever height it happened to have.
-    let panel = rect(Color::BLUE).add(&mut h.rsc);
-    let leaf = rect(Color::RED).height(100).add(&mut h.rsc);
-    let stack = (panel, leaf)
-        .stack()
-        .size(StackSize::Child(1))
-        .add(&mut h.rsc);
-    h.set_root(stack.align(Align::TOP));
-    assert_corners!(h, panel, (0, 0), (400, 100));
-
-    h.rsc[leaf].y = Some(Len::abs(250));
-    h.frame();
-
-    assert_corners!(h, panel, (0, 0), (400, 250));
-}

tests/pointer.rs

@@ -1,85 +0,0 @@
-//! Which widget an input reaches.
-
-use std::{cell::RefCell, rc::Rc};
-
-use iris::harness::{Harness, TouchScript};
-use iris::prelude::*;
-
-#[test]
-fn a_press_reaches_only_the_widget_under_the_cursor() {
-    let mut h = Harness::new((400, 200));
-    let clicks = Rc::new(RefCell::new(Vec::new()));
-
-    let (on_left, on_right) = (clicks.clone(), clicks.clone());
-    let left = rect(Color::RED)
-        .width(100)
-        .on(CursorSense::click(), move |_, _| {
-            on_left.borrow_mut().push("left")
-        })
-        .add(&mut h.rsc);
-    let right = rect(Color::BLUE)
-        .on(CursorSense::click(), move |_, _| {
-            on_right.borrow_mut().push("right")
-        })
-        .add(&mut h.rsc);
-    h.set_root((left, right).span(Dir::RIGHT));
-
-    h.click((50, 100));
-    assert_eq!(*clicks.borrow(), ["left"]);
-
-    h.click((300, 100));
-    assert_eq!(*clicks.borrow(), ["left", "right"]);
-}
-
-#[test]
-fn hover_ends_when_the_cursor_leaves_the_window() {
-    let mut h = Harness::new((400, 200));
-    let hovered = Rc::new(RefCell::new(0));
-    let ended = Rc::new(RefCell::new(0));
-
-    let (h_count, e_count) = (hovered.clone(), ended.clone());
-    let widget = rect(Color::RED)
-        .on(CursorSense::HoverStart, move |_, _| {
-            *h_count.borrow_mut() += 1
-        })
-        .on(CursorSense::HoverEnd, move |_, _| {
-            *e_count.borrow_mut() += 1
-        })
-        .add(&mut h.rsc);
-    h.set_root(widget);
-
-    h.move_to((200, 100));
-    assert_eq!((*hovered.borrow(), *ended.borrow()), (1, 0));
-
-    // A second sample inside the same widget is not a second hover.
-    h.move_to((210, 100));
-    assert_eq!((*hovered.borrow(), *ended.borrow()), (1, 0));
-
-    h.leave();
-    assert_eq!((*hovered.borrow(), *ended.borrow()), (1, 1));
-}
-
-#[test]
-fn a_recorded_gesture_presses_where_it_says() {
-    let mut h = Harness::new((400, 200));
-    let clicks = Rc::new(RefCell::new(Vec::new()));
-
-    let (on_left, on_right) = (clicks.clone(), clicks.clone());
-    let left = rect(Color::RED)
-        .width(100)
-        .on(CursorSense::click(), move |_, _| {
-            on_left.borrow_mut().push("left")
-        })
-        .add(&mut h.rsc);
-    let right = rect(Color::BLUE)
-        .on(CursorSense::click(), move |_, _| {
-            on_right.borrow_mut().push("right")
-        })
-        .add(&mut h.rsc);
-    h.set_root((left, right).span(Dir::RIGHT));
-
-    let script = TouchScript::parse("0 down 300 100\n80 up 300 100").unwrap();
-    h.replay(&script);
-
-    assert_eq!(*clicks.borrow(), ["right"]);
-}

tests/pointer_routing.rs

@@ -1,225 +0,0 @@
-//! 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/remap.rs

@@ -1,27 +0,0 @@
-//! What a drawing can be taken out of, and what it cannot.
-
-use iris::core::{Remap, UiRegion, UiScalar, UiSpan};
-
-/// A box `size` tall whose top is `rel` of the way down the window.
-fn fixed(rel: f32, size: f32) -> UiRegion {
-    UiRegion::new(
-        UiSpan::FULL,
-        UiSpan::new(UiScalar { rel, abs: 0.0 }, UiScalar { rel, abs: size }),
-    )
-}
-
-#[test]
-fn a_fixed_box_can_be_carried_but_not_stretched() {
-    let from = fixed(0.0, 164.0);
-    assert!(Remap::new(from, UiRegion::FULL).is_none());
-    assert!(Remap::new(from, fixed(0.5, 164.0)).is_some());
-    assert!(Remap::new(from, fixed(0.0, 98.0)).is_none());
-}
-
-#[test]
-fn a_relative_box_can_be_stretched_to_any_other() {
-    let remap = Remap::new(UiRegion::FULL, fixed(0.0, 98.0)).expect("relative boxes remap");
-    // A part that filled the window keeps filling what replaced it, which is
-    // exactly what `outside` could not say for a box of a fixed length.
-    assert_eq!(remap.apply(UiRegion::FULL), fixed(0.0, 98.0));
-}

tests/retained.rs

@@ -1,252 +0,0 @@
-//! 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: OnResize,
-}
-
-impl Widget for Counted {
-    fn draw(&mut self, _: &mut Painter) -> Size {
-        self.draws.set(self.draws.get() + 1);
-        self.size
-    }
-
-    fn on_resize(&self, _: Axis) -> OnResize {
-        self.dependence
-    }
-}
-
-struct Counts(Rc<Cell<usize>>);
-
-impl Counts {
-    fn get(&self) -> usize {
-        self.0.get()
-    }
-}
-
-fn counted(h: &mut Harness, size: Size, dependence: OnResize) -> (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: OnResize) -> (WeakWidget<Counted>, Counts, WidgetId) {
-    let (first, _) = counted(h, Size::from((100, 200)), OnResize::Translate);
-    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, OnResize::Scale);
-    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, OnResize::Redraw);
-    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)), OnResize::Translate);
-    let (asked, asked_draws) = counted(&mut h, Size::from((100, 200)), OnResize::Translate);
-    // 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, OnResize::Translate);
-
-    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));
-}
-
-/// Lays its child out from the hint alone, never reading what it drew.
-struct FromHint {
-    inner: StrongWidget,
-}
-
-impl Widget for FromHint {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let len = painter.size_hint(&self.inner, Axis::Y).unwrap();
-        let mut region = UiRegion::FULL;
-        region.y.end = region.y.start.offset(len.abs);
-        painter.widget_within(&self.inner, region);
-        Size::REST
-    }
-}
-
-#[test]
-fn a_parent_that_only_read_a_hint_relays_out_when_the_hint_changes() {
-    let mut h = Harness::new((400, 200));
-    let inner = rect(Color::RED).height(80).add(&mut h.rsc);
-    let parent = FromHint {
-        inner: inner.add_strong(&mut h.rsc),
-    }
-    .add(&mut h.rsc);
-    h.set_root(parent);
-    assert_corners!(h, inner, (0, 0), (400, 80));
-
-    h.rsc[inner].y = Some(Len::abs(120));
-    h.frame();
-
-    assert_corners!(h, inner, (0, 0), (400, 120));
-}
-
-/// Reads the output's size, which nothing but its own draw can put right.
-struct ReadsOutput {
-    draws: Rc<Cell<usize>>,
-}
-
-impl Widget for ReadsOutput {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.draws.set(self.draws.get() + 1);
-        Size::abs(painter.output_size() / 4.0)
-    }
-}
-
-#[test]
-fn a_resize_does_not_redraw_what_the_shader_can_move() {
-    let mut h = Harness::new((400, 200));
-    let (leaf, draws) = counted(&mut h, Size::REST, OnResize::Redraw);
-    h.set_root(leaf);
-    let settled = draws.get();
-
-    h.resize((800, 100));
-    assert!(h.needs_redraw());
-    h.frame();
-
-    assert_eq!(
-        draws.get(),
-        settled,
-        "its box is the same fraction of a different output"
-    );
-    assert_corners!(h, leaf, (0, 0), (800, 100));
-}
-
-#[test]
-fn a_resize_redraws_what_read_the_output() {
-    let mut h = Harness::new((400, 200));
-    let draws = Rc::new(Cell::new(0));
-    let leaf = ReadsOutput {
-        draws: draws.clone(),
-    }
-    .add(&mut h.rsc);
-    h.set_root(leaf);
-    let settled = draws.get();
-
-    h.resize((800, 100));
-    h.frame();
-
-    assert_eq!(draws.get(), settled + 1);
-}
-
-#[test]
-fn narrowing_the_output_reflows_text_and_relays_out_around_it() {
-    let mut h = Harness::new((600, 400));
-    let para = wtext(
-        "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.",
-    )
-    .size(20)
-    .wrap(true)
-    .add(&mut h.rsc);
-    let below = rect(Color::RED).add(&mut h.rsc);
-    h.set_root((para, below).span(Dir::DOWN));
-    let top = h.region(&below).expect("drew nothing").top_left.y;
-
-    h.resize((300, 400));
-    h.frame();
-
-    let lower = h.region(&below).expect("drew nothing").top_left.y;
-    assert!(lower > top, "same words, half the width: {top} -> {lower}");
-}
-
-#[test]
-fn a_change_two_levels_under_its_reader_still_reaches_it() {
-    let mut h = Harness::new((400, 400));
-    // 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::abs((100, 100).into()), OnResize::Redraw);
-    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));
-    assert_corners!(h, below, (12, 132), (388, 388));
-
-    h.rsc[leaf].size = Size::abs((100, 200).into());
-    h.frame();
-
-    assert_corners!(h, below, (12, 232), (388, 388));
-}

tests/scroll.rs

@@ -1,26 +0,0 @@
-//! Scrolling moves content and stops at its ends.
-
-use iris::harness::{Harness, assert_corners};
-use iris::prelude::*;
-
-#[test]
-fn a_wheel_scrolls_the_content_and_stops_at_its_end() {
-    let mut h = Harness::new((400, 200));
-    // Twice the window's height, so there is 200 to scroll.
-    let top = rect(Color::RED).height(200).add(&mut h.rsc);
-    let bottom = rect(Color::BLUE).height(200).add(&mut h.rsc);
-    h.set_root((top, bottom).span(Dir::DOWN).scrollable());
-    h.move_to((200, 100));
-
-    // `Scroll` starts snapped to the end.
-    assert_corners!(h, top, (0, -200), (400, 0));
-
-    // The handler scales a wheel line by 50.
-    h.scroll((0, 1));
-    h.frame();
-    assert_corners!(h, top, (0, -150), (400, 50));
-
-    h.scroll((0, 10));
-    h.frame();
-    assert_corners!(h, top, (0, 0), (400, 200));
-}

tests/tasks.rs

@@ -1,23 +0,0 @@
-//! What a background task can change, and how it gets back to the ui.
-
-use std::time::Duration;
-
-use iris::harness::Harness;
-use iris::prelude::*;
-
-#[test]
-fn a_task_update_reaches_the_tree() {
-    let mut h = Harness::new((400, 200));
-    let widget = rect(Color::RED).add(&mut h.rsc);
-    h.set_root(widget.task_on(CursorSense::click(), async move |mut ctx| {
-        ctx.update(move |_, rsc| widget(rsc).color = Color::BLUE);
-    }));
-
-    h.click((200, 100));
-
-    assert!(
-        h.await_update(Duration::from_secs(5)),
-        "the task sent no update"
-    );
-    assert_eq!(h.rsc[widget].color, Color::BLUE);
-}