Take a strong widget to depend on, and use the question mark

`depend_on_size` took a bare `WidgetId`, which any id at all satisfies.
It takes a `&StrongWidget` now, so `DrawResult` carries the handle it
was drawn from rather than an id copied out of it and nothing can claim
a dependency on a widget it does not hold.

`UiSpan::outside` matched on a pair of `Option`s where `?` says it. It
was written that way while the method was still `const`, and it is not.

No call site changed. Checked: fmt, clippy and 35 tests; `tabs`, `view`,
`minimal` and `text` render unchanged, and the live sway resize round
trip still matches a cold start at each size.

Cargo.toml

@@ -8,8 +8,7 @@ edition.workspace = true
 [dependencies]
 iris-core = { workspace = true }
 iris-macro = { workspace = true }
-cosmic-text = { workspace = true }
-unicode-segmentation = { workspace = true }
+parley = { workspace = true }
 winit = { workspace = true }
 arboard = { workspace = true, features = ["wayland-data-control"] }
 pollster = { workspace = true }
@@ -28,14 +27,15 @@ version = "0.1.0"
 edition = "2024"
 
 [workspace.dependencies]
-pollster = "1.0.1"
+pollster = "0.4.0"
 winit = "0.30.12"
-wgpu = "30.0.0"
+wgpu = "30.0.1"
 bytemuck = "1.23.1"
-image = "0.25.6"
-cosmic-text = "0.16.0"
-unicode-segmentation = "1.12.0"
+image = "0.25.10"
+parley = "0.11.1"
+swash = "0.2.10"
 fxhash = "0.2.1"
+log = "0.4.29"
 arboard = "3.6.1"
 iris-core = { path = "core" }
 iris-macro = { path = "macro" }

TODO

@@ -1,19 +1,6 @@
 images
     settings (sampler)
-
-text
-    figure out ways to speed up / what costs the most
-    resizing (per frame) is really slow (assuming painter isn't griefing)
-    j is weird / fix x offset
-
-masks r just made to bare minimum work
-
-scaling
-    could be just a simple scaling factor that multiplies abs
-    and need to ensure text uses raw abs and not scaled abs
-    naming? (pt, px)
-    want to keep (drawn) regions using px? or should I add another field to UiScalar/Vec
-    field could be best solution so redrawing stuff isn't needed & you can specify both as user
+    consider typed TextureHandle<T> variants for distinct texture uses
 
 WidgetRef<W> or smth instead of Id
     enum that's either an Id or an actual concrete instance of W
@@ -24,17 +11,6 @@ WidgetRef<W> or smth instead of Id
     maybe introduce InnerWidget trait to allow for editors to expose & modify inner type
     maybe could also store a parent widget and keep using InnerWidget trait? unsure if possible
 
-really weird limitation:
-    I don't think you can currently remove an element from a parent and put it in a child of the same parent
-    because it removes the unused children after the entire parent redraw
-    but the child gets drawn during that, so it will think the child is still active !!!
-    or something like that idk, maybe I need a special enum for parent that includes a undecided state where it may or may not get redrawn by the parent
-    or just do ref counting and ensure all drawn things == 1 afterwards (seems like best way)
-    ok so I'm removing the limit for now
-
-don't forget I'm streaming
-
-tags
 vecs for each widget type?
 
 POTENTIAL BUG: closures that store IDs will not decrement the id!!! need to not increment id if moved into closure somehow??? wait no, need to decrement ID every time an event fn is added...... only if the id is used in it..??

core/Cargo.toml

@@ -4,9 +4,10 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-winit = { workspace = true }
 wgpu = { workspace = true }
 bytemuck ={ workspace = true }
 image = { workspace = true }
-cosmic-text = { workspace = true }
+parley = { workspace = true }
+swash = { workspace = true }
 fxhash = { workspace = true }
+log = { workspace = true }

core/src/attr.rs

@@ -1,4 +1,4 @@
-use crate::{UiRsc, WidgetIdFn, WidgetLike, WeakWidget};
+use crate::{UiRsc, WeakWidget, WidgetIdFn, WidgetLike};
 
 pub trait WidgetAttr<Rsc, W: ?Sized> {
     type Input;

core/src/event/manager.rs

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

core/src/event/mod.rs

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

core/src/event/rsc.rs

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

core/src/lib.rs

@@ -5,7 +5,6 @@
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
 #![feature(const_destruct)]
-#![feature(portable_simd)]
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(coerce_unsized)]

core/src/orientation/pos.rs

@@ -56,13 +56,6 @@ 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,
@@ -209,10 +202,12 @@ impl UiScalar {
         }
     }
 
-    pub const fn outside(&self, span: &UiSpan) -> Self {
-        let rel = self.rel.lerp_inv(span.start.rel, span.end.rel);
+    /// 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)?;
         let abs = self.abs - rel.lerp(span.start.abs, span.end.abs);
-        Self { rel, abs }
+        Some(Self { rel, abs })
     }
 
     pub fn within_len(&self, len: UiScalar) -> Self {
@@ -283,11 +278,11 @@ impl UiSpan {
         }
     }
 
-    pub const fn outside(&self, parent: &Self) -> Self {
-        Self {
-            start: self.start.outside(parent),
-            end: self.end.outside(parent),
-        }
+    pub fn outside(&self, parent: &Self) -> Option<Self> {
+        Some(Self {
+            start: self.start.outside(parent)?,
+            end: self.end.outside(parent)?,
+        })
     }
 
     pub const fn len(&self) -> UiScalar {
@@ -324,14 +319,7 @@ impl UiRegion {
             y: self.y.within(&parent.y),
         }
     }
-    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 {
+    pub const fn axis(&self, axis: Axis) -> &UiSpan {
         match axis {
             Axis::X => &self.x,
             Axis::Y => &self.y,
@@ -409,6 +397,50 @@ 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!(
@@ -421,7 +453,7 @@ impl Display for UiRegion {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone, Copy, PartialEq)]
 pub struct PixelRegion {
     pub top_left: Vec2,
     pub bot_right: Vec2,

core/src/primitive/color.rs

@@ -10,6 +10,12 @@ pub struct Color<T> {
     pub a: T,
 }
 
+impl<T: ColorNum> Default for Color<T> {
+    fn default() -> Self {
+        Self::BLACK
+    }
+}
+
 impl<T: ColorNum> Color<T> {
     pub const BLACK: Self = Self::rgb(T::MIN, T::MIN, T::MIN);
     pub const WHITE: Self = Self::rgb(T::MAX, T::MAX, T::MAX);

core/src/primitive/layer.rs

@@ -1,7 +1,7 @@
 use std::ops::{Index, IndexMut};
 
 use crate::{
-    render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives},
+    render::{LayerDraws, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
     util::to_mut,
 };
 
@@ -39,7 +39,7 @@ struct Child {
     tail: usize,
 }
 
-pub type PrimitiveLayers = Layers<Primitives>;
+pub type DrawLayers = Layers<LayerDraws>;
 
 impl<T: Default> Layers<T> {
     pub fn new() -> Layers<T> {
@@ -119,7 +119,7 @@ impl<T: Default> Layers<T> {
     }
 }
 
-impl PrimitiveLayers {
+impl DrawLayers {
     pub fn write<P: Primitive>(
         &mut self,
         layer: LayerId,

core/src/primitive/text.rs

@@ -1,60 +1,66 @@
-use crate::{Align, RegionAlign, TextureHandle, Textures, UiColor, util::Vec2};
-use cosmic_text::{
-    Attrs, AttrsList, Buffer, CacheKey, Color, Family, FontSystem, Metrics, Placement, SwashCache,
-    SwashContent,
+use crate::{
+    Align, GlyphAtlas, GlyphEntry, GlyphKey, PlacedGlyph, RegionAlign, UiColor, util::Vec2,
+};
+use parley::{
+    Alignment, AlignmentOptions, FontContext, FontFamily, FontFamilyName, GenericFamily, Layout,
+    LayoutContext, LineHeight, PositionedLayoutItem, StyleProperty,
+};
+use std::hash::{DefaultHasher, Hash, Hasher};
+use swash::{
+    FontRef,
+    scale::{Render, ScaleContext, Source, StrikeWith},
+    zeno::{Format, Vector},
 };
-use image::{DynamicImage, GenericImageView, RgbaImage};
-use std::simd::{Simd, num::SimdUint};
-
-/// TODO: properly wrap this
-pub mod text_lib {
-    pub use cosmic_text::*;
-}
 
 pub struct TextData {
-    pub font_system: FontSystem,
-    pub swash_cache: SwashCache,
-    glyph_cache: Vec<(Placement, CacheKey, Color)>,
+    pub font_ctx: FontContext,
+    pub layout_ctx: LayoutContext<UiColor>,
+    scale_ctx: ScaleContext,
+    pub atlas: GlyphAtlas,
 }
 
 impl Default for TextData {
     fn default() -> Self {
         Self {
-            font_system: FontSystem::new(),
-            swash_cache: SwashCache::new(),
-            glyph_cache: Default::default(),
+            font_ctx: FontContext::new(),
+            layout_ctx: LayoutContext::new(),
+            scale_ctx: ScaleContext::new(),
+            atlas: GlyphAtlas::default(),
         }
     }
 }
 
-#[derive(Clone, Copy)]
+#[derive(Clone, PartialEq)]
+pub enum Family {
+    SansSerif,
+    Serif,
+    Monospace,
+    Named(String),
+}
+
+impl Family {
+    fn family(&self) -> FontFamily<'_> {
+        let name = match self {
+            Self::SansSerif => FontFamilyName::Generic(GenericFamily::SansSerif),
+            Self::Serif => FontFamilyName::Generic(GenericFamily::Serif),
+            Self::Monospace => FontFamilyName::Generic(GenericFamily::Monospace),
+            Self::Named(name) => FontFamilyName::Named(name.as_str().into()),
+        };
+        FontFamily::Single(name)
+    }
+}
+
+#[derive(Clone, PartialEq)]
 pub struct TextAttrs {
     pub color: UiColor,
     pub font_size: f32,
     pub line_height: f32,
-    pub family: Family<'static>,
+    pub family: Family,
     pub wrap: bool,
-    /// inner alignment of text region (within where it's drawn)
     pub align: RegionAlign,
 }
 
-impl TextAttrs {
-    pub fn apply(&self, font_system: &mut FontSystem, buf: &mut Buffer, width: Option<f32>) {
-        buf.set_metrics_and_size(
-            font_system,
-            Metrics::new(self.font_size, self.line_height),
-            width,
-            None,
-        );
-        let attrs = Attrs::new().family(self.family);
-        let list = AttrsList::new(&attrs);
-        for line in &mut buf.lines {
-            line.set_attrs_list(list.clone());
-        }
-    }
-}
-
-pub type TextBuffer = Buffer;
+pub const LINE_HEIGHT_MULT: f32 = 1.1;
 
 impl Default for TextAttrs {
     fn default() -> Self {
@@ -70,122 +76,207 @@ impl Default for TextAttrs {
     }
 }
 
-pub const LINE_HEIGHT_MULT: f32 = 1.1;
+/// Keeps text and its corresponding layout from getting out of sync.
+pub struct TextBuffer {
+    text: String,
+    layout: Layout<UiColor>,
+    layout_key: Option<LayoutKey>,
+}
+
+#[derive(PartialEq)]
+struct LayoutKey {
+    attrs: TextAttrs,
+    max_width: Option<f32>,
+}
+
+impl TextBuffer {
+    pub fn new(text: impl Into<String>) -> Self {
+        Self {
+            text: text.into(),
+            layout: Layout::new(),
+            layout_key: None,
+        }
+    }
+
+    pub fn new_empty() -> Self {
+        Self::new("")
+    }
+
+    pub fn text(&self) -> &str {
+        &self.text
+    }
+
+    pub fn layout(&self) -> &Layout<UiColor> {
+        &self.layout
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.text.is_empty()
+    }
+
+    pub fn set_text(&mut self, text: impl Into<String>) {
+        let text = text.into();
+        if text != self.text {
+            self.text = text;
+            self.layout_key = None;
+        }
+    }
+
+    /// Invalidates the layout and returns the underlying string for editing.
+    pub fn edit(&mut self) -> &mut String {
+        self.layout_key = None;
+        &mut self.text
+    }
+
+    pub fn size(&self) -> Vec2 {
+        Vec2::new(self.layout.width(), self.layout.height())
+    }
+
+    pub fn shape(&mut self, data: &mut TextData, attrs: &TextAttrs, width: Option<f32>) {
+        let layout_key = LayoutKey {
+            attrs: attrs.clone(),
+            max_width: width,
+        };
+        if self.layout_key.as_ref() == Some(&layout_key) {
+            return;
+        }
+        let mut builder = data
+            .layout_ctx
+            .ranged_builder(&mut data.font_ctx, &self.text, 1.0, true);
+        builder.push_default(StyleProperty::FontFamily(attrs.family.family()));
+        builder.push_default(StyleProperty::FontSize(attrs.font_size));
+        builder.push_default(StyleProperty::LineHeight(LineHeight::Absolute(
+            attrs.line_height,
+        )));
+        builder.push_default(StyleProperty::Brush(attrs.color));
+        builder.build_into(&mut self.layout, &self.text);
+        self.layout.break_all_lines(width);
+        self.layout
+            .align(Alignment::Start, AlignmentOptions::default());
+        self.layout_key = Some(layout_key);
+    }
+}
 
 impl TextData {
-    pub fn draw(
-        &mut self,
-        buffer: &mut TextBuffer,
-        attrs: &TextAttrs,
-        textures: &mut Textures,
-    ) -> RenderedText {
-        // TODO: either this or the layout stuff (or both) is super slow,
-        // should probably do texture packing and things if possible.
-        // very visible if you add just a couple of wrapping texts and resize window
-        // should also be timed to figure out exactly what points need to be sped up
-        // let mut pixels = HashMap::<_, [u8; 4]>::default();
-        let mut min_x = 0;
-        let mut min_y = 0;
-        let mut max_x = 0;
-        let mut max_y = 0;
-        let text_color = {
-            let c = attrs.color;
-            cosmic_text::Color::rgba(c.r, c.g, c.b, c.a)
-        };
-        let mut max_width = 0.0f32;
-        let mut height = 0.0;
-
-        for run in buffer.layout_runs() {
-            for glyph in run.glyphs.iter() {
-                let physical_glyph = glyph.physical((0., 0.), 1.0);
-
-                let glyph_color = match glyph.color_opt {
-                    Some(some) => some,
-                    None => text_color,
+    pub fn place(&mut self, buffer: &TextBuffer) -> Vec<PlacedGlyph> {
+        let mut placed = Vec::new();
+        for line in buffer.layout.lines() {
+            for item in line.items() {
+                let PositionedLayoutItem::GlyphRun(run) = item else {
+                    continue;
                 };
+                let font = run.run().font();
+                let font_size = run.run().font_size();
+                let coords = run.run().normalized_coords();
+                let Some(font_ref) = FontRef::from_index(font.data.as_ref(), font.index as usize)
+                else {
+                    continue;
+                };
+                let coords_hash = hash_coords(coords);
+                let font_id = font.data.id();
 
-                if let Some(img) = self
-                    .swash_cache
-                    .get_image(&mut self.font_system, physical_glyph.cache_key)
-                {
-                    let mut pos = img.placement;
-                    pos.left += physical_glyph.x;
-                    pos.top = physical_glyph.y + run.line_y as i32 - pos.top;
-                    min_x = min_x.min(pos.left);
-                    min_y = min_y.min(pos.top);
-                    max_x = max_x.max(pos.left + pos.width as i32);
-                    max_y = max_y.max(pos.top + pos.height as i32);
-                    self.glyph_cache
-                        .push((pos, physical_glyph.cache_key, glyph_color));
-                }
-            }
-            max_width = max_width.max(run.line_w);
-            height += run.line_height;
-        }
-        let img_width = (max_x - min_x + 1) as u32;
-        let img_height = (max_y - min_y + 1) as u32;
-        let mut image = RgbaImage::new(img_width, img_height);
-
-        for (pos, key, color) in self.glyph_cache.drain(..) {
-            let img = self
-                .swash_cache
-                .get_image(&mut self.font_system, key)
-                .as_ref()
-                .unwrap();
-            let mut merge = |i, color: [u8; 4]| {
-                let i = i as i32;
-                let x = (i % pos.width as i32 + pos.left - min_x) as u32;
-                let y = (i / pos.width as i32 + pos.top - min_y) as u32;
-                let pixel = &mut image[(x, y)].0;
-                // TODO: no clue if proper alpha blending should be done
-                *pixel = Simd::from(color).saturating_add(Simd::from(*pixel)).into();
-            };
-
-            match img.content {
-                SwashContent::Mask => {
-                    for (i, a) in img.data.iter().enumerate() {
-                        let mut color = color.as_rgba();
-                        color[3] = ((color[3] as u32 * *a as u32) / u8::MAX as u32) as u8;
-                        merge(i, color);
-                    }
-                }
-                SwashContent::SubpixelMask => todo!("subpixel mask text rendering"),
-                SwashContent::Color => {
-                    let (colors, _) = img.data.as_chunks::<4>();
-                    for (i, color) in colors.iter().enumerate() {
-                        merge(i, *color);
-                    }
+                for glyph in run.positioned_glyphs() {
+                    let subpixel = ((glyph.x.fract() * 4.0).round() as i32).rem_euclid(4) as u8;
+                    let key = GlyphKey {
+                        font: font_id,
+                        glyph: glyph.id,
+                        size: glyph_size_key(font_size),
+                        subpixel,
+                        coords: coords_hash,
+                    };
+                    let Some(entry) = self.glyph_entry(GlyphRaster {
+                        key,
+                        font: font_ref,
+                        font_size,
+                        coords,
+                        subpixel,
+                        glyph_id: glyph.id,
+                    }) else {
+                        continue;
+                    };
+                    placed.push(PlacedGlyph {
+                        entry,
+                        offset: Vec2::new(
+                            glyph.x.floor() + entry.left as f32,
+                            glyph.y.floor() - entry.top as f32,
+                        ),
+                    });
                 }
             }
         }
+        placed
+    }
 
-        let max_dim = 8192;
-        if image.width() > max_dim || image.height() > max_dim {
-            let width = image.width().min(max_dim);
-            let height = image.height().min(max_dim);
-            eprintln!(
-                "WARNING: image of size {:?} cropped to {:?} (texture too big)",
-                image.dimensions(),
-                (width, height)
-            );
-            image = image.view(0, 0, width, height).to_image();
+    fn glyph_entry(&mut self, glyph: GlyphRaster<'_>) -> Option<GlyphEntry> {
+        if let Some(entry) = self.atlas.get(&glyph.key) {
+            return entry;
         }
 
-        RenderedText {
-            handle: textures.add(image),
-            top_left_offset: Vec2::new(min_x as f32, min_y as f32),
-            size: Vec2::new(max_width, height),
+        let mut scaler = self
+            .scale_ctx
+            .builder(glyph.font)
+            .size(glyph.font_size)
+            .hint(true)
+            .normalized_coords(glyph.coords)
+            .build();
+        let image = Render::new(&[
+            Source::ColorOutline(0),
+            Source::ColorBitmap(StrikeWith::BestFit),
+            Source::Outline,
+        ])
+        .format(Format::Alpha)
+        .offset(Vector::new(glyph.subpixel as f32 / 4.0, 0.0))
+        .render(&mut scaler, glyph.glyph_id as u16);
+
+        if let Some(image) = image {
+            self.atlas.insert(glyph.key, &image)
+        } else {
+            self.atlas.insert_empty(glyph.key);
+            None
         }
     }
 }
 
-#[derive(Clone)]
-pub struct RenderedText {
-    pub handle: TextureHandle,
-    pub top_left_offset: Vec2,
-    pub size: Vec2,
+struct GlyphRaster<'a> {
+    key: GlyphKey,
+    font: FontRef<'a>,
+    font_size: f32,
+    coords: &'a [i16],
+    subpixel: u8,
+    glyph_id: u32,
 }
 
-pub trait HasTextures {
-    fn add_texture(&mut self, image: DynamicImage) -> TextureHandle;
+fn hash_coords(coords: &[i16]) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    coords.hash(&mut hasher);
+    hasher.finish()
+}
+
+const GLYPH_SIZE_STEPS_PER_PIXEL: f32 = 16.0;
+
+fn glyph_size_key(font_size: f32) -> u32 {
+    (font_size * GLYPH_SIZE_STEPS_PER_PIXEL).round() as u32
+}
+
+pub struct RenderedText {
+    pub glyphs: Vec<PlacedGlyph>,
+    pub size: Vec2,
+    pub color: UiColor,
+}
+
+impl TextData {
+    pub fn render(
+        &mut self,
+        buffer: &mut TextBuffer,
+        attrs: &TextAttrs,
+        width: Option<f32>,
+    ) -> RenderedText {
+        buffer.shape(self, attrs, width);
+        let glyphs = self.place(buffer);
+        RenderedText {
+            glyphs,
+            size: buffer.size(),
+            color: attrs.color,
+        }
+    }
 }

core/src/primitive/texture.rs

@@ -1,7 +1,4 @@
-use crate::{
-    render::TexturePrimitive,
-    util::{RefCounter, Vec2},
-};
+use crate::util::{RefCounter, Vec2};
 use image::{DynamicImage, GenericImageView};
 use std::{
     ops::Index,
@@ -10,7 +7,7 @@ use std::{
 
 #[derive(Debug, Clone)]
 pub struct TextureHandle {
-    inner: TexturePrimitive,
+    slot: u32,
     size: Vec2,
     counter: RefCounter,
     send: Sender<u32>,
@@ -29,14 +26,26 @@ pub struct Textures {
 pub enum TextureUpdate<'a> {
     Push(&'a DynamicImage),
     Set(u32, &'a DynamicImage),
+    Patch(u32, PatchRect, &'a DynamicImage),
     Free(u32),
+    /// Added and freed before the renderer drained either update. It still has
+    /// to push a slot to stay lined up with `images`; `Free` then empties it.
     PushFree,
     SetFree,
 }
 
+#[derive(Debug, Clone, Copy)]
+pub struct PatchRect {
+    pub x: u32,
+    pub y: u32,
+    pub width: u32,
+    pub height: u32,
+}
+
 enum Update {
     Push(u32),
     Set(u32),
+    Patch(u32, PatchRect),
     Free(u32),
 }
 
@@ -54,14 +63,8 @@ impl Textures {
     pub fn add(&mut self, image: impl Into<DynamicImage>) -> TextureHandle {
         let image = image.into();
         let size = image.dimensions().into();
-        let view_idx = self.push(image);
-        // 0 == default in renderer; TODO: actually create samplers here
-        let sampler_idx = 0;
         TextureHandle {
-            inner: TexturePrimitive {
-                view_idx,
-                sampler_idx,
-            },
+            slot: self.push(image),
             size,
             counter: RefCounter::new(),
             send: self.send.clone(),
@@ -81,6 +84,23 @@ impl Textures {
         }
     }
 
+    pub fn image_mut(&mut self, handle: &TextureHandle) -> &mut DynamicImage {
+        self.images[handle.slot as usize]
+            .as_mut()
+            .expect("texture was freed while still held")
+    }
+
+    /// Queue an upload of just `rect`, after writing it with `image_mut`.
+    pub fn patch(&mut self, handle: &TextureHandle, rect: PatchRect) {
+        self.updates.push(Update::Patch(handle.slot, rect));
+    }
+
+    /// How many textures are live, which is what a ui can ask; the renderer's
+    /// copies follow from the updates it drains.
+    pub fn count(&self) -> usize {
+        self.images.iter().flatten().count()
+    }
+
     pub fn free(&mut self) {
         for idx in self.recv.try_iter() {
             self.images[idx as usize] = None;
@@ -99,14 +119,19 @@ impl Textures {
                 .as_ref()
                 .map(|img| TextureUpdate::Set(i, img))
                 .unwrap_or(TextureUpdate::SetFree),
+            Update::Patch(i, rect) => self.images[i as usize]
+                .as_ref()
+                .map(|img| TextureUpdate::Patch(i, rect, img))
+                .unwrap_or(TextureUpdate::SetFree),
             Update::Free(i) => TextureUpdate::Free(i),
         })
     }
 }
 
 impl TextureHandle {
-    pub fn primitive(&self) -> TexturePrimitive {
-        self.inner
+    /// Index into `Textures`, and into the renderer's parallel slots.
+    pub fn slot(&self) -> u32 {
+        self.slot
     }
     pub fn size(&self) -> Vec2 {
         self.size
@@ -116,7 +141,7 @@ impl TextureHandle {
 impl Drop for TextureHandle {
     fn drop(&mut self) {
         if self.counter.drop() {
-            let _ = self.send.send(self.inner.view_idx);
+            let _ = self.send.send(self.slot);
         }
     }
 }
@@ -125,7 +150,7 @@ impl Index<&TextureHandle> for Textures {
     type Output = DynamicImage;
 
     fn index(&self, index: &TextureHandle) -> &Self::Output {
-        self.images[index.inner.view_idx as usize].as_ref().unwrap()
+        self.images[index.slot as usize].as_ref().unwrap()
     }
 }
 

core/src/render/atlas.rs

@@ -0,0 +1,245 @@
+use crate::{
+    PatchRect,
+    util::{HashMap, Vec2},
+};
+use image::RgbaImage;
+use swash::scale::image::{Content, Image};
+
+/// Side of one page, and so of every layer of `render::page`'s array texture.
+pub(crate) const PAGE: u32 = 1024;
+
+/// Transparent margin kept around every glyph, so that sampling one cannot
+/// pick up its neighbour along a shared edge.
+const PAD: u32 = 1;
+
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct GlyphKey {
+    pub font: u64,
+    pub glyph: u32,
+    /// Font size in 1/16 px, so sizes that round to the same pixels share a
+    /// raster instead of filling the atlas with near-duplicates.
+    pub size: u32,
+    /// Horizontal subpixel phase, in 1/4 px.
+    pub subpixel: u8,
+    /// Hash of the variation coordinates; a variable font at two weights is two
+    /// different sets of pixels from one glyph id.
+    pub coords: u64,
+}
+
+#[derive(Clone, Copy)]
+pub struct GlyphEntry {
+    pub uv_min: Vec2,
+    pub uv_max: Vec2,
+    /// Offset from the glyph's pen position to the top-left of its pixels.
+    pub left: i32,
+    pub top: i32,
+    pub width: u32,
+    pub height: u32,
+    pub is_colored: bool,
+    /// Which atlas array layer this glyph is on.
+    pub layer: u32,
+}
+
+impl GlyphEntry {
+    const IS_COLORED: u32 = 1;
+
+    pub(crate) fn flags(&self) -> u32 {
+        if self.is_colored { Self::IS_COLORED } else { 0 }
+    }
+}
+
+struct Page {
+    image: RgbaImage,
+    x: u32,
+    y: u32,
+    shelf_height: u32,
+}
+
+/// A rectangle of one page the renderer has not uploaded yet.
+#[derive(Clone, Copy)]
+pub struct PageUpload {
+    pub layer: u32,
+    pub rect: PatchRect,
+}
+
+#[derive(Default)]
+pub struct GlyphAtlas {
+    pages: Vec<Page>,
+    /// `None` for a glyph that rasterised to nothing -- a space, say. Cached
+    /// too, so it is not re-rasterised on every layout.
+    entries: HashMap<GlyphKey, Option<GlyphEntry>>,
+    uploads: Vec<PageUpload>,
+}
+
+impl GlyphAtlas {
+    pub fn get(&self, key: &GlyphKey) -> Option<Option<GlyphEntry>> {
+        self.entries.get(key).copied()
+    }
+
+    pub fn insert(&mut self, key: GlyphKey, image: &Image) -> Option<GlyphEntry> {
+        let w = image.placement.width;
+        let h = image.placement.height;
+        if w == 0 || h == 0 {
+            log::warn!(
+                "glyph {} in font {} rasterized at {w}x{h}; skipping it",
+                key.glyph,
+                key.font,
+            );
+            self.entries.insert(key, None);
+            return None;
+        }
+        if w > PAGE - PAD * 2 || h > PAGE - PAD * 2 {
+            log::warn!(
+                "glyph {} in font {} rasterized at {w}x{h}, too large for the {PAGE}x{PAGE} atlas; skipping it",
+                key.glyph,
+                key.font,
+            );
+            self.entries.insert(key, None);
+            return None;
+        }
+
+        let upload = self.allocate(w, h);
+        let PatchRect { x, y, .. } = upload.rect;
+        write_glyph(&mut self.pages[upload.layer as usize].image, image, x, y);
+        self.uploads.push(upload);
+
+        let scale = 1.0 / PAGE as f32;
+        let entry = GlyphEntry {
+            uv_min: Vec2::new(x as f32 * scale, y as f32 * scale),
+            uv_max: Vec2::new((x + w) as f32 * scale, (y + h) as f32 * scale),
+            left: image.placement.left,
+            top: image.placement.top,
+            width: w,
+            height: h,
+            is_colored: matches!(image.content, Content::Color),
+            layer: upload.layer,
+        };
+        self.entries.insert(key, Some(entry));
+        Some(entry)
+    }
+
+    /// Reserves room for a `w` by `h` glyph, adding a page if none has it.
+    fn allocate(&mut self, w: u32, h: u32) -> PageUpload {
+        let rect = |x, y| PatchRect {
+            x,
+            y,
+            width: w,
+            height: h,
+        };
+        if let Some((i, (x, y))) = self
+            .pages
+            .iter_mut()
+            .enumerate()
+            .find_map(|(i, page)| page.allocate(w, h).map(|position| (i, position)))
+        {
+            return PageUpload {
+                layer: i as u32,
+                rect: rect(x, y),
+            };
+        }
+
+        self.pages.push(Page {
+            image: RgbaImage::new(PAGE, PAGE),
+            x: PAD + w + PAD,
+            y: PAD,
+            shelf_height: h + PAD,
+        });
+        PageUpload {
+            layer: self.pages.len() as u32 - 1,
+            rect: rect(PAD, PAD),
+        }
+    }
+
+    /// Drains what has been written since the last call, for the renderer to
+    /// upload. A new page needs nothing more: wgpu leaves the rest of a fresh
+    /// layer transparent, which is what an atlas wants.
+    pub fn uploads(&mut self) -> impl Iterator<Item = (PageUpload, &RgbaImage)> {
+        let pages = &self.pages;
+        self.uploads
+            .drain(..)
+            .map(|upload| (upload, &pages[upload.layer as usize].image))
+    }
+
+    pub fn insert_empty(&mut self, key: GlyphKey) {
+        self.entries.insert(key, None);
+    }
+
+    pub fn page_count(&self) -> u32 {
+        self.pages.len() as u32
+    }
+
+    pub fn glyph_count(&self) -> usize {
+        self.entries.len()
+    }
+}
+
+impl Page {
+    fn allocate(&mut self, w: u32, h: u32) -> Option<(u32, u32)> {
+        let need_w = w + PAD;
+        let need_h = h + PAD;
+        if self.x + need_w > PAGE {
+            if need_w + PAD > PAGE || self.y + self.shelf_height + need_h > PAGE {
+                return None;
+            }
+            self.y += self.shelf_height;
+            self.x = PAD;
+            self.shelf_height = 0;
+        } else if self.y + need_h > PAGE {
+            return None;
+        }
+
+        let position = (self.x, self.y);
+        self.x += need_w;
+        self.shelf_height = self.shelf_height.max(need_h);
+        Some(position)
+    }
+}
+
+/// Mask glyphs keep coverage in alpha so their raster can be tinted at draw time.
+fn write_glyph(page: &mut RgbaImage, image: &Image, x: u32, y: u32) {
+    let width = image.placement.width as usize;
+    let height = image.placement.height as usize;
+    let page_stride = page.width() as usize * 4;
+    let x = x as usize * 4;
+    let y = y as usize;
+    let page = page.as_mut();
+
+    for row in 0..height {
+        let start = (y + row) * page_stride + x;
+        let target = &mut page[start..start + width * 4];
+        match image.content {
+            Content::Color => {
+                let start = row * width * 4;
+                target.copy_from_slice(&image.data[start..start + width * 4]);
+            }
+            Content::Mask => {
+                let start = row * width;
+                for (target, &alpha) in target
+                    .as_chunks_mut::<4>()
+                    .0
+                    .iter_mut()
+                    .zip(&image.data[start..start + width])
+                {
+                    target.copy_from_slice(&[255, 255, 255, alpha]);
+                }
+            }
+            Content::SubpixelMask => {
+                let start = row * width * 4;
+                for (target, source) in target
+                    .as_chunks_mut::<4>()
+                    .0
+                    .iter_mut()
+                    .zip(image.data[start..start + width * 4].as_chunks::<4>().0)
+                {
+                    target.copy_from_slice(&[255, 255, 255, source[1]]);
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub struct PlacedGlyph {
+    pub entry: GlyphEntry,
+    pub offset: Vec2,
+}

core/src/render/data.rs

@@ -12,20 +12,16 @@ pub struct WindowUniform {
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct PrimitiveInstance {
     pub region: UiRegion,
-    pub binding: u32,
-    pub idx: u32,
     pub mask_idx: MaskIdx,
 }
 
 impl PrimitiveInstance {
-    const ATTRIBS: [VertexAttribute; 7] = vertex_attr_array![
+    const ATTRIBS: [VertexAttribute; 5] = vertex_attr_array![
         0 => Float32x2,
         1 => Float32x2,
         2 => Float32x2,
         3 => Float32x2,
         4 => Uint32,
-        5 => Uint32,
-        6 => Uint32,
     ];
 
     pub fn desc() -> VertexBufferLayout<'static> {

core/src/render/mod.rs

@@ -1,61 +1,82 @@
-use std::num::NonZero;
-
 use crate::{
     UiData, UiRenderState,
-    render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf},
-    util::HashMap,
+    render::{data::PrimitiveInstance, util::ArrBuf},
+    util::{HashMap, Vec2},
 };
 use data::WindowUniform;
 use wgpu::{
     util::{BufferInitDescriptor, DeviceExt},
     *,
 };
-use winit::dpi::PhysicalSize;
 
+mod atlas;
 mod data;
+mod page;
 mod primitive;
 mod texture;
 mod util;
 
+pub use atlas::*;
 pub use data::{Mask, MaskIdx};
 pub use primitive::*;
 
-const SHAPE_SHADER: &str = include_str!("./shader.wgsl");
+const PRELUDE: &str = include_str!("./shader/prelude.wgsl");
 
 pub struct UiRenderNode {
-    uniform_group: BindGroup,
-    primitive_layout: BindGroupLayout,
-    rsc_layout: BindGroupLayout,
-    rsc_group: BindGroup,
+    shared_layout: BindGroupLayout,
+    shared_group: BindGroup,
+    format: TextureFormat,
 
-    pipeline: RenderPipeline,
+    /// One per registered primitive, in id order.
+    primitives: Vec<PrimitivePipeline>,
 
     layers: HashMap<usize, RenderLayer>,
     active: Vec<usize>,
     window_buffer: Buffer,
-    textures: GpuTextures,
     masks: ArrBuf<Mask>,
 }
 
 struct RenderLayer {
+    /// One per registered primitive, `None` where this layer draws none.
+    primitives: Vec<Option<ListBuffers>>,
+}
+
+/// What draws one registered primitive.
+struct PrimitivePipeline {
+    data_layout: BindGroupLayout,
+    pipeline: RenderPipeline,
+    render: Box<dyn PrimitiveRender>,
+}
+
+/// One list's vertex buffer and the data its shader reads.
+struct ListBuffers {
     instance: ArrBuf<PrimitiveInstance>,
-    primitives: PrimitiveBuffers,
-    primitive_group: BindGroup,
+    data: ArrBuf<u8>,
+    group: Option<BindGroup>,
+    /// What the primitive asked to keep per instance, if anything.
+    bindings: Vec<u32>,
 }
 
 impl UiRenderNode {
     pub fn draw<'a>(&'a self, pass: &mut RenderPass<'a>) {
-        pass.set_pipeline(&self.pipeline);
-        pass.set_bind_group(0, &self.uniform_group, &[]);
-        pass.set_bind_group(2, &self.rsc_group, &[]);
+        pass.set_bind_group(0, &self.shared_group, &[]);
         for i in &self.active {
             let layer = &self.layers[i];
-            if layer.instance.len() == 0 {
-                continue;
+            for (id, list) in layer.primitives.iter().enumerate() {
+                let Some(list) = list else { continue };
+                let Some(group) = &list.group else { continue };
+                let primitive = &self.primitives[id];
+                pass.set_pipeline(&primitive.pipeline);
+                pass.set_bind_group(1, group, &[]);
+                pass.set_vertex_buffer(0, list.instance.buffer.slice(..));
+                primitive.render.draw(
+                    pass,
+                    ListDraw {
+                        instances: list.instance.len() as u32,
+                        bindings: &list.bindings,
+                    },
+                );
             }
-            pass.set_bind_group(1, &layer.primitive_group, &[]);
-            pass.set_vertex_buffer(0, layer.instance.buffer.slice(..));
-            pass.draw(0..4, 0..layer.instance.len() as u32);
         }
     }
 
@@ -66,145 +87,146 @@ impl UiRenderNode {
         ui: &mut UiData,
         ui_render: &mut UiRenderState,
     ) {
+        // Before the layers: each list is given its pipeline's data layout.
+        self.build_pipelines(device, queue, &ui.primitives);
         self.active.clear();
-        for (i, primitives) in ui_render.layers.iter_mut() {
+        for (i, draws) in ui_render.layers.iter_mut() {
             self.active.push(i);
-            for change in primitives.apply_free() {
+            for change in draws.apply_free() {
                 if let Some(inst) = ui_render.active.get_mut(&change.id) {
                     for h in &mut inst.primitives {
-                        if h.layer == i && h.inst_idx == change.old {
+                        if h.layer == i && h.kind == change.kind && h.inst_idx == change.old {
                             h.inst_idx = change.new;
                             break;
                         }
                     }
                 }
             }
-            let rlayer = self.layers.entry(i).or_insert_with(|| {
-                let primitives = PrimitiveBuffers::new(device);
-                let primitive_group =
-                    Self::primitive_group(device, &self.primitive_layout, primitives.buffers());
-                RenderLayer {
-                    instance: ArrBuf::new(
-                        device,
-                        BufferUsages::VERTEX | BufferUsages::COPY_DST,
-                        "instance",
-                    ),
-                    primitives,
-                    primitive_group,
+            let rlayer = self.layers.entry(i).or_insert_with(RenderLayer::new);
+            if draws.updated {
+                let lists = draws.primitives();
+                // The zip would otherwise skip a list with no pipeline.
+                assert!(lists.len() <= self.primitives.len());
+                rlayer.primitives.resize_with(lists.len(), || None);
+                for ((buffers, list), primitive) in rlayer
+                    .primitives
+                    .iter_mut()
+                    .zip(lists)
+                    .zip(&self.primitives)
+                {
+                    let Some(list) = list else {
+                        continue;
+                    };
+                    buffers
+                        .get_or_insert_with(|| ListBuffers::new(device))
+                        .update(device, queue, primitive, list);
                 }
-            });
-            if primitives.updated {
-                rlayer
-                    .instance
-                    .update(device, queue, primitives.instances());
-                rlayer.primitives.update(device, queue, primitives.data());
-                rlayer.primitive_group = Self::primitive_group(
-                    device,
-                    &self.primitive_layout,
-                    rlayer.primitives.buffers(),
-                );
-                primitives.updated = false;
+                draws.updated = false;
             }
         }
-        let mut changed = false;
-        changed |= self.textures.update(&mut ui.textures);
+        for primitive in &mut self.primitives {
+            primitive.render.update(ui);
+        }
         if ui.masks.changed {
             ui.masks.changed = false;
-            self.masks.update(device, queue, &ui.masks[..]);
-            changed = true;
-        }
-        if changed {
-            self.rsc_group = Self::rsc_group(device, &self.rsc_layout, &self.textures, &self.masks);
+            if self.masks.update(device, queue, &ui.masks[..]) {
+                self.shared_group = Self::shared_group(
+                    device,
+                    &self.shared_layout,
+                    &self.window_buffer,
+                    &self.masks,
+                );
+            }
         }
     }
 
-    pub fn resize(&mut self, size: &PhysicalSize<u32>, queue: &Queue) {
+    pub fn resize(&mut self, size: impl Into<Vec2>, queue: &Queue) {
+        let size = size.into();
         let slice = &[WindowUniform {
-            width: size.width as f32,
-            height: size.height as f32,
+            width: size.x,
+            height: size.y,
         }];
         queue.write_buffer(&self.window_buffer, 0, bytemuck::cast_slice(slice));
     }
 
-    pub fn new(
-        device: &Device,
-        queue: &Queue,
-        config: &SurfaceConfiguration,
-        limits: UiLimits,
-    ) -> Self {
-        let shader = device.create_shader_module(ShaderModuleDescriptor {
-            label: Some("UI Shape Shader"),
-            source: ShaderSource::Wgsl(SHAPE_SHADER.into()),
-        });
-
-        let window_uniform = WindowUniform::default();
+    pub fn new(device: &Device, config: &SurfaceConfiguration) -> Self {
+        let window_uniform = WindowUniform {
+            width: config.width as f32,
+            height: config.height as f32,
+        };
         let window_buffer = device.create_buffer_init(&BufferInitDescriptor {
             label: Some("window"),
             contents: bytemuck::cast_slice(&[window_uniform]),
             usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
         });
 
-        let uniform_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &[BindGroupLayoutEntry {
-                binding: 0,
-                visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
-                ty: BindingType::Buffer {
-                    ty: BufferBindingType::Uniform,
-                    has_dynamic_offset: false,
-                    min_binding_size: None,
-                },
-                count: None,
-            }],
-            label: Some("window"),
-        });
-
-        let uniform_group = Self::bind_group_0(device, &uniform_layout, &window_buffer);
-
-        let primitive_layout = device.create_bind_group_layout(&BindGroupLayoutDescriptor {
-            entries: &core::array::from_fn::<_, { PrimitiveBuffers::LEN }, _>(|i| {
-                BindGroupLayoutEntry {
-                    binding: i as u32,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Buffer {
-                        ty: BufferBindingType::Storage { read_only: true },
-                        has_dynamic_offset: false,
-                        min_binding_size: None,
-                    },
-                    count: None,
-                }
-            }),
-            label: Some("primitive"),
-        });
-
-        let tex_manager = GpuTextures::new(device, queue);
+        let shared_layout = Self::shared_layout(device);
         let masks = ArrBuf::new(
             device,
             BufferUsages::STORAGE | BufferUsages::COPY_DST,
             "ui masks",
         );
+        let shared_group = Self::shared_group(device, &shared_layout, &window_buffer, &masks);
 
-        let rsc_layout = Self::rsc_layout(device, &limits);
-        let rsc_group = Self::rsc_group(device, &rsc_layout, &tex_manager, &masks);
+        Self {
+            shared_layout,
+            shared_group,
+            format: config.format,
+            primitives: Vec::new(),
+            window_buffer,
+            layers: HashMap::default(),
+            active: Vec::new(),
+            masks,
+        }
+    }
 
-        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
-            label: Some("UI Shape Pipeline Layout"),
-            bind_group_layouts: &[&uniform_layout, &primitive_layout, &rsc_layout].map(Some),
-            immediate_size: 0,
+    /// Compiles a pipeline for every primitive registered since the last call.
+    /// Sources only ever arrive at the end, so an id keeps its pipeline.
+    fn build_pipelines(&mut self, device: &Device, queue: &Queue, registry: &PrimitiveRegistry) {
+        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 layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
+                label: Some(source.label),
+                bind_group_layouts: &groups,
+                immediate_size: 0,
+            });
+            let pipeline = Self::pipeline(device, &layout, self.format, source.wgsl, source.label);
+            self.primitives.push(PrimitivePipeline {
+                data_layout,
+                pipeline,
+                render,
+            });
+        }
+    }
+
+    fn pipeline(
+        device: &Device,
+        layout: &PipelineLayout,
+        format: TextureFormat,
+        wgsl: &str,
+        label: &str,
+    ) -> RenderPipeline {
+        let module = device.create_shader_module(ShaderModuleDescriptor {
+            label: Some(label),
+            source: ShaderSource::Wgsl(format!("{PRELUDE}\n{wgsl}").into()),
         });
-        let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
-            label: Some("UI Shape Pipeline"),
-            layout: Some(&pipeline_layout),
+        device.create_render_pipeline(&RenderPipelineDescriptor {
+            label: Some(label),
+            layout: Some(layout),
             vertex: VertexState {
-                module: &shader,
+                module: &module,
                 entry_point: Some("vs_main"),
                 buffers: &[Some(PrimitiveInstance::desc())],
                 compilation_options: Default::default(),
             },
             fragment: Some(FragmentState {
-                module: &shader,
+                module: &module,
                 entry_point: Some("fs_main"),
                 targets: &[Some(ColorTargetState {
-                    format: config.format,
+                    format,
                     blend: Some(BlendState::ALPHA_BLENDING),
                     write_mask: ColorWrites::ALL,
                 })],
@@ -227,90 +249,42 @@ impl UiRenderNode {
             },
             multiview_mask: None,
             cache: None,
-        });
-
-        Self {
-            uniform_group,
-            primitive_layout,
-            rsc_layout,
-            rsc_group,
-            pipeline,
-            window_buffer,
-            layers: HashMap::default(),
-            active: Vec::new(),
-            textures: tex_manager,
-            masks,
-        }
-    }
-
-    fn bind_group_0(
-        device: &Device,
-        layout: &BindGroupLayout,
-        window_buffer: &Buffer,
-    ) -> BindGroup {
-        device.create_bind_group(&BindGroupDescriptor {
-            layout,
-            entries: &[BindGroupEntry {
-                binding: 0,
-                resource: window_buffer.as_entire_binding(),
-            }],
-            label: Some("ui window"),
         })
     }
 
-    fn primitive_group(
-        device: &Device,
-        layout: &BindGroupLayout,
-        buffers: [(u32, &Buffer); PrimitiveBuffers::LEN],
-    ) -> BindGroup {
-        device.create_bind_group(&BindGroupDescriptor {
-            layout,
-            entries: &buffers.map(|(binding, buf)| BindGroupEntry {
-                binding,
-                resource: buf.as_entire_binding(),
-            }),
-            label: Some("ui primitives"),
-        })
-    }
-
-    fn rsc_layout(device: &Device, limits: &UiLimits) -> BindGroupLayout {
+    /// What every draw in the ui is given: the window and the masks.
+    fn shared_layout(device: &Device) -> BindGroupLayout {
         device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[
                 BindGroupLayoutEntry {
                     binding: 0,
-                    visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Texture {
-                        sample_type: TextureSampleType::Float { filterable: false },
-                        view_dimension: TextureViewDimension::D2,
-                        multisampled: false,
+                    visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                    ty: BindingType::Buffer {
+                        ty: BufferBindingType::Uniform,
+                        has_dynamic_offset: false,
+                        min_binding_size: BufferSize::new(size_of::<WindowUniform>() as u64),
                     },
-                    count: Some(NonZero::new(limits.max_textures).unwrap()),
+                    count: None,
                 },
                 BindGroupLayoutEntry {
                     binding: 1,
                     visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Sampler(SamplerBindingType::NonFiltering),
-                    count: Some(NonZero::new(limits.max_samplers).unwrap()),
-                },
-                BindGroupLayoutEntry {
-                    binding: 2,
-                    visibility: ShaderStages::FRAGMENT,
                     ty: BindingType::Buffer {
                         ty: BufferBindingType::Storage { read_only: true },
                         has_dynamic_offset: false,
-                        min_binding_size: None,
+                        min_binding_size: BufferSize::new(size_of::<Mask>() as u64),
                     },
                     count: None,
                 },
             ],
-            label: Some("ui rsc"),
+            label: Some("ui shared"),
         })
     }
 
-    fn rsc_group(
+    fn shared_group(
         device: &Device,
         layout: &BindGroupLayout,
-        tex_manager: &GpuTextures,
+        window: &Buffer,
         masks: &ArrBuf<Mask>,
     ) -> BindGroup {
         device.create_bind_group(&BindGroupDescriptor {
@@ -318,45 +292,85 @@ impl UiRenderNode {
             entries: &[
                 BindGroupEntry {
                     binding: 0,
-                    resource: BindingResource::TextureViewArray(&tex_manager.views()),
+                    resource: window.as_entire_binding(),
                 },
                 BindGroupEntry {
                     binding: 1,
-                    resource: BindingResource::SamplerArray(&tex_manager.samplers()),
-                },
-                BindGroupEntry {
-                    binding: 2,
                     resource: masks.buffer.as_entire_binding(),
                 },
             ],
-            label: Some("ui rsc"),
+            label: Some("ui shared"),
         })
     }
 
-    pub fn view_count(&self) -> usize {
-        self.textures.view_count()
+    /// Layout for a list of one primitive's data. Every size in the ui is
+    /// stated, so "is the buffer big enough for one entry?" is answered when
+    /// the bind group is made; a `None` size is wgpu's to check on every draw.
+    fn data_layout(device: &Device, stride: u64) -> BindGroupLayout {
+        device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+            entries: &[BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::FRAGMENT,
+                ty: BindingType::Buffer {
+                    ty: BufferBindingType::Storage { read_only: true },
+                    has_dynamic_offset: false,
+                    min_binding_size: BufferSize::new(stride),
+                },
+                count: None,
+            }],
+            label: Some("ui primitive data"),
+        })
     }
 }
 
-pub struct UiLimits {
-    max_textures: u32,
-    max_samplers: u32,
-}
-
-impl Default for UiLimits {
-    fn default() -> Self {
+impl RenderLayer {
+    fn new() -> Self {
         Self {
-            max_textures: 100000,
-            max_samplers: 1000,
+            primitives: Vec::new(),
         }
     }
 }
 
-impl UiLimits {
-    pub fn max_binding_array_elements_per_shader_stage(&self) -> u32 {
-        self.max_textures + self.max_samplers
+impl ListBuffers {
+    fn new(device: &Device) -> Self {
+        Self {
+            instance: ArrBuf::new(
+                device,
+                BufferUsages::VERTEX | BufferUsages::COPY_DST,
+                "instance",
+            ),
+            data: ArrBuf::new(
+                device,
+                BufferUsages::STORAGE | BufferUsages::COPY_DST,
+                "primitive data",
+            ),
+            group: None,
+            bindings: Vec::new(),
+        }
     }
-    pub fn max_binding_array_sampler_elements_per_shader_stage(&self) -> u32 {
-        self.max_samplers
+
+    fn update(
+        &mut self,
+        device: &Device,
+        queue: &Queue,
+        primitive: &PrimitivePipeline,
+        list: &InstanceList,
+    ) {
+        self.bindings.clear();
+        primitive.render.instance_bindings(list, &mut self.bindings);
+        self.instance.update(device, queue, list.instances());
+        let resized = self.data.update(device, queue, list.data());
+        if list.instances().is_empty() {
+            self.group = None;
+        } else if resized || self.group.is_none() {
+            self.group = Some(device.create_bind_group(&BindGroupDescriptor {
+                layout: &primitive.data_layout,
+                entries: &[BindGroupEntry {
+                    binding: 0,
+                    resource: self.data.buffer.as_entire_binding(),
+                }],
+                label: Some("ui primitive data"),
+            }));
+        }
     }
 }

core/src/render/page.rs

@@ -0,0 +1,156 @@
+use wgpu::*;
+
+use crate::{GlyphAtlas, UiData};
+
+use super::{
+    atlas::PAGE,
+    primitive::{ListDraw, PrimitiveRender},
+    texture::{default_sampler, sampled_group, sampled_layout, write_region},
+};
+
+/// Draws glyphs from the atlas, which it owns: one array texture bound once
+/// for a whole list, since every glyph in it reads the same pages.
+pub struct GlyphRender {
+    pages: GpuPages,
+    layout: BindGroupLayout,
+    sampler: Sampler,
+}
+
+impl GlyphRender {
+    pub fn new(device: &Device, queue: &Queue) -> Self {
+        let layout = sampled_layout(device, TextureViewDimension::D2Array, "ui atlas");
+        let sampler = default_sampler(device);
+        Self {
+            pages: GpuPages::new(device, queue, &layout, &sampler),
+            layout,
+            sampler,
+        }
+    }
+}
+
+impl PrimitiveRender for GlyphRender {
+    fn layout(&self) -> Option<&BindGroupLayout> {
+        Some(&self.layout)
+    }
+
+    fn update(&mut self, ui: &mut UiData) {
+        self.pages
+            .update(&mut ui.text.atlas, &self.layout, &self.sampler);
+    }
+
+    fn draw<'a>(&'a self, pass: &mut RenderPass<'a>, list: ListDraw<'a>) {
+        pass.set_bind_group(2, self.pages.group(), &[]);
+        pass.draw(0..4, 0..list.instances);
+    }
+}
+
+/// The glyph atlas on the GPU: one array texture whose layers are the pages
+/// `GlyphAtlas` packs.
+///
+/// One array rather than a texture per page because a layer index is ordinary
+/// Vulkan 1.0 / GLES sampling, where a `binding_array` would need
+/// `VK_EXT_descriptor_indexing`, which a real share of Android GPUs lack.
+pub struct GpuPages {
+    device: Device,
+    queue: Queue,
+    texture: Texture,
+    group: BindGroup,
+}
+
+impl GpuPages {
+    pub fn new(
+        device: &Device,
+        queue: &Queue,
+        layout: &BindGroupLayout,
+        sampler: &Sampler,
+    ) -> Self {
+        let texture = create_array(device, 1);
+        Self {
+            device: device.clone(),
+            queue: queue.clone(),
+            group: atlas_group(device, layout, &texture, sampler),
+            texture,
+        }
+    }
+
+    pub fn update(&mut self, atlas: &mut GlyphAtlas, layout: &BindGroupLayout, sampler: &Sampler) {
+        if atlas.page_count() > self.texture.depth_or_array_layers() {
+            self.grow(atlas.page_count(), layout, sampler);
+        }
+        for (upload, page) in atlas.uploads() {
+            let dst = TexelCopyTextureInfo {
+                texture: &self.texture,
+                mip_level: 0,
+                origin: Origin3d {
+                    x: upload.rect.x,
+                    y: upload.rect.y,
+                    z: upload.layer,
+                },
+                aspect: TextureAspect::All,
+            };
+            write_region(&self.queue, dst, page, upload.rect);
+        }
+    }
+
+    pub fn group(&self) -> &BindGroup {
+        &self.group
+    }
+
+    /// Doubles until `needed` fits and copies the old layers across GPU side.
+    /// The new texture stales the group, so that is rebuilt here.
+    fn grow(&mut self, needed: u32, layout: &BindGroupLayout, sampler: &Sampler) {
+        let old = self.texture.depth_or_array_layers();
+        let mut layers = old;
+        while layers < needed {
+            layers *= 2;
+        }
+        let texture = create_array(&self.device, layers);
+        let mut encoder = self
+            .device
+            .create_command_encoder(&CommandEncoderDescriptor {
+                label: Some("atlas grow"),
+            });
+        encoder.copy_texture_to_texture(
+            self.texture.as_image_copy(),
+            texture.as_image_copy(),
+            Extent3d {
+                width: PAGE,
+                height: PAGE,
+                depth_or_array_layers: old,
+            },
+        );
+        self.queue.submit(std::iter::once(encoder.finish()));
+        self.group = atlas_group(&self.device, layout, &texture, sampler);
+        self.texture = texture;
+    }
+}
+
+fn atlas_group(
+    device: &Device,
+    layout: &BindGroupLayout,
+    texture: &Texture,
+    sampler: &Sampler,
+) -> BindGroup {
+    let view = texture.create_view(&TextureViewDescriptor {
+        dimension: Some(TextureViewDimension::D2Array),
+        ..Default::default()
+    });
+    sampled_group(device, layout, &view, sampler, "ui atlas")
+}
+
+fn create_array(device: &Device, layers: u32) -> Texture {
+    device.create_texture(&TextureDescriptor {
+        label: Some("glyph atlas"),
+        size: Extent3d {
+            width: PAGE,
+            height: PAGE,
+            depth_or_array_layers: layers,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: TextureDimension::D2,
+        format: TextureFormat::Rgba8Unorm,
+        usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST | TextureUsages::COPY_SRC,
+        view_formats: &[],
+    })
+}

core/src/render/primitive.rs

@@ -1,114 +1,247 @@
-use std::ops::{Deref, DerefMut};
+use std::{any::TypeId, marker::PhantomData};
 
 use crate::{
-    Color, UiRegion, WidgetId,
+    Color, TextureHandle, UiData, UiRegion, WidgetId,
     render::{
-        ArrBuf,
         data::{MaskIdx, PrimitiveInstance},
+        page::GlyphRender,
+        texture::ImageRender,
     },
+    util::{HashMap, Vec2},
 };
 use bytemuck::Pod;
-use wgpu::*;
+use wgpu::{BindGroupLayout, Device, Queue, RenderPass};
 
-pub struct Primitives {
+/// One instance of a primitive, laid out as the struct its shader reads.
+///
+/// The type carries its own shader, so drawing one is all the wiring it needs:
+/// its list, free list, buffers and pipeline follow from being registered.
+pub trait Primitive: Pod + 'static {
+    /// Compiled after `prelude.wgsl`, which states what it declares and what
+    /// it is given.
+    const WGSL: &'static str;
+
+    /// Made once, the first time the renderer sees this primitive. It owns
+    /// whatever the shader samples and records the primitive's own draws; the
+    /// default owns nothing and draws every instance in one call.
+    fn render(device: &Device, queue: &Queue) -> Box<dyn PrimitiveRender>
+    where
+        Self: Sized,
+    {
+        let _ = (device, queue);
+        Box::new(Instanced)
+    }
+}
+
+/// The renderer's half of a primitive: what it samples, what it uploads, and
+/// what draws it records.
+///
+/// Everything a draw shares -- the pipeline, the window and masks, the list's
+/// own data and instance buffer -- is set before this is called. What is left
+/// is what only this primitive knows: its group 2, and how many draws its
+/// instances are.
+pub trait PrimitiveRender {
+    /// The layout its shader reads at group 2. `None` for a primitive whose
+    /// shader samples nothing, whose pipeline then has no group 2 at all.
+    fn layout(&self) -> Option<&BindGroupLayout> {
+        None
+    }
+
+    /// Uploads whatever this primitive owns, once a frame, before any draw.
+    fn update(&mut self, ui: &mut UiData) {
+        let _ = ui;
+    }
+
+    /// Keeps what the primitive needs per instance at draw time, read from
+    /// the list's own data. A primitive that binds nothing per instance --
+    /// most of them -- leaves this empty and draws in one call.
+    fn instance_bindings(&self, list: &InstanceList, out: &mut Vec<u32>) {
+        let _ = (list, out);
+    }
+
+    fn draw<'a>(&'a self, pass: &mut RenderPass<'a>, list: ListDraw<'a>);
+}
+
+/// What a `PrimitiveRender` draws: this list's instances, and whatever
+/// `instance_bindings` kept for them.
+pub struct ListDraw<'a> {
+    pub instances: u32,
+    pub bindings: &'a [u32],
+}
+
+/// The default: nothing sampled, every instance in one call.
+pub struct Instanced;
+
+impl PrimitiveRender for Instanced {
+    fn draw<'a>(&'a self, pass: &mut RenderPass<'a>, list: ListDraw<'a>) {
+        pass.draw(0..4, 0..list.instances);
+    }
+}
+
+/// Which registered primitive an instance is.
+pub struct PrimitiveKind<P> {
+    id: u32,
+    _p: PhantomData<fn(P)>,
+}
+
+impl<P> PrimitiveKind<P> {
+    fn new(id: u32) -> Self {
+        Self {
+            id,
+            _p: PhantomData,
+        }
+    }
+}
+
+impl<P> Clone for PrimitiveKind<P> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<P> Copy for PrimitiveKind<P> {}
+
+/// Every primitive a ui can draw, in the order they were first drawn.
+#[derive(Default)]
+pub struct PrimitiveRegistry {
+    kinds: Vec<PrimitiveSource>,
+    ids: HashMap<TypeId, u32>,
+}
+
+pub struct PrimitiveSource {
+    pub wgsl: &'static str,
+    pub label: &'static str,
+    /// Size of one instance's entry, stated as the data binding's minimum.
+    pub stride: u64,
+    pub render: fn(&Device, &Queue) -> Box<dyn PrimitiveRender>,
+}
+
+impl PrimitiveRegistry {
+    /// Registers `P` if this is the first time it has been drawn.
+    pub fn kind<P: Primitive>(&mut self) -> PrimitiveKind<P> {
+        let Self { kinds, ids } = self;
+        let id = *ids.entry(TypeId::of::<P>()).or_insert_with(|| {
+            kinds.push(PrimitiveSource {
+                wgsl: P::WGSL,
+                label: std::any::type_name::<P>(),
+                stride: size_of::<P>() as u64,
+                render: P::render,
+            });
+            kinds.len() as u32 - 1
+        });
+        PrimitiveKind::new(id)
+    }
+
+    pub fn sources(&self) -> &[PrimitiveSource] {
+        &self.kinds
+    }
+}
+
+/// One registered primitive's instances in one layer. Everything per-instance
+/// rides here, so it stays in step through a `swap_remove`.
+pub struct InstanceList {
     instances: Vec<PrimitiveInstance>,
+    /// The widget each instance belongs to, for renumbering its handles.
     assoc: Vec<WidgetId>,
-    data: PrimitiveData,
     free: Vec<usize>,
+    /// `stride` bytes of the primitive's own data per instance.
+    data: Vec<u8>,
+    /// From the type the list was made for, so a write is never checked.
+    stride: usize,
+}
+
+impl InstanceList {
+    fn new<P: Primitive>() -> Self {
+        Self {
+            instances: Vec::new(),
+            assoc: Vec::new(),
+            free: Vec::new(),
+            data: Vec::new(),
+            stride: size_of::<P>(),
+        }
+    }
+
+    pub fn instances(&self) -> &[PrimitiveInstance] {
+        &self.instances
+    }
+
+    pub fn data(&self) -> &[u8] {
+        &self.data
+    }
+
+    pub fn stride(&self) -> usize {
+        self.stride
+    }
+
+    fn push(&mut self, id: WidgetId, inst: PrimitiveInstance, data: &[u8]) -> usize {
+        if let Some(i) = self.free.pop() {
+            self.instances[i] = inst;
+            self.assoc[i] = id;
+            self.data[i * self.stride..][..self.stride].copy_from_slice(data);
+            i
+        } else {
+            let i = self.instances.len();
+            self.instances.push(inst);
+            self.assoc.push(id);
+            self.data.extend_from_slice(data);
+            i
+        }
+    }
+
+    fn free(&mut self, i: usize) -> MaskIdx {
+        self.free.push(i);
+        self.instances[i].mask_idx
+    }
+
+    fn apply_free(&mut self, kind: u32) -> impl Iterator<Item = PrimitiveChange> {
+        self.free.sort_by(|a, b| b.cmp(a));
+        let instances = &mut self.instances;
+        let assoc = &mut self.assoc;
+        let data = &mut self.data;
+        let stride = self.stride;
+        self.free.drain(..).filter_map(move |i| {
+            instances.swap_remove(i);
+            assoc.swap_remove(i);
+            let last = instances.len();
+            data.copy_within(last * stride..(last + 1) * stride, i * stride);
+            data.truncate(last * stride);
+            if i == last {
+                return None;
+            }
+            let id = assoc[i];
+            Some(PrimitiveChange {
+                id,
+                kind,
+                old: last,
+                new: i,
+            })
+        })
+    }
+}
+
+/// Everything one layer draws, one list per registered primitive.
+pub struct LayerDraws {
+    /// `None` until this layer draws that primitive, because only the write
+    /// knows the type the list is for.
+    primitives: Vec<Option<InstanceList>>,
     pub updated: bool,
 }
 
-impl Default for Primitives {
+impl Default for LayerDraws {
     fn default() -> Self {
         Self {
-            instances: Default::default(),
-            assoc: Default::default(),
-            data: Default::default(),
-            free: Vec::new(),
+            primitives: Vec::new(),
             updated: true,
         }
     }
 }
 
-pub trait Primitive: Pod {
-    const BINDING: u32;
-    fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec<Self>;
-}
-
-macro_rules! primitives {
-    ($($name:ident: $ty:ty => $binding:expr,)*) => {
-        #[derive(Default)]
-        pub struct PrimitiveData {
-            $(pub(crate) $name: PrimitiveVec<$ty>,)*
-        }
-
-        pub struct PrimitiveBuffers {
-            $($name: ArrBuf<$ty>,)*
-        }
-
-        impl PrimitiveBuffers {
-            pub fn update(&mut self, device: &Device, queue: &Queue, data: &PrimitiveData) {
-                $(self.$name.update(device, queue, &data.$name);)*
-            }
-        }
-
-        impl PrimitiveBuffers {
-            pub const LEN: usize = primitives!(@count $($name)*);
-            pub fn buffers(&self) -> [(u32, &Buffer); Self::LEN] {
-                [
-                    $((<$ty>::BINDING, &self.$name.buffer),)*
-                ]
-            }
-            pub fn new(device: &Device) -> Self {
-                Self {
-                    $($name: ArrBuf::new(
-                        device,
-                        BufferUsages::STORAGE | BufferUsages::COPY_DST,
-                        stringify!($name),
-                    ),)*
-                }
-            }
-        }
-
-        impl PrimitiveData {
-            pub fn clear(&mut self) {
-                $(self.$name.clear();)*
-            }
-            pub fn free(&mut self, binding: u32, idx: usize) {
-                match binding {
-                    $(<$ty>::BINDING => self.$name.free(idx),)*
-                    _ => unreachable!()
-                }
-            }
-        }
-
-        $(
-            unsafe impl bytemuck::Pod for $ty {}
-            unsafe impl bytemuck::Zeroable for $ty {}
-            impl Primitive for $ty {
-                const BINDING: u32 = $binding;
-                fn vec(data: &mut PrimitiveData) -> &mut PrimitiveVec<Self> {
-                    &mut data.$name
-                }
-            }
-        )*
-    };
-    (@count $t1:tt $($t:tt)+) => { 1 + primitives!(@count $($t),+) };
-    (@count $t:tt) => { 1 };
-}
-
-pub struct PrimitiveInst<P> {
-    pub id: WidgetId,
-    pub primitive: P,
-    pub region: UiRegion,
-    pub mask_idx: MaskIdx,
-}
-
-impl Primitives {
+impl LayerDraws {
     pub fn write<P: Primitive>(
         &mut self,
         layer: usize,
         PrimitiveInst {
+            kind,
             id,
             primitive,
             region,
@@ -116,65 +249,67 @@ impl Primitives {
         }: PrimitiveInst<P>,
     ) -> PrimitiveHandle {
         self.updated = true;
-        let vec = P::vec(&mut self.data);
-        let i = vec.add(primitive);
-        let inst = PrimitiveInstance {
-            region,
-            idx: i as u32,
-            mask_idx,
-            binding: P::BINDING,
-        };
-        let inst_i = if let Some(i) = self.free.pop() {
-            self.instances[i] = inst;
-            self.assoc[i] = id;
-            i
-        } else {
-            let i = self.instances.len();
-            self.instances.push(inst);
-            self.assoc.push(id);
-            i
-        };
-        PrimitiveHandle::new::<P>(layer, inst_i, i)
+        // Grown on first use rather than sized from the registry, which a
+        // layer cannot see.
+        if self.primitives.len() <= kind.id as usize {
+            self.primitives.resize_with(kind.id as usize + 1, || None);
+        }
+        let inst_idx = self.primitives[kind.id as usize]
+            .get_or_insert_with(InstanceList::new::<P>)
+            .push(
+                id,
+                PrimitiveInstance { region, mask_idx },
+                bytemuck::bytes_of(&primitive),
+            );
+        PrimitiveHandle {
+            layer,
+            kind: kind.id,
+            inst_idx,
+        }
+    }
+
+    pub fn primitives(&self) -> &[Option<InstanceList>] {
+        &self.primitives
     }
 
-    /// returns (old index, new index)
     pub fn apply_free(&mut self) -> impl Iterator<Item = PrimitiveChange> {
-        self.free.sort_by(|a, b| b.cmp(a));
-        self.free.drain(..).filter_map(|i| {
-            self.instances.swap_remove(i);
-            self.assoc.swap_remove(i);
-            if i == self.instances.len() {
-                return None;
-            }
-            let id = self.assoc[i];
-            let old = self.instances.len();
-            Some(PrimitiveChange { id, old, new: i })
-        })
+        self.primitives
+            .iter_mut()
+            .enumerate()
+            .filter_map(|(kind, list)| Some((kind as u32, list.as_mut()?)))
+            .flat_map(|(kind, list)| list.apply_free(kind))
     }
 
     pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx {
         self.updated = true;
-        self.data.free(h.binding, h.data_idx);
-        self.free.push(h.inst_idx);
-        self.instances[h.inst_idx].mask_idx
-    }
-
-    pub fn data(&self) -> &PrimitiveData {
-        &self.data
-    }
-
-    pub fn instances(&self) -> &Vec<PrimitiveInstance> {
-        &self.instances
+        self.list(h).free(h.inst_idx)
     }
 
     pub fn region_mut(&mut self, h: &PrimitiveHandle) -> &mut UiRegion {
         self.updated = true;
-        &mut self.instances[h.inst_idx].region
+        &mut self.list(h).instances[h.inst_idx].region
     }
+
+    /// A handle is only ever made by `write`, which is what created the list.
+    fn list(&mut self, h: &PrimitiveHandle) -> &mut InstanceList {
+        self.primitives[h.kind as usize]
+            .as_mut()
+            .expect("handle names a primitive this layer never drew")
+    }
+}
+
+pub struct PrimitiveInst<P> {
+    pub kind: PrimitiveKind<P>,
+    pub id: WidgetId,
+    pub primitive: P,
+    pub region: UiRegion,
+    pub mask_idx: MaskIdx,
 }
 
 pub struct PrimitiveChange {
     pub id: WidgetId,
+    /// Which registered primitive's list moved, since they index separately.
+    pub kind: u32,
     pub old: usize,
     pub new: usize,
 }
@@ -182,29 +317,12 @@ pub struct PrimitiveChange {
 #[derive(Debug)]
 pub struct PrimitiveHandle {
     pub layer: usize,
+    pub kind: u32,
     pub inst_idx: usize,
-    pub data_idx: usize,
-    pub binding: u32,
 }
 
-impl PrimitiveHandle {
-    fn new<P: Primitive>(layer: usize, inst_idx: usize, data_idx: usize) -> Self {
-        Self {
-            layer,
-            inst_idx,
-            data_idx,
-            binding: P::BINDING,
-        }
-    }
-}
-
-primitives!(
-    rects: RectPrimitive => 0,
-    textures: TexturePrimitive => 1,
-);
-
 #[repr(C)]
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct RectPrimitive {
     pub color: Color<u8>,
     pub radius: f32,
@@ -212,6 +330,10 @@ pub struct RectPrimitive {
     pub inner_radius: f32,
 }
 
+impl Primitive for RectPrimitive {
+    const WGSL: &'static str = include_str!("shader/rect.wgsl");
+}
+
 impl RectPrimitive {
     pub fn color(color: Color<u8>) -> Self {
         Self {
@@ -223,60 +345,51 @@ impl RectPrimitive {
     }
 }
 
-#[repr(C)]
+/// `color` is multiplied by the atlas alpha for a mask glyph; a colour glyph
+/// takes the texel unchanged, which `GlyphEntry::IS_COLORED` selects.
+#[repr(C, align(8))]
 #[derive(Debug, Copy, Clone)]
+pub struct GlyphPrimitive {
+    pub uv_min: Vec2,
+    pub uv_max: Vec2,
+    /// Which atlas array layer this glyph is on.
+    pub layer: u32,
+    pub color: Color<u8>,
+    pub flags: u32,
+}
+
+// Manual rather than derived: the align(8) leaves four bytes of padding, which
+// is how WGSL lays the struct out.
+unsafe impl bytemuck::Pod for GlyphPrimitive {}
+unsafe impl bytemuck::Zeroable for GlyphPrimitive {}
+impl Primitive for GlyphPrimitive {
+    const WGSL: &'static str = include_str!("shader/glyph.wgsl");
+
+    fn render(device: &Device, queue: &Queue) -> Box<dyn PrimitiveRender> {
+        Box::new(GlyphRender::new(device, queue))
+    }
+}
+
+/// One drawn image. Its shader reads nothing per instance; the slot names the
+/// texture to bind for it.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct TexturePrimitive {
-    pub view_idx: u32,
-    pub sampler_idx: u32,
+    pub slot: u32,
 }
 
-pub struct PrimitiveVec<T> {
-    vec: Vec<T>,
-    free: Vec<usize>,
+impl Primitive for TexturePrimitive {
+    const WGSL: &'static str = include_str!("shader/texture.wgsl");
+
+    fn render(device: &Device, queue: &Queue) -> Box<dyn PrimitiveRender> {
+        Box::new(ImageRender::new(device, queue))
+    }
 }
 
-impl<T> PrimitiveVec<T> {
-    pub fn new() -> Self {
+impl From<&TextureHandle> for TexturePrimitive {
+    fn from(handle: &TextureHandle) -> Self {
         Self {
-            vec: Vec::new(),
-            free: Vec::new(),
+            slot: handle.slot(),
         }
     }
-    pub fn add(&mut self, t: T) -> usize {
-        if let Some(i) = self.free.pop() {
-            self.vec[i] = t;
-            i
-        } else {
-            let i = self.vec.len();
-            self.vec.push(t);
-            i
-        }
-    }
-    pub fn free(&mut self, i: usize) {
-        self.free.push(i);
-    }
-    pub fn clear(&mut self) {
-        self.free.clear();
-        self.vec.clear();
-    }
-}
-
-impl<T> Default for PrimitiveVec<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<T> Deref for PrimitiveVec<T> {
-    type Target = Vec<T>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.vec
-    }
-}
-
-impl<T> DerefMut for PrimitiveVec<T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.vec
-    }
 }

core/src/render/shader.wgsl

@@ -1,180 +0,0 @@
-enable wgpu_binding_array;
-
-const RECT: u32 = 0u;
-const TEXTURE: u32 = 1u;
-
-@group(0) @binding(0)
-var<uniform> window: WindowUniform;
-@group(1) @binding(RECT)
-var<storage> rects: array<Rect>;
-@group(1) @binding(TEXTURE)
-var<storage> textures: array<TextureInfo>;
-
-struct Rect {
-    color: u32,
-    radius: f32,
-    thickness: f32,
-    inner_radius: f32,
-}
-
-struct TextureInfo {
-    view_idx: u32,
-    sampler_idx: u32,
-}
-
-struct Mask {
-    x: UiSpan,
-    y: UiSpan,
-}
-
-struct UiSpan {
-    start: UiScalar,
-    end: UiScalar,
-}
-
-struct UiScalar {
-    rel: f32,
-    abs: f32,
-}
-
-struct UiVec2 {
-    rel: vec2<f32>,
-    abs: vec2<f32>,
-}
-
-@group(2) @binding(0)
-var views: binding_array<texture_2d<f32>>;
-@group(2) @binding(1)
-var samplers: binding_array<sampler>;
-@group(2) @binding(2)
-var<storage> masks: array<Mask>;
-
-struct WindowUniform {
-    dim: vec2<f32>,
-};
-
-struct InstanceInput {
-    @location(0) x_start: vec2<f32>,
-    @location(1) x_end: vec2<f32>,
-    @location(2) y_start: vec2<f32>,
-    @location(3) y_end: vec2<f32>,
-    @location(4) binding: u32,
-    @location(5) idx: u32,
-    @location(6) mask_idx: u32,
-}
-
-struct VertexOutput {
-    @location(0) top_left: vec2<f32>,
-    @location(1) bot_right: vec2<f32>,
-    @location(2) uv: vec2<f32>,
-    @location(3) @interpolate(flat) binding: u32,
-    @location(4) @interpolate(flat) idx: u32,
-    @location(5) @interpolate(flat) mask_idx: u32,
-    @builtin(position) clip_position: vec4<f32>,
-};
-
-struct Region {
-    pos: vec2<f32>,
-    uv: vec2<f32>,
-    top_left: vec2<f32>,
-    bot_right: vec2<f32>,
-}
-
-@vertex
-fn vs_main(
-    @builtin(vertex_index) vi: u32,
-    in: InstanceInput,
-) -> VertexOutput {
-    var out: VertexOutput;
-
-    let top_left_rel = vec2(in.x_start.x, in.y_start.x);
-    let top_left_abs = vec2(in.x_start.y, in.y_start.y);
-    let bot_right_rel = vec2(in.x_end.x, in.y_end.x);
-    let bot_right_abs = vec2(in.x_end.y, in.y_end.y);
-
-    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs);
-    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs);
-    let size = bot_right - top_left;
-
-    let uv = vec2<f32>(
-        f32(vi % 2u),
-        f32(vi / 2u)
-    );
-    let pos = (top_left + uv * size) / window.dim * 2.0 - 1.0;
-    out.clip_position = vec4<f32>(pos.x, -pos.y, 0.0, 1.0);
-    out.uv = uv;
-    out.binding = in.binding;
-    out.idx = in.idx;
-    out.top_left = top_left;
-    out.bot_right = bot_right;
-    out.mask_idx = in.mask_idx;
-
-    return out;
-}
-
-@fragment
-fn fs_main(
-    in: VertexOutput
-) -> @location(0) vec4<f32> {
-    let pos = in.clip_position.xy;
-    let region = Region(pos, in.uv, in.top_left, in.bot_right);
-    let i = in.idx;
-    var color: vec4<f32>;
-    switch in.binding {
-        case RECT: {
-            color = draw_rounded_rect(region, rects[i]);
-        }
-        case TEXTURE: {
-            color = draw_texture(region, textures[i]);
-        }
-        default: {
-            color = vec4(1.0, 0.0, 1.0, 1.0);
-        }
-    }
-    if in.mask_idx != 4294967295u {
-        let mask = masks[in.mask_idx];
-        let tl = UiVec2(vec2(mask.x.start.rel, mask.y.start.rel), vec2(mask.x.start.abs, mask.y.start.abs));
-        let br = UiVec2(vec2(mask.x.end.rel, mask.y.end.rel), vec2(mask.x.end.abs, mask.y.end.abs));
-
-        let top_left = floor(tl.rel * window.dim) + floor(tl.abs);
-        let bot_right = floor(br.rel * window.dim) + floor(br.abs);
-        if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y {
-            color *= 0.0;
-        }
-    }
-    return color;
-}
-
-// TODO: this seems really inefficient (per frag indexing)?
-fn draw_texture(region: Region, info: TextureInfo) -> vec4<f32> {
-    return textureSample(views[info.view_idx], samplers[info.sampler_idx], region.uv);
-}
-
-fn draw_rounded_rect(region: Region, rect: Rect) -> vec4<f32> {
-    var color = unpack4x8unorm(rect.color);
-
-    let edge = 0.5;
-
-    let size = region.bot_right - region.top_left;
-    let corner = size / 2.0;
-    let center = region.top_left + corner;
-
-    let dist = distance_from_rect(region.pos, center, corner, rect.radius);
-    color.a *= 1.0 - smoothstep(-min(edge, rect.radius), edge, dist);
-
-    if rect.thickness > 0.0 {
-        let dist2 = distance_from_rect(region.pos, center, corner - rect.thickness, rect.inner_radius);
-        color.a *= smoothstep(-min(edge, rect.inner_radius), edge, dist2);
-    }
-
-    return color;
-}
-
-fn distance_from_rect(pixel_pos: vec2<f32>, rect_center: vec2<f32>, rect_corner: vec2<f32>, radius: f32) -> f32 {
-    // vec from center to pixel
-    let p = pixel_pos - rect_center;
-    // vec from inner rect corner to pixel
-    let q = abs(p) - (rect_corner - radius);
-    return length(max(q, vec2(0.0))) - radius;
-}
-

core/src/render/shader/glyph.wgsl

@@ -0,0 +1,33 @@
+// Matches `GlyphEntry::IS_COLORED`.
+const COLORED: u32 = 1u;
+
+// The glyph atlas, whose array layers are its pages.
+@group(2) @binding(0)
+var atlas: texture_2d_array<f32>;
+@group(2) @binding(1)
+var samp: sampler;
+
+struct GlyphInfo {
+    uv_min: vec2<f32>,
+    uv_max: vec2<f32>,
+    // Which layer of the atlas array this glyph's page is.
+    layer: u32,
+    color: u32,
+    flags: u32,
+}
+
+@group(1) @binding(0)
+var<storage> glyphs: array<GlyphInfo>;
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    let g = glyphs[in.idx];
+    let uv = mix(g.uv_min, g.uv_max, in.uv);
+    let texel = textureSample(atlas, samp, uv, i32(g.layer));
+    if (g.flags & COLORED) != 0u {
+        return masked(in, texel);
+    }
+    var color = unpack4x8unorm(g.color);
+    color.a *= texel.a;
+    return masked(in, color);
+}

core/src/render/shader/prelude.wgsl

@@ -0,0 +1,96 @@
+// Prepended to every primitive's shader, which declares its own instance data
+// as `var<storage> <name>: array<T>` at group 1 binding 0, and an `fs_main`
+// shading one instance of it. What it samples, if anything, is bound at group
+// 2: the texture at binding 0 and the sampler at binding 1.
+
+@group(0) @binding(0)
+var<uniform> window: WindowUniform;
+@group(0) @binding(1)
+var<storage> masks: array<Mask>;
+
+struct WindowUniform {
+    dim: vec2<f32>,
+};
+
+struct Mask {
+    x: UiSpan,
+    y: UiSpan,
+}
+
+struct UiSpan {
+    start: UiScalar,
+    end: UiScalar,
+}
+
+struct UiScalar {
+    rel: f32,
+    abs: f32,
+}
+
+struct InstanceInput {
+    @location(0) x_start: vec2<f32>,
+    @location(1) x_end: vec2<f32>,
+    @location(2) y_start: vec2<f32>,
+    @location(3) y_end: vec2<f32>,
+    @location(4) mask_idx: u32,
+}
+
+struct VertexOutput {
+    @location(0) top_left: vec2<f32>,
+    @location(1) bot_right: vec2<f32>,
+    @location(2) uv: vec2<f32>,
+    @location(3) @interpolate(flat) mask_idx: u32,
+    @location(4) @interpolate(flat) idx: u32,
+    @builtin(position) clip_position: vec4<f32>,
+};
+
+@vertex
+fn vs_main(
+    @builtin(vertex_index) vi: u32,
+    @builtin(instance_index) ii: u32,
+    in: InstanceInput,
+) -> VertexOutput {
+    var out: VertexOutput;
+
+    let top_left_rel = vec2(in.x_start.x, in.y_start.x);
+    let top_left_abs = vec2(in.x_start.y, in.y_start.y);
+    let bot_right_rel = vec2(in.x_end.x, in.y_end.x);
+    let bot_right_abs = vec2(in.x_end.y, in.y_end.y);
+
+    let top_left = floor(top_left_rel * window.dim) + floor(top_left_abs);
+    let bot_right = floor(bot_right_rel * window.dim) + floor(bot_right_abs);
+    let size = bot_right - top_left;
+
+    let uv = vec2<f32>(
+        f32(vi % 2u),
+        f32(vi / 2u)
+    );
+    let pos = (top_left + uv * size) / window.dim * 2.0 - 1.0;
+    out.clip_position = vec4<f32>(pos.x, -pos.y, 0.0, 1.0);
+    out.uv = uv;
+    out.top_left = top_left;
+    out.bot_right = bot_right;
+    out.mask_idx = in.mask_idx;
+    out.idx = ii;
+
+    return out;
+}
+
+fn masked(in: VertexOutput, color: vec4<f32>) -> vec4<f32> {
+    if in.mask_idx == 4294967295u {
+        return color;
+    }
+    let mask = masks[in.mask_idx];
+    let tl = vec2(mask.x.start.rel, mask.y.start.rel);
+    let tl_abs = vec2(mask.x.start.abs, mask.y.start.abs);
+    let br = vec2(mask.x.end.rel, mask.y.end.rel);
+    let br_abs = vec2(mask.x.end.abs, mask.y.end.abs);
+
+    let top_left = floor(tl * window.dim) + floor(tl_abs);
+    let bot_right = floor(br * window.dim) + floor(br_abs);
+    let pos = in.clip_position.xy;
+    if pos.x < top_left.x || pos.x > bot_right.x || pos.y < top_left.y || pos.y > bot_right.y {
+        return color * 0.0;
+    }
+    return color;
+}

core/src/render/shader/rect.wgsl

@@ -0,0 +1,39 @@
+struct Rect {
+    color: u32,
+    radius: f32,
+    thickness: f32,
+    inner_radius: f32,
+}
+
+@group(1) @binding(0)
+var<storage> rects: array<Rect>;
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    let rect = rects[in.idx];
+    var color = unpack4x8unorm(rect.color);
+
+    let edge = 0.5;
+    let size = in.bot_right - in.top_left;
+    let corner = size / 2.0;
+    let center = in.top_left + corner;
+    let pos = in.clip_position.xy;
+
+    let dist = distance_from_rect(pos, center, corner, rect.radius);
+    color.a *= 1.0 - smoothstep(-min(edge, rect.radius), edge, dist);
+
+    if rect.thickness > 0.0 {
+        let dist2 = distance_from_rect(pos, center, corner - rect.thickness, rect.inner_radius);
+        color.a *= smoothstep(-min(edge, rect.inner_radius), edge, dist2);
+    }
+
+    return masked(in, color);
+}
+
+fn distance_from_rect(pixel_pos: vec2<f32>, rect_center: vec2<f32>, rect_corner: vec2<f32>, radius: f32) -> f32 {
+    // vec from center to pixel
+    let p = pixel_pos - rect_center;
+    // vec from inner rect corner to pixel
+    let q = abs(p) - (rect_corner - radius);
+    return length(max(q, vec2(0.0))) - radius;
+}

core/src/render/shader/texture.wgsl

@@ -0,0 +1,10 @@
+// The image this instance draws, bound for it alone.
+@group(2) @binding(0)
+var image: texture_2d<f32>;
+@group(2) @binding(1)
+var samp: sampler;
+
+@fragment
+fn fs_main(in: VertexOutput) -> @location(0) vec4<f32> {
+    return masked(in, textureSample(image, samp, in.uv));
+}

core/src/render/texture.rs

@@ -1,59 +1,119 @@
-use image::{DynamicImage, EncodableLayout};
+use image::{DynamicImage, EncodableLayout, GenericImageView, RgbaImage};
 use wgpu::{util::DeviceExt, *};
 
-use crate::{TextureUpdate, Textures};
+use crate::{
+    PatchRect, TextureUpdate, Textures, UiData,
+    render::{
+        TexturePrimitive,
+        primitive::{ListDraw, PrimitiveRender},
+    },
+};
 
+/// Draws standalone images, which it owns. Each is its own texture, so each
+/// instance binds its own and is a draw of its own.
+pub struct ImageRender {
+    textures: GpuTextures,
+    layout: BindGroupLayout,
+    sampler: Sampler,
+}
+
+impl ImageRender {
+    pub fn new(device: &Device, queue: &Queue) -> Self {
+        Self {
+            textures: GpuTextures::new(device, queue),
+            layout: sampled_layout(device, TextureViewDimension::D2, "ui image"),
+            sampler: default_sampler(device),
+        }
+    }
+}
+
+impl PrimitiveRender for ImageRender {
+    fn layout(&self) -> Option<&BindGroupLayout> {
+        Some(&self.layout)
+    }
+
+    fn update(&mut self, ui: &mut UiData) {
+        self.textures
+            .update(&mut ui.textures, &self.layout, &self.sampler);
+    }
+
+    fn instance_bindings(&self, list: &super::InstanceList, out: &mut Vec<u32>) {
+        let slots = list
+            .data()
+            .chunks_exact(list.stride())
+            .map(|data| bytemuck::pod_read_unaligned::<TexturePrimitive>(data).slot);
+        out.extend(slots);
+    }
+
+    fn draw<'a>(&'a self, pass: &mut RenderPass<'a>, list: ListDraw<'a>) {
+        for (i, &slot) in list.bindings.iter().enumerate() {
+            let Some(image) = self.textures.group(slot) else {
+                continue;
+            };
+            pass.set_bind_group(2, image, &[]);
+            pass.draw(0..4, i as u32..i as u32 + 1);
+        }
+    }
+}
+
+/// The standalone images a ui draws, each its own texture and bind group --
+/// unlike the glyph atlas in `super::page`, which is one array they share.
 pub struct GpuTextures {
     device: Device,
     queue: Queue,
-    views: Vec<TextureView>,
-    view_count: usize,
-    samplers: Vec<Sampler>,
-    null_view: TextureView,
-    no_views: Vec<TextureView>,
+    slots: Vec<Option<ImageGpu>>,
+}
+
+struct ImageGpu {
+    /// Kept for `patch`, which needs the texture rather than the view.
+    texture: Texture,
+    group: BindGroup,
 }
 
 impl GpuTextures {
-    pub fn update(&mut self, textures: &mut Textures) -> bool {
-        let mut changed = false;
-        for update in textures.updates() {
-            changed = true;
-            match update {
-                TextureUpdate::Push(image) => self.push(image),
-                TextureUpdate::Set(i, image) => self.set(i, image),
-                TextureUpdate::SetFree => self.view_count += 1,
-                TextureUpdate::Free(i) => self.free(i),
-                TextureUpdate::PushFree => self.push_free(),
-            }
+    pub fn new(device: &Device, queue: &Queue) -> Self {
+        Self {
+            device: device.clone(),
+            queue: queue.clone(),
+            slots: Vec::new(),
         }
-        changed
-    }
-    fn set(&mut self, i: u32, image: &DynamicImage) {
-        self.view_count += 1;
-        let view = self.create_view(image);
-        self.views[i as usize] = view;
-    }
-    fn free(&mut self, i: u32) {
-        self.view_count -= 1;
-        self.views[i as usize] = self.null_view.clone();
-    }
-    fn push(&mut self, image: &DynamicImage) {
-        self.view_count += 1;
-        let view = self.create_view(image);
-        self.views.push(view);
-    }
-    fn push_free(&mut self) {
-        self.view_count += 1;
-        self.views.push(self.null_view.clone());
     }
 
-    fn create_view(&self, image: &DynamicImage) -> TextureView {
-        let image = image.to_rgba8();
-        let (width, height) = image.dimensions();
+    pub fn update(&mut self, textures: &mut Textures, layout: &BindGroupLayout, sampler: &Sampler) {
+        for update in textures.updates() {
+            match update {
+                TextureUpdate::Push(image) => {
+                    let image = self.create(image, layout, sampler);
+                    self.slots.push(Some(image));
+                }
+                TextureUpdate::Set(i, image) => {
+                    let image = self.create(image, layout, sampler);
+                    self.slots[i as usize] = Some(image);
+                }
+                TextureUpdate::Patch(i, rect, image) => self.patch(i, rect, image),
+                TextureUpdate::PushFree => self.slots.push(None),
+                TextureUpdate::SetFree => {}
+                TextureUpdate::Free(i) => self.slots[i as usize] = None,
+            }
+        }
+    }
+
+    pub fn group(&self, slot: u32) -> Option<&BindGroup> {
+        self.slots.get(slot as usize)?.as_ref().map(|i| &i.group)
+    }
+
+    fn create(
+        &self,
+        image: &DynamicImage,
+        layout: &BindGroupLayout,
+        sampler: &Sampler,
+    ) -> ImageGpu {
+        let rgba = image.to_rgba8();
+        let (width, height) = rgba.dimensions();
         let texture = self.device.create_texture_with_data(
             &self.queue,
             &TextureDescriptor {
-                label: None,
+                label: Some("image"),
                 size: Extent3d {
                     width,
                     height,
@@ -63,65 +123,119 @@ impl GpuTextures {
                 sample_count: 1,
                 dimension: TextureDimension::D2,
                 format: TextureFormat::Rgba8Unorm,
-                usage: TextureUsages::TEXTURE_BINDING,
+                usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
                 view_formats: &[],
             },
             wgt::TextureDataOrder::MipMajor,
-            image.as_bytes(),
+            rgba.as_bytes(),
         );
-        texture.create_view(&TextureViewDescriptor::default())
+        let view = texture.create_view(&TextureViewDescriptor::default());
+        let group = sampled_group(&self.device, layout, &view, sampler, "ui image");
+        ImageGpu { texture, group }
     }
 
-    pub fn new(device: &Device, queue: &Queue) -> Self {
-        let null_view = null_texture_view(device);
-        Self {
-            device: device.clone(),
-            queue: queue.clone(),
-            views: Vec::new(),
-            samplers: vec![default_sampler(device)],
-            no_views: vec![null_view.clone()],
-            null_view,
-            view_count: 0,
+    fn patch(&mut self, i: u32, rect: PatchRect, image: &DynamicImage) {
+        let Some(Some(slot)) = self.slots.get(i as usize) else {
+            return;
+        };
+        let dst = TexelCopyTextureInfo {
+            texture: &slot.texture,
+            mip_level: 0,
+            origin: Origin3d {
+                x: rect.x,
+                y: rect.y,
+                z: 0,
+            },
+            aspect: TextureAspect::All,
+        };
+        match image.as_rgba8() {
+            Some(rgba) => write_region(&self.queue, dst, rgba, rect),
+            // The texture is rgba8, so any other layout has to be converted --
+            // and converting the rectangle is cheaper than the whole image.
+            None => {
+                let sub = image
+                    .view(rect.x, rect.y, rect.width, rect.height)
+                    .to_image();
+                write_region(&self.queue, dst, &sub, PatchRect { x: 0, y: 0, ..rect });
+            }
         }
     }
-
-    pub fn views(&self) -> Vec<&TextureView> {
-        if self.views.is_empty() {
-            &self.no_views
-        } else {
-            &self.views
-        }
-        .iter()
-        .by_ref()
-        .collect()
-    }
-
-    pub fn samplers(&self) -> Vec<&Sampler> {
-        self.samplers.iter().by_ref().collect()
-    }
-
-    pub fn view_count(&self) -> usize {
-        self.view_count
-    }
 }
 
-pub fn null_texture_view(device: &Device) -> TextureView {
-    device
-        .create_texture(&TextureDescriptor {
-            label: Some("null"),
-            size: Extent3d {
-                width: 1,
-                height: 1,
-                depth_or_array_layers: 1,
+pub fn write_region(queue: &Queue, dst: TexelCopyTextureInfo, src: &RgbaImage, rect: PatchRect) {
+    if rect.width == 0 || rect.height == 0 {
+        return;
+    }
+    let stride = src.width() * 4;
+    queue.write_texture(
+        dst,
+        src.as_bytes(),
+        TexelCopyBufferLayout {
+            offset: (rect.y * stride + rect.x * 4) as u64,
+            bytes_per_row: Some(stride),
+            rows_per_image: Some(rect.height),
+        },
+        Extent3d {
+            width: rect.width,
+            height: rect.height,
+            depth_or_array_layers: 1,
+        },
+    );
+}
+
+/// What a primitive that samples binds: a texture, and the sampler that reads
+/// it.
+pub fn sampled_group(
+    device: &Device,
+    layout: &BindGroupLayout,
+    view: &TextureView,
+    sampler: &Sampler,
+    label: &'static str,
+) -> BindGroup {
+    device.create_bind_group(&BindGroupDescriptor {
+        layout,
+        entries: &[
+            BindGroupEntry {
+                binding: 0,
+                resource: BindingResource::TextureView(view),
             },
-            mip_level_count: 1,
-            sample_count: 1,
-            dimension: TextureDimension::D2,
-            format: TextureFormat::Rgba8Unorm,
-            usage: TextureUsages::TEXTURE_BINDING,
-            view_formats: &[],
-        })
-        .create_view(&TextureViewDescriptor::default())
+            BindGroupEntry {
+                binding: 1,
+                resource: BindingResource::Sampler(sampler),
+            },
+        ],
+        label: Some(label),
+    })
+}
+
+/// The layout for one of those. The dimension differs -- the atlas is an
+/// array of pages and an image is not -- and nothing else does.
+pub fn sampled_layout(
+    device: &Device,
+    dimension: TextureViewDimension,
+    label: &'static str,
+) -> BindGroupLayout {
+    device.create_bind_group_layout(&BindGroupLayoutDescriptor {
+        entries: &[
+            BindGroupLayoutEntry {
+                binding: 0,
+                visibility: ShaderStages::FRAGMENT,
+                ty: BindingType::Texture {
+                    sample_type: TextureSampleType::Float { filterable: false },
+                    view_dimension: dimension,
+                    multisampled: false,
+                },
+                count: None,
+            },
+            BindGroupLayoutEntry {
+                binding: 1,
+                visibility: ShaderStages::FRAGMENT,
+                ty: BindingType::Sampler(SamplerBindingType::NonFiltering),
+                count: None,
+            },
+        ],
+        label: Some(label),
+    })
 }
 
 pub fn default_sampler(device: &Device) -> Sampler {

core/src/render/util/mod.rs

@@ -21,17 +21,25 @@ impl<T: Pod> ArrBuf<T> {
             _pd: PhantomData,
         }
     }
-    pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) {
-        if self.len != data.len() {
+    /// Returns whether the `Buffer` was recreated, which stales any cached
+    /// `BindGroup` holding it.
+    pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) -> bool {
+        let resized = self.len != data.len();
+        if resized {
             self.len = data.len();
             self.buffer =
                 Self::init_buf(device, std::mem::size_of_val(data), self.usage, self.label);
         }
         queue.write_buffer(&self.buffer, 0, bytemuck::cast_slice(data));
+        resized
+    }
+    pub fn len(&self) -> usize {
+        self.len
     }
     fn init_buf(device: &Device, size: usize, usage: BufferUsages, label: &'static str) -> Buffer {
         let mut size = size as u64;
         if usage.contains(BufferUsages::STORAGE) {
+            // A binding cannot be empty or under the layout's minimum.
             size = size.max(std::mem::size_of::<T>() as u64);
         }
         device.create_buffer(&BufferDescriptor {
@@ -41,8 +49,4 @@ impl<T: Pod> ArrBuf<T> {
             usage,
         })
     }
-    #[allow(clippy::len_without_is_empty)]
-    pub fn len(&self) -> usize {
-        self.len
-    }
 }

core/src/ui/active.rs

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

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

core/src/ui/mod.rs

@@ -1,19 +1,20 @@
-use crate::{Mask, TextData, Textures, WeakWidget, WidgetId, Widgets, util::TrackedArena};
+use crate::{
+    Mask, PrimitiveRegistry, TextData, Textures, WeakWidget, WidgetId, Widgets, util::TrackedArena,
+};
 
 mod active;
-mod cache;
 mod painter;
 mod render_state;
-mod size;
 
 pub use active::*;
-pub use painter::Painter;
+pub use painter::{Painter, PrimitiveLike};
 pub use render_state::*;
-pub use size::*;
 
 #[derive(Default)]
 pub struct UiData {
     pub widgets: Widgets,
+    /// Every primitive this ui can draw.
+    pub primitives: PrimitiveRegistry,
     pub textures: Textures,
     pub text: TextData,
     pub masks: TrackedArena<Mask, u32>,
@@ -28,7 +29,7 @@ pub trait UiRsc {
     #[allow(unused_variables)]
     fn on_remove(&mut self, id: WidgetId) {}
     #[allow(unused_variables)]
-    fn on_draw(&mut self, active: &ActiveData, redrawn: bool) {}
+    fn on_draw(&mut self, active: &ActiveData) {}
     #[allow(unused_variables)]
     fn on_undraw(&mut self, active: &ActiveData) {}
 

core/src/ui/painter.rs

@@ -1,7 +1,10 @@
 use crate::{
-    Axis, Len, RenderedText, Size, SizeCtx, StrongWidget, TextAttrs, TextBuffer, TextData,
-    TextureHandle, UiRegion, UiRenderState, UiRsc, Widget, WidgetId,
-    render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
+    Axis, Len, RenderedText, Size, StrongWidget, TextAttrs, TextBuffer, TextData, TextureHandle,
+    UiRegion, UiRenderState, UiRsc, UiScalar, UiVec2, WidgetId,
+    render::{
+        GlyphPrimitive, Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, PrimitiveKind,
+        TexturePrimitive,
+    },
     util::Vec2,
 };
 
@@ -15,21 +18,35 @@ 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,
 }
 
 impl<'a> Painter<'a> {
     fn primitive_at<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+        let kind = self.rsc.ui_mut().primitives.kind::<P>();
+        self.write(kind, primitive, region);
+    }
+
+    /// Takes the kind, for a caller writing many of one primitive.
+    fn write<P: Primitive>(&mut self, kind: PrimitiveKind<P>, primitive: P, region: UiRegion) {
         let h = self.state.layers.write(
             self.layer,
             PrimitiveInst {
+                kind,
                 id: self.id,
                 primitive,
                 region,
                 mask_idx: self.mask,
             },
         );
+        self.push_primitive(h);
+    }
+
+    fn push_primitive(&mut self, h: PrimitiveHandle) {
         if self.mask != MaskIdx::NONE {
             // TODO: I have no clue if this works at all :joy:
             self.rsc.ui_mut().masks.push_ref(self.mask);
@@ -38,11 +55,13 @@ impl<'a> Painter<'a> {
     }
 
     /// Writes a primitive to be rendered
-    pub fn primitive<P: Primitive>(&mut self, primitive: P) {
+    pub fn primitive(&mut self, primitive: impl PrimitiveLike) {
+        let primitive = primitive.into_primitive(self);
         self.primitive_at(primitive, self.region)
     }
 
-    pub fn primitive_within<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+    pub fn primitive_within(&mut self, primitive: impl PrimitiveLike, region: UiRegion) {
+        let primitive = primitive.into_primitive(self);
         self.primitive_at(primitive, region.within(&self.region));
     }
 
@@ -52,19 +71,31 @@ impl<'a> Painter<'a> {
     }
 
     /// Draws a widget within this widget's region.
-    pub fn widget<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
-        self.widget_at(id, self.region);
+    pub fn widget<'s, W: ?Sized>(&'s mut self, id: &'s StrongWidget<W>) -> DrawResult<'s, 'a, W> {
+        self.widget_at(id, self.region)
     }
 
-    /// Draws a widget somewhere within this one.
-    /// Useful for drawing child widgets in select areas.
-    pub fn widget_within<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) {
-        self.widget_at(id, region.within(&self.region));
+    /// 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)
     }
 
-    fn widget_at<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) {
-        self.children.push(id.id());
-        self.state.draw_inner(
+    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()) {
+            self.children.push(id.id());
+        }
+        let size = self.state.draw_inner(
             self.layer,
             id.id(),
             region,
@@ -73,49 +104,76 @@ impl<'a> Painter<'a> {
             None,
             self.rsc,
         );
+        DrawResult {
+            child: id,
+            painter: self,
+            size,
+        }
     }
 
-    pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) {
-        self.textures.push(handle.clone());
-        self.primitive_at(handle.primitive(), region.within(&self.region));
+    /// 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)
     }
 
-    pub fn texture(&mut self, handle: &TextureHandle) {
-        self.textures.push(handle.clone());
-        self.primitive(handle.primitive());
+    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 texture_at(&mut self, handle: &TextureHandle, region: UiRegion) {
-        self.textures.push(handle.clone());
-        self.primitive_at(handle.primitive(), region);
-    }
-
-    /// returns (handle, offset from top left)
-    pub fn render_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
+    pub fn render_text(
+        &mut self,
+        buffer: &mut TextBuffer,
+        attrs: &TextAttrs,
+        width: Option<f32>,
+    ) -> RenderedText {
         let ui = self.rsc.ui_mut();
-        ui.text.draw(buffer, attrs, &mut ui.textures)
+        ui.text.render(buffer, attrs, width)
+    }
+
+    // TODO: merge the text methods into the primitive ones.
+    pub fn glyphs(&mut self, text: &RenderedText, origin: UiRegion) {
+        let kind = self.rsc.ui_mut().primitives.kind::<GlyphPrimitive>();
+        for glyph in text.glyphs.iter() {
+            let mut region = origin;
+            region.x.end = region.x.start;
+            region.y.end = region.y.start;
+            let mut region = region.offset(UiVec2::abs(glyph.offset));
+            region.x.end = region.x.start + UiScalar::abs(glyph.entry.width as f32);
+            region.y.end = region.y.start + UiScalar::abs(glyph.entry.height as f32);
+            self.write(
+                kind,
+                GlyphPrimitive {
+                    uv_min: glyph.entry.uv_min,
+                    uv_max: glyph.entry.uv_max,
+                    layer: glyph.entry.layer,
+                    color: text.color,
+                    flags: glyph.entry.flags(),
+                },
+                region,
+            );
+        }
     }
 
     pub fn region(&self) -> UiRegion {
         self.region
     }
 
-    pub fn size<W: ?Sized + Widget>(&mut self, id: &StrongWidget<W>) -> Size {
-        self.size_ctx().size(id)
-    }
-
-    pub fn len_axis<W: ?Sized + Widget>(&mut self, id: &StrongWidget<W>, axis: Axis) -> Len {
-        match axis {
-            Axis::X => self.size_ctx().width(id),
-            Axis::Y => self.size_ctx().height(id),
-        }
-    }
-
-    pub fn output_size(&self) -> Vec2 {
+    /// 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;
         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)
     }
 
@@ -138,8 +196,49 @@ impl<'a> Painter<'a> {
     pub fn id(&self) -> &WidgetId {
         &self.id
     }
+}
 
-    pub fn size_ctx(&mut self) -> SizeCtx<'_> {
-        self.state.size_ctx(self.id, self.region.size(), self.rsc)
+/// A child that has just been drawn. Reading its size records that this
+/// widget's own size depends on it; dropping it without reading draws the
+/// child and leaves the parent independent of what it came to.
+pub struct DrawResult<'p, 'a, 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)
+    }
+}
+
+/// What `Painter::primitive` takes: a primitive, or something that yields one
+/// and does whatever else drawing it needs.
+pub trait PrimitiveLike {
+    type Primitive: Primitive;
+    fn into_primitive(self, painter: &mut Painter) -> Self::Primitive;
+}
+
+impl<P: Primitive> PrimitiveLike for P {
+    type Primitive = P;
+    fn into_primitive(self, _: &mut Painter) -> P {
+        self
+    }
+}
+
+impl PrimitiveLike for &TextureHandle {
+    type Primitive = TexturePrimitive;
+
+    /// Retains a share of the handle, so the slot the primitive names cannot
+    /// be freed and reused while it is still drawn.
+    fn into_primitive(self, painter: &mut Painter) -> TexturePrimitive {
+        painter.textures.push(self.clone());
+        self.into()
     }
 }

core/src/ui/render_state.rs

@@ -1,15 +1,13 @@
 use crate::{
-    ActiveData, Axis, IdLike, MaskIdx, Painter, PixelRegion, PrimitiveLayers, SizeCtx,
-    StrongWidget, UiRegion, UiRsc, UiVec2, WidgetId, Widgets,
-    ui::cache::Cache,
+    ActiveData, Axis, DrawLayers, IdLike, MaskIdx, OnResize, Painter, PixelRegion, Remap, Size,
+    StrongWidget, UiRegion, UiRsc, WidgetId, Widgets,
     util::{HashMap, HashSet, Vec2, forget_ref},
 };
 
 pub struct UiRenderState {
     pub active: HashMap<WidgetId, ActiveData>,
-    pub layers: PrimitiveLayers,
+    pub layers: DrawLayers,
     pub(super) output_size: Vec2,
-    pub cache: Cache,
 
     old_root: Option<WidgetId>,
     resized: bool,
@@ -21,7 +19,6 @@ impl UiRenderState {
         Self {
             active: Default::default(),
             layers: Default::default(),
-            cache: Default::default(),
             output_size: Vec2::ZERO,
             old_root: None,
             resized: false,
@@ -34,6 +31,10 @@ 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
@@ -52,11 +53,21 @@ impl UiRenderState {
             );
         }
         let root = root.into();
-        if self.root_changed(root) || self.resized {
+        if self.root_changed(root) {
             self.redraw_all(root, rsc);
             self.old_root = root.map(|r| r.id());
-            self.resized = false;
-        } else if rsc.widgets().has_updates() {
+        } 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() {
             self.redraw_updates(rsc);
         }
     }
@@ -80,21 +91,11 @@ impl UiRenderState {
         mask: MaskIdx,
         old_children: Option<Vec<WidgetId>>,
         rsc: &mut dyn UiRsc,
-    ) {
-        let mut redrawn = old_children.is_some();
+    ) -> Size {
         let mut old_children = old_children.unwrap_or_default();
-        if let Some(active) = self.active.get_mut(&id)
-            && !rsc.widgets().needs_redraw.contains(&id)
-        {
-            redrawn = true;
-            // check to see if we can skip drawing first
-            if active.region == region {
-                return;
-            } else if active.region.size() == region.size() {
-                // TODO: epsilon?
-                let from = active.region;
-                self.mov(id, from, region);
-                return;
+        if self.active.contains_key(&id) {
+            if let Some(size) = self.try_reuse(id, region, rsc) {
+                return size;
             }
             // if not, then maintain resize and track old children to remove unneeded
             let active = self.remove(id, false, rsc).unwrap();
@@ -102,6 +103,7 @@ impl UiRenderState {
         }
 
         // draw widget
+        rsc.widgets_mut().needs_redraw.remove(&id);
         self.draw_started.insert(id);
 
         let mut painter = Painter {
@@ -113,11 +115,13 @@ 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);
-        widget.draw(&mut painter);
+        let size = widget.draw(&mut painter);
         drop(widget);
 
         let Painter {
@@ -128,18 +132,29 @@ 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,
         };
@@ -151,21 +166,79 @@ impl UiRenderState {
             }
         }
 
-        rsc.on_draw(&active, redrawn);
+        rsc.on_draw(&active);
         self.active.insert(id, active);
+        size
     }
 
-    fn mov(&mut self, id: WidgetId, from: UiRegion, to: UiRegion) {
+    /// 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) {
         let active = self.active.get_mut(&id).unwrap();
         for h in &active.primitives {
             let region = self.layers[h.layer].region_mut(h);
-            *region = region.outside(&from).within(&to);
+            *region = remap.apply(*region);
         }
-        active.region = active.region.outside(&from).within(&to);
+        active.region = remap.apply(active.region);
         // SAFETY: children cannot be recursive
         let children = unsafe { forget_ref(&active.children) };
         for child in children {
-            self.mov(*child, from, to);
+            self.mov(*child, remap);
         }
     }
 
@@ -189,7 +262,6 @@ impl UiRenderState {
     }
 
     fn remove_rec(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) -> Option<ActiveData> {
-        self.cache.remove(id);
         let inst = self.remove(id, true, rsc);
         if let Some(inst) = &inst {
             for c in &inst.children {
@@ -203,7 +275,6 @@ impl UiRenderState {
         for (_, active) in self.active.drain() {
             rsc.on_undraw(&active);
         }
-        self.cache.clear();
         self.layers.clear();
         rsc.widgets_mut().needs_redraw.clear();
         rsc.free();
@@ -225,7 +296,7 @@ impl UiRenderState {
         root: impl Into<Option<&'a StrongWidget>>,
         widgets: &Widgets,
     ) -> bool {
-        self.root_changed(root) || widgets.has_updates()
+        self.root_changed(root) || self.resized || widgets.has_updates()
     }
 
     pub fn active_widgets(&self) -> usize {
@@ -240,14 +311,14 @@ impl UiRenderState {
     }
 
     pub fn debug_layers(&self) {
-        for ((idx, depth), primitives) in self.layers.iter_depth() {
+        for ((idx, depth), draws) in self.layers.iter_depth() {
             let indent = " ".repeat(depth * 2);
-            let len = primitives.instances().len();
-            print!("{indent}{idx}: {len} primitives");
-            if len >= 1 {
-                print!(" ({})", primitives.instances()[0].binding);
-            }
-            println!();
+            let counts: Vec<String> = draws
+                .primitives()
+                .iter()
+                .map(|l| l.as_ref().map_or(0, |l| l.instances().len()).to_string())
+                .collect();
+            println!("{indent}{idx}: [{}]", counts.join(", "));
         }
     }
 
@@ -258,22 +329,19 @@ 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);
-        // check if parent depends on the desired size of this, if so then redraw it first
-        for axis in [Axis::X, Axis::Y] {
-            if let Some(&(outer, old)) = self.cache.size.axis_dyn(axis).get(&id)
-                && let Some(current) = self.active.get(&id)
-                && let Some(pid) = current.parent
-            {
-                self.cache.size.axis_dyn(axis).remove(&id);
-                let new = self.size_ctx(id, outer, rsc).len_axis(id, axis);
-                self.cache.size.axis_dyn(axis).insert(id, (outer, new));
-                if new != old {
-                    self.redraw(pid, rsc);
-                }
-            }
+        // Whoever read this widget's size may be a different size now, so the
+        // highest reader is what draws. 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;
         }
+        rsc.widgets_mut().needs_redraw.remove(&id);
 
         if self.draw_started.contains(&id) {
             return;
@@ -294,23 +362,23 @@ impl UiRenderState {
         );
     }
 
-    pub(super) fn size_ctx<'b>(
-        &'b mut self,
-        source: WidgetId,
-        outer: UiVec2,
-        rsc: &'b mut dyn UiRsc,
-    ) -> SizeCtx<'b> {
-        let ui = rsc.ui_mut();
-        SizeCtx {
-            source,
-            cache: &mut self.cache,
-            text: &mut ui.text,
-            textures: &mut ui.textures,
-            widgets: &ui.widgets,
-            outer,
-            output_size: self.output_size,
-            id: source,
+    /// The furthest ancestor that read this widget's size, directly or through
+    /// widgets that did the same, 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;
         }
+        top
     }
 }
 

core/src/ui/size.rs

@@ -1,86 +0,0 @@
-use crate::{
-    Axis, AxisT, IdLike, Len, RenderedText, Size, TextAttrs, TextBuffer, TextData, Textures,
-    UiVec2, WidgetAxisFns, WidgetId, Widgets, XAxis, YAxis, ui::cache::Cache, util::Vec2,
-};
-
-pub struct SizeCtx<'a> {
-    pub text: &'a mut TextData,
-    pub textures: &'a mut Textures,
-    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,
-                textures: self.textures,
-                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) -> RenderedText {
-        self.text.draw(buffer, attrs, self.textures)
-    }
-
-    pub fn label(&self, id: WidgetId) -> &String {
-        self.widgets.label(id)
-    }
-}

core/src/util/math.rs

@@ -1,33 +1,21 @@
-use std::ops::*;
-
-pub const trait LerpUtil {
+pub const trait LerpUtil: Sized {
     fn lerp(self, from: Self, to: Self) -> Self;
-    fn lerp_inv(self, from: Self, to: Self) -> Self;
+    fn lerp_inv(self, from: Self, to: Self) -> Option<Self>;
 }
 
-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
-{
+const impl LerpUtil for f32 {
     /// linear interpolation
     /// from * (1.0 - self) + to * self
     fn lerp(self, from: Self, to: Self) -> Self {
         from + (to - from) * self
     }
-    /// inverse of lerp
-    fn lerp_inv(self, from: Self, to: Self) -> Self {
-        (self - from).div_or(to - from, from)
+    /// 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)),
+        }
     }
 }
 

core/src/util/mod.rs

@@ -16,7 +16,7 @@ pub use id::*;
 pub use math::*;
 pub use refcount::*;
 pub use slot::*;
-pub use trust::*;
+pub(crate) use trust::*;
 pub use typemap::*;
 pub use vec2::*;
 

core/src/util/trust.rs

@@ -1,15 +1,15 @@
 #[allow(clippy::missing_safety_doc)]
-pub unsafe fn forget_ref<'a, T>(x: &T) -> &'a T {
+pub(crate) unsafe fn forget_ref<'a, T>(x: &T) -> &'a T {
     unsafe { std::mem::transmute::<&T, &T>(x) }
 }
 
 #[allow(clippy::missing_safety_doc)]
-pub unsafe fn forget_mut<'a, T>(x: &mut T) -> &'a mut T {
+pub(crate) unsafe fn forget_mut<'a, T>(x: &mut T) -> &'a mut T {
     unsafe { std::mem::transmute::<&mut T, &mut T>(x) }
 }
 
 #[allow(clippy::mut_from_ref, clippy::missing_safety_doc)]
-pub unsafe fn to_mut<T>(x: &T) -> &mut T {
+pub(crate) unsafe fn to_mut<T>(x: &T) -> &mut T {
     #[allow(mutable_transmutes)]
     unsafe {
         std::mem::transmute::<&T, &mut T>(x)

core/src/util/vec2.rs

@@ -1,4 +1,4 @@
-use crate::util::{DivOr, impl_op};
+use crate::util::impl_op;
 use std::{hash::Hash, ops::*};
 
 #[repr(C)]
@@ -67,15 +67,6 @@ 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/like.rs

@@ -34,7 +34,7 @@ pub trait HasRoot {
 
 pub trait WidgetArrLike<Rsc, const LEN: usize, Tag> {
     #[track_caller]
-    fn add(self, rsc: &mut Rsc) -> WidgetArr<LEN>;
+    fn add(self, state: &mut Rsc) -> WidgetArr<LEN>;
 }
 
 impl<Rsc, const LEN: usize> WidgetArrLike<Rsc, LEN, ArrTag> for WidgetArr<LEN> {
@@ -58,13 +58,6 @@ macro_rules! impl_widget_arr {
                 )
             }
         }
-        impl<Rsc: UiRsc, $($W: WidgetLike<Rsc, $Tag>,$Tag,)*> IntoWidgetVec<Rsc, ($($Tag,)*), ArrTag> for ($($W,)*) {
-            fn into_vec(self, rsc: &mut Rsc) -> Vec<StrongWidget> {
-                #[allow(non_snake_case)]
-                let ($($W,)*) = self;
-                vec![$($W.add(rsc).upgrade(rsc),)*]
-            }
-        }
     };
 }
 

core/src/widget/mod.rs

@@ -1,4 +1,4 @@
-use crate::{Axis, AxisT, Len, Painter, SizeCtx, UiRsc};
+use crate::{Axis, Len, Painter, Size};
 use std::any::Any;
 
 mod data;
@@ -15,32 +15,45 @@ 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 {
-    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;
-}
+    /// Draws the widget, and returns what it used of the box it was given.
+    fn draw(&mut self, painter: &mut Painter) -> Size;
 
-pub trait WidgetAxisFns {
-    fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len;
-}
+    /// An exact length the widget can give without a painter or its children.
+    /// Optional, and saves a draw rather than changing one: a hint that
+    /// disagrees with the eventual draw fails a debug assertion.
+    fn size_hint(&self, _axis: Axis) -> Option<Len> {
+        None
+    }
 
-impl<W: Widget + ?Sized> WidgetAxisFns for W {
-    fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len {
-        match A::get() {
-            Axis::X => self.desired_width(ctx),
-            Axis::Y => self.desired_height(ctx),
-        }
+    fn on_resize(&self, _axis: Axis) -> OnResize {
+        OnResize::default()
     }
 }
 
 impl Widget for () {
-    fn draw(&mut self, _: &mut Painter) {}
-    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
-        Len::ZERO
+    /// 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 desired_height(&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
     }
 }
 
@@ -85,16 +98,3 @@ impl<State, F: FnOnce(&mut State) -> Option<StrongWidget>> WidgetOption<State> f
         self(state)
     }
 }
-
-pub trait IntoWidgetVec<Rsc, WTag, GTag> {
-    fn into_vec(self, rsc: &mut Rsc) -> Vec<StrongWidget>;
-}
-
-impl<Rsc: UiRsc, I: IntoIterator, Tag> IntoWidgetVec<Rsc, Tag, IterTag> for I
-where
-    I::Item: WidgetLike<Rsc, Tag>,
-{
-    fn into_vec(self, rsc: &mut Rsc) -> Vec<StrongWidget> {
-        self.into_iter().map(|w| w.add_strong(rsc).any()).collect()
-    }
-}

core/src/widget/tag.rs

@@ -62,4 +62,3 @@ impl<Rsc: UiRsc, V: WidgetView> WidgetLike<Rsc, ViewTag> for V {
 }
 
 pub struct ArrTag;
-pub struct IterTag;

examples/minimal.rs

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

examples/tabs/main.rs

@@ -1,4 +1,3 @@
-use cosmic_text::Family;
 use std::{cell::RefCell, rc::Rc};
 use winit::event::WindowEvent;
 
@@ -16,7 +15,7 @@ pub struct Client {
 }
 
 impl DefaultAppState for Client {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>) -> Self {
+    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
         let rrect = rect(Color::WHITE).radius(20);
         let pad_test = (
             rrect.color(Color::BLUE),
@@ -144,7 +143,7 @@ impl DefaultAppState for Client {
             .span(Dir::DOWN)
             .add(rsc);
 
-        let main = WidgetPtr::empty().add(rsc);
+        let main = WidgetPtr::new().add(rsc);
 
         let vals = Rc::new(RefCell::new((0, Vec::new())));
         let mut switch_button = |color, to: WeakWidget, label| {
@@ -209,10 +208,10 @@ impl DefaultAppState for Client {
         render: &mut UiRenderState,
     ) {
         let new = format!(
-            "widgets: {}\nactive: {}\nviews: {}",
+            "widgets: {}\nactive: {}\ntextures: {}",
             rsc.widgets().len(),
             render.active_widgets(),
-            self.ui_state.renderer.ui.view_count(),
+            rsc.ui().textures.count(),
         );
         if new != *rsc.widgets()[self.info].content {
             *rsc.widgets_mut()[self.info].content = new;

examples/task.rs

@@ -11,7 +11,7 @@ struct State {
 }
 
 impl DefaultAppState for State {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>) -> Self {
+    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> 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

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

examples/view.rs

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

macro/Cargo.toml

@@ -6,7 +6,7 @@ edition.workspace = true
 [dependencies]
 proc-macro2 = "1.0.103"
 quote = "1.0.42"
-syn = { version = "3.0.3", features = ["full"] }
+syn = { version = "2.0.111", features = ["full"] }
 
 [lib]
 proc-macro = true

rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly"
+components = ["clippy", "rustfmt"]

src/default/event.rs

@@ -7,11 +7,3 @@ impl Event for Submit {}
 #[derive(Eq, PartialEq, Hash, Clone)]
 pub struct Edited;
 impl Event for Edited {}
-
-#[derive(Eq, PartialEq, Hash, Clone)]
-pub struct Draw;
-impl Event for Draw {}
-
-#[derive(Eq, PartialEq, Hash, Clone)]
-pub struct Undraw;
-impl Event for Undraw {}

src/default/mod.rs

@@ -1,10 +1,6 @@
 use crate::prelude::*;
 use arboard::Clipboard;
-use std::{
-    marker::{PhantomData, Sized},
-    sync::Arc,
-    time::Instant,
-};
+use std::{marker::PhantomData, sync::Arc, time::Instant};
 use winit::{
     event::{Ime, WindowEvent},
     event_loop::{ActiveEventLoop, EventLoopProxy},
@@ -29,24 +25,33 @@ pub use sense::*;
 pub use state::*;
 pub use task::*;
 
-pub struct EventSender<State: DefaultAppState> {
-    proxy: EventLoopProxy<UiMainEvent<State>>,
-}
+/// 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 EventSender<State> {
+impl<State: DefaultAppState> Clone for Proxy<State> {
     fn clone(&self) -> Self {
-        Self {
-            proxy: self.proxy.clone(),
-        }
+        Self(self.0.clone())
     }
 }
 
-impl<State: DefaultAppState> EventSender<State> {
-    pub fn send(&self, event: State::Event) {
-        let _ = self.proxy.send_event(UiMainEvent::App(event));
+impl<State: DefaultAppState> Proxy<State> {
+    pub fn send_event(&self, event: State::Event) {
+        let _ = self.0.send_event(DefaultEvent::User(event));
     }
-    pub fn run(&self, f: impl MainCallback<State>) {
-        let _ = self.proxy.send_event(UiMainEvent::Callback(Box::new(f)));
+}
+
+/// 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));
     }
 }
 
@@ -90,7 +95,7 @@ pub trait HasDefaultUiState: Sized + 'static {
 
 pub trait DefaultAppState: HasDefaultUiState {
     type Event: Send = ();
-    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>) -> Self;
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self>) -> Self;
     #[allow(unused_variables)]
     fn event(
         &mut self,
@@ -114,58 +119,23 @@ pub trait DefaultAppState: HasDefaultUiState {
     }
 }
 
-pub struct DefaultRsc<State: 'static + DefaultAppState> {
+pub struct DefaultRsc<State: 'static> {
     pub ui: UiData,
     pub events: EventManager<Self>,
     pub tasks: Tasks<Self>,
     pub state: WidgetState,
-    pub widget_events: Vec<WidgetEvent>,
-    pub window_event: EventSender<State>,
     _state: PhantomData<State>,
 }
 
-pub struct WidgetEvent {
-    id: WidgetId,
-    ty: WidgetEventType,
-}
-
-pub enum WidgetEventType {
-    Draw,
-    Undraw,
-    Remove,
-}
-
-pub trait MainCallback<State>: FnOnce(&mut DefaultRsc<State>) + Sync + Send + 'static {}
-impl<F: FnOnce(&mut DefaultRsc<State>) + Sync + Send + 'static, State> MainCallback<State> for F {}
-
-pub enum UiMainEvent<State: DefaultAppState> {
-    RequestUpdate,
-    Callback(Box<dyn MainCallback<State>>),
-    App(State::Event),
-}
-
-impl<State: DefaultAppState> DefaultRsc<State> {
-    fn init(proxy: EventLoopProxy<UiMainEvent<State>>) -> (Self, TaskMsgReceiver<Self>) {
-        let window_event = EventSender {
-            proxy: proxy.clone(),
-        };
-        let (tasks, recv) = Tasks::init(move || {
-            if proxy.send_event(UiMainEvent::RequestUpdate).is_err() {
-                panic!("main thread blew up or smth");
-            }
-        });
-        (
-            Self {
-                ui: Default::default(),
-                events: Default::default(),
-                tasks,
-                widget_events: Default::default(),
-                state: Default::default(),
-                window_event,
-                _state: Default::default(),
-            },
-            recv,
-        )
+impl<State> DefaultRsc<State> {
+    pub fn init(queue: Arc<dyn TaskQueue<Self>>) -> Self {
+        Self {
+            ui: Default::default(),
+            events: Default::default(),
+            tasks: Tasks::init(queue),
+            state: Default::default(),
+            _state: Default::default(),
+        }
     }
 
     pub fn create_state<T: 'static>(&mut self, id: impl IdLike, data: T) -> WeakState<T> {
@@ -173,7 +143,7 @@ impl<State: DefaultAppState> DefaultRsc<State> {
     }
 }
 
-impl<State: DefaultAppState> UiRsc for DefaultRsc<State> {
+impl<State> UiRsc for DefaultRsc<State> {
     fn ui(&self) -> &UiData {
         &self.ui
     }
@@ -182,39 +152,25 @@ impl<State: DefaultAppState> UiRsc for DefaultRsc<State> {
         &mut self.ui
     }
 
-    fn on_draw(&mut self, active: &ActiveData, redrawn: bool) {
+    fn on_draw(&mut self, active: &ActiveData) {
         self.events.draw(active);
-        if !redrawn {
-            self.widget_events.push(WidgetEvent {
-                id: active.id,
-                ty: WidgetEventType::Draw,
-            });
-        }
     }
 
     fn on_undraw(&mut self, active: &ActiveData) {
         self.events.undraw(active);
-        self.widget_events.push(WidgetEvent {
-            id: active.id,
-            ty: WidgetEventType::Undraw,
-        });
     }
 
     fn on_remove(&mut self, id: WidgetId) {
         self.events.remove(id);
         self.state.remove(id);
-        self.widget_events.push(WidgetEvent {
-            id,
-            ty: WidgetEventType::Remove,
-        });
     }
 }
 
-impl<State: 'static + DefaultAppState> HasState for DefaultRsc<State> {
+impl<State: 'static> HasState for DefaultRsc<State> {
     type State = State;
 }
 
-impl<State: 'static + DefaultAppState> HasEvents for DefaultRsc<State> {
+impl<State: 'static> HasEvents for DefaultRsc<State> {
     fn events(&self) -> &EventManager<Self> {
         &self.events
     }
@@ -224,13 +180,13 @@ impl<State: 'static + DefaultAppState> HasEvents for DefaultRsc<State> {
     }
 }
 
-impl<State: 'static + DefaultAppState> HasTasks for DefaultRsc<State> {
+impl<State: 'static> HasTasks for DefaultRsc<State> {
     fn tasks_mut(&mut self) -> &mut Tasks<Self> {
         &mut self.tasks
     }
 }
 
-impl<State: 'static + DefaultAppState> HasWidgetState for DefaultRsc<State> {
+impl<State: 'static> HasWidgetState for DefaultRsc<State> {
     fn widget_state(&self) -> &WidgetState {
         &self.state
     }
@@ -244,62 +200,49 @@ 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 = UiMainEvent<State>;
+    type Event = DefaultEvent<State>;
 
     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, task_recv) = DefaultRsc::init(proxy);
-        let state = State::new(default_state, &mut rsc);
+        let mut rsc = DefaultRsc::init(Arc::new(Proxy(proxy.clone())));
+        let state = State::new(default_state, &mut rsc, Proxy(proxy));
         let render = UiRenderState::new();
-        Self {
-            rsc,
-            state,
-            render,
-            task_recv,
-        }
+        Self { rsc, state, render }
     }
 
     fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
         match event {
-            UiMainEvent::RequestUpdate => {
-                self.check_updates();
-            }
-            UiMainEvent::App(event) => {
-                self.state.event(event, &mut self.rsc, &mut self.render);
-            }
-            UiMainEvent::Callback(f) => f(&mut self.rsc),
+            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();
     }
 
     fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
-        let Self {
-            rsc, render, state, ..
-        } = self;
+        let Self { rsc, render, state } = self;
 
-        // input handling
         let ui_state = state.default_state_mut();
-        if ui_state.input.event(&event) {
-            let cursor_state = ui_state.cursor_state().clone();
-            let old = ui_state.focus;
-            if cursor_state.buttons.left.is_start() {
-                ui_state.focus = None;
-            }
-            let window_size = ui_state.window_size();
-            render.run_sensors(rsc, state, cursor_state, window_size);
-            if old != state.default_state().focus
-                && let Some(old) = old
-            {
-                old.edit(rsc).deselect();
-            }
+        let input_changed = ui_state.input.event(&event);
+        let cursor_state = ui_state.cursor_state().clone();
+        let old = ui_state.focus;
+        if cursor_state.buttons.left.is_start() {
+            ui_state.focus = None;
+        }
+        if input_changed {
+            render.run_sensors(rsc, state, cursor_state);
         }
         let ui_state = state.default_state_mut();
+        if old != ui_state.focus
+            && let Some(old) = old
+        {
+            old.edit(rsc).deselect();
+        }
         match &event {
             WindowEvent::CloseRequested => event_loop.exit(),
             WindowEvent::RedrawRequested => {
@@ -361,8 +304,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
             _ => (),
         }
         state.window_event(event, rsc, render);
-
-        self.check_updates();
+        self.request_redraw_if_needed();
         self.state.default_state_mut().input.end_frame();
     }
 
@@ -372,34 +314,9 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
 }
 
 impl<State: DefaultAppState> DefaultApp<State> {
-    pub fn check_updates(&mut self) {
-        let Self {
-            rsc,
-            render,
-            state,
-            task_recv,
-        } = self;
-
-        for update in task_recv.try_iter() {
-            update(state, rsc);
-        }
-
-        let mut events = std::mem::take(&mut rsc.widget_events);
-        for event in events.drain(..) {
-            match event.ty {
-                WidgetEventType::Draw => {
-                    rsc.run_event::<Draw>(event.id, (), state);
-                }
-                WidgetEventType::Undraw => {
-                    rsc.run_event::<Undraw>(event.id, (), state);
-                }
-                _ => (),
-            }
-        }
-        rsc.widget_events = events;
-
-        let ui_state = state.default_state();
-        if render.needs_redraw(&ui_state.root, rsc.widgets()) {
+    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();
         }
     }
@@ -411,9 +328,7 @@ pub trait RscIdx<Rsc> {
     fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output;
 }
 
-impl<State: 'static + DefaultAppState, I: RscIdx<DefaultRsc<State>>> std::ops::Index<I>
-    for DefaultRsc<State>
-{
+impl<State: 'static, I: RscIdx<DefaultRsc<State>>> std::ops::Index<I> for DefaultRsc<State> {
     type Output = I::Output;
 
     fn index(&self, index: I) -> &Self::Output {
@@ -421,9 +336,7 @@ impl<State: 'static + DefaultAppState, I: RscIdx<DefaultRsc<State>>> std::ops::I
     }
 }
 
-impl<State: 'static + DefaultAppState, I: RscIdx<DefaultRsc<State>>> std::ops::IndexMut<I>
-    for DefaultRsc<State>
-{
+impl<State: 'static, I: RscIdx<DefaultRsc<State>>> std::ops::IndexMut<I> for DefaultRsc<State> {
     fn index_mut(&mut self, index: I) -> &mut Self::Output {
         index.get_mut(self)
     }

src/default/render.rs

@@ -1,4 +1,4 @@
-use iris_core::{UiData, UiLimits, UiRenderNode, UiRenderState};
+use iris_core::{UiData, UiRenderNode, UiRenderState};
 use pollster::FutureExt;
 use std::sync::Arc;
 use wgpu::*;
@@ -23,9 +23,18 @@ impl UiRenderer {
 
     pub fn draw(&mut self) {
         let output = match self.surface.get_current_texture() {
-            CurrentSurfaceTexture::Success(v) => v,
-            CurrentSurfaceTexture::Suboptimal(v) => v,
-            _ => panic!("failed"),
+            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 view = output
             .texture
@@ -49,6 +58,7 @@ impl UiRenderer {
         }
 
         self.queue.submit(std::iter::once(encoder.finish()));
+        self.window.pre_present_notify();
         self.queue.present(output);
     }
 
@@ -56,7 +66,7 @@ impl UiRenderer {
         self.config.width = size.width;
         self.config.height = size.height;
         self.surface.configure(&self.device, &self.config);
-        self.ui.resize(size, &self.queue);
+        self.ui.resize((size.width, size.height), &self.queue);
     }
 
     fn create_encoder(device: &Device) -> CommandEncoder {
@@ -70,10 +80,8 @@ impl UiRenderer {
 
         let instance = Instance::new(InstanceDescriptor {
             backends: Backends::PRIMARY,
-            flags: Default::default(),
-            memory_budget_thresholds: Default::default(),
-            backend_options: Default::default(),
-            display: None,
+            display: Some(Box::new(window.clone())),
+            ..InstanceDescriptor::new_without_display_handle()
         });
 
         let surface = instance
@@ -90,18 +98,9 @@ impl UiRenderer {
             .block_on()
             .expect("Could not get adapter!");
 
-        let ui_limits = UiLimits::default();
-
         let (device, queue) = adapter
             .request_device(&DeviceDescriptor {
-                required_features: Features::TEXTURE_BINDING_ARRAY
-                    | Features::PARTIALLY_BOUND_BINDING_ARRAY
-                    | Features::SAMPLED_TEXTURE_AND_STORAGE_BUFFER_ARRAY_NON_UNIFORM_INDEXING,
                 required_limits: Limits {
-                    max_binding_array_elements_per_shader_stage: ui_limits
-                        .max_binding_array_elements_per_shader_stage(),
-                    max_binding_array_sampler_elements_per_shader_stage: ui_limits
-                        .max_binding_array_sampler_elements_per_shader_stage(),
                     max_buffer_size: 1 << 30,
                     ..Default::default()
                 },
@@ -121,20 +120,20 @@ 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::AutoNoVsync,
+            present_mode: PresentMode::AutoVsync,
             alpha_mode: surface_caps.alpha_modes[0],
             desired_maximum_frame_latency: 2,
             view_formats: vec![],
-            color_space: Default::default(),
         };
 
         surface.configure(&device, &config);
 
         let encoder = Self::create_encoder(&device);
 
-        let ui = UiRenderNode::new(&device, &queue, &config, ui_limits);
+        let ui = UiRenderNode::new(&device, &config);
 
         Self {
             surface,

src/default/sense.rs

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

src/default/task.rs

@@ -1,11 +1,5 @@
 use iris_core::HasState;
-use std::{
-    pin::Pin,
-    sync::{
-        Arc,
-        mpsc::{Receiver as SyncReceiver, Sender as SyncSender, channel as sync_channel},
-    },
-};
+use std::{pin::Pin, sync::Arc};
 use tokio::{
     runtime::Runtime,
     sync::mpsc::{
@@ -14,62 +8,51 @@ use tokio::{
     },
 };
 
-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>,
-    request_update: Arc<dyn Fn() + Send + Sync>,
-    msg_send: SyncSender<Box<dyn TaskUpdate<Rsc>>>,
+    queue: Arc<dyn TaskQueue<Rsc>>,
 }
 
 pub struct TaskCtx<Rsc: HasState> {
-    send: TaskMsgSender<Rsc>,
+    queue: Arc<dyn TaskQueue<Rsc>>,
 }
 
 impl<Rsc: HasState> TaskCtx<Rsc> {
     pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
-        let _ = self.send.send(Box::new(f));
-    }
-}
-impl<Rsc: HasState + 'static> TaskCtx<Rsc> {
-    fn new(send: TaskMsgSender<Rsc>) -> Self {
-        Self { send }
+        self.queue.send(Box::new(f));
     }
 }
 
 type BoxTask = Pin<Box<dyn Future<Output = ()> + Send>>;
 
 impl<Rsc: HasState> Tasks<Rsc> {
-    pub fn init(request_update: impl Fn() + 'static + Send + Sync) -> (Self, TaskMsgReceiver<Rsc>) {
+    pub fn init(queue: Arc<dyn TaskQueue<Rsc>>) -> Self {
         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,
-                msg_send: msgs,
-                request_update: Arc::new(request_update),
-            },
-            msgs_recv,
-        )
+        Self { start, queue }
     }
 
     pub fn spawn<F: AsyncFnOnce(TaskCtx<Rsc>) + 'static + std::marker::Send>(&mut self, task: F)
     where
         F::CallOnceFuture: Send,
     {
-        let send = self.msg_send.clone();
-        let request_update = self.request_update.clone();
+        let queue = self.queue.clone();
         let _ = self.start.send(Box::pin(async move {
-            task(TaskCtx::new(send)).await;
-            request_update();
+            task(TaskCtx { queue }).await;
         }));
     }
 }

src/harness.rs

@@ -0,0 +1,180 @@
+//! 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;
+
+#[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);
+    }
+
+    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();
+    }
+}

src/lib.rs

@@ -1,6 +1,5 @@
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
-#![feature(gen_blocks)]
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(option_into_flat_iter)]
@@ -8,6 +7,7 @@
 
 pub mod default;
 pub mod event;
+pub mod harness;
 pub mod widget;
 
 pub use iris_core as core;

src/widget/image.rs

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

src/widget/mask.rs

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

src/widget/mod.rs

@@ -5,7 +5,6 @@ mod ptr;
 mod rect;
 mod text;
 mod trait_fns;
-mod selector;
 
 pub use image::*;
 pub use mask::*;
@@ -14,4 +13,3 @@ pub use ptr::*;
 pub use rect::*;
 pub use text::*;
 pub use trait_fns::*;
-pub use selector::*;

src/widget/position/align.rs

@@ -6,30 +6,17 @@ pub struct Aligned {
 }
 
 impl Widget for Aligned {
-    fn draw(&mut self, painter: &mut Painter) {
+    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();
         let region = match self.align.tuple() {
-            (Some(x), Some(y)) => painter
-                .size(&self.inner)
-                .to_uivec2()
-                .align(RegionAlign { x, y }),
-            (Some(x), None) => {
-                let x = painter.size_ctx().width(&self.inner).apply_rest().align(x);
-                UiRegion::new(x, UiSpan::FULL)
-            }
-            (None, Some(y)) => {
-                let y = painter.size_ctx().height(&self.inner).apply_rest().align(y);
-                UiRegion::new(UiSpan::FULL, y)
-            }
+            (Some(x), Some(y)) => size.to_uivec2().align(RegionAlign { x, y }),
+            (Some(x), None) => UiRegion::new(size.x.apply_rest().align(x), UiSpan::FULL),
+            (None, Some(y)) => UiRegion::new(UiSpan::FULL, size.y.apply_rest().align(y)),
             (None, None) => UiRegion::FULL,
         };
         painter.widget_within(&self.inner, region);
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.width(&self.inner)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.height(&self.inner)
+        size
     }
 }

src/widget/position/layer.rs

@@ -6,18 +6,10 @@ pub struct LayerOffset {
 }
 
 impl Widget for LayerOffset {
-    fn draw(&mut self, painter: &mut Painter) {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
         for _ in 0..self.offset {
             painter.next_layer();
         }
-        painter.widget(&self.inner);
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.width(&self.inner)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.height(&self.inner)
+        painter.widget(&self.inner).size()
     }
 }

src/widget/position/max_size.rs

@@ -6,43 +6,20 @@ pub struct MaxSize {
     pub y: Option<Len>,
 }
 
-impl MaxSize {
-    fn apply_to_outer(&self, ctx: &mut SizeCtx) {
-        if let Some(x) = self.x {
-            ctx.outer.x.select_len(x.apply_rest());
-        }
-        if let Some(y) = self.y {
-            ctx.outer.y.select_len(y.apply_rest());
-        }
-    }
-}
-
 impl 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
+    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),
         }
     }
 }
+
+fn capped(len: Len, max: Option<Len>, output: f32) -> Len {
+    match max {
+        Some(max) if len.apply_rest().to_abs(output) > max.apply_rest().to_abs(output) => max,
+        _ => len,
+    }
+}

src/widget/position/mod.rs

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

src/widget/position/offset.rs

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

src/widget/position/pad.rs

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

src/widget/position/scroll.rs

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

src/widget/position/set_size.rs

@@ -0,0 +1,26 @@
+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

@@ -1,34 +0,0 @@
-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,13 +8,27 @@ pub struct Span {
 }
 
 impl Widget for Span {
-    fn draw(&mut self, painter: &mut Painter) {
-        let total = self.len_sum(&mut painter.size_ctx());
+    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);
+
         let mut start = UiScalar::rel_min();
-        for child in &self.children {
+        let mut ortho = Len::ZERO;
+        for (child, len) in self.children.iter().zip(&lens) {
             let mut span = UiSpan::FULL;
             span.start = start;
-            let len = painter.len_axis(child, self.dir.axis);
             if len.rest > 0.0 {
                 let offset = UiScalar::new(total.rel, total.abs);
                 let rel_end = UiScalar::rel(len.rest / total.rest);
@@ -24,27 +38,25 @@ impl Widget for Span {
             start.abs += len.abs;
             start.rel += len.rel;
             span.end = start;
-            let mut child_region = UiRegion::from_axis(self.dir.axis, span, UiSpan::FULL);
+            let mut region = UiRegion::from_axis(axis, span, UiSpan::FULL);
             if self.dir.sign == Sign::Neg {
-                child_region.flip(self.dir.axis);
+                region.flip(axis);
+            }
+            let used = painter.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);
             }
-            painter.widget_within(child, child_region);
             start.abs += self.gap;
         }
-    }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        match self.dir.axis {
-            Axis::X => self.desired_len(ctx),
-            Axis::Y => self.desired_ortho(ctx),
-        }
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        match self.dir.axis {
-            Axis::X => self.desired_ortho(ctx),
-            Axis::Y => self.desired_len(ctx),
-        }
+        let along = match total.rest == 0.0 && total.rel == 0.0 {
+            true => total,
+            false => Len::default(),
+        };
+        Size::from_axis(axis, along, ortho)
     }
 }
 
@@ -69,115 +81,34 @@ 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<Children, Rsc, Tag, GTag> {
-    pub children: Children,
+pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
+    pub children: Wa,
     pub dir: Dir,
     pub gap: f32,
-    _pd: PhantomData<(Rsc, Tag, GTag)>,
+    _pd: PhantomData<(State, Tag)>,
 }
 
-impl<Children: IntoWidgetVec<Rsc, Tag, GTag>, Rsc, Tag, GTag> WidgetFnTrait<Rsc>
-    for SpanBuilder<Children, Rsc, Tag, GTag>
+impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
+    for SpanBuilder<Rsc, LEN, Wa, Tag>
 {
     type Widget = Span;
 
     #[track_caller]
     fn run(self, rsc: &mut Rsc) -> Self::Widget {
         Span {
-            children: self.children.into_vec(rsc),
+            children: self.children.add(rsc).arr.into_iter().collect(),
             dir: self.dir,
             gap: self.gap,
         }
     }
 }
 
-impl<Children: IntoWidgetVec<Rsc, Tag, GTag>, Rsc, Tag, GTag>
-    SpanBuilder<Children, Rsc, Tag, GTag>
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    SpanBuilder<State, LEN, Wa, Tag>
 {
-    pub fn new(children: Children, dir: Dir) -> Self {
+    pub fn new(children: Wa, dir: Dir) -> Self {
         Self {
             children,
             dir,

src/widget/position/stack.rs

@@ -8,30 +8,25 @@ pub struct Stack {
 }
 
 impl Widget for Stack {
-    fn draw(&mut self, painter: &mut Painter) {
-        let mut iter = self.children.iter();
-        if let Some(child) = iter.next() {
-            painter.child_layer();
-            painter.widget(child);
-        }
-        for child in iter {
-            painter.next_layer();
-            painter.widget(child);
-        }
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        match self.size {
-            StackSize::Default => Len::default(),
-            StackSize::Child(i) => ctx.width(&self.children[i]),
-        }
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        match self.size {
-            StackSize::Default => Len::default(),
-            StackSize::Child(i) => ctx.height(&self.children[i]),
+    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(),
+            }
+            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();
+            }
         }
+        size
     }
 }
 
@@ -42,28 +37,30 @@ pub enum StackSize {
     Child(usize),
 }
 
-pub struct StackBuilder<Children, Rsc, Tag, GTag> {
-    pub children: Children,
+pub struct StackBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
+    pub children: Wa,
     pub size: StackSize,
-    _pd: PhantomData<(Rsc, Tag, GTag)>,
+    _pd: PhantomData<(State, Tag)>,
 }
 
-impl<Children: IntoWidgetVec<Rsc, Tag, GTag>, Rsc, Tag, GTag> WidgetFnTrait<Rsc>
-    for StackBuilder<Children, Rsc, Tag, GTag>
+impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
+    for StackBuilder<Rsc, LEN, Wa, Tag>
 {
     type Widget = Stack;
 
     #[track_caller]
     fn run(self, rsc: &mut Rsc) -> Self::Widget {
         Stack {
-            children: self.children.into_vec(rsc),
+            children: self.children.add(rsc).arr.into_iter().collect(),
             size: self.size,
         }
     }
 }
 
-impl<Children: IntoWidgetVec<Rsc, Tag, GTag>, Rsc, Tag, GTag> StackBuilder<Children, Rsc, Tag, GTag> {
-    pub fn new(children: Children) -> Self {
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    StackBuilder<State, LEN, Wa, Tag>
+{
+    pub fn new(children: Wa) -> Self {
         Self {
             children,
             size: StackSize::default(),

src/widget/ptr.rs

@@ -1,39 +1,22 @@
 use crate::prelude::*;
-use std::marker::{Sized, Unsize};
+use std::marker::Unsize;
 
 pub struct WidgetPtr {
     pub inner: Option<StrongWidget>,
 }
 
 impl Widget for WidgetPtr {
-    fn draw(&mut self, painter: &mut Painter) {
-        if let Some(id) = &self.inner {
-            painter.widget(id);
-        }
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(id) = &self.inner {
-            ctx.width(id)
-        } else {
-            Len::ZERO
-        }
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(id) = &self.inner {
-            ctx.height(id)
-        } else {
-            Len::ZERO
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        match &self.inner {
+            Some(id) => painter.widget(id).size(),
+            None => Size::default(),
         }
     }
 }
 
 impl WidgetPtr {
-    pub fn new(widget: StrongWidget) -> Self {
-        Self {
-            inner: Some(widget),
-        }
+    pub fn new() -> Self {
+        Self::default()
     }
     pub fn empty() -> Self {
         Self {

src/widget/rect.rs

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

src/widget/selector.rs

@@ -1,48 +0,0 @@
-use std::hash::Hash;
-
-use iris_core::util::HashMap;
-
-use crate::prelude::*;
-
-pub struct WidgetSelector<T> {
-    current: (T, StrongWidget),
-    map: HashMap<T, StrongWidget>,
-}
-
-impl<T: Hash + Eq> WidgetSelector<T> {
-    pub fn new(key: T, widget: StrongWidget) -> Self {
-        Self {
-            current: (key, widget),
-            map: Default::default(),
-        }
-    }
-
-    pub fn set(&mut self, key: T, widget: StrongWidget) {
-        self.map.insert(key, widget);
-    }
-
-    pub fn select(&mut self, key: T) -> bool {
-        if let Some(val) = self.map.remove(&key) {
-            let mut new = (key, val);
-            std::mem::swap(&mut new, &mut self.current);
-            self.map.insert(new.0, new.1);
-            true
-        } else {
-            false
-        }
-    }
-}
-
-impl<T: 'static> Widget for WidgetSelector<T> {
-    fn draw(&mut self, painter: &mut Painter) {
-        painter.widget(&self.current.1);
-    }
-
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.width(&self.current.1)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        ctx.height(&self.current.1)
-    }
-}

src/widget/text/build.rs

@@ -1,6 +1,5 @@
 use crate::prelude::*;
-use cosmic_text::{Attrs, Family, Metrics};
-use std::marker::{PhantomData, Sized};
+use std::marker::PhantomData;
 
 pub struct TextBuilder<State, O = TextOutput, H: WidgetOption<State> = ()> {
     pub content: String,
@@ -20,7 +19,7 @@ impl<State, O, H: WidgetOption<State>> TextBuilder<State, O, H> {
         self.attrs.color = color;
         self
     }
-    pub fn family(mut self, family: Family<'static>) -> Self {
+    pub fn family(mut self, family: Family) -> Self {
         self.attrs.family = family;
         self
     }
@@ -82,19 +81,13 @@ impl<Rsc: UiRsc> TextBuilderOutput<Rsc> for TextOutput {
         state: &mut Rsc,
         builder: TextBuilder<Rsc, Self, H>,
     ) -> Self::Output {
-        let mut buf = TextBuffer::new_empty(Metrics::new(
-            builder.attrs.font_size,
-            builder.attrs.line_height,
-        ));
+        let buf = TextBuffer::new(&builder.content);
         let hint = builder.hint.get(state);
-        let font_system = &mut state.ui_mut().text.font_system;
-        buf.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
         let mut text = Text {
             content: builder.content.into(),
             view: TextView::new(buf, builder.attrs, hint),
         };
         text.content.changed = false;
-        builder.attrs.apply(font_system, &mut text.view.buf, None);
         text
     }
 }
@@ -110,19 +103,11 @@ impl<State: UiRsc> TextBuilderOutput<State> for TextEditOutput {
         state: &mut State,
         builder: TextBuilder<State, Self, H>,
     ) -> Self::Output {
-        let buf = TextBuffer::new_empty(Metrics::new(
-            builder.attrs.font_size,
-            builder.attrs.line_height,
-        ));
-        let mut text = TextEdit::new(
+        let buf = TextBuffer::new(&builder.content);
+        TextEdit::new(
             TextView::new(buf, builder.attrs, builder.hint.get(state)),
             builder.output.mode,
-        );
-        let font_system = &mut state.ui_mut().text.font_system;
-        text.buf
-            .set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
-        builder.attrs.apply(font_system, &mut text.buf, None);
-        text
+        )
     }
 }
 

src/widget/text/edit.rs

@@ -1,17 +1,30 @@
 use crate::prelude::*;
-use cosmic_text::{Affinity, Attrs, Cursor, FontSystem, LayoutRun, Motion};
+use iris_core::{TextData, UiColor};
+use parley::{Affinity, Layout, Selection};
 use std::ops::{Deref, DerefMut};
-use unicode_segmentation::UnicodeSegmentation;
 use winit::{
     event::KeyEvent,
     keyboard::{Key, NamedKey},
 };
 
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Motion {
+    Left,
+    Right,
+    LeftWord,
+    RightWord,
+    Up,
+    Down,
+    LineStart,
+    LineEnd,
+}
+
 pub struct TextEdit {
     view: TextView,
-    selection: TextSelection,
-    history: Vec<(String, TextSelection)>,
-    double_hit: Option<Cursor>,
+    /// `None` represents unfocused, which Parley's `Selection` cannot express.
+    selection: Option<Selection>,
+    history: Vec<(String, Option<Selection>)>,
+    double_hit: Option<usize>,
     pub mode: EditMode,
 }
 
@@ -25,230 +38,119 @@ impl TextEdit {
     pub fn new(view: TextView, mode: EditMode) -> Self {
         Self {
             view,
-            selection: Default::default(),
+            selection: None,
             history: Default::default(),
             double_hit: None,
             mode,
         }
     }
-    pub fn select_content(&self, start: Cursor, end: Cursor) -> String {
-        let (start, end) = sort_cursors(start, end);
-        let mut iter = self.buf.lines.iter().skip(start.line);
-        let first = iter.next().unwrap();
-        if start.line == end.line {
-            first.text()[start.index..end.index].to_string()
-        } else {
-            let mut str = first.text()[start.index..].to_string();
-            for _ in (start.line + 1)..end.line {
-                str = str + "\n" + iter.next().unwrap().text();
-            }
-            let last = iter.next().unwrap();
-            str = str + "\n" + &last.text()[..end.index];
-            str
+
+    pub fn selected_text(&self) -> Option<String> {
+        let sel = self.selection?;
+        if sel.is_collapsed() {
+            return None;
         }
+        Some(self.buf.text()[sel.text_range()].to_string())
     }
 }
 
 impl Widget for TextEdit {
-    fn draw(&mut self, painter: &mut Painter) {
+    fn draw(&mut self, painter: &mut Painter) -> Size {
         let base = painter.layer;
         painter.child_layer();
-        self.view.draw(painter);
+        let (_, size) = self.view.draw(painter);
         painter.layer = base;
         let region = self.region();
 
-        let size = vec2(1, self.attrs.line_height);
-        match self.selection {
-            TextSelection::None => (),
-            TextSelection::Pos(cursor) => {
-                if let Some(offset) = cursor_pos(cursor, &self.buf) {
-                    painter.primitive_within(
-                        RectPrimitive::color(Color::WHITE),
-                        size.align(Align::TOP_LEFT).offset(offset).within(&region),
-                    );
-                }
-            }
-            TextSelection::Span { start, end } => {
-                let (start, end) = sort_cursors(start, end);
-                for (l, x, width) in iter_layout_lines(start, end, &self.buf) {
-                    let top_left = vec2(x, self.attrs.line_height * l as f32);
-                    painter.primitive_within(
-                        RectPrimitive::color(Color::SKY),
-                        size.with_x(width)
-                            .align(Align::TOP_LEFT)
-                            .offset(top_left)
-                            .within(&region),
-                    );
-                }
-                if let Some(end_offset) = cursor_pos(end, &self.buf) {
-                    painter.primitive_within(
-                        RectPrimitive::color(Color::WHITE),
-                        size.align(Align::TOP_LEFT)
-                            .offset(end_offset)
-                            .within(&region),
-                    );
-                }
-            }
+        let Some(selection) = self.selection else {
+            return size;
+        };
+        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 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),
+            );
         }
+
+        let caret = selection.focus().geometry(layout, CARET_WIDTH);
+        let caret_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
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.view.desired_width(ctx)
-    }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.view.desired_height(ctx)
+    fn on_resize(&self, axis: Axis) -> OnResize {
+        self.view.on_resize(axis)
     }
 }
 
-/// provides top left + width
-fn iter_layout_lines(
-    start: Cursor,
-    end: Cursor,
-    buf: &TextBuffer,
-) -> impl Iterator<Item = (usize, f32, f32)> {
-    gen move {
-        let mut iter = buf.layout_runs().enumerate();
-        for (i, line) in iter.by_ref() {
-            if line.line_i == start.line
-                && let Some(start_x) = index_x(&line, start.index)
-            {
-                if start.line == end.line
-                    && let Some(end_x) = index_x(&line, end.index)
-                {
-                    yield (i, start_x, end_x - start_x);
-                    return;
-                }
-                yield (i, start_x, line.line_w - start_x);
-                break;
-            }
-        }
-        for (i, line) in iter {
-            if line.line_i > end.line {
-                return;
-            }
-            if line.line_i == end.line
-                && let Some(end_x) = index_x(&line, end.index)
-            {
-                yield (i, 0.0, end_x);
-                return;
-            }
-            yield (i, 0.0, line.line_w);
-        }
-    }
-}
-
-/// copied & modified from fn found in Editor in cosmic_text
-/// returns x pos of a (non layout) index within an layout run
-fn index_x(run: &LayoutRun, index: usize) -> Option<f32> {
-    for glyph in run.glyphs.iter() {
-        if index == glyph.start {
-            return Some(glyph.x);
-        } else if index > glyph.start && index < glyph.end {
-            // Guess x offset based on characters
-            let mut before = 0;
-            let mut total = 0;
-
-            let cluster = &run.text[glyph.start..glyph.end];
-            for (i, _) in cluster.grapheme_indices(true) {
-                if glyph.start + i < index {
-                    before += 1;
-                }
-                total += 1;
-            }
-
-            let offset = glyph.w * (before as f32) / (total as f32);
-            return Some(glyph.x + offset);
-        }
-    }
-    None
-}
-
-/// returns top of line segment where cursor should visually select
-fn cursor_pos(cursor: Cursor, buf: &TextBuffer) -> Option<Vec2> {
-    let mut prev = None;
-    for run in buf
-        .layout_runs()
-        .skip_while(|r| r.line_i < cursor.line)
-        .take_while(|r| r.line_i == cursor.line)
-    {
-        prev = Some(vec2(run.line_w, run.line_top));
-        if let Some(pos) = index_x(&run, cursor.index) {
-            return Some(vec2(pos, run.line_top));
-        }
-    }
-    prev
-}
+const CARET_WIDTH: f32 = 1.0;
 
 pub struct TextEditCtx<'a> {
     pub text: &'a mut TextEdit,
-    pub font_system: &'a mut FontSystem,
+    pub data: &'a mut TextData,
 }
 
 impl<'a> TextEditCtx<'a> {
+    fn layout(&mut self) -> &Layout<UiColor> {
+        let attrs = self.text.view.attrs.clone();
+        let width = self.text.view.wrap_width();
+        self.text.view.buf.shape(self.data, &attrs, width);
+        self.text.view.buf.layout()
+    }
+
+    fn clamp_selection_to_layout(&mut self) {
+        if let Some(sel) = self.text.selection {
+            let layout = self.layout();
+            self.text.selection = Some(sel.refresh(layout));
+        }
+    }
+
     pub fn take(&mut self) -> String {
-        let text = self
-            .text
-            .buf
-            .lines
-            .drain(..)
-            .map(|l| l.into_text())
-            .collect::<Vec<_>>()
-            .join("\n");
-        self.text
-            .buf
-            .set_text(self.font_system, "", &Attrs::new(), SHAPING, None);
-        self.text.selection.clear();
+        let text = std::mem::take(self.text.view.buf.edit());
+        self.text.selection = None;
         text
     }
 
     pub fn set(&mut self, text: &str) {
         let text = self.string(text);
-        self.text
-            .buf
-            .set_text(self.font_system, &text, &Attrs::new(), SHAPING, None);
-        self.text.selection.clear();
+        self.text.view.buf.set_text(text);
+        self.text.view.buf.changed = true;
+        self.text.selection = None;
     }
 
     pub fn motion(&mut self, motion: Motion, select: bool) {
-        if let TextSelection::Pos(cursor) = self.text.selection
-            && let Some(new) = self.buf_motion(cursor, motion)
-        {
-            if select {
-                self.text.selection = TextSelection::Span {
-                    start: cursor,
-                    end: new,
-                };
-            } else {
-                self.text.selection = TextSelection::Pos(new);
-            }
-        } else if let TextSelection::Span { start, end } = self.text.selection {
-            if select {
-                if let Some(cursor) = self.buf_motion(end, motion) {
-                    self.text.selection = TextSelection::Span { start, end: cursor };
-                }
-            } else {
-                let (start, end) = sort_cursors(start, end);
-                let sel = &mut self.text.selection;
-                match motion {
-                    Motion::Left | Motion::LeftWord => *sel = TextSelection::Pos(start),
-                    Motion::Right | Motion::RightWord => *sel = TextSelection::Pos(end),
-                    _ => {
-                        if let Some(cursor) = self.buf_motion(end, motion) {
-                            self.text.selection = TextSelection::Pos(cursor);
-                        }
-                    }
-                }
-            }
-        }
+        let Some(sel) = self.text.selection else {
+            return;
+        };
+        let layout = self.layout();
+        let sel = apply_motion(sel, layout, motion, select);
+        self.text.selection = Some(sel);
     }
 
+    /// Replace the `len` characters before the caret. This is the IME's
+    /// preedit path: it re-sends the whole composition each time.
     pub fn replace(&mut self, len: usize, text: &str) {
         let text = self.string(text);
         for _ in 0..len {
-            self.delete(false);
+            self.backspace(false);
         }
-        self.insert_inner(&text, false);
+        self.insert_str(&text);
     }
 
     fn string(&self, text: &str) -> String {
@@ -261,202 +163,173 @@ impl<'a> TextEditCtx<'a> {
 
     pub fn insert(&mut self, text: &str) {
         let text = self.string(text);
-        let mut lines = text.split('\n');
-        let Some(first) = lines.next() else {
+        self.insert_str(&text);
+    }
+
+    fn insert_str(&mut self, text: &str) {
+        if text.is_empty() {
             return;
-        };
-        self.insert_inner(first, true);
-        for line in lines {
-            self.newline();
-            self.insert_inner(line, true);
         }
+        self.clear_span();
+        let at = match self.text.selection {
+            Some(sel) => sel.focus().index(),
+            None => return,
+        };
+        let at = at.min(self.text.view.buf.text().len());
+        self.text.view.buf.edit().insert_str(at, text);
+        self.text.view.buf.changed = true;
+        self.set_caret(at + text.len());
     }
 
     pub fn clear_span(&mut self) -> bool {
-        if let TextSelection::Span { start, end } = self.text.selection {
-            self.delete_between(start, end);
-            let (start, _) = sort_cursors(start, end);
-            self.text.selection = TextSelection::Pos(start);
-            true
-        } else {
-            false
+        let Some(sel) = self.text.selection else {
+            return false;
+        };
+        if sel.is_collapsed() {
+            return false;
         }
+        let range = sel.text_range();
+        self.text.view.buf.edit().replace_range(range.clone(), "");
+        self.text.view.buf.changed = true;
+        self.set_caret(range.start);
+        true
     }
 
-    pub fn delete_between(&mut self, start: Cursor, end: Cursor) {
-        let lines = &mut self.text.view.buf.lines;
-        let (start, end) = sort_cursors(start, end);
-        if start.line == end.line {
-            let line = &mut lines[start.line];
-            let text = line.text();
-            let text = text[..start.index].to_string() + &text[end.index..];
-            edit_line(line, text);
-        } else {
-            // start
-            let start_text = lines[start.line].text()[..start.index].to_string();
-            let end_text = &lines[end.line].text()[end.index..];
-            let text = start_text + end_text;
-            edit_line(&mut lines[start.line], text);
-        }
-        // between
-        let range = (start.line + 1)..=end.line;
-        if !range.is_empty() {
-            lines.splice(range, None);
-        }
-    }
-
-    fn insert_inner(&mut self, text: &str, mov: bool) {
-        self.clear_span();
-        if let TextSelection::Pos(cursor) = &mut self.text.selection {
-            let line = &mut self.text.view.buf.lines[cursor.line];
-            let mut line_text = line.text().to_string();
-            line_text.insert_str(cursor.index, text);
-            edit_line(line, line_text);
-            if mov {
-                for _ in 0..text.chars().count() {
-                    self.motion(Motion::Right, false);
-                }
-            }
-        }
+    fn set_caret(&mut self, index: usize) {
+        let index = index.min(self.text.view.buf.text().len());
+        let layout = self.layout();
+        self.text.selection = Some(Selection::from_byte_index(
+            layout,
+            index,
+            Affinity::default(),
+        ));
     }
 
     pub fn newline(&mut self) {
-        if self.text.mode == EditMode::SingleLine {
-            return;
-        }
-        self.clear_span();
-        if let TextSelection::Pos(cursor) = &mut self.text.selection {
-            let lines = &mut self.text.view.buf.lines;
-            let line = &mut lines[cursor.line];
-            let new = line.split_off(cursor.index);
-            cursor.line += 1;
-            lines.insert(cursor.line, new);
-            cursor.index = 0;
+        if self.text.mode == EditMode::MultiLine {
+            self.insert_str("\n");
         }
     }
 
     pub fn backspace(&mut self, word: bool) {
-        if !self.clear_span()
-            && let TextSelection::Pos(cursor) = &mut self.text.selection
-            && (cursor.index != 0 || cursor.line != 0)
-        {
-            self.motion(if word { Motion::LeftWord } else { Motion::Left }, false);
-            self.delete(word);
+        if self.clear_span() {
+            return;
         }
+        let Some(sel) = self.text.selection else {
+            return;
+        };
+        let end = sel.focus().index();
+        if end == 0 {
+            return;
+        }
+        let layout = self.layout();
+        let start = if word {
+            sel.focus().previous_logical_word(layout).index()
+        } else {
+            let Some(cluster) = sel.focus().logical_clusters(layout)[0] else {
+                return;
+            };
+            let range = cluster.text_range();
+            if cluster.is_hard_line_break() || cluster.is_emoji() {
+                range.start
+            } else {
+                self.text.view.buf.text()[..range.end]
+                    .char_indices()
+                    .next_back()
+                    .map_or(range.start, |(start, _)| start)
+            }
+        };
+        self.delete_range(start, end);
     }
 
     pub fn delete(&mut self, word: bool) {
-        if !self.clear_span()
-            && let TextSelection::Pos(cursor) = &mut self.text.selection
-        {
-            if word {
-                let start = *cursor;
-                if let Some(end) = self.buf_motion(start, Motion::RightWord) {
-                    self.delete_between(start, end);
-                }
-            } else {
-                let lines = &mut self.text.view.buf.lines;
-                let line = &mut lines[cursor.line];
-                if cursor.index == line.text().len() {
-                    if cursor.line == lines.len() - 1 {
-                        return;
-                    }
-                    let add = lines.remove(cursor.line + 1).into_text();
-                    let line = &mut lines[cursor.line];
-                    let mut cur = line.text().to_string();
-                    cur.push_str(&add);
-                    edit_line(line, cur);
-                } else {
-                    let mut text = line.text().to_string();
-                    text.remove(cursor.index);
-                    edit_line(line, text);
-                }
-            }
+        if self.clear_span() {
+            return;
         }
+        let Some(sel) = self.text.selection else {
+            return;
+        };
+        let start = sel.focus().index();
+        if start >= self.text.view.buf.text().len() {
+            return;
+        }
+        let layout = self.layout();
+        let end = if word {
+            sel.focus().next_logical_word(layout).index()
+        } else {
+            let clusters = sel.focus().logical_clusters(layout);
+            let Some(cluster) = clusters[1].as_ref() else {
+                return;
+            };
+            cluster.text_range().end
+        };
+        self.delete_range(start, end);
     }
 
-    fn buf_motion(&mut self, cursor: Cursor, motion: Motion) -> Option<Cursor> {
-        self.text
-            .buf
-            .cursor_motion(self.font_system, cursor, None, motion)
-            .map(|r| r.0)
+    fn delete_range(&mut self, start: usize, end: usize) {
+        self.text.view.buf.edit().replace_range(start..end, "");
+        self.text.view.buf.changed = true;
+        self.set_caret(start);
     }
 
-    pub fn select_word_at(&mut self, cursor: Cursor) {
-        if let (Some(start), Some(end)) = (
-            self.buf_motion(cursor, Motion::LeftWord),
-            self.buf_motion(cursor, Motion::RightWord),
-        ) {
-            self.text.selection = TextSelection::Span { start, end };
-        }
-    }
-
-    pub fn select_line_at(&mut self, cursor: Cursor) {
-        let end = self.text.buf.lines[cursor.line].text().len();
-        self.text.selection = TextSelection::Span {
-            start: Cursor::new(cursor.line, 0),
-            end: Cursor::new(cursor.line, end),
+    pub fn select_all(&mut self) {
+        let len = self.text.view.buf.text().len();
+        if len == 0 {
+            return;
         }
+        let layout = self.layout();
+        let anchor = parley::Cursor::from_byte_index(layout, 0, Affinity::default());
+        let focus = parley::Cursor::from_byte_index(layout, len, Affinity::default());
+        self.text.selection = Some(Selection::new(anchor, focus));
     }
 
     pub fn select(&mut self, pos: Vec2, size: Vec2, drag: bool, recent: bool) {
         let pos = pos - self.text.region().top_left().to_abs(size);
-        let hit = self.text.buf.hit(pos.x, pos.y);
-        let sel = &mut self.text.selection;
-        match sel {
-            TextSelection::None => {
-                if !drag && let Some(hit) = hit {
-                    *sel = TextSelection::Pos(hit)
-                }
+        let prev_sel = self.text.selection;
+        let prev_hit = self.text.double_hit;
+
+        let layout = self.layout();
+        let (selection, double_hit) = if drag {
+            let Some(selection) = prev_sel else {
+                return;
+            };
+            (selection.extend_to_point(layout, pos.x, pos.y), prev_hit)
+        } else {
+            let hit = Selection::from_point(layout, pos.x, pos.y);
+            let index = hit.focus().index();
+            // Successive clicks at one index select the word, then the line.
+            if recent && prev_hit == Some(index) {
+                (Selection::line_from_point(layout, pos.x, pos.y), None)
+            } else if recent && prev_sel.map(|s| s.focus().index()) == Some(index) {
+                (
+                    Selection::word_from_point(layout, pos.x, pos.y),
+                    Some(index),
+                )
+            } else {
+                (hit, None)
             }
-            TextSelection::Pos(pos) => match (hit, drag) {
-                (None, false) => *sel = TextSelection::None,
-                (None, true) => (),
-                (Some(hit), false) => {
-                    if recent && hit == *pos {
-                        self.text.double_hit = Some(hit);
-                        return self.select_word_at(hit);
-                    } else {
-                        *pos = hit
-                    }
-                }
-                (Some(end), true) => *sel = TextSelection::Span { start: *pos, end },
-            },
-            TextSelection::Span { start, end } => match (hit, drag) {
-                (None, false) => *sel = TextSelection::None,
-                (None, true) => *sel = TextSelection::Pos(*start),
-                (Some(hit), false) => {
-                    if recent
-                        && let Some(double) = self.text.double_hit
-                        && double == hit
-                    {
-                        return self.select_line_at(hit);
-                    } else {
-                        *sel = TextSelection::Pos(hit)
-                    }
-                }
-                (Some(hit), true) => *end = hit,
-            },
-        }
-        if let TextSelection::Span { start, end } = sel
-            && start == end
-        {
-            *sel = TextSelection::Pos(*start);
-        }
+        };
+
+        self.text.selection = Some(selection);
+        self.text.double_hit = double_hit;
     }
 
     pub fn deselect(&mut self) {
-        self.text.selection = TextSelection::None;
+        self.text.selection = None;
+        self.text.double_hit = None;
     }
 
     pub fn apply_event(&mut self, event: &KeyEvent, modifiers: &Modifiers) -> TextInputResult {
-        let old = (self.text.content(), self.text.selection);
+        let old = (self.text.view.buf.text().to_string(), self.text.selection);
         let mut undo = false;
         let res = self.apply_event_inner(event, modifiers, &mut undo);
-        if undo && let Some((old, selection)) = self.text.history.pop() {
-            self.set(&old);
-            self.text.selection = selection;
-        } else if self.text.content() != old.0 {
+        if undo {
+            if let Some((old, selection)) = self.text.history.pop() {
+                self.set(&old);
+                self.text.selection = selection;
+                self.clamp_selection_to_layout();
+            }
+        } else if self.text.view.buf.text() != old.0 {
             self.text.history.push(old);
         }
         res
@@ -481,21 +354,25 @@ impl<'a> TextEditCtx<'a> {
                     }
                 }
                 NamedKey::ArrowRight => {
-                    if modifiers.control {
-                        self.motion(Motion::RightWord, modifiers.shift)
+                    let motion = if modifiers.control {
+                        Motion::RightWord
                     } else {
-                        self.motion(Motion::Right, modifiers.shift)
-                    }
+                        Motion::Right
+                    };
+                    self.motion(motion, modifiers.shift);
                 }
                 NamedKey::ArrowLeft => {
-                    if modifiers.control {
-                        self.motion(Motion::LeftWord, modifiers.shift)
+                    let motion = if modifiers.control {
+                        Motion::LeftWord
                     } else {
-                        self.motion(Motion::Left, modifiers.shift)
-                    }
+                        Motion::Left
+                    };
+                    self.motion(motion, modifiers.shift);
                 }
                 NamedKey::ArrowUp => self.motion(Motion::Up, modifiers.shift),
                 NamedKey::ArrowDown => self.motion(Motion::Down, modifiers.shift),
+                NamedKey::Home => self.motion(Motion::LineStart, modifiers.shift),
+                NamedKey::End => self.motion(Motion::LineEnd, modifiers.shift),
                 NamedKey::Escape => {
                     self.deselect();
                     return TextInputResult::Unfocus;
@@ -507,34 +384,18 @@ impl<'a> TextEditCtx<'a> {
                     match text.as_str() {
                         "v" => return TextInputResult::Paste,
                         "c" => {
-                            if let TextSelection::Span { start, end } = self.text.selection {
-                                let content = self.text.select_content(start, end);
+                            if let Some(content) = self.text.selected_text() {
                                 return TextInputResult::Copy(content);
                             }
                         }
                         "x" => {
-                            if let TextSelection::Span { start, end } = self.text.selection {
-                                let content = self.text.select_content(start, end);
+                            if let Some(content) = self.text.selected_text() {
                                 self.clear_span();
                                 return TextInputResult::Copy(content);
                             }
                         }
-                        "a" => {
-                            if !self.text.buf.lines[0].text().is_empty()
-                                || self.text.buf.lines.len() > 1
-                            {
-                                let lines = &self.text.buf.lines;
-                                let last_line = lines.len() - 1;
-                                let last_idx = lines[last_line].text().len();
-                                self.text.selection = TextSelection::Span {
-                                    start: Cursor::new(0, 0),
-                                    end: Cursor::new(last_line, last_idx),
-                                };
-                            }
-                        }
-                        "z" => {
-                            *undo = true;
-                        }
+                        "a" => self.select_all(),
+                        "z" => *undo = true,
                         _ => self.insert(text),
                     }
                 } else {
@@ -547,6 +408,24 @@ impl<'a> TextEditCtx<'a> {
     }
 }
 
+fn apply_motion(
+    sel: Selection,
+    layout: &Layout<UiColor>,
+    motion: Motion,
+    extend: bool,
+) -> Selection {
+    match motion {
+        Motion::Left => sel.previous_visual(layout, extend),
+        Motion::Right => sel.next_visual(layout, extend),
+        Motion::LeftWord => sel.previous_visual_word(layout, extend),
+        Motion::RightWord => sel.next_visual_word(layout, extend),
+        Motion::Up => sel.previous_line(layout, extend),
+        Motion::Down => sel.next_line(layout, extend),
+        Motion::LineStart => sel.line_start(layout, extend),
+        Motion::LineEnd => sel.line_end(layout, extend),
+    }
+}
+
 #[derive(Default)]
 pub struct Modifiers {
     pub shift: bool,
@@ -569,33 +448,6 @@ pub enum TextInputResult {
     Paste,
 }
 
-#[derive(Debug, Default, Clone, Copy)]
-pub enum TextSelection {
-    #[default]
-    None,
-    Pos(Cursor),
-    Span {
-        start: Cursor,
-        end: Cursor,
-    },
-}
-
-impl TextSelection {
-    pub fn clear(&mut self) {
-        match self {
-            TextSelection::None => (),
-            TextSelection::Pos(cursor) => {
-                cursor.line = 0;
-                cursor.index = 0;
-                cursor.affinity = Affinity::default();
-            }
-            TextSelection::Span { start: _, end: _ } => {
-                *self = TextSelection::None;
-            }
-        }
-    }
-}
-
 impl TextInputResult {
     pub fn unfocus(&self) -> bool {
         matches!(self, TextInputResult::Unfocus)
@@ -625,7 +477,7 @@ impl<I: IdLike<Widget = TextEdit>> TextEditable for I {
         let ui = ui.ui_mut();
         TextEditCtx {
             text: ui.widgets.get_mut(self).unwrap(),
-            font_system: &mut ui.text.font_system,
+            data: &mut ui.text,
         }
     }
 }

src/widget/text/mod.rs

@@ -6,11 +6,8 @@ pub use edit::*;
 use iris_core::util::MutDetect;
 
 use crate::prelude::*;
-use cosmic_text::{Attrs, BufferLine, Cursor, Metrics, Shaping};
 use std::ops::{Deref, DerefMut};
 
-pub const SHAPING: Shaping = Shaping::Advanced;
-
 pub struct Text {
     pub content: MutDetect<String>,
     view: TextView,
@@ -25,6 +22,16 @@ pub struct TextView {
     pub hint: Option<StrongWidget>,
 }
 
+impl TextView {
+    fn is_empty(&self) -> bool {
+        self.buf.is_empty()
+    }
+
+    pub fn wrap_width(&self) -> Option<f32> {
+        self.width
+    }
+}
+
 impl TextView {
     pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option<StrongWidget>) -> Self {
         Self {
@@ -45,133 +52,89 @@ impl TextView {
             .align(self.align)
     }
 
-    fn tex_region(&self, tex: &RenderedText) -> UiRegion {
-        let region = tex.size.align(self.align);
-        let dims = tex.handle.size();
-        let mut region = region.offset(tex.top_left_offset);
-        region.x.end = region.x.start + UiScalar::abs(dims.x);
-        region.y.end = region.y.start + UiScalar::abs(dims.y);
-        region
-    }
-
-    fn render(&mut self, ctx: &mut SizeCtx) -> RenderedText {
+    fn render(&mut self, painter: &mut Painter) -> &RenderedText {
         let width = if self.attrs.wrap {
-            Some(ctx.px_size().x)
+            Some(painter.px_size().x)
         } else {
             None
         };
-        if width == self.width
-            && let Some(tex) = &self.tex
-            && !self.attrs.changed
-            && !self.buf.changed
-        {
-            return tex.clone();
+        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.attrs.changed = false;
+            self.buf.changed = false;
         }
-        self.width = width;
-        let font_system = &mut ctx.text.font_system;
-        self.attrs.apply(font_system, &mut self.buf, width);
-        self.buf.shape_until_scroll(font_system, false);
-        let tex = ctx.draw_text(&mut self.buf, &self.attrs);
-        self.tex = Some(tex.clone());
-        self.attrs.changed = false;
-        self.buf.changed = false;
-        tex
+        self.tex.as_ref().unwrap()
     }
     pub fn tex(&self) -> Option<&RenderedText> {
         self.tex.as_ref()
     }
-    pub fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(hint) = &self.hint
-            && let [line] = &self.buf.lines[..]
-            && line.text().is_empty()
-        {
-            ctx.width(hint)
-        } else {
-            Len::abs(self.render(ctx).size.x)
+    /// Draws the text, and says where the glyphs went and what they use.
+    pub fn draw(&mut self, painter: &mut Painter) -> (UiRegion, Size) {
+        let align = self.align;
+        if self.is_empty() && self.hint.is_some() {
+            let region = self.render(painter).size.align(align);
+            let size = match &self.hint {
+                Some(hint) => painter.widget(hint).size(),
+                None => Size::ZERO,
+            };
+            return (region, size);
         }
+
+        let tex = self.render(painter);
+        let region = tex.size.align(align);
+        let size = Size::abs(tex.size);
+        let within = region.within(&painter.region());
+        painter.glyphs(tex, within);
+        (region, size)
     }
-    pub fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        if let Some(hint) = &self.hint
-            && let [line] = &self.buf.lines[..]
-            && line.text().is_empty()
-        {
-            ctx.height(hint)
-        } else {
-            Len::abs(self.render(ctx).size.y)
+
+    /// 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,
         }
     }
-    pub fn draw(&mut self, painter: &mut Painter) -> UiRegion {
-        let tex = self.render(&mut painter.size_ctx());
-        let region = self.tex_region(&tex);
-        if let Some(hint) = &self.hint
-            && let [line] = &self.buf.lines[..]
-            && line.text().is_empty()
-        {
-            painter.widget(hint);
-        } else {
-            painter.texture_within(&tex.handle, region);
-        }
-        region
-    }
 
     pub fn content(&self) -> String {
-        self.buf
-            .lines
-            .iter()
-            .map(|l| l.text())
-            .collect::<Vec<_>>()
-            .join("\n")
+        self.buf.text().to_string()
     }
 }
 
 impl Text {
     pub fn new(content: impl Into<String>) -> Self {
-        let attrs = TextAttrs::default();
-        let buf = TextBuffer::new_empty(Metrics::new(attrs.font_size, attrs.line_height));
+        let content: String = content.into();
         Self {
-            content: content.into().into(),
-            view: TextView::new(buf, attrs, None),
+            view: TextView::new(TextBuffer::new(&content), TextAttrs::default(), None),
+            content: content.into(),
         }
     }
-    fn update_buf(&mut self, ctx: &mut SizeCtx) {
+    fn update_buf(&mut self) {
         if self.content.changed {
             self.content.changed = false;
-            self.view.buf.set_text(
-                &mut ctx.text.font_system,
-                &self.content,
-                &Attrs::new().family(self.view.attrs.family),
-                SHAPING,
-                None,
-            );
+            self.view.buf.set_text(self.content.as_str());
         }
     }
 }
 
 impl Widget for Text {
-    fn draw(&mut self, painter: &mut Painter) {
-        self.update_buf(&mut painter.size_ctx());
-        self.view.draw(painter);
+    fn draw(&mut self, painter: &mut Painter) -> Size {
+        self.update_buf();
+        self.view.draw(painter).1
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.update_buf(ctx);
-        self.view.desired_width(ctx)
+    fn on_resize(&self, axis: Axis) -> OnResize {
+        self.view.on_resize(axis)
     }
-
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
-        self.update_buf(ctx);
-        self.view.desired_height(ctx)
-    }
-}
-
-pub fn sort_cursors(a: Cursor, b: Cursor) -> (Cursor, Cursor) {
-    let start = a.min(b);
-    let end = a.max(b);
-    (start, end)
-}
-
-pub fn edit_line(line: &mut BufferLine, text: String) {
-    line.set_text(text, line.ending(), line.attrs_list().clone());
 }
 
 impl Deref for Text {

src/widget/trait_fns.rs

@@ -31,9 +31,9 @@ widget_trait! {
         }
     }
 
-    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, Sized> {
+    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, SetSize> {
         let size = size.into();
-        move |state| Sized {
+        move |state| SetSize {
             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, Sized> {
+    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
         let len = len.into();
-        move |state| Sized {
+        move |state| SetSize {
             inner: self.add_strong(state),
             x: Some(len),
             y: None,
         }
     }
 
-    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
+    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, SetSize> {
         let len = len.into();
-        move |state| Sized {
+        move |state| SetSize {
             inner: self.add_strong(state),
             x: None,
             y: Some(len),
@@ -131,61 +131,18 @@ widget_trait! {
     }
 }
 
-pub trait CoreWidgetArr<Children, Rsc, Tag, GTag> {
-    fn span(self, dir: Dir) -> SpanBuilder<Children, Rsc, Tag, GTag>;
-    fn stack(self) -> StackBuilder<Children, Rsc, Tag, GTag>;
+pub trait CoreWidgetArr<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> {
+    fn span(self, dir: Dir) -> SpanBuilder<Rsc, LEN, Wa, Tag>;
+    fn stack(self) -> StackBuilder<Rsc, LEN, Wa, Tag>;
 }
 
-impl<Children: IntoWidgetVec<Rsc, Tag, GTag>, Rsc, Tag, GTag>
-    CoreWidgetArr<Children, Rsc, Tag, GTag> for Children
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    CoreWidgetArr<State, LEN, Wa, Tag> for Wa
 {
-    fn span(self, dir: Dir) -> SpanBuilder<Children, Rsc, Tag, GTag> {
+    fn span(self, dir: Dir) -> SpanBuilder<State, LEN, Wa, Tag> {
         SpanBuilder::new(self, dir)
     }
-    fn stack(self) -> StackBuilder<Children, Rsc, Tag, GTag> {
+    fn stack(self) -> StackBuilder<State, LEN, Wa, Tag> {
         StackBuilder::new(self)
     }
 }
-
-pub trait RscFnMap<Rsc> {
-    type Input;
-    fn rsc_map<O>(
-        self,
-        f: impl Fn(Self::Input, &mut Rsc) -> O + Clone,
-    ) -> impl Iterator<Item = impl FnOnce(&mut Rsc) -> O>;
-}
-
-impl<I: IntoIterator, Rsc> RscFnMap<Rsc> for I {
-    type Input = I::Item;
-    fn rsc_map<O>(
-        self,
-        f: impl Fn(Self::Input, &mut Rsc) -> O + Clone,
-    ) -> impl Iterator<Item = impl FnOnce(&mut Rsc) -> O> {
-        self.into_iter().map(move |i| {
-            let f = f.clone();
-            move |rsc: &mut Rsc| f(i, rsc)
-        })
-    }
-}
-
-pub trait WidgetFnMap<Rsc: UiRsc> {
-    fn widget_map<O: WidgetLike<Rsc, Tag>, Tag>(
-        self,
-        f: impl Fn(WeakWidget) -> O + Clone,
-    ) -> impl Iterator<Item = impl FnOnce(&mut Rsc) -> WeakWidget>;
-}
-
-impl<I: IntoIterator, Rsc: UiRsc> WidgetFnMap<Rsc> for I
-where
-    I::Item: WidgetIdFn<Rsc>,
-{
-    fn widget_map<O: WidgetLike<Rsc, Tag>, Tag>(
-        self,
-        f: impl Fn(WeakWidget) -> O + Clone,
-    ) -> impl Iterator<Item = impl FnOnce(&mut Rsc) -> WeakWidget> {
-        self.into_iter().map(move |f2| {
-            let f = f.clone();
-            move |rsc: &mut Rsc| f(f2(rsc)).add(rsc) as WeakWidget
-        })
-    }
-}

tests/draw_cost.rs

@@ -0,0 +1,205 @@
+//! What one frame of `UiRenderNode::draw` costs on the CPU, against the number
+//! of layers it walks. Recording only: the pass is built and dropped without
+//! being submitted, so this is the loop's cost and not the GPU's.
+//!
+//!     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:
+//!
+//!     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.
+//!
+//! The instance is leaked deliberately. A Vulkan loader may unload the driver
+//! when the last one drops, which can fault as a thread that used it exits --
+//! and every test runs on a spawned thread.
+
+use std::time::Instant;
+
+use iris::prelude::*;
+use iris_core::{
+    GlyphPrimitive, MaskIdx, PrimitiveInst, RectPrimitive, TextureHandle, TexturePrimitive, UiData,
+    UiRegion, UiRenderNode, UiRenderState,
+};
+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.
+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());
+    let instance = match pollster::block_on(all.request_adapter(&RequestAdapterOptions::default()))
+    {
+        Ok(_) => all,
+        Err(_) => Instance::new(InstanceDescriptor {
+            backends: Backends::GL,
+            ..InstanceDescriptor::new_without_display_handle()
+        }),
+    };
+    // Leaked rather than dropped: see the note at the top of the file.
+    let instance: &'static Instance = Box::leak(Box::new(instance));
+    let adapter =
+        pollster::block_on(instance.request_adapter(&RequestAdapterOptions::default())).ok()?;
+    println!("adapter: {:?}", adapter.get_info());
+    pollster::block_on(adapter.request_device(&DeviceDescriptor::default())).ok()
+}
+
+fn config(format: TextureFormat) -> SurfaceConfiguration {
+    SurfaceConfiguration {
+        usage: TextureUsages::RENDER_ATTACHMENT,
+        format,
+        color_space: SurfaceColorSpace::Auto,
+        width: SIZE,
+        height: SIZE,
+        present_mode: PresentMode::Fifo,
+        desired_maximum_frame_latency: 2,
+        alpha_mode: CompositeAlphaMode::Auto,
+        view_formats: vec![],
+    }
+}
+
+/// Every layer draws all three primitives, so the renderer takes a different
+/// path for each list it walks -- which is the case a single-primitive layer
+/// would never exercise. Images are bound per instance, so there are few.
+fn fill(
+    ui: &mut UiData,
+    render: &mut UiRenderState,
+    layers: usize,
+    per_layer: usize,
+) -> Vec<TextureHandle> {
+    let rect = ui.primitives.kind::<RectPrimitive>();
+    let glyph = ui.primitives.kind::<GlyphPrimitive>();
+    let texture = ui.primitives.kind::<TexturePrimitive>();
+    let id = ui.widgets.add_strong(Rect::new(UiColor::WHITE)).id();
+    let handles: Vec<_> = (0..4)
+        .map(|_| ui.textures.add(image::RgbaImage::new(4, 4)))
+        .collect();
+
+    let mut layer = 0;
+    for _ in 0..layers {
+        for _ in 0..per_layer {
+            render.layers.write(
+                layer,
+                PrimitiveInst {
+                    kind: rect,
+                    id,
+                    primitive: RectPrimitive::color(UiColor::WHITE),
+                    region: UiRegion::FULL,
+                    mask_idx: MaskIdx::NONE,
+                },
+            );
+            render.layers.write(
+                layer,
+                PrimitiveInst {
+                    kind: glyph,
+                    id,
+                    primitive: GlyphPrimitive {
+                        uv_min: vec2(0.0, 0.0),
+                        uv_max: vec2(1.0, 1.0),
+                        layer: 0,
+                        color: UiColor::WHITE,
+                        flags: 0,
+                    },
+                    region: UiRegion::FULL,
+                    mask_idx: MaskIdx::NONE,
+                },
+            );
+        }
+        for h in &handles[..2] {
+            render.layers.write(
+                layer,
+                PrimitiveInst {
+                    kind: texture,
+                    id,
+                    primitive: TexturePrimitive::from(h),
+                    region: UiRegion::FULL,
+                    mask_idx: MaskIdx::NONE,
+                },
+            );
+        }
+        layer = render.layers.next(layer);
+    }
+    handles
+}
+
+fn frame_cost(device: &Device, queue: &Queue, layers: usize, per_layer: usize) -> f64 {
+    let format = TextureFormat::Bgra8Unorm;
+    let mut node = UiRenderNode::new(device, &config(format));
+    let mut ui = UiData::default();
+    let mut render = UiRenderState::new();
+    let _handles = fill(&mut ui, &mut render, layers, per_layer);
+    node.update(device, queue, &mut ui, &mut render);
+
+    let target = device.create_texture(&TextureDescriptor {
+        label: Some("draw cost"),
+        size: Extent3d {
+            width: SIZE,
+            height: SIZE,
+            depth_or_array_layers: 1,
+        },
+        mip_level_count: 1,
+        sample_count: 1,
+        dimension: TextureDimension::D2,
+        format,
+        usage: TextureUsages::RENDER_ATTACHMENT,
+        view_formats: &[],
+    });
+    let view = target.create_view(&TextureViewDescriptor::default());
+
+    let record = |frames: u32| {
+        let start = Instant::now();
+        for _ in 0..frames {
+            let mut encoder = device.create_command_encoder(&CommandEncoderDescriptor::default());
+            {
+                let pass = &mut encoder.begin_render_pass(&RenderPassDescriptor {
+                    color_attachments: &[Some(RenderPassColorAttachment {
+                        view: &view,
+                        resolve_target: None,
+                        ops: Operations {
+                            load: LoadOp::Clear(GpuColor::BLACK),
+                            store: StoreOp::Store,
+                        },
+                        depth_slice: None,
+                    })],
+                    ..Default::default()
+                });
+                node.draw(pass);
+            }
+            drop(encoder.finish());
+        }
+        start.elapsed().as_secs_f64() / frames as f64
+    };
+    record(FRAMES / 4);
+    (0..BATCHES)
+        .map(|_| record(FRAMES))
+        .fold(f64::MAX, f64::min)
+}
+
+#[test]
+#[ignore = "measurement, not a check"]
+fn draw_cost_by_layer_count() {
+    let Some((device, queue)) = gpu() else {
+        panic!("no wgpu device; see the this-machine-graphics notes");
+    };
+    println!(
+        "layers, each 8 rects + 8 glyphs + 2 images: us/frame (us per layer), best of {BATCHES}"
+    );
+    let base = frame_cost(&device, &queue, 1, 8) * 1e6;
+    for layers in [8, 64, 256, 1024] {
+        let per_frame = frame_cost(&device, &queue, layers, 8) * 1e6;
+        // Net of the empty pass, which is the same in any version of this.
+        println!(
+            "{layers:>5}: {per_frame:8.1} us ({:.3} us)",
+            (per_frame - base).max(0.0) / layers as f64
+        );
+    }
+}

tests/layout.rs

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

@@ -0,0 +1,60 @@
+//! Which widget an input reaches.
+
+use std::{cell::RefCell, rc::Rc};
+
+use iris::harness::Harness;
+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));
+}

tests/pointer_routing.rs

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

tests/remap.rs

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

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

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

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

tests/text_edit.rs

@@ -0,0 +1,67 @@
+use iris::prelude::*;
+
+fn editor(text: &str, mode: EditMode) -> (TextEdit, TextData) {
+    let view = TextView::new(TextBuffer::new(text), TextAttrs::default(), None);
+    (TextEdit::new(view, mode), TextData::default())
+}
+
+fn press(edit: &mut TextEditCtx<'_>, x: f32) {
+    edit.select(vec2(x, 10.0), vec2(400.0, 200.0), false, false);
+}
+
+#[test]
+fn pressing_an_empty_field_places_input() {
+    let (mut text, mut data) = editor("", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    press(&mut edit, 40.0);
+    edit.insert("hello");
+
+    assert_eq!(edit.text.content(), "hello");
+}
+
+#[test]
+fn preedit_replaces_the_previous_composition() {
+    let (mut text, mut data) = editor("", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    press(&mut edit, 0.0);
+    edit.replace(0, "に");
+    edit.replace(1, "日本");
+
+    assert_eq!(edit.text.content(), "日本");
+}
+
+#[test]
+fn backspace_respects_utf8_boundaries() {
+    let (mut text, mut data) = editor("aé", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    press(&mut edit, f32::MAX);
+    edit.backspace(false);
+
+    assert_eq!(edit.text.content(), "a");
+}
+
+#[test]
+fn typing_replaces_the_selection() {
+    let (mut text, mut data) = editor("hello", EditMode::SingleLine);
+    let mut edit = TextEditCtx {
+        text: &mut text,
+        data: &mut data,
+    };
+
+    edit.select_all();
+    edit.insert("goodbye");
+
+    assert_eq!(edit.text.content(), "goodbye");
+}