naw

Cargo.toml

@@ -1,35 +1,24 @@
 [package]
 name = "iris"
+default-run = "test"
 version.workspace = true
 edition.workspace = true
 
-[features]
-layout-diagnostics = ["iris-core/layout-diagnostics"]
-
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 iris-core = { workspace = true }
 iris-macro = { workspace = true }
-parley = { workspace = true }
+cosmic-text = { workspace = true }
+unicode-segmentation = { workspace = true }
 winit = { workspace = true }
 arboard = { workspace = true, features = ["wayland-data-control"] }
 pollster = { workspace = true }
 wgpu = { workspace = true }
 image = { workspace = true }
-tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread"] }
-
-[dev-dependencies]
-tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread", "time"] }
 
 [workspace]
-members = ["core", "macro", "rig-input"]
-
-[profile.dev]
-debug = 1
-
-[profile.test]
-debug = "line-tables-only"
+members = ["core", "macro"]
 
 [workspace.package]
 version = "0.1.0"
@@ -38,16 +27,12 @@ edition = "2024"
 [workspace.dependencies]
 pollster = "0.4.0"
 winit = "0.30.12"
-wgpu = "30.0.1"
+wgpu = "27.0.1"
 bytemuck = "1.23.1"
-image = "0.25.10"
-parley = "0.11.1"
-swash = "0.2.10"
+image = "0.25.6"
+cosmic-text = "0.15.0"
+unicode-segmentation = "1.12.0"
 fxhash = "0.2.1"
-log = "0.4.29"
 arboard = "3.6.1"
 iris-core = { path = "core" }
 iris-macro = { path = "macro" }
-tokio = "1.49.0"
-wayland-client = "0.31.15"
-wayland-protocols-wlr = { version = "0.3.12", features = ["client"] }

TODO

@@ -1,6 +1,19 @@
 images
     settings (sampler)
-    consider typed TextureHandle<T> variants for distinct texture uses
+
+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
 
 WidgetRef<W> or smth instead of Id
     enum that's either an Id or an actual concrete instance of W
@@ -11,6 +24,17 @@ 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

@@ -3,14 +3,10 @@ name = "iris-core"
 version.workspace = true
 edition.workspace = true
 
-[features]
-layout-diagnostics = []
-
 [dependencies]
+winit = { workspace = true }
 wgpu = { workspace = true }
 bytemuck ={ workspace = true }
 image = { workspace = true }
-parley = { workspace = true }
-swash = { workspace = true }
+cosmic-text = { workspace = true }
 fxhash = { workspace = true }
-log = { workspace = true }

core/src/attr.rs

@@ -1,22 +1,24 @@
-use crate::{UiRsc, WeakWidget, WidgetIdFn, WidgetLike};
+use crate::{HasUi, StateLike, WidgetIdFn, WidgetLike, WidgetRef};
 
-pub trait WidgetAttr<Rsc, W: ?Sized> {
+pub trait WidgetAttr<State, W: ?Sized> {
     type Input;
-    fn run(rsc: &mut Rsc, id: WeakWidget<W>, input: Self::Input);
+    fn run(state: &mut State, id: WidgetRef<W>, input: Self::Input);
 }
 
-pub trait Attrable<Rsc, W: ?Sized, Tag> {
-    fn attr<A: WidgetAttr<Rsc, W>>(self, input: A::Input) -> impl WidgetIdFn<Rsc, W>;
+pub trait Attrable<State, W: ?Sized, Tag> {
+    fn attr<A: WidgetAttr<State, W>>(self, input: A::Input) -> impl WidgetIdFn<State, W>;
 }
 
-impl<Rsc: UiRsc, WL: WidgetLike<Rsc, Tag>, Tag> Attrable<Rsc, WL::Widget, Tag> for WL {
-    fn attr<A: WidgetAttr<Rsc, WL::Widget>>(
+impl<State: HasUi + StateLike<State>, WL: WidgetLike<State, Tag>, Tag>
+    Attrable<State, WL::Widget, Tag> for WL
+{
+    fn attr<A: WidgetAttr<State, WL::Widget>>(
         self,
         input: A::Input,
-    ) -> impl WidgetIdFn<Rsc, WL::Widget> {
-        |rsc| {
-            let id = self.add(rsc);
-            A::run(rsc, id, input);
+    ) -> impl WidgetIdFn<State, WL::Widget> {
+        |state| {
+            let id = self.add(state);
+            A::run(state, id, input);
             id
         }
     }

core/src/event/ctx.rs

@@ -1,18 +1,116 @@
-use crate::{HasEvents, WeakWidget, Widget};
+use crate::{HasEvents, HasState, HasUi, StateLike, Ui, Widget, WidgetRef};
+use std::ops::{Deref, DerefMut};
 
-pub struct EventCtx<'a, Rsc: HasEvents, Data> {
-    pub state: &'a mut Rsc::State,
-    pub data: Data,
+pub struct EventCtx<'a, State, Data> {
+    pub state: &'a mut State,
+    pub data: &'a mut Data,
 }
 
-pub struct EventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> {
-    pub widget: WeakWidget<W>,
-    pub state: &'a mut Rsc::State,
-    pub data: Data,
+pub struct EventIdCtx<'a, State, Data, W: ?Sized> {
+    pub widget: WidgetRef<W>,
+    pub state: &'a mut State,
+    pub data: &'a mut Data,
 }
 
-impl<Rsc: HasEvents, Data, W: Widget> EventIdCtx<'_, Rsc, Data, W> {
-    pub fn widget<'a>(&self, rsc: &'a mut Rsc) -> &'a mut W {
-        &mut rsc.ui_mut().widgets[self.widget]
+impl<State: HasUi, Data, W: ?Sized> Deref for EventIdCtx<'_, State, Data, W> {
+    type Target = State;
+
+    fn deref(&self) -> &Self::Target {
+        self.state
     }
 }
+
+impl<State: HasUi, Data, W: ?Sized> DerefMut for EventIdCtx<'_, State, Data, W> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.state
+    }
+}
+
+impl<State: HasUi, Data, W: Widget> EventIdCtx<'_, State, Data, W> {
+    pub fn widget(&mut self) -> &mut W {
+        &mut self.state.get_mut()[self.widget]
+    }
+}
+
+impl<State: HasUi, Data, W: Widget> HasUi for EventIdCtx<'_, State, Data, W> {
+    fn get(&self) -> &Ui {
+        self.state.ui()
+    }
+
+    fn get_mut(&mut self) -> &mut Ui {
+        self.state.ui_mut()
+    }
+}
+
+impl<State: HasUi, Data, W: Widget> HasState for EventIdCtx<'_, State, Data, W> {
+    type State = State;
+}
+
+impl<State: HasEvents<State = State>, Data, W: Widget> HasEvents
+    for EventIdCtx<'_, State, Data, W>
+{
+    fn get(&self) -> &super::EventManager<Self::State> {
+        self.state.events()
+    }
+
+    fn get_mut(&mut self) -> &mut super::EventManager<Self::State> {
+        self.state.events_mut()
+    }
+}
+
+impl<State, Data, W: Widget> StateLike<State> for EventIdCtx<'_, State, Data, W> {
+    fn as_state(&mut self) -> &mut State {
+        self.state
+    }
+}
+
+// fn test() {
+//     use crate::*;
+//     struct ClientRsc;
+//     impl<State, Data> HasUi for EventCtx<'_, State, Data> {
+//         fn get(&self) -> &Ui {
+//             todo!()
+//         }
+//
+//         fn get_mut(&mut self) -> &mut Ui {
+//             todo!()
+//         }
+//     }
+//     fn on(_: impl for<'a> EventFn<ClientRsc, &'a mut i32>) {}
+//
+//     pub trait WidgetLike<State: HasUi, Tag>: Sized {
+//         type Widget: Widget + ?Sized + std::marker::Unsize<dyn Widget>;
+//
+//         fn add(self, state: &mut State) -> WidgetHandle<Self::Widget>;
+//
+//         fn with_id<W2>(
+//             self,
+//             f: impl FnOnce(&mut State, WidgetHandle<Self::Widget>) -> WidgetHandle<W2>,
+//         ) -> impl WidgetIdFn<State, W2> {
+//             move |state| {
+//                 let id = self.add(state);
+//                 f(state, id)
+//             }
+//         }
+//
+//         fn set_root(self, state: &mut State) {
+//             state.get_mut().root = Some(self.add(state));
+//         }
+//
+//         fn handles(self, state: &mut State) -> WidgetHandles<Self::Widget> {
+//             self.add(state).handles()
+//         }
+//     }
+//
+//     pub struct WidgetTag;
+//     impl<State: HasUi, W: Widget> WidgetLike<State, WidgetTag> for W {
+//         type Widget = W;
+//         fn add(self, state: &mut State) -> WidgetHandle<W> {
+//             state.get_mut().add_widget(self)
+//         }
+//     }
+//
+//     on(move |ctx| {
+//         ().add(ctx);
+//     });
+// }

core/src/event/manager.rs

@@ -1,16 +1,16 @@
 use crate::{
-    ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, HasEvents, IdLike, LayerId,
-    WeakWidget, WidgetEventFn, WidgetId,
+    ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, IdLike, LayerId, Widget,
+    WidgetEventFn, WidgetId, WidgetRef,
     util::{HashMap, HashSet, TypeMap},
 };
 use std::{any::TypeId, rc::Rc};
 
-pub struct EventManager<Rsc> {
+pub struct EventManager<State> {
     widget_to_types: HashMap<WidgetId, HashSet<TypeId>>,
-    types: TypeMap<dyn EventManagerLike<Rsc>>,
+    types: TypeMap<dyn EventManagerLike<State>>,
 }
 
-impl<Rsc> Default for EventManager<Rsc> {
+impl<State> Default for EventManager<State> {
     fn default() -> Self {
         Self {
             widget_to_types: Default::default(),
@@ -19,27 +19,26 @@ impl<Rsc> Default for EventManager<Rsc> {
     }
 }
 
-impl<Rsc: HasEvents + 'static> EventManager<Rsc> {
-    pub fn get_type<E: EventLike>(&mut self) -> &mut TypeEventManager<Rsc, E::Event> {
+impl<State: 'static> EventManager<State> {
+    pub fn get_type<E: EventLike>(&mut self) -> &mut TypeEventManager<State, E::Event> {
         self.types.type_or_default()
     }
 
-    pub fn register<I: IdLike + 'static, E: EventLike>(
+    pub fn register<W: Widget + ?Sized, E: EventLike>(
         &mut self,
-        id: I,
+        id: WidgetRef<W>,
         event: E,
-        f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, I::Widget>,
+        f: impl for<'a> WidgetEventFn<State, <E::Event as Event>::Data<'a>, W>,
     ) {
-        let i = id.id();
         self.get_type::<E>().register(id, event, f);
         self.widget_to_types
-            .entry(i)
+            .entry(id.id())
             .or_default()
             .insert(Self::type_key::<E>());
     }
 
     pub fn type_key<E: EventLike>() -> TypeId {
-        TypeId::of::<TypeEventManager<Rsc, E::Event>>()
+        TypeId::of::<TypeEventManager<State, E::Event>>()
     }
 }
 
@@ -49,7 +48,7 @@ pub trait EventsLike {
     fn undraw(&mut self, active: &ActiveData);
 }
 
-impl<Rsc: HasEvents + 'static> EventsLike for EventManager<Rsc> {
+impl<State: 'static> EventsLike for EventManager<State> {
     fn remove(&mut self, id: WidgetId) {
         for t in self.widget_to_types.get(&id).into_flat_iter() {
             self.types.get_mut(t).unwrap().remove(id);
@@ -75,15 +74,14 @@ pub trait EventManagerLike<State> {
     fn undraw(&mut self, data: &ActiveData);
 }
 
-type EventData<Rsc, E> = (E, Rc<dyn for<'a> EventFn<Rsc, <E as Event>::Data<'a>>>);
-pub struct TypeEventManager<Rsc: HasEvents, E: Event> {
+type EventData<State, E> = (E, Rc<dyn for<'a> EventFn<State, <E as Event>::Data<'a>>>);
+pub struct TypeEventManager<State, E: Event> {
     // TODO: reduce visiblity!!
     pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
-    pub global: E::Global,
-    map: HashMap<WidgetId, Vec<EventData<Rsc, E>>>,
+    map: HashMap<WidgetId, Vec<EventData<State, E>>>,
 }
 
-impl<Rsc: HasEvents, E: Event> EventManagerLike<Rsc> for TypeEventManager<Rsc, E> {
+impl<State, E: Event> EventManagerLike<State> for TypeEventManager<State, E> {
     fn remove(&mut self, id: WidgetId) {
         self.map.remove(&id);
         for layer in self.active.values_mut() {
@@ -104,35 +102,32 @@ impl<Rsc: HasEvents, E: Event> EventManagerLike<Rsc> for TypeEventManager<Rsc, E
     }
 }
 
-impl<Rsc: HasEvents, E: Event> Default for TypeEventManager<Rsc, E> {
+impl<State, E: Event> Default for TypeEventManager<State, E> {
     fn default() -> Self {
         Self {
             active: Default::default(),
-            global: Default::default(),
             map: Default::default(),
         }
     }
 }
 
-impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
-    fn register<I: IdLike + 'static>(
+impl<State: 'static, E: Event> TypeEventManager<State, E> {
+    fn register<W: Widget + ?Sized>(
         &mut self,
-        widget: I,
+        widget: WidgetRef<W>,
         event: impl EventLike<Event = E>,
-        f: impl for<'a> WidgetEventFn<Rsc, E::Data<'a>, I::Widget>,
+        f: impl for<'a> WidgetEventFn<State, E::Data<'a>, W>,
     ) {
         let event = event.into_event();
         self.map.entry(widget.id()).or_default().push((
             event,
-            Rc::new(move |ctx, rsc| {
-                f(
-                    EventIdCtx {
-                        widget: WeakWidget::new(widget.id()),
-                        state: ctx.state,
-                        data: ctx.data,
-                    },
-                    rsc,
-                );
+            Rc::new(move |ctx| {
+                let mut test = EventIdCtx {
+                    widget,
+                    state: ctx.state,
+                    data: ctx.data,
+                };
+                f(&mut test);
             }),
         ));
     }
@@ -140,23 +135,17 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
     pub fn run_fn<'a>(
         &mut self,
         id: impl IdLike,
-    ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) -> bool + 'a {
+    ) -> impl for<'b> FnOnce(EventCtx<'_, State, E::Data<'b>>) + 'a {
         let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
-        move |ctx, rsc| {
-            let mut consumed = false;
+        move |ctx| {
             for (e, f) in fs {
-                if let Some(data) = e.should_run(&ctx.data) {
-                    consumed |= e.consumes(&data);
-                    f(
-                        EventCtx {
-                            state: ctx.state,
-                            data,
-                        },
-                        rsc,
-                    )
+                if e.should_run(ctx.data) {
+                    f(&mut EventCtx {
+                        state: ctx.state,
+                        data: ctx.data,
+                    })
                 }
             }
-            consumed
         }
     }
 }

core/src/event/mod.rs

@@ -7,20 +7,11 @@ pub use manager::*;
 pub use rsc::*;
 
 pub trait Event: Sized + 'static + Clone {
-    type Data<'a>: Clone = ();
+    type Data<'a> = ();
     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
+    fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
+        true
     }
 }
 
@@ -37,17 +28,14 @@ impl<E: Event> EventLike for E {
     }
 }
 
-pub trait EventFn<Rsc: HasEvents, Data>: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static {}
-impl<Rsc: HasEvents, F: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static, Data> EventFn<Rsc, Data>
-    for F
-{
-}
+pub trait EventFn<State, Data>: Fn(&mut EventCtx<State, Data>) + 'static {}
+impl<State, F: Fn(&mut EventCtx<State, Data>) + 'static, Data> EventFn<State, Data> for F {}
 
-pub trait WidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
-    Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
+pub trait WidgetEventFn<State, Data, W: ?Sized>:
+    Fn(&mut EventIdCtx<State, Data, W>) + 'static
 {
 }
-impl<Rsc: HasEvents, F: Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static, Data, W: ?Sized>
-    WidgetEventFn<Rsc, Data, W> for F
+impl<State, F: Fn(&mut EventIdCtx<State, Data, W>) + 'static, Data, W: ?Sized>
+    WidgetEventFn<State, Data, W> for F
 {
 }

core/src/event/rsc.rs

@@ -1,35 +1,41 @@
 use crate::{
-    Event, EventCtx, EventLike, EventManager, IdLike, UiRsc, WeakWidget, Widget, WidgetEventFn,
+    Event, EventCtx, EventLike, EventManager, HasUi, IdLike, Widget, WidgetEventFn, WidgetRef,
 };
 
-pub trait HasState: 'static {
-    type State;
+pub trait HasState {
+    type State: HasUi;
 }
 
-pub trait HasEvents: Sized + UiRsc + HasState {
-    fn events(&self) -> &EventManager<Self>;
-    fn events_mut(&mut self) -> &mut EventManager<Self>;
+pub trait HasEvents: Sized + HasState + HasUi {
+    fn get(&self) -> &EventManager<Self::State>;
+    fn get_mut(&mut self) -> &mut EventManager<Self::State>;
+    fn events(&self) -> &EventManager<Self::State> {
+        HasEvents::get(self)
+    }
+    fn events_mut(&mut self) -> &mut EventManager<Self::State> {
+        HasEvents::get_mut(self)
+    }
 
     fn register_event<W: Widget + ?Sized, E: EventLike>(
         &mut self,
-        id: WeakWidget<W>,
+        id: WidgetRef<W>,
         event: E,
-        f: impl for<'a> WidgetEventFn<Self, <E::Event as Event>::Data<'a>, W>,
-    ) {
+        f: impl for<'a> WidgetEventFn<Self::State, <E::Event as Event>::Data<'a>, W>,
+    ) where
+        Self::State: 'static,
+    {
         self.events_mut().register(id, event, f);
     }
 }
 
-pub trait RunEvents: HasEvents {
-    /// Whether anything that ran used up what triggered it.
+pub trait RunEvents: HasEvents + HasState<State = Self> + 'static {
     fn run_event<E: EventLike>(
         &mut self,
         id: impl IdLike,
-        data: <E::Event as Event>::Data<'_>,
-        state: &mut Self::State,
-    ) -> bool {
+        data: &mut <E::Event as Event>::Data<'_>,
+    ) {
         let f = self.events_mut().get_type::<E>().run_fn(id);
-        f(EventCtx { state, data }, self)
+        f(EventCtx { state: self, data })
     }
 }
-impl<T: HasEvents> RunEvents for T {}
+impl<T: HasEvents + HasState<State = Self> + 'static> RunEvents for T {}

core/src/fixed.rs

@@ -1,574 +0,0 @@
-use crate::{UiNum, util::Vec2};
-use std::{
-    fmt::{Debug, Display, Formatter},
-    ops::{Add, AddAssign, Div, Mul, Neg, Sub, SubAssign},
-};
-
-/// A number held as a whole count of `1 / 2^SHIFT`.
-///
-/// Layout reaches one place by more than one route -- a box composed down the
-/// chain, and the same box summed from what its children asked for -- and has
-/// to decide whether the two are the same place. In floats they land a few
-/// bits apart, which is a defect wherever the answer changes what is drawn
-/// rather than where. Here adding and subtracting are exact, a multiply
-/// drops to the step below, and a conversion between grids takes the nearest
-/// one, so two routes to one place land on one number and everything
-/// downstream compares for equality instead of for nearness.
-///
-/// `SHIFT` is the number of fractional bits, which is what makes the steps
-/// divide a whole number: a power of two also converts to `f32` without
-/// rounding while the value fits in its mantissa.
-///
-/// Arithmetic wraps at the ends of the range, the way the `i32` underneath
-/// does. Saturating instead was measured at a twelfth of layout's
-/// instructions -- five per add against one -- to keep the ordering of
-/// coordinates two million pixels out, where nothing draws anyway. A value
-/// off the end is a defect either way; wrapping makes it an obvious one.
-/// Only [`Self::from_f32`] clamps, since a float has further to come from.
-#[repr(transparent)]
-#[derive(
-    Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default, bytemuck::Pod, bytemuck::Zeroable,
-)]
-pub struct Fixed<const SHIFT: u32>(i32);
-
-/// A length or a coordinate in pixels, in steps of `1/1024`. Finer than
-/// anything a display can show, and exact in `f32` up to 16,384 px, which is
-/// what lets the same number reach the GPU.
-pub type Px = Fixed<PX_SHIFT>;
-
-/// How many bits of a pixel a [`Px`] keeps. One place, because [`PxVec2`]
-/// and the shader's own decoding are the same grid or nothing lines up.
-pub const PX_SHIFT: u32 = 10;
-
-/// A share of what a box has left over, which is a weight beside its
-/// siblings rather than a fraction of anything: a list divides its room by
-/// the total of these, so the range has to hold a whole list's worth and the
-/// precision only has to tell two weights apart.
-pub type Weight = Fixed<16>;
-
-/// A fraction of a box. Twenty-four bits of it, which matches `f32` around a
-/// half and beats it above one -- where anchors actually sit -- and leaves
-/// +/-128 of range, enough to sum a hundred children each asking for a whole
-/// box. A `leftover` weight is not one of these: it is a share of what is
-/// left rather than a fraction of anything, and it sums over a whole list.
-pub type Rel = Fixed<REL_SHIFT>;
-
-/// How many bits of a box a [`Rel`] keeps, beside [`PX_SHIFT`] and for the
-/// same reason.
-pub const REL_SHIFT: u32 = 24;
-
-impl<const SHIFT: u32> Fixed<SHIFT> {
-    pub const ZERO: Self = Self(0);
-    pub const ONE: Self = Self::one();
-    /// The gap between neighbouring values, which is also how far apart two
-    /// numbers can be and still mean the same place.
-    pub const STEP: Self = Self(1);
-    /// Also what stands in for an unbounded end: compared against, never
-    /// added to, since arithmetic wraps past it.
-    pub const MIN: Self = Self(i32::MIN);
-    pub const MAX: Self = Self(i32::MAX);
-
-    const fn one() -> Self {
-        assert!(SHIFT < 31, "a Fixed needs a bit for the whole part");
-        Self(1 << SHIFT)
-    }
-
-    pub const fn from_raw(raw: i32) -> Self {
-        Self(raw)
-    }
-
-    /// The count of steps, for a caller that needs the representation rather
-    /// than the number.
-    pub const fn raw(self) -> i32 {
-        self.0
-    }
-
-    pub const fn from_int(v: i32) -> Self {
-        Self(v.wrapping_mul(Self::one().0))
-    }
-
-    /// Rounds to the nearest step, and clamps to the ends of the grid rather
-    /// than wrapping: this is where a number from outside arrives, and a float
-    /// has the range to be anywhere. A NaN has no nearest step and becomes
-    /// zero, which is a caller's mistake rather than a value worth carrying.
-    ///
-    /// Half-away is written out rather than called through `f32::round`,
-    /// which is not `const`: a layout constant has to stay a constant.
-    pub const fn from_f32(v: f32) -> Self {
-        debug_assert!(!v.is_nan(), "a NaN has no place on the grid");
-        let scaled = v * Self::one().0 as f32;
-        // Above 2^23 an `f32` has no fractional part left to round, and
-        // adding a half there rounds the number itself up instead. The cast
-        // saturates at both ends and sends NaN to zero, which is the
-        // behaviour wanted at both.
-        const WHOLE: f32 = (1 << 23) as f32;
-        Self(match (scaled >= WHOLE, scaled <= -WHOLE, scaled < 0.0) {
-            (true, _, _) | (_, true, _) => scaled as i32,
-            (_, _, true) => (scaled - 0.5) as i32,
-            _ => (scaled + 0.5) as i32,
-        })
-    }
-
-    /// The first step at or above `v`, where [`Self::from_f32`] takes the
-    /// nearest one and is below it half the time. For a bound that has to
-    /// admit the value it came from: a measurement rounded down is a bound
-    /// that leaves out the thing it was measured from.
-    pub const fn ceil_from_f32(v: f32) -> Self {
-        let nearest = Self::from_f32(v);
-        match nearest.to_f32() < v {
-            true => nearest.next_up(),
-            false => nearest,
-        }
-    }
-
-    /// From a number as it is written in source -- `16`, `1.5` -- which is
-    /// the other place a value enters the grid.
-    pub fn from_num(v: impl UiNum) -> Self {
-        Self::from_f32(v.to_f32())
-    }
-
-    pub const fn to_f32(self) -> f32 {
-        self.0 as f32 / Self::one().0 as f32
-    }
-
-    /// The same value on another grid, rounded where the new one is coarser.
-    pub const fn to_scale<const TO: u32>(self) -> Fixed<TO> {
-        Fixed(match TO >= SHIFT {
-            true => self.0 << (TO - SHIFT),
-            false => shift_round(self.0 as i64, SHIFT - TO) as i32,
-        })
-    }
-
-    pub const fn add(self, rhs: Self) -> Self {
-        Self(self.0.wrapping_add(rhs.0))
-    }
-
-    pub const fn sub(self, rhs: Self) -> Self {
-        Self(self.0.wrapping_sub(rhs.0))
-    }
-
-    pub const fn neg(self) -> Self {
-        Self(self.0.wrapping_neg())
-    }
-
-    /// Scaled by a number on any grid, which is how a length takes a fraction
-    /// of itself and keeps being a length: the product is measured in the
-    /// receiver's steps.
-    ///
-    /// Dropped to the step below rather than taken to the nearest one
-    /// (Bryan, 2026-09-16), which costs a share a thousandth of a pixel of
-    /// its row -- less than an even number of pixels draws. Toward negative
-    /// infinity on both sides of zero, since that is a shift and nothing
-    /// else: a value and its negation therefore land different distances
-    /// from where they came, so a flipped span can sit a step from its
-    /// mirror image.
-    pub const fn mul<const BY: u32>(self, by: Fixed<BY>) -> Self {
-        Self(((self.0 as i64 * by.0 as i64) >> BY) as i32)
-    }
-
-    /// Repeated a whole number of times, which no grid rounds.
-    pub const fn mul_int(self, by: i32) -> Self {
-        Self(self.0.wrapping_mul(by))
-    }
-
-    /// Divided into a whole number of parts, rounded to the nearest step.
-    pub const fn div_int(self, by: i32) -> Self {
-        debug_assert!(by != 0, "no part of nothing");
-        if by == 0 {
-            return Self::ZERO;
-        }
-        Self(div_round(self.0 as i64, by as i64) as i32)
-    }
-
-    /// Divided by a number on any grid. A zero divisor is a caller bug -- a
-    /// box of no length has no fraction of itself -- and answers with the end
-    /// of the range so that a release build lays out something absurd rather
-    /// than dying.
-    pub const fn div<const BY: u32>(self, by: Fixed<BY>) -> Self {
-        debug_assert!(by.0 != 0, "dividing by a length of zero");
-        if by.0 == 0 {
-            return match self.0 < 0 {
-                true => Self::MIN,
-                false => Self::MAX,
-            };
-        }
-        Self(div_round((self.0 as i64) << BY, by.0 as i64) as i32)
-    }
-
-    /// `num / den` on *this* grid rather than on theirs, for weights coarser
-    /// than the share they divide.
-    pub const fn ratio<const OF: u32>(num: Fixed<OF>, den: Fixed<OF>) -> Self {
-        debug_assert!(den.0 != 0, "no part of a whole of nothing");
-        if den.0 == 0 {
-            return Self::ZERO;
-        }
-        Self(div_round((num.0 as i64) << SHIFT, den.0 as i64) as i32)
-    }
-
-    /// `from` and `to` a fraction of the way apart, the fraction being the
-    /// receiver -- the argument order [`crate::util::LerpUtil`] already uses.
-    pub const fn lerp<const OF: u32>(self, from: Fixed<OF>, to: Fixed<OF>) -> Fixed<OF> {
-        from.add(to.sub(from).mul(self))
-    }
-
-    pub const fn min(self, other: Self) -> Self {
-        match self.0 < other.0 {
-            true => self,
-            false => other,
-        }
-    }
-
-    pub const fn max(self, other: Self) -> Self {
-        match self.0 > other.0 {
-            true => self,
-            false => other,
-        }
-    }
-
-    pub const fn abs(self) -> Self {
-        Self(self.0.wrapping_abs())
-    }
-
-    pub const fn clamp(self, lo: Self, hi: Self) -> Self {
-        debug_assert!(lo.0 <= hi.0, "an empty clamp has no answer");
-        self.max(lo).min(hi)
-    }
-
-    /// The next value along, for an interval that must not admit its own
-    /// boundary. The step is the whole gap, so there is nothing to exclude
-    /// between this and the boundary itself.
-    pub const fn next_up(self) -> Self {
-        Self(self.0.wrapping_add(1))
-    }
-
-    pub const fn next_down(self) -> Self {
-        Self(self.0.wrapping_sub(1))
-    }
-}
-
-/// Back to a single step, rounding halves away from zero so that a value and
-/// its negation round to the same distance.
-const fn shift_round(v: i64, bits: u32) -> i64 {
-    let half = (1i64 << bits) >> 1;
-    match v < 0 {
-        true => -((-v + half) >> bits),
-        false => (v + half) >> bits,
-    }
-}
-
-const fn div_round(num: i64, den: i64) -> i64 {
-    let (q, rem) = (num / den, num % den);
-    match rem.unsigned_abs() * 2 >= den.unsigned_abs() {
-        true => match (num < 0) == (den < 0) {
-            true => q + 1,
-            false => q - 1,
-        },
-        false => q,
-    }
-}
-
-/// Toward positive infinity when `up`, toward negative infinity otherwise.
-pub(crate) const fn div_toward(num: i64, den: i64, up: bool) -> i64 {
-    let (q, rem) = (num / den, num % den);
-    if rem == 0 {
-        return q;
-    }
-    match (rem < 0) == (den < 0) {
-        true => q + up as i64,
-        false => q - !up as i64,
-    }
-}
-
-/// Clamped to the ends, unlike a [`Fixed`]'s own arithmetic: a range of box
-/// lengths that runs past `i32` really is unbounded.
-pub(crate) const fn narrow(v: i64) -> i32 {
-    if v > i32::MAX as i64 {
-        return i32::MAX;
-    }
-    if v < i32::MIN as i64 {
-        return i32::MIN;
-    }
-    v as i32
-}
-
-const impl<const SHIFT: u32> Add for Fixed<SHIFT> {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self {
-        Fixed::add(self, rhs)
-    }
-}
-
-const impl<const SHIFT: u32> Sub for Fixed<SHIFT> {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self {
-        Fixed::sub(self, rhs)
-    }
-}
-
-const impl<const SHIFT: u32> Neg for Fixed<SHIFT> {
-    type Output = Self;
-
-    fn neg(self) -> Self {
-        Fixed::neg(self)
-    }
-}
-
-const impl<const SHIFT: u32> AddAssign for Fixed<SHIFT> {
-    fn add_assign(&mut self, rhs: Self) {
-        *self = Fixed::add(*self, rhs);
-    }
-}
-
-const impl<const SHIFT: u32> SubAssign for Fixed<SHIFT> {
-    fn sub_assign(&mut self, rhs: Self) {
-        *self = Fixed::sub(*self, rhs);
-    }
-}
-
-const impl<const SHIFT: u32, const BY: u32> Mul<Fixed<BY>> for Fixed<SHIFT> {
-    type Output = Self;
-
-    fn mul(self, rhs: Fixed<BY>) -> Self {
-        Fixed::mul(self, rhs)
-    }
-}
-
-const impl<const SHIFT: u32, const BY: u32> Div<Fixed<BY>> for Fixed<SHIFT> {
-    type Output = Self;
-
-    fn div(self, rhs: Fixed<BY>) -> Self {
-        Fixed::div(self, rhs)
-    }
-}
-
-impl<const SHIFT: u32> Display for Fixed<SHIFT> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.to_f32(), f)
-    }
-}
-
-/// Prints the number rather than the count of steps: a failing layout test
-/// reports boxes, and `1126` is not a height anybody can read.
-impl<const SHIFT: u32> Debug for Fixed<SHIFT> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        Display::fmt(&self.to_f32(), f)
-    }
-}
-
-/// Two of them, for the places a size or a position needs both axes: a
-/// window, a box in pixels, a pointer. Held apart from [`crate::util::Vec2`]
-/// because that one is what the GPU and the platform speak.
-#[repr(C)]
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Default)]
-pub struct FixedVec2<const SHIFT: u32> {
-    pub x: Fixed<SHIFT>,
-    pub y: Fixed<SHIFT>,
-}
-
-pub type PxVec2 = FixedVec2<PX_SHIFT>;
-
-impl<const SHIFT: u32> FixedVec2<SHIFT> {
-    pub const ZERO: Self = Self::splat(Fixed::ZERO);
-
-    pub const fn new(x: Fixed<SHIFT>, y: Fixed<SHIFT>) -> Self {
-        Self { x, y }
-    }
-
-    pub const fn splat(v: Fixed<SHIFT>) -> Self {
-        Self { x: v, y: v }
-    }
-
-    pub fn from_f32(v: Vec2) -> Self {
-        Self::new(Fixed::from_f32(v.x), Fixed::from_f32(v.y))
-    }
-
-    /// The first step at or above each part, for a measurement reported as a
-    /// box: what it occupies is not less than what was measured.
-    pub fn ceil_from_f32(v: Vec2) -> Self {
-        Self::new(Fixed::ceil_from_f32(v.x), Fixed::ceil_from_f32(v.y))
-    }
-
-    pub fn to_f32(self) -> Vec2 {
-        Vec2::new(self.x.to_f32(), self.y.to_f32())
-    }
-
-    pub const fn div_int(self, by: i32) -> Self {
-        Self::new(self.x.div_int(by), self.y.div_int(by))
-    }
-
-    pub const fn min(self, other: Self) -> Self {
-        Self::new(self.x.min(other.x), self.y.min(other.y))
-    }
-
-    pub const fn max(self, other: Self) -> Self {
-        Self::new(self.x.max(other.x), self.y.max(other.y))
-    }
-}
-
-// `impl_op!` names one concrete type, and this one is generic.
-const impl<const SHIFT: u32> Add for FixedVec2<SHIFT> {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self {
-        Self::new(self.x.add(rhs.x), self.y.add(rhs.y))
-    }
-}
-
-const impl<const SHIFT: u32> Sub for FixedVec2<SHIFT> {
-    type Output = Self;
-
-    fn sub(self, rhs: Self) -> Self {
-        Self::new(self.x.sub(rhs.x), self.y.sub(rhs.y))
-    }
-}
-
-const impl<const SHIFT: u32> AddAssign for FixedVec2<SHIFT> {
-    fn add_assign(&mut self, rhs: Self) {
-        *self = Add::add(*self, rhs);
-    }
-}
-
-const impl<const SHIFT: u32> SubAssign for FixedVec2<SHIFT> {
-    fn sub_assign(&mut self, rhs: Self) {
-        *self = Sub::sub(*self, rhs);
-    }
-}
-
-impl<const SHIFT: u32> Debug for FixedVec2<SHIFT> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "({}, {})", self.x, self.y)
-    }
-}
-
-impl<const SHIFT: u32> Display for FixedVec2<SHIFT> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        write!(f, "({}, {})", self.x, self.y)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn a_sum_of_steps_does_not_drift() {
-        let mut at = Px::ZERO;
-        for _ in 0..20_000 {
-            at += Px::from_raw(3);
-        }
-        assert_eq!(at, Px::from_raw(60_000));
-        for _ in 0..20_000 {
-            at -= Px::from_raw(3);
-        }
-        assert_eq!(at, Px::ZERO);
-    }
-
-    #[test]
-    fn a_pixel_survives_the_trip_through_f32() {
-        for raw in [0, 1, -1, 64, -1000, 16_777_215, -16_777_215] {
-            let px = Px::from_raw(raw);
-            assert_eq!(Px::from_f32(px.to_f32()), px);
-        }
-    }
-
-    #[test]
-    fn a_fraction_of_a_length_is_a_length() {
-        let half = Px::from_int(100) * Rel::from_f32(0.5);
-        assert_eq!(half, Px::from_int(50));
-        assert_eq!(Px::from_int(100) * Rel::ONE, Px::from_int(100));
-        assert_eq!(Px::from_int(100) * Rel::ZERO, Px::ZERO);
-    }
-
-    /// Toward negative infinity on both sides of zero, which is what makes
-    /// it a shift rather than a shift and a sign branch -- and what makes a
-    /// value and its negation land different distances from where they came,
-    /// so a flipped span can sit a step from its mirror image.
-    #[test]
-    fn a_multiply_drops_to_the_step_below_on_both_sides_of_zero() {
-        // A step and a half of one, which has no step of its own.
-        let step_and_a_half = Rel::from_f32(1.5).div_int(Px::ONE.raw());
-        assert_eq!(Px::ONE * step_and_a_half, Px::from_raw(1));
-        assert_eq!(Px::ONE.neg() * step_and_a_half, Px::from_raw(-2));
-    }
-
-    /// A division rounds to the nearest step, so it cannot put back the
-    /// steps a truncating multiply dropped: a round trip comes back short,
-    /// never long, and by the few steps the two operations gave up.
-    #[test]
-    fn dividing_by_a_fraction_cannot_undo_a_truncating_multiply() {
-        let third = Rel::ONE / Rel::from_int(3);
-        let len = Px::from_int(300);
-        let back = len * third / third;
-        assert!(back <= len, "{back:?} is longer than {len:?}");
-        assert!(len - back <= Px::from_raw(3), "{back:?} against {len:?}");
-        assert_eq!(Px::from_int(100) / Rel::from_f32(0.5), Px::from_int(200));
-    }
-
-    /// The bound a greedy line break needs: the width it was measured at is
-    /// not on the grid, and the narrowest box the break still holds for is
-    /// the step at or above it, never the one below.
-    #[test]
-    fn a_ceiling_never_lands_below_the_number_it_came_from() {
-        let step = 1.0 / (1 << PX_SHIFT) as f32;
-        for n in 0..64 {
-            let v = 189.0 + n as f32 * step / 3.0;
-            let up = Px::ceil_from_f32(v);
-            assert!(up.to_f32() >= v, "{up:?} is below {v}");
-            assert!(
-                up.to_f32() - v < step,
-                "{up:?} is more than a step above {v}"
-            );
-        }
-        // An exact step is its own ceiling.
-        assert_eq!(Px::ceil_from_f32(189.5), Px::from_f32(189.5));
-    }
-
-    #[test]
-    fn a_number_from_outside_is_clamped_to_the_grid() {
-        assert_eq!(Px::from_f32(1e12), Px::MAX);
-        assert_eq!(Px::from_f32(-1e12), Px::MIN);
-    }
-
-    #[test]
-    fn a_coarser_grid_rounds_and_a_finer_one_does_not() {
-        // A third, which neither grid holds exactly.
-        let third = Rel::ONE / Rel::from_int(3);
-        assert_eq!(third.to_scale::<6>(), Fixed::<6>::from_raw(21));
-        let coarse = Fixed::<6>::from_raw(21);
-        assert_eq!(coarse.to_scale::<24>().to_scale::<6>(), coarse);
-    }
-
-    #[test]
-    fn lerp_takes_the_fraction_as_the_receiver() {
-        let (from, to) = (Px::from_int(10), Px::from_int(20));
-        assert_eq!(Rel::ZERO.lerp(from, to), from);
-        assert_eq!(Rel::ONE.lerp(from, to), to);
-        assert_eq!(Rel::from_f32(0.5).lerp(from, to), Px::from_int(15));
-        assert_eq!(Rel::from_f32(0.5).lerp(to, from), Px::from_int(15));
-    }
-
-    #[test]
-    fn a_ratio_is_finer_than_the_weights_it_divides() {
-        let (one, three) = (Weight::ONE, Weight::from_int(3));
-        // A third, which the weights' own grid could only hold to 1/65536.
-        assert_eq!(Rel::ratio(one, three), Rel::from_raw(5592405));
-        assert_eq!(Rel::ratio(three, three), Rel::ONE);
-        assert_eq!(Rel::ratio(Weight::ZERO, three), Rel::ZERO);
-    }
-
-    #[test]
-    fn nothing_sits_between_a_value_and_the_next_one() {
-        let at = Px::from_int(3);
-        assert_eq!(at.next_up().next_down(), at);
-        assert_eq!(at.next_up().raw() - at.raw(), 1);
-        assert!(at.next_down() < at && at < at.next_up());
-    }
-
-    #[test]
-    fn it_prints_the_number_rather_than_the_steps() {
-        assert_eq!(format!("{:?}", Px::from_f32(17.59375)), "17.59375");
-        assert_eq!(format!("{}", Px::from_int(-2)), "-2");
-    }
-}

core/src/layout_diagnostics.rs

@@ -1,489 +0,0 @@
-//! Opt-in counters and coarse timers for explaining CPU layout cost.
-//!
-//! Enable the `layout-diagnostics` feature. With it disabled, none of the
-//! instrumentation is compiled into Iris. The retained rig in
-//! `tests/layout_diagnostics.rs` is the ordinary entry point.
-//!
-//! Timers are inclusive: `update total` contains `full layout` or
-//! `incremental layout`, and `text render` contains shaping and glyph
-//! placement. They locate cost within one instrumented run and must not be
-//! added together. Use an uninstrumented build under `perf` for final CPU
-//! totals; counting every primitive and distinct widget deliberately perturbs
-//! the instrumented run.
-//!
-//! Call [`trace_widget`] before a frame to retain the ordered constraint,
-//! reuse, size, placement, and text events for one suspicious widget. The
-//! selection is a set and survives [`take`] until cleared.
-
-use crate::{Axis, LayoutLen, PxVec2, Size, UiRegion, WidgetId};
-use std::{
-    cell::RefCell,
-    collections::{HashMap, HashSet},
-    fmt::Write,
-    time::Instant,
-};
-
-#[derive(Clone, Copy)]
-pub(crate) enum Counter {
-    Updates,
-    DrawRequests,
-    WidgetDraws,
-    RegionNodeDraws,
-    SizeReads,
-    HintHits,
-    HintMisses,
-    RetainedSizeHits,
-    ReuseAttempts,
-    ReuseExact,
-    ReuseMoved,
-    ReuseDirty,
-    ReuseWrongParent,
-    ReuseRemapped,
-    ReuseOutside,
-    ReuseWrongLayer,
-    ReuseWrongNode,
-    PlaceRedraws,
-    QueuePops,
-    DepthReads,
-    LocalRedraws,
-    SizeChanges,
-    ReaderEdges,
-    PrimitiveWrites,
-    TextRenders,
-    TextShapeHits,
-    TextShapes,
-    TextBreaks,
-    GlyphPlacements,
-    OutsidePlacement,
-    OutsideFrame,
-    OutsideExtent,
-}
-
-impl Counter {
-    const COUNT: usize = Self::OutsideExtent as usize + 1;
-
-    const NAMES: [&'static str; Self::COUNT] = [
-        "updates",
-        "draw requests",
-        "widget draws",
-        "region-node draws",
-        "draw-result size reads",
-        "hint hits",
-        "hint misses",
-        "retained size hits",
-        "reuse attempts",
-        "reuse exact",
-        "reuse moved",
-        "reuse: dirty",
-        "reuse: wrong parent",
-        "reuse remapped",
-        "reuse: outside what it holds for",
-        "reuse: another layer",
-        "reuse: region-node choice changed",
-        "placed by redrawing",
-        "redraw queue pops",
-        "depth reads",
-        "local redraws",
-        "size changes",
-        "reader edges",
-        "primitive writes",
-        "text renders",
-        "text shape hits",
-        "text shapes",
-        "text line breaks",
-        "glyph placements",
-        "reuse outside: the placement it was pinned to",
-        "reuse outside: a frame length",
-        "reuse outside: an extent length",
-    ];
-}
-
-#[derive(Clone, Copy)]
-pub(crate) enum TimerKind {
-    Update,
-    FullLayout,
-    IncrementalLayout,
-    TextRender,
-    TextShape,
-    TextBreak,
-    GlyphPlacement,
-}
-
-impl TimerKind {
-    const COUNT: usize = Self::GlyphPlacement as usize + 1;
-
-    const NAMES: [&'static str; Self::COUNT] = [
-        "update total",
-        "full layout",
-        "incremental layout",
-        "text render",
-        "text shape",
-        "text line break",
-        "glyph placement",
-    ];
-}
-
-#[derive(Clone)]
-pub struct Report {
-    counters: [u64; Counter::COUNT],
-    nanos: [u64; TimerKind::COUNT],
-    distinct_widgets: usize,
-    distinct_text_widgets: usize,
-    hot_widgets: Vec<Callsite>,
-    hot_text: Vec<Callsite>,
-    traces: Vec<TraceEvent>,
-}
-
-impl Default for Report {
-    fn default() -> Self {
-        Self {
-            counters: [0; Counter::COUNT],
-            nanos: [0; TimerKind::COUNT],
-            distinct_widgets: 0,
-            distinct_text_widgets: 0,
-            hot_widgets: Vec::new(),
-            hot_text: Vec::new(),
-            traces: Vec::new(),
-        }
-    }
-}
-
-impl Report {
-    pub fn counters(&self) -> impl Iterator<Item = (&'static str, u64)> + '_ {
-        Counter::NAMES.into_iter().zip(self.counters)
-    }
-
-    /// Inclusive elapsed time accumulated for each targeted operation.
-    pub fn timings_ns(&self) -> impl Iterator<Item = (&'static str, u64)> + '_ {
-        TimerKind::NAMES.into_iter().zip(self.nanos)
-    }
-
-    pub fn distinct_widgets(&self) -> usize {
-        self.distinct_widgets
-    }
-
-    pub fn distinct_text_widgets(&self) -> usize {
-        self.distinct_text_widgets
-    }
-
-    pub fn hot_widgets(&self) -> &[Callsite] {
-        &self.hot_widgets
-    }
-
-    pub fn hot_text(&self) -> &[Callsite] {
-        &self.hot_text
-    }
-
-    /// Ordered layout events for widgets selected with [`trace_widget`].
-    pub fn traces(&self) -> &[TraceEvent] {
-        &self.traces
-    }
-
-    /// Formats nonzero totals divided by `frames`.
-    pub fn per_frame(&self, frames: usize) -> String {
-        let divisor = frames.max(1) as f64;
-        let mut out = String::new();
-        for (name, value) in self.counters() {
-            if value != 0 {
-                let _ = writeln!(out, "  {name:<27} {:>12.2}", value as f64 / divisor);
-            }
-        }
-        if self.distinct_widgets != 0 {
-            let _ = writeln!(
-                out,
-                "  {:<27} {:>12}",
-                "distinct widgets", self.distinct_widgets
-            );
-        }
-        if self.distinct_text_widgets != 0 {
-            let _ = writeln!(
-                out,
-                "  {:<27} {:>12}",
-                "distinct text widgets", self.distinct_text_widgets
-            );
-        }
-        for (name, nanos) in self.timings_ns() {
-            if nanos != 0 {
-                let ms = nanos as f64 / divisor / 1_000_000.0;
-                let _ = writeln!(out, "  {name:<27} {ms:>12.3} ms");
-            }
-        }
-        if !self.hot_widgets.is_empty() {
-            let _ = writeln!(out, "  hottest widget draws:");
-            for callsite in &self.hot_widgets {
-                let calls = callsite.calls as f64 / divisor;
-                let _ = writeln!(
-                    out,
-                    "    {calls:>9.2}  {:?} {}",
-                    callsite.id, callsite.label
-                );
-            }
-        }
-        if !self.hot_text.is_empty() {
-            let _ = writeln!(out, "  hottest text renders:");
-            for callsite in &self.hot_text {
-                let calls = callsite.calls as f64 / divisor;
-                let _ = writeln!(
-                    out,
-                    "    {calls:>9.2}  {:>3} widths  {:?} {}",
-                    callsite.distinct_widths, callsite.id, callsite.label
-                );
-            }
-        }
-        if !self.traces.is_empty() {
-            let _ = writeln!(out, "  targeted layout trace:");
-            for event in &self.traces {
-                let _ = writeln!(out, "    {event:?}");
-            }
-        }
-        out
-    }
-}
-
-#[derive(Clone)]
-pub struct Callsite {
-    pub id: WidgetId,
-    pub label: String,
-    pub calls: u64,
-    pub distinct_widths: usize,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum ReuseOutcome {
-    Exact,
-    Moved,
-    Dirty,
-    WrongParent,
-    WrongLayer,
-    Remapped,
-    Outside,
-    Undrawn,
-}
-
-/// One targeted layout event. Events are retained in execution order, making
-/// repeated constraint paths visible without logging every widget globally.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum TraceEvent {
-    DrawRequest {
-        id: WidgetId,
-        parent: Option<WidgetId>,
-        region: UiRegion,
-        pixel_size: PxVec2,
-        region_node: bool,
-    },
-    Reuse {
-        id: WidgetId,
-        outcome: ReuseOutcome,
-    },
-    SizeReported {
-        id: WidgetId,
-        size: Size,
-    },
-    RegionNode {
-        id: WidgetId,
-        parent: WidgetId,
-        region: UiRegion,
-    },
-    SizeRead {
-        id: WidgetId,
-        reader: WidgetId,
-        size: Size,
-    },
-    HintRead {
-        id: WidgetId,
-        reader: WidgetId,
-        axis: Axis,
-        hint: Option<LayoutLen>,
-    },
-    TextRendered {
-        id: WidgetId,
-        width: Option<f32>,
-    },
-}
-
-#[derive(Default)]
-struct Calls {
-    label: String,
-    count: u64,
-    widths: HashSet<Option<u32>>,
-}
-
-#[derive(Default)]
-struct Current {
-    report: Report,
-    widgets: HashMap<WidgetId, Calls>,
-    text_widgets: HashMap<WidgetId, Calls>,
-    traced: HashSet<WidgetId>,
-}
-
-thread_local! {
-    static CURRENT: RefCell<Current> = RefCell::new(Current::default());
-}
-
-pub(crate) fn bump(counter: Counter) {
-    CURRENT.with_borrow_mut(|current| current.report.counters[counter as usize] += 1);
-}
-
-pub(crate) fn draw_widget(id: WidgetId, label: &str) {
-    CURRENT.with_borrow_mut(|current| {
-        let calls = current.widgets.entry(id).or_default();
-        if calls.label.is_empty() {
-            calls.label = label.to_owned();
-        }
-        calls.count += 1;
-    });
-}
-
-/// Adds a widget to the targeted trace set. Selection survives [`take`]
-/// until explicitly removed or cleared.
-pub fn trace_widget(id: impl Into<WidgetId>) {
-    CURRENT.with_borrow_mut(|current| {
-        current.traced.insert(id.into());
-    });
-}
-
-pub fn untrace_widget(id: impl Into<WidgetId>) {
-    CURRENT.with_borrow_mut(|current| {
-        current.traced.remove(&id.into());
-    });
-}
-
-pub fn clear_traced_widgets() {
-    CURRENT.with_borrow_mut(|current| current.traced.clear());
-}
-
-fn trace(id: WidgetId, event: TraceEvent) {
-    CURRENT.with_borrow_mut(|current| {
-        if current.traced.contains(&id) {
-            current.report.traces.push(event);
-        }
-    });
-}
-
-pub(crate) fn draw_request(
-    id: WidgetId,
-    parent: Option<WidgetId>,
-    region: UiRegion,
-    pixel_size: PxVec2,
-    region_node: bool,
-) {
-    trace(
-        id,
-        TraceEvent::DrawRequest {
-            id,
-            parent,
-            region,
-            pixel_size,
-            region_node,
-        },
-    );
-}
-
-pub(crate) fn reuse(id: WidgetId, outcome: ReuseOutcome) {
-    trace(id, TraceEvent::Reuse { id, outcome });
-}
-
-pub(crate) fn size_reported(id: WidgetId, size: Size) {
-    trace(id, TraceEvent::SizeReported { id, size });
-}
-
-pub(crate) fn region_node(id: WidgetId, parent: WidgetId, region: UiRegion) {
-    trace(id, TraceEvent::RegionNode { id, parent, region });
-}
-
-pub(crate) fn size_read(id: WidgetId, reader: WidgetId, size: Size) {
-    trace(id, TraceEvent::SizeRead { id, reader, size });
-}
-
-pub(crate) fn hint_read(id: WidgetId, reader: WidgetId, axis: Axis, hint: Option<LayoutLen>) {
-    trace(
-        id,
-        TraceEvent::HintRead {
-            id,
-            reader,
-            axis,
-            hint,
-        },
-    );
-}
-
-pub(crate) fn render_text(id: WidgetId, label: &str, width: Option<f32>) {
-    CURRENT.with_borrow_mut(|current| {
-        let calls = current.text_widgets.entry(id).or_default();
-        if calls.label.is_empty() {
-            calls.label = label.to_owned();
-        }
-        calls.count += 1;
-        calls.widths.insert(width.map(f32::to_bits));
-        if current.traced.contains(&id) {
-            current
-                .report
-                .traces
-                .push(TraceEvent::TextRendered { id, width });
-        }
-    });
-}
-
-pub(crate) struct Timer {
-    kind: TimerKind,
-    start: Instant,
-}
-
-pub(crate) fn timer(kind: TimerKind) -> Timer {
-    Timer {
-        kind,
-        start: Instant::now(),
-    }
-}
-
-impl Drop for Timer {
-    fn drop(&mut self) {
-        let nanos = self.start.elapsed().as_nanos().min(u64::MAX as u128) as u64;
-        CURRENT.with_borrow_mut(|current| current.report.nanos[self.kind as usize] += nanos);
-    }
-}
-
-/// Takes all diagnostics accumulated on this thread and resets them.
-pub fn take() -> Report {
-    CURRENT.with_borrow_mut(|current| {
-        current.report.distinct_widgets = current.widgets.len();
-        current.report.distinct_text_widgets = current.text_widgets.len();
-        current.report.hot_widgets = hottest(&current.widgets);
-        current.report.hot_text = hottest(&current.text_widgets);
-        let report = std::mem::take(&mut current.report);
-        current.widgets.clear();
-        current.text_widgets.clear();
-        report
-    })
-}
-
-fn hottest(calls: &HashMap<WidgetId, Calls>) -> Vec<Callsite> {
-    let mut calls: Vec<_> = calls
-        .iter()
-        .map(|(&id, calls)| Callsite {
-            id,
-            label: calls.label.clone(),
-            calls: calls.count,
-            distinct_widths: calls.widths.len(),
-        })
-        .collect();
-    calls.sort_by(|a, b| b.calls.cmp(&a.calls).then_with(|| a.label.cmp(&b.label)));
-    calls.truncate(8);
-    calls
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn taking_a_report_resets_its_counters() {
-        let _ = take();
-        bump(Counter::Updates);
-        bump(Counter::Updates);
-
-        let report = take();
-        assert_eq!(report.counters().next(), Some(("updates", 2)));
-        assert!(take().counters().all(|(_, count)| count == 0));
-    }
-}

core/src/lib.rs

@@ -2,20 +2,19 @@
 #![feature(const_ops)]
 #![feature(const_trait_impl)]
 #![feature(const_convert)]
+#![feature(map_try_insert)]
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
+#![feature(const_cmp)]
 #![feature(const_destruct)]
+#![feature(portable_simd)]
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(coerce_unsized)]
 #![feature(option_into_flat_iter)]
 
-#[cfg(feature = "layout-diagnostics")]
-pub mod layout_diagnostics;
-
 mod attr;
 mod event;
-mod fixed;
 mod num;
 mod orientation;
 mod primitive;
@@ -27,7 +26,6 @@ pub mod util;
 
 pub use attr::*;
 pub use event::*;
-pub use fixed::*;
 pub use num::*;
 pub use orientation::*;
 pub use primitive::*;

core/src/num.rs

@@ -5,19 +5,19 @@ pub const trait UiNum {
     fn to_f32(self) -> f32;
 }
 
-const impl UiNum for f32 {
+impl const UiNum for f32 {
     fn to_f32(self) -> f32 {
         self
     }
 }
 
-const impl UiNum for u32 {
+impl const UiNum for u32 {
     fn to_f32(self) -> f32 {
         self as f32
     }
 }
 
-const impl UiNum for i32 {
+impl const UiNum for i32 {
     fn to_f32(self) -> f32 {
         self as f32
     }
@@ -27,7 +27,7 @@ pub const fn vec2(x: impl const UiNum, y: impl const UiNum) -> Vec2 {
     Vec2::new(x.to_f32(), y.to_f32())
 }
 
-const impl<T: const UiNum + Copy> From<T> for Vec2 {
+impl<T: const UiNum + Copy> const From<T> for Vec2 {
     fn from(v: T) -> Self {
         Self {
             x: v.to_f32(),
@@ -36,7 +36,7 @@ const impl<T: const UiNum + Copy> From<T> for Vec2 {
     }
 }
 
-const impl<T: const UiNum, U: const UiNum> From<(T, U)> for Vec2
+impl<T: const UiNum, U: const UiNum> const From<(T, U)> for Vec2
 where
     (T, U): const Destruct,
 {

core/src/orientation/align.rs

@@ -1,8 +1,8 @@
-use crate::{Px, Rel};
+use crate::vec2;
 
 use super::*;
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct Align {
     pub x: Option<AxisAlign>,
     pub y: Option<AxisAlign>,
@@ -24,38 +24,39 @@ impl Align {
     pub const TOP: CardinalAlign = CardinalAlign::TOP;
     pub const V_CENTER: CardinalAlign = CardinalAlign::V_CENTER;
     pub const BOT: CardinalAlign = CardinalAlign::BOT;
+    pub const NONE: Align = Align { x: None, y: None };
 
     pub fn tuple(&self) -> (Option<AxisAlign>, Option<AxisAlign>) {
         (self.x, self.y)
     }
+
+    /// naming is a bit inconsistent w option,
+    /// normally would return Self, but can't see
+    /// that being needed atm and would wanna do
+    /// a trait if so, so they can both be named .or
+    /// (because Self impls From<RegionAlign>)
+    pub fn or(&self, other: RegionAlign) -> RegionAlign {
+        RegionAlign {
+            x: self.x.unwrap_or(other.x),
+            y: self.y.unwrap_or(other.x),
+        }
+    }
 }
 
-/// Where a widget sits in a box longer than it is. The default is the middle,
-/// because the two edges are the ones that assume a direction: which of them
-/// is the near one depends on the writing system and on which way a container
-/// runs, and the middle is the same either way.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub struct AxisAlign(Rel);
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AxisAlign {
+    Neg,
+    Center,
+    Pos,
+}
 
 impl AxisAlign {
-    pub const NEG: Self = Self::new(0.0);
-    pub const CENTER: Self = Self::new(0.5);
-    pub const POS: Self = Self::new(1.0);
-
-    pub const fn new(rel: f32) -> Self {
-        Self(Rel::from_f32(rel))
-    }
-
-    /// A fraction of the room left over, which is what the layout reads: the
-    /// three constants are the familiar places along it, not the only ones.
-    pub const fn rel(&self) -> Rel {
-        self.0
-    }
-}
-
-impl Default for AxisAlign {
-    fn default() -> Self {
-        Self::CENTER
+    pub const fn rel(&self) -> f32 {
+        match self {
+            Self::Neg => 0.0,
+            Self::Center => 0.5,
+            Self::Pos => 1.0,
+        }
     }
 }
 
@@ -65,60 +66,41 @@ pub struct CardinalAlign {
 }
 
 impl CardinalAlign {
-    pub const LEFT: Self = Self::new(Axis::X, AxisAlign::NEG);
-    pub const H_CENTER: Self = Self::new(Axis::X, AxisAlign::CENTER);
-    pub const RIGHT: Self = Self::new(Axis::X, AxisAlign::POS);
-    pub const TOP: Self = Self::new(Axis::Y, AxisAlign::NEG);
-    pub const V_CENTER: Self = Self::new(Axis::Y, AxisAlign::CENTER);
-    pub const BOT: Self = Self::new(Axis::Y, AxisAlign::POS);
+    pub const LEFT: Self = Self::new(Axis::X, AxisAlign::Neg);
+    pub const H_CENTER: Self = Self::new(Axis::X, AxisAlign::Center);
+    pub const RIGHT: Self = Self::new(Axis::X, AxisAlign::Pos);
+    pub const TOP: Self = Self::new(Axis::Y, AxisAlign::Neg);
+    pub const V_CENTER: Self = Self::new(Axis::Y, AxisAlign::Center);
+    pub const BOT: Self = Self::new(Axis::Y, AxisAlign::Pos);
 
     pub const fn new(axis: Axis, align: AxisAlign) -> Self {
         Self { axis, align }
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
+#[derive(Clone, Copy, PartialEq, Eq)]
 pub struct RegionAlign {
     pub x: AxisAlign,
     pub y: AxisAlign,
 }
 
 impl RegionAlign {
-    /// Both axes at the near edge: the start of a box in its own orientation.
-    pub const NEAR: Self = Self {
-        x: AxisAlign::NEG,
-        y: AxisAlign::NEG,
-    };
-
-    pub fn axis(&self, axis: Axis) -> AxisAlign {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-
-    pub fn axis_mut(&mut self, axis: Axis) -> &mut AxisAlign {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-}
-
-impl RegionAlign {
-    pub const TOP_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::NEG);
-    pub const TOP_CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::NEG);
-    pub const TOP_RIGHT: Self = Self::new(AxisAlign::POS, AxisAlign::NEG);
-    pub const CENTER_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::CENTER);
-    pub const CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::CENTER);
-    pub const CENTER_RIGHT: Self = Self::new(AxisAlign::POS, AxisAlign::CENTER);
-    pub const BOT_LEFT: Self = Self::new(AxisAlign::NEG, AxisAlign::POS);
-    pub const BOT_CENTER: Self = Self::new(AxisAlign::CENTER, AxisAlign::POS);
-    pub const BOT_RIGHT: Self = Self::new(AxisAlign::POS, AxisAlign::POS);
+    pub const TOP_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Neg);
+    pub const TOP_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Neg);
+    pub const TOP_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Neg);
+    pub const CENTER_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Center);
+    pub const CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Center);
+    pub const CENTER_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Center);
+    pub const BOT_LEFT: Self = Self::new(AxisAlign::Neg, AxisAlign::Pos);
+    pub const BOT_CENTER: Self = Self::new(AxisAlign::Center, AxisAlign::Pos);
+    pub const BOT_RIGHT: Self = Self::new(AxisAlign::Pos, AxisAlign::Pos);
 
     pub const fn new(x: AxisAlign, y: AxisAlign) -> Self {
         Self { x, y }
     }
+    pub const fn rel(&self) -> Vec2 {
+        vec2(self.x.rel(), self.y.rel())
+    }
 }
 
 impl UiVec2 {
@@ -137,6 +119,7 @@ impl UiVec2 {
         }
     }
 
+    /// aligns this as a size within a region
     pub fn align(&self, align: RegionAlign) -> UiRegion {
         UiRegion {
             x: self.x.align(align.x),
@@ -171,15 +154,16 @@ impl Vec2 {
     }
 }
 
-impl Len {
+impl UiScalar {
     pub const fn align(&self, align: AxisAlign) -> UiSpan {
         let rel = align.rel();
-        let rest = Rel::ONE.sub(rel);
-        let at = Len::from_parts(rel, Px::ZERO);
-        UiSpan {
-            start: Len::from_parts(at.rel.sub(self.rel.mul(rel)), at.px.sub(self.px.mul(rel))),
-            end: Len::from_parts(at.rel.add(self.rel.mul(rest)), at.px.add(self.px.mul(rest))),
-        }
+        let mut start = UiScalar::rel(rel);
+        start.abs -= self.abs * rel;
+        start.rel -= self.rel * rel;
+        let mut end = UiScalar::rel(rel);
+        end.abs += self.abs * (1.0 - rel);
+        end.rel += self.rel * (1.0 - rel);
+        UiSpan { start, end }
     }
 }
 
@@ -195,8 +179,8 @@ impl From<RegionAlign> for Align {
 impl From<Align> for RegionAlign {
     fn from(align: Align) -> Self {
         Self {
-            x: align.x.unwrap_or(AxisAlign::CENTER),
-            y: align.y.unwrap_or(AxisAlign::CENTER),
+            x: align.x.unwrap_or(AxisAlign::Center),
+            y: align.y.unwrap_or(AxisAlign::Center),
         }
     }
 }
@@ -217,12 +201,9 @@ impl From<CardinalAlign> for Align {
     }
 }
 
-const impl From<RegionAlign> for UiVec2 {
+impl const From<RegionAlign> for UiVec2 {
     fn from(align: RegionAlign) -> Self {
-        Self::new(
-            Len::from_parts(align.x.rel(), Px::ZERO),
-            Len::from_parts(align.y.rel(), Px::ZERO),
-        )
+        Self::rel(align.rel())
     }
 }
 

core/src/orientation/axis.rs

@@ -1,23 +1,11 @@
 use super::*;
-use crate::{Fixed, FixedVec2};
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Eq, PartialEq)]
 pub enum Axis {
     X,
     Y,
 }
 
-impl Axis {
-    /// A per-axis pair with `aligned` on this axis and `ortho` on the other,
-    /// which is what `from_axis` does for a vector.
-    pub fn pair<T>(self, aligned: T, ortho: T) -> [T; 2] {
-        match self {
-            Self::X => [aligned, ortho],
-            Self::Y => [ortho, aligned],
-        }
-    }
-}
-
 impl std::ops::Not for Axis {
     type Output = Self;
 
@@ -52,29 +40,6 @@ pub enum Sign {
     Pos,
 }
 
-impl<const SHIFT: u32> FixedVec2<SHIFT> {
-    pub const fn axis(&self, axis: Axis) -> Fixed<SHIFT> {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-
-    pub const fn axis_mut(&mut self, axis: Axis) -> &mut Fixed<SHIFT> {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-
-    pub const fn from_axis(axis: Axis, aligned: Fixed<SHIFT>, ortho: Fixed<SHIFT>) -> Self {
-        match axis {
-            Axis::X => Self::new(aligned, ortho),
-            Axis::Y => Self::new(ortho, aligned),
-        }
-    }
-}
-
 impl Vec2 {
     pub fn axis(&self, axis: Axis) -> f32 {
         match axis {
@@ -109,14 +74,14 @@ pub const trait AxisT {
 }
 
 pub struct XAxis;
-const impl AxisT for XAxis {
+impl const AxisT for XAxis {
     fn get() -> Axis {
         Axis::X
     }
 }
 
 pub struct YAxis;
-const impl AxisT for YAxis {
+impl const AxisT for YAxis {
     fn get() -> Axis {
         Axis::Y
     }

core/src/orientation/len.rs

@@ -1,30 +1,22 @@
 use super::*;
-use crate::{Px, PxVec2, Rel, UiNum, Weight, util::impl_op};
+use crate::{UiNum, util::impl_op};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 pub struct Size {
-    pub x: LayoutLen,
-    pub y: LayoutLen,
+    pub x: Len,
+    pub y: Len,
 }
 
-/// What a widget asks for along one axis: a [`Len`] -- pixels and a fraction
-/// of the box it is given -- plus a share of whatever is left over once
-/// everything fixed has been taken. The parts add up rather than choosing
-/// between one another.
-///
-/// Only a container dividing its room can answer a share, so a length nobody
-/// divides is a `Len`: a position, a padding, a cap, anything already
-/// resolved.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct LayoutLen {
-    pub px: Px,
-    pub rel: Rel,
-    pub leftover: Weight,
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Len {
+    pub abs: f32,
+    pub rel: f32,
+    pub rest: f32,
 }
 
-impl<N: UiNum> From<N> for LayoutLen {
+impl<N: UiNum> From<N> for Len {
     fn from(value: N) -> Self {
-        LayoutLen::px(value.to_f32())
+        Len::abs(value.to_f32())
     }
 }
 
@@ -37,76 +29,52 @@ impl<Nx: UiNum, Ny: UiNum> From<(Nx, Ny)> for Size {
     }
 }
 
-/// A length with no share in it is a length a container does not have to
-/// divide, which is one it can always give.
-impl From<Len> for LayoutLen {
-    fn from(len: Len) -> Self {
-        Self {
-            px: len.px,
-            rel: len.rel,
-            leftover: Weight::ZERO,
-        }
-    }
-}
-
-impl From<LayoutLen> for Size {
-    fn from(value: LayoutLen) -> Self {
+impl From<Len> for Size {
+    fn from(value: Len) -> Self {
         Self { x: value, y: value }
     }
 }
 
 impl Size {
     pub const ZERO: Self = Self {
-        x: LayoutLen::ZERO,
-        y: LayoutLen::ZERO,
+        x: Len::ZERO,
+        y: Len::ZERO,
     };
 
-    pub const LEFTOVER: Self = Self {
-        x: LayoutLen::LEFTOVER,
-        y: LayoutLen::LEFTOVER,
+    pub const REST: Self = Self {
+        x: Len::REST,
+        y: Len::REST,
     };
 
-    /// From something measured outside layout -- a texture, a shaped line --
-    /// which is where a size in floats comes from.
-    pub fn px(v: Vec2) -> Self {
-        Self::from_px(PxVec2::from_f32(v))
-    }
-
-    pub const fn from_px(v: PxVec2) -> Self {
+    pub fn abs(v: Vec2) -> Self {
         Self {
-            x: LayoutLen {
-                px: v.x,
-                ..LayoutLen::ZERO
-            },
-            y: LayoutLen {
-                px: v.y,
-                ..LayoutLen::ZERO
-            },
+            x: Len::abs(v.x),
+            y: Len::abs(v.y),
         }
     }
 
     pub fn rel(v: Vec2) -> Self {
         Self {
-            x: LayoutLen::rel(v.x),
-            y: LayoutLen::rel(v.y),
+            x: Len::rel(v.x),
+            y: Len::rel(v.y),
         }
     }
 
-    pub fn leftover(v: Vec2) -> Self {
+    pub fn rest(v: Vec2) -> Self {
         Self {
-            x: LayoutLen::leftover(v.x),
-            y: LayoutLen::leftover(v.y),
+            x: Len::rest(v.x),
+            y: Len::rest(v.y),
         }
     }
 
     pub fn to_uivec2(self) -> UiVec2 {
         UiVec2 {
-            x: self.x.apply_leftover(),
-            y: self.y.apply_leftover(),
+            x: self.x.apply_rest(),
+            y: self.y.apply_rest(),
         }
     }
 
-    pub fn from_axis(axis: Axis, aligned: LayoutLen, ortho: LayoutLen) -> Self {
+    pub fn from_axis(axis: Axis, aligned: Len, ortho: Len) -> Self {
         match axis {
             Axis::X => Self {
                 x: aligned,
@@ -119,73 +87,53 @@ impl Size {
         }
     }
 
-    pub fn axis(&self, axis: Axis) -> LayoutLen {
+    pub fn axis(&self, axis: Axis) -> Len {
         match axis {
             Axis::X => self.x,
             Axis::Y => self.y,
         }
     }
-
-    pub fn axis_mut(&mut self, axis: Axis) -> &mut LayoutLen {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
 }
 
-impl LayoutLen {
+impl Len {
     pub const ZERO: Self = Self {
-        px: Px::ZERO,
-        rel: Rel::ZERO,
-        leftover: Weight::ZERO,
+        abs: 0.0,
+        rel: 0.0,
+        rest: 0.0,
     };
 
-    pub const LEFTOVER: Self = Self {
-        px: Px::ZERO,
-        rel: Rel::ZERO,
-        leftover: Weight::ONE,
+    pub const REST: Self = Self {
+        abs: 0.0,
+        rel: 0.0,
+        rest: 1.0,
     };
 
-    /// The whole of what is left over counts as the whole box, which is what
-    /// a length means to something that is not dividing a box between
-    /// siblings -- a scroll asking how long its content is.
-    pub fn apply_leftover(&self) -> Len {
-        let share = match self.leftover > Weight::ZERO {
-            true => Rel::ONE,
-            false => Rel::ZERO,
-        };
-        Len::from_parts(self.rel.add(share), self.px)
-    }
-
-    /// This length, given as a part of a box `len` long, as a part of the
-    /// box `len` is itself a part of. The share is untouched: it is a claim
-    /// on whoever divides the room, not a fraction of anything.
-    pub const fn within_len(self, len: Len) -> Self {
-        let part = Len::from_parts(self.rel, self.px).within_len(len);
-        Self {
-            px: part.px,
-            rel: part.rel,
-            leftover: self.leftover,
+    pub fn apply_rest(&self) -> UiScalar {
+        UiScalar {
+            rel: self.rel + if self.rest > 0.0 { 1.0 } else { 0.0 },
+            abs: self.abs,
         }
     }
 
-    pub fn px(px: impl UiNum) -> Self {
+    pub fn abs(abs: impl UiNum) -> Self {
         Self {
-            px: Px::from_num(px),
-            ..Self::ZERO
+            abs: abs.to_f32(),
+            rel: 0.0,
+            rest: 0.0,
         }
     }
     pub fn rel(rel: impl UiNum) -> Self {
         Self {
-            rel: Rel::from_num(rel),
-            ..Self::ZERO
+            abs: 0.0,
+            rel: rel.to_f32(),
+            rest: 0.0,
         }
     }
-    pub fn leftover(ratio: impl UiNum) -> Self {
+    pub fn rest(ratio: impl UiNum) -> Self {
         Self {
-            leftover: Weight::from_num(ratio),
-            ..Self::ZERO
+            abs: 0.0,
+            rel: 0.0,
+            rest: ratio.to_f32(),
         }
     }
 }
@@ -193,26 +141,38 @@ impl LayoutLen {
 pub mod len_fns {
     use super::*;
 
-    pub fn px(px: impl UiNum) -> LayoutLen {
-        LayoutLen::px(px)
+    pub fn abs(abs: impl UiNum) -> Len {
+        Len {
+            abs: abs.to_f32(),
+            rel: 0.0,
+            rest: 0.0,
+        }
     }
-    pub fn rel(rel: impl UiNum) -> LayoutLen {
-        LayoutLen::rel(rel)
+    pub fn rel(rel: impl UiNum) -> Len {
+        Len {
+            abs: 0.0,
+            rel: rel.to_f32(),
+            rest: 0.0,
+        }
     }
-    pub fn leftover(ratio: impl UiNum) -> LayoutLen {
-        LayoutLen::leftover(ratio)
+    pub fn rest(ratio: impl UiNum) -> Len {
+        Len {
+            abs: 0.0,
+            rel: 0.0,
+            rest: ratio.to_f32(),
+        }
     }
 }
 
-impl_op!(same LayoutLen Add add; px rel leftover);
-impl_op!(same LayoutLen Sub sub; px rel leftover);
+impl_op!(Len Add add; abs rel rest);
+impl_op!(Len Sub sub; abs rel rest);
 
-impl_op!(same Size Add add; x y);
-impl_op!(same Size Sub sub; x y);
+impl_op!(Size Add add; x y);
+impl_op!(Size Sub sub; x y);
 
-impl Default for LayoutLen {
+impl Default for Len {
     fn default() -> Self {
-        Self::leftover(1.0)
+        Self::rest(1.0)
     }
 }
 
@@ -222,16 +182,16 @@ impl std::fmt::Display for Size {
     }
 }
 
-impl std::fmt::Display for LayoutLen {
+impl std::fmt::Display for Len {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.px != Px::ZERO {
-            write!(f, "{} px;", self.px)?;
+        if self.abs != 0.0 {
+            write!(f, "{} abs;", self.abs)?;
         }
-        if self.rel != Rel::ZERO {
+        if self.rel != 0.0 {
             write!(f, "{} rel;", self.rel)?;
         }
-        if self.leftover != Weight::ZERO {
-            write!(f, "{} leftover;", self.leftover)?;
+        if self.rest != 0.0 {
+            write!(f, "{} rest;", self.rest)?;
         }
         Ok(())
     }

core/src/orientation/pos.rs

@@ -1,46 +1,41 @@
-use std::{fmt::Display, marker::Destruct};
+use std::{fmt::Display, hash::Hash, marker::Destruct};
 
 use super::*;
-use crate::{Px, PxVec2, Rel, UiNum, util::impl_op};
+use crate::{
+    UiNum,
+    util::{LerpUtil, impl_op},
+};
 
 #[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, bytemuck::Pod, bytemuck::Zeroable, Default)]
 pub struct UiVec2 {
-    pub x: Len,
-    pub y: Len,
+    pub x: UiScalar,
+    pub y: UiScalar,
 }
 
 impl UiVec2 {
     pub const ZERO: Self = Self {
-        x: Len::ZERO,
-        y: Len::ZERO,
+        x: UiScalar::ZERO,
+        y: UiScalar::ZERO,
     };
 
-    pub const fn new(x: Len, y: Len) -> Self {
+    pub const fn new(x: UiScalar, y: UiScalar) -> Self {
         Self { x, y }
     }
 
-    pub const fn px(px: impl const Into<Vec2>) -> Self {
-        let px = px.into();
+    pub const fn abs(abs: impl const Into<Vec2>) -> Self {
+        let abs = abs.into();
         Self {
-            x: Len::px(px.x),
-            y: Len::px(px.y),
-        }
-    }
-
-    /// From lengths already on the grid, with no fraction of a box.
-    pub const fn from_px(px: PxVec2) -> Self {
-        Self {
-            x: Len::from_parts(Rel::ZERO, px.x),
-            y: Len::from_parts(Rel::ZERO, px.y),
+            x: UiScalar::abs(abs.x),
+            y: UiScalar::abs(abs.y),
         }
     }
 
     pub const fn rel(rel: impl const Into<Vec2>) -> Self {
         let rel = rel.into();
         Self {
-            x: Len::rel(rel.x),
-            y: Len::rel(rel.y),
+            x: UiScalar::rel(rel.x),
+            y: UiScalar::rel(rel.y),
         }
     }
 
@@ -61,29 +56,37 @@ impl UiVec2 {
         }
     }
 
-    pub fn axis_mut(&mut self, axis: Axis) -> &mut Len {
+    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,
             Axis::Y => &mut self.y,
         }
     }
 
-    pub fn axis(&self, axis: Axis) -> Len {
+    pub fn axis(&self, axis: Axis) -> UiScalar {
         match axis {
             Axis::X => self.x,
             Axis::Y => self.y,
         }
     }
 
-    /// Resolved against a box of `size`, which is where a fraction stops
-    /// being one and becomes a place.
-    pub fn to_px(&self, size: PxVec2) -> PxVec2 {
-        PxVec2::new(self.x.to_px(size.x), self.y.to_px(size.y))
+    pub fn to_abs(&self, rel: Vec2) -> Vec2 {
+        Vec2 {
+            x: self.x.to_abs(rel.x),
+            y: self.y.to_abs(rel.y),
+        }
     }
 
     pub const FULL_SIZE: Self = Self::rel(Vec2::ONE);
 
-    pub const fn from_axis(axis: Axis, aligned: Len, ortho: Len) -> Self {
+    pub const fn from_axis(axis: Axis, aligned: UiScalar, ortho: UiScalar) -> Self {
         match axis {
             Axis::X => Self {
                 x: aligned,
@@ -96,177 +99,178 @@ impl UiVec2 {
         }
     }
 
-    pub fn get_px(&self) -> Vec2 {
-        (self.x.px.to_f32(), self.y.px.to_f32()).into()
+    pub fn get_abs(&self) -> Vec2 {
+        (self.x.abs, self.y.abs).into()
     }
 
     pub fn get_rel(&self) -> Vec2 {
-        (self.x.rel.to_f32(), self.y.rel.to_f32()).into()
+        (self.x.rel, self.y.rel).into()
+    }
+
+    pub fn abs_mut(&mut self) -> Vec2View<'_> {
+        Vec2View {
+            x: &mut self.x.abs,
+            y: &mut self.y.abs,
+        }
     }
 }
 
 impl Display for UiVec2 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "rel{};px{}", self.get_rel(), self.get_px())
+        write!(f, "rel{};abs{}", self.get_rel(), self.get_abs())
     }
 }
 
-impl_op!(same UiVec2 Add add; x y);
-impl_op!(same UiVec2 Sub sub; x y);
+impl_op!(UiVec2 Add add; x y);
+impl_op!(UiVec2 Sub sub; x y);
 
-const impl From<Vec2> for UiVec2 {
-    fn from(px: Vec2) -> Self {
-        Self::px(px)
+impl const From<Vec2> for UiVec2 {
+    fn from(abs: Vec2) -> Self {
+        Self::abs(abs)
     }
 }
 
-const impl<T: const UiNum, U: const UiNum> From<(T, U)> for UiVec2
+impl<T: const UiNum, U: const UiNum> const From<(T, U)> for UiVec2
 where
     (T, U): const Destruct,
 {
-    fn from(px: (T, U)) -> Self {
-        Self::px(px)
+    fn from(abs: (T, U)) -> Self {
+        Self::abs(abs)
     }
 }
 
-/// A length along one axis: a fraction of the box it is measured in plus an
-/// offset, `rel * box + px`. A position is the same number -- the length from
-/// the start of the box to the point -- which is why a [`UiSpan`] is two of
-/// these. Both parts are fixed point, so composing one through a chain of
-/// boxes rounds only where it multiplies, and lands on the same number as any
-/// other route to the same place.
-///
-/// It carries no claim on what a container has left over. That is
-/// [`crate::LayoutLen`], which is this plus a weight, and which means nothing
-/// to anyone but whoever divides the room.
 #[repr(C)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, bytemuck::Pod, Default, bytemuck::Zeroable)]
-pub struct Len {
-    pub rel: Rel,
-    pub px: Px,
+#[derive(Debug, Copy, Clone, bytemuck::Pod, Default, bytemuck::Zeroable)]
+pub struct UiScalar {
+    pub rel: f32,
+    pub abs: f32,
 }
 
-impl_op!(same Len Add add; rel px);
-impl_op!(same Len Sub sub; rel px);
+// TODO: unknown exactly what these should be
+const REL_EPSILON: f32 = 0.00001;
+const ABS_EPSILON: f32 = 0.1;
 
-impl Len {
-    pub const ZERO: Self = Self {
-        rel: Rel::ZERO,
-        px: Px::ZERO,
-    };
-    pub const FULL: Self = Self {
-        rel: Rel::ONE,
-        px: Px::ZERO,
-    };
-
-    pub const fn new(rel: f32, px: f32) -> Self {
-        Self::from_parts(Rel::from_f32(rel), Px::from_f32(px))
+impl PartialEq for UiScalar {
+    fn eq(&self, other: &Self) -> bool {
+        (self.rel - other.rel).abs() < REL_EPSILON && (self.abs - other.abs).abs() < ABS_EPSILON
     }
+}
 
-    /// From parts already on the grid, rather than numbers to be put on it.
-    pub const fn from_parts(rel: Rel, px: Px) -> Self {
-        Self { rel, px }
+impl Eq for UiScalar {}
+impl Hash for UiScalar {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        state.write_u32(self.rel.to_bits());
+        state.write_u32(self.abs.to_bits());
+    }
+}
+
+impl_op!(UiScalar Add add; rel abs);
+impl_op!(UiScalar Sub sub; rel abs);
+
+impl UiScalar {
+    pub const ZERO: Self = Self { rel: 0.0, abs: 0.0 };
+    pub const FULL: Self = Self { rel: 1.0, abs: 0.0 };
+
+    pub const fn new(rel: f32, abs: f32) -> Self {
+        Self { rel, abs }
     }
 
     pub const fn rel(rel: f32) -> Self {
-        Self::from_parts(Rel::from_f32(rel), Px::ZERO)
+        Self { rel, abs: 0.0 }
     }
 
-    pub const fn px(px: f32) -> Self {
-        Self::from_parts(Rel::ZERO, Px::from_f32(px))
+    pub const fn abs(abs: f32) -> Self {
+        Self { rel: 0.0, abs }
     }
 
     pub const fn rel_min() -> Self {
-        Self::ZERO
+        Self::new(0.0, 0.0)
     }
 
     pub const fn rel_max() -> Self {
-        Self::FULL
+        Self::new(1.0, 0.0)
     }
 
     pub const fn max(&self, other: Self) -> Self {
         Self {
             rel: self.rel.max(other.rel),
-            px: self.px.max(other.px),
+            abs: self.abs.max(other.abs),
         }
     }
 
     pub const fn min(&self, other: Self) -> Self {
         Self {
             rel: self.rel.min(other.rel),
-            px: self.px.min(other.px),
+            abs: self.abs.min(other.abs),
         }
     }
 
-    /// Both parts by the same fraction, which is what a part of a length
-    /// means when the length is part pixels and part a fraction of a box.
-    pub const fn scale(&self, by: Rel) -> Self {
-        Self {
-            rel: self.rel.mul(by),
-            px: self.px.mul(by),
-        }
-    }
-
-    pub const fn offset(mut self, amt: Px) -> Self {
-        self.px = self.px.add(amt);
+    pub const fn offset(mut self, amt: f32) -> Self {
+        self.abs += amt;
         self
     }
 
     pub const fn within(&self, span: &UiSpan) -> Self {
+        let anchor = self.rel.lerp(span.start.rel, span.end.rel);
+        let offset = self.abs + self.rel.lerp(span.start.abs, span.end.abs);
         Self {
-            rel: self.rel.lerp(span.start.rel, span.end.rel),
-            px: self.px.add(self.rel.lerp(span.start.px, span.end.px)),
+            rel: anchor,
+            abs: offset,
         }
     }
 
-    pub const fn within_len(&self, len: Len) -> Self {
+    pub const fn outside(&self, span: &UiSpan) -> Self {
+        let rel = self.rel.lerp_inv(span.start.rel, span.end.rel);
+        let abs = self.abs - rel.lerp(span.start.abs, span.end.abs);
+        Self { rel, abs }
+    }
+
+    pub fn within_len(&self, len: UiScalar) -> Self {
         self.within(&UiSpan {
-            start: Len::ZERO,
+            start: UiScalar::ZERO,
             end: len,
         })
     }
 
-    pub fn select_len(&self, len: Len) -> Self {
+    pub fn select_len(&self, len: UiScalar) -> Self {
         len.within_len(*self)
     }
 
     pub const fn flip(&mut self) {
-        self.rel = Rel::ONE.sub(self.rel);
-        self.px = self.px.neg();
+        self.rel = 1.0 - self.rel;
+        self.abs = -self.abs;
     }
 
     pub const fn to(&self, end: Self) -> UiSpan {
         UiSpan { start: *self, end }
     }
 
-    /// Resolved against a box of `len`, which is the only place a fraction
-    /// becomes a number of pixels.
-    pub const fn to_px(&self, len: Px) -> Px {
-        self.px.add(len.mul(self.rel))
+    pub const fn to_abs(&self, rel: f32) -> f32 {
+        self.rel * rel + self.abs
     }
 }
 
 #[repr(C)]
 #[derive(Debug, Copy, Clone, PartialEq, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct UiSpan {
-    pub start: Len,
-    pub end: Len,
+    pub start: UiScalar,
+    pub end: UiScalar,
 }
 
 impl UiSpan {
     pub const FULL: Self = Self {
-        start: Len::ZERO,
-        end: Len::FULL,
+        start: UiScalar::ZERO,
+        end: UiScalar::FULL,
     };
 
     pub const fn rel(rel: f32) -> Self {
         Self {
-            start: Len::rel(rel),
-            end: Len::rel(rel),
+            start: UiScalar::rel(rel),
+            end: UiScalar::rel(rel),
         }
     }
 
-    pub const fn new(start: Len, end: Len) -> Self {
+    pub const fn new(start: UiScalar, end: UiScalar) -> Self {
         Self { start, end }
     }
 
@@ -274,19 +278,14 @@ impl UiSpan {
         self.start.flip();
         self.end.flip();
         std::mem::swap(&mut self.start.rel, &mut self.end.rel);
-        std::mem::swap(&mut self.start.px, &mut self.end.px);
+        std::mem::swap(&mut self.start.abs, &mut self.end.abs);
     }
 
-    pub const fn shift(&mut self, offset: Len) {
+    pub const fn shift(&mut self, offset: UiScalar) {
         self.start += offset;
         self.end += offset;
     }
 
-    /// Composing a box through the one it sits in, and the hottest line in
-    /// layout. It used to skip the multiplies where a span was the whole of
-    /// its parent or the parent the whole of its own; both come out of the
-    /// multiply unchanged anyway, and the body those comparisons cost was
-    /// what kept the inliner from taking this at all.
     pub const fn within(&self, parent: &Self) -> Self {
         Self {
             start: self.start.within(parent),
@@ -294,17 +293,15 @@ impl UiSpan {
         }
     }
 
-    pub const fn len(&self) -> Len {
-        self.end - self.start
+    pub const fn outside(&self, parent: &Self) -> Self {
+        Self {
+            start: self.start.outside(parent),
+            end: self.end.outside(parent),
+        }
     }
 
-    /// Both ends by the same amount, which is what moving a box without
-    /// changing its length does to every part of it.
-    pub const fn translated(self, by: Len) -> Self {
-        Self {
-            start: self.start + by,
-            end: self.end + by,
-        }
+    pub const fn len(&self) -> UiScalar {
+        self.end - self.start
     }
 }
 
@@ -316,17 +313,6 @@ pub struct UiRegion {
 }
 
 impl UiRegion {
-    /// Every part of the box by the same amount on each axis. Done to the
-    /// whole region rather than an end at a time, because that is what it is
-    /// -- and because four adds in a row are four adds, where four asked for
-    /// separately are four sequences.
-    pub const fn translated(self, x: Len, y: Len) -> Self {
-        Self {
-            x: self.x.translated(x),
-            y: self.y.translated(y),
-        }
-    }
-
     pub const FULL: Self = Self {
         x: UiSpan::FULL,
         y: UiSpan::FULL,
@@ -348,7 +334,14 @@ impl UiRegion {
             y: self.y.within(&parent.y),
         }
     }
-    pub const fn axis(&self, axis: Axis) -> &UiSpan {
+    pub const fn outside(&self, parent: &Self) -> Self {
+        Self {
+            x: self.x.outside(&parent.x),
+            y: self.y.outside(&parent.y),
+        }
+    }
+
+    pub const fn axis(&mut self, axis: Axis) -> &UiSpan {
         match axis {
             Axis::X => &self.x,
             Axis::Y => &self.y,
@@ -380,10 +373,10 @@ impl UiRegion {
         self
     }
 
-    pub fn to_px(&self, size: PxVec2) -> PixelRegion {
+    pub fn to_px(&self, size: Vec2) -> PixelRegion {
         PixelRegion {
-            top_left: self.top_left().to_px(size),
-            bot_right: self.bot_right().to_px(size),
+            top_left: self.top_left().get_rel() * size + self.top_left().get_abs(),
+            bot_right: self.bot_right().get_rel() * size + self.bot_right().get_abs(),
         }
     }
 
@@ -438,21 +431,21 @@ impl Display for UiRegion {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug)]
 pub struct PixelRegion {
-    pub top_left: PxVec2,
-    pub bot_right: PxVec2,
+    pub top_left: Vec2,
+    pub bot_right: Vec2,
 }
 
 impl PixelRegion {
-    pub fn contains(&self, pos: PxVec2) -> bool {
+    pub fn contains(&self, pos: Vec2) -> bool {
         pos.x >= self.top_left.x
             && pos.x <= self.bot_right.x
             && pos.y >= self.top_left.y
             && pos.y <= self.bot_right.y
     }
 
-    pub fn size(&self) -> PxVec2 {
+    pub fn size(&self) -> Vec2 {
         self.bot_right - self.top_left
     }
 }
@@ -462,3 +455,20 @@ impl Display for PixelRegion {
         write!(f, "{} -> {}", self.top_left, self.bot_right)
     }
 }
+
+pub struct Vec2View<'a> {
+    pub x: &'a mut f32,
+    pub y: &'a mut f32,
+}
+
+impl Vec2View<'_> {
+    pub fn set(&mut self, other: Vec2) {
+        *self.x = other.x;
+        *self.y = other.y;
+    }
+
+    pub fn add(&mut self, other: Vec2) {
+        *self.x += other.x;
+        *self.y += other.y;
+    }
+}

core/src/primitive/color.rs

@@ -10,12 +10,6 @@ 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);
@@ -150,7 +144,7 @@ impl ColorNum for f32 {
 
 unsafe impl bytemuck::Pod for Color<u8> {}
 
-const impl F32Conversion for f32 {
+impl const F32Conversion for f32 {
     fn to(self) -> f32 {
         self
     }
@@ -159,7 +153,7 @@ const impl F32Conversion for f32 {
     }
 }
 
-const impl F32Conversion for u8 {
+impl const F32Conversion for u8 {
     fn to(self) -> f32 {
         self as f32 / 255.0
     }

core/src/primitive/layer.rs

@@ -1,7 +1,7 @@
 use std::ops::{Index, IndexMut};
 
 use crate::{
-    render::{LayerDraws, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
+    render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives},
     util::to_mut,
 };
 
@@ -39,7 +39,7 @@ struct Child {
     tail: usize,
 }
 
-pub type DrawLayers = Layers<LayerDraws>;
+pub type PrimitiveLayers = Layers<Primitives>;
 
 impl<T: Default> Layers<T> {
     pub fn new() -> Layers<T> {
@@ -119,11 +119,7 @@ impl<T: Default> Layers<T> {
     }
 }
 
-impl DrawLayers {
-    /// Inlined on purpose: it is one call per glyph, the innermost thing a
-    /// frame does, and whether the inliner takes it turns out to depend on
-    /// unrelated code elsewhere in the crate -- 12% of a resize frame.
-    #[inline]
+impl PrimitiveLayers {
     pub fn write<P: Primitive>(
         &mut self,
         layer: LayerId,

core/src/primitive/text.rs

@@ -1,97 +1,60 @@
-#[cfg(feature = "layout-diagnostics")]
-use crate::layout_diagnostics::{self as diag, Counter, TimerKind};
-use crate::{
-    Align, GlyphAtlas, GlyphEntry, GlyphKey, PlacedGlyph, Px, PxVec2, RegionAlign, UiColor,
-    util::Vec2,
-};
-use parley::{
-    Alignment, AlignmentOptions, FontContext, FontFamily, FontFamilyName, GenericFamily, Layout,
-    LayoutContext, LineHeight, PositionedLayoutItem, StyleProperty,
-};
-use std::{
-    collections::VecDeque,
-    hash::{DefaultHasher, Hash, Hasher},
-};
-use swash::{
-    FontRef,
-    scale::{Render, ScaleContext, Source, StrikeWith},
-    zeno::{Format, Vector},
+use crate::{Align, RegionAlign, TextureHandle, Textures, UiColor, util::Vec2};
+use cosmic_text::{
+    Attrs, AttrsList, Buffer, CacheKey, Color, Family, FontSystem, Metrics, Placement, SwashCache,
+    SwashContent,
 };
+use image::{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_ctx: FontContext,
-    pub layout_ctx: LayoutContext<UiColor>,
-    scale_ctx: ScaleContext,
-    pub atlas: GlyphAtlas,
-    spare: VecDeque<Placed>,
+    pub font_system: FontSystem,
+    pub swash_cache: SwashCache,
+    glyph_cache: Vec<(Placement, CacheKey, Color)>,
 }
 
-/// The glyphs of one text at one width. A buffer holds the ones it is drawn
-/// as; these are the ones it had before, kept because a container measures a
-/// child by drawing it in a box it may not keep, and so comes back to widths
-/// it has already asked for.
-struct Placed {
-    /// Where the glyphs land is a function of these three and nothing else,
-    /// so no widget or buffer identity is involved and two texts of the same
-    /// words share an answer.
-    text: String,
-    key: LayoutKey,
-    glyphs: RenderedText,
-}
-
-/// How many to keep. Bounding the whole store rather than each buffer is what
-/// makes this a fixed cost instead of one a tree of ten thousand texts pays
-/// ten thousand times; the re-asks come from laying out one subtree, so they
-/// are close together and few are needed. Instructions over 500 resize frames
-/// of `tests/revision_cost.rs`, both the repeating widths and the sweep that
-/// cannot hit across frames: 13.7B at 32, 12.1B at 64, 10.4B and 12.1B at 128,
-/// and nothing past that -- so 128, which is no worse in the case that never
-/// repeats and better in the one that does.
-const SPARE_PLACED: usize = 128;
-
 impl Default for TextData {
     fn default() -> Self {
         Self {
-            font_ctx: FontContext::new(),
-            layout_ctx: LayoutContext::new(),
-            scale_ctx: ScaleContext::new(),
-            atlas: GlyphAtlas::default(),
-            spare: VecDeque::new(),
+            font_system: FontSystem::new(),
+            swash_cache: SwashCache::new(),
+            glyph_cache: Default::default(),
         }
     }
 }
 
-#[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)]
+#[derive(Clone, Copy)]
 pub struct TextAttrs {
     pub color: UiColor,
     pub font_size: f32,
     pub line_height: f32,
-    pub family: Family,
+    pub family: Family<'static>,
     pub wrap: bool,
+    /// inner alignment of text region (within where it's drawn)
     pub align: RegionAlign,
 }
 
-pub const LINE_HEIGHT_MULT: f32 = 1.1;
+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;
 
 impl Default for TextAttrs {
     fn default() -> Self {
@@ -107,334 +70,118 @@ impl Default for TextAttrs {
     }
 }
 
-/// Keeps text and its corresponding layout from getting out of sync.
-pub struct TextBuffer {
-    text: String,
-    layout: Layout<UiColor>,
-    layout_key: Option<LayoutKey>,
-    /// The glyphs placed from `layout`, so drawing this text again at the
-    /// width it already has places them once.
-    placed: Option<RenderedText>,
-}
-
-#[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,
-            placed: 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;
-            self.placed = None;
-        }
-    }
-
-    /// Invalidates the layout and returns the underlying string for editing.
-    pub fn edit(&mut self) -> &mut String {
-        self.layout_key = None;
-        self.placed = None;
-        &mut self.text
-    }
-
-    /// The glyphs of the shaping it is drawn as, once they are placed.
-    pub fn rendered(&self) -> Option<&RenderedText> {
-        self.placed.as_ref()
-    }
-
-    /// The width its shaping wraps at, and `None` where it does not wrap or
-    /// has not been shaped.
-    pub fn wrap_width(&self) -> Option<f32> {
-        self.layout_key.as_ref()?.max_width
-    }
-
-    /// Widths covered by the current line breaks, including a wider shaping
-    /// retained when a later draw requested a narrower box.
-    pub fn width_holds(&self) -> crate::Holds {
-        let Some(width) = self.wrap_width() else {
-            return crate::Holds::ANY;
-        };
-        let width = Px::from_f32(width);
-        let soft_wrapped = self.layout.lines().any(|line| {
-            matches!(
-                line.break_reason(),
-                parley::layout::BreakReason::Regular | parley::layout::BreakReason::Emergency
-            )
-        });
-        let upper = if soft_wrapped { width } else { Px::MAX };
-        crate::Holds::from(Px::ceil_from_f32(self.layout.width()).min(width)..=upper)
-    }
-
-    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) {
-            #[cfg(feature = "layout-diagnostics")]
-            diag::bump(Counter::TextShapeHits);
-            return;
-        }
-        // A greedy break at one width is the same break at every width down
-        // to the longest line it produced: each line still fits, and none can
-        // take a word that would not fit in the wider box. So the layout in
-        // hand already answers, and re-breaking would only be work.
-        //
-        // At the longest line exactly, with no margin below it. A narrower
-        // width really does break differently, so answering one from the
-        // break in hand is how a warm tree keeps lines a cold tree would
-        // never produce. The margin was here because a text reports the
-        // width it used and a parent hands that back; the report is the step
-        // at or above its longest line now, so what comes back fits.
-        if let Some(key) = &self.layout_key
-            && key.attrs == *attrs
-            && let (Some(broke_at), Some(want)) = (key.max_width, width)
-            && want <= broke_at
-            && want >= self.layout.width()
-        {
-            #[cfg(feature = "layout-diagnostics")]
-            diag::bump(Counter::TextShapeHits);
-            return;
-        }
-        let same_shaping = self
-            .layout_key
-            .as_ref()
-            .is_some_and(|key| key.attrs == *attrs);
-        let old_key = self.layout_key.replace(layout_key);
-        // The glyphs it holds are of the width it held, which the layout may
-        // well come back to.
-        if let Some(key) = old_key
-            && let Some(glyphs) = self.placed.take()
-        {
-            data.keep_placed(Placed {
-                text: self.text.clone(),
-                key,
-                glyphs,
-            });
-        }
-        // Only the line breaking depends on the width: the shaped runs under
-        // it are a function of the text and the attrs, and parley re-breaks
-        // them in place. So a new width is a break, not a shaping.
-        if same_shaping {
-            #[cfg(feature = "layout-diagnostics")]
-            diag::bump(Counter::TextBreaks);
-            #[cfg(feature = "layout-diagnostics")]
-            let _break = diag::timer(TimerKind::TextBreak);
-            self.break_lines(width);
-            return;
-        }
-        #[cfg(feature = "layout-diagnostics")]
-        diag::bump(Counter::TextShapes);
-        #[cfg(feature = "layout-diagnostics")]
-        let _shape = diag::timer(TimerKind::TextShape);
-        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.break_lines(width);
-    }
-
-    fn break_lines(&mut self, width: Option<f32>) {
-        self.layout.break_all_lines(width);
-        self.layout
-            .align(Alignment::Start, AlignmentOptions::default());
-    }
-}
+pub const LINE_HEIGHT_MULT: f32 = 1.1;
 
 impl TextData {
-    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();
-
-                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: PxVec2::new(
-                            Px::from_int(glyph.x.floor() as i32 + entry.left),
-                            Px::from_int(glyph.y.floor() as i32 - entry.top),
-                        ),
-                    });
-                }
-            }
-        }
-        placed
-    }
-
-    fn glyph_entry(&mut self, glyph: GlyphRaster<'_>) -> Option<GlyphEntry> {
-        if let Some(entry) = self.atlas.get(&glyph.key) {
-            return entry;
-        }
-
-        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
-        }
-    }
-}
-
-struct GlyphRaster<'a> {
-    key: GlyphKey,
-    font: FontRef<'a>,
-    font_size: f32,
-    coords: &'a [i16],
-    subpixel: u8,
-    glyph_id: u32,
-}
-
-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 {
-    /// The glyphs of this text at this width, taken out of what is kept.
-    fn take_placed(&mut self, text: &str, key: &LayoutKey) -> Option<RenderedText> {
-        // From the newest, since a re-ask is usually of something recent.
-        let at = self
-            .spare
-            .iter()
-            .rposition(|spare| spare.key == *key && spare.text == text)?;
-        self.spare.remove(at).map(|spare| spare.glyphs)
-    }
-
-    fn keep_placed(&mut self, placed: Placed) {
-        if self.spare.len() >= SPARE_PLACED {
-            self.spare.pop_front();
-        }
-        self.spare.push_back(placed);
-    }
-
-    pub fn render<'b>(
+    pub fn draw(
         &mut self,
-        buffer: &'b mut TextBuffer,
+        buffer: &mut TextBuffer,
         attrs: &TextAttrs,
-        width: Option<f32>,
-    ) -> &'b RenderedText {
-        #[cfg(feature = "layout-diagnostics")]
-        diag::bump(Counter::TextRenders);
-        #[cfg(feature = "layout-diagnostics")]
-        let _render = diag::timer(TimerKind::TextRender);
-        buffer.shape(self, attrs, width);
-        // Only asked for when the buffer no longer holds them: taking one out
-        // of the store to then drop it would throw an answer away.
-        let placed = buffer.placed.take().or_else(|| {
-            let key = buffer.layout_key.as_ref()?;
-            self.take_placed(&buffer.text, key)
-        });
-        let placed = match placed {
-            Some(placed) => placed,
-            None => {
-                #[cfg(feature = "layout-diagnostics")]
-                diag::bump(Counter::GlyphPlacements);
-                #[cfg(feature = "layout-diagnostics")]
-                let _place = diag::timer(TimerKind::GlyphPlacement);
-                RenderedText {
-                    glyphs: self.place(buffer),
-                    size: buffer.size(),
-                    color: attrs.color,
+        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,
+                };
+
+                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));
                 }
             }
-        };
-        buffer.placed.insert(placed)
+            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);
+                    }
+                }
+            }
+        }
+
+        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();
+        }
+
+        RenderedText {
+            handle: textures.add(image),
+            top_left_offset: Vec2::new(min_x as f32, min_y as f32),
+            size: Vec2::new(max_width, height),
+        }
     }
 }
+
+#[derive(Clone)]
+pub struct RenderedText {
+    pub handle: TextureHandle,
+    pub top_left_offset: Vec2,
+    pub size: Vec2,
+}

core/src/primitive/texture.rs

@@ -1,4 +1,7 @@
-use crate::util::{RefCounter, Vec2};
+use crate::{
+    render::TexturePrimitive,
+    util::{RefCounter, Vec2},
+};
 use image::{DynamicImage, GenericImageView};
 use std::{
     ops::Index,
@@ -7,7 +10,7 @@ use std::{
 
 #[derive(Debug, Clone)]
 pub struct TextureHandle {
-    slot: u32,
+    inner: TexturePrimitive,
     size: Vec2,
     counter: RefCounter,
     send: Sender<u32>,
@@ -26,26 +29,14 @@ 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),
 }
 
@@ -63,8 +54,14 @@ 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 {
-            slot: self.push(image),
+            inner: TexturePrimitive {
+                view_idx,
+                sampler_idx,
+            },
             size,
             counter: RefCounter::new(),
             send: self.send.clone(),
@@ -84,23 +81,6 @@ 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;
@@ -119,19 +99,14 @@ 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 {
-    /// Index into `Textures`, and into the renderer's parallel slots.
-    pub fn slot(&self) -> u32 {
-        self.slot
+    pub fn primitive(&self) -> TexturePrimitive {
+        self.inner
     }
     pub fn size(&self) -> Vec2 {
         self.size
@@ -141,7 +116,7 @@ impl TextureHandle {
 impl Drop for TextureHandle {
     fn drop(&mut self) {
         if self.counter.drop() {
-            let _ = self.send.send(self.slot);
+            let _ = self.send.send(self.inner.view_idx);
         }
     }
 }
@@ -150,7 +125,7 @@ impl Index<&TextureHandle> for Textures {
     type Output = DynamicImage;
 
     fn index(&self, index: &TextureHandle) -> &Self::Output {
-        self.images[index.slot as usize].as_ref().unwrap()
+        self.images[index.inner.view_idx as usize].as_ref().unwrap()
     }
 }
 

core/src/render/atlas.rs

@@ -1,247 +0,0 @@
-use crate::{
-    PatchRect, PxVec2,
-    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,
-    /// Whole pixels from the origin of the text to this glyph's top-left,
-    /// on the grid once here rather than on every frame that draws it.
-    pub offset: PxVec2,
-}

core/src/render/data.rs

@@ -1,30 +1,31 @@
-use crate::{UiRegion, util::Id, util::Vec2};
+use crate::{UiRegion, util::Id};
 use wgpu::*;
 
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable, Default)]
 pub struct WindowUniform {
-    pub dim: Vec2,
+    pub width: f32,
+    pub height: f32,
 }
 
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct PrimitiveInstance {
     pub region: UiRegion,
+    pub binding: u32,
+    pub idx: u32,
     pub mask_idx: MaskIdx,
-    pub move_idx: MoveIdx,
 }
 
 impl PrimitiveInstance {
-    // The region's four scalars, each a `Rel` beside a `Px`: whole counts
-    // that the shader decodes, rather than the numbers themselves.
-    const ATTRIBS: [VertexAttribute; 6] = vertex_attr_array![
-        0 => Sint32x2,
-        1 => Sint32x2,
-        2 => Sint32x2,
-        3 => Sint32x2,
+    const ATTRIBS: [VertexAttribute; 7] = vertex_attr_array![
+        0 => Float32x2,
+        1 => Float32x2,
+        2 => Float32x2,
+        3 => Float32x2,
         4 => Uint32,
         5 => Uint32,
+        6 => Uint32,
     ];
 
     pub fn desc() -> VertexBufferLayout<'static> {
@@ -46,45 +47,4 @@ impl MaskIdx {
 #[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct Mask {
     pub region: UiRegion,
-    pub move_idx: MoveIdx,
-}
-
-/// Its own type rather than another `Id<u32>`, because it sits beside
-/// `MaskIdx` in an instance and the two must not be swappable.
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, bytemuck::Pod, bytemuck::Zeroable)]
-pub struct MoveIdx(u32);
-
-impl MoveIdx {
-    pub const NONE: Self = Self(u32::MAX);
-
-    pub(crate) fn slot(idx: usize) -> Self {
-        Self(idx as u32)
-    }
-
-    pub(crate) fn idx(self) -> usize {
-        self.0 as usize
-    }
-}
-
-/// One link of the chain a primitive's position is resolved through: the box
-/// its contents are placed within, given in the coordinates of the slot it
-/// names. Moving or resizing a subtree writes its own slot and nothing else.
-///
-/// The identity is `UiRegion::FULL`, not zero: a zeroed entry is a box of no
-/// extent, which collapses everything under it to a point.
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct MoveOffset {
-    pub region: UiRegion,
-    pub parent: MoveIdx,
-}
-
-unsafe impl bytemuck::Pod for MoveOffset {}
-unsafe impl bytemuck::Zeroable for MoveOffset {}
-
-impl MoveOffset {
-    pub fn new(parent: MoveIdx, region: UiRegion) -> Self {
-        Self { region, parent }
-    }
 }

core/src/render/mod.rs

@@ -1,255 +1,204 @@
+use std::num::NonZero;
+
 use crate::{
-    UiData, UiRenderState,
-    render::{data::PrimitiveInstance, util::ArrBuf},
-    util::{HashMap, Vec2},
+    Ui,
+    render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf},
+    util::HashMap,
 };
 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, MoveIdx, MoveOffset};
+pub use data::{Mask, MaskIdx};
 pub use primitive::*;
 
-const PRELUDE: &str = include_str!("./shader/prelude.wgsl");
-
-fn module_source(wgsl: &str) -> String {
-    // The steps come from the same constants the CPU counts in, rather than
-    // a second copy of them written into the shader: a grid the two disagree
-    // about puts every coordinate somewhere else.
-    format!(
-        "const PX_STEP: f32 = 1.0 / {}.0;\nconst REL_STEP: f32 = 1.0 / {}.0;\n{PRELUDE}\n{wgsl}",
-        1u32 << crate::PX_SHIFT,
-        1u32 << crate::REL_SHIFT,
-    )
-}
+const SHAPE_SHADER: &str = include_str!("./shader.wgsl");
 
 pub struct UiRenderNode {
-    shared_layout: BindGroupLayout,
-    shared_group: BindGroup,
-    format: TextureFormat,
+    uniform_group: BindGroup,
+    primitive_layout: BindGroupLayout,
+    rsc_layout: BindGroupLayout,
+    rsc_group: BindGroup,
 
-    /// One per registered primitive, in id order.
-    primitives: Vec<PrimitivePipeline>,
+    pipeline: RenderPipeline,
 
     layers: HashMap<usize, RenderLayer>,
     active: Vec<usize>,
     window_buffer: Buffer,
+    textures: GpuTextures,
     masks: ArrBuf<Mask>,
-    moves: ArrBuf<MoveOffset>,
 }
 
 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>,
-    data: ArrBuf<u8>,
-    group: Option<BindGroup>,
-    /// What the primitive asked to keep per instance, if anything.
-    bindings: Vec<u32>,
+    primitives: PrimitiveBuffers,
+    primitive_group: BindGroup,
 }
 
 impl UiRenderNode {
     pub fn draw<'a>(&'a self, pass: &mut RenderPass<'a>) {
-        pass.set_bind_group(0, &self.shared_group, &[]);
+        pass.set_pipeline(&self.pipeline);
+        pass.set_bind_group(0, &self.uniform_group, &[]);
+        pass.set_bind_group(2, &self.rsc_group, &[]);
         for i in &self.active {
             let layer = &self.layers[i];
-            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,
-                    },
-                );
+            if layer.instance.len() == 0 {
+                continue;
             }
+            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);
         }
     }
 
-    pub fn update(
-        &mut self,
-        device: &Device,
-        queue: &Queue,
-        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);
+    pub fn update(&mut self, device: &Device, queue: &Queue, ui: &mut Ui) {
         self.active.clear();
-        for (i, draws) in ui_render.layers.iter_mut() {
+        for (i, primitives) in ui.layers.iter_mut() {
             self.active.push(i);
-            for change in draws.apply_free() {
-                if let Some(inst) = ui_render.active.get_mut(&change.id) {
-                    for primitive in &mut inst.primitives {
-                        let h = &mut primitive.handle;
-                        if h.layer == i && h.kind == change.kind && h.inst_idx == change.old {
+            for change in primitives.apply_free() {
+                if let Some(inst) = ui.active.get_mut(&change.id) {
+                    for h in &mut inst.primitives {
+                        if h.layer == i && h.inst_idx == change.old {
                             h.inst_idx = change.new;
                             break;
                         }
                     }
                 }
             }
-            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);
+            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,
                 }
-                draws.updated = false;
+            });
+            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;
             }
         }
-        for primitive in &mut self.primitives {
-            primitive.render.update(ui);
-        }
-        let mut regroup = false;
+        let mut changed = false;
+        changed |= self.textures.update(&mut ui.textures);
         if ui.masks.changed {
             ui.masks.changed = false;
-            regroup |= self.masks.update(device, queue, &ui.masks[..]);
+            self.masks.update(device, queue, &ui.masks[..]);
+            changed = true;
         }
-        if ui_render.moves.changed {
-            ui_render.moves.changed = false;
-            regroup |= self.moves.update(device, queue, ui_render.moves.entries());
-        }
-        if regroup {
-            self.shared_group = Self::shared_group(
-                device,
-                &self.shared_layout,
-                &self.window_buffer,
-                &self.masks,
-                &self.moves,
-            );
+        if changed {
+            self.rsc_group = Self::rsc_group(device, &self.rsc_layout, &self.textures, &self.masks);
         }
     }
 
-    pub fn resize(&mut self, size: impl Into<Vec2>, queue: &Queue) {
-        let size = size.into();
-        let slice = &[WindowUniform { dim: size }];
+    pub fn resize(&mut self, size: &PhysicalSize<u32>, queue: &Queue) {
+        let slice = &[WindowUniform {
+            width: size.width as f32,
+            height: size.height as f32,
+        }];
         queue.write_buffer(&self.window_buffer, 0, bytemuck::cast_slice(slice));
     }
 
-    pub fn new(device: &Device, config: &SurfaceConfiguration) -> Self {
-        let window_uniform = WindowUniform {
-            dim: Vec2::new(config.width as f32, config.height as f32),
-        };
+    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();
         let window_buffer = device.create_buffer_init(&BufferInitDescriptor {
             label: Some("window"),
             contents: bytemuck::cast_slice(&[window_uniform]),
             usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
         });
 
-        let shared_layout = Self::shared_layout(device);
+        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 masks = ArrBuf::new(
             device,
             BufferUsages::STORAGE | BufferUsages::COPY_DST,
             "ui masks",
         );
-        let moves = ArrBuf::new(
-            device,
-            BufferUsages::STORAGE | BufferUsages::COPY_DST,
-            "ui move offsets",
-        );
-        let shared_group =
-            Self::shared_group(device, &shared_layout, &window_buffer, &masks, &moves);
 
-        Self {
-            shared_layout,
-            shared_group,
-            format: config.format,
-            primitives: Vec::new(),
-            window_buffer,
-            layers: HashMap::default(),
-            active: Vec::new(),
-            masks,
-            moves,
-        }
-    }
+        let rsc_layout = Self::rsc_layout(device, &limits);
+        let rsc_group = Self::rsc_group(device, &rsc_layout, &tex_manager, &masks);
 
-    /// 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(module_source(wgsl).into()),
+        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
+            label: Some("UI Shape Pipeline Layout"),
+            bind_group_layouts: &[&uniform_layout, &primitive_layout, &rsc_layout],
+            push_constant_ranges: &[],
         });
-        device.create_render_pipeline(&RenderPipelineDescriptor {
-            label: Some(label),
-            layout: Some(layout),
+        let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
+            label: Some("UI Shape Pipeline"),
+            layout: Some(&pipeline_layout),
             vertex: VertexState {
-                module: &module,
+                module: &shader,
                 entry_point: Some("vs_main"),
-                buffers: &[Some(PrimitiveInstance::desc())],
+                buffers: &[PrimitiveInstance::desc()],
                 compilation_options: Default::default(),
             },
             fragment: Some(FragmentState {
-                module: &module,
+                module: &shader,
                 entry_point: Some("fs_main"),
                 targets: &[Some(ColorTargetState {
-                    format,
+                    format: config.format,
                     blend: Some(BlendState::ALPHA_BLENDING),
                     write_mask: ColorWrites::ALL,
                 })],
@@ -270,178 +219,138 @@ impl UiRenderNode {
                 mask: !0,
                 alpha_to_coverage_enabled: false,
             },
-            multiview_mask: None,
+            multiview: 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"),
         })
     }
 
-    /// What every draw in the ui is given: the window, the masks and the
-    /// move chain every position is resolved through.
-    fn shared_layout(device: &Device) -> BindGroupLayout {
+    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 {
         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: BufferSize::new(size_of::<WindowUniform>() as u64),
+                    visibility: ShaderStages::FRAGMENT,
+                    ty: BindingType::Texture {
+                        sample_type: TextureSampleType::Float { filterable: false },
+                        view_dimension: TextureViewDimension::D2,
+                        multisampled: false,
                     },
-                    count: None,
+                    count: Some(NonZero::new(limits.max_textures).unwrap()),
                 },
                 BindGroupLayoutEntry {
                     binding: 1,
                     visibility: ShaderStages::FRAGMENT,
-                    ty: BindingType::Buffer {
-                        ty: BufferBindingType::Storage { read_only: true },
-                        has_dynamic_offset: false,
-                        min_binding_size: BufferSize::new(size_of::<Mask>() as u64),
-                    },
-                    count: None,
+                    ty: BindingType::Sampler(SamplerBindingType::NonFiltering),
+                    count: Some(NonZero::new(limits.max_samplers).unwrap()),
                 },
                 BindGroupLayoutEntry {
                     binding: 2,
-                    visibility: ShaderStages::VERTEX | ShaderStages::FRAGMENT,
+                    visibility: ShaderStages::FRAGMENT,
                     ty: BindingType::Buffer {
                         ty: BufferBindingType::Storage { read_only: true },
                         has_dynamic_offset: false,
-                        min_binding_size: BufferSize::new(size_of::<MoveOffset>() as u64),
+                        min_binding_size: None,
                     },
                     count: None,
                 },
             ],
-            label: Some("ui shared"),
+            label: Some("ui rsc"),
         })
     }
 
-    fn shared_group(
+    fn rsc_group(
         device: &Device,
         layout: &BindGroupLayout,
-        window: &Buffer,
+        tex_manager: &GpuTextures,
         masks: &ArrBuf<Mask>,
-        moves: &ArrBuf<MoveOffset>,
     ) -> BindGroup {
         device.create_bind_group(&BindGroupDescriptor {
             layout,
             entries: &[
                 BindGroupEntry {
                     binding: 0,
-                    resource: window.as_entire_binding(),
+                    resource: BindingResource::TextureViewArray(&tex_manager.views()),
                 },
                 BindGroupEntry {
                     binding: 1,
-                    resource: masks.buffer.as_entire_binding(),
+                    resource: BindingResource::SamplerArray(&tex_manager.samplers()),
                 },
                 BindGroupEntry {
                     binding: 2,
-                    resource: moves.buffer.as_entire_binding(),
+                    resource: masks.buffer.as_entire_binding(),
                 },
             ],
-            label: Some("ui shared"),
+            label: Some("ui rsc"),
         })
     }
 
-    /// 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 fn view_count(&self) -> usize {
+        self.textures.view_count()
     }
 }
 
-impl RenderLayer {
-    fn new() -> Self {
+pub struct UiLimits {
+    max_textures: u32,
+    max_samplers: u32,
+}
+
+impl Default for UiLimits {
+    fn default() -> Self {
         Self {
-            primitives: Vec::new(),
+            max_textures: 100000,
+            max_samplers: 1000,
         }
     }
 }
 
-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(),
-        }
+impl UiLimits {
+    pub fn max_binding_array_elements_per_shader_stage(&self) -> u32 {
+        self.max_textures + 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"),
-            }));
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::module_source;
-    use wgpu::naga::{
-        front::wgsl,
-        valid::{Capabilities, ValidationFlags, Validator},
-    };
-
-    /// Every shader file, composed as the renderer composes it, parses and
-    /// validates with no device -- so an edit that breaks one fails here and
-    /// not in the first window opened.
-    #[test]
-    fn every_shader_validates() {
-        let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/src/render/shader");
-        let mut checked = 0;
-        for entry in std::fs::read_dir(dir).unwrap() {
-            let path = entry.unwrap().path();
-            if path.extension().is_none_or(|e| e != "wgsl") || path.ends_with("prelude.wgsl") {
-                continue;
-            }
-            let source = module_source(&std::fs::read_to_string(&path).unwrap());
-            let module = wgsl::parse_str(&source)
-                .unwrap_or_else(|e| panic!("{}: {}", path.display(), e.emit_to_string(&source)));
-            Validator::new(ValidationFlags::all(), Capabilities::all())
-                .validate(&module)
-                .unwrap_or_else(|e| panic!("{}: {e:?}", path.display()));
-            checked += 1;
-        }
-        assert!(checked > 0, "no shaders found in {dir}");
+    pub fn max_binding_array_sampler_elements_per_shader_stage(&self) -> u32 {
+        self.max_samplers
     }
 }

core/src/render/page.rs

@@ -1,156 +0,0 @@
-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,321 +1,180 @@
-use std::{any::TypeId, marker::PhantomData};
+use std::ops::{Deref, DerefMut};
 
 use crate::{
-    Color, TextureHandle, UiData, UiRegion, WidgetId,
+    Color, UiRegion, WidgetId,
     render::{
-        data::{MaskIdx, MoveIdx, PrimitiveInstance},
-        page::GlyphRender,
-        texture::ImageRender,
+        ArrBuf,
+        data::{MaskIdx, PrimitiveInstance},
     },
-    util::{HashMap, Vec2},
 };
 use bytemuck::Pod;
-use wgpu::{BindGroupLayout, Device, Queue, RenderPass};
+use wgpu::*;
 
-/// 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 {
+pub struct Primitives {
     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 LayerDraws {
+impl Default for Primitives {
     fn default() -> Self {
         Self {
-            primitives: Vec::new(),
+            instances: Default::default(),
+            assoc: Default::default(),
+            data: Default::default(),
+            free: Vec::new(),
             updated: true,
         }
     }
 }
 
-impl LayerDraws {
-    pub fn write<P: Primitive>(
-        &mut self,
-        layer: usize,
-        PrimitiveInst {
-            kind,
-            id,
-            primitive,
-            region,
-            mask_idx,
-            move_idx,
-        }: PrimitiveInst<P>,
-    ) -> PrimitiveHandle {
-        self.updated = true;
-        // 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);
+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>,)*
         }
-        let inst_idx = self.primitives[kind.id as usize]
-            .get_or_insert_with(InstanceList::new::<P>)
-            .push(
-                id,
-                PrimitiveInstance {
-                    region,
-                    mask_idx,
-                    move_idx,
-                },
-                bytemuck::bytes_of(&primitive),
-            );
-        PrimitiveHandle {
-            layer,
-            kind: kind.id,
-            inst_idx,
+
+        pub struct PrimitiveBuffers {
+            $($name: ArrBuf<$ty>,)*
         }
-    }
 
-    pub fn primitives(&self) -> &[Option<InstanceList>] {
-        &self.primitives
-    }
+        impl PrimitiveBuffers {
+            pub fn update(&mut self, device: &Device, queue: &Queue, data: &PrimitiveData) {
+                $(self.$name.update(device, queue, &data.$name);)*
+            }
+        }
 
-    pub fn apply_free(&mut self) -> impl Iterator<Item = PrimitiveChange> {
-        self.primitives
-            .iter_mut()
-            .enumerate()
-            .filter_map(|(kind, list)| Some((kind as u32, list.as_mut()?)))
-            .flat_map(|(kind, list)| list.apply_free(kind))
-    }
+        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),
+                    ),)*
+                }
+            }
+        }
 
-    pub fn free(&mut self, h: &PrimitiveHandle) -> MaskIdx {
-        self.updated = true;
-        self.list(h).free(h.inst_idx)
-    }
+        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!()
+                }
+            }
+        }
 
-    pub fn region_mut(&mut self, h: &PrimitiveHandle) -> &mut UiRegion {
-        self.updated = true;
-        &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")
-    }
+        $(
+            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 kind: PrimitiveKind<P>,
     pub id: WidgetId,
     pub primitive: P,
     pub region: UiRegion,
     pub mask_idx: MaskIdx,
-    pub move_idx: MoveIdx,
+}
+
+impl Primitives {
+    pub fn write<P: Primitive>(
+        &mut self,
+        layer: usize,
+        PrimitiveInst {
+            id,
+            primitive,
+            region,
+            mask_idx,
+        }: 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)
+    }
+
+    /// 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 })
+        })
+    }
+
+    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
+    }
+
+    pub fn region_mut(&mut self, h: &PrimitiveHandle) -> &mut UiRegion {
+        self.updated = true;
+        &mut self.instances[h.inst_idx].region
+    }
 }
 
 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,
 }
@@ -323,12 +182,29 @@ 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, bytemuck::Pod, bytemuck::Zeroable)]
+#[derive(Copy, Clone)]
 pub struct RectPrimitive {
     pub color: Color<u8>,
     pub radius: f32,
@@ -336,10 +212,6 @@ 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 {
@@ -351,51 +223,60 @@ impl RectPrimitive {
     }
 }
 
-/// `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)]
 #[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: `Vec2`'s alignment leaves four bytes of padding
-// here, 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 slot: u32,
+    pub view_idx: u32,
+    pub sampler_idx: u32,
 }
 
-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))
-    }
+pub struct PrimitiveVec<T> {
+    vec: Vec<T>,
+    free: Vec<usize>,
 }
 
-impl From<&TextureHandle> for TexturePrimitive {
-    fn from(handle: &TextureHandle) -> Self {
+impl<T> PrimitiveVec<T> {
+    pub fn new() -> Self {
         Self {
-            slot: handle.slot(),
+            vec: Vec::new(),
+            free: Vec::new(),
         }
     }
+    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

@@ -0,0 +1,178 @@
+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) binding: u32,
+    @location(4) idx: u32,
+    @location(5) 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

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

@@ -1,193 +0,0 @@
-// 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>;
-@group(0) @binding(2)
-var<storage> move_offsets: array<MoveOffset>;
-
-struct WindowUniform {
-    dim: vec2<f32>,
-};
-
-struct Mask {
-    x: RawSpan,
-    y: RawSpan,
-    move_idx: u32,
-}
-
-struct MoveOffset {
-    x: RawSpan,
-    y: RawSpan,
-    parent: u32,
-}
-
-// `PX_STEP` and `REL_STEP` are prepended from `iris_core`'s own constants:
-// what it stores is a whole count of each, both powers of two, so decoding
-// is exact and the number here is the number the CPU decided.
-
-// Every coordinate the CPU decided is a whole count of `PX_STEP`, so one that
-// composes to within half a step of a pixel boundary is on that boundary and
-// belongs to the pixel above it. Flooring the product instead drops a pixel
-// wherever a fraction divides a window exactly: a fifth of 1920 comes out of
-// `REL_STEP` as 383.99998, and five tabs each lose their last column.
-//
-// Taken over the whole coordinate, fraction and pixels summed, since a floor
-// does not distribute over a sum: floored apart, a half of one and a half of
-// the other lose the pixel the two together make.
-fn snap_floor(v: vec2<f32>) -> vec2<f32> {
-    return floor(v + PX_STEP * 0.5);
-}
-
-struct RawScalar {
-    rel: i32,
-    px: i32,
-}
-
-struct RawSpan {
-    start: RawScalar,
-    end: RawScalar,
-}
-
-fn scalar_of(raw: RawScalar) -> Len {
-    return Len(f32(raw.rel) * REL_STEP, f32(raw.px) * PX_STEP);
-}
-
-fn span_of(raw: RawSpan) -> UiSpan {
-    return UiSpan(scalar_of(raw.start), scalar_of(raw.end));
-}
-
-fn scalar_of_pair(raw: vec2<i32>) -> Len {
-    return Len(f32(raw.x) * REL_STEP, f32(raw.y) * PX_STEP);
-}
-
-struct Region {
-    x: UiSpan,
-    y: UiSpan,
-}
-
-const MOVE_NONE: u32 = 4294967295u;
-// Keep in step with `iris_core::CHAIN_LIMIT`. It bounds a malformed cycle
-// rather than any real tree, and the CPU walk uses the same number so both
-// resolve a deep one the same way.
-const CHAIN_LIMIT: u32 = 64u;
-
-// The same expression `Len::within` uses, in floats rather than on the
-// CPU's grid: a move is resolved here so that scrolling a subtree writes one
-// entry instead of walking it. What has to hold is that this agrees with
-// itself frame to frame, not that it matches the CPU to the last bit.
-fn scalar_within(s: Len, p: UiSpan) -> Len {
-    return Len(
-        p.start.rel + (p.end.rel - p.start.rel) * s.rel,
-        s.px + (p.start.px + (p.end.px - p.start.px) * s.rel),
-    );
-}
-
-fn span_within(s: UiSpan, p: UiSpan) -> UiSpan {
-    return UiSpan(scalar_within(s.start, p), scalar_within(s.end, p));
-}
-
-fn resolve_move(idx: u32, local: Region) -> Region {
-    var r = local;
-    var at = idx;
-    for (var step = 0u; step < CHAIN_LIMIT; step++) {
-        if at == MOVE_NONE {
-            break;
-        }
-        let entry = move_offsets[at];
-        r = Region(span_within(r.x, span_of(entry.x)), span_within(r.y, span_of(entry.y)));
-        at = entry.parent;
-    }
-    return r;
-}
-
-struct UiSpan {
-    start: Len,
-    end: Len,
-}
-
-struct Len {
-    rel: f32,
-    px: f32,
-}
-
-struct InstanceInput {
-    @location(0) x_start: vec2<i32>,
-    @location(1) x_end: vec2<i32>,
-    @location(2) y_start: vec2<i32>,
-    @location(3) y_end: vec2<i32>,
-    @location(4) mask_idx: u32,
-    @location(5) move_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 local = Region(
-        UiSpan(scalar_of_pair(in.x_start), scalar_of_pair(in.x_end)),
-        UiSpan(scalar_of_pair(in.y_start), scalar_of_pair(in.y_end)),
-    );
-    let r = resolve_move(in.move_idx, local);
-    let top_left_rel = vec2(r.x.start.rel, r.y.start.rel);
-    let top_left_px = vec2(r.x.start.px, r.y.start.px);
-    let bot_right_rel = vec2(r.x.end.rel, r.y.end.rel);
-    let bot_right_px = vec2(r.x.end.px, r.y.end.px);
-
-    let top_left = snap_floor(top_left_rel * window.dim + top_left_px);
-    let bot_right = snap_floor(bot_right_rel * window.dim + bot_right_px);
-    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];
-    // Its own chain, not the drawn primitive's, so a stationary viewport
-    // clips content that moves inside it.
-    let m = resolve_move(mask.move_idx, Region(span_of(mask.x), span_of(mask.y)));
-    let tl = vec2(m.x.start.rel, m.y.start.rel);
-    let tl_px = vec2(m.x.start.px, m.y.start.px);
-    let br = vec2(m.x.end.rel, m.y.end.rel);
-    let br_px = vec2(m.x.end.px, m.y.end.px);
-
-    let top_left = snap_floor(tl * window.dim + tl_px);
-    let bot_right = snap_floor(br * window.dim + br_px);
-    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

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

@@ -1,10 +0,0 @@
-// 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,119 +1,59 @@
-use image::{DynamicImage, EncodableLayout, GenericImageView, RgbaImage};
+use image::{DynamicImage, EncodableLayout};
 use wgpu::{util::DeviceExt, *};
 
-use crate::{
-    PatchRect, TextureUpdate, Textures, UiData,
-    render::{
-        TexturePrimitive,
-        primitive::{ListDraw, PrimitiveRender},
-    },
-};
+use crate::{TextureUpdate, Textures};
 
-/// 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,
-    slots: Vec<Option<ImageGpu>>,
-}
-
-struct ImageGpu {
-    /// Kept for `patch`, which needs the texture rather than the view.
-    texture: Texture,
-    group: BindGroup,
+    views: Vec<TextureView>,
+    view_count: usize,
+    samplers: Vec<Sampler>,
+    null_view: TextureView,
+    no_views: Vec<TextureView>,
 }
 
 impl GpuTextures {
-    pub fn new(device: &Device, queue: &Queue) -> Self {
-        Self {
-            device: device.clone(),
-            queue: queue.clone(),
-            slots: Vec::new(),
-        }
-    }
-
-    pub fn update(&mut self, textures: &mut Textures, layout: &BindGroupLayout, sampler: &Sampler) {
+    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) => {
-                    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,
+                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(),
             }
         }
+        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());
     }
 
-    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();
+    fn create_view(&self, image: &DynamicImage) -> TextureView {
+        let image = image.to_rgba8();
+        let (width, height) = image.dimensions();
         let texture = self.device.create_texture_with_data(
             &self.queue,
             &TextureDescriptor {
-                label: Some("image"),
+                label: None,
                 size: Extent3d {
                     width,
                     height,
@@ -123,119 +63,65 @@ impl GpuTextures {
                 sample_count: 1,
                 dimension: TextureDimension::D2,
                 format: TextureFormat::Rgba8Unorm,
-                usage: TextureUsages::TEXTURE_BINDING | TextureUsages::COPY_DST,
+                usage: TextureUsages::TEXTURE_BINDING,
                 view_formats: &[],
             },
             wgt::TextureDataOrder::MipMajor,
-            rgba.as_bytes(),
+            image.as_bytes(),
         );
-        let view = texture.create_view(&TextureViewDescriptor::default());
-        let group = sampled_group(&self.device, layout, &view, sampler, "ui image");
-        ImageGpu { texture, group }
+        texture.create_view(&TextureViewDescriptor::default())
     }
 
-    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 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,
         }
     }
-}
 
-pub fn write_region(queue: &Queue, dst: TexelCopyTextureInfo, src: &RgbaImage, rect: PatchRect) {
-    if rect.width == 0 || rect.height == 0 {
-        return;
+    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
     }
-    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),
+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,
             },
-            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),
-    })
+            mip_level_count: 1,
+            sample_count: 1,
+            dimension: TextureDimension::D2,
+            format: TextureFormat::Rgba8Unorm,
+            usage: TextureUsages::TEXTURE_BINDING,
+            view_formats: &[],
+        })
+        .create_view(&TextureViewDescriptor::default())
 }
 
 pub fn default_sampler(device: &Device) -> Sampler {

core/src/render/util/mod.rs

@@ -21,25 +21,17 @@ impl<T: Pod> ArrBuf<T> {
             _pd: PhantomData,
         }
     }
-    /// 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 {
+    pub fn update(&mut self, device: &Device, queue: &Queue, data: &[T]) {
+        if self.len != data.len() {
             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 {
@@ -49,4 +41,8 @@ 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,115 +1,16 @@
-use crate::{
-    DrawRegion, LayerId, LayoutHolds, LayoutLen, MaskIdx, MoveIdx, RegionAlign, RetainedPrimitive,
-    Size, TextureHandle, UiRegion, UiVec2, WidgetId,
-};
+use crate::{Align, LayerId, MaskIdx, PrimitiveHandle, TextureHandle, UiRegion, WidgetId};
 
-/// What is kept of a widget its parent has asked about. `drawn` says whether
-/// it currently draws; one that does not is kept so that a change to it, or
-/// under it, still reaches whoever asked.
+/// important non rendering data for retained drawing
 #[derive(Debug)]
 pub struct ActiveData {
     pub id: WidgetId,
-    /// The box its parent gave it, in `parent_move`'s coordinates: what it
-    /// was asked about, and what a fraction under it is a fraction of. A
-    /// local redraw asks here.
     pub region: UiRegion,
-    /// Where its drawing sits inside that box, in the box's own coordinates.
-    pub placement: UiRegion,
-    /// The original frame in its parent widget's coordinates. Recomposition
-    /// and pixel-length evaluation both follow this chain.
-    pub given_region: UiRegion,
-    /// The frame it was first asked in, in the same coordinates: the offer's
-    /// frame, which its parent's placing draw may since have narrowed.
-    pub offer_region: UiRegion,
-    /// The lengths of the box its parent first asked about it in, as
-    /// lengths of the box the parent was itself offered. Any later box it
-    /// was given was decided knowing its answer, so this is the question
-    /// asked again -- and a chain of fractions has no frame in it, which is
-    /// why a region node between two widgets cannot break it.
-    pub offer_len: UiVec2,
-    pub offer_placement: [Option<crate::UiSpan>; 2],
-    /// The measured answer and its dependencies. A hint-only dependency or
-    /// a widget first encountered during placement has no measurement yet.
-    pub answer: Option<(Size, LayoutHolds)>,
-    /// What the widget said it used of its box, the last time it drew.
-    pub size: Size,
-    /// The frame, extent and explicit placement reads that this drawing holds for.
-    pub holds: LayoutHolds,
-    pub drawn: bool,
+    pub region_used: UiRegion,
     pub parent: Option<WidgetId>,
-    /// How far down the tree it was drawn, the root being 1. Carried down a
-    /// draw rather than worked out by walking up, so it is right for every
-    /// widget a frame visits and cannot drift while one is being drawn.
-    pub depth: usize,
     pub textures: Vec<TextureHandle>,
-    pub primitives: Vec<RetainedPrimitive>,
-    pub mask_region: Option<DrawRegion>,
-    /// The children whose box is a part of this widget's extent rather than
-    /// of its frame, and which part each was given. Moving the extent
-    /// re-places them through that part, so the drawing need not depend on
-    /// where it sits.
-    pub(crate) extent_children: Vec<(WidgetId, ExtentPlacement)>,
+    pub primitives: Vec<PrimitiveHandle>,
     pub children: Vec<WidgetId>,
-    /// The children whose size this widget read while drawing.
-    pub size_deps: Vec<WidgetId>,
-    /// The movable region its primitives are positioned through: its own when
-    /// opted in, otherwise the nearest ancestor's.
-    pub move_idx: MoveIdx,
-    /// The declared lengths whoever drew this widget resolved into its box.
-    /// A change to one moves a box this widget cannot fix by drawing again,
-    /// and comparing them is what says so.
-    pub declared: [Option<LayoutLen>; 2],
-    /// The axes along which its parent chose its box from its own answer,
-    /// so a local redraw asks the question its parent asked.
-    pub decided: [bool; 2],
-    /// Its alignment when it was last drawn, which a change to the property
-    /// is found against.
-    pub own_align: RegionAlign,
-    /// The movable region whose coordinates `region` uses.
-    pub parent_move: MoveIdx,
-    /// The mask its drawing is clipped to: one it set itself, or the one it
-    /// inherited from whoever drew it.
     pub mask: MaskIdx,
-    /// That inherited one. The two differ exactly where the widget set a
-    /// mask of its own, which is the one it owns and the one a move rewrites
-    /// -- and the one a redraw of it must not be handed back, since setting
-    /// a mask asserts there is none.
-    pub parent_mask: MaskIdx,
     pub layer: LayerId,
-}
-
-impl ActiveData {
-    /// Whether what it answered still stands for a box of these pixel
-    /// lengths -- the box it was asked in, where `holds` is about the box its
-    /// answer then chose.
-    pub fn answers_at(&self, px: crate::PxVec2) -> bool {
-        self.answer.is_some_and(|(_, holds)| {
-            holds.contains(
-                px,
-                UiRegion {
-                    x: self.offer_placement[0].unwrap_or(crate::UiSpan::FULL),
-                    y: self.offer_placement[1].unwrap_or(crate::UiSpan::FULL),
-                },
-            )
-        })
-    }
-}
-
-/// What of a container's extent a child was given: the whole of it, for a
-/// wrapper whose box is its child's, or a part of it.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub(crate) enum ExtentPlacement {
-    Inherit,
-    Within(UiRegion),
-}
-
-impl ExtentPlacement {
-    /// The child's frame in the container's frame coordinates, and the slot
-    /// the container chose within it.
-    pub fn resolve(self, extent: UiRegion) -> (UiRegion, [Option<crate::UiSpan>; 2]) {
-        match self {
-            Self::Inherit => (UiRegion::FULL, [Some(extent.x), Some(extent.y)]),
-            Self::Within(part) => (part.within(&extent), [None; 2]),
-        }
-    }
+    pub align: Align,
 }

core/src/ui/draw_region.rs

@@ -1,36 +0,0 @@
-use crate::{PrimitiveHandle, UiRegion};
-
-/// Retains which box geometry follows when only the extent changes.
-#[derive(Clone, Copy, Debug)]
-pub enum DrawRegion {
-    Frame(UiRegion),
-    Extent(UiRegion),
-}
-
-impl DrawRegion {
-    pub(crate) fn resolve(self, frame: UiRegion, extent: UiRegion) -> UiRegion {
-        match self {
-            Self::Frame(local) => local.within(&frame),
-            Self::Extent(local) => local.within(&extent).within(&frame),
-        }
-    }
-
-    pub(crate) fn map(self, f: impl FnOnce(UiRegion) -> UiRegion) -> Self {
-        match self {
-            Self::Frame(local) => Self::Frame(f(local)),
-            Self::Extent(local) => Self::Extent(f(local)),
-        }
-    }
-}
-
-impl From<UiRegion> for DrawRegion {
-    fn from(region: UiRegion) -> Self {
-        Self::Frame(region)
-    }
-}
-
-#[derive(Debug)]
-pub struct RetainedPrimitive {
-    pub handle: PrimitiveHandle,
-    pub region: DrawRegion,
-}

core/src/ui/draw_state.rs

@@ -0,0 +1,209 @@
+use crate::{
+    ActiveData, Align, Axis, EventsLike, Painter, Ui, UiRegion, WidgetId,
+    render::MaskIdx,
+    util::{HashSet, forget_ref},
+};
+use std::ops::{Deref, DerefMut};
+
+/// state maintained between widgets during painting
+pub struct DrawState<'a> {
+    pub(super) ui: &'a mut Ui,
+    pub(super) events: &'a mut dyn EventsLike,
+    draw_started: HashSet<WidgetId>,
+}
+
+impl<'a> DrawState<'a> {
+    pub fn new(ui: &'a mut Ui, events: &'a mut dyn EventsLike) -> Self {
+        Self {
+            ui,
+            events,
+            draw_started: Default::default(),
+        }
+    }
+
+    pub fn redraw_updates(&mut self) {
+        while let Some(&id) = self.widgets.needs_redraw.iter().next() {
+            self.redraw(id);
+        }
+        self.ui.free(self.events);
+    }
+
+    /// redraws a widget that's currently active (drawn)
+    pub fn redraw(&mut self, id: WidgetId) {
+        self.widgets.needs_redraw.remove(&id);
+
+        let Some(active) = self.active.get(&id) else {
+            return;
+        };
+        let ActiveData {
+            id,
+            region,
+            parent,
+            mask,
+            layer,
+            align,
+            ..
+        } = *active;
+
+        self.draw_inner(layer, id, region, parent, mask, align);
+    }
+
+    pub fn redraw_all(&mut self) {
+        // free all resources & cache
+        for (_, active) in self.ui.active.drain() {
+            self.events.undraw(&active);
+        }
+        self.ui.free(self.events);
+        self.layers.clear();
+        self.widgets.needs_redraw.clear();
+
+        if let Some(id) = &self.ui.root {
+            self.draw_inner(0, id.id(), UiRegion::FULL, None, MaskIdx::NONE, Align::NONE);
+        }
+    }
+
+    pub(super) fn draw_inner(
+        &mut self,
+        layer: usize,
+        id: WidgetId,
+        region: UiRegion,
+        parent: Option<WidgetId>,
+        mask: MaskIdx,
+        align: Align,
+    ) {
+        let mut old_children = Vec::new();
+        if let Some(active) = self.ui.active.get_mut(&id) {
+            // check to see if we can skip drawing first, and just need to move
+            if !self.ui.widgets.needs_redraw.contains(&id) {
+                if active.region == region {
+                    return;
+                } else if active.region.size() == region.size() {
+                    self.mov(id, active.region, region);
+                    return;
+                }
+            }
+            let active = self.remove(id, false).unwrap();
+            old_children = active.children;
+        }
+
+        // draw widget
+        self.draw_started.insert(id);
+
+        let mut painter = Painter {
+            state: self,
+            region,
+            region_used: region,
+            mask,
+            layer,
+            id,
+            textures: Vec::new(),
+            primitives: Vec::new(),
+            children: Vec::new(),
+        };
+
+        let mut widget = painter.state.widgets.get_dyn(id);
+        widget.draw(&mut painter);
+        let walign = painter.state.widgets.data(id).unwrap().align;
+        let align = align.or(walign.into());
+
+        let Painter {
+            region_used,
+            state: _,
+            region,
+            mask,
+            textures,
+            primitives,
+            children,
+            layer,
+            id,
+        } = painter;
+
+        // remove old children that weren't kept
+        for c in &old_children {
+            if !children.contains(c) {
+                self.remove_rec(*c);
+            }
+        }
+
+        // add to active
+        self.active.insert(
+            id,
+            ActiveData {
+                id,
+                region,
+                parent,
+                textures,
+                primitives,
+                children,
+                region_used,
+                mask,
+                layer,
+            },
+        );
+
+        // TODO: unsure if there's a better way, currently using epsilon
+        // in PartialEq impl for UiScalar
+        let target = region_used.size().align(align);
+        if region_used != target {
+            self.mov(id, from, to);
+        }
+
+        self.events.draw(self.active.get(&id).unwrap());
+    }
+
+    fn mov(&mut self, id: WidgetId, from: UiRegion, to: UiRegion) {
+        let active = self.ui.active.get_mut(&id).unwrap();
+        for h in &active.primitives {
+            let region = self.ui.layers[h.layer].region_mut(h);
+            *region = region.outside(&from).within(&to);
+        }
+        active.region = active.region.outside(&from).within(&to);
+        // SAFETY: children cannot be recursive
+        let children = unsafe { forget_ref(&active.children) };
+        for child in children {
+            self.mov(*child, from, to);
+        }
+    }
+
+    /// NOTE: instance textures are cleared and self.textures freed
+    fn remove(&mut self, id: WidgetId, undraw: bool) -> Option<ActiveData> {
+        let mut active = self.active.remove(&id);
+        if let Some(active) = &mut active {
+            for h in &active.primitives {
+                let mask = self.layers.free(h);
+                if mask != MaskIdx::NONE {
+                    self.masks.remove(mask);
+                }
+            }
+            active.textures.clear();
+            self.textures.free();
+            if undraw {
+                self.events.undraw(active);
+            }
+        }
+        active
+    }
+
+    fn remove_rec(&mut self, id: WidgetId) -> Option<ActiveData> {
+        let inst = self.remove(id, true);
+        if let Some(inst) = &inst {
+            for c in &inst.children {
+                self.remove_rec(*c);
+            }
+        }
+        inst
+    }
+}
+
+impl Deref for DrawState<'_> {
+    type Target = Ui;
+
+    fn deref(&self) -> &Self::Target {
+        self.ui
+    }
+}
+impl DerefMut for DrawState<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.ui
+    }
+}

core/src/ui/holds.rs

@@ -1,178 +0,0 @@
-use crate::{Len, Px, REL_SHIFT, fixed::div_toward, fixed::narrow};
-use std::ops::RangeInclusive;
-
-/// The lengths of a box, in pixels, that one drawing of a widget holds for:
-/// give the widget any box in this range and it draws the same thing and
-/// reports the same size. A widget that never reads its box in pixels holds
-/// for every length; one that does holds for the one it read unless it says
-/// otherwise, and a parent holds for whatever keeps every child it asked
-/// about or drew inside its own range.
-///
-/// The ends are lengths on the grid rather than floats with a tolerance
-/// around them: a box offered back at the length a widget reported comes back
-/// as the same number, so a range means what it says. The one place a range
-/// is wider than the length it came from is [`Self::through`], and what it is
-/// wider by is the floor that inverting a fraction undoes.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct Holds {
-    pub lo: Px,
-    pub hi: Px,
-}
-
-impl Holds {
-    pub const ANY: Self = Self {
-        lo: Px::MIN,
-        hi: Px::MAX,
-    };
-
-    pub const fn at(len: Px) -> Self {
-        Self { lo: len, hi: len }
-    }
-
-    pub const fn contains(&self, len: Px) -> bool {
-        len.raw() >= self.lo.raw() && len.raw() <= self.hi.raw()
-    }
-
-    pub const fn and(self, other: Self) -> Self {
-        Self {
-            lo: self.lo.max(other.lo),
-            hi: self.hi.min(other.hi),
-        }
-    }
-
-    /// What a box has to be for a part of it, `len` of the box long, to stay
-    /// in this range: the exact preimage of `px + floor(rel * box)`, which is
-    /// the one way a box in pixels is reached. A part with no relative extent
-    /// is a fixed length -- it was drawn at that length and any box keeps it
-    /// there.
-    ///
-    /// The answer is an interval even where this range is a single length,
-    /// because the multiply on the way in drops to the step below and many
-    /// boxes therefore give one length. That is a floor rather than an
-    /// allowance: inverting it is two divisions and nothing else, and the
-    /// whole of a box maps back to itself.
-    pub const fn through(self, len: Len) -> Self {
-        if self.lo.raw() == Px::MIN.raw() && self.hi.raw() == Px::MAX.raw() {
-            return Self::ANY;
-        }
-        let rel = len.rel.raw() as i64;
-        if rel == 0 {
-            return Self::ANY;
-        }
-        let px = len.px.raw() as i64;
-        // `floor(rel * box) >= lo - px` is `rel * box >= (lo - px) << REL`, and
-        // `floor(rel * box) <= hi - px` is `rel * box < (hi - px + 1) << REL`.
-        let lo = (self.lo.raw() as i64 - px) << REL_SHIFT;
-        let hi = (((self.hi.raw() as i64 - px) + 1) << REL_SHIFT) - 1;
-        // Dividing by a negative fraction turns the ends around, so which
-        // bound each comes from is decided before dividing rather than by
-        // taking the min and max of four divisions.
-        match rel > 0 {
-            true => Self::raws(div_toward(lo, rel, true), div_toward(hi, rel, false)),
-            false => Self::raws(div_toward(hi, rel, true), div_toward(lo, rel, false)),
-        }
-    }
-
-    const fn raws(lo: i64, hi: i64) -> Self {
-        Self {
-            lo: Px::from_raw(narrow(lo)),
-            hi: Px::from_raw(narrow(hi)),
-        }
-    }
-}
-
-impl From<RangeInclusive<Px>> for Holds {
-    fn from(range: RangeInclusive<Px>) -> Self {
-        Self {
-            lo: *range.start(),
-            hi: *range.end(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::Rel;
-
-    #[test]
-    fn an_unrestricted_range_stays_unrestricted_through_any_length() {
-        for rel in [-2.0, -0.5, 0.0, 0.5, 1.0, 2.0] {
-            for px in [-8, 0, 8] {
-                let len = Len::from_parts(Rel::from_f32(rel), Px::from_int(px));
-                assert_eq!(Holds::ANY.through(len), Holds::ANY);
-            }
-        }
-    }
-
-    #[test]
-    fn through_reverses_a_range_for_a_negative_fraction() {
-        // `10 - box / 2` is between 20 and 40 for boxes from -60 to -20.
-        let part = Len::from_parts(Rel::from_f32(-0.5), Px::from_int(10));
-        let holds = Holds::from(Px::from_int(20)..=Px::from_int(40)).through(part);
-        assert!(holds.contains(Px::from_int(-60)) && holds.contains(Px::from_int(-20)));
-        assert!(!holds.contains(Px::from_int(-61)) && !holds.contains(Px::from_int(-19)));
-    }
-
-    /// The case the widening is for: a part that holds only for the length it
-    /// was drawn at has to hold for the box it was drawn in, and a third of a
-    /// box is not a whole number of steps.
-    #[test]
-    fn a_part_maps_back_onto_the_box_it_was_measured_in() {
-        let part = Len::from_parts(Rel::from_f32(1.0 / 3.0), Px::from_int(-146));
-        for box_len in (440..460).map(Px::from_int) {
-            let holds = Holds::at(part.to_px(box_len)).through(part);
-            assert!(holds.contains(box_len), "{box_len:?} left out by {holds:?}");
-        }
-    }
-
-    /// A widget handed the whole of its parent's box, with or without pixels
-    /// taken off it, has no fraction to invert: multiplying by one is exact
-    /// and taking the pixels off again is too, so the box maps back to
-    /// itself. Allowing for anything here compounded a step a level down a
-    /// chain of widgets each taking the whole of its parent.
-    #[test]
-    fn the_whole_of_a_box_maps_back_to_itself() {
-        let at = Px::from_int(956);
-        assert_eq!(Holds::at(at).through(Len::FULL), Holds::at(at));
-        let less_eight = Len::from_parts(Rel::ONE, Px::from_int(-8));
-        assert_eq!(
-            Holds::at(at).through(less_eight),
-            Holds::at(at + Px::from_int(8))
-        );
-    }
-
-    /// The range is the exact preimage at both ends, so a box one step
-    /// outside it really does give a length outside this range. What a wider
-    /// range costs is a drawing reused where it does not hold.
-    #[test]
-    fn a_box_one_step_outside_the_range_is_outside_it() {
-        let part = Len::from_parts(Rel::from_f32(1.0 / 3.0), Px::from_int(-146));
-        let at = Px::from_int(300);
-        let holds = Holds::at(at).through(part);
-        for inside in [holds.lo, holds.hi] {
-            assert_eq!(part.to_px(inside), at, "{inside:?} left out of {holds:?}");
-        }
-        for outside in [holds.lo.next_down(), holds.hi.next_up()] {
-            assert_ne!(part.to_px(outside), at, "{outside:?} admitted by {holds:?}");
-        }
-    }
-
-    /// A truncating multiply only ever drops, so the step it needs allowing
-    /// for on the way in belongs at the top of the range and not the bottom.
-    #[test]
-    fn a_fraction_widens_further_up_than_down() {
-        let half = Len::from_parts(Rel::from_f32(0.5), Px::ZERO);
-        let holds = Holds::at(Px::from_int(100)).through(half);
-        let box_len = Px::from_int(200);
-        assert!(holds.hi - box_len > box_len - holds.lo, "{holds:?}");
-    }
-
-    #[test]
-    fn a_boundary_the_next_step_along_does_not_admit_it() {
-        let boundary = Px::from_int(10);
-        let above = Holds::from(boundary.next_up()..=Px::MAX);
-        assert!(!above.contains(boundary));
-        assert!(above.contains(boundary.next_up()));
-    }
-}

core/src/ui/layout_holds.rs

@@ -1,63 +0,0 @@
-use crate::{Axis, Holds, PxVec2, UiRegion};
-
-/// Dependencies of one evaluation, before the frame and extent are composed.
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub struct LayoutHolds {
-    pub frame: [Holds; 2],
-    pub extent: [Holds; 2],
-    pub placement: Option<UiRegion>,
-}
-
-impl LayoutHolds {
-    pub const ANY: Self = Self {
-        frame: [Holds::ANY; 2],
-        extent: [Holds::ANY; 2],
-        placement: None,
-    };
-
-    pub fn and(self, other: Self) -> Self {
-        debug_assert!(
-            self.placement.is_none()
-                || other.placement.is_none()
-                || self.placement == other.placement
-        );
-        Self {
-            frame: [
-                self.frame[0].and(other.frame[0]),
-                self.frame[1].and(other.frame[1]),
-            ],
-            extent: [
-                self.extent[0].and(other.extent[0]),
-                self.extent[1].and(other.extent[1]),
-            ],
-            placement: self.placement.or(other.placement),
-        }
-    }
-
-    pub fn covers(self, other: Self) -> bool {
-        self.placement
-            .is_none_or(|placement| other.placement == Some(placement))
-            && [0, 1].into_iter().all(|n| {
-                self.frame[n].lo <= other.frame[n].lo
-                    && self.frame[n].hi >= other.frame[n].hi
-                    && self.extent[n].lo <= other.extent[n].lo
-                    && self.extent[n].hi >= other.extent[n].hi
-            })
-    }
-
-    pub fn contains(self, px: PxVec2, placement: UiRegion) -> bool {
-        self.placement.is_none_or(|old| old == placement)
-            && [Axis::X, Axis::Y].into_iter().all(|axis| {
-                self.frame[axis as usize].contains(px.axis(axis))
-                    && self.extent[axis as usize]
-                        .contains(placement.axis(axis).len().to_px(px.axis(axis)))
-            })
-    }
-
-    pub fn in_frame(self, placement: UiRegion) -> [Holds; 2] {
-        [Axis::X, Axis::Y].map(|axis| {
-            self.frame[axis as usize]
-                .and(self.extent[axis as usize].through(placement.axis(axis).len()))
-        })
-    }
-}

core/src/ui/mod.rs

@@ -1,149 +1,211 @@
 use crate::{
-    Mask, MoveIdx, MoveOffset, PrimitiveRegistry, TextData, Textures, UiRegion, WeakWidget,
-    WidgetId, Widgets,
-    util::{Arena, Id, TrackedArena},
+    EventsLike, IdLike, Mask, PixelRegion, PrimitiveLayers, TextData, TextureHandle, Textures,
+    Widget, WidgetHandle, WidgetId, Widgets,
+    ui::draw_state::DrawState,
+    util::{HashMap, TrackedArena, Vec2},
+};
+use image::DynamicImage;
+use std::{
+    ops::{Index, IndexMut},
+    sync::mpsc::{Receiver, channel},
 };
 
-/// How far the shader will walk a move chain. It bounds a malformed cycle
-/// rather than any real tree; `Moves::resolve` uses the same number so the
-/// two agree on what a deep tree resolves to.
-pub const CHAIN_LIMIT: u32 = 64;
-
 mod active;
-mod draw_region;
-mod holds;
-mod layout_holds;
+mod draw_state;
 mod painter;
-mod render_state;
+mod state;
 
 pub use active::*;
-pub use draw_region::*;
-pub use holds::*;
-pub use layout_holds::*;
-pub use painter::{Painter, PrimitiveLike};
-pub use render_state::*;
+pub use painter::Painter;
 
-#[derive(Default)]
-pub struct UiData {
+pub struct Ui {
+    // TODO: edit visibilities
     pub widgets: Widgets,
-    /// Every primitive this ui can draw.
-    pub primitives: PrimitiveRegistry,
+
+    // retained painter state
+    pub active: HashMap<WidgetId, ActiveData>,
+    pub layers: PrimitiveLayers,
     pub textures: Textures,
     pub text: TextData,
+    output_size: Vec2,
     pub masks: TrackedArena<Mask, u32>,
+
+    pub root: Option<WidgetHandle>,
+    old_root: Option<WidgetId>,
+    recv: Receiver<WidgetId>,
+    resized: bool,
 }
 
-/// Where each widget's drawing sits relative to its parent's slot, so moving
-/// a subtree writes one entry rather than every descendant's primitives.
-#[derive(Default)]
-pub struct Moves {
-    arena: Arena<MoveOffset, u32>,
-    pub changed: bool,
+pub trait HasUi: Sized {
+    fn get(&self) -> &Ui;
+    fn get_mut(&mut self) -> &mut Ui;
+    fn ui(&self) -> &Ui {
+        self.get()
+    }
+    fn ui_mut(&mut self) -> &mut Ui {
+        self.get_mut()
+    }
 }
 
-impl Moves {
-    pub fn push(&mut self, parent: MoveIdx, region: UiRegion) -> MoveIdx {
-        self.changed = true;
-        MoveIdx::slot(self.arena.push(MoveOffset::new(parent, region)).idx())
+impl HasUi for Ui {
+    fn get(&self) -> &Ui {
+        self
     }
 
-    /// Re-points a slot at a different parent, for a widget drawn somewhere
-    /// else in the tree than it was.
-    pub fn set_parent(&mut self, idx: MoveIdx, parent: MoveIdx) {
-        let entry = self.arena.get_mut(Id::preset(idx.idx() as u32));
-        if entry.parent != parent {
-            entry.parent = parent;
-            self.changed = true;
+    fn get_mut(&mut self) -> &mut Ui {
+        self
+    }
+}
+
+impl Ui {
+    /// useful for debugging
+    pub fn set_label(&mut self, id: impl IdLike, label: String) {
+        self.widgets.data_mut(id.id()).unwrap().label = label;
+    }
+
+    pub fn label(&self, id: impl IdLike) -> &String {
+        &self.widgets.data(id.id()).unwrap().label
+    }
+
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn get<I: IdLike>(&self, id: &I) -> Option<&I::Widget>
+    where
+        I::Widget: Sized + Widget,
+    {
+        self.widgets.get(id)
+    }
+
+    pub fn get_mut<I: IdLike>(&mut self, id: &I) -> Option<&mut I::Widget>
+    where
+        I::Widget: Sized + Widget,
+    {
+        self.widgets.get_mut(id)
+    }
+
+    pub fn add_texture(&mut self, image: DynamicImage) -> TextureHandle {
+        self.textures.add(image)
+    }
+
+    pub fn resize(&mut self, size: impl Into<Vec2>) {
+        self.output_size = size.into();
+        self.resized = true;
+    }
+
+    pub fn update(&mut self, events: &mut dyn EventsLike) {
+        if !self.widgets.waiting.is_empty() {
+            let len = self.widgets.waiting.len();
+            let all: Vec<_> = self
+                .widgets
+                .waiting
+                .iter()
+                .map(|&w| format!("'{}' ({w:?})", self.label(w)))
+                .collect();
+            panic!(
+                "{len} widget(s) were never upgraded\n\
+                this is likely a memory leak; consider upgrading to strong if you plan on using it later\n\
+                weak widgets: {all:#?}"
+            );
+        }
+        if self.root_changed() {
+            DrawState::new(self, events).redraw_all();
+            self.old_root = self.root.as_ref().map(|r| r.id());
+        } else if self.widgets.has_updates() {
+            DrawState::new(self, events).redraw_updates();
+        }
+        if self.resized {
+            self.resized = false;
+            DrawState::new(self, events).redraw_all();
         }
     }
 
-    pub fn remove(&mut self, idx: MoveIdx) {
-        self.changed = true;
-        self.arena.remove(Id::preset(idx.idx() as u32));
-    }
-
-    /// Sets the box a slot's contents are placed within, itself given in the
-    /// coordinates of its parent slot.
-    pub fn set(&mut self, idx: MoveIdx, region: UiRegion) {
-        let entry = self.arena.get_mut(Id::preset(idx.idx() as u32));
-        if entry.region != region {
-            entry.region = region;
-            self.changed = true;
+    /// free any resources that don't have references anymore
+    fn free(&mut self, events: &mut dyn EventsLike) {
+        for id in self.recv.try_iter() {
+            events.remove(id);
+            self.widgets.delete(id);
         }
+        self.textures.free();
     }
 
-    /// The same walk the vertex shader does, in the same `Len` the shader is
-    /// handed, for asking where a drawing will actually land -- hit testing,
-    /// and nothing layout decides on. Layout threads its lengths down the
-    /// draw instead, so no box it compares is composed back up this chain.
-    pub fn resolve(&self, idx: MoveIdx, local: UiRegion) -> UiRegion {
-        let mut region = local;
-        self.walk(idx, |entry| region = region.within(entry));
-        region
+    pub fn root_changed(&self) -> bool {
+        self.root.as_ref().map(|r| r.id()) != self.old_root
     }
 
-    fn walk(&self, idx: MoveIdx, mut step: impl FnMut(&UiRegion)) {
-        let mut at = idx;
-        for _ in 0..CHAIN_LIMIT {
-            if at == MoveIdx::NONE {
-                return;
+    pub fn needs_redraw(&self) -> bool {
+        self.root_changed() || self.widgets.has_updates()
+    }
+
+    pub fn num_widgets(&self) -> usize {
+        self.widgets.len()
+    }
+
+    pub fn active_widgets(&self) -> usize {
+        self.active.len()
+    }
+
+    pub fn debug_layers(&self) {
+        for ((idx, depth), primitives) 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);
             }
-            let entry = &self.arena[at.idx()];
-            step(&entry.region);
-            at = entry.parent;
+            println!();
         }
-        debug_assert!(
-            at == MoveIdx::NONE,
-            "a move chain longer than {CHAIN_LIMIT} resolves to the wrong place, \
-             and the shader stops at the same depth"
-        );
     }
 
-    /// How many slots a region in `idx` is composed through, which is what
-    /// the shader's walk costs per primitive.
-    pub fn depth(&self, idx: MoveIdx) -> usize {
-        let mut depth = 0;
-        let mut at = idx;
-        while at != MoveIdx::NONE && depth < CHAIN_LIMIT as usize {
-            at = self.arena[at.idx()].parent;
-            depth += 1;
-        }
-        depth
+    pub fn window_region(&self, id: &impl IdLike) -> Option<PixelRegion> {
+        let region = self.active.get(&id.id())?.region;
+        Some(region.to_px(self.output_size))
     }
 
-    pub fn entries(&self) -> &[MoveOffset] {
-        &self.arena
-    }
-
-    pub fn clear(&mut self) {
-        self.changed = true;
-        self.arena = Arena::default();
+    pub fn debug(&self, label: &str) -> impl Iterator<Item = &ActiveData> {
+        self.active.iter().filter_map(move |(&id, inst)| {
+            let l = self.widgets.label(id);
+            if l == label { Some(inst) } else { None }
+        })
     }
 }
 
-pub trait UiRsc {
-    fn ui(&self) -> &UiData;
-    fn ui_mut(&mut self) -> &mut UiData;
+impl<I: IdLike> Index<I> for Ui
+where
+    I::Widget: Sized + Widget,
+{
+    type Output = I::Widget;
 
-    #[allow(unused_variables)]
-    fn on_add(&mut self, id: WeakWidget) {}
-    #[allow(unused_variables)]
-    fn on_remove(&mut self, id: WidgetId) {}
-    #[allow(unused_variables)]
-    fn on_draw(&mut self, active: &ActiveData) {}
-    #[allow(unused_variables)]
-    fn on_undraw(&mut self, active: &ActiveData) {}
+    fn index(&self, id: I) -> &Self::Output {
+        self.get(&id).unwrap()
+    }
+}
 
-    fn widgets(&self) -> &Widgets {
-        &self.ui().widgets
+impl<I: IdLike> IndexMut<I> for Ui
+where
+    I::Widget: Sized + Widget,
+{
+    fn index_mut(&mut self, id: I) -> &mut Self::Output {
+        self.get_mut(&id).unwrap()
     }
-    fn widgets_mut(&mut self) -> &mut Widgets {
-        &mut self.ui_mut().widgets
-    }
-    fn free(&mut self) {
-        while let Some(id) = self.widgets_mut().free_next() {
-            self.on_remove(id);
+}
+
+impl Default for Ui {
+    fn default() -> Self {
+        let (send, recv) = channel();
+        Self {
+            widgets: Widgets::new(send),
+            active: Default::default(),
+            layers: Default::default(),
+            masks: Default::default(),
+            text: Default::default(),
+            textures: Default::default(),
+            output_size: Vec2::ZERO,
+            root: None,
+            old_root: None,
+            recv,
+            resized: false,
         }
-        self.ui_mut().textures.free();
     }
 }

core/src/ui/painter.rs

@@ -1,826 +1,124 @@
-#[cfg(feature = "layout-diagnostics")]
-use crate::layout_diagnostics::{self as diag, Counter};
 use crate::{
-    Axis, DrawRegion, ExtentPlacement, Holds, LayoutHolds, LayoutLen, Len, Px, PxVec2, RegionAlign,
-    RenderedText, RetainedPrimitive, Size, StrongWidget, TextAttrs, TextBuffer, TextData,
-    TextureHandle, UiRegion, UiRenderState, UiRsc, UiSpan, UiVec2, Weight, WidgetId, Widgets,
-    render::{
-        GlyphPrimitive, Mask, MaskIdx, MoveIdx, Primitive, PrimitiveInst, PrimitiveKind,
-        TexturePrimitive,
-    },
-    ui::render_state::DrawInfo,
+    RenderedText, TextAttrs, TextBuffer, TextData, TextureHandle, UiRegion, WidgetHandle, WidgetId,
+    render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
+    ui::draw_state::DrawState,
+    util::Vec2,
 };
-const AXES: [Axis; 2] = [Axis::X, Axis::Y];
 
 /// makes your surfaces look pretty
-pub struct Painter<'a> {
-    pub(super) state: &'a mut UiRenderState,
-    pub(super) rsc: &'a mut dyn UiRsc,
+pub struct Painter<'a, 'b> {
+    pub(super) state: &'a mut DrawState<'b>,
 
-    /// The box its parent gave it, in the coordinates of `move_idx`: what a
-    /// fraction of this widget's area is a fraction of, and what every region
-    /// it writes composes within. The same box on the ask that measures and
-    /// the ask that places, which is what keeps a fraction under it from
-    /// being resolved twice.
+    pub region_used: UiRegion,
     pub(super) region: UiRegion,
-    /// Where this widget's drawing sits inside that box, in the box's own
-    /// coordinates: `FULL` while its answer is not yet known, and the box
-    /// its answer or its parent chose once one of them has.
-    pub(super) placement: UiRegion,
-    /// Whether this draw read its placement, which makes the drawing one
-    /// that holds for that placement alone -- the way reading a length in
-    /// pixels makes it hold for that length.
-    pub(super) reads_placement: bool,
-    /// That box in pixels, which its children's are a length of: threaded
-    /// down from the box this widget was given rather than composed back up
-    /// the chain, so every length in layout is one multiply from its
-    /// parent's and [`Holds::through`] inverts exactly that.
-    pub(super) px: PxVec2,
     pub(super) mask: MaskIdx,
     pub(super) textures: Vec<TextureHandle>,
-    pub(super) primitives: Vec<RetainedPrimitive>,
-    pub(super) mask_region: Option<DrawRegion>,
-    pub(super) extent_children: Vec<(WidgetId, ExtentPlacement)>,
-    pub(super) extent_own: [Holds; 2],
-    /// Only children whose answers were read constrain this widget's answer.
-    pub(super) answer_under: LayoutHolds,
+    pub(super) primitives: Vec<PrimitiveHandle>,
     pub(super) children: Vec<WidgetId>,
-    /// The children asked about so far, so the first box each was asked in
-    /// is the one recorded as its offer.
-    pub(super) offered: Vec<WidgetId>,
-    /// The lengths of the box this widget was first asked about in, in
-    /// pixels. Its children's offers are a fraction of it.
-    pub(super) offered_px: PxVec2,
-    /// Whether this draw is in a box of those lengths, which makes the
-    /// questions it asks the ones a cold layout asks and their answers the
-    /// ones to keep.
-    pub(super) at_offer: bool,
-    /// The children whose size this widget read while drawing.
-    pub(super) size_deps: Vec<WidgetId>,
-    /// What this draw itself read of its box in pixels, per axis: every
-    /// length until it reads one, then that one, unless it says otherwise.
-    pub(super) own: [Holds; 2],
-    /// Dependencies of every child drawing, including unmeasured overlays.
-    pub(super) under: LayoutHolds,
-    /// The movable region this widget's primitives are positioned through:
-    /// its own when opted in, otherwise the nearest ancestor's.
-    pub(super) move_idx: MoveIdx,
     pub layer: usize,
-    /// The layer this widget was entered on, which its children's layers are
-    /// counted from however far `layer` has walked.
-    pub(super) own_layer: usize,
-    pub(super) depth: usize,
     pub(super) id: WidgetId,
 }
 
-impl<'a> Painter<'a> {
-    fn primitive_at<P: Primitive>(&mut self, primitive: P, region: DrawRegion) {
-        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: DrawRegion) {
-        self.write_resolved(
-            kind,
-            primitive,
-            region,
-            region.resolve(self.region, self.placement),
-        );
-    }
-
-    fn write_resolved<P: Primitive>(
-        &mut self,
-        kind: PrimitiveKind<P>,
-        primitive: P,
-        region: DrawRegion,
-        resolved: UiRegion,
-    ) {
-        #[cfg(feature = "layout-diagnostics")]
-        diag::bump(Counter::PrimitiveWrites);
+impl<'a, 'c> Painter<'a, 'c> {
+    fn primitive_at<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
         let h = self.state.layers.write(
             self.layer,
             PrimitiveInst {
-                kind,
                 id: self.id,
                 primitive,
-                region: resolved,
+                region,
                 mask_idx: self.mask,
-                move_idx: self.move_idx,
             },
         );
-        self.push_primitive(RetainedPrimitive { handle: h, region });
-    }
-
-    fn push_primitive(&mut self, h: RetainedPrimitive) {
         if self.mask != MaskIdx::NONE {
             // TODO: I have no clue if this works at all :joy:
-            self.rsc.ui_mut().masks.push_ref(self.mask);
+            self.state.masks.push_ref(self.mask);
         }
         self.primitives.push(h);
     }
 
-    /// Writes a primitive over the whole of this widget's own box.
-    pub fn primitive(&mut self, primitive: impl PrimitiveLike) {
-        let at = DrawRegion::Extent(UiRegion::FULL);
-        let primitive = primitive.into_primitive(self);
-        self.primitive_at(primitive, at)
+    /// Writes a primitive to be rendered
+    pub fn primitive<P: Primitive>(&mut self, primitive: P) {
+        self.primitive_at(primitive, self.region)
     }
 
-    /// Writes in the frame by default. `DrawRegion::Extent` keeps the local
-    /// geometry attached to this widget's box without reading its placement.
-    pub fn primitive_within(
-        &mut self,
-        primitive: impl PrimitiveLike,
-        region: impl Into<DrawRegion>,
-    ) {
-        let primitive = primitive.into_primitive(self);
-        self.primitive_at(primitive, region.into());
+    pub fn primitive_within<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+        self.primitive_at(primitive, region.within(&self.region));
     }
 
-    /// Sets a mask in the selected frame or extent coordinates.
-    pub fn set_mask(&mut self, region: impl Into<DrawRegion>) {
-        let region = region.into();
-        self.mask_region = Some(region);
+    pub fn set_mask(&mut self, region: UiRegion) {
         assert!(self.mask == MaskIdx::NONE);
-        self.mask = self.rsc.ui_mut().masks.push(Mask {
-            region: region.resolve(self.region, self.placement),
-            move_idx: self.move_idx,
-        });
+        self.mask = self.state.masks.push(Mask { region });
     }
 
-    /// Draws a widget in the whole of this widget's own box: it gets the
-    /// same region -- the same area for its fractions to be of -- and is put
-    /// where this widget was put. What a container that is only a wrapper
-    /// around one child wants, since its box is the child's.
-    pub fn widget<'s, W: ?Sized>(&'s mut self, id: &'s StrongWidget<W>) -> DrawResult<'s, 'a, W> {
-        let own = self.placement;
-        self.widget_at_inner(
-            id,
-            UiRegion::FULL,
-            [Some(own.x), Some(own.y)],
-            Some(ExtentPlacement::Inherit),
-            false,
-        )
+    /// Draws a widget within this widget's region.
+    pub fn widget<W: ?Sized>(&mut self, id: &WidgetHandle<W>) {
+        self.widget_at(id, self.region);
     }
 
-    /// What a widget's rules declare its lengths to be, which whoever draws
-    /// it resolves into its box. Reading them depends on nothing -- the box
-    /// that comes of them is kept on the child, and `redraw` compares it
-    /// there.
-    fn declared_lens<W: ?Sized>(&self, id: &StrongWidget<W>) -> [Option<LayoutLen>; 2] {
-        declared_lens(self.rsc.widgets(), id.id())
+    pub fn rest_hint(&self, id: &WidgetHandle) -> f32 {
+        self.state.widgets.data(id).unwrap().align
     }
 
-    /// Takes back a child that was drawn only to find out how long it is.
-    /// Its drawing is dropped and it is not one of this widget's children
-    /// this frame; what it answered is still something this widget asked.
-    pub fn undraw<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
-        self.children.retain(|child| *child != id.id());
-        self.extent_children.retain(|(child, _)| *child != id.id());
-        self.state.undraw_rec(id.id(), self.rsc);
+    /// Draws a widget somewhere within this one.
+    /// Useful for drawing child widgets in select areas.
+    pub fn widget_within<W: ?Sized>(&mut self, id: &WidgetHandle<W>, region: UiRegion) {
+        self.widget_at(id, region.within(&self.region));
     }
 
-    /// Draws a child in `region`, relative to this widget's frame. The child
-    /// resolves declared lengths and reports against that frame, then places
-    /// its drawing by its own alignment.
-    ///
-    /// `DrawRegion::Extent` gives a part of where this widget's drawing sits
-    /// instead, for a container whose children belong inside that rather than
-    /// inside the box it was offered. The part is what is kept, so moving the
-    /// extent re-places the child rather than drawing this widget again.
-    pub fn widget_within<'s, W: ?Sized>(
-        &'s mut self,
-        id: &'s StrongWidget<W>,
-        region: impl Into<DrawRegion>,
-    ) -> DrawResult<'s, 'a, W> {
-        match region.into() {
-            DrawRegion::Frame(region) => self.widget_at(id, region, [None; 2]),
-            DrawRegion::Extent(part) => {
-                let within = part.within(&self.placement);
-                self.widget_at_inner(
-                    id,
-                    within,
-                    [None; 2],
-                    Some(ExtentPlacement::Within(part)),
-                    false,
-                )
-            }
-        }
+    fn widget_at<W: ?Sized>(&mut self, id: &WidgetHandle<W>, region: UiRegion) {
+        self.children.push(id.id());
+        self.state
+            .draw_inner(self.layer, id.id(), region, Some(self.id), self.mask);
     }
 
-    /// Draws a widget in `region`, saying where in it the drawing goes.
-    ///
-    /// `region` is the child's own area: what a fraction it declares or
-    /// reports is a fraction of, and the coordinates the regions it writes
-    /// compose within. It is the same box on the ask that measures and the
-    /// ask that places, which is what stops a fraction under it being
-    /// resolved twice.
-    ///
-    /// `placement` is what of that region the child's drawing takes, per
-    /// axis, wherever this widget is choosing. `None` leaves the axis to the
-    /// child's own answer and alignment, which is what
-    /// [`Self::widget_within`] passes. A span passes the whole row as the
-    /// region, so `rel(0.5)` is half the row wherever the child sits in it,
-    /// and places the child by passing the slot along its axis.
-    pub fn widget_at<'s, W: ?Sized>(
-        &'s mut self,
-        id: &'s StrongWidget<W>,
-        region: UiRegion,
-        placement: [Option<UiSpan>; 2],
-    ) -> DrawResult<'s, 'a, W> {
-        self.widget_at_inner(id, region, placement, None, false)
+    pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) {
+        self.textures.push(handle.clone());
+        self.primitive_at(handle.primitive(), region.within(&self.region));
     }
 
-    fn widget_at_inner<'s, W: ?Sized>(
-        &'s mut self,
-        id: &'s StrongWidget<W>,
-        region: UiRegion,
-        placement: [Option<UiSpan>; 2],
-        extent: Option<ExtentPlacement>,
-        measuring: bool,
-    ) -> DrawResult<'s, 'a, W> {
-        self.extent_children.retain(|(child, _)| *child != id.id());
-        if let Some(extent) = extent {
-            self.extent_children.push((id.id(), extent));
-        }
-        let region_node = self.rsc.widgets().is_region_node(id.id());
-        let declared = self.declared_lens(id);
-        let align = self.rsc.widgets().alignment(id.id());
-        let (local, placement) = ask_box(region, declared, align, placement);
-        let within = match local == UiRegion::FULL {
-            true => self.region,
-            false => local.within(&self.region),
-        };
-        #[cfg(feature = "layout-diagnostics")]
-        if region_node {
-            diag::bump(Counter::RegionNodeDraws);
-            diag::region_node(id.id(), self.id, within);
-        }
-        // A child listed twice would be moved twice.
-        if !self.children.contains(&id.id()) {
-            self.children.push(id.id());
-        }
-        let first_ask = self.offer(id.id());
-        let given_len = local.size();
-        let offer_len = match first_ask {
-            true => given_len,
-            false => self
-                .state
-                .active
-                .get(&id.id())
-                .map_or(given_len, |a| a.offer_len),
-        };
-        let offer_region = match first_ask {
-            true => local,
-            false => self
-                .state
-                .active
-                .get(&id.id())
-                .map_or(local, |a| a.offer_region),
-        };
-        let offer_placement = if first_ask {
-            placement
-        } else {
-            self.state
-                .active
-                .get(&id.id())
-                .map_or(placement, |a| a.offer_placement)
-        };
-        let px = given_len.to_px(self.px);
-        let offered_px = offer_len.to_px(self.offered_px);
-        // The answer and what it holds for, both about the box asked in. The
-        // child's record may say something else once its drawing has been
-        // placed: a drawing made again in its placed box holds for that box.
-        let (size, answer_holds, holds) = self.state.draw_inner(
-            id.id(),
-            within,
-            DrawInfo {
-                layer: self.layer,
-                parent: Some(self.id),
-                depth: self.depth + 1,
-                parent_move: self.move_idx,
-                region_node,
-                mask: self.mask,
-                given_region: local,
-                offer_region,
-                offer_len,
-                offer_placement,
-                px,
-                offered_px,
-                placement,
-            },
-            None,
-            measuring,
-            self.rsc,
-        );
-        let in_parent = |holds: LayoutHolds| {
-            let mut result = LayoutHolds::ANY;
-            for axis in AXES {
-                let n = axis as usize;
-                let chosen = placement[n].unwrap_or(UiSpan::FULL).len();
-                match extent {
-                    // Its box is this widget's own, so what its drawing holds
-                    // for is what this widget's extent holds for.
-                    Some(ExtentPlacement::Inherit) if declared[n].is_none() => {
-                        result.frame[n] = holds.frame[n].through(local.axis(axis).len());
-                        result.extent[n] = holds.extent[n];
-                        if holds.placement.is_some() {
-                            result.placement = Some(self.placement);
-                        }
-                    }
-                    // Its box is a part of this widget's extent, so what it
-                    // holds for is a range on that extent and none of it a
-                    // range on the frame. Only the part's length reaches it,
-                    // which is what lets the extent move without a redraw.
-                    Some(ExtentPlacement::Within(part)) if declared[n].is_none() => {
-                        result.extent[n] = holds.frame[n]
-                            .and(holds.extent[n].through(chosen))
-                            .through(part.axis(axis).len());
-                    }
-                    // Its box is a length of this widget's frame: an
-                    // ordinary ask, or a declared length, which is that
-                    // length wherever the box it sits in came from.
-                    _ => {
-                        result.frame[n] = holds.frame[n].through(local.axis(axis).len()).and(
-                            holds.extent[n]
-                                .through(chosen)
-                                .through(local.axis(axis).len()),
-                        );
-                    }
-                }
-            }
-            result
-        };
-        self.under = self.under.and(in_parent(holds));
-        let mut answer_holds = in_parent(answer_holds);
-        // What it reports is a fraction of the box it was given, which is a
-        // part of this widget's extent -- so the same fraction is a different
-        // length once that extent is, and pixels are not. The answer only:
-        // the drawing this holds is re-placed rather than made again.
-        if matches!(extent, Some(ExtentPlacement::Within(_)))
-            && AXES.into_iter().any(|axis| {
-                declared[axis as usize].is_none() && size.axis(axis).rel != crate::Rel::ZERO
-            })
-        {
-            answer_holds.placement = Some(self.placement);
-        }
-        DrawResult {
-            child: id,
-            painter: self,
-            size: in_parent_frame(size, local.size(), declared),
-            answer_holds,
-        }
+    pub fn texture(&mut self, handle: &TextureHandle) {
+        self.textures.push(handle.clone());
+        self.primitive(handle.primitive());
     }
 
-    /// 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<LayoutLen> {
-        let widgets = self.rsc.widgets();
-        // A rule is the answer where there is one: it wins over whatever the
-        // widget would draw, so it has to win over what the widget says too.
-        let hint = widgets.size_rules(id.id()).axis(axis).exact().or_else(|| {
-            widgets
-                .get_dyn(id.id())
-                .and_then(|widget| widget.size_hint(axis))
-        });
-        #[cfg(feature = "layout-diagnostics")]
-        diag::hint_read(id.id(), self.id, axis, hint);
-        match hint {
-            Some(hint) => {
-                #[cfg(feature = "layout-diagnostics")]
-                diag::bump(Counter::HintHits);
-                self.depend_on(id);
-                Some(hint)
-            }
-            None => {
-                #[cfg(feature = "layout-diagnostics")]
-                diag::bump(Counter::HintMisses);
-                None
-            }
-        }
+    /// returns (handle, offset from top left)
+    pub fn render_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
+        self.state
+            .ui
+            .text
+            .draw(buffer, attrs, &mut self.state.ui.textures)
     }
 
-    /// Measures a child's length from its hint, a retained answer, or `draw`.
-    /// A fresh draw evaluates the offer without placing its answer. The caller
-    /// must later place or undraw the child.
-    pub fn measure_len<W: ?Sized>(
-        &mut self,
-        child: &StrongWidget<W>,
-        axis: Axis,
-        region: UiRegion,
-        placement: [Option<UiSpan>; 2],
-    ) -> LayoutLen {
-        let offered = placement;
-        let declared = self.declared_lens(child);
-        let align = self.rsc.widgets().alignment(child.id());
-        let (local, placement) = ask_box(region, declared, align, placement);
-        let first_ask = self.at_offer && !self.offered.contains(&child.id());
-
-        if let Some(hint) = self.size_hint(child, axis) {
-            return hint;
-        }
-        let px = local.size().to_px(self.px);
-        let retained =
-            self.state
-                .retained_size(child.id(), px, placement, self.move_idx, self.rsc.widgets());
-        let Some((size, holds)) = retained else {
-            return self
-                .widget_at_inner(child, region, offered, None, true)
-                .len(axis);
-        };
-        #[cfg(feature = "layout-diagnostics")]
-        diag::bump(Counter::RetainedSizeHits);
-        self.depend_on(child);
-        if first_ask {
-            self.offered.push(child.id());
-            let active = self.state.active.get_mut(&child.id()).unwrap();
-            active.offer_len = local.size();
-            active.offer_region = local;
-            active.offer_placement = placement;
-        }
-        let placement = UiRegion {
-            x: placement[0].unwrap_or(UiSpan::FULL),
-            y: placement[1].unwrap_or(UiSpan::FULL),
-        };
-        let holds = holds.in_frame(placement);
-        for (axis, under) in AXES.into_iter().zip(self.answer_under.frame.iter_mut()) {
-            *under = under.and(holds[axis as usize].through(local.axis(axis).len()));
-        }
-        in_parent_frame(size, local.size(), declared).axis(axis)
-    }
-
-    /// Whether this is the first box a child is asked about in during a draw
-    /// that is itself in the box it was asked in -- the question a cold
-    /// layout asks, whose answer is the one to keep.
-    fn offer(&mut self, child: WidgetId) -> bool {
-        if !self.at_offer || self.offered.contains(&child) {
-            return false;
-        }
-        self.offered.push(child);
-        true
-    }
-
-    fn depend_on<W: ?Sized>(&mut self, child: &StrongWidget<W>) {
-        if !self.size_deps.contains(&child.id()) {
-            self.size_deps.push(child.id());
-        }
-    }
-
-    pub fn render_text<'b>(
-        &mut self,
-        buffer: &'b mut TextBuffer,
-        attrs: &TextAttrs,
-        width: Option<f32>,
-    ) -> &'b RenderedText {
-        #[cfg(feature = "layout-diagnostics")]
-        diag::render_text(self.id, self.rsc.widgets().label(self.id), width);
-        let ui = self.rsc.ui_mut();
-        ui.text.render(buffer, attrs, width)
-    }
-
-    /// Writes glyphs in the selected frame or extent coordinates.
-    // TODO: merge the text methods into the primitive ones.
-    pub fn glyphs(&mut self, text: &RenderedText, origin: impl Into<DrawRegion>) {
-        let origin = origin.into();
-        // Glyph offsets and sizes are pixels, which compose additively.
-        // Only the shared origin needs the frame/extent composition.
-        let resolved = origin.resolve(self.region, self.placement);
-        let kind = self.rsc.ui_mut().primitives.kind::<GlyphPrimitive>();
-        for glyph in text.glyphs.iter() {
-            let place = |mut region: UiRegion| {
-                region.x.end = region.x.start;
-                region.y.end = region.y.start;
-                let mut region = region.offset(UiVec2::from_px(glyph.offset));
-                let size = PxVec2::new(
-                    Px::from_int(glyph.entry.width as i32),
-                    Px::from_int(glyph.entry.height as i32),
-                );
-                region.x.end = region.x.start.offset(size.x);
-                region.y.end = region.y.start.offset(size.y);
-                region
-            };
-            self.write_resolved(
-                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(),
-                },
-                origin.map(place),
-                place(resolved),
-            );
-        }
-    }
-
-    /// The box this widget's parent gave it, in the coordinates its own
-    /// primitives are written in -- so a region composed `within` it may be
-    /// drawn directly. Its own box is [`Self::placement`] of this one.
     pub fn region(&self) -> UiRegion {
         self.region
     }
 
-    /// Where this widget's drawing goes inside the box it was given, in that
-    /// box's coordinates: what its own answer took of it, or what its parent
-    /// chose for it. `FULL` on the ask that measures, since nothing has been
-    /// placed yet.
-    ///
-    /// Reading it is what says the drawing depends on it, so a widget that
-    /// positions its own content reads it and is drawn again once its box is
-    /// known, and one that fills whatever it is given never is.
-    pub fn placement(&mut self) -> UiRegion {
-        self.reads_placement = true;
-        self.placement
+    pub fn output_size(&self) -> Vec2 {
+        self.state.output_size
     }
 
-    /// Where this widget sits in a box longer than the length it takes. A
-    /// widget that positions its own content reads it to place that content
-    /// the way the box around it would have placed the widget.
-    pub fn alignment(&self) -> RegionAlign {
-        self.rsc.widgets().alignment(self.id)
-    }
-
-    /// Whether a rule beside this widget gives its length on `axis` outright,
-    /// which makes whatever it reports for that axis moot. A rule that only
-    /// bounds the length is not one of these: the answer is still the
-    /// widget's to give, and something still has to work it out.
-    ///
-    /// The widget under a rule does not otherwise learn of it -- this is for
-    /// a container deciding whether reading its children across an axis is
-    /// worth anything, since reading one is also what makes its own size
-    /// depend on it.
-    pub fn has_exact_size(&self, axis: Axis) -> bool {
-        self.rsc
-            .widgets()
-            .size_rules(self.id)
-            .axis(axis)
-            .exact()
-            .is_some()
-    }
-
-    /// The part of this widget's box that something of `size` takes, at the
-    /// near edge. A container that reports one child's size gives every child
-    /// this, so what it draws is inside what it says it occupies.
-    pub fn box_of(&self, size: Size) -> UiRegion {
-        let lens = placed_lens(size, [None; 2], [false; 2]);
-        placed_box(UiRegion::FULL, lens, RegionAlign::NEAR)
-    }
-
-    /// This widget's own box in pixels. Reading it makes the drawing one
-    /// that holds for this box only, until `holds` says how far it goes.
-    pub fn px_size(&mut self) -> PxVec2 {
-        PxVec2::new(self.px_len(Axis::X), self.px_len(Axis::Y))
-    }
-
-    /// One axis of this widget's own box in pixels. Prefer this to
-    /// [`Self::px_size`] when the other axis cannot affect the drawing.
-    pub fn px_len(&mut self, axis: Axis) -> Px {
-        let part = self.placement.axis(axis).len();
-        let len = part.to_px(self.px.axis(axis));
-        let own = &mut self.extent_own[axis as usize];
-        if *own == Holds::ANY {
-            *own = Holds::at(len);
-        }
-        len
-    }
-
-    /// The lengths of this widget's own box on `axis` that what it is drawing
-    /// holds for -- the same primitives, in the same fractions and offsets
-    /// of the box, and the same reported size. A widget that read its length
-    /// in pixels holds for that one alone until it says otherwise.
-    pub fn holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
-        let part = self.placement.axis(axis).len();
-        let holds = holds.into();
-        debug_assert!(
-            holds.contains(part.to_px(self.px.axis(axis))),
-            "'{}' ({:?}) says its drawing holds for lengths that leave out its own box",
-            self.label(),
-            self.id
-        );
-        self.extent_own[axis as usize] = holds;
-    }
-
-    /// One axis of the box this widget's parent gave it, in pixels -- what a
-    /// fraction of its area resolves against, and so what a container divides
-    /// among its children. Its own box is a part of this one.
-    pub fn region_px_len(&mut self, axis: Axis) -> Px {
-        let len = self.px.axis(axis);
-        let own = &mut self.own[axis as usize];
-        if *own == Holds::ANY {
-            *own = Holds::at(len);
-        }
-        len
-    }
-
-    /// [`Self::holds`] stated about the region rather than about this
-    /// widget's own box, for a container whose drawing turns on the box it
-    /// was given rather than on the part of it it took.
-    pub fn region_holds(&mut self, axis: Axis, holds: impl Into<Holds>) {
-        let holds = holds.into();
-        debug_assert!(
-            holds.contains(self.px.axis(axis)),
-            "'{}' ({:?}) says its drawing holds for lengths that leave out its region",
-            self.label(),
-            self.id
-        );
-        self.own[axis as usize] = holds;
+    pub fn px_size(&mut self) -> Vec2 {
+        self.region.size().to_abs(self.state.output_size)
     }
 
     pub fn text_data(&mut self) -> &mut TextData {
-        &mut self.rsc.ui_mut().text
+        &mut self.state.text
     }
 
     pub fn child_layer(&mut self) {
         self.layer = self.state.layers.child(self.layer);
     }
 
-    /// The layer this widget's `n`th child draws on, addressed rather than
-    /// walked to. A container that measures one child by drawing it can ask
-    /// on the layer that child will end up on, and then the second ask is a
-    /// reuse rather than a second drawing on another layer.
-    pub fn child_layer_at(&mut self, n: usize) {
-        let mut at = self.state.layers.child(self.own_layer);
-        for _ in 0..n {
-            at = self.state.layers.next(at);
-        }
-        self.layer = at;
-    }
-
     pub fn next_layer(&mut self) {
         self.layer = self.state.layers.next(self.layer);
     }
 
     pub fn label(&self) -> &str {
-        &self.rsc.widgets().data(self.id).unwrap().label
+        &self.state.widgets.data(self.id).unwrap().label
     }
 
     pub fn id(&self) -> &WidgetId {
         &self.id
     }
 }
-
-/// A child that has just been drawn. Reading its size records that this
-/// widget's own size depends on it; dropping it without reading draws the
-/// child and leaves the parent independent of what it came to.
-pub struct DrawResult<'p, 'a, W: ?Sized> {
-    painter: &'p mut Painter<'a>,
-    child: &'p StrongWidget<W>,
-    size: Size,
-    answer_holds: LayoutHolds,
-}
-
-impl<W: ?Sized> DrawResult<'_, '_, W> {
-    pub fn size(self) -> Size {
-        #[cfg(feature = "layout-diagnostics")]
-        {
-            diag::bump(Counter::SizeReads);
-            diag::size_read(self.child.id(), self.painter.id, self.size);
-        }
-        self.painter.depend_on(self.child);
-        self.painter.answer_under = self.painter.answer_under.and(self.answer_holds);
-        self.size
-    }
-
-    pub fn len(self, axis: Axis) -> LayoutLen {
-        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()
-    }
-}
-
-/// A child's answer as lengths of the parent's own region. A widget reports
-/// a fraction of its own region, and `of` is that region as a length of this
-/// one. Pixels come through untouched, being that many pixels wherever they
-/// end up. A declared axis is already the parent's: it resolved the rule in
-/// its own region, and the rule is what the report says.
-fn in_parent_frame(size: Size, of: UiVec2, declared: [Option<LayoutLen>; 2]) -> Size {
-    let mut size = size;
-    for (axis, declared) in AXES.into_iter().zip(declared) {
-        if declared.is_none() {
-            *size.axis_mut(axis) = size.axis(axis).within_len(of.axis(axis));
-        }
-    }
-    size
-}
-
-/// What a widget declares a length of its box to be. `leftover` is not one: a
-/// share of what is left over is only a length to the widget dividing one,
-/// so it passes up in the size instead.
-pub(crate) fn declared_lens(widgets: &Widgets, id: WidgetId) -> [Option<LayoutLen>; 2] {
-    let rules = widgets.size_rules(id);
-    let widget = widgets.get_dyn(id);
-    AXES.map(|axis| {
-        rules.axis(axis).declared().or_else(|| {
-            // A hint still narrows the box where no rule does, which is how a
-            // widget with a natural pixel size -- an image, a gap -- gets that
-            // size rather than the whole offer. That is the offer's business
-            // rather than a declaration's, and this falls away once a widget
-            // occupies its reported size inside the box it was offered.
-            widget
-                .and_then(|widget| widget.size_hint(axis))
-                .filter(|len| len.leftover == Weight::ZERO)
-        })
-    })
-}
-
-/// Whether what a widget reported along an axis is the whole of the box it
-/// is in rather than a part to be placed inside it. A share fills, because a
-/// share is a length only to whoever divides one, and whoever did is the one
-/// that handed down this box. A declared axis does too: the rule already gave
-/// the region its length, and the rule's length is what the widget reports
-/// there. And an axis the parent decided from the answer is
-/// the answer already.
-pub(crate) fn fills(reported: LayoutLen, declared: Option<LayoutLen>, decided: bool) -> bool {
-    reported.leftover != Weight::ZERO || declared.is_some() || decided
-}
-
-/// What of the box it was given a widget's drawing occupies, as lengths of
-/// that box: the size it reported wherever that is a part to be placed, and
-/// the whole of the box wherever the answer fills it.
-///
-/// A reported fraction is a fraction of the box the widget drew in, where a
-/// declared one is a fraction of the box its parent handed down -- a span
-/// reporting `rel(1.0)` means all of what it was given, whatever that was a
-/// fraction of. So this is a length of the box rather than a length composed
-/// into it, and a box in pixels is this step from the given box's pixels.
-pub(crate) fn placed_lens(
-    size: Size,
-    declared: [Option<LayoutLen>; 2],
-    decided: [bool; 2],
-) -> UiVec2 {
-    let mut lens = UiVec2::FULL_SIZE;
-    for (axis, (declared, decided)) in AXES.into_iter().zip(declared.into_iter().zip(decided)) {
-        let reported = size.axis(axis);
-        if !fills(reported, declared, decided) {
-            *lens.axis_mut(axis) = Len::from_parts(reported.rel, reported.px);
-        }
-    }
-    lens
-}
-
-/// Where that drawing sits: those lengths taken of the box the widget was
-/// asked in, on the side of it that the widget's alignment says.
-pub(crate) fn placed_box(region: UiRegion, lens: UiVec2, align: RegionAlign) -> UiRegion {
-    let mut placed = region;
-    for axis in AXES {
-        // The whole of the box is already where it sits, and the arithmetic
-        // below is the identity for it.
-        if lens.axis(axis) == Len::FULL {
-            continue;
-        }
-        let span = placed.axis_mut(axis);
-        let len = lens.axis(axis).within_len(span.len());
-        span.start += (span.len() - len).scale(align.axis(axis).rel());
-        span.end = span.start + len;
-    }
-    placed
-}
-
-/// A declared axis gets a frame of that length, aligned within the parent's
-/// slot (or the offer). Undeclared axes keep the offered frame and chosen
-/// placement, so their reported fractions retain that reference.
-pub(crate) fn ask_box(
-    mut region: UiRegion,
-    declared: [Option<LayoutLen>; 2],
-    align: RegionAlign,
-    placement: [Option<UiSpan>; 2],
-) -> (UiRegion, [Option<UiSpan>; 2]) {
-    let mut placed = [None; 2];
-    for (axis, (len, chosen)) in AXES.into_iter().zip(declared.into_iter().zip(placement)) {
-        let Some(len) = len else {
-            placed[axis as usize] = chosen;
-            continue;
-        };
-        let span = region.axis_mut(axis);
-        let len = Len::from_parts(len.rel, len.px);
-        let slot = chosen.unwrap_or(*span);
-        span.start = slot.start + (slot.len() - len).scale(align.axis(axis).rel());
-        span.end = span.start + len;
-    }
-    (region, placed)
-}

core/src/ui/state.rs

@@ -0,0 +1,3 @@
+// pub struct DynState {
+//
+// }

core/src/util/arena.rs

@@ -34,10 +34,6 @@ impl<T, I: IdNum> Arena<T, I> {
         self.tracker.free(id);
         self.data[i]
     }
-
-    pub(crate) fn get_mut(&mut self, id: Id<I>) -> &mut T {
-        &mut self.data[id.idx()]
-    }
 }
 
 impl<T, I: IdNum> Default for Arena<T, I> {
@@ -75,11 +71,6 @@ impl<T, I: IdNum> TrackedArena<T, I> {
         self.refs[i.idx()] += 1;
     }
 
-    pub fn get_mut(&mut self, id: Id<I>) -> &mut T {
-        self.changed = true;
-        self.inner.get_mut(id)
-    }
-
     pub fn remove(&mut self, id: Id<I>) -> T
     where
         T: Copy,

core/src/util/math.rs

@@ -1,13 +1,33 @@
+use std::ops::*;
+
 pub const trait LerpUtil {
     fn lerp(self, from: Self, to: Self) -> Self;
+    fn lerp_inv(self, from: Self, to: Self) -> Self;
 }
 
-const impl LerpUtil for f32 {
+pub const trait DivOr {
+    fn div_or(self, rhs: Self, other: Self) -> Self;
+}
+
+impl const DivOr for f32 {
+    fn div_or(self, rhs: Self, other: Self) -> Self {
+        let res = self / rhs;
+        if res.is_nan() { other } else { res }
+    }
+}
+
+impl<T: const Add<Output = T> + const Sub<Output = T> + const Mul<Output = T> + const DivOr + Copy> const
+    LerpUtil for T
+{
     /// linear interpolation
     /// from * (1.0 - self) + to * self
     fn lerp(self, from: Self, to: Self) -> Self {
         from + (to - from) * self
     }
+    /// inverse of lerp
+    fn lerp_inv(self, from: Self, to: Self) -> Self {
+        (self - from).div_or(to - from, from)
+    }
 }
 
 macro_rules! impl_op {
@@ -17,7 +37,7 @@ macro_rules! impl_op {
             use super::*;
             #[allow(unused_imports)]
             use std::ops::*;
-            const impl $op for $T {
+            impl const $op for $T {
                 type Output = Self;
 
                 fn $fn(self, rhs: Self) -> Self::Output {
@@ -26,12 +46,12 @@ macro_rules! impl_op {
                     }
                 }
             }
-            const impl $opa for $T {
+            impl const $opa for $T {
                 fn $fna(&mut self, rhs: Self) {
                     *self = self.$fn(rhs);
                 }
             }
-            const impl $op<f32> for $T {
+            impl const $op<f32> for $T {
                 type Output = Self;
 
                 fn $fn(self, rhs: f32) -> Self::Output {
@@ -40,7 +60,7 @@ macro_rules! impl_op {
                     }
                 }
             }
-            const impl $op<$T> for f32 {
+            impl const $op<$T> for f32 {
                 type Output = $T;
 
                 fn $fn(self, rhs: $T) -> Self::Output {
@@ -49,41 +69,13 @@ macro_rules! impl_op {
                     }
                 }
             }
-            const impl $opa<f32> for $T {
+            impl const $opa<f32> for $T {
                 fn $fna(&mut self, rhs: f32) {
                     *self = self.$fn(rhs);
                 }
             }
         }
     };
-    // Without the `f32` operations, for a type whose fields are not all the
-    // same kind of number: there is nothing a bare float means to a fraction
-    // and an offset at once.
-    (same $T:ident $op:ident $fn:ident $opa:ident $fna:ident; $($field:ident)*) => {
-        #[allow(non_snake_case)]
-        mod ${concat($T, _op_, $fn, _same_impl)} {
-            use super::*;
-            #[allow(unused_imports)]
-            use std::ops::*;
-            const impl $op for $T {
-                type Output = Self;
-
-                fn $fn(self, rhs: Self) -> Self::Output {
-                    Self {
-                        $($field: self.$field.$fn(rhs.$field),)*
-                    }
-                }
-            }
-            const impl $opa for $T {
-                fn $fna(&mut self, rhs: Self) {
-                    *self = self.$fn(rhs);
-                }
-            }
-        }
-    };
-    (same $T:ident $op:ident $fn:ident; $($field:ident)*) => {
-        impl_op!(same $T $op $fn ${concat($op,Assign)} ${concat($fn,_assign)}; $($field)*);
-    };
     ($T:ident $op:ident $fn:ident; $($field:ident)*) => {
         impl_op!($T $op $fn ${concat($op,Assign)} ${concat($fn,_assign)}; $($field)*);
     };

core/src/util/mod.rs

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

core/src/util/slot.rs

@@ -1,4 +1,4 @@
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub struct SlotId {
     idx: u32,
     genr: u32,

core/src/util/trust.rs

@@ -1,10 +1,15 @@
 #[allow(clippy::missing_safety_doc)]
-pub(crate) unsafe fn forget_mut<'a, T>(x: &mut T) -> &'a mut T {
+pub 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 {
     unsafe { std::mem::transmute::<&mut T, &mut T>(x) }
 }
 
 #[allow(clippy::mut_from_ref, clippy::missing_safety_doc)]
-pub(crate) unsafe fn to_mut<T>(x: &T) -> &mut T {
+pub 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,11 +1,7 @@
-use crate::util::impl_op;
+use crate::util::{DivOr, impl_op};
 use std::{hash::Hash, ops::*};
 
-/// `align(8)` because that is WGSL's alignment for a `vec2<f32>`, so any GPU
-/// struct holding one is laid out the way its shader reads it without having
-/// to say so itself. Those structs still need a manual `unsafe impl Pod`,
-/// since the trailing padding this introduces is what `derive(Pod)` refuses.
-#[repr(C, align(8))]
+#[repr(C)]
 #[derive(Clone, Copy, PartialEq, Default, bytemuck::Pod, bytemuck::Zeroable)]
 pub struct Vec2 {
     pub x: f32,
@@ -71,6 +67,15 @@ impl_op!(Vec2 Sub sub; x y);
 impl_op!(Vec2 Mul mul; x y);
 impl_op!(Vec2 Div div; x y);
 
+impl const 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/data.rs

@@ -1,11 +1,12 @@
-use crate::{RegionAlign, SizeRules, Widget};
+use crate::{RegionAlign, Widget};
 
 pub struct WidgetData {
     pub widget: Box<dyn Widget>,
     pub label: String,
-    pub(super) region_node: bool,
-    pub(super) size: SizeRules,
-    pub(super) align: RegionAlign,
+    /// alignment used if this does not fill up container
+    /// and there is no enforced alignment from parent
+    pub align: RegionAlign,
+    pub rest_len: Option<f32>,
     /// dynamic borrow checking
     pub borrowed: bool,
 }
@@ -18,10 +19,9 @@ impl WidgetData {
         }
         Self {
             widget: Box::new(widget),
+            align: RegionAlign::CENTER,
             label,
-            region_node: false,
-            size: SizeRules::default(),
-            align: RegionAlign::default(),
+            rest_len: None,
             borrowed: false,
         }
     }

core/src/widget/handle.rs

@@ -1,7 +1,7 @@
 use std::{marker::Unsize, ops::CoerceUnsized, sync::mpsc::Sender};
 
 use crate::{
-    UiRsc, Widget,
+    HasUi, Widget,
     util::{RefCounter, SlotId},
 };
 
@@ -12,7 +12,7 @@ pub type WidgetId = SlotId;
 /// a signal is sent to the owning UI to clean up the resources.
 ///
 /// TODO: ergonomic clones when they get put in rust-analyzer & don't cause ICEs?
-pub struct StrongWidget<W: ?Sized = dyn Widget> {
+pub struct WidgetHandle<W: ?Sized = dyn Widget> {
     pub(super) id: WidgetId,
     counter: RefCounter,
     send: Sender<WidgetId>,
@@ -21,19 +21,24 @@ pub struct StrongWidget<W: ?Sized = dyn Widget> {
 
 /// A weak handle to a widget.
 /// Will not keep it alive, but can still be used for indexing like WidgetHandle.
-pub struct WeakWidget<W: ?Sized = dyn Widget> {
+pub struct WidgetRef<W: ?Sized = dyn Widget> {
     pub(super) id: WidgetId,
     #[allow(unused)]
     ty: *const W,
 }
 
-impl<W: Widget + ?Sized + Unsize<dyn Widget>> StrongWidget<W> {
-    pub fn any(self) -> StrongWidget<dyn Widget> {
+pub struct WidgetHandles<W: ?Sized = dyn Widget> {
+    pub h: WidgetHandle<W>,
+    pub r: WidgetRef<W>,
+}
+
+impl<W: Widget + ?Sized + Unsize<dyn Widget>> WidgetHandle<W> {
+    pub fn any(self) -> WidgetHandle<dyn Widget> {
         self
     }
 }
 
-impl<W: ?Sized> StrongWidget<W> {
+impl<W: ?Sized> WidgetHandle<W> {
     pub(crate) fn new(id: WidgetId, send: Sender<WidgetId>) -> Self {
         Self {
             id,
@@ -51,13 +56,18 @@ impl<W: ?Sized> StrongWidget<W> {
         self.counter.refs()
     }
 
-    pub fn weak(&self) -> WeakWidget<W> {
+    pub fn weak(&self) -> WidgetRef<W> {
         let Self { ty, id, .. } = *self;
-        WeakWidget { ty, id }
+        WidgetRef { ty, id }
+    }
+
+    pub fn handles(self) -> WidgetHandles<W> {
+        let r = self.weak();
+        WidgetHandles { h: self, r }
     }
 }
 
-impl<W: ?Sized> WeakWidget<W> {
+impl<W: ?Sized> WidgetRef<W> {
     pub(crate) fn new(id: WidgetId) -> Self {
         Self { id, ty: null_ptr() }
     }
@@ -67,12 +77,12 @@ impl<W: ?Sized> WeakWidget<W> {
     }
 
     #[track_caller]
-    pub fn upgrade(self, ui: &mut impl UiRsc) -> StrongWidget<W> {
-        ui.widgets_mut().upgrade(self)
+    pub fn upgrade(self, ui: &mut impl HasUi) -> WidgetHandle<W> {
+        ui.ui_mut().widgets.upgrade(self)
     }
 }
 
-impl<W: ?Sized> Drop for StrongWidget<W> {
+impl<W: ?Sized> Drop for WidgetHandle<W> {
     fn drop(&mut self) {
         if self.counter.drop() {
             let _ = self.send.send(self.id);
@@ -80,29 +90,29 @@ impl<W: ?Sized> Drop for StrongWidget<W> {
     }
 }
 
-pub trait WidgetIdFn<Rsc, W: ?Sized = dyn Widget>: FnOnce(&mut Rsc) -> WeakWidget<W> {}
-impl<Rsc, W: ?Sized, F: FnOnce(&mut Rsc) -> WeakWidget<W>> WidgetIdFn<Rsc, W> for F {}
+pub trait WidgetIdFn<State, W: ?Sized = dyn Widget>: FnOnce(&mut State) -> WidgetRef<W> {}
+impl<State, W: ?Sized, F: FnOnce(&mut State) -> WidgetRef<W>> WidgetIdFn<State, W> for F {}
 
 pub trait IdLike {
     type Widget: ?Sized;
     fn id(&self) -> WidgetId;
 }
 
-impl<W: ?Sized> IdLike for &StrongWidget<W> {
+impl<W: ?Sized> IdLike for &WidgetHandle<W> {
     type Widget = W;
     fn id(&self) -> WidgetId {
         self.id
     }
 }
 
-impl<W: ?Sized> IdLike for StrongWidget<W> {
+impl<W: ?Sized> IdLike for WidgetHandle<W> {
     type Widget = W;
     fn id(&self) -> WidgetId {
         self.id
     }
 }
 
-impl<W: ?Sized> IdLike for WeakWidget<W> {
+impl<W: ?Sized> IdLike for WidgetRef<W> {
     type Widget = W;
     fn id(&self) -> WidgetId {
         self.id
@@ -116,38 +126,38 @@ impl IdLike for WidgetId {
     }
 }
 
-impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<StrongWidget<U>> for StrongWidget<T> {}
-impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WeakWidget<U>> for WeakWidget<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetHandle<U>> for WidgetHandle<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetRef<U>> for WidgetRef<T> {}
 
-impl<W: ?Sized> Clone for WeakWidget<W> {
+impl<W: ?Sized> Clone for WidgetRef<W> {
     fn clone(&self) -> Self {
         *self
     }
 }
-impl<W: ?Sized> Copy for WeakWidget<W> {}
-impl<W: ?Sized> PartialEq for WeakWidget<W> {
+impl<W: ?Sized> Copy for WidgetRef<W> {}
+impl<W: ?Sized> PartialEq for WidgetRef<W> {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 
-impl<W> PartialEq for StrongWidget<W> {
+impl<W> PartialEq for WidgetHandle<W> {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 
-impl<W> std::fmt::Debug for StrongWidget<W> {
+impl<W> std::fmt::Debug for WidgetHandle<W> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.id.fmt(f)
     }
 }
 
-impl<'a, W: Widget + 'a, State: UiRsc> FnOnce<(&'a mut State,)> for WeakWidget<W> {
+impl<'a, W: Widget + 'a, State: HasUi> FnOnce<(&'a mut State,)> for WidgetRef<W> {
     type Output = &'a mut W;
 
     extern "rust-call" fn call_once(self, args: (&'a mut State,)) -> Self::Output {
-        &mut args.0.widgets_mut()[self]
+        &mut args.0.ui_mut()[self]
     }
 }
 
@@ -159,6 +169,3 @@ fn null_ptr<W: ?Sized>() -> *const W {
         unsafe { std::mem::transmute_copy(&[0usize; 1]) }
     }
 }
-
-unsafe impl<W: ?Sized> Send for WeakWidget<W> {}
-unsafe impl<W: ?Sized> Sync for WeakWidget<W> {}

core/src/widget/like.rs

@@ -1,44 +1,55 @@
-use crate::UiRsc;
+use crate::{HasUi, Ui};
 
 use super::*;
 use std::marker::Unsize;
 
-pub trait WidgetLike<Rsc: UiRsc, Tag>: Sized {
+pub trait StateLike<State> {
+    fn as_state(&mut self) -> &mut State;
+}
+
+impl StateLike<Ui> for Ui {
+    fn as_state(&mut self) -> &mut Ui {
+        self
+    }
+}
+
+pub trait WidgetLike<State: HasUi + StateLike<State>, Tag>: Sized {
     type Widget: Widget + ?Sized + Unsize<dyn Widget>;
 
-    fn add(self, rsc: &mut Rsc) -> WeakWidget<Self::Widget>;
+    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<Self::Widget>;
 
-    fn add_strong(self, rsc: &mut Rsc) -> StrongWidget<Self::Widget> {
-        self.add(rsc).upgrade(rsc)
+    fn add_strong(self, state: &mut impl StateLike<State>) -> WidgetHandle<Self::Widget> {
+        self.add(state).upgrade(state.as_state().ui_mut())
     }
 
     fn with_id<W2>(
         self,
-        f: impl FnOnce(&mut Rsc, WeakWidget<Self::Widget>) -> WeakWidget<W2>,
-    ) -> impl WidgetIdFn<Rsc, W2> {
+        f: impl FnOnce(&mut State, WidgetRef<Self::Widget>) -> WidgetRef<W2>,
+    ) -> impl WidgetIdFn<State, W2> {
         move |state| {
             let id = self.add(state);
             f(state, id)
         }
     }
 
-    fn set_root(self, rsc: &mut Rsc, root: &mut impl HasRoot) {
-        let id = self.add_strong(rsc);
-        root.set_root(id);
+    fn set_root(self, state: &mut impl StateLike<State>) {
+        let id = self.add(state);
+        let ui = state.as_state().ui_mut();
+        ui.root = Some(id.upgrade(ui));
+    }
+
+    fn handles(self, state: &mut impl StateLike<State>) -> WidgetHandles<Self::Widget> {
+        self.add(state).upgrade(state.as_state().ui_mut()).handles()
     }
 }
 
-pub trait HasRoot {
-    fn set_root(&mut self, root: StrongWidget);
-}
-
-pub trait WidgetArrLike<Rsc, const LEN: usize, Tag> {
+pub trait WidgetArrLike<State, const LEN: usize, Tag> {
     #[track_caller]
-    fn add(self, state: &mut Rsc) -> WidgetArr<LEN>;
+    fn add(self, state: &mut impl StateLike<State>) -> WidgetArr<LEN>;
 }
 
-impl<Rsc, const LEN: usize> WidgetArrLike<Rsc, LEN, ArrTag> for WidgetArr<LEN> {
-    fn add(self, _: &mut Rsc) -> WidgetArr<LEN> {
+impl<State, const LEN: usize> WidgetArrLike<State, LEN, ArrTag> for WidgetArr<LEN> {
+    fn add(self, _: &mut impl StateLike<State>) -> WidgetArr<LEN> {
         self
     }
 }
@@ -49,12 +60,12 @@ macro_rules! impl_widget_arr {
         impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*);
     };
     ($n:expr;$($W:ident)*;$($Tag:ident)*) => {
-        impl<Rsc: UiRsc, $($W: WidgetLike<Rsc, $Tag>,$Tag,)*> WidgetArrLike<Rsc, $n, ($($Tag,)*)> for ($($W,)*) {
-            fn add(self, rsc: &mut Rsc) -> WidgetArr<$n> {
+        impl<State: HasUi + StateLike<State>, $($W: WidgetLike<State, $Tag>,$Tag,)*> WidgetArrLike<State, $n, ($($Tag,)*)> for ($($W,)*) {
+            fn add(self, state: &mut impl StateLike<State>) -> WidgetArr<$n> {
                 #[allow(non_snake_case)]
                 let ($($W,)*) = self;
                 WidgetArr::new(
-                    [$($W.add(rsc).upgrade(rsc),)*],
+                    [$($W.add(state).upgrade(state.as_state().ui_mut()),)*],
                 )
             }
         }

core/src/widget/mod.rs

@@ -1,43 +1,24 @@
-use crate::{Axis, LayoutLen, Painter, Size};
+use crate::Painter;
 use std::any::Any;
 
 mod data;
 mod handle;
 mod like;
-mod size_rule;
 mod tag;
-mod view;
 mod widgets;
 
 pub use data::*;
 pub use handle::*;
 pub use like::*;
-pub use size_rule::*;
 pub use tag::*;
-pub use view::*;
 pub use widgets::*;
 
 pub trait Widget: Any {
-    /// Draws the widget, and returns what it used of the box it was given.
-    fn draw(&mut self, painter: &mut Painter) -> Size;
-
-    /// An exact length the widget can give without a painter or its children.
-    /// Optional, and saves a draw rather than changing one: a hint that
-    /// disagrees with the eventual draw fails a debug assertion.
-    fn size_hint(&self, _axis: Axis) -> Option<LayoutLen> {
-        None
-    }
+    fn draw(&mut self, painter: &mut Painter);
 }
 
 impl Widget for () {
-    /// A gap: nothing drawn, at the default length, so a span gives it a share.
-    fn draw(&mut self, _: &mut Painter) -> Size {
-        Size::default()
-    }
-
-    fn size_hint(&self, _axis: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::default())
-    }
+    fn draw(&mut self, _: &mut Painter) {}
 }
 
 impl dyn Widget {
@@ -57,27 +38,27 @@ pub trait WidgetFn<State, W: Widget + ?Sized>: FnOnce(&mut State) -> W {}
 impl<State, W: Widget + ?Sized, F: FnOnce(&mut State) -> W> WidgetFn<State, W> for F {}
 
 pub struct WidgetArr<const LEN: usize> {
-    pub arr: [StrongWidget; LEN],
+    pub arr: [WidgetHandle; LEN],
 }
 
 impl<const LEN: usize> WidgetArr<LEN> {
-    pub fn new(arr: [StrongWidget; LEN]) -> Self {
+    pub fn new(arr: [WidgetHandle; LEN]) -> Self {
         Self { arr }
     }
 }
 
 pub trait WidgetOption<State> {
-    fn get(self, state: &mut State) -> Option<StrongWidget>;
+    fn get(self, state: &mut State) -> Option<WidgetHandle>;
 }
 
 impl<State> WidgetOption<State> for () {
-    fn get(self, _: &mut State) -> Option<StrongWidget> {
+    fn get(self, _: &mut State) -> Option<WidgetHandle> {
         None
     }
 }
 
-impl<State, F: FnOnce(&mut State) -> Option<StrongWidget>> WidgetOption<State> for F {
-    fn get(self, state: &mut State) -> Option<StrongWidget> {
+impl<State, F: FnOnce(&mut State) -> Option<WidgetHandle>> WidgetOption<State> for F {
+    fn get(self, state: &mut State) -> Option<WidgetHandle> {
         self(state)
     }
 }

core/src/widget/size_rule.rs

@@ -1,87 +0,0 @@
-use crate::{Axis, LayoutLen, Weight};
-
-/// What a widget's length on one axis is, as a rule its parent applies where
-/// it draws it rather than an answer the widget gives about itself.
-///
-/// A rule and a drawn size are not two opinions to reconcile: a rule wins on
-/// the axis it names, and the `Size` returned by `draw` answers only the axes
-/// with no rule. That is what lets a span divide its space around a length
-/// nobody has drawn yet, and it is why a rule lives beside the widget rather
-/// than inside it -- the widget under the rule never has to know about it.
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
-pub enum SizeRule {
-    /// Whatever the widget reports from drawing.
-    #[default]
-    Free,
-    /// This length, whatever the widget reports.
-    Exact(LayoutLen),
-}
-
-impl SizeRule {
-    /// The length this rule gives without the widget being drawn, if it can
-    /// give one. `leftover` is never among them: a share is a length only to
-    /// whoever divides one, so it passes up in the reported size instead and
-    /// is resolved there.
-    pub fn declared(&self) -> Option<LayoutLen> {
-        match self {
-            Self::Exact(len) if len.leftover == Weight::ZERO => Some(*len),
-            _ => None,
-        }
-    }
-
-    /// The length this rule gives outright, whatever the widget reports --
-    /// which makes the widget's answer on that axis moot. A share counts: it
-    /// is a length the widget's parent still has to divide, so it is exact
-    /// here and resolved there, unlike `declared`, which is only the ones
-    /// that give a box directly.
-    pub fn exact(&self) -> Option<LayoutLen> {
-        match self {
-            Self::Free => None,
-            Self::Exact(len) => Some(*len),
-        }
-    }
-
-    /// The length a widget reporting `reported` ends up with.
-    pub fn apply(&self, reported: LayoutLen) -> LayoutLen {
-        match self {
-            Self::Free => reported,
-            Self::Exact(len) => *len,
-        }
-    }
-}
-
-impl From<LayoutLen> for SizeRule {
-    fn from(len: LayoutLen) -> Self {
-        Self::Exact(len)
-    }
-}
-
-impl From<Option<LayoutLen>> for SizeRule {
-    fn from(len: Option<LayoutLen>) -> Self {
-        len.map_or(Self::Free, Self::Exact)
-    }
-}
-
-/// One rule per axis, which is how a widget carries a length on one axis and
-/// leaves the other to whatever it draws.
-#[derive(Debug, Clone, Copy, PartialEq, Default)]
-pub struct SizeRules {
-    pub x: SizeRule,
-    pub y: SizeRule,
-}
-
-impl SizeRules {
-    pub fn axis(&self, axis: Axis) -> SizeRule {
-        match axis {
-            Axis::X => self.x,
-            Axis::Y => self.y,
-        }
-    }
-
-    pub fn axis_mut(&mut self, axis: Axis) -> &mut SizeRule {
-        match axis {
-            Axis::X => &mut self.x,
-            Axis::Y => &mut self.y,
-        }
-    }
-}

core/src/widget/tag.rs

@@ -1,63 +1,58 @@
 use super::*;
-use crate::UiRsc;
+use crate::HasUi;
 use std::marker::Unsize;
 
 pub struct WidgetTag;
-impl<Rsc: UiRsc, W: Widget> WidgetLike<Rsc, WidgetTag> for W {
+impl<State: HasUi + StateLike<State>, W: Widget> WidgetLike<State, WidgetTag> for W {
     type Widget = W;
-    fn add(self, rsc: &mut Rsc) -> WeakWidget<W> {
-        let w = rsc.ui_mut().widgets.add_weak(self);
-        rsc.on_add(w);
-        w
+    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
+        state.as_state().get_mut().widgets.add_weak(self)
     }
 }
 
 pub struct FnTag;
-impl<Rsc: UiRsc, W: Widget, F: FnOnce(&mut Rsc) -> W> WidgetLike<Rsc, FnTag> for F {
-    type Widget = W;
-    fn add(self, rsc: &mut Rsc) -> WeakWidget<W> {
-        self(rsc).add(rsc)
-    }
-}
-
-pub trait WidgetFnTrait<Rsc> {
-    type Widget: Widget;
-    fn run(self, rsc: &mut Rsc) -> Self::Widget;
-}
-pub struct FnTraitTag;
-impl<Rsc: UiRsc, T: WidgetFnTrait<Rsc>> WidgetLike<Rsc, FnTraitTag> for T {
-    type Widget = T::Widget;
-    #[track_caller]
-    fn add(self, rsc: &mut Rsc) -> WeakWidget<T::Widget> {
-        self.run(rsc).add(rsc)
-    }
-}
-
-pub struct RefTag;
-impl<Rsc: UiRsc, W: ?Sized + Widget + Unsize<dyn Widget>> WidgetLike<Rsc, RefTag>
-    for WeakWidget<W>
+impl<State: HasUi + StateLike<State>, W: Widget, F: FnOnce(&mut State) -> W>
+    WidgetLike<State, FnTag> for F
 {
     type Widget = W;
-    fn add(self, _: &mut Rsc) -> WeakWidget<W> {
+    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
+        self(state.as_state()).add(state)
+    }
+}
+
+pub trait WidgetFnTrait<State> {
+    type Widget: Widget;
+    fn run(self, state: &mut State) -> Self::Widget;
+}
+pub struct FnTraitTag;
+impl<State: HasUi + StateLike<State>, T: WidgetFnTrait<State>> WidgetLike<State, FnTraitTag> for T {
+    type Widget = T::Widget;
+    #[track_caller]
+    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<T::Widget> {
+        self.run(state.as_state()).add(state)
+    }
+}
+
+pub struct IdTag;
+impl<State: HasUi + StateLike<State>, W: ?Sized + Widget + Unsize<dyn Widget>>
+    WidgetLike<State, IdTag> for WidgetRef<W>
+{
+    type Widget = W;
+    fn add(self, _: &mut impl StateLike<State>) -> WidgetRef<W> {
         self
     }
 }
 
-pub struct RefFnTag;
-impl<Rsc: UiRsc, W: ?Sized + Widget + Unsize<dyn Widget>, F: FnOnce(&mut Rsc) -> WeakWidget<W>>
-    WidgetLike<Rsc, RefFnTag> for F
+pub struct IdFnTag;
+impl<
+    State: HasUi + StateLike<State>,
+    W: ?Sized + Widget + Unsize<dyn Widget>,
+    F: FnOnce(&mut State) -> WidgetRef<W>,
+> WidgetLike<State, IdFnTag> for F
 {
     type Widget = W;
-    fn add(self, rsc: &mut Rsc) -> WeakWidget<W> {
-        self(rsc)
-    }
-}
-
-pub struct ViewTag;
-impl<Rsc: UiRsc, V: WidgetView> WidgetLike<Rsc, ViewTag> for V {
-    type Widget = V::Widget;
-    fn add(self, _: &mut Rsc) -> WeakWidget<Self::Widget> {
-        self.root()
+    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
+        self(state.as_state())
     }
 }
 

core/src/widget/view.rs

@@ -1,24 +0,0 @@
-use std::marker::Unsize;
-
-use crate::{IdLike, WeakWidget, Widget};
-
-pub trait WidgetView {
-    type Widget: Widget + ?Sized + Unsize<dyn Widget>;
-    fn root(&self) -> WeakWidget<Self::Widget>;
-}
-
-pub trait HasWidget {
-    type Widget: Widget + ?Sized + Unsize<dyn Widget>;
-}
-
-impl<W: Widget + Unsize<dyn Widget> + ?Sized> HasWidget for WeakWidget<W> {
-    type Widget = W;
-}
-
-impl<WV: WidgetView> IdLike for WV {
-    type Widget = WV::Widget;
-
-    fn id(&self) -> super::WidgetId {
-        self.root().id
-    }
-}

core/src/widget/widgets.rs

@@ -1,8 +1,7 @@
-use std::sync::mpsc::{Receiver, Sender, channel};
+use std::sync::mpsc::Sender;
 
 use crate::{
-    Axis, AxisAlign, IdLike, RegionAlign, SizeRule, SizeRules, StrongWidget, WeakWidget, Widget,
-    WidgetData, WidgetId,
+    IdLike, Widget, WidgetData, WidgetHandle, WidgetId, WidgetRef,
     util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut},
 };
 
@@ -10,19 +9,16 @@ pub struct Widgets {
     pub needs_redraw: HashSet<WidgetId>,
     vec: SlotVec<WidgetData>,
     send: Sender<WidgetId>,
-    recv: Receiver<WidgetId>,
     pub(crate) waiting: HashSet<WidgetId>,
 }
 
 impl Widgets {
-    pub fn new() -> Self {
-        let (send, recv) = channel();
+    pub fn new(send: Sender<WidgetId>) -> Self {
         Self {
             needs_redraw: Default::default(),
             vec: Default::default(),
             waiting: Default::default(),
             send,
-            recv,
         }
     }
 
@@ -30,18 +26,9 @@ impl Widgets {
         !self.needs_redraw.is_empty()
     }
 
-    pub fn get_dyn(&self, id: WidgetId) -> Option<&dyn Widget> {
-        Some(self.vec.get(id)?.widget.as_ref())
-    }
-
-    pub fn get_dyn_mut(&mut self, id: WidgetId) -> Option<&mut dyn Widget> {
-        self.needs_redraw.insert(id);
-        Some(self.vec.get_mut(id)?.widget.as_mut())
-    }
-
     /// get_dyn but dynamic borrow checking of widgets
     /// lets you do recursive (tree) operations, like the painter does
-    pub(crate) fn get_dyn_dynamic<'a>(&self, id: WidgetId) -> WidgetWrapper<'a> {
+    pub(crate) fn get_dyn<'a>(&self, id: WidgetId) -> WidgetWrapper<'a> {
         // SAFETY: must guarantee no other mutable references to this widget exist
         // done through the borrow variable
         let data = unsafe { forget_mut(to_mut(self.vec.get(id).unwrap())) };
@@ -55,29 +42,41 @@ impl Widgets {
     where
         I::Widget: Sized + Widget,
     {
-        self.get_dyn(id.id())?.as_any().downcast_ref()
+        self.vec
+            .get(id.id())?
+            .widget
+            .as_ref()
+            .as_any()
+            .downcast_ref()
     }
 
     pub fn get_mut<I: IdLike>(&mut self, id: &I) -> Option<&mut I::Widget>
     where
         I::Widget: Sized + Widget,
     {
-        self.get_dyn_mut(id.id())?.as_any_mut().downcast_mut()
+        let id = id.id();
+        self.needs_redraw.insert(id);
+        self.vec
+            .get_mut(id)?
+            .widget
+            .as_mut()
+            .as_any_mut()
+            .downcast_mut()
     }
 
-    pub fn add_strong<W: Widget>(&mut self, widget: W) -> StrongWidget<W> {
+    pub fn add_strong<W: Widget>(&mut self, widget: W) -> WidgetHandle<W> {
         let id = self.vec.add(WidgetData::new(widget));
-        StrongWidget::new(id, self.send.clone())
+        WidgetHandle::new(id, self.send.clone())
     }
 
-    pub fn add_weak<W: Widget>(&mut self, widget: W) -> WeakWidget<W> {
+    pub fn add_weak<W: Widget>(&mut self, widget: W) -> WidgetRef<W> {
         let id = self.vec.add(WidgetData::new(widget));
         self.waiting.insert(id);
-        WeakWidget::new(id)
+        WidgetRef::new(id)
     }
 
     #[track_caller]
-    pub fn upgrade<W: ?Sized>(&mut self, rf: WeakWidget<W>) -> StrongWidget<W> {
+    pub fn upgrade<W: ?Sized>(&mut self, rf: WidgetRef<W>) -> WidgetHandle<W> {
         if !self.waiting.remove(&rf.id()) {
             let label = self.label(rf);
             let id = rf.id();
@@ -85,7 +84,7 @@ impl Widgets {
                 "widget '{label}' ({id:?}) was already added\ncannot add a widget twice; consider creating two"
             )
         }
-        StrongWidget::new(rf.id(), self.send.clone())
+        WidgetHandle::new(rf.id(), self.send.clone())
     }
 
     pub fn data(&self, id: impl IdLike) -> Option<&WidgetData> {
@@ -96,84 +95,14 @@ impl Widgets {
         &self.data(id.id()).unwrap().label
     }
 
-    /// useful for debugging
-    pub fn set_label(&mut self, id: impl IdLike, label: String) {
-        self.data_mut(id.id()).unwrap().label = label;
-    }
-
-    /// Whether this widget owns a movable retained region.
-    pub fn is_region_node(&self, id: impl IdLike) -> bool {
-        self.data(id).unwrap().region_node
-    }
-
-    /// Chooses whether this widget's retained drawing has one movable region
-    /// of its own. Changing the boundary redraws the subtree once so every
-    /// primitive names the right coordinate space.
-    pub fn set_region_node(&mut self, id: impl IdLike, region_node: bool) {
-        let id = id.id();
-        let data = self.data_mut(id).unwrap();
-        if data.region_node == region_node {
-            return;
-        }
-        data.region_node = region_node;
-        self.needs_redraw.insert(id);
-    }
-
-    /// The length rules whoever draws this widget applies to its box.
-    pub fn size_rules(&self, id: impl IdLike) -> SizeRules {
-        self.data(id).unwrap().size
-    }
-
-    /// Sets one axis's rule. The widget is marked rather than its parent
-    /// because the parent is not known here; `redraw` escalates a changed
-    /// declared length to whoever resolves it.
-    pub fn set_size_rule(&mut self, id: impl IdLike, axis: Axis, rule: SizeRule) {
-        let id = id.id();
-        let data = self.data_mut(id).unwrap();
-        if *data.size.axis_mut(axis) == rule {
-            return;
-        }
-        *data.size.axis_mut(axis) = rule;
-        self.needs_redraw.insert(id);
-    }
-
-    /// Where this widget sits in a box longer than the length it takes.
-    pub fn alignment(&self, id: impl IdLike) -> RegionAlign {
-        self.data(id).unwrap().align
-    }
-
-    /// Sets one axis's alignment. Which box a widget ends up in is its
-    /// parent's to decide, so this is escalated the way a length rule is.
-    pub fn set_alignment(&mut self, id: impl IdLike, axis: Axis, align: AxisAlign) {
-        let id = id.id();
-        let data = self.data_mut(id).unwrap();
-        if *data.align.axis_mut(axis) == align {
-            return;
-        }
-        *data.align.axis_mut(axis) = align;
-        self.needs_redraw.insert(id);
-    }
-
-    /// Both axes at once, for a caller holding a pair.
-    pub fn set_size_rules(
-        &mut self,
-        id: impl IdLike,
-        x: impl Into<SizeRule>,
-        y: impl Into<SizeRule>,
-    ) {
-        let id = id.id();
-        self.set_size_rule(id, Axis::X, x.into());
-        self.set_size_rule(id, Axis::Y, y.into());
-    }
-
     pub fn data_mut(&mut self, id: impl IdLike) -> Option<&mut WidgetData> {
         self.vec.get_mut(id.id())
     }
 
-    pub fn free_next(&mut self) -> Option<WidgetId> {
-        let next = self.recv.try_recv().ok()?;
-        self.vec.free(next);
-        Some(next)
+    pub fn delete(&mut self, id: impl IdLike) {
+        self.vec.free(id.id());
+        // not sure if there's any point in this
+        // self.updates.remove(&id);
     }
 
     #[allow(clippy::len_without_is_empty)]
@@ -182,30 +111,4 @@ impl Widgets {
     }
 }
 
-impl Default for Widgets {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>;
-
-impl<I: IdLike> std::ops::Index<I> for Widgets
-where
-    I::Widget: Sized + Widget,
-{
-    type Output = I::Widget;
-
-    fn index(&self, id: I) -> &Self::Output {
-        self.get(&id).unwrap()
-    }
-}
-
-impl<I: IdLike> std::ops::IndexMut<I> for Widgets
-where
-    I::Widget: Sized + Widget,
-{
-    fn index_mut(&mut self, id: I) -> &mut Self::Output {
-        self.get_mut(&id).unwrap()
-    }
-}

examples/minimal.rs

@@ -1,17 +1,20 @@
 use iris::prelude::*;
 
 fn main() {
-    DefaultApp::<State>::run();
+    App::<State>::run();
 }
 
-#[derive(DefaultUiState)]
-struct State {
-    ui_state: DefaultUiState,
-}
+#[default_ui_state]
+struct State {}
 
 impl DefaultAppState for State {
-    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 }
+    fn new(ui_state: DefaultUiState, _proxy: Proxy<Self::Event>) -> Self {
+        let mut ui = Ui::new();
+        rect(Color::RED).set_root(&mut ui);
+        Self {
+            ui,
+            ui_state,
+            events: EventManager::default(),
+        }
     }
 }

examples/random.rs

@@ -1,31 +0,0 @@
-//! The seeded random tree `tests/generated.rs` checks, drawn so it can be
-//! looked at. `IRIS_SEED` and `IRIS_DEPTH` choose which one.
-
-use iris::prelude::*;
-use iris::random::Edits;
-
-fn env(name: &str, fallback: u64) -> u64 {
-    std::env::var(name)
-        .ok()
-        .and_then(|v| v.parse().ok())
-        .unwrap_or(fallback)
-}
-
-fn main() {
-    DefaultApp::<State>::run();
-}
-
-#[derive(DefaultUiState)]
-struct State {
-    ui_state: DefaultUiState,
-}
-
-impl DefaultAppState for State {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
-        let seed = env("IRIS_SEED", 1);
-        let depth = env("IRIS_DEPTH", 4) as usize;
-        let (root, _) = iris::random::grow(rsc, seed, depth, &Edits::default());
-        ui_state.set_root(root);
-        Self { ui_state }
-    }
-}

examples/task.rs

@@ -1,30 +0,0 @@
-use iris::prelude::*;
-use std::time::Duration;
-
-fn main() {
-    DefaultApp::<State>::run();
-}
-
-#[derive(DefaultUiState)]
-struct State {
-    ui_state: DefaultUiState,
-}
-
-impl DefaultAppState for State {
-    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;
-            ctx.update(move |_, rsc| {
-                let rect = rect(rsc);
-                if rect.color == Color::RED {
-                    rect.color = Color::BLUE;
-                } else {
-                    rect.color = Color::RED;
-                }
-            });
-        })
-        .set_root(rsc, &mut ui_state);
-        Self { ui_state }
-    }
-}

examples/text.rs

@@ -1,67 +0,0 @@
-//! Text sizing: wrapped text reads the width it is offered, fixed text does
-//! not, and both report a height their container lays out around.
-
-use iris::prelude::*;
-
-fn main() {
-    DefaultApp::<State>::run();
-}
-
-#[derive(DefaultUiState)]
-struct State {
-    ui_state: DefaultUiState,
-}
-
-const SAMPLE: &str = "Wrapping shapes one source into as many lines as its container \
-    leaves room for, so the height of a paragraph is an answer rather than a setting, and \
-    the same words in a narrower box come back taller. Resize the window and watch the \
-    text below reflow into a different number of lines while nothing about it changes.";
-
-impl DefaultAppState for State {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
-        let panel = || rect(Color::WHITE.darker(0.85));
-
-        let wrapped = wtext(SAMPLE)
-            .size(28)
-            .wrap(true)
-            .text_align(Align::LEFT)
-            .pad(16)
-            .background(panel());
-
-        // Each one takes the whole width, because `text_align` puts the
-        // glyphs somewhere in the box the text is given and a text that
-        // reports the width of its own glyphs is given exactly that.
-        let label = |text: &str, align| wtext(text).size(24).text_align(align).width(rel(1.0));
-        let aligned = (
-            label("left", Align::LEFT),
-            label("centred", Align::H_CENTER),
-            label("right", 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

@@ -1,49 +0,0 @@
-use iris::prelude::*;
-
-fn main() {
-    DefaultApp::<State>::run();
-}
-
-#[derive(DefaultUiState)]
-struct State {
-    ui_state: DefaultUiState,
-}
-
-type Rsc = DefaultRsc<State>;
-
-#[derive(Clone, Copy, WidgetView)]
-struct Test {
-    #[root]
-    root: WeakWidget<Rect>,
-    cur: WeakState<bool>,
-}
-
-impl Test {
-    pub fn new(rsc: &mut Rsc) -> Self {
-        let root = rect(Color::RED).add(rsc);
-        let cur = rsc.create_state(root, false);
-        Self { root, cur }
-    }
-    pub fn toggle(&self, rsc: &mut Rsc) {
-        let cur = &mut rsc[self.cur];
-        *cur = !*cur;
-        if *cur {
-            rsc[self.root].color = Color::BLUE;
-        } else {
-            rsc[self.root].color = Color::RED;
-        }
-    }
-}
-
-impl DefaultAppState for State {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
-        let test = Test::new(rsc);
-
-        test.on(CursorSense::click(), move |_, rsc| {
-            test.toggle(rsc);
-        })
-        .set_root(rsc, &mut ui_state);
-
-        Self { ui_state }
-    }
-}

macro/src/lib.rs

@@ -2,8 +2,8 @@ extern crate proc_macro;
 use proc_macro::TokenStream;
 use quote::quote;
 use syn::{
-    Attribute, Block, Error, GenericParam, Generics, Ident, ItemStruct, ItemTrait, Signature,
-    Token, Type, Visibility,
+    Attribute, Block, Error, Fields, FieldsNamed, GenericParam, Generics, Ident, ItemStruct,
+    ItemTrait, Meta, Signature, Token, Visibility,
     parse::{Parse, ParseStream, Result},
     parse_macro_input, parse_quote,
     spanned::Spanned,
@@ -89,108 +89,104 @@ pub fn widget_trait(input: TokenStream) -> TokenStream {
     quote! {
         #trai
 
-        impl #generics #name<Rsc, WL, Tag> for WL {
+        impl #generics #name<State, WL, Tag> for WL {
             #(#impls)*
         }
     }
     .into()
 }
 
-#[proc_macro_derive(DefaultUiState, attributes(default_ui_state))]
-pub fn derive_default_ui_state(input: TokenStream) -> TokenStream {
+#[proc_macro_derive(UiState, attributes(rsc))]
+pub fn derive_ui_state(input: TokenStream) -> TokenStream {
     let mut output = proc_macro2::TokenStream::new();
 
     let state: ItemStruct = parse_macro_input!(input);
+    let sname = state.ident;
+    let rscname = Ident::new(&(sname.to_string() + "Rsc"), sname.span());
+    let mut rsc_fields = Vec::new();
 
-    let mut found_attr = false;
-    let mut state_field = None;
-    for field in &state.fields {
-        if !found_attr
-            && let Type::Path(path) = &field.ty
-            && path.path.is_ident("DefaultUiState")
-        {
-            state_field = Some(field);
-        }
-        let Some(attr) = field
-            .attrs
-            .iter()
-            .find(|a| a.path().is_ident("default_ui_state"))
-        else {
+    for field in state.fields {
+        let Some(attr) = field.attrs.iter().find(|a| a.path().is_ident("rsc")) else {
             continue;
         };
-        if found_attr {
-            output.extend(
-                Error::new(
-                    attr.span(),
-                    "cannot have more than one default_ui_state attribute",
-                )
-                .into_compile_error(),
-            );
+        let Meta::List(list) = &attr.meta else {
+            output.extend(Error::new(attr.span(), "invalid attr syntax").into_compile_error());
             continue;
-        }
-        found_attr = true;
-        state_field = Some(field);
-    }
-    let Some(field) = state_field else {
-        output.extend(
-            Error::new(state.ident.span(), "no DefaultUiState field found").into_compile_error(),
-        );
-        return output.into();
-    };
-    let sname = &state.ident;
-    let fname = field.ident.as_ref().unwrap();
-    output.extend(quote! {
-        impl iris::default::HasDefaultUiState for #sname {
-            fn default_state(&self) -> &iris::default::DefaultUiState {
-                &self.#fname
+        };
+        let tname: Ident = match list.parse_args::<Ident>() {
+            Ok(ident) => ident,
+            Err(err) => {
+                output.extend(err.to_compile_error());
+                continue;
             }
-            fn default_state_mut(&mut self) -> &mut iris::default::DefaultUiState {
-                &mut self.#fname
+        };
+        let fty = &field.ty;
+        let fname = &field.ident.unwrap();
+        rsc_fields.extend(quote! {#fname: #fty,});
+        output.extend(quote! {
+            impl #tname for #sname {
+                fn get(&self) -> &#fty {
+                    &self.#fname
+                }
+                fn get_mut(&mut self) -> &mut #fty {
+                    &mut self.#fname
+                }
+            }
+            impl #tname for #rscname {
+                fn get(&self) -> &#fty {
+                    &self.#fname
+                }
+                fn get_mut(&mut self) -> &mut #fty {
+                    &mut self.#fname
+                }
+            }
+        });
+    }
+    let vis = state.vis;
+    output.extend(quote! {
+        #vis struct #rscname {
+            #(#rsc_fields)*
+        }
+
+        impl HasState for #sname {
+            type State = #sname;
+        }
+
+        impl HasState for #rscname {
+            type State = #sname;
+        }
+
+        impl StateLike<#sname> for #sname {
+            fn as_state(&mut self) -> &mut Self {
+                self
+            }
+        }
+
+        impl StateLike<#rscname> for #rscname {
+            fn as_state(&mut self) -> &mut Self {
+                self
             }
         }
     });
     output.into()
 }
 
-#[proc_macro_derive(WidgetView, attributes(root))]
-pub fn derive_widget_view(input: TokenStream) -> TokenStream {
-    let mut output = proc_macro2::TokenStream::new();
-
-    let state: ItemStruct = parse_macro_input!(input);
-
-    let mut found_attr = false;
-    let mut state_field = None;
-    for field in &state.fields {
-        let Some(attr) = field.attrs.iter().find(|a| a.path().is_ident("root")) else {
-            continue;
-        };
-        if found_attr {
-            output.extend(
-                Error::new(attr.span(), "cannot have more than one root widget")
-                    .into_compile_error(),
-            );
-            continue;
-        }
-        found_attr = true;
-        state_field = Some(field);
-    }
-    let Some(field) = state_field else {
-        output.extend(
-            Error::new(state.ident.span(), "no root widget field found (#[root])")
-                .into_compile_error(),
-        );
-        return output.into();
+#[proc_macro_attribute]
+pub fn default_ui_state(_attr: TokenStream, input: TokenStream) -> TokenStream {
+    let mut state: ItemStruct = parse_macro_input!(input);
+    let Fields::Named(fields) = &mut state.fields else {
+        panic!("must be on named fields struct");
     };
-    let sname = &state.ident;
-    let fname = field.ident.as_ref().unwrap();
-    let fty = &field.ty;
-    output.extend(quote! {
-        impl iris::core::WidgetView for #sname {
-            type Widget = <#fty as iris::core::HasWidget>::Widget;
-            fn root(&self) -> #fty {
-                self.#fname
-            }
-        }
-    });
-    output.into()
+    let name = &state.ident;
+    state.attrs.push(parse_quote! {#[derive(UiState)]});
+    let new: FieldsNamed = parse_quote! {{
+        #[rsc(HasUi)]
+        pub ui: Ui,
+        #[rsc(HasDefaultUiState)]
+        pub ui_state: DefaultUiState,
+        #[rsc(HasEvents)]
+        pub events: iris::prelude::EventManager<#name>,
+    }};
+    fields.named.extend(new.named);
+    quote! {#state}.into()
 }

readme.md

@@ -4,12 +4,12 @@ My experimental attempt at a rust ui library (also my first ui library).
 
 It's currently designed around using retained data structures (widgets), rather than diffing generated trees from data like xilem or iced. This is an experiment and I'm not sure if it's a good idea or not.
 
-Examples are in `examples`, eg. `cargo run --example tabs`.
+There's a `main.rs` that runs a testing window, so you can just `cargo run` to see it working.
 
 Goals, in general order:
 1. does what I want it to (text, images, video, animations)
 2. very easy to use ignoring ergonomic ref counting
-3. reasonably fast / efficient (a lot faster than electron, save battery life, try to beat iced and xilem)
+3. reasonably fast / efficient (a lot faster than electron, save battery life)
 
 ## dev details
 

rig-input/Cargo.toml

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

rig-input/src/main.rs

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

rust-toolchain.toml

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

scripts/headless.conf

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

scripts/run-headless.sh

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

src/bin/test/main.rs

@@ -1,48 +1,49 @@
+use cosmic_text::Family;
 use std::{cell::RefCell, rc::Rc};
 use winit::event::WindowEvent;
 
-use iris::prelude::*;
-type ClientRsc = DefaultRsc<Client>;
+iris::state_prelude!(ClientRsc);
 
 fn main() {
-    DefaultApp::<Client>::run();
+    App::<Client>::run();
 }
 
-#[derive(DefaultUiState)]
+#[default_ui_state]
 pub struct Client {
-    ui_state: DefaultUiState,
-    info: WeakWidget<Text>,
+    info: WidgetRef<Text>,
 }
 
 impl DefaultAppState for Client {
-    fn new(mut ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self>) -> Self {
+    fn new(ui_state: DefaultUiState, _proxy: Proxy<Self::Event>) -> Self {
+        let mut rsc = ClientRsc {
+            ui: Ui::new(),
+            ui_state,
+            events: EventManager::default(),
+        };
+
         let rrect = rect(Color::WHITE).radius(20);
         let pad_test = (
             rrect.color(Color::BLUE),
             (
-                // The square is one widget and the two shares of the row it
-                // sits centred in are another: a length is a property of a
-                // widget, so `.width` here would overwrite the `.sized`.
                 rrect
                     .color(Color::RED)
                     .sized((100, 100))
                     .center()
-                    .wrapper()
-                    .width(leftover(2)),
+                    .width(rest(2)),
                 (
                     rrect.color(Color::ORANGE),
                     rrect.color(Color::LIME).pad(10.0),
                 )
                     .span(Dir::RIGHT)
-                    .width(leftover(2)),
+                    .width(rest(2)),
                 rrect.color(Color::YELLOW),
             )
                 .span(Dir::RIGHT)
                 .pad(10)
-                .width(leftover(3)),
+                .width(rest(3)),
         )
             .span(Dir::RIGHT)
-            .add(rsc);
+            .add(&mut rsc);
 
         let span_test = (
             rrect.color(Color::GREEN).width(100),
@@ -53,30 +54,30 @@ impl DefaultAppState for Client {
             rrect.color(Color::RED).width(100),
         )
             .span(Dir::LEFT)
-            .add(rsc);
+            .add(&mut rsc);
 
-        let span_add = Span::empty(Dir::RIGHT).add(rsc);
+        let span_add = Span::empty(Dir::RIGHT).add(&mut rsc);
 
         let add_button = rect(Color::LIME)
             .radius(30)
-            .on(CursorSense::click(), move |_, rsc| {
+            .on(CursorSense::click(), move |ctx| {
                 let child = image(include_bytes!("assets/sungals.png"))
                     .center()
-                    .add_strong(rsc);
-                span_add(rsc).push(child);
+                    .add_strong(ctx);
+                span_add(ctx).push(child);
             })
             .sized((150, 150))
             .align(Align::BOT_RIGHT);
 
         let del_button = rect(Color::RED)
             .radius(30)
-            .on(CursorSense::click(), move |_, rsc| {
-                span_add(rsc).pop();
+            .on(CursorSense::click(), move |ctx| {
+                span_add(ctx).pop();
             })
             .sized((150, 150))
             .align(Align::BOT_LEFT);
 
-        let span_add_test = (span_add, add_button, del_button).stack().add(rsc);
+        let span_add_test = (span_add, add_button, del_button).stack().add(&mut rsc);
 
         let btext = |content| wtext(content).size(30);
 
@@ -99,18 +100,18 @@ impl DefaultAppState for Client {
             wtext("pretty cool right?").size(50),
         )
             .span(Dir::DOWN)
-            .add(rsc);
+            .add(&mut rsc);
 
-        let texts = Span::empty(Dir::DOWN).gap(10).add(rsc);
+        let texts = Span::empty(Dir::DOWN).gap(10).add(&mut rsc);
         let msg_area = texts.scrollable().masked().background(rect(Color::SKY));
         let add_text = wtext("add")
             .editable(EditMode::MultiLine)
             .text_align(Align::LEFT)
             .size(30)
             .attr::<Selectable>(())
-            .on(Submit, move |ctx, rsc| {
+            .on(Submit, move |ctx| {
                 let w = ctx.widget;
-                let content = w.edit(rsc).take();
+                let content = w.edit(ctx).take();
                 let text = wtext(content)
                     .editable(EditMode::MultiLine)
                     .size(30)
@@ -119,20 +120,19 @@ impl DefaultAppState for Client {
                     .attr::<Selectable>(());
                 let msg_box = text
                     .background(rect(Color::WHITE.darker(0.5)))
-                    .add_strong(rsc);
-                texts(rsc).push(msg_box);
+                    .add_strong(ctx);
+                texts(ctx).push(msg_box);
             })
-            .add(rsc);
-
+            .add(&mut rsc);
         let text_edit_scroll = (
-            msg_area.height(leftover(1)),
+            msg_area.height(rest(1)),
             (
                 Rect::new(Color::WHITE.darker(0.9)),
                 (
-                    add_text.width(leftover(1)),
+                    add_text.width(rest(1)),
                     Rect::new(Color::GREEN)
-                        .on(CursorSense::click(), move |ctx, rsc: &mut ClientRsc| {
-                            rsc.run_event::<Submit>(add_text, (), ctx.state);
+                        .on(CursorSense::click(), move |ctx| {
+                            ctx.state.run_event::<Submit>(add_text, &mut ());
                         })
                         .sized((40, 40)),
                 )
@@ -145,39 +145,39 @@ impl DefaultAppState for Client {
                 .align(Align::BOT),
         )
             .span(Dir::DOWN)
-            .add(rsc);
+            .add(&mut rsc);
 
-        let main = Wrapper::new().add(rsc);
+        let main = WidgetPtr::new().add(&mut rsc);
 
         let vals = Rc::new(RefCell::new((0, Vec::new())));
-        let mut switch_button = |color, to: WeakWidget, label| {
-            let to = to.upgrade(rsc);
+        let mut switch_button = |color, to: WidgetRef, label| {
+            let to = to.upgrade(&mut rsc);
             let vec = &mut vals.borrow_mut().1;
             let i = vec.len();
             if vec.is_empty() {
                 vec.push(None);
-                main(rsc).set(to);
+                rsc.ui[main].set(to);
             } else {
                 vec.push(Some(to));
             }
             let vals = vals.clone();
             let rect = rect(color)
-                .on(CursorSense::click(), move |ctx, rsc| {
+                .on(CursorSense::click(), move |ctx| {
                     let (prev, vec) = &mut *vals.borrow_mut();
                     if let Some(h) = vec[i].take() {
-                        vec[*prev] = main(rsc).replace(h);
+                        vec[*prev] = main(ctx).replace(h);
                         *prev = i;
                     }
-                    ctx.widget(rsc).color = color.darker(0.3);
+                    ctx.widget().color = color.darker(0.3);
                 })
                 .on(
                     CursorSense::HoverStart | CursorSense::unclick(),
-                    move |ctx, rsc| {
-                        ctx.widget(rsc).color = color.brighter(0.2);
+                    move |ctx| {
+                        ctx.widget().color = color.brighter(0.2);
                     },
                 )
-                .on(CursorSense::HoverEnd, move |ctx, rsc| {
-                    ctx.widget(rsc).color = color;
+                .on(CursorSense::HoverEnd, move |ctx| {
+                    ctx.widget().color = color;
                 });
             (rect, wtext(label).size(30).text_align(Align::CENTER)).stack()
         };
@@ -195,30 +195,30 @@ impl DefaultAppState for Client {
         )
             .span(Dir::RIGHT);
 
-        let info = wtext("").add(rsc);
+        let info = wtext("").add(&mut rsc);
         let info_sect = info.pad(10).align(Align::RIGHT);
 
         ((tabs.height(40), main.pad(10)).span(Dir::DOWN), info_sect)
             .stack()
-            .set_root(rsc, &mut ui_state);
+            .set_root(&mut rsc);
 
-        Self { ui_state, info }
+        Self {
+            ui: rsc.ui,
+            ui_state: rsc.ui_state,
+            events: rsc.events,
+            info,
+        }
     }
 
-    fn window_event(
-        &mut self,
-        _: WindowEvent,
-        rsc: &mut DefaultRsc<Self>,
-        render: &mut UiRenderState,
-    ) {
+    fn window_event(&mut self, _: WindowEvent) {
         let new = format!(
-            "widgets: {}\nactive: {}\ntextures: {}",
-            rsc.widgets().len(),
-            render.active_widgets(),
-            rsc.ui().textures.count(),
+            "widgets: {}\nactive:{}\nviews: {}",
+            self.ui.num_widgets(),
+            self.ui.active_widgets(),
+            self.ui_state.renderer.ui.view_count()
         );
-        if new != *rsc.widgets()[self.info].content {
-            *rsc.widgets_mut()[self.info].content = new;
+        if new != *self.ui[self.info].content {
+            *self.ui[self.info].content = new;
         }
     }
 }

src/default/app.rs

@@ -11,13 +11,6 @@ pub trait AppState {
     fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop);
     fn event(&mut self, event: Self::Event, event_loop: &ActiveEventLoop);
     fn exit(&mut self);
-
-    fn run()
-    where
-        Self: Sized,
-    {
-        App::<Self>::run();
-    }
 }
 
 pub struct App<State: AppState> {

src/default/attr.rs

@@ -4,47 +4,35 @@ use winit::dpi::{LogicalPosition, LogicalSize};
 
 pub struct Selector;
 
-impl<Rsc: HasEvents, W: Widget + 'static> WidgetAttr<Rsc, W> for Selector
+impl<State: HasEvents, W: Widget + 'static> WidgetAttr<State, W> for Selector
 where
-    Rsc::State: HasDefaultUiState,
+    State::State: HasDefaultUiState,
 {
-    type Input = WeakWidget<TextEdit>;
+    type Input = WidgetRef<TextEdit>;
 
-    fn run(rsc: &mut Rsc, container: WeakWidget<W>, id: Self::Input) {
-        rsc.register_event(container, CursorSense::click_or_drag(), move |ctx, rsc| {
-            let region = ctx.data.render.window_region(&id).unwrap();
+    fn run(state: &mut State, container: WidgetRef<W>, id: Self::Input) {
+        state.register_event(container, CursorSense::click_or_drag(), move |ctx| {
+            let region = ctx.ui().window_region(&id).unwrap();
             let id_pos = region.top_left;
-            let container_pos = ctx.data.render.window_region(&container).unwrap().top_left;
-            // The pointer arrives from the platform in floats; everything
-            // it is compared against is on the grid.
-            let pos = (PxVec2::from_f32(ctx.data.pos) + container_pos - id_pos).to_f32();
-            let size = region.size().to_f32();
-            select(
-                rsc,
-                ctx.data.render,
-                ctx.state,
-                id,
-                pos,
-                size,
-                ctx.data.sense.is_dragging(),
-            );
+            let container_pos = ctx.state.ui().window_region(&container).unwrap().top_left;
+            let pos = ctx.data.pos + container_pos - id_pos;
+            let size = region.size();
+            select(ctx.state, id, pos, size, ctx.data.sense.is_dragging());
         });
     }
 }
 
 pub struct Selectable;
 
-impl<Rsc: HasEvents> WidgetAttr<Rsc, TextEdit> for Selectable
+impl<State: HasEvents> WidgetAttr<State, TextEdit> for Selectable
 where
-    Rsc::State: HasDefaultUiState,
+    State::State: HasDefaultUiState,
 {
     type Input = ();
 
-    fn run(rsc: &mut Rsc, id: WeakWidget<TextEdit>, _: Self::Input) {
-        rsc.register_event(id, CursorSense::click_or_drag(), move |ctx, rsc| {
+    fn run(state: &mut State, id: WidgetRef<TextEdit>, _: Self::Input) {
+        state.register_event(id, CursorSense::click_or_drag(), move |ctx| {
             select(
-                rsc,
-                ctx.data.render,
                 ctx.state,
                 id,
                 ctx.data.pos,
@@ -56,24 +44,22 @@ where
 }
 
 fn select(
-    rsc: &mut impl UiRsc,
-    render: &UiRenderState,
     state: &mut impl HasDefaultUiState,
-    id: WeakWidget<TextEdit>,
+    id: WidgetRef<TextEdit>,
     pos: Vec2,
     size: Vec2,
     dragging: bool,
 ) {
-    let state = state.default_state_mut();
+    let (ui, state) = HasDefaultUiState::ui_with_state(state);
     let now = Instant::now();
     let recent = (now - state.last_click) < Duration::from_millis(300);
     state.last_click = now;
-    id.edit(rsc).select(pos, size, dragging, recent);
-    if let Some(region) = render.window_region(&id) {
+    id.edit(ui).select(pos, size, dragging, recent);
+    if let Some(region) = ui.window_region(&id) {
         state.window.set_ime_allowed(true);
         state.window.set_ime_cursor_area(
-            LogicalPosition::<f32>::from(region.top_left.to_f32().tuple()),
-            LogicalSize::<f32>::from(region.size().to_f32().tuple()),
+            LogicalPosition::<f32>::from(region.top_left.tuple()),
+            LogicalSize::<f32>::from(region.size().tuple()),
         );
     }
     state.focus = Some(id);

src/default/mod.rs

@@ -1,6 +1,7 @@
 use crate::prelude::*;
 use arboard::Clipboard;
-use std::{marker::PhantomData, sync::Arc, time::Instant};
+use iris_core::util::forget_mut;
+use std::{marker::Sized, sync::Arc, time::Instant};
 use winit::{
     event::{Ime, WindowEvent},
     event_loop::{ActiveEventLoop, EventLoopProxy},
@@ -13,8 +14,6 @@ mod event;
 mod input;
 mod render;
 mod sense;
-mod state;
-mod task;
 
 pub use app::*;
 pub use attr::*;
@@ -22,61 +21,23 @@ pub use event::*;
 pub use input::*;
 pub use render::*;
 pub use sense::*;
-pub use state::*;
-pub use task::*;
 
-/// Sends an application's own events to its event loop. It wraps the proxy
-/// rather than being one because task updates travel the same way: what an
-/// application sends is its `Event`, not the loop's whole message type.
-pub struct Proxy<State: DefaultAppState>(EventLoopProxy<DefaultEvent<State>>);
-
-impl<State: DefaultAppState> Clone for Proxy<State> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<State: DefaultAppState> Proxy<State> {
-    pub fn send_event(&self, event: State::Event) {
-        let _ = self.0.send_event(DefaultEvent::User(event));
-    }
-}
-
-/// What the event loop carries: the application's own events, and the
-/// updates tasks send back to the ui thread.
-pub enum DefaultEvent<State: DefaultAppState> {
-    User(State::Event),
-    Update(Box<dyn TaskUpdate<DefaultRsc<State>>>),
-}
-
-impl<State: DefaultAppState> TaskQueue<DefaultRsc<State>> for Proxy<State> {
-    fn send(&self, update: Box<dyn TaskUpdate<DefaultRsc<State>>>) {
-        let _ = self.0.send_event(DefaultEvent::Update(update));
-    }
-}
+pub type Proxy<Event> = EventLoopProxy<Event>;
 
 pub struct DefaultUiState {
-    pub root: Option<StrongWidget>,
     pub renderer: UiRenderer,
     pub input: Input,
-    pub focus: Option<WeakWidget<TextEdit>>,
+    pub focus: Option<WidgetRef<TextEdit>>,
     pub clipboard: Clipboard,
     pub window: Arc<Window>,
     pub ime: usize,
     pub last_click: Instant,
 }
 
-impl HasRoot for DefaultUiState {
-    fn set_root(&mut self, root: StrongWidget) {
-        self.root = Some(root);
-    }
-}
-
 impl DefaultUiState {
     pub fn new(window: impl Into<Arc<Window>>) -> Self {
         let window = window.into();
         Self {
-            root: None,
             renderer: UiRenderer::new(window.clone()),
             window,
             input: Input::default(),
@@ -88,146 +49,53 @@ impl DefaultUiState {
     }
 }
 
-pub trait HasDefaultUiState: Sized + 'static {
-    fn default_state(&self) -> &DefaultUiState;
-    fn default_state_mut(&mut self) -> &mut DefaultUiState;
+pub trait HasDefaultUiState: Sized + 'static + HasUi {
+    fn get(&self) -> &DefaultUiState;
+    fn get_mut(&mut self) -> &mut DefaultUiState;
+    fn ui_state(&self) -> &DefaultUiState {
+        HasDefaultUiState::get(self)
+    }
+    fn ui_state_mut(&mut self) -> &mut DefaultUiState {
+        HasDefaultUiState::get_mut(self)
+    }
+    fn ui_with_state(&mut self) -> (&mut Ui, &mut DefaultUiState) {
+        // as long as you're not doing anything actually unhinged this should always work safely
+        (
+            unsafe { forget_mut(self.ui_mut()) },
+            HasDefaultUiState::get_mut(self),
+        )
+    }
 }
 
-pub trait DefaultAppState: HasDefaultUiState {
-    type Event: Send = ();
-    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self>) -> Self;
+pub trait DefaultAppState: RunEvents + HasDefaultUiState {
+    type Event: 'static = ();
+    fn new(ui_state: DefaultUiState, proxy: Proxy<Self::Event>) -> Self;
     #[allow(unused_variables)]
-    fn event(
-        &mut self,
-        event: Self::Event,
-        rsc: &mut DefaultRsc<Self>,
-        render: &mut UiRenderState,
-    ) {
-    }
+    fn event(&mut self, event: Self::Event) {}
     #[allow(unused_variables)]
-    fn exit(&mut self, rsc: &mut DefaultRsc<Self>, render: &mut UiRenderState) {}
+    fn exit(&mut self) {}
     #[allow(unused_variables)]
-    fn window_event(
-        &mut self,
-        event: WindowEvent,
-        rsc: &mut DefaultRsc<Self>,
-        render: &mut UiRenderState,
-    ) {
-    }
+    fn window_event(&mut self, event: WindowEvent) {}
     fn window_attributes() -> WindowAttributes {
         Default::default()
     }
 }
 
-pub struct DefaultRsc<State: 'static> {
-    pub ui: UiData,
-    pub events: EventManager<Self>,
-    pub tasks: Tasks<Self>,
-    pub state: WidgetState,
-    _state: PhantomData<State>,
-}
-
-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> {
-        self.state.add(id.id(), data)
-    }
-}
-
-impl<State> UiRsc for DefaultRsc<State> {
-    fn ui(&self) -> &UiData {
-        &self.ui
-    }
-
-    fn ui_mut(&mut self) -> &mut UiData {
-        &mut self.ui
-    }
-
-    fn on_draw(&mut self, active: &ActiveData) {
-        self.events.draw(active);
-    }
-
-    fn on_undraw(&mut self, active: &ActiveData) {
-        self.events.undraw(active);
-    }
-
-    fn on_remove(&mut self, id: WidgetId) {
-        self.events.remove(id);
-        self.state.remove(id);
-    }
-}
-
-impl<State: 'static> HasState for DefaultRsc<State> {
-    type State = State;
-}
-
-impl<State: 'static> HasEvents for DefaultRsc<State> {
-    fn events(&self) -> &EventManager<Self> {
-        &self.events
-    }
-
-    fn events_mut(&mut self) -> &mut EventManager<Self> {
-        &mut self.events
-    }
-}
-
-impl<State: 'static> HasTasks for DefaultRsc<State> {
-    fn tasks_mut(&mut self) -> &mut Tasks<Self> {
-        &mut self.tasks
-    }
-}
-
-impl<State: 'static> HasWidgetState for DefaultRsc<State> {
-    fn widget_state(&self) -> &WidgetState {
-        &self.state
-    }
-
-    fn widget_state_mut(&mut self) -> &mut WidgetState {
-        &mut self.state
-    }
-}
-
-pub struct DefaultApp<State: DefaultAppState> {
-    rsc: DefaultRsc<State>,
-    render: UiRenderState,
-    state: State,
-}
-
-impl<State: DefaultAppState> AppState for DefaultApp<State> {
-    type Event = DefaultEvent<State>;
+impl<State: DefaultAppState> AppState for State {
+    type Event = State::Event;
 
     fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
-        let window = event_loop
-            .create_window(State::window_attributes())
-            .unwrap();
-        let default_state = DefaultUiState::new(window);
-        let mut rsc = DefaultRsc::init(Arc::new(Proxy(proxy.clone())));
-        let state = State::new(default_state, &mut rsc, Proxy(proxy));
-        let render = UiRenderState::new();
-        Self { rsc, state, render }
+        let window = event_loop.create_window(Self::window_attributes()).unwrap();
+        Self::new(DefaultUiState::new(window), proxy)
     }
 
     fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
-        match event {
-            DefaultEvent::User(event) => self.state.event(event, &mut self.rsc, &mut self.render),
-            DefaultEvent::Update(update) => update(&mut self.state, &mut self.rsc),
-        }
-        self.request_redraw_if_needed();
+        self.event(event);
     }
 
     fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
-        let Self { rsc, render, state } = self;
-
-        let ui_state = state.default_state_mut();
+        let events = unsafe { forget_mut(self.events_mut()) };
+        let ui_state = HasDefaultUiState::get_mut(self);
         let input_changed = ui_state.input.event(&event);
         let cursor_state = ui_state.cursor_state().clone();
         let old = ui_state.focus;
@@ -235,43 +103,44 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
             ui_state.focus = None;
         }
         if input_changed {
-            render.run_sensors(rsc, state, cursor_state);
+            let window_size = ui_state.window_size();
+            self.run_sensors(&cursor_state, window_size);
         }
-        let ui_state = state.default_state_mut();
+        let (mut ui, mut ui_state) = self.ui_with_state();
         if old != ui_state.focus
             && let Some(old) = old
         {
-            old.edit(rsc).deselect();
+            old.edit(ui).deselect();
         }
         match &event {
             WindowEvent::CloseRequested => event_loop.exit(),
             WindowEvent::RedrawRequested => {
-                render.update(&ui_state.root, rsc);
-                ui_state.renderer.update(&mut rsc.ui, render);
+                ui.update(events);
+                ui_state.renderer.update(ui);
                 ui_state.renderer.draw();
             }
             WindowEvent::Resized(size) => {
-                render.resize((size.width, size.height), rsc.widgets_mut());
+                ui.resize((size.width, size.height));
                 ui_state.renderer.resize(size)
             }
             WindowEvent::KeyboardInput { event, .. } => {
                 if let Some(sel) = ui_state.focus
                     && event.state.is_pressed()
                 {
-                    let mut text = sel.edit(rsc);
+                    let mut text = sel.edit(ui);
                     match text.apply_event(event, &ui_state.input.modifiers) {
                         TextInputResult::Unfocus => {
                             ui_state.focus = None;
                             ui_state.window.set_ime_allowed(false);
                         }
                         TextInputResult::Submit => {
-                            rsc.run_event::<Submit>(sel, (), state);
+                            self.run_event::<Submit>(sel, &mut ());
                         }
                         TextInputResult::Paste => {
                             if let Ok(t) = ui_state.clipboard.get_text() {
                                 text.insert(&t);
                             }
-                            rsc.run_event::<Edited>(sel, (), state);
+                            self.run_event::<Edited>(sel, &mut ());
                         }
                         TextInputResult::Copy(text) => {
                             if let Err(err) = ui_state.clipboard.set_text(text) {
@@ -279,7 +148,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
                             }
                         }
                         TextInputResult::Used => {
-                            rsc.run_event::<Edited>(sel, (), state);
+                            self.run_event::<Edited>(sel, &mut ());
                         }
                         TextInputResult::Unused => {}
                     }
@@ -287,7 +156,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
             }
             WindowEvent::Ime(ime) => {
                 if let Some(sel) = ui_state.focus {
-                    let mut text = sel.edit(rsc);
+                    let mut text = sel.edit(ui);
                     match ime {
                         Ime::Enabled | Ime::Disabled => (),
                         Ime::Preedit(content, _pos) => {
@@ -303,65 +172,15 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
             }
             _ => (),
         }
-        state.window_event(event, rsc, render);
-        self.request_redraw_if_needed();
-        self.state.default_state_mut().input.end_frame();
+        self.window_event(event);
+        (ui, ui_state) = self.ui_with_state();
+        if ui.needs_redraw() {
+            ui_state.renderer.window().request_redraw();
+        }
+        ui_state.input.end_frame();
     }
 
     fn exit(&mut self) {
-        self.state.exit(&mut self.rsc, &mut self.render);
-    }
-}
-
-impl<State: DefaultAppState> DefaultApp<State> {
-    fn request_redraw_if_needed(&mut self) {
-        let ui_state = self.state.default_state_mut();
-        if self.render.needs_redraw(&ui_state.root, self.rsc.widgets()) {
-            ui_state.renderer.window().request_redraw();
-        }
-    }
-}
-
-pub trait RscIdx<Rsc> {
-    type Output;
-    fn get(self, rsc: &Rsc) -> &Self::Output;
-    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output;
-}
-
-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 {
-        index.get(self)
-    }
-}
-
-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)
-    }
-}
-
-impl<W: Widget, Rsc: UiRsc> RscIdx<Rsc> for WeakWidget<W> {
-    type Output = W;
-
-    fn get(self, rsc: &Rsc) -> &Self::Output {
-        &rsc.ui().widgets[self]
-    }
-
-    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
-        &mut rsc.ui_mut().widgets[self]
-    }
-}
-
-impl<T: 'static, Rsc: HasWidgetState> RscIdx<Rsc> for WeakState<T> {
-    type Output = T;
-
-    fn get(self, rsc: &Rsc) -> &Self::Output {
-        rsc.widget_state().get(self)
-    }
-
-    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
-        rsc.widget_state_mut().get_mut(self)
+        self.exit();
     }
 }

src/default/render.rs

@@ -1,7 +1,7 @@
-use iris_core::{UiData, UiRenderNode, UiRenderState};
+use iris_core::{Ui, UiLimits, UiRenderNode};
 use pollster::FutureExt;
 use std::sync::Arc;
-use wgpu::*;
+use wgpu::{util::StagingBelt, *};
 use winit::{dpi::PhysicalSize, window::Window};
 
 pub const CLEAR_COLOR: Color = Color::BLACK;
@@ -13,29 +13,17 @@ pub struct UiRenderer {
     queue: Queue,
     config: SurfaceConfiguration,
     encoder: CommandEncoder,
+    staging_belt: StagingBelt,
     pub ui: UiRenderNode,
 }
 
 impl UiRenderer {
-    pub fn update(&mut self, ui: &mut UiData, render: &mut UiRenderState) {
-        self.ui.update(&self.device, &self.queue, ui, render);
+    pub fn update(&mut self, ui: &mut Ui) {
+        self.ui.update(&self.device, &self.queue, ui);
     }
 
     pub fn draw(&mut self) {
-        let output = match self.surface.get_current_texture() {
-            CurrentSurfaceTexture::Success(texture) => texture,
-            CurrentSurfaceTexture::Suboptimal(texture) => {
-                self.surface.configure(&self.device, &self.config);
-                texture
-            }
-            CurrentSurfaceTexture::Outdated | CurrentSurfaceTexture::Lost => {
-                self.surface.configure(&self.device, &self.config);
-                return;
-            }
-            CurrentSurfaceTexture::Timeout
-            | CurrentSurfaceTexture::Occluded
-            | CurrentSurfaceTexture::Validation => return,
-        };
+        let output = self.surface.get_current_texture().unwrap();
         let view = output
             .texture
             .create_view(&TextureViewDescriptor::default());
@@ -58,15 +46,16 @@ impl UiRenderer {
         }
 
         self.queue.submit(std::iter::once(encoder.finish()));
-        self.window.pre_present_notify();
-        self.queue.present(output);
+        self.staging_belt.finish();
+        output.present();
+        self.staging_belt.recall();
     }
 
     pub fn resize(&mut self, size: &PhysicalSize<u32>) {
         self.config.width = size.width;
         self.config.height = size.height;
         self.surface.configure(&self.device, &self.config);
-        self.ui.resize((size.width, size.height), &self.queue);
+        self.ui.resize(size, &self.queue);
     }
 
     fn create_encoder(device: &Device) -> CommandEncoder {
@@ -78,10 +67,9 @@ impl UiRenderer {
     pub fn new(window: Arc<Window>) -> Self {
         let size = window.inner_size();
 
-        let instance = Instance::new(InstanceDescriptor {
+        let instance = Instance::new(&InstanceDescriptor {
             backends: Backends::PRIMARY,
-            display: Some(Box::new(window.clone())),
-            ..InstanceDescriptor::new_without_display_handle()
+            ..Default::default()
         });
 
         let surface = instance
@@ -93,14 +81,22 @@ impl UiRenderer {
                 power_preference: PowerPreference::default(),
                 compatible_surface: Some(&surface),
                 force_fallback_adapter: false,
-                apply_limit_buckets: false,
             })
             .block_on()
             .expect("Could not get adapter!");
 
+        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()
                 },
@@ -120,10 +116,9 @@ impl UiRenderer {
         let config = SurfaceConfiguration {
             usage: TextureUsages::RENDER_ATTACHMENT,
             format: surface_format,
-            color_space: SurfaceColorSpace::Auto,
             width: size.width,
             height: size.height,
-            present_mode: PresentMode::AutoVsync,
+            present_mode: PresentMode::AutoNoVsync,
             alpha_mode: surface_caps.alpha_modes[0],
             desired_maximum_frame_latency: 2,
             view_formats: vec![],
@@ -131,9 +126,10 @@ impl UiRenderer {
 
         surface.configure(&device, &config);
 
+        let staging_belt = StagingBelt::new(4096 * 4);
         let encoder = Self::create_encoder(&device);
 
-        let ui = UiRenderNode::new(&device, &config);
+        let shape_pipeline = UiRenderNode::new(&device, &queue, &config, ui_limits);
 
         Self {
             surface,
@@ -141,7 +137,8 @@ impl UiRenderer {
             queue,
             config,
             encoder,
-            ui,
+            staging_belt,
+            ui: shape_pipeline,
             window,
         }
     }

src/default/sense.rs

@@ -4,14 +4,14 @@ use std::{
     rc::Rc,
 };
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq)]
 pub enum CursorButton {
     Left,
     Right,
     Middle,
 }
 
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq)]
 pub enum CursorSense {
     PressStart(CursorButton),
     Pressing(CursorButton),
@@ -27,34 +27,15 @@ pub struct CursorSenses(Vec<CursorSense>);
 
 impl Event for CursorSenses {
     type Data<'a> = CursorData<'a>;
-    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();
+    type State = SensorState;
+    fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
+        if let Some(sense) = should_run(self, data.cursor, data.hover) {
             data.sense = sense;
-            Some(data)
+            true
         } else {
-            None
+            false
         }
     }
-
-    /// A press or a scroll is used up by whatever answered it, so it stops
-    /// there. Hovering is not: a cursor resting somewhere goes on resting.
-    fn consumes(&self, data: &Self::Data<'_>) -> bool {
-        !data.sense.position_only()
-    }
-}
-
-/// Who the cursor was inside, before and after an input. The difference is
-/// whose hover has ended -- including a widget a higher layer has covered,
-/// which the walk stops before reaching.
-///
-/// Two buffers that swap rather than one rebuilt, so an input allocates
-/// nothing once they have grown.
-#[derive(Default)]
-pub struct Hovered {
-    was: Vec<WidgetId>,
-    now: Vec<WidgetId>,
 }
 
 impl CursorSense {
@@ -70,12 +51,6 @@ impl CursorSense {
     pub fn is_dragging(&self) -> bool {
         matches!(self, CursorSense::Pressing(CursorButton::Left))
     }
-
-    /// False if the sense is a button or a scroll, true if it is only about
-    /// where the cursor is.
-    fn position_only(&self) -> bool {
-        matches!(self, Self::HoverStart | Self::Hovering | Self::HoverEnd)
-    }
 }
 
 #[derive(Default, Clone)]
@@ -120,12 +95,6 @@ impl CursorButtons {
 }
 
 impl CursorState {
-    /// True if the cursor is only reporting where it is: no button and no
-    /// scroll this frame.
-    pub fn position_only(&self) -> bool {
-        self.scroll_delta == Vec2::ZERO && self.buttons.iter().all(|(_, state)| state.is_off())
-    }
-
     pub fn end_frame(&mut self) {
         self.buttons.end_frame();
         self.scroll_delta = Vec2::ZERO;
@@ -146,133 +115,76 @@ pub enum ActivationState {
 /// or basically have some way to have custom senses
 /// that depend on active widget positions
 /// but I'm not sure how or if worth it
-pub struct Sensor<Ctx: HasEvents, Data> {
+pub struct Sensor<Ctx, Data> {
     pub senses: CursorSenses,
     pub f: Rc<dyn EventFn<Ctx, Data>>,
 }
 
 pub type SenseShape = UiRegion;
 
-#[derive(Clone)]
+#[derive(Default, Debug)]
+pub struct SensorState {
+    pub hover: ActivationState,
+}
+
 pub struct CursorData<'a> {
     /// where this widget was hit
     pub pos: Vec2,
     pub size: Vec2,
     pub scroll_delta: Vec2,
     pub hover: ActivationState,
-    pub cursor: CursorState,
+    pub cursor: &'a CursorState,
     /// the first sense that triggered this
     pub sense: CursorSense,
-    pub render: &'a UiRenderState,
 }
 
-pub trait SensorUi {
-    fn run_sensors<Rsc: HasEvents>(
-        &self,
-        rsc: &mut Rsc,
-        state: &mut Rsc::State,
-        cursor: CursorState,
-    );
+pub trait SensorUi<State> {
+    fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2);
 }
 
-impl SensorUi for UiRenderState {
-    fn run_sensors<Rsc: HasEvents>(
-        &self,
-        rsc: &mut Rsc,
-        state: &mut Rsc::State,
-        cursor: CursorState,
-    ) {
-        // in order to remove this take, need to store active list in UiRenderState somehow
-        // this would probably be done through a generic parameter that adds yet another rsc /
-        // state like thing, but local to render state, and is passed to UiRsc events so you can
-        // update it there?
-        let active = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().active);
-        let mut hovered = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().global);
-        hovered.now.clear();
-        let position_only = cursor.position_only();
-        let region_of = |id| self.window_region(&id);
-
-        for layer in self.layers.indices().rev() {
-            let mut consumed = false;
-            for id in active.get(&layer).into_flat_iter().map(|(id, _)| *id) {
-                let Some(region) = region_of(id) else {
-                    continue;
-                };
-                if !cursor.exists || !region.contains(PxVec2::from_f32(cursor.pos)) {
+impl<State: RunEvents> SensorUi<State> for State {
+    fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2) {
+        let layers = std::mem::take(&mut self.ui_mut().layers);
+        let mut active = std::mem::take(&mut self.events_mut().get_type::<CursorSense>().active);
+        for layer in layers.indices().rev() {
+            let mut sensed = false;
+            for (id, sensor) in active.get_mut(&layer).into_flat_iter() {
+                let shape = self.ui().active.get(id).unwrap().region;
+                let region = shape.to_px(window_size);
+                let in_shape = cursor.exists && region.contains(cursor.pos);
+                sensor.hover.update(in_shape);
+                if sensor.hover == ActivationState::Off {
                     continue;
                 }
-                hovered.now.push(id);
-                let hover = match hovered.was.contains(&id) {
-                    true => ActivationState::On,
-                    false => ActivationState::Start,
+                sensed = true;
+
+                let mut 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,
                 };
-                // 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;
+                self.run_event::<CursorSense>(*id, &mut data);
             }
-            // Applied after the layer, never during it: senses on one layer do
-            // not block each other.
-            if consumed {
+            if sensed {
                 break;
             }
         }
-
-        // 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;
+        self.events_mut().get_type::<CursorSense>().active = active;
+        self.ui_mut().layers = layers;
     }
 }
 
-/// 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.to_f32(),
-        size: region.size().to_f32(),
-        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/state.rs

@@ -1,75 +0,0 @@
-use iris_core::{
-    WidgetId,
-    util::{HashMap, HashSet},
-};
-use std::{
-    any::{Any, TypeId},
-    marker::PhantomData,
-};
-
-#[derive(Clone, Copy, PartialEq, Eq, Hash)]
-struct Key {
-    id: WidgetId,
-    ty: TypeId,
-    i: usize,
-}
-
-#[derive(Default)]
-pub struct WidgetState {
-    widgets: HashMap<WidgetId, HashSet<(TypeId, usize)>>,
-    counts: HashMap<(WidgetId, TypeId), usize>,
-    map: HashMap<Key, Box<dyn Any>>,
-}
-
-impl WidgetState {
-    pub fn new() -> Self {
-        Self::default()
-    }
-    pub fn add<T: 'static>(&mut self, id: WidgetId, data: T) -> WeakState<T> {
-        let ty = TypeId::of::<T>();
-        let count = self.counts.entry((id, ty)).or_default();
-        let i = *count;
-        let key = Key { ty, i, id };
-        self.map.insert(key, Box::new(data));
-        self.widgets.entry(id).or_default().insert((ty, i));
-        *count += 1;
-        WeakState {
-            key,
-            _pd: PhantomData,
-        }
-    }
-    pub fn remove(&mut self, id: WidgetId) {
-        for &(ty, i) in self.widgets.get(&id).into_iter().flatten() {
-            self.map.remove(&Key { id, ty, i });
-        }
-    }
-    pub fn get<T: 'static>(&self, state: WeakState<T>) -> &T {
-        self.map.get(&state.key).unwrap().downcast_ref().unwrap()
-    }
-    pub fn get_mut<T: 'static>(&mut self, state: WeakState<T>) -> &mut T {
-        self.map
-            .get_mut(&state.key)
-            .unwrap()
-            .downcast_mut()
-            .unwrap()
-    }
-}
-
-#[derive(Clone, Copy)]
-pub struct WeakState<T> {
-    key: Key,
-    _pd: PhantomData<T>,
-}
-
-pub trait HasWidgetState {
-    fn widget_state(&self) -> &WidgetState;
-    fn widget_state_mut(&mut self) -> &mut WidgetState;
-}
-
-impl<'a, T: 'static> FnOnce<(&'a mut WidgetState,)> for WeakState<T> {
-    type Output = &'a mut T;
-
-    extern "rust-call" fn call_once(self, (state,): (&'a mut WidgetState,)) -> Self::Output {
-        state.get_mut(self)
-    }
-}

src/default/task.rs

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

src/event.rs

@@ -1,87 +1,25 @@
-use iris_core::*;
-use iris_macro::*;
-use std::sync::Arc;
+use crate::prelude::*;
 
-use crate::default::{TaskCtx, TaskUpdate, Tasks};
-
-pub trait Eventable<Rsc: HasEvents, Tag>: WidgetLike<Rsc, Tag> {
-    fn on<E: EventLike>(
-        self,
-        event: E,
-        f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, Self::Widget>,
-    ) -> impl WidgetIdFn<Rsc, Self::Widget> {
-        move |rsc| {
-            let id = self.add(rsc);
-            rsc.register_event(id, event.into_event(), move |ctx, rsc| {
-                f(
-                    EventIdCtx {
+pub mod eventable {
+    use super::*;
+    widget_trait! {
+        pub trait Eventable<State: HasEvents + StateLike<State> + 'static>;
+        fn on<E: EventLike>(
+            self,
+            event: E,
+            f: impl for<'a> WidgetEventFn<State::State, <E::Event as Event>::Data<'a>, WL::Widget>,
+        ) -> impl WidgetIdFn<State, WL::Widget> {
+            move |state| {
+                let id = self.add(state);
+                state.register_event(id, event.into_event(), move |ctx| {
+                    f(&mut EventIdCtx {
                         widget: id,
                         state: ctx.state,
                         data: ctx.data,
-                    },
-                    rsc,
-                );
-            });
-            id
-        }
-    }
-}
-impl<WL: WidgetLike<Rsc, Tag>, Rsc: HasEvents, Tag> Eventable<Rsc, Tag> for WL {}
-
-widget_trait! {
-    pub trait TaskEventable<Rsc: HasEvents + HasTasks>;
-    fn task_on<'a, E: EventLike, F: AsyncWidgetEventFn<Rsc, WL::Widget>>(
-        self,
-        event: E,
-        f: F,
-    ) -> impl WidgetIdFn<Rsc, WL::Widget>
-        where <E::Event as Event>::Data<'a>: Send,
-        for<'b> F::CallRefFuture<'b>: Send,
-    {
-        let f = Arc::new(f);
-        move |rsc| {
-            let id = self.add(rsc);
-            rsc.register_event(id, event.into_event(), move |_, rsc| {
-                let f = f.clone();
-                rsc.tasks_mut().spawn(async move |task| {
-                    f(AsyncEventIdCtx {
-                        widget: id,
-                        task,
-                    }).await;
+                    });
                 });
-            });
-            id
+                id
+            }
         }
     }
 }
-
-pub trait HasTasks: Sized + HasState + HasEvents {
-    fn tasks_mut(&mut self) -> &mut Tasks<Self>;
-
-    fn spawn_task<F: AsyncFnOnce(TaskCtx<Self>) + 'static + std::marker::Send>(&mut self, task: F)
-    where
-        F::CallOnceFuture: Send,
-    {
-        self.tasks_mut().spawn(task);
-    }
-}
-
-pub trait AsyncWidgetEventFn<Rsc: HasEvents, W: ?Sized>:
-    AsyncFn(AsyncEventIdCtx<Rsc, W>) + Send + Sync + 'static
-{
-}
-impl<Rsc: HasEvents, F: AsyncFn(AsyncEventIdCtx<Rsc, W>) + Send + Sync + 'static, W: ?Sized>
-    AsyncWidgetEventFn<Rsc, W> for F
-{
-}
-
-pub struct AsyncEventIdCtx<Rsc: HasEvents, W: ?Sized> {
-    pub widget: WeakWidget<W>,
-    task: TaskCtx<Rsc>,
-}
-
-impl<Rsc: HasEvents, W: ?Sized> AsyncEventIdCtx<Rsc, W> {
-    pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
-        self.task.update(f);
-    }
-}

src/harness.rs

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

src/lib.rs

@@ -1,19 +1,31 @@
 #![feature(unboxed_closures)]
 #![feature(fn_traits)]
+#![feature(gen_blocks)]
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(option_into_flat_iter)]
-#![feature(async_fn_traits)]
 
 pub mod default;
 pub mod event;
-pub mod harness;
-pub mod random;
+pub mod typed;
 pub mod widget;
 
 pub use iris_core as core;
 pub use iris_macro as macros;
 
+#[macro_export]
+macro_rules! state_prelude {
+    ($vis:vis $state:ty) => {
+        iris::event_state!($vis $state);
+        $vis use iris::{
+            default::*,
+            core::{len_fns::*, util::Vec2, *},
+            macros::*,
+            widget::*,
+        };
+    };
+}
+
 pub mod prelude {
     use super::*;
     pub use default::*;
@@ -23,5 +35,5 @@ pub mod prelude {
     pub use widget::*;
 
     pub use iris_core::util::Vec2;
-    pub use len_fns::*;
+    pub use typed::*;
 }

src/random.rs

@@ -1,915 +0,0 @@
-//! A seeded random widget tree, for tests and for looking at.
-//!
-//! One seed is one tree, on any machine and after any upgrade, so a test can
-//! grow the same tree twice and a failing seed is reproduced by its number.
-//! `examples/random.rs` draws one; `tests/generated.rs` checks that laying one
-//! out again lands where growing it from scratch would.
-
-use crate::prelude::*;
-use std::collections::HashMap;
-
-/// The declared lengths of one widget carrying a size rule, by axis.
-pub type Lens = [Option<LayoutLen>; 2];
-
-/// Where one widget carrying an alignment sits, by axis. `None` uses the
-/// centered default.
-pub type Aligns = [Option<AxisAlign>; 2];
-
-/// What a test changes between two trees grown from the same seed, so the
-/// warm one can be mutated and the cold one grown that way to begin with.
-#[derive(Default)]
-pub struct Edits {
-    /// Declared sizes, by the order the rules were put on.
-    pub sizes: HashMap<usize, Lens>,
-    /// Which children a span has, by the order the spans were made.
-    pub spans: HashMap<usize, SpanEdit>,
-    /// Alignments, by the order they were put on.
-    pub aligns: HashMap<usize, Aligns>,
-    /// Which widgets own a movable region, by the order they were offered
-    /// one. Region nodes change what a move writes and how deep a primitive's
-    /// chain is, so a tree that never grows one leaves both untested.
-    pub nodes: HashMap<usize, bool>,
-    /// Whether a [`Branch`] takes the side it would take at any measurement,
-    /// rather than the side the one it made says. The oracle wants the
-    /// measured side -- that is the whole point of a branch, and how a widget
-    /// believing a measurement a cold start would not have given it becomes a
-    /// different tree. A rig measuring cost wants this instead: a fixture
-    /// whose shape moves with the thing being measured cannot be compared
-    /// with itself across a change to it, and seed 1 at depth 8 went from 88
-    /// drawn widgets and 2,298 primitive writes a frame to 115 and 8,209
-    /// across fixed point, which is three and a half times the work behind a
-    /// number read as three and a half times the cost.
-    pub fixed_branches: bool,
-}
-
-#[derive(Default, Clone)]
-pub struct SpanEdit {
-    /// Children to leave out, by index among the ones grown.
-    pub detach: Vec<usize>,
-    /// How many of the span's spares are in it, appended in order.
-    pub attach: usize,
-}
-
-/// xorshift64, written out rather than taken from a crate so that a seed
-/// keeps meaning the same tree.
-pub struct Rng(u64);
-
-impl Rng {
-    pub fn new(seed: u64) -> Self {
-        Self(seed | 1)
-    }
-
-    pub fn bits(&mut self) -> u64 {
-        self.0 ^= self.0 << 13;
-        self.0 ^= self.0 >> 7;
-        self.0 ^= self.0 << 17;
-        self.0
-    }
-
-    pub fn below(&mut self, n: usize) -> usize {
-        (self.bits() % n as u64) as usize
-    }
-
-    pub fn chance(&mut self) -> bool {
-        self.bits() & 1 == 0
-    }
-}
-
-const COLORS: [UiColor; 6] = [
-    UiColor::RED,
-    UiColor::GREEN,
-    UiColor::BLUE,
-    UiColor::YELLOW,
-    UiColor::CYAN,
-    UiColor::MAGENTA,
-];
-
-/// Leaves grown beside every span, for a test to put into it.
-const SPARES: usize = 3;
-
-const WORDS: &str = "Wrapping shapes one source into as many lines as the box \
-    leaves room for, so a paragraph's height is an answer and not a setting.";
-
-/// What growing a tree gives back: every widget in creation order, so two
-/// trees from one seed line up index for index, and the declared sizes, which
-/// are what a test changes to watch the change propagate.
-#[derive(Default)]
-pub struct Tree {
-    pub ids: Vec<WidgetId>,
-    pub sized: Vec<WidgetId>,
-    pub aligned: Vec<WidgetId>,
-    pub nodes: Vec<WidgetId>,
-    pub spans: Vec<Spanned>,
-    pub scrolls: Vec<WeakWidget<Scroll>>,
-}
-
-/// Branches on a child's measured length. Comparing boxes catches a widget
-/// that moved; this catches one that believed a measurement a cold start
-/// would not have given it, by turning that into a different tree. Its own
-/// configuration never changes, so which side draws is a property of the
-/// layout alone.
-pub struct Branch {
-    pub probe: StrongWidget,
-    pub wide: StrongWidget,
-    pub narrow: StrongWidget,
-    pub threshold: f32,
-}
-
-impl Widget for Branch {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let mut top = UiRegion::FULL;
-        top.y.end = top.y.start.offset(Px::from_int(40));
-        let measured = painter.widget_within(&self.probe, top).len(Axis::X);
-        let px = measured.apply_leftover().to_px(painter.px_len(Axis::X));
-
-        let mut below = UiRegion::FULL;
-        below.y.start = below.y.start.offset(Px::from_int(40));
-        match px > Px::from_f32(self.threshold) {
-            true => painter.widget_within(&self.wide, below),
-            false => painter.widget_within(&self.narrow, below),
-        };
-        Size::LEFTOVER
-    }
-}
-
-pub struct Spanned {
-    pub id: WeakWidget<Span>,
-    /// Everything made for this span that it does not hold -- spares never
-    /// attached and children detached alike. A widget belongs to one parent,
-    /// and one that belongs to nobody still has to be held here: dropping
-    /// the last share of it frees its id for the next widget to be given,
-    /// which puts two trees out of step.
-    pub spares: Vec<StrongWidget>,
-    /// How many children it was grown with, before any edit.
-    pub grown: usize,
-}
-
-/// A tree described rather than built: [`plan`] turns a seed into one of
-/// these and [`build`] turns it into widgets, where growing did both at once.
-///
-/// The split is what makes a counterexample readable. A failing seed used to
-/// be the entire record of one, because a grower that makes widgets as it
-/// draws leaves nothing to take apart -- a shrinker could only grow its own
-/// trees and hope to meet the same shape, which in practice it does not. A
-/// plan is reduced by [`Plan::smaller`] and built again, so any seed that
-/// fails can be cut down until what is left is small enough to read.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Plan {
-    pub kind: Kind,
-    /// The declared size this widget carries. Whoever grows a widget offers
-    /// it one and the offer is taken or declined; a second offer to the same
-    /// widget is dropped, because two rules on one widget would settle in the
-    /// order they were applied rather than in grow order.
-    pub size: Option<Lens>,
-    /// The alignment it carries, under the same one-offer rule.
-    pub align: Option<Aligns>,
-    /// Whether it was offered a movable region of its own and what it
-    /// answered. `Some(false)` is an offer declined, which still uses up the
-    /// one offer, where `None` is an offer never made.
-    pub region_node: Option<bool>,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum Kind {
-    /// Wrapped and unwrapped text, because only one of them reads the width
-    /// it is given and so only one has to be drawn again for a new one.
-    Wrapped,
-    OneLine,
-    Rect {
-        color: usize,
-        alpha: u8,
-    },
-    /// Scrolling reads the pixel length of its box, which nothing else here
-    /// does, and gives its child a box longer than its own.
-    Scroll {
-        axis: Axis,
-        inner: Box<Plan>,
-    },
-    /// All three sides are grown either way, so a tree that draws one has the
-    /// same ids as a tree that draws another.
-    Branch {
-        probe: Box<Plan>,
-        wide: Box<Plan>,
-        narrow: Box<Plan>,
-        threshold: f32,
-    },
-    /// Each side its own, since a padding that is the same all round hides
-    /// anything that treats one edge differently from another.
-    Pad {
-        padding: [i32; 4],
-        inner: Box<Plan>,
-    },
-    Stack {
-        children: Vec<Plan>,
-    },
-    Span {
-        dir: usize,
-        gap: i32,
-        /// Grown for this span, in the order they are made.
-        children: Vec<Plan>,
-        /// Grown beside it whether or not they end up in it, so the widget
-        /// after them has the same id in a tree that leaves them out as in
-        /// one that puts them in.
-        spares: Vec<Plan>,
-        /// Which of `children` then `spares` are actually in the span, and
-        /// in what order -- kept apart from the two lists above so that a
-        /// tree which detaches, attaches or reorders its children still
-        /// makes the same widgets in the same order, and two builds line up
-        /// index for index. Anything not named here is built and held
-        /// rather than dropped, since freeing an id hands it to the next
-        /// widget and puts two trees out of step.
-        order: Vec<usize>,
-    },
-}
-
-impl Plan {
-    /// A widget carrying nothing anybody has offered it yet.
-    fn bare(kind: Kind) -> Self {
-        Self {
-            kind,
-            size: None,
-            align: None,
-            region_node: None,
-        }
-    }
-
-    /// How many widgets building it makes, spares and detached children
-    /// included, since those are made either way.
-    pub fn size(&self) -> usize {
-        1 + match &self.kind {
-            Kind::Scroll { inner, .. } | Kind::Pad { inner, .. } => inner.size(),
-            Kind::Branch {
-                probe,
-                wide,
-                narrow,
-                ..
-            } => probe.size() + wide.size() + narrow.size(),
-            Kind::Stack { children } => children.iter().map(Plan::size).sum(),
-            Kind::Span {
-                children, spares, ..
-            } => children.iter().chain(spares).map(Plan::size).sum(),
-            _ => 0,
-        }
-    }
-
-    /// The trees to try instead of this one when reducing a counterexample,
-    /// biggest cut first: a shrinker takes the first that still fails, so
-    /// offering "this subtree alone" before "this subtree with one child
-    /// fewer" is what gets from six hundred widgets to six rather than to
-    /// five hundred and ninety.
-    ///
-    /// Every one of these is a tree the generator could have grown, so a
-    /// reduced plan is a counterexample in its own right rather than a
-    /// special case only the shrinker can make.
-    pub fn smaller(&self) -> Vec<Plan> {
-        let mut out = Vec::new();
-        // Standing in for the whole of it, which is the largest cut there is.
-        for kid in self.kids() {
-            out.push(kid.clone());
-        }
-        // Then what it carries, which costs nothing to put back if it was
-        // not the thing that mattered.
-        for dropped in [
-            self.region_node.map(|_| Plan {
-                region_node: None,
-                ..self.clone()
-            }),
-            self.align.map(|_| Plan {
-                align: None,
-                ..self.clone()
-            }),
-            self.size.map(|_| Plan {
-                size: None,
-                ..self.clone()
-            }),
-        ]
-        .into_iter()
-        .flatten()
-        {
-            out.push(dropped);
-        }
-        out.extend(self.kind.smaller().into_iter().map(|kind| Plan {
-            kind,
-            ..self.clone()
-        }));
-        out
-    }
-
-    /// Visits every widget in the order [`build`] makes them, so a count
-    /// kept by the visitor indexes the same widget as the matching [`Tree`]
-    /// vector does.
-    pub fn walk_mut(&mut self, at: &mut impl FnMut(&mut Plan)) {
-        match &mut self.kind {
-            Kind::Scroll { inner, .. } | Kind::Pad { inner, .. } => inner.walk_mut(at),
-            Kind::Branch {
-                probe,
-                wide,
-                narrow,
-                ..
-            } => {
-                probe.walk_mut(at);
-                wide.walk_mut(at);
-                narrow.walk_mut(at);
-            }
-            Kind::Stack { children } => {
-                for child in children {
-                    child.walk_mut(at);
-                }
-            }
-            Kind::Span {
-                children, spares, ..
-            } => {
-                for child in children.iter_mut().chain(spares) {
-                    child.walk_mut(at);
-                }
-            }
-            _ => {}
-        }
-        at(self);
-    }
-
-    /// The same tree with `edits` applied, by the indices the generator would
-    /// have used for them.
-    ///
-    /// [`plan`] resolves edits while drawing, which needs a seed. A scenario
-    /// needs them applied to a tree that already exists -- one it has built,
-    /// and one a shrinker may already have cut down, where no seed grows it
-    /// any more. Both routes take the same [`Edits`], so a case written
-    /// against one reads the same against the other.
-    pub fn edited(&self, edits: &Edits) -> Plan {
-        let mut out = self.clone();
-        let (mut sized, mut aligned, mut nodes, mut spans) = (0, 0, 0, 0);
-        out.walk_mut(&mut |plan| {
-            if let Kind::Span {
-                children,
-                spares,
-                order,
-                ..
-            } = &mut plan.kind
-            {
-                if let Some(edit) = edits.spans.get(&spans) {
-                    *order = span_edited(order, children.len(), spares.len(), edit);
-                }
-                spans += 1;
-            }
-            if let Kind::Branch { threshold, .. } = &mut plan.kind
-                && edits.fixed_branches
-            {
-                *threshold = f32::MIN;
-            }
-            if plan.size.is_some() {
-                if let Some(lens) = edits.sizes.get(&sized) {
-                    plan.size = Some(*lens);
-                }
-                sized += 1;
-            }
-            if plan.align.is_some() {
-                if let Some(align) = edits.aligns.get(&aligned) {
-                    plan.align = Some(*align);
-                }
-                aligned += 1;
-            }
-            if plan.region_node.is_some() {
-                if let Some(take) = edits.nodes.get(&nodes) {
-                    plan.region_node = Some(*take);
-                }
-                nodes += 1;
-            }
-        });
-        out
-    }
-
-    fn kids(&self) -> Vec<&Plan> {
-        match &self.kind {
-            Kind::Scroll { inner, .. } | Kind::Pad { inner, .. } => vec![inner],
-            Kind::Branch {
-                probe,
-                wide,
-                narrow,
-                ..
-            } => vec![probe, wide, narrow],
-            Kind::Stack { children } => children.iter().collect(),
-            Kind::Span { children, .. } => children.iter().collect(),
-            _ => Vec::new(),
-        }
-    }
-}
-
-impl Kind {
-    /// Simplifications of the shape alone, leaving what the widget carries to
-    /// [`Plan::smaller`]. Replacing a node with one of its children is there
-    /// rather than here, since it answers with a whole `Plan`.
-    fn smaller(&self) -> Vec<Kind> {
-        let mut out = Vec::new();
-        /// One child reduced at a time, rebuilt into the same shape. Every
-        /// answer has the same number of children as it was given, so it is
-        /// for the shapes whose child count is part of what they are.
-        fn reduced(kids: &[Plan], rebuild: &dyn Fn(Vec<Plan>) -> Kind) -> Vec<Kind> {
-            let mut out = Vec::new();
-            for (i, kid) in kids.iter().enumerate() {
-                for small in kid.smaller() {
-                    let mut next = kids.to_vec();
-                    next[i] = small;
-                    out.push(rebuild(next));
-                }
-            }
-            out
-        }
-
-        /// One child dropped, then [`reduced`]. For the shapes that hold any
-        /// number of children, where dropping one is the cut that matters.
-        fn each(kids: &[Plan], rebuild: &dyn Fn(Vec<Plan>) -> Kind) -> Vec<Kind> {
-            let mut out = Vec::new();
-            for i in 0..kids.len() {
-                if kids.len() > 1 {
-                    let mut less = kids.to_vec();
-                    less.remove(i);
-                    out.push(rebuild(less));
-                }
-            }
-            out.extend(reduced(kids, rebuild));
-            out
-        }
-        match self {
-            // The one leaf that reads the width it is given, then the one
-            // that does not, then the one that measures nothing at all.
-            Kind::Wrapped => out.push(Kind::OneLine),
-            Kind::OneLine => out.push(Kind::Rect {
-                color: 0,
-                alpha: 255,
-            }),
-            Kind::Rect { .. } => {}
-            Kind::Scroll { axis, inner } => {
-                let axis = *axis;
-                out.extend(each(std::slice::from_ref(inner), &|mut k| Kind::Scroll {
-                    axis,
-                    inner: Box::new(k.remove(0)),
-                }));
-            }
-            Kind::Branch {
-                probe,
-                wide,
-                narrow,
-                threshold,
-            } => {
-                let threshold = *threshold;
-                // All three sides stay: a branch is the widget that draws
-                // one of two on a measurement, and one with a side missing
-                // is a different widget rather than a smaller one. Dropping
-                // the branch for a side is offered by `Plan::smaller`.
-                let sides = [(**probe).clone(), (**wide).clone(), (**narrow).clone()];
-                out.extend(reduced(&sides, &|k| Kind::Branch {
-                    probe: Box::new(k[0].clone()),
-                    wide: Box::new(k[1].clone()),
-                    narrow: Box::new(k[2].clone()),
-                    threshold,
-                }));
-            }
-            Kind::Pad { padding, inner } => {
-                let padding = *padding;
-                if padding != [0; 4] {
-                    out.push(Kind::Pad {
-                        padding: [0; 4],
-                        inner: inner.clone(),
-                    });
-                }
-                out.extend(each(std::slice::from_ref(inner), &|mut k| Kind::Pad {
-                    padding,
-                    inner: Box::new(k.remove(0)),
-                }));
-            }
-            Kind::Stack { children } => {
-                out.extend(each(children, &|children| Kind::Stack { children }))
-            }
-            Kind::Span {
-                dir,
-                gap,
-                children,
-                spares,
-                order,
-            } => {
-                let (dir, gap, n) = (*dir, *gap, children.len());
-                let span = |children: Vec<Plan>, spares: Vec<Plan>, order: Vec<usize>| Kind::Span {
-                    dir,
-                    gap,
-                    children,
-                    spares,
-                    order,
-                };
-                let identity: Vec<usize> = (0..n).collect();
-                // An order the generator did not choose is part of the tree,
-                // so take that off before taking the tree apart.
-                if *order != identity {
-                    out.push(span(children.clone(), spares.clone(), identity));
-                }
-                // Spares exist to be attached; with none attached they are
-                // widgets the span never holds.
-                if !spares.is_empty() && order.iter().all(|&i| i < n) {
-                    out.push(span(children.clone(), Vec::new(), order.clone()));
-                }
-                if gap != 0 {
-                    out.push(Kind::Span {
-                        dir,
-                        gap: 0,
-                        children: children.clone(),
-                        spares: spares.clone(),
-                        order: order.clone(),
-                    });
-                }
-                for k in 0..n {
-                    if n > 1 {
-                        let mut less = children.clone();
-                        less.remove(k);
-                        // Everything after it shifts down, spares included,
-                        // since they are indexed past the children.
-                        let order = order
-                            .iter()
-                            .filter(|&&i| i != k)
-                            .map(|&i| if i > k { i - 1 } else { i })
-                            .collect();
-                        out.push(span(less, spares.clone(), order));
-                    }
-                }
-                for (i, kid) in children.iter().enumerate() {
-                    for small in kid.smaller() {
-                        let mut next = children.clone();
-                        next[i] = small;
-                        out.push(span(next, spares.clone(), order.clone()));
-                    }
-                }
-            }
-        }
-        out
-    }
-}
-
-/// A [`SpanEdit`] applied to the order a span already holds its children in.
-///
-/// `detach` names positions in that order and `attach` takes from the front
-/// of what the span is not holding, both of which is what a test changing a
-/// live span does -- so an edit means the same thing said to a tree and said
-/// to the plan it was built from. On a span nobody has edited the order is
-/// the children in the order they were grown, and this is then "leave these
-/// out and put that many spares on the end".
-fn span_edited(order: &[usize], children: usize, spares: usize, edit: &SpanEdit) -> Vec<usize> {
-    let mut detach = edit.detach.clone();
-    detach.sort_unstable();
-    detach.dedup();
-    let mut next: Vec<usize> = order
-        .iter()
-        .enumerate()
-        .filter(|(at, _)| !detach.contains(at))
-        .map(|(_, &which)| which)
-        .collect();
-    // What the span is not holding, in the order it hands them back: what it
-    // was already not holding first, in the order the widgets were made, and
-    // what this edit takes out after that, highest position first. A child
-    // just detached goes to the back rather than straight back in, which is
-    // what makes detaching one and attaching one a trade.
-    let mut free: Vec<usize> = (0..children + spares)
-        .filter(|i| !order.contains(i))
-        .collect();
-    free.extend(detach.iter().rev().filter_map(|&at| order.get(at).copied()));
-    next.extend(free.into_iter().take(edit.attach));
-    next
-}
-
-/// Plans the tree `seed` describes, `edits` replacing what it would otherwise
-/// have given the widgets that carry them.
-///
-/// The edits are resolved here rather than at build time, so that a plan is
-/// the whole of what a tree is and building one has nothing left to decide.
-pub fn plan(seed: u64, depth: usize, edits: &Edits) -> Plan {
-    let mut sow = Sow {
-        rng: Rng::new(seed),
-        edits,
-        sized: 0,
-        aligned: 0,
-        nodes: 0,
-        spans: 0,
-    };
-    sow.node(depth)
-}
-
-/// Grows the tree `seed` describes, `edits` replacing the declared sizes it
-/// would otherwise have given those wrappers.
-pub fn grow<Rsc: UiRsc + 'static>(
-    rsc: &mut Rsc,
-    seed: u64,
-    depth: usize,
-    edits: &Edits,
-) -> (StrongWidget, Tree) {
-    build(rsc, &plan(seed, depth, edits))
-}
-
-/// Draws a plan out of the random stream. Every draw happens in the order it
-/// always has and before the decision it feeds, including the decisions that
-/// are then dropped, because a seed has to keep meaning the same tree.
-struct Sow<'a> {
-    rng: Rng,
-    edits: &'a Edits,
-    sized: usize,
-    aligned: usize,
-    nodes: usize,
-    spans: usize,
-}
-
-impl Sow<'_> {
-    fn leaf(&mut self) -> Plan {
-        Plan::bare(match self.rng.below(4) {
-            0 => Kind::Wrapped,
-            1 => Kind::OneLine,
-            _ => {
-                let color = self.rng.below(COLORS.len());
-                let alpha = (self.rng.below(5) * 63) as u8;
-                Kind::Rect { color, alpha }
-            }
-        })
-    }
-
-    fn len(&mut self) -> Option<LayoutLen> {
-        match self.rng.below(4) {
-            0 => Some(LayoutLen::px(20.0 + self.rng.below(180) as f32)),
-            1 => Some(LayoutLen::LEFTOVER),
-            _ => None,
-        }
-    }
-
-    fn align(&mut self) -> Aligns {
-        let axis = |s: &mut Self| match s.rng.below(4) {
-            0 => None,
-            1 => Some(AxisAlign::NEG),
-            2 => Some(AxisAlign::CENTER),
-            _ => Some(AxisAlign::POS),
-        };
-        let (x, y) = (axis(self), axis(self));
-        // Aligning on neither axis leaves the branch unexercised.
-        match x.is_none() && y.is_none() {
-            true => [Some(AxisAlign::CENTER), y],
-            false => [x, y],
-        }
-    }
-
-    /// A declared size over half the tree, kept where a test can change it.
-    fn sized(&mut self, inner: &mut Plan) {
-        let take = self.rng.chance();
-        let lens = [self.len(), self.len()];
-        if !take || inner.size.is_some() {
-            return;
-        }
-        let idx = self.sized;
-        self.sized += 1;
-        inner.size = Some(self.edits.sizes.get(&idx).copied().unwrap_or(lens));
-    }
-
-    /// An alignment over some of the tree, kept where a test can change it.
-    fn aligned(&mut self, inner: &mut Plan) {
-        let align = self.align();
-        if inner.align.is_some() {
-            return;
-        }
-        let idx = self.aligned;
-        self.aligned += 1;
-        inner.align = Some(self.edits.aligns.get(&idx).copied().unwrap_or(align));
-    }
-
-    /// A movable region of its own over some of the tree. What it changes is
-    /// how a move is written and how long a primitive's chain is, neither of
-    /// which any other branch here varies.
-    fn noded(&mut self, inner: &mut Plan) {
-        let take = self.rng.below(4) == 0;
-        if inner.region_node.is_some() {
-            return;
-        }
-        let idx = self.nodes;
-        self.nodes += 1;
-        inner.region_node = Some(self.edits.nodes.get(&idx).copied().unwrap_or(take));
-    }
-
-    fn offered(&mut self, inner: &mut Plan) {
-        self.sized(inner);
-        self.noded(inner);
-    }
-
-    fn node(&mut self, depth: usize) -> Plan {
-        if depth == 0 {
-            return self.leaf();
-        }
-        let positioned = self.rng.below(6);
-        if positioned == 0 {
-            let mut inner = self.node(depth - 1);
-            self.offered(&mut inner);
-            let axis = if self.rng.chance() { Axis::X } else { Axis::Y };
-            return Plan::bare(Kind::Scroll {
-                axis,
-                inner: Box::new(inner),
-            });
-        }
-        if positioned == 2 {
-            let probe = self.node(depth - 1);
-            let wide = self.node(depth - 1);
-            let narrow = self.node(depth - 1);
-            // Drawn either way, so the side a fixed branch takes is still a
-            // side the generator chose -- and it consumes the same randomness
-            // as a measured one, so the two grow the same ids.
-            let measured = self.rng.below(500) as f32;
-            let threshold = match self.edits.fixed_branches {
-                true => f32::MIN,
-                false => measured,
-            };
-            return Plan::bare(Kind::Branch {
-                probe: Box::new(probe),
-                wide: Box::new(wide),
-                narrow: Box::new(narrow),
-                threshold,
-            });
-        }
-        if positioned == 1 {
-            // Carries an alignment and makes no widget of its own, so the
-            // plan for it is the child it aligned.
-            let mut inner = self.node(depth - 1);
-            self.offered(&mut inner);
-            self.aligned(&mut inner);
-            return inner;
-        }
-        if self.rng.below(4) == 0 {
-            let mut inner = self.node(depth - 1);
-            self.offered(&mut inner);
-            let side = |s: &mut Self| s.rng.below(24) as i32;
-            let padding = [side(self), side(self), side(self), side(self)];
-            return Plan::bare(Kind::Pad {
-                padding,
-                inner: Box::new(inner),
-            });
-        }
-        let grown = 2 + self.rng.below(3);
-        let mut children = Vec::with_capacity(grown);
-        for _ in 0..grown {
-            let mut child = self.node(depth - 1);
-            self.offered(&mut child);
-            children.push(child);
-        }
-        if self.rng.chance() {
-            return Plan::bare(Kind::Stack { children });
-        }
-        let spares: Vec<Plan> = (0..SPARES).map(|_| self.leaf()).collect();
-        let idx = self.spans;
-        self.spans += 1;
-        let edit = self.edits.spans.get(&idx).cloned().unwrap_or_default();
-        let dir = self.rng.below(4);
-        // A row takes the height it is given rather than its tallest child,
-        // which is a rule beside it. Derived from an existing choice and
-        // consuming no randomness: a seed must keep growing the same tree
-        // when the generator gains another configuration.
-        let gap = self.rng.below(3) as i32 * 4;
-        let grown: Vec<usize> = (0..children.len()).collect();
-        let order = span_edited(&grown, children.len(), spares.len(), &edit);
-        Plan::bare(Kind::Span {
-            dir,
-            gap,
-            children,
-            spares,
-            order,
-        })
-    }
-}
-
-/// Builds a plan's widgets in the order it describes them, so two builds of
-/// one plan line up index for index and their boxes can be compared.
-pub fn build<Rsc: UiRsc + 'static>(rsc: &mut Rsc, plan: &Plan) -> (StrongWidget, Tree) {
-    let mut build = Build {
-        rsc,
-        tree: Tree::default(),
-    };
-    let root = build.node(plan);
-    (root, build.tree)
-}
-
-struct Build<'a, Rsc> {
-    rsc: &'a mut Rsc,
-    tree: Tree,
-}
-
-impl<Rsc: UiRsc + 'static> Build<'_, Rsc> {
-    fn node(&mut self, plan: &Plan) -> StrongWidget {
-        let built = self.kind(&plan.kind);
-        let id = built.id();
-        if let Some(lens) = plan.size {
-            self.rsc
-                .ui_mut()
-                .widgets
-                .set_size_rules(id, lens[0], lens[1]);
-            self.tree.sized.push(id);
-        }
-        if let Some(align) = plan.align {
-            let widgets = &mut self.rsc.ui_mut().widgets;
-            for (axis, align) in [Axis::X, Axis::Y].into_iter().zip(align) {
-                widgets.set_alignment(id, axis, align.unwrap_or_default());
-            }
-            self.tree.aligned.push(id);
-        }
-        if let Some(take) = plan.region_node {
-            self.rsc.ui_mut().widgets.set_region_node(id, take);
-            self.tree.nodes.push(id);
-        }
-        built
-    }
-
-    fn kind(&mut self, kind: &Kind) -> StrongWidget {
-        let id: StrongWidget = match kind {
-            Kind::Wrapped => wtext(WORDS).size(16).wrap(true).add_strong(self.rsc),
-            Kind::OneLine => wtext("one line, overflowing whatever it is given")
-                .size(16)
-                .wrap(false)
-                .add_strong(self.rsc),
-            Kind::Rect { color, alpha } => rect(COLORS[*color].alpha(*alpha)).add_strong(self.rsc),
-            Kind::Scroll { axis, inner } => {
-                let inner = self.node(inner);
-                let id = Scroll::new(inner, *axis).add(self.rsc);
-                self.tree.scrolls.push(id);
-                self.tree.ids.push(id.id());
-                return id.add_strong(self.rsc);
-            }
-            Kind::Branch {
-                probe,
-                wide,
-                narrow,
-                threshold,
-            } => {
-                let probe = self.node(probe);
-                let wide = self.node(wide);
-                let narrow = self.node(narrow);
-                let id = Branch {
-                    probe,
-                    wide,
-                    narrow,
-                    threshold: *threshold,
-                }
-                .add(self.rsc);
-                self.tree.ids.push(id.id());
-                return id.add_strong(self.rsc);
-            }
-            Kind::Pad { padding, inner } => {
-                let inner = self.node(inner);
-                let [left, right, top, bottom] = padding.map(Px::from_int);
-                let padding = Padding {
-                    left,
-                    right,
-                    top,
-                    bottom,
-                };
-                Pad { padding, inner }.add_strong(self.rsc)
-            }
-            Kind::Stack { children } => {
-                let children = children.iter().map(|c| self.node(c)).collect();
-                Stack {
-                    children,
-                    size: StackSize::Child(0),
-                }
-                .add_strong(self.rsc)
-            }
-            Kind::Span {
-                dir,
-                gap,
-                children,
-                spares,
-                order,
-            } => {
-                let grown = children.len();
-                // Every one of them is made, in this order, whether or not
-                // the span ends up holding it.
-                let made: Vec<StrongWidget> = children
-                    .iter()
-                    .chain(spares)
-                    .map(|c| self.node(c))
-                    .collect();
-                let mut left: Vec<Option<StrongWidget>> = made.into_iter().map(Some).collect();
-                let children: Vec<StrongWidget> = order
-                    .iter()
-                    .filter_map(|&i| left.get_mut(i).and_then(Option::take))
-                    .collect();
-                // What the span does not hold is still held here: dropping
-                // the last share of a widget frees its id for the next one
-                // to be given, which puts two trees out of step.
-                let spares: Vec<StrongWidget> = left.into_iter().flatten().collect();
-                let dir = [Dir::RIGHT, Dir::DOWN, Dir::LEFT, Dir::UP][*dir % 4];
-                let id = Span {
-                    children,
-                    dir,
-                    gap: Px::from_int(*gap),
-                }
-                .add(self.rsc);
-                if dir.axis == Axis::X {
-                    self.rsc
-                        .widgets_mut()
-                        .set_size_rules(id, None, Some(LayoutLen::rel(1.0)));
-                }
-                self.tree.ids.push(id.id());
-                self.tree.spans.push(Spanned { id, spares, grown });
-                return id.add_strong(self.rsc);
-            }
-        };
-        self.tree.ids.push(id.id());
-        id
-    }
-}

src/typed.rs

@@ -0,0 +1,37 @@
+#[macro_export]
+macro_rules! event_state {
+    ($vis:vis $state:ty) => {
+        mod local_event_trait {
+            use super::*;
+            #[allow(unused_imports)]
+            use $crate::prelude::*;
+            pub trait EventableCtx<WL: WidgetLike<$state, Tag>, Tag> {
+                fn on<E: EventLike>(
+                    self,
+                    event: E,
+                    f: impl for<'a> WidgetEventFn<
+                        <$state as HasState>::State,
+                        <E::Event as Event>::Data<'a>,
+                        WL::Widget
+                    >,
+                ) -> impl WidgetIdFn<$state, WL::Widget>;
+            }
+            impl<WL: WidgetLike<$state, Tag>, Tag> EventableCtx<WL, Tag> for WL {
+                fn on<E: EventLike>(
+                    self,
+                    event: E,
+                    f: impl for<'a> WidgetEventFn<
+                        <$state as HasState>::State,
+                        <E::Event as Event>::Data<'a>,
+                        WL::Widget
+                    >,
+                ) -> impl WidgetIdFn<$state, WL::Widget> {
+                    eventable::Eventable::on(self, event, f)
+                }
+            }
+        }
+        $vis type EventManager = $crate::prelude::EventManager<<$state as HasState>::State>;
+        $vis use local_event_trait::*;
+    };
+}
+pub use event_state;

src/widget/image.rs

@@ -6,20 +6,23 @@ pub struct Image {
 }
 
 impl Widget for Image {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.primitive(&self.handle);
-        Size::px(self.handle.size())
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.texture(&self.handle);
     }
 
-    fn size_hint(&self, axis: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::px(self.handle.size().axis(axis)))
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::abs(self.handle.size().x)
+    }
+
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::abs(self.handle.size().y)
     }
 }
 
-pub fn image<State: UiRsc>(image: impl LoadableImage) -> impl WidgetFn<State, Image> {
+pub fn image<State: HasUi>(image: impl LoadableImage) -> impl WidgetFn<State, Image> {
     let image = image.get_image().expect("Failed to load image");
     move |state| Image {
-        handle: state.ui_mut().textures.add(image),
+        handle: state.get_mut().add_texture(image),
     }
 }
 

src/widget/mask.rs

@@ -1,18 +1,20 @@
 use crate::prelude::*;
 
 pub struct Masked {
-    pub inner: StrongWidget,
+    pub inner: WidgetHandle,
 }
 
 impl Widget for Masked {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        painter.set_mask(DrawRegion::Extent(UiRegion::FULL));
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.set_mask(painter.region());
         painter.widget(&self.inner);
-        // What it occupies is its box, on both axes, for the reason `Scroll`
-        // reports the same: it clips what is inside to that box, so it can
-        // neither take less of one nor honestly ask for more. Passing the
-        // inner size up instead asks to be placed at a length it does not
-        // draw, and the framework would place the drawing it clipped away.
-        Size::LEFTOVER
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.width(&self.inner)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.height(&self.inner)
     }
 }

src/widget/mod.rs

@@ -1,15 +1,15 @@
 mod image;
 mod mask;
 mod position;
+mod ptr;
 mod rect;
 mod text;
 mod trait_fns;
-mod wrapper;
 
 pub use image::*;
 pub use mask::*;
 pub use position::*;
+pub use ptr::*;
 pub use rect::*;
 pub use text::*;
 pub use trait_fns::*;
-pub use wrapper::*;

src/widget/position/align.rs

@@ -0,0 +1,35 @@
+use crate::prelude::*;
+
+pub struct Aligned {
+    pub inner: WidgetHandle,
+    pub align: Align,
+}
+
+impl Widget for Aligned {
+    fn draw(&mut self, painter: &mut Painter) {
+        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)
+            }
+            (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)
+    }
+}

src/widget/position/layer.rs

@@ -1,15 +1,23 @@
 use crate::prelude::*;
 
 pub struct LayerOffset {
-    pub inner: StrongWidget,
+    pub inner: WidgetHandle,
     pub offset: usize,
 }
 
 impl Widget for LayerOffset {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         for _ in 0..self.offset {
             painter.next_layer();
         }
-        painter.widget(&self.inner).size()
+        painter.widget(&self.inner);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.width(&self.inner)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.height(&self.inner)
     }
 }

src/widget/position/max_size.rs

@@ -0,0 +1,48 @@
+use crate::prelude::*;
+
+pub struct MaxSize {
+    pub inner: WidgetHandle,
+    pub x: Option<Len>,
+    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
+        }
+    }
+}

src/widget/position/mod.rs

@@ -1,13 +1,19 @@
+mod align;
 mod layer;
+mod max_size;
 mod offset;
 mod pad;
 mod scroll;
+mod sized;
 mod span;
 mod stack;
 
+pub use align::*;
 pub use layer::*;
+pub use max_size::*;
 pub use offset::*;
 pub use pad::*;
 pub use scroll::*;
+pub use sized::*;
 pub use span::*;
 pub use stack::*;

src/widget/position/offset.rs

@@ -1,13 +1,21 @@
 use crate::prelude::*;
 
 pub struct Offset {
-    pub inner: StrongWidget,
+    pub inner: WidgetHandle,
     pub amt: UiVec2,
 }
 
 impl Widget for Offset {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         let region = UiRegion::FULL.offset(self.amt);
-        painter.widget_within(&self.inner, region).size()
+        painter.widget_within(&self.inner, region);
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.width(&self.inner)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        ctx.height(&self.inner)
     }
 }

src/widget/position/pad.rs

@@ -2,49 +2,52 @@ use crate::prelude::*;
 
 pub struct Pad {
     pub padding: Padding,
-    pub inner: StrongWidget,
+    pub inner: WidgetHandle,
 }
 
 impl Widget for Pad {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        // The inner's own alignment, not the near edge. This reports the
-        // inner's size plus the padding, so where the box is that answer the
-        // inset box is exactly the inner and alignment has no room to move
-        // it; where the box is bigger -- a share of a row, a rule over this
-        // widget -- the slack is the inner's to sit in, and forcing the near
-        // edge pinned it to a corner it had not asked for.
-        let inside = DrawRegion::Extent(self.padding.region());
-        let inner = painter.widget_within(&self.inner, inside).size();
-        Size {
-            x: LayoutLen {
-                px: inner.x.px + self.padding.left + self.padding.right,
-                ..inner.x
-            },
-            y: LayoutLen {
-                px: inner.y.px + self.padding.top + self.padding.bottom,
-                ..inner.y
-            },
-        }
+    fn draw(&mut self, painter: &mut Painter) {
+        painter.widget_within(&self.inner, self.padding.region());
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        let width = self.padding.left + self.padding.right;
+        let height = self.padding.top + self.padding.bottom;
+        ctx.outer.x.abs -= width;
+        ctx.outer.y.abs -= height;
+        let mut size = ctx.width(&self.inner);
+        size.abs += width;
+        size
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        let width = self.padding.left + self.padding.right;
+        let height = self.padding.top + self.padding.bottom;
+        ctx.outer.x.abs -= width;
+        ctx.outer.y.abs -= height;
+        let mut size = ctx.height(&self.inner);
+        size.abs += height;
+        size
     }
 }
 
 pub struct Padding {
-    pub left: Px,
-    pub right: Px,
-    pub top: Px,
-    pub bottom: Px,
+    pub left: f32,
+    pub right: f32,
+    pub top: f32,
+    pub bottom: f32,
 }
 
 impl Padding {
     pub const ZERO: Self = Self {
-        left: Px::ZERO,
-        right: Px::ZERO,
-        top: Px::ZERO,
-        bottom: Px::ZERO,
+        left: 0.0,
+        right: 0.0,
+        top: 0.0,
+        bottom: 0.0,
     };
 
     pub fn uniform(amt: impl UiNum) -> Self {
-        let amt = Px::from_num(amt);
+        let amt = amt.to_f32();
         Self {
             left: amt,
             right: amt,
@@ -52,82 +55,80 @@ impl Padding {
             bottom: amt,
         }
     }
-    /// `region` less this padding on each side.
-    pub fn region_of(&self, mut region: UiRegion) -> UiRegion {
-        region.x.start.px += self.left;
-        region.y.start.px += self.top;
-        region.x.end.px -= self.right;
-        region.y.end.px -= self.bottom;
+    pub fn region(&self) -> UiRegion {
+        let mut region = UiRegion::FULL;
+        region.x.start.abs += self.left;
+        region.y.start.abs += self.top;
+        region.x.end.abs -= self.right;
+        region.y.end.abs -= self.bottom;
         region
     }
-
-    pub fn region(&self) -> UiRegion {
-        self.region_of(UiRegion::FULL)
-    }
     pub fn x(amt: impl UiNum) -> Self {
-        let amt = Px::from_num(amt);
+        let amt = amt.to_f32();
         Self {
             left: amt,
             right: amt,
-            ..Self::ZERO
+            top: 0.0,
+            bottom: 0.0,
         }
     }
     pub fn y(amt: impl UiNum) -> Self {
-        let amt = Px::from_num(amt);
+        let amt = amt.to_f32();
         Self {
+            left: 0.0,
+            right: 0.0,
             top: amt,
             bottom: amt,
-            ..Self::ZERO
         }
     }
 
     pub fn top(amt: impl UiNum) -> Self {
         let mut s = Self::ZERO;
-        s.top = Px::from_num(amt);
+        s.top = amt.to_f32();
         s
     }
 
     pub fn bottom(amt: impl UiNum) -> Self {
         let mut s = Self::ZERO;
-        s.bottom = Px::from_num(amt);
+        s.bottom = amt.to_f32();
         s
     }
 
     pub fn left(amt: impl UiNum) -> Self {
         let mut s = Self::ZERO;
-        s.left = Px::from_num(amt);
+        s.left = amt.to_f32();
         s
     }
 
     pub fn right(amt: impl UiNum) -> Self {
         let mut s = Self::ZERO;
-        s.right = Px::from_num(amt);
+        s.right = amt.to_f32();
         s
     }
 
     pub fn with_top(mut self, amt: impl UiNum) -> Self {
-        self.top = Px::from_num(amt);
+        self.top = amt.to_f32();
         self
     }
 
     pub fn with_bottom(mut self, amt: impl UiNum) -> Self {
-        self.bottom = Px::from_num(amt);
+        self.bottom = amt.to_f32();
         self
     }
 
     pub fn with_left(mut self, amt: impl UiNum) -> Self {
-        self.left = Px::from_num(amt);
+        self.left = amt.to_f32();
         self
     }
 
     pub fn with_right(mut self, amt: impl UiNum) -> Self {
-        self.right = Px::from_num(amt);
+        self.right = amt.to_f32();
         self
     }
 }
 
 impl<T: UiNum> From<T> for Padding {
     fn from(amt: T) -> Self {
-        Self::uniform(amt)
+        Self::uniform(amt.to_f32())
     }
 }

src/widget/position/scroll.rs

@@ -1,104 +1,66 @@
 use crate::prelude::*;
 
 pub struct Scroll {
-    inner: StrongWidget,
+    inner: WidgetHandle,
     axis: Axis,
-    amt: Px,
+    amt: f32,
     snap_end: bool,
-    container_len: Px,
-    content_len: Px,
+    container_len: f32,
+    content_len: f32,
 }
 
 impl Widget for Scroll {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let container_len = painter.px_len(self.axis);
-        // Draw in the whole container only when its scrolling-axis length is
-        // not already known, then draw it at the scrolled offset.
-        let whole = UiRegion::FULL;
-        let own = painter.placement();
-        let answer_len =
-            painter.measure_len(&self.inner, self.axis, whole, [Some(own.x), Some(own.y)]);
-        let content = answer_len.apply_leftover();
-        self.container_len = container_len;
-        self.content_len = content.to_px(container_len);
+    fn draw(&mut self, painter: &mut Painter) {
+        let output_len = painter.output_size().axis(self.axis);
+        let container_len = painter.region().axis(self.axis).len();
+        let content_len = painter
+            .len_axis(&self.inner, self.axis)
+            .apply_rest()
+            .within_len(container_len)
+            .to_abs(output_len);
+        self.container_len = container_len.to_abs(output_len);
+        self.content_len = content_len;
 
         if self.snap_end {
             self.amt = self.content_len - self.container_len;
         }
         self.update_amt();
-        let align = painter.alignment().axis(self.axis);
-        // Content of a fixed length that fits sits at the start of any box it
-        // fits in -- but only anchored there. Anywhere else it is a part of
-        // the room left over, so it moves with every length the box takes and
-        // the drawing holds for that length alone. One scrolled part way sits
-        // where it is until the box shrinks past what is left of it. Kept to
-        // the end, it moves with every length.
-        let fixed_len = content.rel == Rel::ZERO;
-        if fixed_len && self.content_len <= self.container_len && align == AxisAlign::NEG {
-            painter.holds(self.axis, self.content_len..=Px::MAX);
-        } else if fixed_len && !self.snap_end {
-            let left = self.content_len - self.amt;
-            painter.holds(self.axis, Px::MIN..=left);
-        }
 
-        // Content shorter than the viewport has room to sit in, and where it
-        // sits is this widget's own alignment -- the same property that would
-        // have placed the whole scroll in a box longer than it.
-        let slack = (self.container_len - self.content_len).max(Px::ZERO);
-        let anchor = slack.mul(align.rel());
-        let mut region = UiRegion::FULL;
-        // Content that fills the viewport and has not been scrolled is the
-        // viewport, and is handed back as it came. Writing the same box as
-        // its own length in pixels is the same box in another form, and the
-        // two do not round alike: a part centred in `rel 1` lands a step from
-        // one centred in `px 900`, since halving a difference is not halving
-        // each part of it.
-        let moved = anchor != Px::ZERO || self.amt != Px::ZERO;
-        if moved || self.content_len != self.container_len {
-            let offset = UiVec2::from_axis(
-                self.axis,
-                Len::from_parts(Rel::ZERO, anchor - self.amt),
-                Len::ZERO,
-            );
-            region = region.offset(offset);
-            region.axis_mut(self.axis).end = region.axis(self.axis).start.offset(self.content_len);
-        }
-        // The viewport is the inner's region, so a fraction it declares or
-        // reports is a fraction of what is on screen rather than of the
-        // content box its own answer decided. Where it is put is the content
-        // box, scrolled.
-        painter.widget_at(&self.inner, whole, [Some(region.x), Some(region.y)]);
-        // What it occupies is its box, on both axes: it clips its content to
-        // that box, so it can neither take less of one nor honestly ask for
-        // more. The content's length is what it scrolls through, not what it
-        // is.
-        Size::LEFTOVER
+        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)
     }
 }
 
 impl Scroll {
-    pub fn new(inner: StrongWidget, axis: Axis) -> Self {
+    pub fn new(inner: WidgetHandle, axis: Axis) -> Self {
         Self {
             inner,
             axis,
-            amt: Px::ZERO,
+            amt: 0.0,
             snap_end: true,
-            container_len: Px::ZERO,
-            content_len: Px::ZERO,
+            container_len: 0.0,
+            content_len: 0.0,
         }
     }
 
     pub fn update_amt(&mut self) {
-        self.amt = self.amt.max(Px::ZERO);
-        let len = (self.content_len - self.container_len).max(Px::ZERO);
+        self.amt = self.amt.max(0.0);
+        let len = (self.content_len - self.container_len).max(0.0);
         self.amt = self.amt.min(len);
         self.snap_end = self.amt == len;
     }
 
-    /// Scrolled by a distance the platform measures, which is the last place
-    /// a wheel notch or a finger is a float.
     pub fn scroll(&mut self, amt: f32) {
-        self.amt -= Px::from_f32(amt);
+        self.amt -= amt;
         self.update_amt();
     }
 }

src/widget/position/sized.rs

@@ -0,0 +1,34 @@
+use crate::prelude::*;
+
+pub struct Sized {
+    pub inner: WidgetHandle,
+    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

@@ -2,200 +2,143 @@ use crate::prelude::*;
 use std::marker::PhantomData;
 
 pub struct Span {
-    pub children: Vec<StrongWidget>,
+    pub children: Vec<WidgetHandle>,
     pub dir: Dir,
-    pub gap: Px,
+    pub gap: f32,
 }
 
 impl Widget for Span {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let axis = self.dir.axis;
-        // The row: this span's own box, as a span of the region it was given.
-        // Its children are laid out along it, and what they declare or report
-        // is a fraction of the region -- the area this span was told it has,
-        // which it passes on unchanged.
-        let own = painter.placement();
-        let row = *own.axis(axis);
-        // Across itself the span's own box is the child's region: a span is
-        // what contains its children there, and nothing divides that axis.
-        // Along it the whole region is, so a fraction means the same thing
-        // for every child however much of the row is left when it is asked.
-        let region = UiRegion::from_axis(axis, UiSpan::FULL, *own.axis(!axis));
-        let along = |from: Len, to: Len| match self.dir.sign {
-            Sign::Pos => UiSpan::new(row.start + from, row.start + to),
-            Sign::Neg => UiSpan::new(row.end - to, row.end - from),
-        };
-        let far = row.len();
-        // A length for every child before their final boxes are chosen: from
-        // a hint where one exists, and from drawing otherwise.
-        let mut cursor = Len::rel_min();
-        let mut lens = Vec::with_capacity(self.children.len());
+    fn draw(&mut self, painter: &mut Painter) {
+        let total = self.len_sum();
+        let mut start = UiScalar::rel_min();
         for child in &self.children {
-            // The whole region is the child's, so `rel(0.5)` is half the area
-            // this span was given whatever else is in it and wherever this
-            // child sits among them. What it is placed in is the room left
-            // from the cursor, because a text has to wrap at the width
-            // actually there.
-            let room = axis.pair(Some(along(cursor, far)), None);
-            let len = painter.measure_len(child, axis, region, room);
-            cursor.px += len.px + self.gap;
-            cursor.rel += len.rel;
-            lens.push(len);
-        }
-
-        let gaps = self
-            .gap
-            .mul_int(self.children.len().saturating_sub(1) as i32);
-        let total = lens.iter().fold(
-            LayoutLen {
-                px: gaps,
-                ..LayoutLen::ZERO
-            },
-            |sum, len| sum + *len,
-        );
-
-        // What is left for the shares to divide: the row less everything
-        // fixed, as a length of the region rather than a number of pixels.
-        let room = far - Len::from_parts(total.rel, total.px);
-        // Whether anything is left over is a question in pixels: `rel(0.5)`
-        // beside 300 px is full at 600 and overfull at 400. Asked of `room`
-        // itself, and answered back through the same expression, so the
-        // boundary is the drawing's own and not a second way of finding it:
-        // the three cases a rounded division needed -- the fixed parts
-        // growing slower than the box, faster, or exactly with it -- are the
-        // sign of `room.rel`, which `through` already reads. What the
-        // generated oracle checks is the consequence, since which children
-        // exist at all turns on this.
-        let mut shares = false;
-        if total.leftover > Weight::ZERO {
-            shares = room.to_px(painter.region_px_len(axis)) > Px::ZERO;
-            let holds = match shares {
-                true => Holds::from(Px::STEP..=Px::MAX),
-                false => Holds::from(Px::MIN..=Px::ZERO),
-            };
-            painter.region_holds(axis, holds.through(room));
-        }
-
-        // Across itself a span is as long as its longest child -- unless a
-        // rule beside it gives that length outright, and then reading them
-        // answers nothing and makes its size depend on theirs for it. A rule
-        // that only bounds the length does not count: the answer is still
-        // this span's to give.
-        let shrinks = !painter.has_exact_size(!axis);
-        // What the fixed parts and the gaps before here take, which is a sum
-        // of lengths and exact, and how much of the leftover weight is
-        // spoken for. A position is one from the other rather than a step
-        // from the last child: the share of the room is rounded, and taking
-        // each from the one before it would carry every rounding along the
-        // row.
-        let mut fixed = Len::rel_min();
-        let mut taken = Weight::ZERO;
-        let mut start = Len::rel_min();
-        let mut ortho = LayoutLen::ZERO;
-        for (child, len) in self.children.iter().zip(&lens) {
-            // A child asking for nothing but a part of what is left over,
-            // when nothing is, is not drawn at all. One that also asked for
-            // pixels or a fraction keeps those and overflows.
-            if len.leftover > Weight::ZERO && len.px == Px::ZERO && len.rel == Rel::ZERO && !shares
-            {
-                painter.undraw(child);
-                fixed.px += self.gap;
-                continue;
+            let mut span = UiSpan::FULL;
+            span.start = start;
+            painter.widget(id);
+            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);
+                let end = (UiScalar::rel_max() + start) - offset;
+                start = rel_end.within(&start.to(end));
             }
-            let from = start;
-            if len.leftover > Weight::ZERO && shares {
-                taken += len.leftover;
+            start.abs += len.abs;
+            start.rel += len.rel;
+            span.end = start;
+            let mut child_region = UiRegion::from_axis(self.dir.axis, span, UiSpan::FULL);
+            if self.dir.sign == Sign::Neg {
+                child_region.flip(self.dir.axis);
             }
-            fixed.px += len.px;
-            fixed.rel += len.rel;
-            start = shared(fixed, taken, total.leftover, room);
-            // Along the row the span says where the child goes; across it the
-            // child sits where its own alignment says. Its region is the
-            // whole of what this span was given either way, which is what its
-            // fractions are of.
-            let placed =
-                painter.widget_at(child, region, axis.pair(Some(along(from, start)), None));
-            if shrinks {
-                let used = placed.len(!axis);
-                // Choosing between a fixed and a relative length from the
-                // span's own eventual width admits multiple fixed points.
-                // A scalable child therefore makes Children scalable too;
-                // only fixed children are compared with one another.
-                if used.rel != Rel::ZERO || used.leftover != Weight::ZERO {
-                    ortho = LayoutLen::LEFTOVER;
-                } else if ortho.leftover == Weight::ZERO {
-                    ortho.px = ortho.px.max(used.px);
-                }
-            }
-            fixed.px += self.gap;
-            start = shared(fixed, taken, total.leftover, room);
+            painter.widget_within(child, child_region);
+            start.abs += self.gap;
         }
-
-        // Carried whole rather than collapsed to one share: a span that sizes
-        // from its children does not resolve `leftover`, it passes the weight up,
-        // so nesting spans divides the same space rather than re-dividing a
-        // share of it. Four `leftover(1)` children under two spans under one span
-        // get a quarter each, which collapsing to `leftover(1)` per level does
-        // not give. Resolution happens at the nearest ancestor with a length,
-        // and the root always has one.
-        let along = total;
-        let ortho = match shrinks {
-            true => ortho,
-            false => LayoutLen::rel(1.0),
-        };
-        Size::from_axis(axis, along, ortho)
     }
 }
 
-/// Where a row has reached: everything fixed before this point, which is a
-/// sum and exact, plus the share of the room the weights so far are worth,
-/// which is one rounding wherever it is asked for.
-fn shared(fixed: Len, taken: Weight, weight: Weight, room: Len) -> Len {
-    if taken == Weight::ZERO {
-        return fixed;
-    }
-    fixed + room.scale(Rel::ratio(taken, weight))
-}
-
 impl Span {
     pub fn empty(dir: Dir) -> Self {
         Self {
             children: Vec::new(),
             dir,
-            gap: Px::ZERO,
+            gap: 0.0,
         }
     }
 
     pub fn gap(mut self, gap: impl UiNum) -> Self {
-        self.gap = Px::from_num(gap);
+        self.gap = gap.to_f32();
         self
     }
 
-    pub fn push(&mut self, w: StrongWidget) {
+    pub fn push(&mut self, w: WidgetHandle) {
         self.children.push(w);
     }
 
-    pub fn pop(&mut self) -> Option<StrongWidget> {
+    pub fn pop(&mut self) -> Option<WidgetHandle> {
         self.children.pop()
     }
+
+    fn desired_len(&mut self, ctx: &mut SizeCtx) -> Len {
+        let len = self.len_sum(ctx);
+        if len.rest == 0.0 && len.rel == 0.0 {
+            len
+        } else {
+            Len::default()
+        }
+    }
+
+    fn desired_ortho(&mut self, ctx: &mut SizeCtx) -> Len {
+        // this is a weird hack to get text wrapping to work properly when in a downward span
+        // the correct solution here is to add a function to widget that lets them
+        // request that ctx.outer has an axis "resolved" before checking the other,
+        // and panicking or warning if two request opposite axis (unsolvable in that case)
+        let outer = ctx.outer.axis(self.dir.axis);
+        if self.dir.axis == Axis::X {
+            // so....... this literally copies draw so that the lengths are correctly set in the
+            // context, which makes this slow and not cool
+            let total = self.len_sum(ctx);
+            let mut start = UiScalar::rel_min();
+            let mut ortho_len = Len::ZERO;
+            for child in &self.children {
+                let mut span = UiSpan::FULL;
+                span.start = start;
+                let len = ctx.len_axis(child, self.dir.axis);
+                if len.rest > 0.0 {
+                    let offset = UiScalar::new(total.rel, total.abs);
+                    let rel_end = UiScalar::rel(len.rest / total.rest);
+                    let end = (UiScalar::rel_max() + start) - offset;
+                    start = rel_end.within(&start.to(end));
+                }
+                start.abs += len.abs;
+                start.rel += len.rel;
+                span.end = start;
+
+                let scalar = span.len();
+                *ctx.outer.axis_mut(self.dir.axis) = outer.select_len(scalar);
+                let ortho = ctx.len_axis(child, !self.dir.axis);
+                // TODO: rel shouldn't do this, but no easy way before actually calculating pixels
+                if ortho.rel > 0.0 || ortho.rest > 0.0 {
+                    ortho_len.rest = 1.0;
+                    ortho_len.abs = 0.0;
+                    break;
+                }
+                ortho_len.abs = ortho_len.abs.max(ortho.abs);
+                start.abs += self.gap;
+            }
+            ortho_len
+        } else {
+            let mut ortho_len = Len::ZERO;
+            let ortho = !self.dir.axis;
+            for child in &self.children {
+                let len = ctx.len_axis(child, ortho);
+                // TODO: rel shouldn't do this, but no easy way before actually calculating pixels
+                if len.rel > 0.0 || len.rest > 0.0 {
+                    ortho_len.rest = 1.0;
+                    ortho_len.abs = 0.0;
+                    break;
+                }
+                ortho_len.abs = ortho_len.abs.max(len.abs);
+            }
+            ortho_len
+        }
+    }
 }
 
 pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
     pub children: Wa,
     pub dir: Dir,
-    pub gap: Px,
+    pub gap: f32,
     _pd: PhantomData<(State, Tag)>,
 }
 
-impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
-    for SpanBuilder<Rsc, LEN, Wa, Tag>
+impl<State: StateLike<State>, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    WidgetFnTrait<State> for SpanBuilder<State, LEN, Wa, Tag>
 {
     type Widget = Span;
 
     #[track_caller]
-    fn run(self, rsc: &mut Rsc) -> Self::Widget {
+    fn run(self, state: &mut State) -> Self::Widget {
         Span {
-            children: self.children.add(rsc).arr.into_iter().collect(),
+            children: self.children.add(state).arr.into_iter().collect(),
             dir: self.dir,
             gap: self.gap,
         }
@@ -209,19 +152,19 @@ impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
         Self {
             children,
             dir,
-            gap: Px::ZERO,
+            gap: 0.0,
             _pd: PhantomData,
         }
     }
 
     pub fn gap(mut self, gap: impl UiNum) -> Self {
-        self.gap = Px::from_num(gap);
+        self.gap = gap.to_f32();
         self
     }
 }
 
 impl std::ops::Deref for Span {
-    type Target = Vec<StrongWidget>;
+    type Target = Vec<WidgetHandle>;
 
     fn deref(&self) -> &Self::Target {
         &self.children

src/widget/position/stack.rs

@@ -3,41 +3,35 @@ use std::marker::PhantomData;
 use crate::prelude::*;
 
 pub struct Stack {
-    pub children: Vec<StrongWidget>,
+    pub children: Vec<WidgetHandle>,
     pub size: StackSize,
 }
 
 impl Widget for Stack {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        let sizing = match self.size {
-            StackSize::Default => None,
-            StackSize::Child(i) => Some(i),
-        };
-        // Whichever child sizes the stack keeps the stack's whole region as
-        // its own -- the stack is the length that child asked for, so taking
-        // the fraction of the stack's box again would take it twice -- and is
-        // put where the stack itself is put.
-        let size = match sizing.and_then(|i| self.children.get(i).map(|c| (i, c))) {
-            // On the layer that child ends up on, so the ask below is a reuse
-            // rather than a second drawing of it somewhere else: a retained
-            // drawing belongs to the layer it was made on.
-            Some((i, child)) => {
-                painter.child_layer_at(i);
-                painter.widget(child).size()
-            }
-            None => Size::LEFTOVER,
-        };
-        for (i, child) in self.children.iter().enumerate() {
-            if sizing == Some(i) {
-                continue;
-            }
-            painter.child_layer_at(i);
-            // Every other child has the stack's own box for its region, since
-            // the stack is what contains it, and where it sits in one bigger
-            // than itself is its own business.
-            painter.widget_within(child, DrawRegion::Extent(UiRegion::FULL));
+    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]),
         }
-        size
     }
 }
 
@@ -54,15 +48,14 @@ pub struct StackBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, T
     _pd: PhantomData<(State, Tag)>,
 }
 
-impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
-    for StackBuilder<Rsc, LEN, Wa, Tag>
+impl<State: StateLike<State>, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> FnOnce<(&mut State,)>
+    for StackBuilder<State, LEN, Wa, Tag>
 {
-    type Widget = Stack;
+    type Output = Stack;
 
-    #[track_caller]
-    fn run(self, rsc: &mut Rsc) -> Self::Widget {
+    extern "rust-call" fn call_once(self, args: (&mut State,)) -> Self::Output {
         Stack {
-            children: self.children.add(rsc).arr.into_iter().collect(),
+            children: self.children.add(args.0).arr.into_iter().collect(),
             size: self.size,
         }
     }

src/widget/ptr.rs

@@ -0,0 +1,57 @@
+use crate::prelude::*;
+use std::marker::{Sized, Unsize};
+
+pub struct WidgetPtr {
+    pub inner: Option<WidgetHandle>,
+}
+
+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
+        }
+    }
+}
+
+impl WidgetPtr {
+    pub fn new() -> Self {
+        Self::default()
+    }
+    pub fn empty() -> Self {
+        Self {
+            inner: Default::default(),
+        }
+    }
+    pub fn set<W: ?Sized + Unsize<dyn Widget>>(&mut self, to: WidgetHandle<W>) {
+        self.inner = Some(to)
+    }
+
+    pub fn replace<W: ?Sized + Unsize<dyn Widget>>(
+        &mut self,
+        to: WidgetHandle<W>,
+    ) -> Option<WidgetHandle> {
+        self.inner.replace(to)
+    }
+}
+
+impl Default for WidgetPtr {
+    fn default() -> Self {
+        Self::empty()
+    }
+}

src/widget/rect.rs

@@ -28,18 +28,21 @@ impl Rect {
 }
 
 impl Widget for Rect {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         painter.primitive(RectPrimitive {
             color: self.color,
             radius: self.radius,
             thickness: self.thickness,
             inner_radius: self.inner_radius,
         });
-        Size::LEFTOVER
     }
 
-    fn size_hint(&self, _: Axis) -> Option<LayoutLen> {
-        Some(LayoutLen::LEFTOVER)
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::rest(1)
+    }
+
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::rest(1)
     }
 }
 

src/widget/text/build.rs

@@ -1,5 +1,6 @@
 use crate::prelude::*;
-use std::marker::PhantomData;
+use cosmic_text::{Attrs, Family, Metrics};
+use std::marker::{PhantomData, Sized};
 
 pub struct TextBuilder<State, O = TextOutput, H: WidgetOption<State> = ()> {
     pub content: String,
@@ -19,7 +20,7 @@ impl<State, O, H: WidgetOption<State>> TextBuilder<State, O, H> {
         self.attrs.color = color;
         self
     }
-    pub fn family(mut self, family: Family) -> Self {
+    pub fn family(mut self, family: Family<'static>) -> Self {
         self.attrs.family = family;
         self
     }
@@ -50,15 +51,15 @@ impl<State, O, H: WidgetOption<State>> TextBuilder<State, O, H> {
     }
 }
 
-impl<Rsc: UiRsc, O> TextBuilder<Rsc, O> {
-    pub fn hint<W: WidgetLike<Rsc, Tag>, Tag>(
+impl<State: HasUi + StateLike<State>, O> TextBuilder<State, O> {
+    pub fn hint<W: WidgetLike<State, Tag>, Tag>(
         self,
         hint: W,
-    ) -> TextBuilder<Rsc, O, impl WidgetOption<Rsc>> {
+    ) -> TextBuilder<State, O, impl WidgetOption<State>> {
         TextBuilder {
             content: self.content,
             attrs: self.attrs,
-            hint: move |rsc: &mut Rsc| Some(hint.add_strong(rsc).any()),
+            hint: move |ui: &mut State| Some(hint.add_strong(ui).any()),
             output: self.output,
             state: PhantomData,
         }
@@ -74,20 +75,26 @@ pub trait TextBuilderOutput<State>: Sized {
 }
 
 pub struct TextOutput;
-impl<Rsc: UiRsc> TextBuilderOutput<Rsc> for TextOutput {
+impl<State: HasUi> TextBuilderOutput<State> for TextOutput {
     type Output = Text;
 
-    fn run<H: WidgetOption<Rsc>>(
-        state: &mut Rsc,
-        builder: TextBuilder<Rsc, Self, H>,
+    fn run<H: WidgetOption<State>>(
+        state: &mut State,
+        builder: TextBuilder<State, Self, H>,
     ) -> Self::Output {
-        let buf = TextBuffer::new(&builder.content);
+        let mut buf = TextBuffer::new_empty(Metrics::new(
+            builder.attrs.font_size,
+            builder.attrs.line_height,
+        ));
         let hint = builder.hint.get(state);
+        let font_system = &mut state.get_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
     }
 }
@@ -96,18 +103,26 @@ pub struct TextEditOutput {
     mode: EditMode,
 }
 
-impl<State: UiRsc> TextBuilderOutput<State> for TextEditOutput {
+impl<State: HasUi> TextBuilderOutput<State> for TextEditOutput {
     type Output = TextEdit;
 
     fn run<H: WidgetOption<State>>(
         state: &mut State,
         builder: TextBuilder<State, Self, H>,
     ) -> Self::Output {
-        let buf = TextBuffer::new(&builder.content);
-        TextEdit::new(
+        let buf = TextBuffer::new_empty(Metrics::new(
+            builder.attrs.font_size,
+            builder.attrs.line_height,
+        ));
+        let mut text = TextEdit::new(
             TextView::new(buf, builder.attrs, builder.hint.get(state)),
             builder.output.mode,
-        )
+        );
+        let font_system = &mut state.get_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,30 +1,17 @@
 use crate::prelude::*;
-use iris_core::{TextData, UiColor};
-use parley::{Affinity, Layout, Selection};
+use cosmic_text::{Affinity, Attrs, Cursor, FontSystem, LayoutRun, Motion};
 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,
-    /// `None` represents unfocused, which Parley's `Selection` cannot express.
-    selection: Option<Selection>,
-    history: Vec<(String, Option<Selection>)>,
-    double_hit: Option<usize>,
+    selection: TextSelection,
+    history: Vec<(String, TextSelection)>,
+    double_hit: Option<Cursor>,
     pub mode: EditMode,
 }
 
@@ -38,114 +25,230 @@ impl TextEdit {
     pub fn new(view: TextView, mode: EditMode) -> Self {
         Self {
             view,
-            selection: None,
+            selection: Default::default(),
             history: Default::default(),
             double_hit: None,
             mode,
         }
     }
-
-    pub fn selected_text(&self) -> Option<String> {
-        let sel = self.selection?;
-        if sel.is_collapsed() {
-            return None;
+    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
         }
-        Some(self.buf.text()[sel.text_range()].to_string())
     }
 }
 
 impl Widget for TextEdit {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
+    fn draw(&mut self, painter: &mut Painter) {
         let base = painter.layer;
         painter.child_layer();
-        let (_, size) = self.view.draw(painter);
+        self.view.draw(painter);
         painter.layer = base;
         let region = self.region();
 
-        let Some(selection) = self.selection else {
-            return size;
-        };
-        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 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 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)
     }
 }
 
-const CARET_WIDTH: f32 = 1.0;
+/// 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
+}
 
 pub struct TextEditCtx<'a> {
     pub text: &'a mut TextEdit,
-    pub data: &'a mut TextData,
+    pub font_system: &'a mut FontSystem,
 }
 
 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 = std::mem::take(self.text.view.buf.edit());
-        self.text.selection = None;
+        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();
         text
     }
 
     pub fn set(&mut self, text: &str) {
         let text = self.string(text);
-        self.text.view.buf.set_text(text);
-        self.text.selection = None;
+        self.text
+            .buf
+            .set_text(self.font_system, &text, &Attrs::new(), SHAPING, None);
+        self.text.selection.clear();
     }
 
     pub fn motion(&mut self, motion: Motion, select: bool) {
-        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);
+        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);
+                        }
+                    }
+                }
+            }
+        }
     }
 
-    /// 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.backspace(false);
+            self.delete(false);
         }
-        self.insert_str(&text);
+        self.insert_inner(&text, false);
     }
 
     fn string(&self, text: &str) -> String {
@@ -158,176 +261,202 @@ impl<'a> TextEditCtx<'a> {
 
     pub fn insert(&mut self, text: &str) {
         let text = self.string(text);
-        self.insert_str(&text);
-    }
-
-    fn insert_str(&mut self, text: &str) {
-        if text.is_empty() {
+        let mut lines = text.split('\n');
+        let Some(first) = lines.next() else {
             return;
-        }
-        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.set_caret(at + text.len());
+        self.insert_inner(first, true);
+        for line in lines {
+            self.newline();
+            self.insert_inner(line, true);
+        }
     }
 
     pub fn clear_span(&mut self) -> bool {
-        let Some(sel) = self.text.selection else {
-            return false;
-        };
-        if sel.is_collapsed() {
-            return false;
+        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 range = sel.text_range();
-        self.text.view.buf.edit().replace_range(range.clone(), "");
-        self.set_caret(range.start);
-        true
     }
 
-    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 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);
+                }
+            }
+        }
     }
 
     pub fn newline(&mut self) {
-        if self.text.mode == EditMode::MultiLine {
-            self.insert_str("\n");
+        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;
         }
     }
 
     pub fn backspace(&mut self, word: bool) {
-        if self.clear_span() {
-            return;
+        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);
         }
-        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() {
-            return;
+        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);
+                }
+            }
         }
-        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 delete_range(&mut self, start: usize, end: usize) {
-        self.text.view.buf.edit().replace_range(start..end, "");
-        self.set_caret(start);
+    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)
     }
 
-    pub fn select_all(&mut self) {
-        let len = self.text.view.buf.text().len();
-        if len == 0 {
-            return;
+    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),
         }
-        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_px(PxVec2::from_f32(size))
-                .to_f32();
-        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)
+        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)
+                }
             }
-        };
-
-        self.text.selection = Some(selection);
-        self.text.double_hit = double_hit;
+            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);
+        }
     }
 
     pub fn deselect(&mut self) {
-        self.text.selection = None;
-        self.text.double_hit = None;
+        self.text.selection = TextSelection::None;
     }
 
     pub fn apply_event(&mut self, event: &KeyEvent, modifiers: &Modifiers) -> TextInputResult {
-        let old = (self.text.view.buf.text().to_string(), self.text.selection);
+        let old = (self.text.content(), self.text.selection);
         let mut undo = false;
         let res = self.apply_event_inner(event, modifiers, &mut undo);
-        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 {
+        if undo && let Some((old, selection)) = self.text.history.pop() {
+            self.set(&old);
+            self.text.selection = selection;
+        } else if self.text.content() != old.0 {
             self.text.history.push(old);
         }
         res
@@ -352,25 +481,21 @@ impl<'a> TextEditCtx<'a> {
                     }
                 }
                 NamedKey::ArrowRight => {
-                    let motion = if modifiers.control {
-                        Motion::RightWord
+                    if modifiers.control {
+                        self.motion(Motion::RightWord, modifiers.shift)
                     } else {
-                        Motion::Right
-                    };
-                    self.motion(motion, modifiers.shift);
+                        self.motion(Motion::Right, modifiers.shift)
+                    }
                 }
                 NamedKey::ArrowLeft => {
-                    let motion = if modifiers.control {
-                        Motion::LeftWord
+                    if modifiers.control {
+                        self.motion(Motion::LeftWord, modifiers.shift)
                     } else {
-                        Motion::Left
-                    };
-                    self.motion(motion, modifiers.shift);
+                        self.motion(Motion::Left, 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;
@@ -382,18 +507,34 @@ impl<'a> TextEditCtx<'a> {
                     match text.as_str() {
                         "v" => return TextInputResult::Paste,
                         "c" => {
-                            if let Some(content) = self.text.selected_text() {
+                            if let TextSelection::Span { start, end } = self.text.selection {
+                                let content = self.text.select_content(start, end);
                                 return TextInputResult::Copy(content);
                             }
                         }
                         "x" => {
-                            if let Some(content) = self.text.selected_text() {
+                            if let TextSelection::Span { start, end } = self.text.selection {
+                                let content = self.text.select_content(start, end);
                                 self.clear_span();
                                 return TextInputResult::Copy(content);
                             }
                         }
-                        "a" => self.select_all(),
-                        "z" => *undo = true,
+                        "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;
+                        }
                         _ => self.insert(text),
                     }
                 } else {
@@ -406,24 +547,6 @@ 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,
@@ -446,6 +569,33 @@ 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)
@@ -467,15 +617,15 @@ impl DerefMut for TextEdit {
 }
 
 pub trait TextEditable {
-    fn edit<'a>(&self, ui: &'a mut impl UiRsc) -> TextEditCtx<'a>;
+    fn edit<'a>(&self, ui: &'a mut impl HasUi) -> TextEditCtx<'a>;
 }
 
 impl<I: IdLike<Widget = TextEdit>> TextEditable for I {
-    fn edit<'a>(&self, ui: &'a mut impl UiRsc) -> TextEditCtx<'a> {
+    fn edit<'a>(&self, ui: &'a mut impl HasUi) -> TextEditCtx<'a> {
         let ui = ui.ui_mut();
         TextEditCtx {
             text: ui.widgets.get_mut(self).unwrap(),
-            data: &mut ui.text,
+            font_system: &mut ui.text.font_system,
         }
     }
 }

src/widget/text/mod.rs

@@ -6,32 +6,34 @@ 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,
 }
 
 pub struct TextView {
-    pub attrs: TextAttrs,
-    pub buf: TextBuffer,
-    pub hint: Option<StrongWidget>,
+    pub attrs: MutDetect<TextAttrs>,
+    pub buf: MutDetect<TextBuffer>,
+    // cache
+    tex: Option<RenderedText>,
+    width: Option<f32>,
+    pub hint: Option<WidgetHandle>,
 }
 
 impl TextView {
-    fn is_empty(&self) -> bool {
-        self.buf.is_empty()
-    }
-
-    pub fn wrap_width(&self) -> Option<f32> {
-        self.buf.wrap_width()
-    }
-}
-
-impl TextView {
-    pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option<StrongWidget>) -> Self {
-        Self { attrs, buf, hint }
+    pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option<WidgetHandle>) -> Self {
+        Self {
+            attrs: attrs.into(),
+            buf: buf.into(),
+            tex: None,
+            width: None,
+            hint,
+        }
     }
 
     /// region where the text should be draw
@@ -43,73 +45,133 @@ impl TextView {
             .align(self.align)
     }
 
-    /// The text shaped for the width it is drawn in. The buffer keeps its
-    /// answers under the attrs too, so changing those asks a new question
-    /// rather than invalidating anything.
-    fn render(&mut self, painter: &mut Painter) -> &RenderedText {
-        let width = self.attrs.wrap.then(|| painter.px_len(Axis::X));
-        // The shaper measures in floats, which is where a glyph advance comes
-        // from; what it answers goes back on the grid.
-        painter.render_text(&mut self.buf, &self.attrs, width.map(Px::to_f32));
-        if width.is_some() {
-            painter.holds(Axis::X, self.buf.width_holds());
-        }
-        self.buf.rendered().expect("render_text placed the glyphs")
+    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 {
+        let width = if self.attrs.wrap {
+            Some(ctx.px_size().x)
+        } else {
+            None
+        };
+        if width == self.width
+            && let Some(tex) = &self.tex
+            && !self.attrs.changed
+            && !self.buf.changed
+        {
+            return tex.clone();
+        }
+        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
+    }
     pub fn tex(&self) -> Option<&RenderedText> {
-        self.buf.rendered()
+        self.tex.as_ref()
     }
-    /// Draws the text, and says where the glyphs went and what they use.
-    pub fn draw(&mut self, painter: &mut Painter) -> (UiRegion, Size) {
-        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);
+    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)
         }
-
-        let tex = self.render(painter);
-        let region = tex.size.align(align);
-        // The step at or above what the shaper measured, so a parent that
-        // hands back the length this reports hands back a box the longest
-        // line fits in. Rounded to the nearest step it is half the time a
-        // hair under that line, and the break made in it is not the break a
-        // cold layout makes there.
-        let size = Size::from_px(PxVec2::ceil_from_f32(tex.size));
-        painter.glyphs(tex, DrawRegion::Extent(region));
-        (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)
+        }
+    }
+    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.text().to_string()
+        self.buf
+            .lines
+            .iter()
+            .map(|l| l.text())
+            .collect::<Vec<_>>()
+            .join("\n")
     }
 }
 
 impl Text {
     pub fn new(content: impl Into<String>) -> Self {
-        let content: String = content.into();
+        let attrs = TextAttrs::default();
+        let buf = TextBuffer::new_empty(Metrics::new(attrs.font_size, attrs.line_height));
         Self {
-            view: TextView::new(TextBuffer::new(&content), TextAttrs::default(), None),
-            content: content.into(),
+            content: content.into().into(),
+            view: TextView::new(buf, attrs, None),
         }
     }
-    fn update_buf(&mut self) {
+    fn update_buf(&mut self, ctx: &mut SizeCtx) {
         if self.content.changed {
             self.content.changed = false;
-            self.view.buf.set_text(self.content.as_str());
+            self.view.buf.set_text(
+                &mut ctx.text.font_system,
+                &self.content,
+                &Attrs::new().family(self.view.attrs.family),
+                SHAPING,
+                None,
+            );
         }
     }
 }
 
 impl Widget for Text {
-    fn draw(&mut self, painter: &mut Painter) -> Size {
-        self.update_buf();
-        self.view.draw(painter).1
+    fn draw(&mut self, painter: &mut Painter) {
+        self.update_buf(&mut painter.size_ctx());
+        self.view.draw(painter);
     }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.update_buf(ctx);
+        self.view.desired_width(ctx)
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        self.update_buf(ctx);
+        self.view.desired_height(ctx)
+    }
+}
+
+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 {