readme

Cargo.toml

@@ -1,19 +1,42 @@
 [package]
 name = "iris"
-version = "0.1.0"
+version.workspace = true
-edition = "2024"
+edition.workspace = true
-default-run = "test"
 
 # 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 }
+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"]
+
+[workspace.package]
+version = "0.1.0"
+edition = "2024"
+
+[workspace.dependencies]
 pollster = "0.4.0"
 winit = "0.30.12"
-wgpu = "27.0.1"
+wgpu = "28.0.0"
 bytemuck = "1.23.1"
 image = "0.25.6"
-cosmic-text = "0.15.0"
+cosmic-text = "0.16.0"
 unicode-segmentation = "1.12.0"
 fxhash = "0.2.1"
-arboard = { version = "3.6.1", features = ["wayland-data-control"] }
+arboard = "3.6.1"
-
+iris-core = { path = "core" }
+iris-macro = { path = "macro" }
+tokio = "1.49.0"

core/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "iris-core"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+winit = { workspace = true }
+wgpu = { workspace = true }
+bytemuck ={ workspace = true }
+image = { workspace = true }
+cosmic-text = { workspace = true }
+fxhash = { workspace = true }

core/src/attr.rs

@@ -0,0 +1,23 @@
+use crate::{UiRsc, WidgetIdFn, WidgetLike, WeakWidget};
+
+pub trait WidgetAttr<Rsc, W: ?Sized> {
+    type Input;
+    fn run(rsc: &mut Rsc, id: WeakWidget<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>;
+}
+
+impl<Rsc: UiRsc, WL: WidgetLike<Rsc, Tag>, Tag> Attrable<Rsc, WL::Widget, Tag> for WL {
+    fn attr<A: WidgetAttr<Rsc, WL::Widget>>(
+        self,
+        input: A::Input,
+    ) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        |rsc| {
+            let id = self.add(rsc);
+            A::run(rsc, id, input);
+            id
+        }
+    }
+}

core/src/event/ctx.rs

@@ -0,0 +1,18 @@
+use crate::{HasEvents, WeakWidget, Widget};
+
+pub struct EventCtx<'a, Rsc: HasEvents, Data> {
+    pub state: &'a mut Rsc::State,
+    pub data: Data,
+}
+
+pub struct EventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> {
+    pub widget: WeakWidget<W>,
+    pub state: &'a mut Rsc::State,
+    pub data: 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]
+    }
+}

core/src/event/manager.rs

@@ -0,0 +1,157 @@
+use crate::{
+    ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, HasEvents, IdLike, LayerId,
+    WeakWidget, WidgetEventFn, WidgetId,
+    util::{HashMap, HashSet, TypeMap},
+};
+use std::{any::TypeId, rc::Rc};
+
+pub struct EventManager<Rsc> {
+    widget_to_types: HashMap<WidgetId, HashSet<TypeId>>,
+    types: TypeMap<dyn EventManagerLike<Rsc>>,
+}
+
+impl<Rsc> Default for EventManager<Rsc> {
+    fn default() -> Self {
+        Self {
+            widget_to_types: Default::default(),
+            types: Default::default(),
+        }
+    }
+}
+
+impl<Rsc: HasEvents + 'static> EventManager<Rsc> {
+    pub fn get_type<E: EventLike>(&mut self) -> &mut TypeEventManager<Rsc, E::Event> {
+        self.types.type_or_default()
+    }
+
+    pub fn register<I: IdLike + 'static, E: EventLike>(
+        &mut self,
+        id: I,
+        event: E,
+        f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, I::Widget>,
+    ) {
+        let i = id.id();
+        self.get_type::<E>().register(id, event, f);
+        self.widget_to_types
+            .entry(i)
+            .or_default()
+            .insert(Self::type_key::<E>());
+    }
+
+    pub fn type_key<E: EventLike>() -> TypeId {
+        TypeId::of::<TypeEventManager<Rsc, E::Event>>()
+    }
+}
+
+pub trait EventsLike {
+    fn remove(&mut self, id: WidgetId);
+    fn draw(&mut self, active: &ActiveData);
+    fn undraw(&mut self, active: &ActiveData);
+}
+
+impl<Rsc: HasEvents + 'static> EventsLike for EventManager<Rsc> {
+    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);
+        }
+    }
+
+    fn draw(&mut self, active: &ActiveData) {
+        for t in self.widget_to_types.get(&active.id).into_flat_iter() {
+            self.types.get_mut(t).unwrap().draw(active);
+        }
+    }
+
+    fn undraw(&mut self, active: &ActiveData) {
+        for t in self.widget_to_types.get(&active.id).into_flat_iter() {
+            self.types.get_mut(t).unwrap().undraw(active);
+        }
+    }
+}
+
+pub trait EventManagerLike<State> {
+    fn remove(&mut self, id: WidgetId);
+    fn draw(&mut self, data: &ActiveData);
+    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> {
+    // TODO: reduce visiblity!!
+    pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
+    map: HashMap<WidgetId, Vec<EventData<Rsc, E>>>,
+}
+
+impl<Rsc: HasEvents, E: Event> EventManagerLike<Rsc> for TypeEventManager<Rsc, E> {
+    fn remove(&mut self, id: WidgetId) {
+        self.map.remove(&id);
+        for layer in self.active.values_mut() {
+            layer.remove(&id);
+        }
+    }
+    fn draw(&mut self, data: &ActiveData) {
+        self.active
+            .entry(data.layer)
+            .or_default()
+            .entry(data.id)
+            .or_default();
+    }
+    fn undraw(&mut self, data: &ActiveData) {
+        if let Some(layer) = self.active.get_mut(&data.layer) {
+            layer.remove(&data.id);
+        }
+    }
+}
+
+impl<Rsc: HasEvents, E: Event> Default for TypeEventManager<Rsc, E> {
+    fn default() -> Self {
+        Self {
+            active: Default::default(),
+            map: Default::default(),
+        }
+    }
+}
+
+impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
+    fn register<I: IdLike + 'static>(
+        &mut self,
+        widget: I,
+        event: impl EventLike<Event = E>,
+        f: impl for<'a> WidgetEventFn<Rsc, E::Data<'a>, I::Widget>,
+    ) {
+        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,
+                );
+            }),
+        ));
+    }
+
+    pub fn run_fn<'a>(
+        &mut self,
+        id: impl IdLike,
+    ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) + 'a {
+        let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
+        move |ctx, rsc| {
+            for (e, f) in fs {
+                if let Some(data) = e.should_run(&ctx.data) {
+                    f(
+                        EventCtx {
+                            state: ctx.state,
+                            data,
+                        },
+                        rsc,
+                    )
+                }
+            }
+        }
+    }
+}

core/src/event/mod.rs

@@ -0,0 +1,44 @@
+mod ctx;
+mod manager;
+mod rsc;
+
+pub use ctx::*;
+pub use manager::*;
+pub use rsc::*;
+
+pub trait Event: Sized + 'static + Clone {
+    type Data<'a>: Clone = ();
+    type State: Default = ();
+    #[allow(unused_variables)]
+    fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option<Self::Data<'a>> {
+        Some(data.clone())
+    }
+}
+
+pub trait EventLike {
+    type Event: Event;
+    fn into_event(self) -> Self::Event;
+}
+
+impl<E: Event> EventLike for E {
+    type Event = Self;
+
+    fn into_event(self) -> Self::Event {
+        self
+    }
+}
+
+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 WidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
+    Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
+{
+}
+impl<Rsc: HasEvents, F: Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static, Data, W: ?Sized>
+    WidgetEventFn<Rsc, Data, W> for F
+{
+}

core/src/event/rsc.rs

@@ -0,0 +1,34 @@
+use crate::{
+    Event, EventCtx, EventLike, EventManager, IdLike, UiRsc, WeakWidget, Widget, WidgetEventFn,
+};
+
+pub trait HasState: 'static {
+    type State;
+}
+
+pub trait HasEvents: Sized + UiRsc + HasState {
+    fn events(&self) -> &EventManager<Self>;
+    fn events_mut(&mut self) -> &mut EventManager<Self>;
+
+    fn register_event<W: Widget + ?Sized, E: EventLike>(
+        &mut self,
+        id: WeakWidget<W>,
+        event: E,
+        f: impl for<'a> WidgetEventFn<Self, <E::Event as Event>::Data<'a>, W>,
+    ) {
+        self.events_mut().register(id, event, f);
+    }
+}
+
+pub trait RunEvents: HasEvents {
+    fn run_event<E: EventLike>(
+        &mut self,
+        id: impl IdLike,
+        data: <E::Event as Event>::Data<'_>,
+        state: &mut Self::State,
+    ) {
+        let f = self.events_mut().get_type::<E>().run_fn(id);
+        f(EventCtx { state, data }, self)
+    }
+}
+impl<T: HasEvents> RunEvents for T {}

core/src/lib.rs

@@ -0,0 +1,36 @@
+#![feature(macro_metavar_expr_concat)]
+#![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)]
+
+mod attr;
+mod event;
+mod num;
+mod orientation;
+mod primitive;
+mod render;
+mod ui;
+mod widget;
+
+pub mod util;
+
+pub use attr::*;
+pub use event::*;
+pub use num::*;
+pub use orientation::*;
+pub use primitive::*;
+pub use render::*;
+pub use ui::*;
+pub use widget::*;
+
+pub type UiColor = primitive::Color<u8>;

core/src/num.rs

@@ -0,0 +1,49 @@
+use crate::util::Vec2;
+use std::marker::Destruct;
+
+pub const trait UiNum {
+    fn to_f32(self) -> f32;
+}
+
+impl const UiNum for f32 {
+    fn to_f32(self) -> f32 {
+        self
+    }
+}
+
+impl const UiNum for u32 {
+    fn to_f32(self) -> f32 {
+        self as f32
+    }
+}
+
+impl const UiNum for i32 {
+    fn to_f32(self) -> f32 {
+        self as f32
+    }
+}
+
+pub const fn vec2(x: impl const UiNum, y: impl const UiNum) -> Vec2 {
+    Vec2::new(x.to_f32(), y.to_f32())
+}
+
+impl<T: const UiNum + Copy> const From<T> for Vec2 {
+    fn from(v: T) -> Self {
+        Self {
+            x: v.to_f32(),
+            y: v.to_f32(),
+        }
+    }
+}
+
+impl<T: const UiNum, U: const UiNum> const From<(T, U)> for Vec2
+where
+    (T, U): const Destruct,
+{
+    fn from((x, y): (T, U)) -> Self {
+        Self {
+            x: x.to_f32(),
+            y: y.to_f32(),
+        }
+    }
+}

core/src/orientation/align.rs

@@ -1,4 +1,4 @@
-use crate::layout::vec2;
+use crate::vec2;
 
 use super::*;
 

core/src/orientation/axis.rs

@@ -68,3 +68,48 @@ impl Vec2 {
         }
     }
 }
+
+pub const trait AxisT {
+    fn get() -> Axis;
+}
+
+pub struct XAxis;
+impl const AxisT for XAxis {
+    fn get() -> Axis {
+        Axis::X
+    }
+}
+
+pub struct YAxis;
+impl const AxisT for YAxis {
+    fn get() -> Axis {
+        Axis::Y
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+pub struct BothAxis<T> {
+    pub x: T,
+    pub y: T,
+}
+
+impl<T> BothAxis<T> {
+    pub const fn axis<A: const AxisT>(&mut self) -> &mut T {
+        match A::get() {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+    pub fn take_axis<A: const AxisT>(self) -> T {
+        match A::get() {
+            Axis::X => self.x,
+            Axis::Y => self.y,
+        }
+    }
+    pub fn axis_dyn(&mut self, axis: Axis) -> &mut T {
+        match axis {
+            Axis::X => &mut self.x,
+            Axis::Y => &mut self.y,
+        }
+    }
+}

core/src/orientation/len.rs

@@ -1,5 +1,5 @@
 use super::*;
-use crate::{layout::UiNum, util::impl_op};
+use crate::{UiNum, util::impl_op};
 
 #[derive(Debug, Default, Clone, Copy, PartialEq)]
 pub struct Size {

core/src/orientation/mod.rs

@@ -3,7 +3,7 @@ mod axis;
 mod len;
 mod pos;
 
-use super::vec2::*;
+use crate::util::Vec2;
 
 pub use align::*;
 pub use axis::*;

core/src/orientation/pos.rs

@@ -2,7 +2,7 @@ use std::{fmt::Display, hash::Hash, marker::Destruct};
 
 use super::*;
 use crate::{
-    layout::UiNum,
+    UiNum,
     util::{LerpUtil, impl_op},
 };
 

core/src/primitive/color.rs

@@ -1,9 +1,9 @@
-#![allow(clippy::multiple_bound_locations)]
+use std::marker::Destruct;
 
 /// stored in linear for sane manipulation
 #[repr(C)]
 #[derive(Clone, Copy, Hash, PartialEq, Eq, bytemuck::Zeroable, Debug)]
-pub struct Color<T: ColorNum> {
+pub struct Color<T> {
     pub r: T,
     pub g: T,
     pub b: T,
@@ -56,23 +56,47 @@ pub trait ColorNum {
     const MAX: Self;
 }
 
-impl<T: ColorNum + F32Conversion> Color<T> {
+macro_rules! map_rgb {
-    pub fn mul_rgb(self, amt: impl F32Conversion) -> Self {
+    ($x:ident,$self:ident, $e:tt) => {
-        let amt = amt.to();
+        #[allow(unused_braces)]
-        self.map_rgb(|x| T::from(x.to() * amt))
+        Self {
+            r: {
+                let $x = $self.r;
+                $e
+            },
+            g: {
+                let $x = $self.g;
+                $e
+            },
+            b: {
+                let $x = $self.b;
+                $e
+            },
+            a: $self.a,
+        }
+    };
 }
 
-    pub fn add_rgb(self, amt: impl F32Conversion) -> Self {
+impl<T: ColorNum + const F32Conversion> Color<T>
+where
+    Self: const Destruct,
+{
+    pub const fn mul_rgb(self, amt: impl const F32Conversion) -> Self {
         let amt = amt.to();
-        self.map_rgb(|x| T::from(x.to() + amt))
+        map_rgb!(x, self, { T::from(x.to() * amt) })
     }
 
-    pub fn darker(self, amt: f32) -> Self {
+    pub const fn add_rgb(self, amt: impl const F32Conversion) -> Self {
+        let amt = amt.to();
+        map_rgb!(x, self, { T::from(x.to() + amt) })
+    }
+
+    pub const fn darker(self, amt: f32) -> Self {
         self.mul_rgb(1.0 - amt)
     }
 
-    pub fn brighter(self, amt: f32) -> Self {
+    pub const fn brighter(self, amt: f32) -> Self {
-        self.map_rgb(|x| {
+        map_rgb!(x, self, {
             let x = x.to();
             T::from(x + (1.0 - x) * amt)
         })

core/src/primitive/layer.rs

@@ -1,6 +1,11 @@
 use std::ops::{Index, IndexMut};
 
-use crate::render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives};
+use crate::{
+    render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives},
+    util::to_mut,
+};
+
+pub type LayerId = usize;
 
 struct LayerNode<T> {
     next: Ptr,
@@ -49,13 +54,13 @@ impl<T: Default> Layers<T> {
         self.vec.push(LayerNode::head());
     }
 
-    fn push(&mut self, node: LayerNode<T>) -> usize {
+    fn push(&mut self, node: LayerNode<T>) -> LayerId {
         let i = self.vec.len();
         self.vec.push(node);
         i
     }
 
-    pub fn next(&mut self, i: usize) -> usize {
+    pub fn next(&mut self, i: LayerId) -> LayerId {
         if let Ptr::Next(i) = self.vec[i].next {
             return i;
         }
@@ -75,7 +80,7 @@ impl<T: Default> Layers<T> {
         i_new
     }
 
-    pub fn child(&mut self, i: usize) -> usize {
+    pub fn child(&mut self, i: LayerId) -> LayerId {
         if let Some(c) = self.vec[i].child {
             return c.head;
         }
@@ -100,11 +105,11 @@ impl<T: Default> Layers<T> {
         self.vec.iter_mut().map(|n| &mut n.data).enumerate()
     }
 
-    pub fn iter(&self) -> impl Iterator<Item = (usize, &T)> {
+    pub fn iter(&self) -> impl Iterator<Item = (LayerId, &T)> {
         self.indices().map(|i| (i, &self.vec[i].data))
     }
 
-    pub fn iter_depth(&self) -> impl Iterator<Item = ((usize, usize), &T)> {
+    pub fn iter_depth(&self) -> impl Iterator<Item = ((LayerId, usize), &T)> {
         self.indices()
             .map(|i| ((i, self.vec[i].depth), &self.vec[i].data))
     }
@@ -115,7 +120,11 @@ impl<T: Default> Layers<T> {
 }
 
 impl PrimitiveLayers {
-    pub fn write<P: Primitive>(&mut self, layer: usize, info: PrimitiveInst<P>) -> PrimitiveHandle {
+    pub fn write<P: Primitive>(
+        &mut self,
+        layer: LayerId,
+        info: PrimitiveInst<P>,
+    ) -> PrimitiveHandle {
         self[layer].write(layer, info)
     }
 
@@ -130,16 +139,16 @@ impl<T: Default> Default for Layers<T> {
     }
 }
 
-impl<T> Index<usize> for Layers<T> {
+impl<T> Index<LayerId> for Layers<T> {
     type Output = T;
 
-    fn index(&self, index: usize) -> &Self::Output {
+    fn index(&self, index: LayerId) -> &Self::Output {
         &self.vec[index].data
     }
 }
 
-impl<T> IndexMut<usize> for Layers<T> {
+impl<T> IndexMut<LayerId> for Layers<T> {
-    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+    fn index_mut(&mut self, index: LayerId) -> &mut Self::Output {
         &mut self.vec[index].data
     }
 }
@@ -170,8 +179,7 @@ impl<'a, T> Iterator for LayerIteratorMut<'a, T> {
     fn next(&mut self) -> Option<Self::Item> {
         let i = self.inner.next()?;
         // SAFETY: requires index iterator to work properly
-        #[allow(mutable_transmutes)]
+        let layer = unsafe { to_mut(&self.inner.vec[i].data) };
-        let layer = unsafe { std::mem::transmute::<&T, &mut T>(&self.inner.vec[i].data) };
         Some((i, layer))
     }
 }
@@ -180,8 +188,7 @@ impl<'a, T> DoubleEndedIterator for LayerIteratorMut<'a, T> {
     fn next_back(&mut self) -> Option<Self::Item> {
         let i = self.inner.next_back()?;
         // SAFETY: requires index iterator to work properly
-        #[allow(mutable_transmutes)]
+        let layer = unsafe { to_mut(&self.inner.vec[i].data) };
-        let layer = unsafe { std::mem::transmute::<&T, &mut T>(&self.inner.vec[i].data) };
         Some((i, layer))
     }
 }

core/src/primitive/mod.rs

@@ -0,0 +1,9 @@
+mod color;
+mod layer;
+mod text;
+mod texture;
+
+pub use color::*;
+pub use layer::*;
+pub use text::*;
+pub use texture::*;

core/src/primitive/text.rs

@@ -1,11 +1,10 @@
-use std::simd::{Simd, num::SimdUint};
+use crate::{Align, RegionAlign, TextureHandle, Textures, UiColor, util::Vec2};
-
-use crate::layout::{Align, RegionAlign, TextureHandle, Textures, UiColor, Vec2};
 use cosmic_text::{
     Attrs, AttrsList, Buffer, CacheKey, Color, Family, FontSystem, Metrics, Placement, SwashCache,
     SwashContent,
 };
-use image::{GenericImageView, RgbaImage};
+use image::{DynamicImage, GenericImageView, RgbaImage};
+use std::simd::{Simd, num::SimdUint};
 
 /// TODO: properly wrap this
 pub mod text_lib {
@@ -59,7 +58,7 @@ pub type TextBuffer = Buffer;
 
 impl Default for TextAttrs {
     fn default() -> Self {
-        let size = 14.0;
+        let size = 16.0;
         Self {
             color: UiColor::WHITE,
             font_size: size,
@@ -186,3 +185,7 @@ pub struct RenderedText {
     pub top_left_offset: Vec2,
     pub size: Vec2,
 }
+
+pub trait HasTextures {
+    fn add_texture(&mut self, image: DynamicImage) -> TextureHandle;
+}

core/src/primitive/texture.rs

@@ -1,12 +1,13 @@
+use crate::{
+    render::TexturePrimitive,
+    util::{RefCounter, Vec2},
+};
+use image::{DynamicImage, GenericImageView};
 use std::{
     ops::Index,
     sync::mpsc::{Receiver, Sender, channel},
 };
 
-use image::{DynamicImage, GenericImageView};
-
-use crate::{layout::Vec2, render::TexturePrimitive, util::RefCounter};
-
 #[derive(Debug, Clone)]
 pub struct TextureHandle {
     inner: TexturePrimitive,

core/src/render/data.rs

@@ -1,4 +1,4 @@
-use crate::{layout::UiRegion, util::Id};
+use crate::{UiRegion, util::Id};
 use wgpu::*;
 
 #[repr(C)]

core/src/render/mod.rs

@@ -1,7 +1,7 @@
 use std::num::NonZero;
 
 use crate::{
-    layout::Ui,
+    UiData, UiRenderState,
     render::{data::PrimitiveInstance, texture::GpuTextures, util::ArrBuf},
     util::HashMap,
 };
@@ -59,12 +59,18 @@ impl UiRenderNode {
         }
     }
 
-    pub fn update(&mut self, device: &Device, queue: &Queue, ui: &mut Ui) {
+    pub fn update(
+        &mut self,
+        device: &Device,
+        queue: &Queue,
+        ui: &mut UiData,
+        ui_render: &mut UiRenderState,
+    ) {
         self.active.clear();
-        for (i, primitives) in ui.data.layers.iter_mut() {
+        for (i, primitives) in ui_render.layers.iter_mut() {
             self.active.push(i);
             for change in primitives.apply_free() {
-                if let Some(inst) = ui.data.active.get_mut(&change.id) {
+                if let Some(inst) = ui_render.active.get_mut(&change.id) {
                     for h in &mut inst.primitives {
                         if h.layer == i && h.inst_idx == change.old {
                             h.inst_idx = change.new;
@@ -101,10 +107,10 @@ impl UiRenderNode {
             }
         }
         let mut changed = false;
-        changed |= self.textures.update(&mut ui.data.textures);
+        changed |= self.textures.update(&mut ui.textures);
-        if ui.data.masks.changed {
+        if ui.masks.changed {
-            ui.data.masks.changed = false;
+            ui.masks.changed = false;
-            self.masks.update(device, queue, &ui.data.masks[..]);
+            self.masks.update(device, queue, &ui.masks[..]);
             changed = true;
         }
         if changed {
@@ -183,7 +189,7 @@ impl UiRenderNode {
         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: &[],
+            immediate_size: 0,
         });
         let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
             label: Some("UI Shape Pipeline"),
@@ -219,7 +225,7 @@ impl UiRenderNode {
                 mask: !0,
                 alpha_to_coverage_enabled: false,
             },
-            multiview: None,
+            multiview_mask: None,
             cache: None,
         });
 

core/src/render/primitive.rs

@@ -1,19 +1,18 @@
 use std::ops::{Deref, DerefMut};
 
 use crate::{
-    layout::{Color, UiRegion},
+    Color, UiRegion, WidgetId,
     render::{
         ArrBuf,
         data::{MaskIdx, PrimitiveInstance},
     },
-    util::Id,
 };
 use bytemuck::Pod;
 use wgpu::*;
 
 pub struct Primitives {
     instances: Vec<PrimitiveInstance>,
-    assoc: Vec<Id>,
+    assoc: Vec<WidgetId>,
     data: PrimitiveData,
     free: Vec<usize>,
     pub updated: bool,
@@ -99,7 +98,7 @@ macro_rules! primitives {
 }
 
 pub struct PrimitiveInst<P> {
-    pub id: Id,
+    pub id: WidgetId,
     pub primitive: P,
     pub region: UiRegion,
     pub mask_idx: MaskIdx,
@@ -175,7 +174,7 @@ impl Primitives {
 }
 
 pub struct PrimitiveChange {
-    pub id: Id,
+    pub id: WidgetId,
     pub old: usize,
     pub new: usize,
 }

core/src/render/texture.rs

@@ -1,7 +1,7 @@
 use image::{DynamicImage, EncodableLayout};
 use wgpu::{util::DeviceExt, *};
 
-use crate::layout::{TextureUpdate, Textures};
+use crate::{TextureUpdate, Textures};
 
 pub struct GpuTextures {
     device: Device,

core/src/ui/active.rs

@@ -0,0 +1,14 @@
+use crate::{LayerId, MaskIdx, PrimitiveHandle, TextureHandle, UiRegion, WidgetId};
+
+/// important non rendering data for retained drawing
+#[derive(Debug)]
+pub struct ActiveData {
+    pub id: WidgetId,
+    pub region: UiRegion,
+    pub parent: Option<WidgetId>,
+    pub textures: Vec<TextureHandle>,
+    pub primitives: Vec<PrimitiveHandle>,
+    pub children: Vec<WidgetId>,
+    pub mask: MaskIdx,
+    pub layer: LayerId,
+}

core/src/ui/cache.rs

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

core/src/ui/mod.rs

@@ -0,0 +1,47 @@
+use crate::{Mask, TextData, Textures, WeakWidget, WidgetId, Widgets, util::TrackedArena};
+
+mod active;
+mod cache;
+mod painter;
+mod render_state;
+mod size;
+
+pub use active::*;
+pub use painter::Painter;
+pub use render_state::*;
+pub use size::*;
+
+#[derive(Default)]
+pub struct UiData {
+    pub widgets: Widgets,
+    pub textures: Textures,
+    pub text: TextData,
+    pub masks: TrackedArena<Mask, u32>,
+}
+
+pub trait UiRsc {
+    fn ui(&self) -> &UiData;
+    fn ui_mut(&mut self) -> &mut UiData;
+
+    #[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 widgets(&self) -> &Widgets {
+        &self.ui().widgets
+    }
+    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);
+        }
+        self.ui_mut().textures.free();
+    }
+}

core/src/ui/painter.rs

@@ -0,0 +1,145 @@
+use crate::{
+    Axis, Len, RenderedText, Size, SizeCtx, StrongWidget, TextAttrs, TextBuffer, TextData,
+    TextureHandle, UiRegion, UiRenderState, UiRsc, Widget, WidgetId,
+    render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
+    util::Vec2,
+};
+
+/// makes your surfaces look pretty
+pub struct Painter<'a> {
+    pub(super) state: &'a mut UiRenderState,
+    pub(super) rsc: &'a mut dyn UiRsc,
+
+    pub(super) region: UiRegion,
+    pub(super) mask: MaskIdx,
+    pub(super) textures: Vec<TextureHandle>,
+    pub(super) primitives: Vec<PrimitiveHandle>,
+    pub(super) children: Vec<WidgetId>,
+    pub layer: usize,
+    pub(super) id: WidgetId,
+}
+
+impl<'a> Painter<'a> {
+    fn primitive_at<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+        let h = self.state.layers.write(
+            self.layer,
+            PrimitiveInst {
+                id: self.id,
+                primitive,
+                region,
+                mask_idx: self.mask,
+            },
+        );
+        if self.mask != MaskIdx::NONE {
+            // TODO: I have no clue if this works at all :joy:
+            self.rsc.ui_mut().masks.push_ref(self.mask);
+        }
+        self.primitives.push(h);
+    }
+
+    /// Writes a primitive to be rendered
+    pub fn primitive<P: Primitive>(&mut self, primitive: P) {
+        self.primitive_at(primitive, self.region)
+    }
+
+    pub fn primitive_within<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
+        self.primitive_at(primitive, region.within(&self.region));
+    }
+
+    pub fn set_mask(&mut self, region: UiRegion) {
+        assert!(self.mask == MaskIdx::NONE);
+        self.mask = self.rsc.ui_mut().masks.push(Mask { region });
+    }
+
+    /// Draws a widget within this widget's region.
+    pub fn widget<W: ?Sized>(&mut self, id: &StrongWidget<W>) {
+        self.widget_at(id, self.region);
+    }
+
+    /// Draws a widget somewhere within this one.
+    /// Useful for drawing child widgets in select areas.
+    pub fn widget_within<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) {
+        self.widget_at(id, region.within(&self.region));
+    }
+
+    fn widget_at<W: ?Sized>(&mut self, id: &StrongWidget<W>, region: UiRegion) {
+        self.children.push(id.id());
+        self.state.draw_inner(
+            self.layer,
+            id.id(),
+            region,
+            Some(self.id),
+            self.mask,
+            None,
+            self.rsc,
+        );
+    }
+
+    pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) {
+        self.textures.push(handle.clone());
+        self.primitive_at(handle.primitive(), region.within(&self.region));
+    }
+
+    pub fn texture(&mut self, handle: &TextureHandle) {
+        self.textures.push(handle.clone());
+        self.primitive(handle.primitive());
+    }
+
+    pub fn texture_at(&mut self, handle: &TextureHandle, region: UiRegion) {
+        self.textures.push(handle.clone());
+        self.primitive_at(handle.primitive(), region);
+    }
+
+    /// returns (handle, offset from top left)
+    pub fn render_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
+        let ui = self.rsc.ui_mut();
+        ui.text.draw(buffer, attrs, &mut ui.textures)
+    }
+
+    pub fn region(&self) -> UiRegion {
+        self.region
+    }
+
+    pub fn size<W: ?Sized + Widget>(&mut self, id: &StrongWidget<W>) -> Size {
+        self.size_ctx().size(id)
+    }
+
+    pub fn len_axis<W: ?Sized + Widget>(&mut self, id: &StrongWidget<W>, axis: Axis) -> Len {
+        match axis {
+            Axis::X => self.size_ctx().width(id),
+            Axis::Y => self.size_ctx().height(id),
+        }
+    }
+
+    pub fn output_size(&self) -> Vec2 {
+        self.state.output_size
+    }
+
+    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
+    }
+
+    pub fn child_layer(&mut self) {
+        self.layer = self.state.layers.child(self.layer);
+    }
+
+    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
+    }
+
+    pub fn id(&self) -> &WidgetId {
+        &self.id
+    }
+
+    pub fn size_ctx(&mut self) -> SizeCtx<'_> {
+        self.state.size_ctx(self.id, self.region.size(), self.rsc)
+    }
+}

core/src/ui/render_state.rs

@@ -0,0 +1,319 @@
+use crate::{
+    ActiveData, Axis, IdLike, MaskIdx, Painter, PixelRegion, PrimitiveLayers, SizeCtx,
+    StrongWidget, UiRegion, UiRsc, UiVec2, WidgetId, Widgets,
+    ui::cache::Cache,
+    util::{HashMap, HashSet, Vec2, forget_ref},
+};
+
+pub struct UiRenderState {
+    pub active: HashMap<WidgetId, ActiveData>,
+    pub layers: PrimitiveLayers,
+    pub(super) output_size: Vec2,
+    pub cache: Cache,
+
+    old_root: Option<WidgetId>,
+    resized: bool,
+    draw_started: HashSet<WidgetId>,
+}
+
+impl UiRenderState {
+    pub fn new() -> Self {
+        Self {
+            active: Default::default(),
+            layers: Default::default(),
+            cache: Default::default(),
+            output_size: Vec2::ZERO,
+            old_root: None,
+            resized: false,
+            draw_started: Default::default(),
+        }
+    }
+
+    pub fn resize(&mut self, size: impl Into<Vec2>) {
+        self.output_size = size.into();
+        self.resized = true;
+    }
+
+    pub fn update<'a>(&mut self, root: impl Into<Option<&'a StrongWidget>>, rsc: &mut dyn UiRsc) {
+        // safety mechanism for memory leaks; might wanna return a result instead so user can
+        // decide whether to panic or not
+        if !rsc.widgets().waiting.is_empty() {
+            let widgets = rsc.widgets();
+            let len = widgets.waiting.len();
+            let all: Vec<_> = widgets
+                .waiting
+                .iter()
+                .map(|&w| format!("'{}' ({w:?})", widgets.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:#?}"
+            );
+        }
+        let root = root.into();
+        if self.root_changed(root) || self.resized {
+            self.redraw_all(root, rsc);
+            self.old_root = root.map(|r| r.id());
+            self.resized = false;
+        } else if rsc.widgets().has_updates() {
+            self.redraw_updates(rsc);
+        }
+    }
+
+    fn redraw_all(&mut self, root: Option<&StrongWidget>, rsc: &mut dyn UiRsc) {
+        self.clear(rsc);
+        // free all resources & cache
+        if let Some(id) = root {
+            self.draw_inner(0, id.id(), UiRegion::FULL, None, MaskIdx::NONE, None, rsc);
+        }
+    }
+
+    // TODO: should prolly make a DrawInfo struct or smth for everything other than rsc
+    #[allow(clippy::too_many_arguments)]
+    pub(super) fn draw_inner(
+        &mut self,
+        layer: usize,
+        id: WidgetId,
+        region: UiRegion,
+        parent: Option<WidgetId>,
+        mask: MaskIdx,
+        old_children: Option<Vec<WidgetId>>,
+        rsc: &mut dyn UiRsc,
+    ) {
+        let mut old_children = old_children.unwrap_or_default();
+        if let Some(active) = self.active.get_mut(&id)
+            && !rsc.widgets().needs_redraw.contains(&id)
+        {
+            // check to see if we can skip drawing first
+            if active.region == region {
+                return;
+            } else if active.region.size() == region.size() {
+                // TODO: epsilon?
+                let from = active.region;
+                self.mov(id, from, region);
+                return;
+            }
+            // if not, then maintain resize and track old children to remove unneeded
+            let active = self.remove(id, false, rsc).unwrap();
+            old_children = active.children;
+        }
+
+        // draw widget
+        self.draw_started.insert(id);
+
+        let mut painter = Painter {
+            state: self,
+            region,
+            mask,
+            layer,
+            id,
+            textures: Vec::new(),
+            primitives: Vec::new(),
+            children: Vec::new(),
+            rsc,
+        };
+
+        let mut widget = painter.rsc.widgets().get_dyn_dynamic(id);
+        widget.draw(&mut painter);
+        drop(widget);
+
+        let Painter {
+            state: _,
+            rsc: _,
+            region,
+            mask,
+            textures,
+            primitives,
+            children,
+            layer,
+            id,
+        } = painter;
+
+        // add to active
+        let active = ActiveData {
+            id,
+            region,
+            parent,
+            textures,
+            primitives,
+            children,
+            mask,
+            layer,
+        };
+
+        // remove old children that weren't kept
+        for c in &old_children {
+            if !active.children.contains(c) {
+                self.remove_rec(*c, rsc);
+            }
+        }
+
+        rsc.on_draw(&active);
+        self.active.insert(id, active);
+    }
+
+    fn mov(&mut self, id: WidgetId, from: UiRegion, to: UiRegion) {
+        let active = self.active.get_mut(&id).unwrap();
+        for h in &active.primitives {
+            let region = self.layers[h.layer].region_mut(h);
+            *region = 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, rsc: &mut dyn UiRsc) -> 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 {
+                    rsc.ui_mut().masks.remove(mask);
+                }
+            }
+            active.textures.clear();
+            rsc.ui_mut().textures.free();
+            if undraw {
+                rsc.on_undraw(active);
+            }
+        }
+        active
+    }
+
+    fn remove_rec(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) -> Option<ActiveData> {
+        self.cache.remove(id);
+        let inst = self.remove(id, true, rsc);
+        if let Some(inst) = &inst {
+            for c in &inst.children {
+                self.remove_rec(*c, rsc);
+            }
+        }
+        inst
+    }
+
+    fn clear(&mut self, rsc: &mut dyn UiRsc) {
+        for (_, active) in self.active.drain() {
+            rsc.on_undraw(&active);
+        }
+        self.cache.clear();
+        self.layers.clear();
+        rsc.widgets_mut().needs_redraw.clear();
+        rsc.free();
+    }
+
+    pub fn redraw_updates(&mut self, rsc: &mut dyn UiRsc) {
+        while let Some(&id) = rsc.widgets().needs_redraw.iter().next() {
+            self.redraw(id, rsc);
+        }
+        rsc.free();
+    }
+
+    pub fn root_changed<'a>(&self, root: impl Into<Option<&'a StrongWidget>>) -> bool {
+        root.into().map(|r| r.id()) != self.old_root
+    }
+
+    pub fn needs_redraw<'a>(
+        &self,
+        root: impl Into<Option<&'a StrongWidget>>,
+        widgets: &Widgets,
+    ) -> bool {
+        self.root_changed(root) || widgets.has_updates()
+    }
+
+    pub fn active_widgets(&self) -> usize {
+        self.active.len()
+    }
+
+    pub fn debug(&self, widgets: &Widgets, label: &str) -> impl Iterator<Item = &ActiveData> {
+        self.active.iter().filter_map(move |(&id, inst)| {
+            let l = widgets.label(id);
+            if l == label { Some(inst) } else { None }
+        })
+    }
+
+    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);
+            }
+            println!();
+        }
+    }
+
+    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))
+    }
+
+    /// redraws a widget that's currently active (drawn)
+    pub fn redraw(&mut self, id: WidgetId, rsc: &mut dyn UiRsc) {
+        rsc.widgets_mut().needs_redraw.remove(&id);
+        self.draw_started.remove(&id);
+        // check if parent depends on the desired size of this, if so then redraw it first
+        for axis in [Axis::X, Axis::Y] {
+            if let Some(&(outer, old)) = self.cache.size.axis_dyn(axis).get(&id)
+                && let Some(current) = self.active.get(&id)
+                && let Some(pid) = current.parent
+            {
+                self.cache.size.axis_dyn(axis).remove(&id);
+                let new = self.size_ctx(id, outer, rsc).len_axis(id, axis);
+                self.cache.size.axis_dyn(axis).insert(id, (outer, new));
+                if new != old {
+                    self.redraw(pid, rsc);
+                }
+            }
+        }
+
+        if self.draw_started.contains(&id) {
+            return;
+        }
+
+        let Some(active) = self.remove(id, false, rsc) else {
+            return;
+        };
+
+        self.draw_inner(
+            active.layer,
+            id,
+            active.region,
+            active.parent,
+            active.mask,
+            Some(active.children),
+            rsc,
+        );
+    }
+
+    pub(super) fn size_ctx<'b>(
+        &'b mut self,
+        source: WidgetId,
+        outer: UiVec2,
+        rsc: &'b mut dyn UiRsc,
+    ) -> SizeCtx<'b> {
+        let ui = rsc.ui_mut();
+        SizeCtx {
+            source,
+            cache: &mut self.cache,
+            text: &mut ui.text,
+            textures: &mut ui.textures,
+            widgets: &ui.widgets,
+            outer,
+            output_size: self.output_size,
+            id: source,
+        }
+    }
+}
+
+impl Default for UiRenderState {
+    fn default() -> Self {
+        Self::new()
+    }
+}

core/src/ui/size.rs

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

core/src/util/mod.rs

@@ -0,0 +1,24 @@
+mod arena;
+mod borrow;
+mod change;
+mod id;
+mod math;
+mod refcount;
+mod slot;
+mod trust;
+mod typemap;
+mod vec2;
+
+pub use arena::*;
+pub use borrow::*;
+pub use change::*;
+pub use id::*;
+pub use math::*;
+pub use refcount::*;
+pub use slot::*;
+pub use trust::*;
+pub use typemap::*;
+pub use vec2::*;
+
+pub type HashMap<K, V> = fxhash::FxHashMap<K, V>;
+pub type HashSet<K> = fxhash::FxHashSet<K>;

core/src/util/refcount.rs

@@ -22,6 +22,12 @@ impl RefCounter {
     }
 }
 
+impl Default for RefCounter {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Clone for RefCounter {
     fn clone(&self) -> Self {
         self.0.fetch_add(1, Ordering::Release);

core/src/util/slot.rs

@@ -0,0 +1,69 @@
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct SlotId {
+    idx: u32,
+    genr: u32,
+}
+
+pub struct SlotVec<T> {
+    data: Vec<(u32, Option<T>)>,
+    free: Vec<u32>,
+}
+
+impl<T> SlotVec<T> {
+    pub fn new() -> Self {
+        Self {
+            data: Default::default(),
+            free: Default::default(),
+        }
+    }
+
+    pub fn add(&mut self, x: T) -> SlotId {
+        if let Some(idx) = self.free.pop() {
+            let (genr, data) = &mut self.data[idx as usize];
+            *data = Some(x);
+            SlotId { idx, genr: *genr }
+        } else {
+            let idx = self.data.len() as u32;
+            let genr = 0;
+            self.data.push((genr, Some(x)));
+            SlotId { idx, genr }
+        }
+    }
+
+    pub fn free(&mut self, id: SlotId) {
+        let (genr, data) = &mut self.data[id.idx as usize];
+        *genr += 1;
+        *data = None;
+        self.free.push(id.idx);
+    }
+
+    pub fn get(&self, id: SlotId) -> Option<&T> {
+        let slot = &self.data[id.idx as usize];
+        if slot.0 != id.genr {
+            return None;
+        }
+        slot.1.as_ref()
+    }
+
+    pub fn get_mut(&mut self, id: SlotId) -> Option<&mut T> {
+        let slot = &mut self.data[id.idx as usize];
+        if slot.0 != id.genr {
+            return None;
+        }
+        slot.1.as_mut()
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.len() - self.free.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<T> Default for SlotVec<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

core/src/util/trust.rs

@@ -0,0 +1,17 @@
+#[allow(clippy::missing_safety_doc)]
+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 unsafe fn to_mut<T>(x: &T) -> &mut T {
+    #[allow(mutable_transmutes)]
+    unsafe {
+        std::mem::transmute::<&T, &mut T>(x)
+    }
+}

core/src/util/typemap.rs

@@ -0,0 +1,56 @@
+use crate::util::HashMap;
+use std::{
+    any::TypeId,
+    marker::Unsize,
+    ops::{Deref, DerefMut},
+};
+
+pub struct TypeMap<Trait: ?Sized> {
+    map: HashMap<TypeId, Box<Trait>>,
+}
+
+impl<Trait: ?Sized> TypeMap<Trait> {
+    pub fn set_type<T: Unsize<Trait> + 'static>(&mut self, val: T) {
+        self.map
+            .insert(TypeId::of::<T>(), Box::new(val) as Box<Trait>);
+    }
+
+    pub fn type_mut<T: Unsize<Trait> + 'static>(&mut self) -> Option<&mut T> {
+        Some(Self::convert_mut(self.map.get_mut(&TypeId::of::<T>())?))
+    }
+
+    pub fn type_or_default<T: Default + Unsize<Trait> + 'static>(&mut self) -> &mut T {
+        Self::convert_mut(
+            self.map
+                .entry(TypeId::of::<T>())
+                .or_insert(Box::new(T::default()) as Box<Trait>),
+        )
+    }
+
+    fn convert_mut<T: Unsize<Trait>>(entry: &mut Box<Trait>) -> &mut T {
+        // allegedly this is just what Any does...
+        unsafe { &mut *(entry.as_mut() as *mut Trait as *mut T) }
+    }
+}
+
+impl<T: ?Sized> Deref for TypeMap<T> {
+    type Target = HashMap<TypeId, Box<T>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.map
+    }
+}
+
+impl<T: ?Sized> DerefMut for TypeMap<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.map
+    }
+}
+
+impl<T: ?Sized> Default for TypeMap<T> {
+    fn default() -> Self {
+        Self {
+            map: Default::default(),
+        }
+    }
+}

core/src/util/vec2.rs

@@ -1,8 +1,5 @@
-use crate::{
+use crate::util::{DivOr, impl_op};
-    layout::UiNum,
+use std::{hash::Hash, ops::*};
-    util::{DivOr, impl_op},
-};
-use std::{hash::Hash, marker::Destruct, ops::*};
 
 #[repr(C)]
 #[derive(Clone, Copy, PartialEq, Default, bytemuck::Pod, bytemuck::Zeroable)]
@@ -20,10 +17,6 @@ impl Hash for Vec2 {
     }
 }
 
-pub const fn vec2(x: impl const UiNum, y: impl const UiNum) -> Vec2 {
-    Vec2::new(x.to_f32(), y.to_f32())
-}
-
 impl Vec2 {
     pub const ZERO: Self = Self::new(0.0, 0.0);
     pub const ONE: Self = Self::new(1.0, 1.0);
@@ -68,15 +61,6 @@ impl Vec2 {
     }
 }
 
-impl<T: const UiNum + Copy> const From<T> for Vec2 {
-    fn from(v: T) -> Self {
-        Self {
-            x: v.to_f32(),
-            y: v.to_f32(),
-        }
-    }
-}
-
 // this version looks kinda cool... is it more readable? more annoying to copy and change though
 impl_op!(impl Add for Vec2: add x y);
 impl_op!(Vec2 Sub sub; x y);
@@ -102,18 +86,6 @@ impl Neg for Vec2 {
     }
 }
 
-impl<T: const UiNum, U: const UiNum> const From<(T, U)> for Vec2
-where
-    (T, U): const Destruct,
-{
-    fn from((x, y): (T, U)) -> Self {
-        Self {
-            x: x.to_f32(),
-            y: y.to_f32(),
-        }
-    }
-}
-
 impl std::fmt::Debug for Vec2 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "({}, {})", self.x, self.y)

core/src/widget/data.rs

@@ -0,0 +1,22 @@
+use crate::Widget;
+
+pub struct WidgetData {
+    pub widget: Box<dyn Widget>,
+    pub label: String,
+    /// dynamic borrow checking
+    pub borrowed: bool,
+}
+
+impl WidgetData {
+    pub fn new<W: Widget>(widget: W) -> Self {
+        let mut label = std::any::type_name::<W>().to_string();
+        if let (Some(first), Some(last)) = (label.find(":"), label.rfind(":")) {
+            label = label.split_at(first).0.to_string() + "::" + label.split_at(last + 1).1;
+        }
+        Self {
+            widget: Box::new(widget),
+            label,
+            borrowed: false,
+        }
+    }
+}

core/src/widget/handle.rs

@@ -0,0 +1,164 @@
+use std::{marker::Unsize, ops::CoerceUnsized, sync::mpsc::Sender};
+
+use crate::{
+    UiRsc, Widget,
+    util::{RefCounter, SlotId},
+};
+
+pub type WidgetId = SlotId;
+
+/// An identifier for a widget that can index a UI or event ctx to get it.
+/// This is a strong handle that does not impl Clone, and when it is dropped,
+/// 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(super) id: WidgetId,
+    counter: RefCounter,
+    send: Sender<WidgetId>,
+    ty: *const W,
+}
+
+/// 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(super) id: WidgetId,
+    #[allow(unused)]
+    ty: *const W,
+}
+
+impl<W: Widget + ?Sized + Unsize<dyn Widget>> StrongWidget<W> {
+    pub fn any(self) -> StrongWidget<dyn Widget> {
+        self
+    }
+}
+
+impl<W: ?Sized> StrongWidget<W> {
+    pub(crate) fn new(id: WidgetId, send: Sender<WidgetId>) -> Self {
+        Self {
+            id,
+            counter: RefCounter::new(),
+            send,
+            ty: null_ptr(),
+        }
+    }
+
+    pub fn id(&self) -> WidgetId {
+        self.id
+    }
+
+    pub fn refs(&self) -> u32 {
+        self.counter.refs()
+    }
+
+    pub fn weak(&self) -> WeakWidget<W> {
+        let Self { ty, id, .. } = *self;
+        WeakWidget { ty, id }
+    }
+}
+
+impl<W: ?Sized> WeakWidget<W> {
+    pub(crate) fn new(id: WidgetId) -> Self {
+        Self { id, ty: null_ptr() }
+    }
+
+    pub fn id(&self) -> WidgetId {
+        self.id
+    }
+
+    #[track_caller]
+    pub fn upgrade(self, ui: &mut impl UiRsc) -> StrongWidget<W> {
+        ui.widgets_mut().upgrade(self)
+    }
+}
+
+impl<W: ?Sized> Drop for StrongWidget<W> {
+    fn drop(&mut self) {
+        if self.counter.drop() {
+            let _ = self.send.send(self.id);
+        }
+    }
+}
+
+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 IdLike {
+    type Widget: ?Sized;
+    fn id(&self) -> WidgetId;
+}
+
+impl<W: ?Sized> IdLike for &StrongWidget<W> {
+    type Widget = W;
+    fn id(&self) -> WidgetId {
+        self.id
+    }
+}
+
+impl<W: ?Sized> IdLike for StrongWidget<W> {
+    type Widget = W;
+    fn id(&self) -> WidgetId {
+        self.id
+    }
+}
+
+impl<W: ?Sized> IdLike for WeakWidget<W> {
+    type Widget = W;
+    fn id(&self) -> WidgetId {
+        self.id
+    }
+}
+
+impl IdLike for WidgetId {
+    type Widget = dyn Widget;
+    fn id(&self) -> WidgetId {
+        *self
+    }
+}
+
+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<W: ?Sized> Clone for WeakWidget<W> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+impl<W: ?Sized> Copy for WeakWidget<W> {}
+impl<W: ?Sized> PartialEq for WeakWidget<W> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl<W> PartialEq for StrongWidget<W> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id == other.id
+    }
+}
+
+impl<W> std::fmt::Debug for StrongWidget<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> {
+    type Output = &'a mut W;
+
+    extern "rust-call" fn call_once(self, args: (&'a mut State,)) -> Self::Output {
+        &mut args.0.widgets_mut()[self]
+    }
+}
+
+fn null_ptr<W: ?Sized>() -> *const W {
+    if size_of::<&W>() == size_of::<*const dyn Widget>() {
+        let w: *const dyn Widget = &();
+        unsafe { std::mem::transmute_copy(&w) }
+    } else {
+        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

@@ -0,0 +1,75 @@
+use crate::UiRsc;
+
+use super::*;
+use std::marker::Unsize;
+
+pub trait WidgetLike<Rsc: UiRsc, Tag>: Sized {
+    type Widget: Widget + ?Sized + Unsize<dyn Widget>;
+
+    fn add(self, rsc: &mut Rsc) -> WeakWidget<Self::Widget>;
+
+    fn add_strong(self, rsc: &mut Rsc) -> StrongWidget<Self::Widget> {
+        self.add(rsc).upgrade(rsc)
+    }
+
+    fn with_id<W2>(
+        self,
+        f: impl FnOnce(&mut Rsc, WeakWidget<Self::Widget>) -> WeakWidget<W2>,
+    ) -> impl WidgetIdFn<Rsc, 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);
+    }
+}
+
+pub trait HasRoot {
+    fn set_root(&mut self, root: StrongWidget);
+}
+
+pub trait WidgetArrLike<Rsc, const LEN: usize, Tag> {
+    #[track_caller]
+    fn add(self, state: &mut Rsc) -> WidgetArr<LEN>;
+}
+
+impl<Rsc, const LEN: usize> WidgetArrLike<Rsc, LEN, ArrTag> for WidgetArr<LEN> {
+    fn add(self, _: &mut Rsc) -> WidgetArr<LEN> {
+        self
+    }
+}
+
+// variadic generics please save us
+macro_rules! impl_widget_arr {
+    ($n:expr;$($W:ident)*) => {
+        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> {
+                #[allow(non_snake_case)]
+                let ($($W,)*) = self;
+                WidgetArr::new(
+                    [$($W.add(rsc).upgrade(rsc),)*],
+                )
+            }
+        }
+    };
+}
+
+impl_widget_arr!(1;A);
+impl_widget_arr!(2;A B);
+impl_widget_arr!(3;A B C);
+impl_widget_arr!(4;A B C D);
+impl_widget_arr!(5;A B C D E);
+impl_widget_arr!(6;A B C D E F);
+impl_widget_arr!(7;A B C D E F G);
+impl_widget_arr!(8;A B C D E F G H);
+impl_widget_arr!(9;A B C D E F G H I);
+impl_widget_arr!(10;A B C D E F G H I J);
+impl_widget_arr!(11;A B C D E F G H I J K);
+impl_widget_arr!(12;A B C D E F G H I J K L);

core/src/widget/mod.rs

@@ -0,0 +1,87 @@
+use crate::{Axis, AxisT, Len, Painter, SizeCtx};
+use std::any::Any;
+
+mod data;
+mod handle;
+mod like;
+mod tag;
+mod view;
+mod widgets;
+
+pub use data::*;
+pub use handle::*;
+pub use like::*;
+pub use tag::*;
+pub use view::*;
+pub use widgets::*;
+
+pub trait Widget: Any {
+    fn draw(&mut self, painter: &mut Painter);
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len;
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len;
+}
+
+pub trait WidgetAxisFns {
+    fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len;
+}
+
+impl<W: Widget + ?Sized> WidgetAxisFns for W {
+    fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len {
+        match A::get() {
+            Axis::X => self.desired_width(ctx),
+            Axis::Y => self.desired_height(ctx),
+        }
+    }
+}
+
+impl Widget for () {
+    fn draw(&mut self, _: &mut Painter) {}
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::ZERO
+    }
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::ZERO
+    }
+}
+
+impl dyn Widget {
+    pub fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    pub fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+/// A function that returns a widget given a UI.
+/// Useful for defining trait functions on widgets that create a parent widget so that the children
+/// don't need to be IDs yet
+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],
+}
+
+impl<const LEN: usize> WidgetArr<LEN> {
+    pub fn new(arr: [StrongWidget; LEN]) -> Self {
+        Self { arr }
+    }
+}
+
+pub trait WidgetOption<State> {
+    fn get(self, state: &mut State) -> Option<StrongWidget>;
+}
+
+impl<State> WidgetOption<State> for () {
+    fn get(self, _: &mut State) -> Option<StrongWidget> {
+        None
+    }
+}
+
+impl<State, F: FnOnce(&mut State) -> Option<StrongWidget>> WidgetOption<State> for F {
+    fn get(self, state: &mut State) -> Option<StrongWidget> {
+        self(state)
+    }
+}

core/src/widget/tag.rs

@@ -0,0 +1,64 @@
+use super::*;
+use crate::UiRsc;
+use std::marker::Unsize;
+
+pub struct WidgetTag;
+impl<Rsc: UiRsc, W: Widget> WidgetLike<Rsc, 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
+    }
+}
+
+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>
+{
+    type Widget = W;
+    fn add(self, _: &mut Rsc) -> WeakWidget<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
+{
+    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()
+    }
+}
+
+pub struct ArrTag;

core/src/widget/view.rs

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

@@ -0,0 +1,145 @@
+use std::sync::mpsc::{Receiver, Sender, channel};
+
+use crate::{
+    IdLike, StrongWidget, WeakWidget, Widget, WidgetData, WidgetId,
+    util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut},
+};
+
+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();
+        Self {
+            needs_redraw: Default::default(),
+            vec: Default::default(),
+            waiting: Default::default(),
+            send,
+            recv,
+        }
+    }
+
+    pub fn has_updates(&self) -> bool {
+        !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> {
+        // 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())) };
+        if data.borrowed {
+            panic!("tried to mutably borrow the same widget twice");
+        }
+        WidgetWrapper::new(data.widget.as_mut(), &mut data.borrowed)
+    }
+
+    pub fn get<I: IdLike>(&self, id: &I) -> Option<&I::Widget>
+    where
+        I::Widget: Sized + Widget,
+    {
+        self.get_dyn(id.id())?.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()
+    }
+
+    pub fn add_strong<W: Widget>(&mut self, widget: W) -> StrongWidget<W> {
+        let id = self.vec.add(WidgetData::new(widget));
+        StrongWidget::new(id, self.send.clone())
+    }
+
+    pub fn add_weak<W: Widget>(&mut self, widget: W) -> WeakWidget<W> {
+        let id = self.vec.add(WidgetData::new(widget));
+        self.waiting.insert(id);
+        WeakWidget::new(id)
+    }
+
+    #[track_caller]
+    pub fn upgrade<W: ?Sized>(&mut self, rf: WeakWidget<W>) -> StrongWidget<W> {
+        if !self.waiting.remove(&rf.id()) {
+            let label = self.label(rf);
+            let id = rf.id();
+            panic!(
+                "widget '{label}' ({id:?}) was already added\ncannot add a widget twice; consider creating two"
+            )
+        }
+        StrongWidget::new(rf.id(), self.send.clone())
+    }
+
+    pub fn data(&self, id: impl IdLike) -> Option<&WidgetData> {
+        self.vec.get(id.id())
+    }
+
+    pub fn label(&self, id: impl IdLike) -> &String {
+        &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;
+    }
+
+    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)
+    }
+
+    #[allow(clippy::len_without_is_empty)]
+    pub fn len(&self) -> usize {
+        self.vec.len()
+    }
+}
+
+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,14 +1,21 @@
-use iris::{prelude::*, winit::*};
+use iris::prelude::*;
 
 fn main() {
     DefaultApp::<State>::run();
 }
 
-struct State;
+#[derive(DefaultUiState)]
+struct State {
+    ui_state: DefaultUiState,
+}
 
 impl DefaultAppState for State {
-    fn new(ui: &mut Ui, _state: &UiState, _proxy: Proxy<Self::Event>) -> Self {
+    fn new(
-        rect(Color::RED).set_root(ui);
+        mut ui_state: DefaultUiState,
-        Self
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
+        rect(Color::RED).set_root(rsc, &mut ui_state);
+        Self { ui_state }
     }
 }

examples/tabs/main.rs

@@ -1,23 +1,26 @@
 use cosmic_text::Family;
-use iris::{
+use std::{cell::RefCell, rc::Rc};
-    prelude::*,
-    winit::{attr::Selectable, event::Submit, *},
-};
-use len_fns::*;
 use winit::event::WindowEvent;
 
+use iris::prelude::*;
+type ClientRsc = DefaultRsc<Client>;
+
 fn main() {
     DefaultApp::<Client>::run();
 }
 
+#[derive(DefaultUiState)]
 pub struct Client {
-    info: WidgetId<Text>,
+    ui_state: DefaultUiState,
+    info: WeakWidget<Text>,
 }
 
-event_ctx!(Client);
-
 impl DefaultAppState for Client {
-    fn new(ui: &mut Ui, _state: &UiState, _proxy: Proxy<Self::Event>) -> Self {
+    fn new(
+        mut ui_state: DefaultUiState,
+        rsc: &mut DefaultRsc<Self>,
+        _: Proxy<Self::Event>,
+    ) -> Self {
         let rrect = rect(Color::WHITE).radius(20);
         let pad_test = (
             rrect.color(Color::BLUE),
@@ -40,7 +43,7 @@ impl DefaultAppState for Client {
                 .width(rest(3)),
         )
             .span(Dir::RIGHT)
-            .add(ui);
+            .add(rsc);
 
         let span_test = (
             rrect.color(Color::GREEN).width(100),
@@ -51,33 +54,30 @@ impl DefaultAppState for Client {
             rrect.color(Color::RED).width(100),
         )
             .span(Dir::LEFT)
-            .add(ui);
+            .add(rsc);
 
-        let span_add = Span::empty(Dir::RIGHT).add(ui);
+        let span_add = Span::empty(Dir::RIGHT).add(rsc);
-        let span_add_ = span_add.clone();
 
         let add_button = rect(Color::LIME)
             .radius(30)
-            .on(CursorSense::click(), move |ctx| {
+            .on(CursorSense::click(), move |_, rsc| {
-                let child = ctx
+                let child = image(include_bytes!("assets/sungals.png"))
-                    .ui
+                    .center()
-                    .add(image(include_bytes!("assets/sungals.png")).center())
+                    .add_strong(rsc);
-                    .any();
+                span_add(rsc).push(child);
-                ctx.ui[&span_add_].children.push(child);
             })
             .sized((150, 150))
             .align(Align::BOT_RIGHT);
 
-        let span_add_ = span_add.clone();
         let del_button = rect(Color::RED)
             .radius(30)
-            .on(CursorSense::click(), move |ctx| {
+            .on(CursorSense::click(), move |_, rsc| {
-                ctx.ui[&span_add_].children.pop();
+                span_add(rsc).pop();
             })
             .sized((150, 150))
             .align(Align::BOT_LEFT);
 
-        let span_add_test = (span_add, add_button, del_button).stack().add(ui);
+        let span_add_test = (span_add, add_button, del_button).stack().add(rsc);
 
         let btext = |content| wtext(content).size(30);
 
@@ -100,36 +100,40 @@ impl DefaultAppState for Client {
             wtext("pretty cool right?").size(50),
         )
             .span(Dir::DOWN)
-            .add(ui);
+            .add(rsc);
 
-        let texts = Span::empty(Dir::DOWN).gap(10).add(ui);
+        let texts = Span::empty(Dir::DOWN).gap(10).add(rsc);
-        let msg_area = texts.clone().scroll().masked().background(rect(Color::SKY));
+        let msg_area = texts.scrollable().masked().background(rect(Color::SKY));
         let add_text = wtext("add")
-            .editable(false)
+            .editable(EditMode::MultiLine)
             .text_align(Align::LEFT)
             .size(30)
             .attr::<Selectable>(())
-            .on(Submit, move |ctx| {
+            .on(Submit, move |ctx, rsc| {
-                let content = ctx.ui.text(ctx.id).take();
+                let w = ctx.widget;
+                let content = w.edit(rsc).take();
                 let text = wtext(content)
-                    .editable(false)
+                    .editable(EditMode::MultiLine)
                     .size(30)
                     .text_align(Align::LEFT)
                     .wrap(true)
                     .attr::<Selectable>(());
-                let msg_box = text.background(rect(Color::WHITE.darker(0.5))).add(ctx.ui);
+                let msg_box = text
-                ctx.ui[&texts].children.push(msg_box.any());
+                    .background(rect(Color::WHITE.darker(0.5)))
+                    .add_strong(rsc);
+                texts(rsc).push(msg_box);
             })
-            .add(ui);
+            .add(rsc);
+
         let text_edit_scroll = (
             msg_area.height(rest(1)),
             (
                 Rect::new(Color::WHITE.darker(0.9)),
                 (
-                    add_text.clone().width(rest(1)),
+                    add_text.width(rest(1)),
                     Rect::new(Color::GREEN)
-                        .on(CursorSense::click(), move |ctx| {
+                        .on(CursorSense::click(), move |ctx, rsc: &mut ClientRsc| {
-                            ctx.ui.run_event(ctx.state, &add_text, Submit, ());
+                            rsc.run_event::<Submit>(add_text, (), ctx.state);
                         })
                         .sized((40, 40)),
                 )
@@ -142,64 +146,80 @@ impl DefaultAppState for Client {
                 .align(Align::BOT),
         )
             .span(Dir::DOWN)
-            .add(ui);
+            .add(rsc);
 
-        let main = pad_test.clone().pad(10).add(ui);
+        let main = WidgetPtr::new().add(rsc);
 
-        let switch_button = |color, to: WidgetId, label| {
+        let vals = Rc::new(RefCell::new((0, Vec::new())));
-            let main_ = main.clone();
+        let mut switch_button = |color, to: WeakWidget, label| {
+            let to = to.upgrade(rsc);
+            let vec = &mut vals.borrow_mut().1;
+            let i = vec.len();
+            if vec.is_empty() {
+                vec.push(None);
+                main(rsc).set(to);
+            } else {
+                vec.push(Some(to));
+            }
+            let vals = vals.clone();
             let rect = rect(color)
-                .on(CursorSense::click(), move |ctx| {
+                .on(CursorSense::click(), move |ctx, rsc| {
-                    ctx.ui[&main_.clone()].inner = to.clone();
+                    let (prev, vec) = &mut *vals.borrow_mut();
-                    ctx.ui[ctx.id].color = color.darker(0.3);
+                    if let Some(h) = vec[i].take() {
+                        vec[*prev] = main(rsc).replace(h);
+                        *prev = i;
+                    }
+                    ctx.widget(rsc).color = color.darker(0.3);
                 })
                 .on(
                     CursorSense::HoverStart | CursorSense::unclick(),
-                    move |ctx| {
+                    move |ctx, rsc| {
-                        ctx.ui[ctx.id].color = color.brighter(0.2);
+                        ctx.widget(rsc).color = color.brighter(0.2);
                     },
                 )
-                .on(CursorSense::HoverEnd, move |ctx| {
+                .on(CursorSense::HoverEnd, move |ctx, rsc| {
-                    ctx.ui[ctx.id].color = color;
+                    ctx.widget(rsc).color = color;
                 });
             (rect, wtext(label).size(30).text_align(Align::CENTER)).stack()
         };
 
         let tabs = (
-            switch_button(Color::RED, pad_test.any(), "pad"),
+            switch_button(Color::RED, pad_test, "pad"),
-            switch_button(Color::GREEN, span_test.any(), "span"),
+            switch_button(Color::GREEN, span_test, "span"),
-            switch_button(Color::BLUE, span_add_test.any(), "image span"),
+            switch_button(Color::BLUE, span_add_test, "image span"),
-            switch_button(Color::MAGENTA, text_test.any(), "text layout"),
+            switch_button(Color::MAGENTA, text_test, "text layout"),
             switch_button(
                 Color::YELLOW.mul_rgb(0.5),
-                text_edit_scroll.any(),
+                text_edit_scroll,
                 "text edit scroll",
             ),
         )
             .span(Dir::RIGHT);
 
-        let info = wtext("").add(ui);
+        let info = wtext("").add(rsc);
-        let info_sect = info.clone().pad(10).align(Align::RIGHT);
+        let info_sect = info.pad(10).align(Align::RIGHT);
 
-        ((tabs.height(40), main).span(Dir::DOWN), info_sect)
+        ((tabs.height(40), main.pad(10)).span(Dir::DOWN), info_sect)
             .stack()
-            .set_root(ui);
+            .set_root(rsc, &mut ui_state);
 
-        Self { info }
+        Self { ui_state, info }
     }
 
-    fn window_event(&mut self, _: WindowEvent, ui: &mut Ui, state: &UiState) {
+    fn window_event(
+        &mut self,
+        _: WindowEvent,
+        rsc: &mut DefaultRsc<Self>,
+        render: &mut UiRenderState,
+    ) {
         let new = format!(
             "widgets: {}\nactive: {}\nviews: {}",
-            ui.num_widgets(),
+            rsc.widgets().len(),
-            ui.active_widgets(),
+            render.active_widgets(),
-            state.renderer.ui.view_count()
+            self.ui_state.renderer.ui.view_count(),
         );
-        if new != *ui[&self.info].content {
+        if new != *rsc.widgets()[self.info].content {
-            *ui[&self.info].content = new;
+            *rsc.widgets_mut()[self.info].content = new;
-        }
-        if ui.needs_redraw() {
-            state.window.request_redraw();
         }
     }
 }

examples/task.rs

@@ -0,0 +1,34 @@
+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::Event>,
+    ) -> Self {
+        let rect = rect(Color::RED).add(rsc);
+        rect.task_on(CursorSense::click(), async move |mut ctx| {
+            tokio::time::sleep(Duration::from_secs(1)).await;
+            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/view.rs

@@ -0,0 +1,53 @@
+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::Event>,
+    ) -> 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/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "iris-macro"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]
+proc-macro2 = "1.0.103"
+quote = "1.0.42"
+syn = { version = "2.0.111", features = ["full"] }
+
+[lib]
+proc-macro = true

macro/src/lib.rs

@@ -0,0 +1,196 @@
+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,
+    parse::{Parse, ParseStream, Result},
+    parse_macro_input, parse_quote,
+    spanned::Spanned,
+};
+
+struct Input {
+    attrs: Vec<Attribute>,
+    vis: Visibility,
+    name: Ident,
+    generics: Generics,
+    fns: Vec<InputFn>,
+}
+
+struct InputFn {
+    sig: Signature,
+    body: Block,
+}
+
+impl Parse for Input {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let attrs = input.call(Attribute::parse_outer)?;
+        let vis = input.parse()?;
+        input.parse::<Token![trait]>()?;
+        let name = input.parse()?;
+        let generics = input.parse::<Generics>()?;
+        input.parse::<Token![;]>()?;
+        let mut fns = Vec::new();
+        while !input.is_empty() {
+            let sig = input.parse()?;
+            let body = input.parse()?;
+            fns.push(InputFn { sig, body })
+        }
+        if !input.is_empty() {
+            input.error("function expected");
+        }
+        Ok(Input {
+            attrs,
+            vis,
+            name,
+            generics,
+            fns,
+        })
+    }
+}
+
+#[proc_macro]
+pub fn widget_trait(input: TokenStream) -> TokenStream {
+    let Input {
+        attrs,
+        vis,
+        name,
+        mut generics,
+        fns,
+    } = parse_macro_input!(input as Input);
+
+    let sigs: Vec<_> = fns.iter().map(|f| f.sig.clone()).collect();
+    let impls: Vec<_> = fns
+        .iter()
+        .map(|InputFn { sig, body }| quote! { #sig #body })
+        .collect();
+
+    let Some(GenericParam::Type(state)) = generics.params.first() else {
+        return Error::new(name.span(), "expected state generic parameter")
+            .into_compile_error()
+            .into();
+    };
+
+    let state = &state.ident;
+
+    generics
+        .params
+        .push(parse_quote!(WL: WidgetLike<#state, Tag>));
+    generics.params.push(parse_quote!(Tag));
+
+    let mut trai: ItemTrait = parse_quote!(
+        #vis trait #name #generics {
+            #(#sigs;)*
+        }
+    );
+
+    trai.attrs = attrs;
+
+    quote! {
+        #trai
+
+        impl #generics #name<Rsc, WL, Tag> for WL {
+            #(#impls)*
+        }
+    }
+    .into()
+}
+
+#[proc_macro_derive(DefaultUiState, attributes(default_ui_state))]
+pub fn derive_default_ui_state(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 {
+        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 {
+            continue;
+        };
+        if found_attr {
+            output.extend(
+                Error::new(
+                    attr.span(),
+                    "cannot have more than one default_ui_state attribute",
+                )
+                .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
+            }
+            fn default_state_mut(&mut self) -> &mut iris::default::DefaultUiState {
+                &mut self.#fname
+            }
+        }
+    });
+    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();
+    };
+    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()
+}

readme.md

@@ -1,22 +1,25 @@
 # iris
 
-my take on a rust ui library (also my first ui library)
+My experimental attempt at a rust ui library (also my first ui library).
 
-it's called iris because it's the structure around what you actually want to display and colorful
+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.
 
-there's a `main.rs` that runs a testing window, so can just `cargo run` to see it working
+Examples are in `examples`, eg. `cargo run --example tabs`.
 
-goals, in general order:
+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)
+3. reasonably fast / efficient (a lot faster than electron, save battery life, try to beat iced and xilem)
 
-not targeting web rn cause wanna use actual nice gpu features & entire point of this is to make desktop apps
+## dev details
+
+not targeting web rn cause wanna use actual nice gpu features & entire point of this is to make desktop apps / not need a web browser
 
 general ideas trynna use rn / experiment with:
 - retained mode
-- specifically designed around wgpu
+- specifically designed around wgpu so there's no translation
 - postfix functions for most things to prevent unreadable indentation (going very well)
+- events can be done directly where you draw the widgets
 - almost no macros in user code & actual LSP typechecking (variadic generics if you can hear me please save us)
 - relative anchor + absolute offset coord system (+ "rest" / leftover during widget layout)
 - single threaded ui & pass context around to make non async usage straightforward (pretty unsure about this)
@@ -24,3 +27,5 @@ general ideas trynna use rn / experiment with:
 
 under heavy initial development so not gonna try to explain status, maybe check TODO for that;
 sizable chance it gets a rewrite once I know everything I need and what seems to work best
+
+it's called iris because it's the structure around what you actually want to display and colorful

src/core/ptr.rs

@@ -1,30 +0,0 @@
-use crate::prelude::*;
-
-#[derive(Default)]
-pub struct WidgetPtr {
-    pub inner: Option<WidgetId>,
-}
-
-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
-        }
-    }
-}

src/core/sense.rs

@@ -1,395 +0,0 @@
-use crate::prelude::*;
-
-use std::{
-    ops::{BitOr, Deref, DerefMut},
-    rc::Rc,
-};
-
-use crate::{
-    layout::{UiModule, UiRegion, Vec2},
-    util::{HashMap, Id},
-};
-
-#[derive(Clone, Copy, PartialEq)]
-pub enum Button {
-    Left,
-    Right,
-    Middle,
-}
-
-#[derive(Clone, Copy, PartialEq)]
-pub enum CursorSense {
-    PressStart(Button),
-    Pressing(Button),
-    PressEnd(Button),
-    HoverStart,
-    Hovering,
-    HoverEnd,
-    Scroll,
-}
-
-pub struct CursorSenses(Vec<CursorSense>);
-
-impl CursorSense {
-    pub fn click() -> Self {
-        Self::PressStart(Button::Left)
-    }
-    pub fn click_or_drag() -> CursorSenses {
-        Self::click() | Self::Pressing(Button::Left)
-    }
-    pub fn unclick() -> Self {
-        Self::PressEnd(Button::Left)
-    }
-    pub fn is_dragging(&self) -> bool {
-        matches!(self, CursorSense::Pressing(Button::Left))
-    }
-}
-
-#[derive(Default, Clone)]
-pub struct CursorState {
-    pub pos: Vec2,
-    pub exists: bool,
-    pub buttons: CursorButtons,
-    pub scroll_delta: Vec2,
-}
-
-#[derive(Default, Clone)]
-pub struct CursorButtons {
-    pub left: ActivationState,
-    pub middle: ActivationState,
-    pub right: ActivationState,
-}
-
-impl CursorButtons {
-    pub fn select(&self, button: &Button) -> &ActivationState {
-        match button {
-            Button::Left => &self.left,
-            Button::Right => &self.right,
-            Button::Middle => &self.middle,
-        }
-    }
-
-    pub fn end_frame(&mut self) {
-        self.left.end_frame();
-        self.middle.end_frame();
-        self.right.end_frame();
-    }
-}
-
-impl CursorState {
-    pub fn end_frame(&mut self) {
-        self.buttons.end_frame();
-        self.scroll_delta = Vec2::ZERO;
-    }
-}
-
-#[derive(Debug, Clone, Copy, Default, PartialEq)]
-pub enum ActivationState {
-    Start,
-    On,
-    End,
-    #[default]
-    Off,
-}
-
-/// this and other similar stuff has a generic
-/// because I kind of want to make CursorModule generic
-/// 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, Data> {
-    pub senses: CursorSenses,
-    pub f: Rc<dyn EventFn<Ctx, Data>>,
-}
-
-pub type SensorMap<Ctx, Data> = HashMap<Id, SensorGroup<Ctx, Data>>;
-pub type SenseShape = UiRegion;
-pub struct SensorGroup<Ctx, Data> {
-    pub hover: ActivationState,
-    pub sensors: Vec<Sensor<Ctx, Data>>,
-}
-
-#[derive(Clone)]
-pub struct CursorData {
-    pub cursor: Vec2,
-    pub size: Vec2,
-    pub scroll_delta: Vec2,
-    /// the (first) sense that triggered this event
-    /// the senses are checked in order
-    pub sense: CursorSense,
-}
-
-pub struct CursorModule<Ctx> {
-    map: SensorMap<Ctx, CursorData>,
-    active: HashMap<usize, HashMap<Id, SenseShape>>,
-}
-
-impl<Ctx: 'static> UiModule for CursorModule<Ctx> {
-    fn on_draw(&mut self, inst: &WidgetInstance) {
-        if self.map.contains_key(&inst.id) {
-            self.active
-                .entry(inst.layer)
-                .or_default()
-                .insert(inst.id, inst.region);
-        }
-    }
-
-    fn on_undraw(&mut self, inst: &WidgetInstance) {
-        if let Some(layer) = self.active.get_mut(&inst.layer) {
-            layer.remove(&inst.id);
-        }
-    }
-
-    fn on_remove(&mut self, id: &Id) {
-        self.map.remove(id);
-        for layer in self.active.values_mut() {
-            layer.remove(id);
-        }
-    }
-
-    fn on_move(&mut self, inst: &WidgetInstance) {
-        if let Some(map) = self.active.get_mut(&inst.layer)
-            && let Some(region) = map.get_mut(&inst.id)
-        {
-            *region = inst.region;
-        }
-    }
-}
-
-impl<Ctx> CursorModule<Ctx> {
-    pub fn merge(&mut self, other: Self) {
-        for (id, group) in other.map {
-            for sensor in group.sensors {
-                self.map.entry(id).or_default().sensors.push(sensor);
-            }
-        }
-    }
-}
-
-impl Ui {
-    pub fn run_sensors<Ctx: 'static>(
-        &mut self,
-        ctx: &mut Ctx,
-        cursor: &CursorState,
-        window_size: Vec2,
-    ) {
-        CursorModule::<Ctx>::run(self, ctx, cursor, window_size);
-    }
-}
-
-impl<Ctx: 'static> CursorModule<Ctx> {
-    pub fn run(ui: &mut Ui, ctx: &mut Ctx, cursor: &CursorState, window_size: Vec2) {
-        let layers = std::mem::take(&mut ui.data.layers);
-        let mut module = std::mem::take(ui.data.modules.get_mut::<Self>());
-
-        for i in layers.indices().rev() {
-            let Some(list) = module.active.get_mut(&i) else {
-                continue;
-            };
-            let mut sensed = false;
-            for (id, shape) in list.iter() {
-                let group = module.map.get_mut(id).unwrap();
-                let region = shape.to_px(window_size);
-                let in_shape = cursor.exists && region.contains(cursor.pos);
-                group.hover.update(in_shape);
-                if group.hover == ActivationState::Off {
-                    continue;
-                }
-                sensed = true;
-
-                for sensor in &mut group.sensors {
-                    if let Some(sense) = should_run(&sensor.senses, cursor, group.hover) {
-                        let data = CursorData {
-                            cursor: cursor.pos - region.top_left,
-                            size: region.bot_right - region.top_left,
-                            scroll_delta: cursor.scroll_delta,
-                            sense,
-                        };
-                        (sensor.f)(EventCtx { ui, state: ctx, data });
-                    }
-                }
-            }
-            if sensed {
-                break;
-            }
-        }
-
-        let ui_mod = ui.data.modules.get_mut::<Self>();
-        std::mem::swap(ui_mod, &mut module);
-        ui_mod.merge(module);
-        ui.data.layers = layers;
-    }
-}
-
-pub fn should_run(
-    senses: &CursorSenses,
-    cursor: &CursorState,
-    hover: ActivationState,
-) -> Option<CursorSense> {
-    for sense in senses.iter() {
-        if match sense {
-            CursorSense::PressStart(button) => cursor.buttons.select(button).is_start(),
-            CursorSense::Pressing(button) => cursor.buttons.select(button).is_on(),
-            CursorSense::PressEnd(button) => cursor.buttons.select(button).is_end(),
-            CursorSense::HoverStart => hover.is_start(),
-            CursorSense::Hovering => hover.is_on(),
-            CursorSense::HoverEnd => hover.is_end(),
-            CursorSense::Scroll => cursor.scroll_delta != Vec2::ZERO,
-        } {
-            return Some(*sense);
-        }
-    }
-    None
-}
-
-impl ActivationState {
-    pub fn is_start(&self) -> bool {
-        *self == Self::Start
-    }
-    pub fn is_on(&self) -> bool {
-        *self == Self::Start || *self == Self::On
-    }
-    pub fn is_end(&self) -> bool {
-        *self == Self::End
-    }
-    pub fn is_off(&self) -> bool {
-        *self == Self::End || *self == Self::Off
-    }
-    pub fn update(&mut self, on: bool) {
-        *self = match *self {
-            Self::Start => match on {
-                true => Self::On,
-                false => Self::End,
-            },
-            Self::On => match on {
-                true => Self::On,
-                false => Self::End,
-            },
-            Self::End => match on {
-                true => Self::Start,
-                false => Self::Off,
-            },
-            Self::Off => match on {
-                true => Self::Start,
-                false => Self::Off,
-            },
-        }
-    }
-
-    pub fn end_frame(&mut self) {
-        match self {
-            Self::Start => *self = Self::On,
-            Self::End => *self = Self::Off,
-            _ => (),
-        }
-    }
-}
-
-impl Event for CursorSenses {
-    type Module<Ctx: 'static> = CursorModule<Ctx>;
-    type Data = CursorData;
-}
-
-impl Event for CursorSense {
-    type Module<Ctx: 'static> = CursorModule<Ctx>;
-    type Data = CursorData;
-}
-
-impl<E: Event<Data = <CursorSenses as Event>::Data> + Into<CursorSenses>, Ctx: 'static>
-    EventModule<E, Ctx> for CursorModule<Ctx>
-{
-    fn register(&mut self, id: Id, senses: E, f: impl EventFn<Ctx, <E as Event>::Data>) {
-        // TODO: does not add to active if currently active
-        self.map.entry(id).or_default().sensors.push(Sensor {
-            senses: senses.into(),
-            f: Rc::new(f),
-        });
-    }
-
-    fn run<'a>(
-        &self,
-        id: &Id,
-        event: E,
-    ) -> Option<impl Fn(EventCtx<Ctx, <E as Event>::Data>) + use<'a, E, Ctx>> {
-        let senses = event.into();
-        if let Some(group) = self.map.get(id) {
-            let fs: Vec<_> = group
-                .sensors
-                .iter()
-                .filter_map(|sensor| {
-                    if sensor.senses.iter().any(|s| senses.contains(s)) {
-                        Some(sensor.f.clone())
-                    } else {
-                        None
-                    }
-                })
-                .collect();
-            Some(move |ctx: EventCtx<Ctx, CursorData>| {
-                for f in &fs {
-                    f(EventCtx {
-                        state: ctx.state,
-                        ui: ctx.ui,
-                        data: ctx.data.clone(),
-                    });
-                }
-            })
-        } else {
-            None
-        }
-    }
-}
-
-impl<Ctx, Data> Default for SensorGroup<Ctx, Data> {
-    fn default() -> Self {
-        Self {
-            hover: Default::default(),
-            sensors: Default::default(),
-        }
-    }
-}
-
-impl Deref for CursorSenses {
-    type Target = Vec<CursorSense>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for CursorSenses {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-impl From<CursorSense> for CursorSenses {
-    fn from(val: CursorSense) -> Self {
-        CursorSenses(vec![val])
-    }
-}
-
-impl BitOr for CursorSense {
-    type Output = CursorSenses;
-
-    fn bitor(self, rhs: Self) -> Self::Output {
-        CursorSenses(vec![self, rhs])
-    }
-}
-
-impl BitOr<CursorSense> for CursorSenses {
-    type Output = Self;
-
-    fn bitor(mut self, rhs: CursorSense) -> Self::Output {
-        self.0.push(rhs);
-        self
-    }
-}
-
-impl<Ctx> Default for CursorModule<Ctx> {
-    fn default() -> Self {
-        Self {
-            map: Default::default(),
-            active: Default::default(),
-        }
-    }
-}

src/core/trait_fns.rs

@@ -1,160 +0,0 @@
-use super::*;
-use crate::prelude::*;
-
-// these methods should "not require any context" (require unit) because they're in core
-event_ctx!(());
-
-pub trait CoreWidget<W, Tag> {
-    fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Pad>;
-    fn align(self, align: impl Into<Align>) -> impl WidgetFn<Aligned>;
-    fn center(self) -> impl WidgetFn<Aligned>;
-    fn label(self, label: impl Into<String>) -> impl WidgetIdFn<W>;
-    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Sized>;
-    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Sized>;
-    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Sized>;
-    fn max_width(self, width: impl Into<Len>) -> impl WidgetFn<MaxSize>;
-    fn max_height(self, height: impl Into<Len>) -> impl WidgetFn<MaxSize>;
-    fn offset(self, amt: impl Into<UiVec2>) -> impl WidgetFn<Offset>;
-    fn scroll(self) -> impl WidgetIdFn<Scroll>;
-    fn masked(self) -> impl WidgetFn<Masked>;
-    fn background<T>(self, w: impl WidgetLike<T>) -> impl WidgetFn<Stack>;
-    fn foreground<T>(self, w: impl WidgetLike<T>) -> impl WidgetFn<Stack>;
-    fn layer_offset(self, offset: usize) -> impl WidgetFn<LayerOffset>;
-    fn to_any(self) -> impl WidgetRet;
-}
-
-impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
-    fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Pad> {
-        |ui| Pad {
-            padding: padding.into(),
-            inner: self.add(ui).any(),
-        }
-    }
-
-    fn align(self, align: impl Into<Align>) -> impl WidgetFn<Aligned> {
-        move |ui| Aligned {
-            inner: self.add(ui).any(),
-            align: align.into(),
-        }
-    }
-
-    fn center(self) -> impl WidgetFn<Aligned> {
-        self.align(Align::CENTER)
-    }
-
-    fn label(self, label: impl Into<String>) -> impl WidgetIdFn<W::Widget> {
-        |ui| {
-            let id = self.add(ui);
-            ui.set_label(&id, label.into());
-            id
-        }
-    }
-
-    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Sized> {
-        let size = size.into();
-        move |ui| Sized {
-            inner: self.add(ui).any(),
-            x: Some(size.x),
-            y: Some(size.y),
-        }
-    }
-
-    fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<MaxSize> {
-        let len = len.into();
-        move |ui| MaxSize {
-            inner: self.add(ui).any(),
-            x: Some(len),
-            y: None,
-        }
-    }
-
-    fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<MaxSize> {
-        let len = len.into();
-        move |ui| MaxSize {
-            inner: self.add(ui).any(),
-            x: None,
-            y: Some(len),
-        }
-    }
-
-    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Sized> {
-        let len = len.into();
-        move |ui| Sized {
-            inner: self.add(ui).any(),
-            x: Some(len),
-            y: None,
-        }
-    }
-
-    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Sized> {
-        let len = len.into();
-        move |ui| Sized {
-            inner: self.add(ui).any(),
-            x: None,
-            y: Some(len),
-        }
-    }
-
-    fn offset(self, amt: impl Into<UiVec2>) -> impl WidgetFn<Offset> {
-        move |ui| Offset {
-            inner: self.add(ui).any(),
-            amt: amt.into(),
-        }
-    }
-
-    fn scroll(self) -> impl WidgetIdFn<Scroll> {
-        move |ui| {
-            Scroll::new(self.add(ui).any(), Axis::Y)
-                .on(CursorSense::Scroll, |ctx| {
-                    let s = &mut ctx.ui[ctx.id];
-                    s.scroll(ctx.data.scroll_delta.y * 50.0);
-                })
-                .add(ui)
-        }
-    }
-
-    fn masked(self) -> impl WidgetFn<Masked> {
-        move |ui| Masked {
-            inner: self.add(ui).any(),
-        }
-    }
-
-    fn background<T>(self, w: impl WidgetLike<T>) -> impl WidgetFn<Stack> {
-        move |ui| Stack {
-            children: vec![w.add(ui).any(), self.add(ui).any()],
-            size: StackSize::Child(1),
-        }
-    }
-
-    fn foreground<T>(self, w: impl WidgetLike<T>) -> impl WidgetFn<Stack> {
-        move |ui| Stack {
-            children: vec![self.add(ui).any(), w.add(ui).any()],
-            size: StackSize::Child(0),
-        }
-    }
-
-    fn layer_offset(self, offset: usize) -> impl WidgetFn<LayerOffset> {
-        move |ui| LayerOffset {
-            inner: self.add(ui).any(),
-            offset,
-        }
-    }
-
-    fn to_any(self) -> impl WidgetRet {
-        |ui| self.add(ui).any()
-    }
-}
-
-pub trait CoreWidgetArr<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> {
-    fn span(self, dir: Dir) -> SpanBuilder<LEN, Wa, Tag>;
-    fn stack(self) -> StackBuilder<LEN, Wa, Tag>;
-}
-
-impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> CoreWidgetArr<LEN, Wa, Tag> for Wa {
-    fn span(self, dir: Dir) -> SpanBuilder<LEN, Wa, Tag> {
-        SpanBuilder::new(self, dir)
-    }
-    fn stack(self) -> StackBuilder<LEN, Wa, Tag> {
-        StackBuilder::new(self)
-    }
-}

src/default/app.rs

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

@@ -0,0 +1,78 @@
+use crate::prelude::*;
+use std::time::{Duration, Instant};
+use winit::dpi::{LogicalPosition, LogicalSize};
+
+pub struct Selector;
+
+impl<Rsc: HasEvents, W: Widget + 'static> WidgetAttr<Rsc, W> for Selector
+where
+    Rsc::State: HasDefaultUiState,
+{
+    type Input = WeakWidget<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();
+            let id_pos = region.top_left;
+            let container_pos = ctx.data.render.window_region(&container).unwrap().top_left;
+            let pos = ctx.data.pos + container_pos - id_pos;
+            let size = region.size();
+            select(
+                rsc,
+                ctx.data.render,
+                ctx.state,
+                id,
+                pos,
+                size,
+                ctx.data.sense.is_dragging(),
+            );
+        });
+    }
+}
+
+pub struct Selectable;
+
+impl<Rsc: HasEvents> WidgetAttr<Rsc, TextEdit> for Selectable
+where
+    Rsc::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| {
+            select(
+                rsc,
+                ctx.data.render,
+                ctx.state,
+                id,
+                ctx.data.pos,
+                ctx.data.size,
+                ctx.data.sense.is_dragging(),
+            );
+        });
+    }
+}
+
+fn select(
+    rsc: &mut impl UiRsc,
+    render: &UiRenderState,
+    state: &mut impl HasDefaultUiState,
+    id: WeakWidget<TextEdit>,
+    pos: Vec2,
+    size: Vec2,
+    dragging: bool,
+) {
+    let state = state.default_state_mut();
+    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) {
+        state.window.set_ime_allowed(true);
+        state.window.set_ime_cursor_area(
+            LogicalPosition::<f32>::from(region.top_left.tuple()),
+            LogicalSize::<f32>::from(region.size().tuple()),
+        );
+    }
+    state.focus = Some(id);
+}

src/default/event.rs

@@ -0,0 +1,9 @@
+use iris_core::Event;
+
+#[derive(Eq, PartialEq, Hash, Clone)]
+pub struct Submit;
+impl Event for Submit {}
+
+#[derive(Eq, PartialEq, Hash, Clone)]
+pub struct Edited;
+impl Event for Edited {}

src/default/input.rs

@@ -1,8 +1,4 @@
-use crate::{
+use crate::prelude::*;
-    core::{CursorState, Modifiers},
-    layout::Vec2,
-    winit::UiState,
-};
 use winit::{
     event::{MouseButton, MouseScrollDelta, WindowEvent},
     keyboard::{Key, NamedKey},
@@ -70,7 +66,7 @@ impl Input {
     }
 }
 
-impl UiState {
+impl DefaultUiState {
     pub fn window_size(&self) -> Vec2 {
         let size = self.renderer.window().inner_size();
         (size.width, size.height).into()

src/default/mod.rs

@@ -0,0 +1,354 @@
+use crate::prelude::*;
+use arboard::Clipboard;
+use std::{
+    marker::{PhantomData, Sized},
+    sync::Arc,
+    time::Instant,
+};
+use winit::{
+    event::{Ime, WindowEvent},
+    event_loop::{ActiveEventLoop, EventLoopProxy},
+    window::{Window, WindowAttributes},
+};
+
+mod app;
+mod attr;
+mod event;
+mod input;
+mod render;
+mod sense;
+mod state;
+mod task;
+
+pub use app::*;
+pub use attr::*;
+pub use event::*;
+pub use input::*;
+pub use render::*;
+pub use sense::*;
+pub use state::*;
+pub use task::*;
+
+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 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(),
+            clipboard: Clipboard::new().unwrap(),
+            ime: 0,
+            last_click: Instant::now(),
+            focus: None,
+        }
+    }
+}
+
+pub trait HasDefaultUiState: Sized + 'static {
+    fn default_state(&self) -> &DefaultUiState;
+    fn default_state_mut(&mut self) -> &mut DefaultUiState;
+}
+
+pub trait DefaultAppState: HasDefaultUiState {
+    type Event = ();
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self::Event>)
+    -> Self;
+    #[allow(unused_variables)]
+    fn event(
+        &mut self,
+        event: Self::Event,
+        rsc: &mut DefaultRsc<Self>,
+        render: &mut UiRenderState,
+    ) {
+    }
+    #[allow(unused_variables)]
+    fn exit(&mut self, rsc: &mut DefaultRsc<Self>, render: &mut UiRenderState) {}
+    #[allow(unused_variables)]
+    fn window_event(
+        &mut self,
+        event: WindowEvent,
+        rsc: &mut DefaultRsc<Self>,
+        render: &mut UiRenderState,
+    ) {
+    }
+    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> {
+    fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Self>) {
+        let (tasks, recv) = Tasks::init(window);
+        (
+            Self {
+                ui: Default::default(),
+                events: Default::default(),
+                tasks,
+                state: Default::default(),
+                _state: Default::default(),
+            },
+            recv,
+        )
+    }
+
+    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,
+    task_recv: TaskMsgReceiver<DefaultRsc<State>>,
+}
+
+impl<State: DefaultAppState> AppState for DefaultApp<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, task_recv) = DefaultRsc::init(default_state.window.clone());
+        let state = State::new(default_state, &mut rsc, proxy);
+        let render = UiRenderState::new();
+        Self {
+            rsc,
+            state,
+            render,
+            task_recv,
+        }
+    }
+
+    fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
+        self.state.event(event, &mut self.rsc, &mut self.render);
+    }
+
+    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
+        let Self {
+            rsc,
+            render,
+            state,
+            task_recv,
+        } = self;
+
+        for update in task_recv.try_iter() {
+            update(state, rsc);
+        }
+
+        let ui_state = state.default_state_mut();
+        let input_changed = ui_state.input.event(&event);
+        let cursor_state = ui_state.cursor_state().clone();
+        let old = ui_state.focus;
+        if cursor_state.buttons.left.is_start() {
+            ui_state.focus = None;
+        }
+        if input_changed {
+            let window_size = ui_state.window_size();
+            render.run_sensors(rsc, state, cursor_state, window_size);
+        }
+        let ui_state = state.default_state_mut();
+        if old != ui_state.focus
+            && let Some(old) = old
+        {
+            old.edit(rsc).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_state.renderer.draw();
+            }
+            WindowEvent::Resized(size) => {
+                render.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);
+                    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);
+                        }
+                        TextInputResult::Paste => {
+                            if let Ok(t) = ui_state.clipboard.get_text() {
+                                text.insert(&t);
+                            }
+                            rsc.run_event::<Edited>(sel, (), state);
+                        }
+                        TextInputResult::Copy(text) => {
+                            if let Err(err) = ui_state.clipboard.set_text(text) {
+                                eprintln!("failed to copy text to clipboard: {err}")
+                            }
+                        }
+                        TextInputResult::Used => {
+                            rsc.run_event::<Edited>(sel, (), state);
+                        }
+                        TextInputResult::Unused => {}
+                    }
+                }
+            }
+            WindowEvent::Ime(ime) => {
+                if let Some(sel) = ui_state.focus {
+                    let mut text = sel.edit(rsc);
+                    match ime {
+                        Ime::Enabled | Ime::Disabled => (),
+                        Ime::Preedit(content, _pos) => {
+                            // TODO: highlight once that's real
+                            text.replace(ui_state.ime, content);
+                            ui_state.ime = content.chars().count();
+                        }
+                        Ime::Commit(content) => {
+                            text.insert(content);
+                        }
+                    }
+                }
+            }
+            _ => (),
+        }
+        state.window_event(event, rsc, render);
+        let ui_state = self.state.default_state_mut();
+        if render.needs_redraw(&ui_state.root, rsc.widgets()) {
+            ui_state.renderer.window().request_redraw();
+        }
+        ui_state.input.end_frame();
+    }
+
+    fn exit(&mut self) {
+        self.state.exit(&mut self.rsc, &mut self.render);
+    }
+}
+
+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)
+    }
+}

src/default/render.rs

@@ -1,10 +1,7 @@
-use crate::{
+use iris_core::{UiData, UiLimits, UiRenderNode, UiRenderState};
-    layout::Ui,
-    render::{UiLimits, UiRenderNode},
-};
 use pollster::FutureExt;
 use std::sync::Arc;
-use wgpu::{util::StagingBelt, *};
+use wgpu::*;
 use winit::{dpi::PhysicalSize, window::Window};
 
 pub const CLEAR_COLOR: Color = Color::BLACK;
@@ -16,13 +13,12 @@ pub struct UiRenderer {
     queue: Queue,
     config: SurfaceConfiguration,
     encoder: CommandEncoder,
-    staging_belt: StagingBelt,
     pub ui: UiRenderNode,
 }
 
 impl UiRenderer {
-    pub fn update(&mut self, updates: &mut Ui) {
+    pub fn update(&mut self, ui: &mut UiData, render: &mut UiRenderState) {
-        self.ui.update(&self.device, &self.queue, updates);
+        self.ui.update(&self.device, &self.queue, ui, render);
     }
 
     pub fn draw(&mut self) {
@@ -49,9 +45,7 @@ impl UiRenderer {
         }
 
         self.queue.submit(std::iter::once(encoder.finish()));
-        self.staging_belt.finish();
         output.present();
-        self.staging_belt.recall();
     }
 
     pub fn resize(&mut self, size: &PhysicalSize<u32>) {
@@ -72,7 +66,6 @@ impl UiRenderer {
 
         let instance = Instance::new(&InstanceDescriptor {
             backends: Backends::PRIMARY,
-            flags: InstanceFlags::empty(),
             ..Default::default()
         });
 
@@ -122,7 +115,7 @@ impl UiRenderer {
             format: surface_format,
             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![],
@@ -130,10 +123,9 @@ impl UiRenderer {
 
         surface.configure(&device, &config);
 
-        let staging_belt = StagingBelt::new(4096 * 4);
         let encoder = Self::create_encoder(&device);
 
-        let shape_pipeline = UiRenderNode::new(&device, &queue, &config, ui_limits);
+        let ui = UiRenderNode::new(&device, &queue, &config, ui_limits);
 
         Self {
             surface,
@@ -141,8 +133,7 @@ impl UiRenderer {
             queue,
             config,
             encoder,
-            staging_belt,
+            ui,
-            ui: shape_pipeline,
             window,
         }
     }

src/default/sense.rs

@@ -0,0 +1,308 @@
+use crate::prelude::*;
+use std::{
+    ops::{BitOr, Deref, DerefMut},
+    rc::Rc,
+};
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum CursorButton {
+    Left,
+    Right,
+    Middle,
+}
+
+#[derive(Clone, Copy, PartialEq)]
+pub enum CursorSense {
+    PressStart(CursorButton),
+    Pressing(CursorButton),
+    PressEnd(CursorButton),
+    HoverStart,
+    Hovering,
+    HoverEnd,
+    Scroll,
+}
+
+#[derive(Clone)]
+pub struct CursorSenses(Vec<CursorSense>);
+
+impl Event for CursorSenses {
+    type Data<'a> = CursorData<'a>;
+    type State = SensorState;
+    fn should_run<'a>(&self, data: &Self::Data<'a>) -> Option<Self::Data<'a>> {
+        if let Some(sense) = should_run(self, &data.cursor, data.hover) {
+            let mut data = data.clone();
+            data.sense = sense;
+            Some(data)
+        } else {
+            None
+        }
+    }
+}
+
+impl CursorSense {
+    pub fn click() -> Self {
+        Self::PressStart(CursorButton::Left)
+    }
+    pub fn click_or_drag() -> CursorSenses {
+        Self::click() | Self::Pressing(CursorButton::Left)
+    }
+    pub fn unclick() -> Self {
+        Self::PressEnd(CursorButton::Left)
+    }
+    pub fn is_dragging(&self) -> bool {
+        matches!(self, CursorSense::Pressing(CursorButton::Left))
+    }
+}
+
+#[derive(Default, Clone)]
+pub struct CursorState {
+    pub pos: Vec2,
+    pub exists: bool,
+    pub buttons: CursorButtons,
+    pub scroll_delta: Vec2,
+}
+
+#[derive(Default, Clone)]
+pub struct CursorButtons {
+    pub left: ActivationState,
+    pub middle: ActivationState,
+    pub right: ActivationState,
+}
+
+impl CursorButtons {
+    pub fn select(&self, button: &CursorButton) -> &ActivationState {
+        match button {
+            CursorButton::Left => &self.left,
+            CursorButton::Right => &self.right,
+            CursorButton::Middle => &self.middle,
+        }
+    }
+
+    pub fn end_frame(&mut self) {
+        self.left.end_frame();
+        self.middle.end_frame();
+        self.right.end_frame();
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (CursorButton, &ActivationState)> {
+        [
+            CursorButton::Left,
+            CursorButton::Middle,
+            CursorButton::Right,
+        ]
+        .into_iter()
+        .map(|b| (b, self.select(&b)))
+    }
+}
+
+impl CursorState {
+    pub fn end_frame(&mut self) {
+        self.buttons.end_frame();
+        self.scroll_delta = Vec2::ZERO;
+    }
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq)]
+pub enum ActivationState {
+    Start,
+    On,
+    End,
+    #[default]
+    Off,
+}
+
+/// this and other similar stuff has a generic
+/// because I kind of want to make CursorModule generic
+/// 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 senses: CursorSenses,
+    pub f: Rc<dyn EventFn<Ctx, Data>>,
+}
+
+pub type SenseShape = UiRegion;
+
+#[derive(Default, Debug)]
+pub struct SensorState {
+    pub hover: ActivationState,
+}
+
+#[derive(Clone)]
+pub struct CursorData<'a> {
+    /// where this widget was hit
+    pub pos: Vec2,
+    pub size: Vec2,
+    pub scroll_delta: Vec2,
+    pub hover: ActivationState,
+    pub cursor: 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,
+        window_size: Vec2,
+    );
+}
+
+impl SensorUi for UiRenderState {
+    fn run_sensors<Rsc: HasEvents>(
+        &self,
+        rsc: &mut Rsc,
+        state: &mut Rsc::State,
+        cursor: CursorState,
+        window_size: Vec2,
+    ) {
+        // in order to remove this take, need to store active list in UiRenderState somehow
+        // this would probably be done through a generic parameter that adds yet another rsc /
+        // state like thing, but local to render state, and is passed to UiRsc events so you can
+        // update it there?
+        let mut active = std::mem::take(&mut rsc.events_mut().get_type::<CursorSense>().active);
+        for layer in self.layers.indices().rev() {
+            let mut sensed = false;
+            for (id, sensor) in active.get_mut(&layer).into_flat_iter() {
+                let shape = self.active.get(id).unwrap().region;
+                let region = shape.to_px(window_size);
+                let in_shape = cursor.exists && region.contains(cursor.pos);
+                sensor.hover.update(in_shape);
+                if sensor.hover == ActivationState::Off {
+                    continue;
+                }
+                sensed = true;
+
+                let cursor = cursor.clone();
+
+                let data = CursorData {
+                    pos: cursor.pos - region.top_left,
+                    size: region.bot_right - region.top_left,
+                    scroll_delta: cursor.scroll_delta,
+                    hover: sensor.hover,
+                    cursor,
+                    // this does not have any meaning;
+                    // might wanna set up Event to have a prepare stage
+                    sense: CursorSense::Hovering,
+                    render: self,
+                };
+                rsc.run_event::<CursorSense>(*id, data, state);
+            }
+            if sensed {
+                break;
+            }
+        }
+        rsc.events_mut().get_type::<CursorSense>().active = active;
+    }
+}
+
+pub fn should_run(
+    senses: &CursorSenses,
+    cursor: &CursorState,
+    hover: ActivationState,
+) -> Option<CursorSense> {
+    for sense in senses.iter() {
+        if match sense {
+            CursorSense::PressStart(button) => cursor.buttons.select(button).is_start(),
+            CursorSense::Pressing(button) => cursor.buttons.select(button).is_on(),
+            CursorSense::PressEnd(button) => cursor.buttons.select(button).is_end(),
+            CursorSense::HoverStart => hover.is_start(),
+            CursorSense::Hovering => hover.is_on(),
+            CursorSense::HoverEnd => hover.is_end(),
+            CursorSense::Scroll => cursor.scroll_delta != Vec2::ZERO,
+        } {
+            return Some(*sense);
+        }
+    }
+    None
+}
+
+impl ActivationState {
+    pub fn is_start(&self) -> bool {
+        *self == Self::Start
+    }
+    pub fn is_on(&self) -> bool {
+        *self == Self::Start || *self == Self::On
+    }
+    pub fn is_end(&self) -> bool {
+        *self == Self::End
+    }
+    pub fn is_off(&self) -> bool {
+        *self == Self::End || *self == Self::Off
+    }
+    pub fn update(&mut self, on: bool) {
+        *self = match *self {
+            Self::Start => match on {
+                true => Self::On,
+                false => Self::End,
+            },
+            Self::On => match on {
+                true => Self::On,
+                false => Self::End,
+            },
+            Self::End => match on {
+                true => Self::Start,
+                false => Self::Off,
+            },
+            Self::Off => match on {
+                true => Self::Start,
+                false => Self::Off,
+            },
+        }
+    }
+
+    pub fn end_frame(&mut self) {
+        match self {
+            Self::Start => *self = Self::On,
+            Self::End => *self = Self::Off,
+            _ => (),
+        }
+    }
+}
+
+impl EventLike for CursorSense {
+    type Event = CursorSenses;
+    fn into_event(self) -> Self::Event {
+        self.into()
+    }
+}
+
+impl Deref for CursorSenses {
+    type Target = Vec<CursorSense>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for CursorSenses {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl From<CursorSense> for CursorSenses {
+    fn from(val: CursorSense) -> Self {
+        CursorSenses(vec![val])
+    }
+}
+
+impl BitOr for CursorSense {
+    type Output = CursorSenses;
+
+    fn bitor(self, rhs: Self) -> Self::Output {
+        CursorSenses(vec![self, rhs])
+    }
+}
+
+impl BitOr<CursorSense> for CursorSenses {
+    type Output = Self;
+
+    fn bitor(mut self, rhs: CursorSense) -> Self::Output {
+        self.0.push(rhs);
+        self
+    }
+}

src/default/state.rs

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

@@ -0,0 +1,82 @@
+use iris_core::HasState;
+use std::{
+    pin::Pin,
+    sync::{
+        Arc,
+        mpsc::{Receiver as SyncReceiver, Sender as SyncSender, channel as sync_channel},
+    },
+};
+use tokio::{
+    runtime::Runtime,
+    sync::mpsc::{
+        UnboundedReceiver as AsyncReceiver, UnboundedSender as AsyncSender,
+        unbounded_channel as async_channel,
+    },
+};
+use winit::window::Window;
+
+pub type TaskMsgSender<Rsc> = SyncSender<Box<dyn TaskUpdate<Rsc>>>;
+pub type TaskMsgReceiver<Rsc> = SyncReceiver<Box<dyn TaskUpdate<Rsc>>>;
+
+pub trait TaskUpdate<Rsc: HasState>: FnOnce(&mut Rsc::State, &mut Rsc) + Send {}
+impl<F: FnOnce(&mut Rsc::State, &mut Rsc) + Send, Rsc: HasState> TaskUpdate<Rsc> for F {}
+
+pub struct Tasks<Rsc: HasState> {
+    start: AsyncSender<BoxTask>,
+    window: Arc<Window>,
+    msg_send: SyncSender<Box<dyn TaskUpdate<Rsc>>>,
+}
+
+pub struct TaskCtx<Rsc: HasState> {
+    send: TaskMsgSender<Rsc>,
+}
+
+impl<Rsc: HasState> TaskCtx<Rsc> {
+    pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
+        let _ = self.send.send(Box::new(f));
+    }
+}
+impl<Rsc: HasState + 'static> TaskCtx<Rsc> {
+    fn new(send: TaskMsgSender<Rsc>) -> Self {
+        Self { send }
+    }
+}
+
+type BoxTask = Pin<Box<dyn Future<Output = ()> + Send>>;
+
+impl<Rsc: HasState> Tasks<Rsc> {
+    pub fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Rsc>) {
+        let (start, start_recv) = async_channel();
+        let (msgs, msgs_recv) = sync_channel();
+        std::thread::spawn(|| {
+            let rt = Runtime::new().unwrap();
+            rt.block_on(listen(start_recv))
+        });
+        (
+            Self {
+                start,
+                msg_send: msgs,
+                window,
+            },
+            msgs_recv,
+        )
+    }
+
+    pub fn spawn<F: AsyncFnOnce(TaskCtx<Rsc>) + 'static + std::marker::Send>(&mut self, task: F)
+    where
+        F::CallOnceFuture: Send,
+    {
+        let send = self.msg_send.clone();
+        let window = self.window.clone();
+        let _ = self.start.send(Box::pin(async move {
+            task(TaskCtx::new(send)).await;
+            window.request_redraw();
+        }));
+    }
+}
+
+async fn listen(mut recv: AsyncReceiver<BoxTask>) {
+    while let Some(task) = recv.recv().await {
+        tokio::spawn(task);
+    }
+}

src/event.rs

@@ -0,0 +1,87 @@
+use iris_core::*;
+use iris_macro::*;
+use std::sync::Arc;
+
+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 {
+                        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
+        }
+    }
+}
+
+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/layout/attr.rs

@@ -1,20 +0,0 @@
-use crate::layout::{Ui, WidgetId, WidgetIdFn, WidgetLike};
-
-pub trait WidgetAttr<W> {
-    type Input;
-    fn run(ui: &mut Ui, id: &WidgetId<W>, input: Self::Input);
-}
-
-pub trait Attrable<W, Tag> {
-    fn attr<A: WidgetAttr<W>>(self, input: A::Input) -> impl WidgetIdFn<W>;
-}
-
-impl<WL: WidgetLike<Tag>, Tag> Attrable<WL::Widget, Tag> for WL {
-    fn attr<A: WidgetAttr<WL::Widget>>(self, input: A::Input) -> impl WidgetIdFn<WL::Widget> {
-        |ui| {
-            let id = self.add(ui);
-            A::run(ui, &id, input);
-            id
-        }
-    }
-}

src/layout/data.rs

@@ -1,27 +0,0 @@
-use std::any::{Any, TypeId};
-
-use crate::util::{HashMap, Id};
-
-#[derive(Default)]
-pub struct UiData {
-    map: HashMap<TypeId, Box<dyn Any>>,
-}
-
-impl UiData {
-    pub fn get<T: 'static>(&self) -> Option<&T> {
-        self.map
-            .get(&TypeId::of::<T>())
-            .map(|d| d.downcast_ref().unwrap())
-    }
-    pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
-        self.map
-            .get_mut(&TypeId::of::<T>())
-            .map(|d| d.downcast_mut().unwrap())
-    }
-
-    pub fn emit_remove(&mut self, id: &Id) {
-        for (tid, f) in &mut self.on_remove {
-            let data = self.map.get_mut(tid).unwrap().downcast_ref().unwrap();
-        }
-    }
-}

src/layout/event.rs

@@ -1,215 +0,0 @@
-use std::{hash::Hash, rc::Rc};
-
-use crate::{
-    layout::{IdFnTag, Ui, UiModule, WidgetId, WidgetIdFn, WidgetLike},
-    util::{HashMap, Id},
-};
-
-pub trait Event: Sized {
-    type Module<Ctx: 'static>: EventModule<Self, Ctx>;
-    type Data: Clone;
-}
-
-pub struct EventCtx<'a, Ctx, Data> {
-    pub ui: &'a mut Ui,
-    pub state: &'a mut Ctx,
-    pub data: Data,
-}
-
-pub type ECtx<'a, Ctx, Data, W> = EventIdCtx<'a, Ctx, Data, W>;
-pub struct EventIdCtx<'a, Ctx, Data, W> {
-    pub id: &'a WidgetId<W>,
-    pub ui: &'a mut Ui,
-    pub state: &'a mut Ctx,
-    pub data: Data,
-}
-
-pub trait EventFn<Ctx, Data>: Fn(EventCtx<Ctx, Data>) + 'static {}
-impl<F: Fn(EventCtx<Ctx, Data>) + 'static, Ctx, Data> EventFn<Ctx, Data> for F {}
-
-pub trait WidgetEventFn<Ctx, Data, W>: Fn(EventIdCtx<Ctx, Data, W>) + 'static {}
-impl<F: Fn(EventIdCtx<Ctx, Data, W>) + 'static, Ctx, Data, W> WidgetEventFn<Ctx, Data, W> for F {}
-
-// TODO: naming in here is a bit weird like eventable
-#[macro_export]
-macro_rules! event_ctx {
-    ($ty: ty) => {
-        mod local_event_trait {
-            use super::*;
-            #[allow(unused_imports)]
-            use $crate::prelude::*;
-
-            pub trait EventableCtx<W, Tag, Ctx: 'static> {
-                fn on<E: Event>(
-                    self,
-                    event: E,
-                    f: impl WidgetEventFn<Ctx, E::Data, W>,
-                ) -> impl WidgetIdFn<W> + EventableCtx<W, IdFnTag, Ctx>;
-            }
-
-            impl<WL: WidgetLike<Tag>, Tag> EventableCtx<WL::Widget, Tag, $ty> for WL {
-                fn on<E: Event>(
-                    self,
-                    event: E,
-                    f: impl WidgetEventFn<$ty, E::Data, WL::Widget>,
-                ) -> impl WidgetIdFn<WL::Widget> + EventableCtx<WL::Widget, IdFnTag, $ty> {
-                    eventable::Eventable::on(self, event, f)
-                }
-            }
-        }
-        use local_event_trait::*;
-    };
-}
-pub use event_ctx;
-
-pub mod eventable {
-    use super::*;
-
-    pub trait Eventable<W, Tag> {
-        fn on<E: Event, Ctx: 'static>(
-            self,
-            event: E,
-            f: impl WidgetEventFn<Ctx, E::Data, W>,
-        ) -> impl WidgetIdFn<W> + Eventable<W, IdFnTag>;
-    }
-
-    impl<WL: WidgetLike<Tag>, Tag> Eventable<WL::Widget, Tag> for WL {
-        fn on<E: Event, Ctx: 'static>(
-            self,
-            event: E,
-            f: impl WidgetEventFn<Ctx, E::Data, WL::Widget>,
-        ) -> impl WidgetIdFn<WL::Widget> {
-            move |ui| {
-                let id = self.add(ui);
-                let id_ = id.weak();
-                ui.register_event(&id, event, move |ctx| {
-                    f(EventIdCtx {
-                        id: &id_.strong(),
-                        state: ctx.state,
-                        data: ctx.data,
-                        ui: ctx.ui,
-                    });
-                });
-                id
-            }
-        }
-    }
-}
-
-pub trait DefaultEvent: Hash + Eq + 'static {
-    type Data: Clone;
-}
-
-impl<E: DefaultEvent> Event for E {
-    type Module<Ctx: 'static> = DefaultEventModule<E, Ctx>;
-    type Data = E::Data;
-}
-
-pub trait EventModule<E: Event, Ctx>: UiModule + Default {
-    fn register(&mut self, id: Id, event: E, f: impl EventFn<Ctx, E::Data>);
-    fn run<'a>(
-        &self,
-        id: &Id,
-        event: E,
-    ) -> Option<impl Fn(EventCtx<Ctx, E::Data>) + use<'a, Self, E, Ctx>>;
-}
-
-type EventFnMap<Ctx, Data> = HashMap<Id, Vec<Rc<dyn EventFn<Ctx, Data>>>>;
-pub struct DefaultEventModule<E: Event, Ctx> {
-    map: HashMap<E, EventFnMap<Ctx, <E as Event>::Data>>,
-}
-
-impl<E: Event + 'static, Ctx: 'static> UiModule for DefaultEventModule<E, Ctx> {
-    fn on_remove(&mut self, id: &Id) {
-        for map in self.map.values_mut() {
-            map.remove(id);
-        }
-    }
-}
-
-pub trait HashableEvent: Event + Hash + Eq + 'static {}
-impl<E: Event + Hash + Eq + 'static> HashableEvent for E {}
-
-impl<E: HashableEvent, Ctx: 'static> EventModule<E, Ctx> for DefaultEventModule<E, Ctx> {
-    fn register(&mut self, id: Id, event: E, f: impl EventFn<Ctx, <E as Event>::Data>) {
-        self.map
-            .entry(event)
-            .or_default()
-            .entry(id)
-            .or_default()
-            .push(Rc::new(f));
-    }
-
-    fn run<'a>(
-        &self,
-        id: &Id,
-        event: E,
-    ) -> Option<impl Fn(EventCtx<Ctx, E::Data>) + use<'a, E, Ctx>> {
-        if let Some(map) = self.map.get(&event)
-            && let Some(fs) = map.get(id)
-        {
-            let fs = fs.clone();
-            Some(move |ctx: EventCtx<Ctx, <E as Event>::Data>| {
-                for f in &fs {
-                    f(EventCtx {
-                        ui: ctx.ui,
-                        state: ctx.state,
-                        data: ctx.data.clone(),
-                    })
-                }
-            })
-        } else {
-            None
-        }
-    }
-}
-
-impl<E: HashableEvent, Ctx: 'static> DefaultEventModule<E, Ctx> {
-    pub fn run_all(&self, event: E, ctx: EventCtx<Ctx, E::Data>)
-    where
-        E::Data: Clone,
-    {
-        if let Some(map) = self.map.get(&event) {
-            for fs in map.values() {
-                for f in fs {
-                    f(EventCtx {
-                        ui: ctx.ui,
-                        state: ctx.state,
-                        data: ctx.data.clone(),
-                    })
-                }
-            }
-        }
-    }
-}
-
-impl<E: Event + 'static, Ctx: 'static> Default for DefaultEventModule<E, Ctx> {
-    fn default() -> Self {
-        Self {
-            map: Default::default(),
-        }
-    }
-}
-
-impl Ui {
-    pub fn run_event<E: Event, Ctx: 'static, W>(
-        &mut self,
-        ctx: &mut Ctx,
-        id: &WidgetId<W>,
-        event: E,
-        data: E::Data,
-    ) {
-        if let Some(f) = self
-            .data
-            .modules
-            .get_mut::<E::Module<Ctx>>()
-            .run(&id.id, event)
-        {
-            f(EventCtx {
-                ui: self,
-                state: ctx,
-                data,
-            });
-        }
-    }
-}

src/layout/id.rs

@@ -1,180 +0,0 @@
-use std::{any::TypeId, marker::PhantomData, sync::mpsc::Sender};
-
-use crate::{
-    layout::{Ui, WidgetLike},
-    util::{Id, RefCounter},
-};
-
-pub struct AnyWidget;
-
-/// An identifier for a widget that can index a UI to get the associated widget.
-/// It should always remain valid; it keeps a ref count and removes the widget from the UI if all
-/// references are dropped.
-///
-/// W does not need to implement widget so that AnyWidget is valid;
-/// Instead, add generic bounds on methods that take an ID if they need specific data.
-///
-/// TODO: ergonomic clones when they get put in rust-analyzer & don't cause ICEs?
-#[repr(C)]
-pub struct WidgetId<W = AnyWidget> {
-    pub(super) ty: TypeId,
-    pub(super) id: Id,
-    counter: RefCounter,
-    send: Sender<Id>,
-    _pd: PhantomData<W>,
-}
-
-#[repr(C)]
-pub struct WeakWidgetId<W = AnyWidget> {
-    pub(super) ty: TypeId,
-    pub(super) id: Id,
-    counter: RefCounter,
-    send: Sender<Id>,
-    _pd: PhantomData<W>,
-}
-
-impl<W> PartialEq for WidgetId<W> {
-    fn eq(&self, other: &Self) -> bool {
-        self.ty == other.ty && self.id == other.id
-    }
-}
-
-impl<W> std::fmt::Debug for WidgetId<W> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.id.fmt(f)
-    }
-}
-
-impl<W> Clone for WidgetId<W> {
-    fn clone(&self) -> Self {
-        Self {
-            id: self.id,
-            ty: self.ty,
-            counter: self.counter.clone(),
-            send: self.send.clone(),
-            _pd: PhantomData,
-        }
-    }
-}
-
-impl<W> WidgetId<W> {
-    pub(super) fn new(id: Id, ty: TypeId, send: Sender<Id>) -> Self {
-        Self {
-            ty,
-            id,
-            counter: RefCounter::new(),
-            send,
-            _pd: PhantomData,
-        }
-    }
-
-    pub fn any(self) -> WidgetId<AnyWidget> {
-        self.cast_type()
-    }
-
-    pub fn as_any(&self) -> &WidgetId<AnyWidget> {
-        // SAFETY: self is repr(C) and generic only used for phantom data
-        unsafe { std::mem::transmute(self) }
-    }
-
-    pub fn key(&self) -> Id {
-        self.id
-    }
-
-    pub(super) fn cast_type<W2>(self) -> WidgetId<W2> {
-        // SAFETY: self is repr(C) and generic only used for phantom data
-        unsafe { std::mem::transmute(self) }
-    }
-
-    pub fn refs(&self) -> u32 {
-        self.counter.refs()
-    }
-
-    pub fn weak(&self) -> WeakWidgetId<W> {
-        let Self {
-            ty,
-            id,
-            ref counter,
-            ref send,
-            _pd,
-        } = *self;
-        WeakWidgetId {
-            ty,
-            id,
-            counter: counter.quiet_clone(),
-            send: send.clone(),
-            _pd,
-        }
-    }
-}
-
-impl<W> WeakWidgetId<W> {
-    /// should guarantee that widget is still valid to prevent indexing failures
-    pub(crate) fn strong(&self) -> WidgetId<W> {
-        let Self {
-            ty,
-            id,
-            ref counter,
-            ref send,
-            _pd,
-        } = *self;
-        WidgetId {
-            ty,
-            id,
-            counter: counter.clone(),
-            send: send.clone(),
-            _pd,
-        }
-    }
-}
-
-impl<W> Drop for WidgetId<W> {
-    fn drop(&mut self) {
-        if self.counter.drop() {
-            let _ = self.send.send(self.id);
-        }
-    }
-}
-
-pub struct IdTag;
-pub struct IdFnTag;
-
-pub trait WidgetIdFn<W>: FnOnce(&mut Ui) -> WidgetId<W> {}
-impl<W, F: FnOnce(&mut Ui) -> WidgetId<W>> WidgetIdFn<W> for F {}
-
-pub trait WidgetRet: FnOnce(&mut Ui) -> WidgetId<AnyWidget> {}
-impl<F: FnOnce(&mut Ui) -> WidgetId<AnyWidget>> WidgetRet for F {}
-
-impl<W: 'static> WidgetLike<IdTag> for WidgetId<W> {
-    type Widget = W;
-    fn add(self, _: &mut Ui) -> WidgetId<W> {
-        self
-    }
-}
-
-impl<W: 'static, F: FnOnce(&mut Ui) -> WidgetId<W>> WidgetLike<IdFnTag> for F {
-    type Widget = W;
-    fn add(self, ui: &mut Ui) -> WidgetId<W> {
-        self(ui)
-    }
-}
-
-pub trait WidgetIdLike<W> {
-    fn id(self, send: &Sender<Id>) -> WidgetId<W>;
-}
-
-impl<W> WidgetIdLike<W> for &WidgetId<W> {
-    fn id(self, _: &Sender<Id>) -> WidgetId<W> {
-        self.clone()
-    }
-}
-
-pub trait IdLike<W> {
-    fn id(&self) -> Id;
-}
-
-impl<W> IdLike<W> for WidgetId<W> {
-    fn id(&self) -> Id {
-        self.id
-    }
-}

src/layout/mask.rs

@@ -1,46 +0,0 @@
-//! tree structure for masking
-
-use crate::layout::UiRegion;
-
-pub struct Masks {
-    data: Vec<MaskNode>,
-}
-
-#[repr(C)]
-#[derive(Clone, Copy)]
-pub struct MaskPtr(u32);
-
-#[repr(C)]
-pub struct MaskNode {
-    /// TODO: this is just a rect for now,
-    /// but would like to support arbitrary masks
-    /// at some point; custom shader
-    /// would probably handle that case
-    /// bc you'd need to render to a special target
-    /// anyways
-    region: UiRegion,
-    prev: MaskPtr,
-}
-
-impl MaskPtr {
-    const NONE: Self = Self(u32::MAX);
-}
-
-impl Masks {
-    pub fn push(&mut self, parent: MaskPtr, region: UiRegion) -> MaskPtr {
-        match parent.0 {
-            _ => {
-            }
-            u32::MAX => {
-                let i = self.data.len();
-                self.data.push(MaskNode {
-                    region,
-                    prev: parent,
-                });
-                MaskPtr(i as u32)
-            }
-        }
-    }
-
-    pub fn pop(&mut self, i: usize) {}
-}

src/layout/mod.rs

@@ -1,33 +0,0 @@
-mod color;
-mod event;
-mod id;
-mod layer;
-mod module;
-mod num;
-mod orientation;
-mod painter;
-mod text;
-mod texture;
-mod ui;
-mod attr;
-mod vec2;
-mod widget;
-mod widgets;
-
-pub use color::*;
-pub use event::*;
-pub use id::*;
-pub use layer::*;
-pub use module::*;
-pub use num::*;
-pub use orientation::*;
-pub use painter::*;
-pub use text::*;
-pub use texture::*;
-pub use ui::*;
-pub use attr::*;
-pub use vec2::*;
-pub use widget::*;
-pub use widgets::*;
-
-pub type UiColor = Color<u8>;

src/layout/module.rs

@@ -1,35 +0,0 @@
-use std::any::{Any, TypeId};
-
-use crate::{
-    layout::WidgetInstance,
-    util::{HashMap, Id},
-};
-
-#[allow(unused_variables)]
-pub trait UiModule: Any {
-    fn on_draw(&mut self, inst: &WidgetInstance) {}
-    fn on_undraw(&mut self, inst: &WidgetInstance) {}
-    fn on_remove(&mut self, id: &Id) {}
-    fn on_move(&mut self, inst: &WidgetInstance) {}
-}
-
-#[derive(Default)]
-pub struct Modules {
-    map: HashMap<TypeId, Box<dyn UiModule>>,
-}
-
-impl Modules {
-    pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut (dyn UiModule + 'static)> {
-        self.map.values_mut().map(|m| m.as_mut())
-    }
-
-    pub fn get_mut<M: UiModule + Default>(&mut self) -> &mut M {
-        let rf = self
-            .map
-            .entry(TypeId::of::<M>())
-            .or_insert_with(|| Box::new(M::default()))
-            .as_mut();
-        let any: &mut dyn Any = &mut *rf;
-        any.downcast_mut().unwrap()
-    }
-}

src/layout/num.rs

@@ -1,21 +0,0 @@
-pub const trait UiNum {
-    fn to_f32(self) -> f32;
-}
-
-impl const UiNum for f32 {
-    fn to_f32(self) -> f32 {
-        self
-    }
-}
-
-impl const UiNum for u32 {
-    fn to_f32(self) -> f32 {
-        self as f32
-    }
-}
-
-impl const UiNum for i32 {
-    fn to_f32(self) -> f32 {
-        self as f32
-    }
-}

src/layout/painter.rs

@@ -1,591 +0,0 @@
-use crate::{
-    layout::{
-        Axis, Len, Modules, PrimitiveLayers, RenderedText, Size, TextAttrs, TextBuffer, TextData,
-        TextureHandle, Textures, UiRegion, UiVec2, Vec2, WidgetId, Widgets,
-    },
-    render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
-    util::{HashMap, HashSet, Id, TrackedArena},
-};
-
-/// makes your surfaces look pretty
-pub struct Painter<'a, 'c> {
-    ctx: &'a mut PainterCtx<'c>,
-    region: UiRegion,
-    mask: MaskIdx,
-    textures: Vec<TextureHandle>,
-    primitives: Vec<PrimitiveHandle>,
-    children: Vec<Id>,
-    children_width: HashMap<Id, (UiVec2, Len)>,
-    children_height: HashMap<Id, (UiVec2, Len)>,
-    pub layer: usize,
-    id: Id,
-}
-
-/// context for a painter; lets you draw and redraw widgets
-struct PainterCtx<'a> {
-    pub widgets: &'a Widgets,
-    pub active: &'a mut HashMap<Id, WidgetInstance>,
-    pub layers: &'a mut PrimitiveLayers,
-    pub textures: &'a mut Textures,
-    pub masks: &'a mut TrackedArena<Mask, u32>,
-    pub text: &'a mut TextData,
-    pub output_size: Vec2,
-    pub modules: &'a mut Modules,
-    pub cache_width: HashMap<Id, (UiVec2, Len)>,
-    pub cache_height: HashMap<Id, (UiVec2, Len)>,
-    pub needs_redraw: HashSet<Id>,
-    draw_started: HashSet<Id>,
-}
-
-/// stores information for children about the highest level parent that needed their size
-/// so that they can redraw the parent if their size changes
-#[derive(Clone, Copy, Debug, Default)]
-pub struct ResizeRef {
-    x: Option<(Id, (UiVec2, Len))>,
-    y: Option<(Id, (UiVec2, Len))>,
-}
-
-/// important non rendering data for retained drawing
-#[derive(Debug)]
-pub struct WidgetInstance {
-    pub id: Id,
-    pub region: UiRegion,
-    pub parent: Option<Id>,
-    pub textures: Vec<TextureHandle>,
-    pub primitives: Vec<PrimitiveHandle>,
-    pub children: Vec<Id>,
-    pub resize: ResizeRef,
-    pub mask: MaskIdx,
-    pub layer: usize,
-}
-
-/// data to be stored in Ui to create PainterCtxs easily
-#[derive(Default)]
-pub struct PainterData {
-    pub widgets: Widgets,
-    pub active: HashMap<Id, WidgetInstance>,
-    pub layers: PrimitiveLayers,
-    pub textures: Textures,
-    pub text: TextData,
-    pub output_size: Vec2,
-    pub modules: Modules,
-    pub px_dependent: HashSet<Id>,
-    pub masks: TrackedArena<Mask, u32>,
-}
-
-impl<'a> PainterCtx<'a> {
-    /// redraws a widget that's currently active (drawn)
-    /// can be called on something already drawn or removed,
-    /// will just return if so
-    pub fn redraw(&mut self, id: Id) {
-        self.needs_redraw.remove(&id);
-        if self.draw_started.contains(&id) {
-            return;
-        }
-        let Some(active) = self.active.get(&id) else {
-            return;
-        };
-        let mut resize = active.resize;
-
-        // set resize back after redrawing
-        let finish = |s: &mut Self, resize| {
-            if let Some(active) = s.active.get_mut(&id) {
-                // might need to get_or_insert here instead of just assuming
-                active.resize = resize;
-            }
-        };
-
-        // check if a parent depends on the desired size of this, if so then redraw it first
-        // TODO: this is stupid having 2 of these, don't ask me what the consequences are
-        let mut ret = false;
-        if let Some((rid, (outer, old_desired))) = &mut resize.x {
-            let new_desired = SizeCtx {
-                source: id,
-                cache_width: &mut self.cache_width,
-                cache_height: &mut self.cache_height,
-                text: self.text,
-                textures: self.textures,
-                widgets: self.widgets,
-                outer: *outer,
-                output_size: self.output_size,
-                checked_width: &mut Default::default(),
-                checked_height: &mut Default::default(),
-                id,
-            }
-            .width_inner(id);
-            if new_desired != *old_desired {
-                // unsure if I need to walk down the tree here
-                self.redraw(*rid);
-                *old_desired = new_desired;
-                if self.draw_started.contains(&id) {
-                    ret = true;
-                }
-            }
-        }
-
-        if let Some((rid, (outer, old_desired))) = &mut resize.y {
-            // NOTE: might need hack in Span here (or also do it properly here)
-            let new_desired = SizeCtx {
-                source: id,
-                cache_width: &mut self.cache_width,
-                cache_height: &mut self.cache_height,
-                text: self.text,
-                textures: self.textures,
-                widgets: self.widgets,
-                outer: *outer,
-                output_size: self.output_size,
-                checked_width: &mut Default::default(),
-                checked_height: &mut Default::default(),
-                id,
-            }
-            .height_inner(id);
-            if new_desired != *old_desired {
-                self.redraw(*rid);
-                *old_desired = new_desired;
-                if self.draw_started.contains(&id) {
-                    ret = true;
-                }
-            }
-        }
-
-        if ret {
-            return finish(self, resize);
-        }
-
-        let Some(active) = self.remove(id) else {
-            return;
-        };
-
-        self.draw_inner(
-            active.layer,
-            id,
-            active.region,
-            active.parent,
-            active.mask,
-            Some(active.children),
-        );
-        finish(self, resize);
-    }
-
-    fn draw_inner(
-        &mut self,
-        layer: usize,
-        id: Id,
-        region: UiRegion,
-        parent: Option<Id>,
-        mask: MaskIdx,
-        old_children: Option<Vec<Id>>,
-    ) {
-        // I have no idea if these checks work lol
-        // the idea is u can't redraw stuff u already drew,
-        // and if parent is different then there's another copy with a different parent
-        // but this has a very weird issue where you can't move widgets unless u remove first
-        // so swapping is impossible rn I think?
-        // there's definitely better solutions like a counter (>1 = panic) but don't care rn
-        // if self.draw_started.contains(&id) {
-        //     panic!(
-        //         "Cannot draw the same widget ({}) twice (1)",
-        //         self.widgets.data(&id).unwrap().label
-        //     );
-        // }
-        let mut old_children = old_children.unwrap_or_default();
-        let mut resize = ResizeRef::default();
-        if let Some(active) = self.active.get_mut(&id)
-            && !self.needs_redraw.contains(&id)
-        {
-            // check to see if we can skip drawing first
-            if active.parent != parent {
-                panic!("Cannot draw the same widget twice (2)");
-            }
-            if active.region == region {
-                return;
-            } else if active.region.size() == region.size() {
-                // TODO: epsilon?
-                let from = active.region;
-                self.mov(id, from, region);
-                return;
-            }
-            // if not, then maintain resize and track old children to remove unneeded
-            let active = self.remove(id).unwrap();
-            old_children = active.children;
-            resize = active.resize;
-        }
-
-        // draw widget
-        self.draw_started.insert(id);
-
-        let mut painter = Painter {
-            region,
-            mask,
-            layer,
-            id,
-            textures: Vec::new(),
-            primitives: Vec::new(),
-            ctx: self,
-            children: Vec::new(),
-            children_width: Default::default(),
-            children_height: Default::default(),
-        };
-
-        painter.ctx.widgets.get_dyn_dynamic(id).draw(&mut painter);
-
-        let children_width = painter.children_width;
-        let children_height = painter.children_height;
-
-        // add to active
-        let instance = WidgetInstance {
-            id,
-            region,
-            parent,
-            textures: painter.textures,
-            primitives: painter.primitives,
-            children: painter.children,
-            resize,
-            mask: painter.mask,
-            layer,
-        };
-        // set resize for children who's size this widget depends on
-        for (cid, outer) in children_width {
-            if let Some(w) = self.active.get_mut(&cid)
-                && w.resize.x.is_none()
-            {
-                w.resize.x = Some((id, outer))
-            }
-        }
-        for (cid, outer) in children_height {
-            if let Some(w) = self.active.get_mut(&cid)
-                && w.resize.y.is_none()
-            {
-                w.resize.y = Some((id, outer))
-            }
-        }
-
-        // remove old children that weren't kept
-        for c in &old_children {
-            if !instance.children.contains(c) {
-                self.remove_rec(*c);
-            }
-        }
-
-        // update modules
-        for m in self.modules.iter_mut() {
-            m.on_draw(&instance);
-        }
-        self.active.insert(id, instance);
-    }
-
-    fn mov(&mut self, id: Id, from: UiRegion, to: UiRegion) {
-        let active = self.active.get_mut(&id).unwrap();
-        for h in &active.primitives {
-            let region = self.layers[h.layer].region_mut(h);
-            *region = region.outside(&from).within(&to);
-        }
-        active.region = active.region.outside(&from).within(&to);
-        for m in self.modules.iter_mut() {
-            m.on_move(active);
-        }
-        // children will not be changed, so this technically should not be needed
-        // probably need unsafe
-        let children = active.children.clone();
-        for child in children {
-            self.mov(child, from, to);
-        }
-    }
-
-    /// NOTE: instance textures are cleared and self.textures freed
-    fn remove(&mut self, id: Id) -> Option<WidgetInstance> {
-        let mut inst = self.active.remove(&id);
-        if let Some(inst) = &mut inst {
-            for h in &inst.primitives {
-                let mask = self.layers.free(h);
-                if mask != MaskIdx::NONE {
-                    self.masks.remove(mask);
-                }
-            }
-            inst.textures.clear();
-            self.textures.free();
-            for m in self.modules.iter_mut() {
-                m.on_undraw(inst);
-            }
-        }
-        inst
-    }
-
-    fn remove_rec(&mut self, id: Id) -> Option<WidgetInstance> {
-        let inst = self.remove(id);
-        if let Some(inst) = &inst {
-            for c in &inst.children {
-                self.remove_rec(*c);
-            }
-        }
-        inst
-    }
-}
-
-impl PainterData {
-    fn ctx(&mut self, needs_redraw: HashSet<Id>) -> PainterCtx<'_> {
-        PainterCtx {
-            widgets: &self.widgets,
-            active: &mut self.active,
-            layers: &mut self.layers,
-            textures: &mut self.textures,
-            text: &mut self.text,
-            output_size: self.output_size,
-            modules: &mut self.modules,
-            masks: &mut self.masks,
-            cache_width: Default::default(),
-            cache_height: Default::default(),
-            draw_started: Default::default(),
-            needs_redraw,
-        }
-    }
-
-    pub fn draw(&mut self, id: Id) {
-        let mut ctx = self.ctx(Default::default());
-        ctx.draw_started.clear();
-        ctx.layers.clear();
-        ctx.draw_inner(0, id, UiRegion::FULL, None, MaskIdx::NONE, None);
-    }
-
-    pub fn redraw(&mut self, ids: HashSet<Id>) {
-        let mut ctx = self.ctx(ids);
-        while let Some(&id) = ctx.needs_redraw.iter().next() {
-            ctx.redraw(id);
-        }
-    }
-}
-
-impl<'a, 'c> Painter<'a, 'c> {
-    fn primitive_at<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
-        let h = self.ctx.layers.write(
-            self.layer,
-            PrimitiveInst {
-                id: self.id,
-                primitive,
-                region,
-                mask_idx: self.mask,
-            },
-        );
-        if self.mask != MaskIdx::NONE {
-            // TODO: I have no clue if this works at all :joy:
-            self.ctx.masks.push_ref(self.mask);
-        }
-        self.primitives.push(h);
-    }
-
-    /// Writes a primitive to be rendered
-    pub fn primitive<P: Primitive>(&mut self, primitive: P) {
-        self.primitive_at(primitive, self.region)
-    }
-
-    pub fn primitive_within<P: Primitive>(&mut self, primitive: P, region: UiRegion) {
-        self.primitive_at(primitive, region.within(&self.region));
-    }
-
-    pub fn set_mask(&mut self, region: UiRegion) {
-        assert!(self.mask == MaskIdx::NONE);
-        self.mask = self.ctx.masks.push(Mask { region });
-    }
-
-    /// Draws a widget within this widget's region.
-    pub fn widget<W>(&mut self, id: &WidgetId<W>) {
-        self.widget_at(id, self.region);
-    }
-
-    /// Draws a widget somewhere within this one.
-    /// Useful for drawing child widgets in select areas.
-    pub fn widget_within<W>(&mut self, id: &WidgetId<W>, region: UiRegion) {
-        self.widget_at(id, region.within(&self.region));
-    }
-
-    fn widget_at<W>(&mut self, id: &WidgetId<W>, region: UiRegion) {
-        self.children.push(id.id);
-        self.ctx
-            .draw_inner(self.layer, id.id, region, Some(self.id), self.mask, None);
-    }
-
-    pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) {
-        self.textures.push(handle.clone());
-        self.primitive_at(handle.primitive(), region.within(&self.region));
-    }
-
-    pub fn texture(&mut self, handle: &TextureHandle) {
-        self.textures.push(handle.clone());
-        self.primitive(handle.primitive());
-    }
-
-    pub fn texture_at(&mut self, handle: &TextureHandle, region: UiRegion) {
-        self.textures.push(handle.clone());
-        self.primitive_at(handle.primitive(), region);
-    }
-
-    /// returns (handle, offset from top left)
-    pub fn render_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
-        self.ctx.text.draw(buffer, attrs, self.ctx.textures)
-    }
-
-    pub fn region(&self) -> UiRegion {
-        self.region
-    }
-
-    pub fn size<W>(&mut self, id: &WidgetId<W>) -> Size {
-        self.size_ctx().size(id)
-    }
-
-    pub fn len_axis<W>(&mut self, id: &WidgetId<W>, axis: Axis) -> Len {
-        match axis {
-            Axis::X => self.size_ctx().width(id),
-            Axis::Y => self.size_ctx().height(id),
-        }
-    }
-
-    pub fn size_ctx(&mut self) -> SizeCtx<'_> {
-        SizeCtx {
-            text: self.ctx.text,
-            textures: self.ctx.textures,
-            widgets: self.ctx.widgets,
-            output_size: self.ctx.output_size,
-            checked_width: &mut self.children_width,
-            checked_height: &mut self.children_height,
-            cache_width: &mut self.ctx.cache_width,
-            cache_height: &mut self.ctx.cache_height,
-            source: self.id,
-            id: self.id,
-            outer: self.region.size(),
-        }
-    }
-
-    pub fn output_size(&self) -> Vec2 {
-        self.ctx.output_size
-    }
-
-    pub fn px_size(&mut self) -> Vec2 {
-        self.region.size().to_abs(self.ctx.output_size)
-    }
-
-    pub fn text_data(&mut self) -> &mut TextData {
-        self.ctx.text
-    }
-
-    pub fn child_layer(&mut self) {
-        self.layer = self.ctx.layers.child(self.layer);
-    }
-
-    pub fn next_layer(&mut self) {
-        self.layer = self.ctx.layers.next(self.layer);
-    }
-
-    pub fn label(&self) -> &str {
-        &self.ctx.widgets.data(&self.id).unwrap().label
-    }
-
-    pub fn id(&self) -> &Id {
-        &self.id
-    }
-}
-
-pub struct SizeCtx<'a> {
-    pub text: &'a mut TextData,
-    pub textures: &'a mut Textures,
-    source: Id,
-    widgets: &'a Widgets,
-    cache_width: &'a mut HashMap<Id, (UiVec2, Len)>,
-    cache_height: &'a mut HashMap<Id, (UiVec2, Len)>,
-    checked_width: &'a mut HashMap<Id, (UiVec2, Len)>,
-    checked_height: &'a mut HashMap<Id, (UiVec2, Len)>,
-    /// TODO: should this be pub? rn used for sized
-    pub outer: UiVec2,
-    output_size: Vec2,
-    id: Id,
-}
-
-impl SizeCtx<'_> {
-    pub fn id(&self) -> &Id {
-        &self.id
-    }
-
-    pub fn source(&self) -> &Id {
-        &self.source
-    }
-
-    fn width_inner(&mut self, id: Id) -> Len {
-        // first check cache
-        // TODO: is this needed? broken rn bc does not store children during upper size check,
-        // so if something actually using check_* hits cache it fails to add them
-        // if let Some(&(outer, len)) = self.cache_width.get(&id)
-        //     && outer == self.outer
-        // {
-        //     self.checked_width.insert(id, (self.outer, len));
-        //     return len;
-        // }
-        // store self vars that need to be maintained
-        let self_outer = self.outer;
-        let self_id = self.id;
-        // get size of input id
-        self.id = id;
-        let len = self.widgets.get_dyn_dynamic(id).desired_width(self);
-        // restore vars & update cache + checked
-        self.outer = self_outer;
-        self.id = self_id;
-        self.cache_width.insert(id, (self.outer, len));
-        self.checked_width.insert(id, (self.outer, len));
-        len
-    }
-
-    // TODO: should be refactored to share code w width_inner
-    fn height_inner(&mut self, id: Id) -> Len {
-        // if let Some(&(outer, len)) = self.cache_height.get(&id)
-        //     && outer == self.outer
-        // {
-        //     self.checked_height.insert(id, (self.outer, len));
-        //     return len;
-        // }
-        let self_outer = self.outer;
-        let self_id = self.id;
-        self.id = id;
-        let len = self.widgets.get_dyn_dynamic(id).desired_height(self);
-        self.outer = self_outer;
-        self.id = self_id;
-        self.cache_height.insert(id, (self.outer, len));
-        self.checked_height.insert(id, (self.outer, len));
-        len
-    }
-
-    pub fn width<W>(&mut self, id: &WidgetId<W>) -> Len {
-        self.width_inner(id.id)
-    }
-
-    pub fn height<W>(&mut self, id: &WidgetId<W>) -> Len {
-        self.height_inner(id.id)
-    }
-
-    pub fn len_axis<W>(&mut self, id: &WidgetId<W>, axis: Axis) -> Len {
-        match axis {
-            Axis::X => self.width(id),
-            Axis::Y => self.height(id),
-        }
-    }
-
-    pub fn size<W>(&mut self, id: &WidgetId<W>) -> Size {
-        Size {
-            x: self.width(id),
-            y: self.height(id),
-        }
-    }
-
-    pub fn px_size(&mut self) -> Vec2 {
-        self.outer.to_abs(self.output_size)
-    }
-
-    pub fn output_size(&mut self) -> Vec2 {
-        self.output_size
-    }
-
-    pub fn draw_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
-        self.text.draw(buffer, attrs, self.textures)
-    }
-
-    pub fn label(&self, id: &Id) -> &String {
-        self.widgets.label(id)
-    }
-}

src/layout/ui.rs

@@ -1,232 +0,0 @@
-use image::DynamicImage;
-
-use crate::{
-    core::{TextEdit, TextEditCtx},
-    layout::{
-        Event, EventFn, EventModule, IdLike, PainterData, PixelRegion, TextureHandle, Vec2, Widget,
-        WidgetId, WidgetInstance, WidgetLike,
-    },
-    util::{HashSet, Id},
-};
-use std::{
-    any::{Any, TypeId},
-    ops::{Index, IndexMut},
-    sync::mpsc::{Receiver, Sender, channel},
-};
-
-pub struct Ui {
-    // TODO: make this at least pub(super)
-    pub(crate) data: PainterData,
-    root: Option<WidgetId>,
-    updates: HashSet<Id>,
-    recv: Receiver<Id>,
-    pub(super) send: Sender<Id>,
-    full_redraw: bool,
-    resized: bool,
-}
-
-impl Ui {
-    pub fn add<W: Widget, Tag>(&mut self, w: impl WidgetLike<Tag, Widget = W>) -> WidgetId<W> {
-        w.add(self)
-    }
-
-    /// useful for debugging
-    pub fn set_label<W>(&mut self, id: &WidgetId<W>, label: String) {
-        self.data.widgets.data_mut(&id.id).unwrap().label = label;
-    }
-
-    pub fn label<W>(&self, id: &WidgetId<W>) -> &String {
-        &self.data.widgets.data(&id.id).unwrap().label
-    }
-
-    pub fn add_widget<W: Widget>(&mut self, w: W) -> WidgetId<W> {
-        self.push(w)
-    }
-
-    pub fn push<W: Widget>(&mut self, w: W) -> WidgetId<W> {
-        let id = self.new_id();
-        self.data.widgets.insert(id.id, w);
-        id
-    }
-
-    pub fn set_root<Tag>(&mut self, w: impl WidgetLike<Tag>) {
-        self.root = Some(w.add(self).any());
-        self.full_redraw = true;
-    }
-
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn get<W: Widget>(&self, id: &impl IdLike<W>) -> Option<&W> {
-        self.data.widgets.get(id)
-    }
-
-    pub fn get_mut<W: Widget>(&mut self, id: &impl IdLike<W>) -> Option<&mut W> {
-        self.data.widgets.get_mut(id)
-    }
-
-    fn new_id<W: Widget>(&mut self) -> WidgetId<W> {
-        WidgetId::new(
-            self.data.widgets.reserve(),
-            TypeId::of::<W>(),
-            self.send.clone(),
-        )
-    }
-
-    pub fn add_texture(&mut self, image: DynamicImage) -> TextureHandle {
-        self.data.textures.add(image)
-    }
-
-    pub fn register_event<W, E: Event, Ctx: 'static>(
-        &mut self,
-        id: &WidgetId<W>,
-        event: E,
-        f: impl EventFn<Ctx, E::Data>,
-    ) {
-        self.data
-            .modules
-            .get_mut::<E::Module<Ctx>>()
-            .register(id.id, event, f);
-    }
-
-    pub fn resize(&mut self, size: impl Into<Vec2>) {
-        self.data.output_size = size.into();
-        self.resized = true;
-    }
-
-    pub fn redraw_all(&mut self) {
-        for (_, inst) in self.data.active.drain() {
-            for m in self.data.modules.iter_mut() {
-                m.on_undraw(&inst);
-            }
-        }
-        // free before bc nothing should exist
-        self.free();
-        if let Some(root) = &self.root {
-            self.data.draw(root.id);
-        }
-    }
-
-    pub fn update(&mut self) {
-        if self.full_redraw {
-            self.redraw_all();
-            self.full_redraw = false;
-        } else if !self.updates.is_empty() {
-            self.redraw_updates();
-        }
-        if self.resized {
-            self.resized = false;
-            self.redraw_size();
-        }
-    }
-
-    fn redraw_size(&mut self) {
-        // let mut ctx = PainterCtx::new(&mut self.data);
-        // let dep = ctx.px_dependent.clone();
-        // for id in dep {
-        //     ctx.redraw(id);
-        // }
-        self.redraw_all();
-    }
-
-    fn redraw_updates(&mut self) {
-        self.data.redraw(std::mem::take(&mut self.updates));
-        self.free();
-    }
-
-    /// free any resources that don't have references anymore
-    fn free(&mut self) {
-        for id in self.recv.try_iter() {
-            for m in self.data.modules.iter_mut() {
-                m.on_remove(&id);
-            }
-            self.data.widgets.delete(id);
-        }
-        self.data.textures.free();
-    }
-
-    pub fn needs_redraw(&self) -> bool {
-        self.full_redraw || !self.updates.is_empty()
-    }
-
-    pub fn num_widgets(&self) -> usize {
-        self.data.widgets.len()
-    }
-
-    pub fn active_widgets(&self) -> usize {
-        self.data.active.len()
-    }
-
-    pub fn text(&mut self, id: &impl IdLike<TextEdit>) -> TextEditCtx<'_> {
-        self.updates.insert(id.id());
-        TextEditCtx {
-            text: self.data.widgets.get_mut(id).unwrap(),
-            font_system: &mut self.data.text.font_system,
-        }
-    }
-
-    pub fn debug_layers(&self) {
-        for ((idx, depth), primitives) in self.data.layers.iter_depth() {
-            let indent = " ".repeat(depth * 2);
-            let len = primitives.instances().len();
-            print!("{indent}{idx}: {len} primitives");
-            if len >= 1 {
-                print!(" ({})", primitives.instances()[0].binding);
-            }
-            println!();
-        }
-    }
-
-    pub fn window_region<W>(&self, id: &impl IdLike<W>) -> Option<PixelRegion> {
-        let region = self.data.active.get(&id.id())?.region;
-        Some(region.to_px(self.data.output_size))
-    }
-
-    pub fn debug(&self, label: &str) -> impl Iterator<Item = &WidgetInstance> {
-        self.data.active.iter().filter_map(move |(id, inst)| {
-            let l = &self.data.widgets.label(id);
-            if *l == label { Some(inst) } else { None }
-        })
-    }
-}
-
-impl<W: Widget> Index<&WidgetId<W>> for Ui {
-    type Output = W;
-
-    fn index(&self, id: &WidgetId<W>) -> &Self::Output {
-        self.get(id).unwrap()
-    }
-}
-
-impl<W: Widget> IndexMut<&WidgetId<W>> for Ui {
-    fn index_mut(&mut self, id: &WidgetId<W>) -> &mut Self::Output {
-        self.updates.insert(id.id);
-        self.get_mut(id).unwrap()
-    }
-}
-
-impl dyn Widget {
-    pub fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    pub fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-}
-
-impl Default for Ui {
-    fn default() -> Self {
-        let (send, recv) = channel();
-        Self {
-            data: PainterData::default(),
-            root: Default::default(),
-            updates: Default::default(),
-            full_redraw: false,
-            send,
-            recv,
-            resized: false,
-        }
-    }
-}

src/layout/widget.rs

@@ -1,160 +0,0 @@
-use crate::{
-    core::WidgetPtr,
-    layout::{Len, Painter, SizeCtx, Ui, WidgetId, WidgetIdFn},
-};
-
-use std::{any::Any, marker::PhantomData};
-
-pub trait Widget: Any {
-    fn draw(&mut self, painter: &mut Painter);
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len;
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len;
-}
-
-impl Widget for () {
-    fn draw(&mut self, _: &mut Painter) {}
-    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
-        Len::ZERO
-    }
-    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
-        Len::ZERO
-    }
-}
-
-pub struct WidgetTag;
-pub struct FnTag;
-
-pub trait WidgetLike<Tag> {
-    type Widget: 'static;
-
-    fn add(self, ui: &mut Ui) -> WidgetId<Self::Widget>;
-
-    fn with_id<W2>(
-        self,
-        f: impl FnOnce(&mut Ui, WidgetId<Self::Widget>) -> WidgetId<W2>,
-    ) -> impl WidgetIdFn<W2>
-    where
-        Self: Sized,
-    {
-        move |ui| {
-            let id = self.add(ui);
-            f(ui, id)
-        }
-    }
-
-    fn set_root(self, ui: &mut Ui)
-    where
-        Self: Sized,
-    {
-        ui.set_root(self);
-    }
-
-    fn set_ptr(self, ptr: &WidgetId<WidgetPtr>, ui: &mut Ui)
-    where
-        Self: Sized,
-    {
-        ui[ptr].inner = Some(self.add(ui).any());
-    }
-}
-
-/// A function that returns a widget given a UI.
-/// Useful for defining trait functions on widgets that create a parent widget so that the children
-/// don't need to be IDs yet
-pub trait WidgetFn<W: Widget>: FnOnce(&mut Ui) -> W {}
-impl<W: Widget, F: FnOnce(&mut Ui) -> W> WidgetFn<W> for F {}
-
-impl<W: Widget, F: FnOnce(&mut Ui) -> W> WidgetLike<FnTag> for F {
-    type Widget = W;
-    fn add(self, ui: &mut Ui) -> WidgetId<W> {
-        self(ui).add(ui)
-    }
-}
-
-impl<W: Widget> WidgetLike<WidgetTag> for W {
-    type Widget = W;
-    fn add(self, ui: &mut Ui) -> WidgetId<W> {
-        ui.add_widget(self)
-    }
-}
-
-pub struct WidgetArr<const LEN: usize, Ws> {
-    pub arr: [WidgetId; LEN],
-    _pd: PhantomData<Ws>,
-}
-
-impl<const LEN: usize, Ws> WidgetArr<LEN, Ws> {
-    pub fn new(arr: [WidgetId; LEN]) -> Self {
-        Self {
-            arr,
-            _pd: PhantomData,
-        }
-    }
-}
-
-pub struct ArrTag;
-pub trait WidgetArrLike<const LEN: usize, Tag> {
-    type Ws;
-    fn ui(self, ui: &mut Ui) -> WidgetArr<LEN, Self::Ws>;
-}
-
-impl<const LEN: usize, Ws> WidgetArrLike<LEN, ArrTag> for WidgetArr<LEN, Ws> {
-    type Ws = Ws;
-    fn ui(self, _: &mut Ui) -> WidgetArr<LEN, Ws> {
-        self
-    }
-}
-
-impl<W: WidgetLike<WidgetTag>> WidgetArrLike<1, WidgetTag> for W {
-    type Ws = (W::Widget,);
-    fn ui(self, ui: &mut Ui) -> WidgetArr<1, (W::Widget,)> {
-        WidgetArr::new([self.add(ui).any()])
-    }
-}
-
-// I hate this language it's so bad why do I even use it
-macro_rules! impl_widget_arr {
-    ($n:expr;$($W:ident)*) => {
-        impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*);
-    };
-    ($n:expr;$($W:ident)*;$($Tag:ident)*) => {
-        impl<$($W: WidgetLike<$Tag>,$Tag,)*> WidgetArrLike<$n, ($($Tag,)*)> for ($($W,)*) {
-            type Ws = ($($W::Widget,)*);
-            fn ui(self, ui: &mut Ui) -> WidgetArr<$n, ($($W::Widget,)*)> {
-                #[allow(non_snake_case)]
-                let ($($W,)*) = self;
-                WidgetArr::new(
-                    [$($W.add(ui).cast_type(),)*],
-                )
-            }
-        }
-    };
-}
-
-impl_widget_arr!(1;A);
-impl_widget_arr!(2;A B);
-impl_widget_arr!(3;A B C);
-impl_widget_arr!(4;A B C D);
-impl_widget_arr!(5;A B C D E);
-impl_widget_arr!(6;A B C D E F);
-impl_widget_arr!(7;A B C D E F G);
-impl_widget_arr!(8;A B C D E F G H);
-impl_widget_arr!(9;A B C D E F G H I);
-impl_widget_arr!(10;A B C D E F G H I J);
-impl_widget_arr!(11;A B C D E F G H I J K);
-impl_widget_arr!(12;A B C D E F G H I J K L);
-
-pub trait WidgetOption {
-    fn get(self, ui: &mut Ui) -> Option<WidgetId>;
-}
-
-impl WidgetOption for () {
-    fn get(self, _: &mut Ui) -> Option<WidgetId> {
-        None
-    }
-}
-
-impl<F: FnOnce(&mut Ui) -> Option<WidgetId>> WidgetOption for F {
-    fn get(self, ui: &mut Ui) -> Option<WidgetId> {
-        self(ui)
-    }
-}

src/layout/widgets.rs

@@ -1,107 +0,0 @@
-use crate::{
-    layout::{IdLike, Widget},
-    util::{DynBorrower, HashMap, Id, IdTracker},
-};
-
-#[derive(Default)]
-pub struct Widgets {
-    ids: IdTracker,
-    map: HashMap<Id, WidgetData>,
-}
-
-pub struct WidgetData {
-    pub widget: Box<dyn Widget>,
-    pub label: String,
-    /// dynamic borrow checking
-    pub borrowed: bool,
-}
-
-impl Widgets {
-    pub fn new() -> Self {
-        Self {
-            ids: IdTracker::default(),
-            map: HashMap::default(),
-        }
-    }
-
-    pub fn get_dyn(&self, id: Id) -> Option<&dyn Widget> {
-        Some(self.map.get(&id)?.widget.as_ref())
-    }
-
-    pub fn get_dyn_mut(&mut self, id: Id) -> Option<&mut dyn Widget> {
-        Some(self.map.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 fn get_dyn_dynamic(&self, id: Id) -> WidgetWrapper<'_> {
-        // SAFETY: must guarantee no other mutable references to this widget exist
-        // done through the borrow variable
-        #[allow(mutable_transmutes)]
-        let data = unsafe {
-            std::mem::transmute::<&WidgetData, &mut WidgetData>(self.map.get(&id).unwrap())
-        };
-        if data.borrowed {
-            panic!("tried to mutably borrow the same widget twice");
-        }
-        WidgetWrapper::new(data.widget.as_mut(), &mut data.borrowed)
-    }
-
-    pub fn get<W: Widget>(&self, id: &impl IdLike<W>) -> Option<&W> {
-        self.get_dyn(id.id())?.as_any().downcast_ref()
-    }
-
-    pub fn get_mut<W: Widget>(&mut self, id: &impl IdLike<W>) -> Option<&mut W> {
-        self.get_dyn_mut(id.id())?.as_any_mut().downcast_mut()
-    }
-
-    pub fn insert<W: Widget>(&mut self, id: Id, widget: W) {
-        let mut label = std::any::type_name::<W>().to_string();
-        if let (Some(first), Some(last)) = (label.find(":"), label.rfind(":")) {
-            label = label.split_at(first).0.to_string() + "::" + label.split_at(last + 1).1;
-        }
-        self.insert_any(id, Box::new(widget), label);
-    }
-
-    pub fn data(&self, id: &Id) -> Option<&WidgetData> {
-        self.map.get(id)
-    }
-
-    pub fn label(&self, id: &Id) -> &String {
-        &self.data(id).unwrap().label
-    }
-
-    pub fn data_mut(&mut self, id: &Id) -> Option<&mut WidgetData> {
-        self.map.get_mut(id)
-    }
-
-    pub fn insert_any(&mut self, id: Id, widget: Box<dyn Widget>, label: String) {
-        self.map.insert(
-            id,
-            WidgetData {
-                widget,
-                label,
-                borrowed: false,
-            },
-        );
-    }
-
-    pub fn delete(&mut self, id: Id) {
-        self.map.remove(&id);
-        self.ids.free(id);
-    }
-
-    pub fn reserve(&mut self) -> Id {
-        self.ids.next()
-    }
-
-    pub fn len(&self) -> usize {
-        self.map.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.map.is_empty()
-    }
-}
-
-pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>;

src/lib.rs

@@ -1,24 +1,26 @@
-#![feature(macro_metavar_expr_concat)]
-#![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(gen_blocks)]
 #![feature(associated_type_defaults)]
+#![feature(unsize)]
+#![feature(option_into_flat_iter)]
+#![feature(async_fn_traits)]
 
-pub mod core;
+pub mod default;
-pub mod layout;
+pub mod event;
-pub mod render;
+pub mod widget;
-pub mod util;
+
-pub mod winit;
+pub use iris_core as core;
+pub use iris_macro as macros;
 
 pub mod prelude {
-    pub use crate::core::*;
+    use super::*;
-    pub use crate::layout::*;
+    pub use default::*;
-    pub use crate::render::*;
+    pub use event::*;
+    pub use iris_core::*;
+    pub use iris_macro::*;
+    pub use widget::*;
+
+    pub use iris_core::util::Vec2;
+    pub use len_fns::*;
 }

src/util/mod.rs

@@ -1,16 +0,0 @@
-mod arena;
-mod borrow;
-mod change;
-mod id;
-mod math;
-mod refcount;
-
-pub(crate) use arena::*;
-pub(crate) use borrow::*;
-pub use change::*;
-pub(crate) use id::*;
-pub(crate) use math::*;
-pub(crate) use refcount::*;
-
-pub type HashMap<K, V> = fxhash::FxHashMap<K, V>;
-pub type HashSet<K> = fxhash::FxHashSet<K>;

src/widget/image.rs

@@ -19,10 +19,10 @@ impl Widget for Image {
     }
 }
 
-pub fn image(image: impl LoadableImage) -> impl WidgetFn<Image> {
+pub fn image<State: UiRsc>(image: impl LoadableImage) -> impl WidgetFn<State, Image> {
     let image = image.get_image().expect("Failed to load image");
-    move |ui| Image {
+    move |state| Image {
-        handle: ui.add_texture(image),
+        handle: state.ui_mut().textures.add(image),
     }
 }
 

src/widget/mask.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub struct Masked {
-    pub inner: WidgetId,
+    pub inner: StrongWidget,
 }
 
 impl Widget for Masked {

src/widget/mod.rs

@@ -3,7 +3,6 @@ mod mask;
 mod position;
 mod ptr;
 mod rect;
-mod sense;
 mod text;
 mod trait_fns;
 
@@ -12,6 +11,5 @@ pub use mask::*;
 pub use position::*;
 pub use ptr::*;
 pub use rect::*;
-pub use sense::*;
 pub use text::*;
 pub use trait_fns::*;

src/widget/position/align.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub struct Aligned {
-    pub inner: WidgetId,
+    pub inner: StrongWidget,
     pub align: Align,
 }
 

src/widget/position/layer.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub struct LayerOffset {
-    pub inner: WidgetId,
+    pub inner: StrongWidget,
     pub offset: usize,
 }
 

src/widget/position/max_size.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub struct MaxSize {
-    pub inner: WidgetId,
+    pub inner: StrongWidget,
     pub x: Option<Len>,
     pub y: Option<Len>,
 }

src/widget/position/offset.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub struct Offset {
-    pub inner: WidgetId,
+    pub inner: StrongWidget,
     pub amt: UiVec2,
 }
 

src/widget/position/pad.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 
 pub struct Pad {
     pub padding: Padding,
-    pub inner: WidgetId,
+    pub inner: StrongWidget,
 }
 
 impl Widget for Pad {

src/widget/position/scroll.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub struct Scroll {
-    inner: WidgetId,
+    inner: StrongWidget,
     axis: Axis,
     amt: f32,
     snap_end: bool,
@@ -41,7 +41,7 @@ impl Widget for Scroll {
 }
 
 impl Scroll {
-    pub fn new(inner: WidgetId, axis: Axis) -> Self {
+    pub fn new(inner: StrongWidget, axis: Axis) -> Self {
         Self {
             inner,
             axis,

src/widget/position/sized.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub struct Sized {
-    pub inner: WidgetId,
+    pub inner: StrongWidget,
     pub x: Option<Len>,
     pub y: Option<Len>,
 }

src/widget/position/span.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 use std::marker::PhantomData;
 
 pub struct Span {
-    pub children: Vec<WidgetId>,
+    pub children: Vec<StrongWidget>,
     pub dir: Dir,
     pub gap: f32,
 }
@@ -62,6 +62,14 @@ impl Span {
         self
     }
 
+    pub fn push(&mut self, w: StrongWidget) {
+        self.children.push(w);
+    }
+
+    pub fn pop(&mut self) -> Option<StrongWidget> {
+        self.children.pop()
+    }
+
     fn len_sum(&mut self, ctx: &mut SizeCtx) -> Len {
         let gap = self.gap * self.children.len().saturating_sub(1) as f32;
         self.children.iter().fold(Len::abs(gap), |mut s, id| {
@@ -144,28 +152,31 @@ impl Span {
     }
 }
 
-pub struct SpanBuilder<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> {
+pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
     pub children: Wa,
     pub dir: Dir,
     pub gap: f32,
-    _pd: PhantomData<Tag>,
+    _pd: PhantomData<(State, Tag)>,
 }
 
-impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> FnOnce<(&mut Ui,)>
+impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
-    for SpanBuilder<LEN, Wa, Tag>
+    for SpanBuilder<Rsc, LEN, Wa, Tag>
 {
-    type Output = Span;
+    type Widget = Span;
 
-    extern "rust-call" fn call_once(self, args: (&mut Ui,)) -> Self::Output {
+    #[track_caller]
+    fn run(self, rsc: &mut Rsc) -> Self::Widget {
         Span {
-            children: self.children.ui(args.0).arr.to_vec(),
+            children: self.children.add(rsc).arr.into_iter().collect(),
             dir: self.dir,
             gap: self.gap,
         }
     }
 }
 
-impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> SpanBuilder<LEN, Wa, Tag> {
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    SpanBuilder<State, LEN, Wa, Tag>
+{
     pub fn new(children: Wa, dir: Dir) -> Self {
         Self {
             children,
@@ -182,7 +193,7 @@ impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> SpanBuilder<LEN, Wa, Ta
 }
 
 impl std::ops::Deref for Span {
-    type Target = Vec<WidgetId>;
+    type Target = Vec<StrongWidget>;
 
     fn deref(&self) -> &Self::Target {
         &self.children

src/widget/position/stack.rs

@@ -3,7 +3,7 @@ use std::marker::PhantomData;
 use crate::prelude::*;
 
 pub struct Stack {
-    pub children: Vec<WidgetId>,
+    pub children: Vec<StrongWidget>,
     pub size: StackSize,
 }
 
@@ -42,26 +42,29 @@ pub enum StackSize {
     Child(usize),
 }
 
-pub struct StackBuilder<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> {
+pub struct StackBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
     pub children: Wa,
     pub size: StackSize,
-    _pd: PhantomData<Tag>,
+    _pd: PhantomData<(State, Tag)>,
 }
 
-impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> FnOnce<(&mut Ui,)>
+impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
-    for StackBuilder<LEN, Wa, Tag>
+    for StackBuilder<Rsc, LEN, Wa, Tag>
 {
-    type Output = Stack;
+    type Widget = Stack;
 
-    extern "rust-call" fn call_once(self, args: (&mut Ui,)) -> Self::Output {
+    #[track_caller]
+    fn run(self, rsc: &mut Rsc) -> Self::Widget {
         Stack {
-            children: self.children.ui(args.0).arr.to_vec(),
+            children: self.children.add(rsc).arr.into_iter().collect(),
             size: self.size,
         }
     }
 }
 
-impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> StackBuilder<LEN, Wa, Tag> {
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    StackBuilder<State, LEN, Wa, Tag>
+{
     pub fn new(children: Wa) -> Self {
         Self {
             children,

src/widget/ptr.rs

@@ -0,0 +1,57 @@
+use crate::prelude::*;
+use std::marker::{Sized, Unsize};
+
+pub struct WidgetPtr {
+    pub inner: Option<StrongWidget>,
+}
+
+impl Widget for WidgetPtr {
+    fn draw(&mut self, painter: &mut Painter) {
+        if let Some(id) = &self.inner {
+            painter.widget(id);
+        }
+    }
+
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+        if let Some(id) = &self.inner {
+            ctx.width(id)
+        } else {
+            Len::ZERO
+        }
+    }
+
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+        if let Some(id) = &self.inner {
+            ctx.height(id)
+        } else {
+            Len::ZERO
+        }
+    }
+}
+
+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: StrongWidget<W>) {
+        self.inner = Some(to)
+    }
+
+    pub fn replace<W: ?Sized + Unsize<dyn Widget>>(
+        &mut self,
+        to: StrongWidget<W>,
+    ) -> Option<StrongWidget> {
+        self.inner.replace(to)
+    }
+}
+
+impl Default for WidgetPtr {
+    fn default() -> Self {
+        Self::empty()
+    }
+}