stuffff

Cargo.toml

@@ -1,12 +1,30 @@
 [package]
 name = "iris"
-version = "0.1.0"
-edition = "2024"
 default-run = "test"
+version.workspace = true
+edition.workspace = true
 
 # 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 }
+
+[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"
@@ -15,5 +33,6 @@ image = "0.25.6"
 cosmic-text = "0.15.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" }

TODO

@@ -16,6 +16,7 @@ scaling
     field could be best solution so redrawing stuff isn't needed & you can specify both as user
 
 WidgetRef<W> or smth instead of Id
+    fyi this is not the same as what was just implemented
     enum that's either an Id or an actual concrete instance of W
     painter takes them in instead of (or in addition to) id
     then type wrapper widgets to contain them

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/layout/attr.rs

@@ -1,11 +1,11 @@
-use crate::layout::{Ui, WidgetId, WidgetIdFn, WidgetLike};
+use crate::layout::{Ui, WidgetIdFn, WidgetLike, WidgetRef};
 
-pub trait WidgetAttr<W> {
+pub trait WidgetAttr<W: ?Sized> {
     type Input;
-    fn run(ui: &mut Ui, id: &WidgetId<W>, input: Self::Input);
+    fn run(ui: &mut Ui, id: WidgetRef<W>, input: Self::Input);
 }
 
-pub trait Attrable<W, Tag> {
+pub trait Attrable<W: ?Sized, Tag> {
     fn attr<A: WidgetAttr<W>>(self, input: A::Input) -> impl WidgetIdFn<W>;
 }
 
@@ -13,7 +13,7 @@ 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);
+            A::run(ui, id.weak(), input);
             id
         }
     }

core/src/layout/event.rs

@@ -0,0 +1,209 @@
+use crate::{
+    layout::{LayerId, UiId, Widget, WidgetId, WidgetInstance, WidgetRef},
+    util::{Handle, HashMap, RefGuardMut},
+};
+use std::{
+    any::{Any, TypeId},
+    ops::DerefMut,
+    sync::{Arc, LazyLock, Mutex},
+};
+
+pub trait Async: Send + Sync + 'static {}
+impl<T: Send + Sync + 'static> Async for T {}
+
+pub trait Event: Sized + Async + Clone {
+    type Data<'a> = ();
+    type State: Sync + Send + Default = ();
+    #[allow(unused_variables)]
+    fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
+        true
+    }
+
+    /// THIS SHOULD NOT BE OVERWRITTEN; the default impl runs this event
+    fn run<Ctx: 'static, W>(id: WidgetRef<W>, data: &mut Self::Data<'_>, state: &mut Ctx) {
+        Events::<Self, Ctx>::run(id.id(), data, state);
+    }
+}
+
+pub trait EventAlias {
+    type Event: Event;
+    fn into_event(self) -> Self::Event;
+}
+
+impl<E: Event> EventAlias for E {
+    type Event = Self;
+
+    fn into_event(self) -> Self::Event {
+        self
+    }
+}
+
+type EventData<E, Ctx> = (E, Arc<dyn for<'a> EventFn<Ctx, <E as Event>::Data<'a>>>);
+pub struct Events<E: Event, Ctx> {
+    active: HashMap<UiId, HashMap<LayerId, HashMap<WidgetId, E::State>>>,
+    map: HashMap<WidgetId, Vec<EventData<E, Ctx>>>,
+}
+
+pub static EVENT_TYPES: LazyLock<Mutex<HashMap<TypeId, Handle<dyn EventManager>>>> =
+    LazyLock::new(|| Mutex::new(HashMap::default()));
+
+pub trait EventManager: Any + Send + Sync {
+    fn remove(&mut self, id: WidgetId) -> Box<dyn Any>;
+    fn draw(&mut self, ui: UiId, inst: &WidgetInstance);
+    fn undraw(&mut self, ui: UiId, inst: &WidgetInstance);
+}
+
+impl Handle<dyn EventManager> {
+    pub fn remove(&mut self, id: WidgetId) {
+        let mut s = self.get_mut();
+        // refer to s.remove documentation for why drop order
+        let contents = s.remove(id);
+        drop(s);
+        drop(contents);
+    }
+    pub fn draw(&mut self, ui: UiId, inst: &WidgetInstance) {
+        self.get_mut().draw(ui, inst);
+    }
+    pub fn undraw(&mut self, ui: UiId, inst: &WidgetInstance) {
+        self.get_mut().undraw(ui, inst);
+    }
+}
+
+impl<E: Event, Ctx: 'static> EventManager for Events<E, Ctx> {
+    /// so... there is a deadlock if this is called in WidgetData::drop
+    /// and some function in here owns another WidgetId
+    /// so for now you need to drop the lock on self, THEN drop the contents
+    /// which is implemented for Handle<dyn EventManager>
+    fn remove(&mut self, id: WidgetId) -> Box<dyn Any> {
+        let contents = self.map.remove(&id);
+        for ui in self.active.values_mut() {
+            for layer in ui.values_mut() {
+                layer.remove(&id);
+            }
+        }
+        Box::new(contents)
+    }
+    fn draw(&mut self, ui: UiId, inst: &WidgetInstance) {
+        self.active
+            .entry(ui)
+            .or_default()
+            .entry(inst.layer)
+            .or_default()
+            .entry(inst.id)
+            .or_default();
+    }
+    fn undraw(&mut self, ui: UiId, inst: &WidgetInstance) {
+        // rust pls
+        (|| {
+            self.active
+                .get_mut(&ui)?
+                .get_mut(&inst.layer)?
+                .remove(&inst.id);
+            Some(())
+        })();
+    }
+}
+
+pub type UiActive<State> = HashMap<LayerId, HashMap<WidgetId, State>>;
+
+impl<E: Event, Ctx: 'static> Events<E, Ctx> {
+    fn id() -> TypeId {
+        TypeId::of::<Self>()
+    }
+
+    fn new() -> Self {
+        Self {
+            map: Default::default(),
+            active: Default::default(),
+        }
+    }
+
+    pub fn active(id: UiId) -> impl DerefMut<Target = UiActive<E::State>> {
+        RefGuardMut::map(Self::get(), |s| s.active.entry(id).or_default())
+    }
+
+    fn register_<W: Widget + ?Sized>(
+        id: WidgetRef<W>,
+        event: impl Into<E>,
+        f: impl for<'a> EventFn<Ctx, <E as Event>::Data<'a>>,
+    ) {
+        let Some(mut data) = id.data_mut() else {
+            return;
+        };
+        data.event_managers.insert(Self::id());
+        Self::get()
+            .map
+            .entry(id.id())
+            .or_default()
+            .push((event.into(), Arc::new(f)));
+    }
+
+    pub fn register<W: Widget + ?Sized + 'static>(
+        id: WidgetRef<W>,
+        event: impl Into<E>,
+        f: impl for<'a> EventIdFn<Ctx, <E as Event>::Data<'a>, W>,
+    ) {
+        Self::register_(id, event, move |ctx| {
+            f(EventIdCtx {
+                widget: id,
+                state: ctx.state,
+                data: ctx.data,
+            })
+        });
+    }
+
+    pub fn run(id: WidgetId, data: &mut E::Data<'_>, state: &mut Ctx) {
+        let s = Self::get();
+        if let Some(fs) = s.map.get(&id) {
+            let fs = fs.clone();
+            drop(s);
+            for (e, f) in fs {
+                if e.should_run(data) {
+                    f(EventCtx { state, data })
+                }
+            }
+        }
+    }
+
+    pub fn run_all(data: &mut E::Data<'_>, state: &mut Ctx) {
+        let s = Self::get();
+        // TODO: should probably document that added events won't run same frame
+        let mut map = s.map.clone();
+        drop(s);
+        for fs in map.values_mut() {
+            for (e, f) in fs {
+                if e.should_run(data) {
+                    f(EventCtx { state, data })
+                }
+            }
+        }
+    }
+
+    /// this some bull
+    fn get<'a>() -> RefGuardMut<'a, Self> {
+        let any = EVENT_TYPES
+            .lock()
+            .unwrap()
+            .entry(Self::id())
+            .or_insert_with(|| Handle::from(Self::new()))
+            .clone();
+        unsafe { any.downcast() }.get_take_mut()
+    }
+}
+
+pub struct EventCtx<'a, Ctx, Data> {
+    pub state: &'a mut Ctx,
+    pub data: &'a mut Data,
+}
+
+pub struct EventIdCtx<'a, Ctx, Data, W: ?Sized> {
+    pub widget: WidgetRef<W>,
+    pub state: &'a mut Ctx,
+    pub data: &'a mut Data,
+}
+
+pub trait EventFn<Ctx, Data>: Fn(EventCtx<Ctx, Data>) + Async {}
+impl<F: Fn(EventCtx<Ctx, Data>) + Async, Ctx, Data> EventFn<Ctx, Data> for F {}
+
+pub trait EventIdFn<Ctx, Data, W: ?Sized>: Fn(EventIdCtx<Ctx, Data, W>) + Async {}
+impl<F: Fn(EventIdCtx<Ctx, Data, W>) + Async, Ctx, Data, W: ?Sized> EventIdFn<Ctx, Data, W> for F {}

core/src/layout/mod.rs

@@ -1,33 +1,24 @@
-mod color;
+mod attr;
 mod event;
-mod id;
-mod layer;
 mod module;
 mod num;
 mod orientation;
 mod painter;
-mod text;
+mod primitive;
-mod texture;
 mod ui;
-mod attr;
+mod view;
-mod vec2;
 mod widget;
-mod widgets;
 
-pub use color::*;
+pub use attr::*;
 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 primitive::*;
-pub use texture::*;
 pub use ui::*;
-pub use attr::*;
+pub use view::*;
-pub use vec2::*;
 pub use widget::*;
-pub use widgets::*;
 
+pub use crate::util::Vec2;
 pub type UiColor = Color<u8>;

core/src/layout/module.rs

@@ -1,15 +1,15 @@
 use std::any::{Any, TypeId};
 
 use crate::{
-    layout::WidgetInstance,
+    layout::{WidgetId, WidgetInstance},
-    util::{HashMap, Id},
+    util::HashMap,
 };
 
 #[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_remove(&mut self, id: &WidgetId) {}
     fn on_move(&mut self, inst: &WidgetInstance) {}
 }
 

core/src/layout/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
+    }
+}
+
+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<T: const UiNum + Copy> const From<T> for Vec2 {
+    fn from(v: T) -> Self {
+        Self {
+            x: v.to_f32(),
+            y: v.to_f32(),
+        }
+    }
+}
+
+pub const fn vec2(x: impl const UiNum, y: impl const UiNum) -> Vec2 {
+    Vec2::new(x.to_f32(), y.to_f32())
+}

core/src/layout/orientation/axis.rs

@@ -6,6 +6,9 @@ pub enum Axis {
     Y,
 }
 
+pub trait Axis_ {
+}
+
 impl std::ops::Not for Axis {
     type Output = Self;
 

core/src/layout/orientation/len.rs

@@ -41,6 +41,11 @@ impl Size {
         y: Len::ZERO,
     };
 
+    pub const REST: Self = Self {
+        x: Len::REST,
+        y: Len::REST,
+    };
+
     pub fn abs(v: Vec2) -> Self {
         Self {
             x: Len::abs(v.x),
@@ -97,6 +102,12 @@ impl Len {
         rest: 0.0,
     };
 
+    pub const REST: Self = Self {
+        abs: 0.0,
+        rel: 0.0,
+        rest: 1.0,
+    };
+
     pub fn apply_rest(&self) -> UiScalar {
         UiScalar {
             rel: self.rel + if self.rest > 0.0 { 1.0 } else { 0.0 },

core/src/layout/orientation/mod.rs

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

core/src/layout/painter.rs

@@ -1,83 +1,104 @@
+use std::{marker::Unsize, sync::mpsc::Sender};
+
 use crate::{
     layout::{
-        Axis, Len, Modules, PrimitiveLayers, RenderedText, Size, TextAttrs, TextBuffer, TextData,
+        Axis, LayerId, Len, PrimitiveLayers, RenderedText, Size, TextAttrs, TextBuffer, TextData,
-        TextureHandle, Textures, UiRegion, UiVec2, Vec2, WidgetId, Widgets,
+        TextureHandle, Textures, UiId, UiRegion, UiVec2, Vec2, Widget, WidgetHandle, WidgetId,
+        WidgetUpdate,
     },
     render::{Mask, MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst},
-    util::{HashMap, HashSet, Id, TrackedArena},
+    util::{HashMap, HashSet, RefMap, TrackedArena},
 };
 
 /// makes your surfaces look pretty
 pub struct Painter<'a, 'c> {
     ctx: &'a mut PainterCtx<'c>,
+    widget: WidgetHandle,
+    id: WidgetId,
     region: UiRegion,
     mask: MaskIdx,
     textures: Vec<TextureHandle>,
     primitives: Vec<PrimitiveHandle>,
-    children: Vec<Id>,
+    children: Vec<WidgetId>,
-    children_width: HashMap<Id, (UiVec2, Len)>,
+    children_width: HashMap<WidgetId, (UiVec2, Len)>,
-    children_height: HashMap<Id, (UiVec2, Len)>,
+    children_height: HashMap<WidgetId, (UiVec2, Len)>,
     pub layer: usize,
-    id: Id,
 }
 
 /// context for a painter; lets you draw and redraw widgets
 struct PainterCtx<'a> {
-    pub widgets: &'a Widgets,
+    ui_id: UiId,
-    pub active: &'a mut HashMap<Id, WidgetInstance>,
+    pub active: &'a mut HashMap<WidgetId, 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,
+    send: &'a Sender<WidgetUpdate>,
-    pub cache_width: HashMap<Id, (UiVec2, Len)>,
+    pub cache_width: HashMap<WidgetId, (UiVec2, Len)>,
-    pub cache_height: HashMap<Id, (UiVec2, Len)>,
+    pub cache_height: HashMap<WidgetId, (UiVec2, Len)>,
-    pub needs_redraw: HashSet<Id>,
+    pub needs_redraw: HashSet<WidgetId>,
-    draw_started: HashSet<Id>,
+    draw_started: HashSet<WidgetId>,
 }
 
 /// 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))>,
+    x: Option<(WidgetId, (UiVec2, Len))>,
-    y: Option<(Id, (UiVec2, Len))>,
+    y: Option<(WidgetId, (UiVec2, Len))>,
 }
 
 /// important non rendering data for retained drawing
 #[derive(Debug)]
 pub struct WidgetInstance {
-    pub id: Id,
+    pub id: WidgetId,
     pub region: UiRegion,
-    pub parent: Option<Id>,
+    pub parent: Option<WidgetId>,
     pub textures: Vec<TextureHandle>,
     pub primitives: Vec<PrimitiveHandle>,
-    pub children: Vec<Id>,
+    pub children: Vec<WidgetId>,
     pub resize: ResizeRef,
     pub mask: MaskIdx,
-    pub layer: usize,
+    pub layer: LayerId,
 }
 
 /// data to be stored in Ui to create PainterCtxs easily
-#[derive(Default)]
+/// TODO: actually use this LMAO
 pub struct PainterData {
-    pub widgets: Widgets,
+    ui_id: UiId,
-    pub active: HashMap<Id, WidgetInstance>,
+    pub active: HashMap<WidgetId, WidgetInstance>,
     pub layers: PrimitiveLayers,
     pub textures: Textures,
     pub text: TextData,
     pub output_size: Vec2,
-    pub modules: Modules,
+    pub px_dependent: HashSet<WidgetId>,
-    pub px_dependent: HashSet<Id>,
     pub masks: TrackedArena<Mask, u32>,
+    send: Sender<WidgetUpdate>,
+}
+
+impl PainterData {
+    pub fn new(ui_id: UiId, send: Sender<WidgetUpdate>) -> Self {
+        Self {
+            ui_id,
+            active: Default::default(),
+            layers: Default::default(),
+            textures: Default::default(),
+            text: Default::default(),
+            output_size: Default::default(),
+            px_dependent: Default::default(),
+            masks: Default::default(),
+            send,
+        }
+    }
 }
 
 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) {
+    pub fn redraw<W: Widget + ?Sized + Unsize<dyn Widget>>(&mut self, widget: &WidgetHandle<W>) {
+        let id = widget.id();
         self.needs_redraw.remove(&id);
         if self.draw_started.contains(&id) {
             return;
@@ -105,17 +126,18 @@ impl<'a> PainterCtx<'a> {
                 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);
+            .width(widget);
-            if new_desired != *old_desired {
+            if new_desired != *old_desired
+                && let Some(w) = rid.strong()
+            {
                 // unsure if I need to walk down the tree here
-                self.redraw(*rid);
+                self.redraw(&w);
                 *old_desired = new_desired;
                 if self.draw_started.contains(&id) {
                     ret = true;
@@ -131,16 +153,17 @@ impl<'a> PainterCtx<'a> {
                 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);
+            .height(widget);
-            if new_desired != *old_desired {
+            if new_desired != *old_desired
-                self.redraw(*rid);
+                && let Some(w) = rid.strong()
+            {
+                self.redraw(&w);
                 *old_desired = new_desired;
                 if self.draw_started.contains(&id) {
                     ret = true;
@@ -152,13 +175,13 @@ impl<'a> PainterCtx<'a> {
             return finish(self, resize);
         }
 
-        let Some(active) = self.remove(id) else {
+        let Some(active) = self.remove(id, false) else {
             return;
         };
 
         self.draw_inner(
             active.layer,
-            id,
+            widget,
             active.region,
             active.parent,
             active.mask,
@@ -167,15 +190,17 @@ impl<'a> PainterCtx<'a> {
         finish(self, resize);
     }
 
-    fn draw_inner(
+    fn draw_inner<W: Widget + ?Sized + Unsize<dyn Widget>>(
         &mut self,
         layer: usize,
-        id: Id,
+        widget: &WidgetHandle<W>,
         region: UiRegion,
-        parent: Option<Id>,
+        parent: Option<WidgetId>,
         mask: MaskIdx,
-        old_children: Option<Vec<Id>>,
+        old_children: Option<Vec<WidgetId>>,
     ) {
+        let id = widget.id();
+        widget.data_mut().send = Some(self.send.clone());
         // 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
@@ -206,7 +231,7 @@ impl<'a> PainterCtx<'a> {
                 return;
             }
             // if not, then maintain resize and track old children to remove unneeded
-            let active = self.remove(id).unwrap();
+            let active = self.remove(id, false).unwrap();
             old_children = active.children;
             resize = active.resize;
         }
@@ -218,6 +243,7 @@ impl<'a> PainterCtx<'a> {
             region,
             mask,
             layer,
+            widget: widget.as_any(),
             id,
             textures: Vec::new(),
             primitives: Vec::new(),
@@ -227,7 +253,7 @@ impl<'a> PainterCtx<'a> {
             children_height: Default::default(),
         };
 
-        painter.ctx.widgets.get_dyn_dynamic(id).draw(&mut painter);
+        widget.get_mut_quiet().draw(&mut painter);
 
         let children_width = painter.children_width;
         let children_height = painter.children_height;
@@ -267,23 +293,20 @@ impl<'a> PainterCtx<'a> {
             }
         }
 
-        // update modules
+        // run events
-        for m in self.modules.iter_mut() {
+        id.map_event_managers(|mut m| {
-            m.on_draw(&instance);
+            m.draw(self.ui_id, &instance);
-        }
+        });
         self.active.insert(id, instance);
     }
 
-    fn mov(&mut self, id: Id, from: UiRegion, to: UiRegion) {
+    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);
-        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();
@@ -293,7 +316,7 @@ impl<'a> PainterCtx<'a> {
     }
 
     /// NOTE: instance textures are cleared and self.textures freed
-    fn remove(&mut self, id: Id) -> Option<WidgetInstance> {
+    fn remove(&mut self, id: WidgetId, undraw: bool) -> Option<WidgetInstance> {
         let mut inst = self.active.remove(&id);
         if let Some(inst) = &mut inst {
             for h in &inst.primitives {
@@ -304,15 +327,17 @@ impl<'a> PainterCtx<'a> {
             }
             inst.textures.clear();
             self.textures.free();
-            for m in self.modules.iter_mut() {
+            if undraw {
-                m.on_undraw(inst);
+                id.map_event_managers(|mut m| {
+                    m.undraw(self.ui_id, inst);
+                });
             }
         }
         inst
     }
 
-    fn remove_rec(&mut self, id: Id) -> Option<WidgetInstance> {
+    fn remove_rec(&mut self, id: WidgetId) -> Option<WidgetInstance> {
-        let inst = self.remove(id);
+        let inst = self.remove(id, true);
         if let Some(inst) = &inst {
             for c in &inst.children {
                 self.remove_rec(*c);
@@ -323,16 +348,16 @@ impl<'a> PainterCtx<'a> {
 }
 
 impl PainterData {
-    fn ctx(&mut self, needs_redraw: HashSet<Id>) -> PainterCtx<'_> {
+    fn ctx(&mut self, needs_redraw: HashSet<WidgetId>) -> PainterCtx<'_> {
         PainterCtx {
-            widgets: &self.widgets,
+            ui_id: self.ui_id,
             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,
+            send: &self.send,
             cache_width: Default::default(),
             cache_height: Default::default(),
             draw_started: Default::default(),
@@ -340,17 +365,19 @@ impl PainterData {
         }
     }
 
-    pub fn draw(&mut self, id: Id) {
+    pub fn draw<W: Widget + ?Sized + Unsize<dyn Widget>>(&mut self, id: &WidgetHandle<W>) {
         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>) {
+    pub fn redraw(&mut self, ids: HashSet<WidgetId>) {
         let mut ctx = self.ctx(ids);
         while let Some(&id) = ctx.needs_redraw.iter().next() {
-            ctx.redraw(id);
+            if let Some(w) = id.strong() {
+                ctx.redraw(&w);
+            }
         }
     }
 }
@@ -360,7 +387,7 @@ impl<'a, 'c> Painter<'a, 'c> {
         let h = self.ctx.layers.write(
             self.layer,
             PrimitiveInst {
-                id: self.id,
+                id: self.id(),
                 primitive,
                 region,
                 mask_idx: self.mask,
@@ -388,20 +415,28 @@ impl<'a, 'c> Painter<'a, 'c> {
     }
 
     /// Draws a widget within this widget's region.
-    pub fn widget<W>(&mut self, id: &WidgetId<W>) {
+    pub fn widget<W: Widget + ?Sized + Unsize<dyn Widget>>(&mut self, id: &WidgetHandle<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) {
+    pub fn widget_within<W: Widget + ?Sized + Unsize<dyn Widget>>(
+        &mut self,
+        id: &WidgetHandle<W>,
+        region: UiRegion,
+    ) {
         self.widget_at(id, region.within(&self.region));
     }
 
-    fn widget_at<W>(&mut self, id: &WidgetId<W>, region: UiRegion) {
+    fn widget_at<W: Widget + ?Sized + Unsize<dyn Widget>>(
-        self.children.push(id.id);
+        &mut self,
+        id: &WidgetHandle<W>,
+        region: UiRegion,
+    ) {
+        self.children.push(id.id());
         self.ctx
-            .draw_inner(self.layer, id.id, region, Some(self.id), self.mask, None);
+            .draw_inner(self.layer, id, region, Some(self.id()), self.mask, None);
     }
 
     pub fn texture_within(&mut self, handle: &TextureHandle, region: UiRegion) {
@@ -421,18 +456,21 @@ impl<'a, 'c> Painter<'a, 'c> {
 
     /// 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)
+        self.ctx
+            .text
+            .get_mut()
+            .draw(buffer, attrs, self.ctx.textures)
     }
 
     pub fn region(&self) -> UiRegion {
         self.region
     }
 
-    pub fn size<W>(&mut self, id: &WidgetId<W>) -> Size {
+    pub fn size<W: Widget + ?Sized>(&mut self, id: &WidgetHandle<W>) -> Size {
         self.size_ctx().size(id)
     }
 
-    pub fn len_axis<W>(&mut self, id: &WidgetId<W>, axis: Axis) -> Len {
+    pub fn len_axis<W: Widget + ?Sized>(&mut self, id: &WidgetHandle<W>, axis: Axis) -> Len {
         match axis {
             Axis::X => self.size_ctx().width(id),
             Axis::Y => self.size_ctx().height(id),
@@ -441,16 +479,15 @@ impl<'a, 'c> Painter<'a, 'c> {
 
     pub fn size_ctx(&mut self) -> SizeCtx<'_> {
         SizeCtx {
+            source: self.id(),
+            id: self.id(),
             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(),
         }
     }
@@ -475,40 +512,39 @@ impl<'a, 'c> Painter<'a, 'c> {
         self.layer = self.ctx.layers.next(self.layer);
     }
 
-    pub fn label(&self) -> &str {
+    pub fn label(&self) -> RefMap<'_, String> {
-        &self.ctx.widgets.data(&self.id).unwrap().label
+        self.widget.get_label()
     }
 
-    pub fn id(&self) -> &Id {
+    pub fn id(&self) -> WidgetId {
-        &self.id
+        self.id
     }
 }
 
 pub struct SizeCtx<'a> {
     pub text: &'a mut TextData,
     pub textures: &'a mut Textures,
-    source: Id,
+    source: WidgetId,
-    widgets: &'a Widgets,
+    cache_width: &'a mut HashMap<WidgetId, (UiVec2, Len)>,
-    cache_width: &'a mut HashMap<Id, (UiVec2, Len)>,
+    cache_height: &'a mut HashMap<WidgetId, (UiVec2, Len)>,
-    cache_height: &'a mut HashMap<Id, (UiVec2, Len)>,
+    checked_width: &'a mut HashMap<WidgetId, (UiVec2, Len)>,
-    checked_width: &'a mut HashMap<Id, (UiVec2, Len)>,
+    checked_height: &'a mut HashMap<WidgetId, (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,
+    id: WidgetId,
 }
 
 impl SizeCtx<'_> {
-    pub fn id(&self) -> &Id {
+    pub fn id(&self) -> &WidgetId {
         &self.id
     }
 
-    pub fn source(&self) -> &Id {
+    pub fn source(&self) -> &WidgetId {
         &self.source
     }
 
-    fn width_inner(&mut self, id: Id) -> Len {
+    pub fn width<W: Widget + ?Sized>(&mut self, widget: &WidgetHandle<W>) -> 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
@@ -519,11 +555,12 @@ impl SizeCtx<'_> {
         //     return len;
         // }
         // store self vars that need to be maintained
+        let id = widget.id();
         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);
+        let len = widget.get_mut_quiet().desired_width(self);
         // restore vars & update cache + checked
         self.outer = self_outer;
         self.id = self_id;
@@ -533,17 +570,18 @@ impl SizeCtx<'_> {
     }
 
     // TODO: should be refactored to share code w width_inner
-    fn height_inner(&mut self, id: Id) -> Len {
+    pub fn height<W: Widget + ?Sized>(&mut self, widget: &WidgetHandle<W>) -> 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 id = widget.id();
         let self_outer = self.outer;
         let self_id = self.id;
         self.id = id;
-        let len = self.widgets.get_dyn_dynamic(id).desired_height(self);
+        let len = widget.get_mut_quiet().desired_height(self);
         self.outer = self_outer;
         self.id = self_id;
         self.cache_height.insert(id, (self.outer, len));
@@ -551,22 +589,14 @@ impl SizeCtx<'_> {
         len
     }
 
-    pub fn width<W>(&mut self, id: &WidgetId<W>) -> Len {
+    pub fn len_axis<W: Widget + ?Sized>(&mut self, id: &WidgetHandle<W>, axis: Axis) -> 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 {
+    pub fn size<W: Widget + ?Sized>(&mut self, id: &WidgetHandle<W>) -> Size {
         Size {
             x: self.width(id),
             y: self.height(id),
@@ -582,10 +612,6 @@ impl SizeCtx<'_> {
     }
 
     pub fn draw_text(&mut self, buffer: &mut TextBuffer, attrs: &TextAttrs) -> RenderedText {
-        self.text.draw(buffer, attrs, self.textures)
+        self.text.get_mut().draw(buffer, attrs, self.textures)
-    }
-
-    pub fn label(&self, id: &Id) -> &String {
-        self.widgets.label(id)
     }
 }

core/src/layout/primitive/color.rs

@@ -1,5 +1,7 @@
 #![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)]
@@ -56,23 +58,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/layout/primitive/layer.rs

@@ -2,6 +2,8 @@ use std::ops::{Index, IndexMut};
 
 use crate::render::{MaskIdx, Primitive, PrimitiveHandle, PrimitiveInst, Primitives};
 
+pub type LayerId = usize;
+
 struct LayerNode<T> {
     next: Ptr,
     prev: Ptr,

core/src/layout/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/layout/primitive/text.rs

@@ -1,6 +1,9 @@
 use std::simd::{Simd, num::SimdUint};
 
-use crate::layout::{Align, RegionAlign, TextureHandle, Textures, UiColor, Vec2};
+use crate::{
+    layout::{Align, RegionAlign, TextureHandle, Textures, UiColor, Vec2},
+    util::Handle,
+};
 use cosmic_text::{
     Attrs, AttrsList, Buffer, CacheKey, Color, Family, FontSystem, Metrics, Placement, SwashCache,
     SwashContent,
@@ -12,13 +15,15 @@ pub mod text_lib {
     pub use cosmic_text::*;
 }
 
-pub struct TextData {
+pub type TextData = Handle<TextDataInner>;
+
+pub struct TextDataInner {
     pub font_system: FontSystem,
     pub swash_cache: SwashCache,
     glyph_cache: Vec<(Placement, CacheKey, Color)>,
 }
 
-impl Default for TextData {
+impl Default for TextDataInner {
     fn default() -> Self {
         Self {
             font_system: FontSystem::new(),
@@ -63,7 +68,7 @@ impl Default for TextAttrs {
         Self {
             color: UiColor::WHITE,
             font_size: size,
-            line_height: size * 1.2,
+            line_height: size * LINE_HEIGHT_MULT,
             family: Family::SansSerif,
             wrap: false,
             align: Align::CENTER_LEFT,
@@ -71,7 +76,9 @@ impl Default for TextAttrs {
     }
 }
 
-impl TextData {
+pub const LINE_HEIGHT_MULT: f32 = 1.1;
+
+impl TextDataInner {
     pub fn draw(
         &mut self,
         buffer: &mut TextBuffer,

core/src/layout/ui.rs

@@ -0,0 +1,159 @@
+use image::DynamicImage;
+
+use crate::{
+    layout::{
+        IdLike, PainterData, PixelRegion, TextureHandle, Vec2, WidgetHandle, WidgetId,
+        WidgetInstance, WidgetLike, WidgetUpdate,
+    },
+    util::{HashMap, HashSet, Id, StaticIdTracker},
+};
+use std::sync::mpsc::{Receiver, channel};
+
+static ID_TRACKER: StaticIdTracker = StaticIdTracker::new();
+pub type UiId = Id;
+
+pub struct Ui {
+    id: UiId,
+    pub(crate) data: PainterData,
+    root: Option<WidgetHandle>,
+    updates: HashSet<WidgetId>,
+    recv: Receiver<WidgetUpdate>,
+    full_redraw: bool,
+    resized: bool,
+}
+
+impl Ui {
+    pub fn id(&self) -> UiId {
+        self.id
+    }
+    pub fn set_root<Tag>(&mut self, w: impl WidgetLike<Tag>) {
+        self.root = Some(w.add(self));
+        self.full_redraw = true;
+    }
+
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn add_texture(&mut self, image: DynamicImage) -> TextureHandle {
+        self.data.textures.add(image)
+    }
+
+    pub fn resize(&mut self, size: impl Into<Vec2>) {
+        self.data.output_size = size.into();
+        self.resized = true;
+    }
+
+    fn redraw_all(&mut self) {
+        for (id, inst) in self.data.active.drain() {
+            id.map_event_managers(|mut m| {
+                m.undraw(self.id, &inst);
+            });
+        }
+        // free before bc nothing should exist
+        self.free();
+        if let Some(root) = &self.root {
+            self.data.draw(root);
+        }
+    }
+
+    pub fn update(&mut self) -> bool {
+        for id in self.recv.try_iter() {
+            self.updates.insert(id);
+        }
+        if self.full_redraw {
+            self.redraw_all();
+            self.full_redraw = false;
+            true
+        } else if self.resized {
+            self.resized = false;
+            self.redraw_all();
+            true
+        } else if !self.updates.is_empty() {
+            self.redraw_updates();
+            true
+        } else {
+            false
+        }
+    }
+
+    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) {
+        self.data.textures.free();
+    }
+
+    pub fn needs_redraw(&self) -> bool {
+        self.full_redraw || !self.updates.is_empty()
+    }
+
+    pub fn active_widgets(&self) -> usize {
+        self.data.active.len()
+    }
+
+    pub fn active(&self) -> &HashMap<WidgetId, WidgetInstance> {
+        &self.data.active
+    }
+
+    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 widget = id.strong().unwrap();
+            if widget.get_label().as_str() == label {
+                Some(inst)
+            } else {
+                None
+            }
+        })
+    }
+
+    pub fn data(&self) -> &PainterData {
+        &self.data
+    }
+
+    pub fn data_mut(&mut self) -> &mut PainterData {
+        &mut self.data
+    }
+}
+
+impl Default for Ui {
+    fn default() -> Self {
+        let (send, recv) = channel();
+        let id = ID_TRACKER.next();
+        Self {
+            id,
+            data: PainterData::new(id, send),
+            root: Default::default(),
+            updates: Default::default(),
+            full_redraw: false,
+            recv,
+            resized: false,
+        }
+    }
+}
+
+impl Drop for Ui {
+    fn drop(&mut self) {
+        ID_TRACKER.free(self.id);
+    }
+}

core/src/layout/view.rs

@@ -0,0 +1,17 @@
+use crate::layout::{Widget, WidgetHandle, WidgetLike};
+use std::marker::Unsize;
+
+pub trait WidgetView {
+    type Widget: Widget + ?Sized + Unsize<dyn Widget> = dyn Widget;
+    fn view(self) -> WidgetHandle<Self::Widget>;
+}
+
+pub struct ViewTag;
+
+impl<WV: WidgetView> WidgetLike<ViewTag> for WV {
+    type Widget = WV::Widget;
+
+    fn add(self, _ui: &mut super::Ui) -> WidgetHandle<Self::Widget> {
+        self.view()
+    }
+}

core/src/layout/widget/data.rs

@@ -0,0 +1,31 @@
+use std::{any::TypeId, sync::mpsc::Sender};
+
+use crate::{
+    layout::{EVENT_TYPES, EventManager, WIDGETS, WidgetId, WidgetUpdate},
+    util::{Handle, HashSet},
+};
+
+pub struct WidgetData<W: ?Sized> {
+    pub id: WidgetId,
+    pub send: Option<Sender<WidgetUpdate>>,
+    pub label: String,
+    pub event_managers: HashSet<TypeId>,
+    pub widget: W,
+}
+
+impl<W: ?Sized> WidgetData<W> {
+    pub(crate) fn event_managers(&self) -> impl Iterator<Item = Handle<dyn EventManager>> {
+        self.event_managers
+            .iter()
+            .map(|id| EVENT_TYPES.lock().unwrap().get_mut(id).unwrap().clone())
+    }
+}
+
+impl<W: ?Sized> Drop for WidgetData<W> {
+    fn drop(&mut self) {
+        WIDGETS.remove(self.id);
+        for mut m in self.event_managers() {
+            m.remove(self.id);
+        }
+    }
+}

core/src/layout/widget/handle.rs

@@ -0,0 +1,244 @@
+use std::{marker::Unsize, mem::MaybeUninit, ops::CoerceUnsized};
+
+use crate::{
+    layout::{EventManager, IdFnTag, IdTag, Ui, WIDGETS, Widget, WidgetData, WidgetLike},
+    util::{
+        Handle, MappedRefGuard, MappedRefGuardMut, Ref, RefGuard, RefGuardMut, RefMap, RefMapMut,
+        RefMut, WeakHandle,
+    },
+};
+
+pub(super) type SlotTy = u32;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct WidgetId {
+    pub(super) i: SlotTy,
+    pub(super) genr: SlotTy,
+}
+
+/// A strong handle to a widget. Cannot be cloned, only one may exist
+/// Use .weak() to obtain weak references to this
+pub struct WidgetHandle<W: ?Sized = dyn Widget>(WidgetId, Handle<WidgetData<W>>);
+/// A weak handle to a widget. Implements Copy so you can easily pass into closures
+pub struct WidgetRef<W: ?Sized = dyn Widget>(WidgetId, *const W);
+
+pub type WidgetUpdate = WidgetId;
+
+impl<W: Widget> WidgetHandle<W> {
+    pub(super) fn new(id: WidgetId, 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(
+            id,
+            WidgetData {
+                id,
+                widget,
+                send: None,
+                label,
+                event_managers: Default::default(),
+            }
+            .into(),
+        )
+    }
+}
+
+impl<W: Widget + ?Sized + Unsize<dyn Widget>> WidgetHandle<W> {
+    pub(super) fn weak_inner(&self) -> WeakHandle<WidgetData<W>> {
+        self.1.weak()
+    }
+
+    pub fn any(self) -> WidgetHandle<dyn Widget> {
+        self
+    }
+
+    /// DO NOT CALL OTHER THAN TEMP IN PAINTER
+    pub(crate) fn as_any(&self) -> WidgetHandle<dyn Widget> {
+        WidgetHandle(self.0, self.1.clone())
+    }
+}
+
+impl<W: ?Sized> WidgetHandle<W> {
+    pub fn id(&self) -> WidgetId {
+        self.0
+    }
+
+    pub fn get(&self) -> RefMap<'_, W> {
+        Ref::map(self.1.get(), |i| &mut i.widget)
+    }
+
+    pub fn get_mut(&self) -> RefMapMut<'_, W> {
+        let inner = self.1.get_mut();
+        if let Some(send) = &inner.send {
+            let _ = send.send(self.0);
+        }
+        RefMut::map(inner, |i| &mut i.widget)
+    }
+
+    pub fn data(&self) -> Ref<'_, WidgetData<W>> {
+        self.1.get()
+    }
+
+    pub(crate) fn data_mut(&self) -> RefMut<'_, WidgetData<W>> {
+        self.1.get_mut()
+    }
+
+    pub(crate) fn get_mut_quiet(&self) -> RefMapMut<'_, W> {
+        RefMut::map(self.1.get_mut(), |i| &mut i.widget)
+    }
+
+    pub fn get_label(&self) -> RefMap<'_, String> {
+        Ref::map(self.1.get(), |i| &mut i.label)
+    }
+
+    pub fn set_label(&self, label: impl Into<String>) {
+        self.1.get_mut().label = label.into();
+    }
+
+    /// TODO: THIS SHOULD ALWAYS BE 1, remove this probably (weak count might be nice though)
+    pub fn refs(&self) -> usize {
+        self.1.refs()
+    }
+
+    pub fn weak(&self) -> WidgetRef<W> {
+        WidgetRef::new(self.0)
+    }
+}
+
+pub type WRef<'a, W> = MappedRefGuard<'a, WidgetData<W>, W>;
+pub type WRefMut<'a, W> = MappedRefGuardMut<'a, WidgetData<W>, W>;
+
+impl<W: Widget> WidgetRef<W> {
+    fn handle(&self) -> Handle<WidgetData<W>> {
+        WIDGETS.get_type(self.0).unwrap()
+    }
+
+    pub fn get<'a>(&self) -> WRef<'a, W> {
+        RefGuard::map(self.handle().get_take(), |i| &mut i.widget)
+    }
+
+    pub fn get_mut<'a>(&self) -> WRefMut<'a, W> {
+        let inner = self.handle().get_take_mut();
+
+        if let Some(send) = &inner.send {
+            let _ = send.send(self.0);
+        }
+        RefGuardMut::map(inner, |i| &mut i.widget)
+    }
+}
+
+impl<W: ?Sized + Widget> WidgetRef<W> {
+    pub fn data<'a>(&self) -> Option<RefGuard<'a, WidgetData<dyn Widget>>> {
+        Some(WIDGETS.get(self.0)?.get_take())
+    }
+
+    pub(crate) fn data_mut(&self) -> Option<RefGuardMut<'_, WidgetData<dyn Widget>>> {
+        Some(WIDGETS.get(self.0)?.get_take_mut())
+    }
+}
+
+impl<W: Widget + ?Sized + Unsize<dyn Widget>> WidgetRef<W> {
+    pub fn any(self) -> WidgetRef<dyn Widget> {
+        WidgetRef::new(self.0)
+    }
+}
+
+impl<W: ?Sized> WidgetRef<W> {
+    fn new(id: WidgetId) -> Self {
+        Self(id, unsafe { MaybeUninit::zeroed().assume_init() })
+    }
+
+    pub fn id(&self) -> WidgetId {
+        self.0
+    }
+}
+
+impl WidgetId {
+    /// THIS SHOULD ONLY BE CALLED FOR TEMP STUFF DURING PAINTING
+    pub(crate) fn strong(self) -> Option<WidgetHandle> {
+        Some(WidgetHandle(self, WIDGETS.get(self)?))
+    }
+
+    pub fn weak(self) -> WidgetRef {
+        WidgetRef::new(self)
+    }
+
+    pub(crate) fn map_event_managers(&self, f: impl Fn(Handle<dyn EventManager>)) {
+        let Some(data) = self.weak().data() else {
+            return;
+        };
+        for m in data.event_managers() {
+            f(m)
+        }
+    }
+}
+
+pub trait WidgetIdFn<W: ?Sized = dyn Widget>: FnOnce(&mut Ui) -> WidgetHandle<W> {}
+impl<W: ?Sized, F: FnOnce(&mut Ui) -> WidgetHandle<W>> WidgetIdFn<W> for F {}
+
+pub trait WidgetRet: FnOnce(&mut Ui) -> WidgetHandle {}
+impl<F: FnOnce(&mut Ui) -> WidgetHandle> WidgetRet for F {}
+
+impl<W: Widget + ?Sized + Unsize<dyn Widget> + 'static> WidgetLike<IdTag> for WidgetHandle<W> {
+    type Widget = W;
+    fn add(self, _: &mut Ui) -> WidgetHandle<W> {
+        self
+    }
+}
+
+impl<W: Widget + ?Sized + Unsize<dyn Widget> + 'static, F: FnOnce(&mut Ui) -> WidgetHandle<W>>
+    WidgetLike<IdFnTag> for F
+{
+    type Widget = W;
+    fn add(self, ui: &mut Ui) -> WidgetHandle<W> {
+        self(ui)
+    }
+}
+
+pub trait IdLike<W> {
+    fn id(&self) -> WidgetId;
+}
+
+impl<W> IdLike<W> for WidgetHandle<W> {
+    fn id(&self) -> WidgetId {
+        self.id()
+    }
+}
+
+impl<W> IdLike<W> for WidgetRef<W> {
+    fn id(&self) -> WidgetId {
+        self.id()
+    }
+}
+
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetHandle<U>> for WidgetHandle<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetRef<U>> for WidgetRef<T> {}
+
+impl<W> PartialEq for WidgetHandle<W> {
+    fn eq(&self, other: &Self) -> bool {
+        self.id() == other.id()
+    }
+}
+
+impl<W> std::fmt::Debug for WidgetHandle<W> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.id().fmt(f)
+    }
+}
+
+impl<W: ?Sized> Clone for WidgetRef<W> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<W: ?Sized> Copy for WidgetRef<W> {}
+
+impl<W: ?Sized> PartialEq for WidgetRef<W> {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+unsafe impl<W: ?Sized> Send for WidgetRef<W> {}
+unsafe impl<W: ?Sized> Sync for WidgetRef<W> {}

core/src/layout/widget/like.rs

@@ -0,0 +1,79 @@
+use super::*;
+use std::marker::Unsize;
+
+pub trait WidgetLike<Tag> {
+    type Widget: Widget + ?Sized + Unsize<dyn Widget> + 'static;
+
+    fn add(self, ui: &mut Ui) -> WidgetHandle<Self::Widget>;
+
+    fn with_id<W2>(
+        self,
+        f: impl FnOnce(&mut Ui, WidgetHandle<Self::Widget>) -> WidgetHandle<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);
+    }
+}
+
+pub struct WidgetArr<const LEN: usize> {
+    pub arr: [WidgetHandle; LEN],
+}
+
+impl<const LEN: usize> WidgetArr<LEN> {
+    pub fn new(arr: [WidgetHandle; LEN]) -> Self {
+        Self { arr }
+    }
+}
+
+pub trait WidgetArrLike<const LEN: usize, Tag> {
+    fn ui(self, ui: &mut Ui) -> WidgetArr<LEN>;
+}
+
+impl<const LEN: usize> WidgetArrLike<LEN, ArrTag> for WidgetArr<LEN> {
+    fn ui(self, _: &mut Ui) -> WidgetArr<LEN> {
+        self
+    }
+}
+
+// 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,)*) {
+            fn ui(self, ui: &mut Ui) -> WidgetArr<$n> {
+                #[allow(non_snake_case)]
+                let ($($W,)*) = self;
+                WidgetArr::new(
+                    [$($W.add(ui),)*],
+                )
+            }
+        }
+    };
+}
+
+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/layout/widget/mod.rs

@@ -0,0 +1,65 @@
+mod data;
+mod handle;
+mod like;
+mod tag;
+mod widgets;
+
+pub use data::*;
+pub use handle::*;
+pub use like::*;
+pub use tag::*;
+pub use widgets::*;
+
+use crate::layout::{Len, Painter, SizeCtx, Ui};
+
+pub trait Widget: 'static + Send + Sync {
+    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
+    }
+}
+
+/// 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 + ?Sized>: 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) -> WidgetHandle<W> {
+        self(ui).add(ui)
+    }
+}
+
+impl<W: Widget> WidgetLike<WidgetTag> for W {
+    type Widget = W;
+    fn add(self, _: &mut Ui) -> WidgetHandle<W> {
+        WIDGETS.insert(self)
+    }
+}
+
+pub trait WidgetOption {
+    fn get(self, ui: &mut Ui) -> Option<WidgetHandle>;
+}
+
+impl WidgetOption for () {
+    fn get(self, _: &mut Ui) -> Option<WidgetHandle> {
+        None
+    }
+}
+
+impl<F: FnOnce(&mut Ui) -> Option<WidgetHandle>> WidgetOption for F {
+    fn get(self, ui: &mut Ui) -> Option<WidgetHandle> {
+        self(ui)
+    }
+}

core/src/layout/widget/tag.rs

@@ -0,0 +1,5 @@
+pub struct WidgetTag;
+pub struct FnTag;
+pub struct IdTag;
+pub struct IdFnTag;
+pub struct ArrTag;

core/src/layout/widget/widgets.rs

@@ -0,0 +1,100 @@
+use std::sync::{Mutex, MutexGuard};
+
+use crate::{
+    layout::{
+        Widget, WidgetData, WidgetHandle,
+        widget::{SlotTy, WidgetId},
+    },
+    util::{Handle, WeakHandle},
+};
+
+pub(crate) static WIDGETS: Widgets = Widgets::new();
+pub(crate) struct Widgets(Mutex<Inner>);
+
+pub fn total_widgets() -> usize {
+    WIDGETS.len()
+}
+
+pub struct WidgetSlot {
+    genr: SlotTy,
+    data: WeakHandle<WidgetData<dyn Widget + Sync + Send>>,
+}
+
+struct Inner {
+    cur_id: SlotTy,
+    vec: Vec<WidgetSlot>,
+    free: Vec<SlotTy>,
+}
+
+impl Widgets {
+    pub const fn new() -> Self {
+        Self(Mutex::new(Inner {
+            cur_id: 0,
+            vec: Vec::new(),
+            free: Vec::new(),
+        }))
+    }
+
+    fn expect(&self) -> MutexGuard<'_, Inner> {
+        self.0.lock().unwrap()
+    }
+
+    pub fn get_type<W: 'static>(&self, id: WidgetId) -> Option<Handle<WidgetData<W>>> {
+        let slot = &self.expect().vec[id.i as usize];
+        if slot.genr != id.genr {
+            None
+        } else {
+            Some(unsafe { slot.data.clone().downcast() }.clone().strong()?)
+        }
+    }
+
+    pub fn get(&self, id: WidgetId) -> Option<Handle<WidgetData<dyn Widget>>> {
+        let slot = &self.expect().vec[id.i as usize];
+        if slot.genr != id.genr {
+            None
+        } else {
+            Some(slot.data.clone().strong()?)
+        }
+    }
+
+    pub fn insert<W: Widget>(&self, widget: W) -> WidgetHandle<W> {
+        let mut s = self.expect();
+        let id = s
+            .free
+            .pop()
+            .map(|i| {
+                assert!(s.vec[i as usize].data.dropped());
+                WidgetId {
+                    i,
+                    genr: s.vec[i as usize].genr,
+                }
+            })
+            .unwrap_or_else(|| {
+                let i = s.cur_id;
+                s.cur_id += 1;
+                WidgetId { i, genr: 0 }
+            });
+        let handle = WidgetHandle::new(id, widget);
+        let slot = WidgetSlot {
+            genr: id.genr,
+            data: handle.weak_inner(),
+        };
+        if id.i == s.vec.len() as SlotTy {
+            s.vec.push(slot);
+        } else {
+            s.vec[id.i as usize] = slot;
+        }
+        handle
+    }
+
+    pub fn remove(&self, id: WidgetId) {
+        let mut s = self.expect();
+        s.vec[id.i as usize].genr += 1;
+        s.free.push(id.i);
+    }
+
+    pub fn len(&self) -> usize {
+        let s = self.expect();
+        s.vec.len() - s.free.len()
+    }
+}

core/src/lib.rs

@@ -0,0 +1,21 @@
+#![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(mapped_lock_guards)]
+#![feature(ptr_metadata)]
+
+pub mod layout;
+pub mod render;
+pub mod util;
+
+pub use image;

core/src/render/primitive.rs

@@ -1,19 +1,17 @@
-use std::ops::{Deref, DerefMut};
-
 use crate::{
-    layout::{Color, UiRegion},
+    layout::{Color, UiRegion, WidgetId},
     render::{
         ArrBuf,
         data::{MaskIdx, PrimitiveInstance},
     },
-    util::Id,
 };
 use bytemuck::Pod;
+use std::ops::{Deref, DerefMut};
 use wgpu::*;
 
 pub struct Primitives {
     instances: Vec<PrimitiveInstance>,
-    assoc: Vec<Id>,
+    assoc: Vec<WidgetId>,
     data: PrimitiveData,
     free: Vec<usize>,
     pub updated: bool,
@@ -99,7 +97,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 +173,7 @@ impl Primitives {
 }
 
 pub struct PrimitiveChange {
-    pub id: Id,
+    pub id: WidgetId,
     pub old: usize,
     pub new: usize,
 }

core/src/util/arena.rs

@@ -7,7 +7,7 @@ pub struct Arena<T, I> {
     tracker: IdTracker<I>,
 }
 
-impl<T, I: IdNum> Arena<T, I> {
+impl<T, I: const IdNum> Arena<T, I> {
     pub fn new() -> Self {
         Self {
             data: Vec::new(),
@@ -36,7 +36,7 @@ impl<T, I: IdNum> Arena<T, I> {
     }
 }
 
-impl<T, I: IdNum> Default for Arena<T, I> {
+impl<T, I: const IdNum> Default for Arena<T, I> {
     fn default() -> Self {
         Self::new()
     }
@@ -48,7 +48,7 @@ pub struct TrackedArena<T, I> {
     pub changed: bool,
 }
 
-impl<T, I: IdNum> TrackedArena<T, I> {
+impl<T, I: const IdNum> TrackedArena<T, I> {
     pub fn new() -> Self {
         Self {
             inner: Arena::default(),
@@ -86,7 +86,7 @@ impl<T, I: IdNum> TrackedArena<T, I> {
     }
 }
 
-impl<T, I: IdNum> Default for TrackedArena<T, I> {
+impl<T, I: const IdNum> Default for TrackedArena<T, I> {
     fn default() -> Self {
         Self::new()
     }

core/src/util/handle.rs

@@ -0,0 +1,227 @@
+//! A helper type for Arc<Mutex<T>>
+//! Currently there are mut versions (of Ref stuff) which don't do anything different under the hood,
+//! leaving them in for now in case I decide RwLock is a desired feature
+
+use std::{
+    marker::Unsize,
+    ops::{CoerceUnsized, Deref, DerefMut},
+    sync::{Arc, MappedMutexGuard, Mutex, MutexGuard, Weak},
+};
+
+pub struct Handle<T: ?Sized>(Arc<Mutex<T>>);
+pub struct WeakHandle<T: ?Sized>(Weak<Mutex<T>>);
+
+pub type Ref<'a, T> = MutexGuard<'a, T>;
+pub type RefMut<'a, T> = MutexGuard<'a, T>;
+
+pub type RefMap<'a, T> = MappedMutexGuard<'a, T>;
+pub type RefMapMut<'a, T> = MappedMutexGuard<'a, T>;
+
+impl<T: ?Sized> Handle<T> {
+    pub fn get(&self) -> Ref<'_, T> {
+        self.0.lock().unwrap()
+    }
+
+    pub fn get_mut(&self) -> RefMut<'_, T> {
+        self.0.lock().unwrap()
+    }
+
+    pub fn get_take<'a>(self) -> RefGuard<'a, T> {
+        let handle = self;
+        RefGuard {
+            guard: unsafe {
+                std::mem::transmute::<MutexGuard<'_, T>, MutexGuard<'_, T>>(
+                    handle.0.lock().unwrap(),
+                )
+            },
+            handle,
+        }
+    }
+
+    pub fn get_take_mut<'a>(self) -> RefGuardMut<'a, T> {
+        let handle = self;
+        RefGuardMut {
+            guard: unsafe {
+                std::mem::transmute::<MutexGuard<'_, T>, MutexGuard<'_, T>>(
+                    handle.0.lock().unwrap(),
+                )
+            },
+            handle,
+        }
+    }
+
+    pub fn refs(&self) -> usize {
+        Arc::strong_count(&self.0)
+    }
+
+    pub fn weak(&self) -> WeakHandle<T> {
+        WeakHandle(Arc::downgrade(&self.0))
+    }
+
+    /// # Safety
+    /// you must guarantee the type outside
+    /// ideally you check the typeid, but this is often used
+    /// when the trait object is wrapped one or more times
+    /// and you'd have to implement each one individually
+    pub unsafe fn downcast<U: 'static>(self) -> Handle<U>
+    where
+        T: 'static,
+    {
+        let raw: *const Mutex<T> = Arc::into_raw(self.0);
+        let raw: *const Mutex<U> = raw.cast();
+        Handle(unsafe { Arc::from_raw(raw) })
+    }
+}
+
+impl<T: ?Sized> WeakHandle<T> {
+    pub fn strong(&self) -> Option<Handle<T>> {
+        Some(Handle(self.0.upgrade()?))
+    }
+
+    pub fn dropped(&self) -> bool {
+        self.0.strong_count() == 0
+    }
+
+    /// # Safety
+    /// you must guarantee the type outside
+    pub unsafe fn downcast<U: 'static>(self) -> WeakHandle<U>
+    where
+        T: 'static,
+    {
+        let raw: *const Mutex<T> = self.0.into_raw();
+        let raw: *const Mutex<U> = raw.cast();
+        WeakHandle(unsafe { Weak::from_raw(raw) })
+    }
+}
+
+impl<T: ?Sized> Clone for Handle<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<T: ?Sized> Clone for WeakHandle<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<T: Default> Default for Handle<T> {
+    fn default() -> Self {
+        Self(Default::default())
+    }
+}
+
+impl<T> From<T> for Handle<T> {
+    fn from(value: T) -> Self {
+        Self(Arc::new(Mutex::new(value)))
+    }
+}
+
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Handle<U>> for Handle<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WeakHandle<U>> for WeakHandle<T> {}
+
+// yucky
+
+// TODO: is drop order important here?
+// something stupid could happen that I don't know about
+// if handle is dropped before guard
+pub struct RefGuard<'a, T: ?Sized> {
+    guard: MutexGuard<'a, T>,
+    handle: Handle<T>,
+}
+
+pub struct RefGuardMut<'a, T: ?Sized> {
+    guard: MutexGuard<'a, T>,
+    handle: Handle<T>,
+}
+
+pub struct MappedRefGuard<'a, T: ?Sized, U> {
+    guard: MappedMutexGuard<'a, U>,
+    handle: Handle<T>,
+}
+
+pub struct MappedRefGuardMut<'a, T: ?Sized, U> {
+    guard: MappedMutexGuard<'a, U>,
+    handle: Handle<T>,
+}
+
+impl<'a, T: ?Sized> RefGuard<'a, T> {
+    pub fn map<U>(s: Self, f: impl FnOnce(&mut T) -> &mut U) -> MappedRefGuard<'a, T, U> {
+        MappedRefGuard {
+            guard: MutexGuard::map(s.guard, f),
+            handle: s.handle,
+        }
+    }
+}
+
+impl<'a, T: ?Sized> RefGuardMut<'a, T> {
+    pub fn map<U>(s: Self, f: impl FnOnce(&mut T) -> &mut U) -> MappedRefGuardMut<'a, T, U> {
+        MappedRefGuardMut {
+            guard: MutexGuard::map(s.guard, f),
+            handle: s.handle,
+        }
+    }
+}
+
+impl<'a, T: ?Sized, U> MappedRefGuard<'a, T, U> {
+    pub fn map<U2>(s: Self, f: impl FnOnce(&mut U) -> &mut U2) -> MappedRefGuard<'a, T, U2> {
+        MappedRefGuard {
+            guard: MappedMutexGuard::map(s.guard, f),
+            handle: s.handle,
+        }
+    }
+}
+
+impl<'a, T: ?Sized, U> MappedRefGuardMut<'a, T, U> {
+    pub fn map<U2>(s: Self, f: impl FnOnce(&mut U) -> &mut U2) -> MappedRefGuardMut<'a, T, U2> {
+        MappedRefGuardMut {
+            guard: MappedMutexGuard::map(s.guard, f),
+            handle: s.handle,
+        }
+    }
+}
+
+impl<T: ?Sized> Deref for RefGuard<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.guard
+    }
+}
+
+impl<T: ?Sized> Deref for RefGuardMut<'_, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.guard
+    }
+}
+
+impl<T: ?Sized> DerefMut for RefGuardMut<'_, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.guard
+    }
+}
+
+impl<T: ?Sized, U> Deref for MappedRefGuard<'_, T, U> {
+    type Target = U;
+
+    fn deref(&self) -> &Self::Target {
+        &self.guard
+    }
+}
+
+impl<T: ?Sized, U> Deref for MappedRefGuardMut<'_, T, U> {
+    type Target = U;
+
+    fn deref(&self) -> &Self::Target {
+        &self.guard
+    }
+}
+
+impl<T: ?Sized, U> DerefMut for MappedRefGuardMut<'_, T, U> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.guard
+    }
+}

core/src/util/id.rs

@@ -1,3 +1,5 @@
+use std::sync::Mutex;
+
 #[repr(C)]
 #[derive(Eq, Hash, PartialEq, Debug, Clone, Copy, bytemuck::Zeroable)]
 pub struct Id<I = u64>(I);
@@ -9,7 +11,14 @@ pub struct IdTracker<I = u64> {
     cur: Id<I>,
 }
 
-impl<I: IdNum> IdTracker<I> {
+impl<I: const IdNum> IdTracker<I> {
+    pub const fn new() -> Self {
+        Self {
+            free: Vec::new(),
+            cur: Id(I::first()),
+        }
+    }
+
     #[allow(clippy::should_implement_trait)]
     pub fn next(&mut self) -> Id<I> {
         if let Some(id) = self.free.pop() {
@@ -43,22 +52,19 @@ impl<I: IdNum> Id<I> {
     }
 }
 
-impl<I: IdNum> Default for IdTracker<I> {
+impl<I: const IdNum> Default for IdTracker<I> {
     fn default() -> Self {
-        Self {
+        Self::new()
-            free: Vec::new(),
-            cur: Id(I::first()),
-        }
     }
 }
 
-pub trait IdNum {
+pub const trait IdNum {
     fn first() -> Self;
     fn next(&self) -> Self;
     fn idx(&self) -> usize;
 }
 
-impl IdNum for u64 {
+impl const IdNum for u64 {
     fn first() -> Self {
         0
     }
@@ -72,7 +78,7 @@ impl IdNum for u64 {
     }
 }
 
-impl IdNum for u32 {
+impl const IdNum for u32 {
     fn first() -> Self {
         0
     }
@@ -85,3 +91,33 @@ impl IdNum for u32 {
         *self as usize
     }
 }
+
+pub struct StaticIdTracker<I = u64>(Mutex<IdTracker<I>>);
+
+impl<I: const IdNum> StaticIdTracker<I> {
+    pub const fn new() -> Self {
+        Self(Mutex::new(IdTracker::new()))
+    }
+
+    #[allow(clippy::should_implement_trait)]
+    pub fn next(&self) -> Id<I> {
+        let mut s = self.0.lock().unwrap();
+        if let Some(id) = s.free.pop() {
+            return id;
+        }
+        let next = s.cur.next();
+        std::mem::replace(&mut s.cur, next)
+    }
+
+    #[allow(dead_code)]
+    pub fn free(&self, id: Id<I>) {
+        let mut s = self.0.lock().unwrap();
+        s.free.push(id);
+    }
+}
+
+impl<I: const IdNum> Default for StaticIdTracker<I> {
+    fn default() -> Self {
+        Self::new()
+    }
+}

core/src/util/mod.rs

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

core/src/util/refcount.rs

@@ -10,6 +10,7 @@ impl RefCounter {
     pub fn new() -> Self {
         Self(Arc::new(0.into()))
     }
+    #[allow(unused)]
     pub fn refs(&self) -> u32 {
         self.0.load(Ordering::Acquire)
     }
@@ -17,11 +18,18 @@ impl RefCounter {
         let refs = self.0.fetch_sub(1, Ordering::Release);
         refs == 0
     }
+    #[allow(unused)]
     pub fn quiet_clone(&self) -> Self {
         Self(self.0.clone())
     }
 }
 
+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/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)

examples/minimal.rs

@@ -1,20 +1,14 @@
-use iris::{prelude::*, winit::*};
+use iris::{prelude::*};
 
 fn main() {
-    UiApp::<State>::run();
+    DefaultApp::<State>::run();
 }
 
-struct State {
+struct State;
-    ui: DefaultUi,
-}
 
-impl DefaultUiState for State {
+impl DefaultAppState for State {
-    fn new(mut ui: DefaultUi, _proxy: Proxy<Self::Event>) -> Self {
+    fn new(ui: &mut Ui, _state: &UiState, _proxy: Proxy<Self::Event>) -> Self {
-        rect(Color::RED).set_root(&mut ui);
+        rect(Color::RED).set_root(ui);
-        Self { ui }
+        Self
-    }
-
-    fn ui(&mut self) -> &mut DefaultUi {
-        &mut self.ui
     }
 }

macro/Cargo.toml

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

macro/src/lib.rs

@@ -0,0 +1,77 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{
+    Attribute, Block, Ident, ItemTrait, Signature, Token, Visibility,
+    parse::{Parse, ParseStream, Result},
+    parse_macro_input, parse_quote,
+};
+
+struct Input {
+    attrs: Vec<Attribute>,
+    vis: Visibility,
+    name: Ident,
+    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()?;
+        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,
+            fns,
+        })
+    }
+}
+
+#[proc_macro]
+pub fn widget_trait(input: TokenStream) -> TokenStream {
+    let Input {
+        attrs,
+        vis,
+        name,
+        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 mut trai: ItemTrait = parse_quote!(
+        #vis trait #name<WL: WidgetLike<Tag>, Tag> {
+            #(#sigs;)*
+        }
+    );
+
+    trai.attrs = attrs;
+
+    TokenStream::from(quote! {
+        #trai
+
+        impl<WL: WidgetLike<Tag>, Tag> #name<WL, Tag> for WL {
+            #(#impls)*
+        }
+    })
+}

readme.md

@@ -1,6 +1,6 @@
 # iris
 
-my take on a rust ui library (also my first ui library)
+my fisrt attempt at a rust ui library
 
 it's called iris because it's the structure around what you actually want to display and colorful
 
@@ -17,7 +17,7 @@ general ideas trynna use rn / experiment with:
 - retained mode
 - specifically designed around wgpu
 - postfix functions for most things to prevent unreadable indentation (going very well)
-- no macros in user code / actual LSP typechecking (variadic generics if you can hear me please save us)
+- 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)
 - widgets store outside of the actual rendering so they can be moved around and swapped easily (unsure about this but seems to work good for now)

src/bin/test/main.rs

@@ -1,22 +1,20 @@
 use cosmic_text::Family;
-use iris::{
+use iris::prelude::*;
-    prelude::*,
-    winit::{attr::Selectable, event::Submit, *},
-};
 use len_fns::*;
 use winit::event::WindowEvent;
 
 fn main() {
-    UiApp::<Client>::run();
+    DefaultApp::<Client>::run();
 }
 
 pub struct Client {
-    ui: DefaultUi,
+    info: WidgetRef<Text>,
-    info: WidgetId<Text>,
 }
 
-impl DefaultUiState for Client {
+event_ctx!(Client);
-    fn new(mut ui: DefaultUi, _proxy: Proxy<Self::Event>) -> Self {
+
+impl DefaultAppState for Client {
+    fn new(ui: &mut Ui, _state: &UiState, _proxy: Proxy<Self::Event>) -> Self {
         let rrect = rect(Color::WHITE).radius(20);
         let pad_test = (
             rrect.color(Color::BLUE),
@@ -39,7 +37,7 @@ impl DefaultUiState for Client {
                 .width(rest(3)),
         )
             .span(Dir::RIGHT)
-            .add(&mut ui);
+            .add(ui);
 
         let span_test = (
             rrect.color(Color::GREEN).width(100),
@@ -50,33 +48,31 @@ impl DefaultUiState for Client {
             rrect.color(Color::RED).width(100),
         )
             .span(Dir::LEFT)
-            .add(&mut ui);
+            .add(ui);
 
-        let span_add = Span::empty(Dir::RIGHT).add(&mut ui);
+        let span_add = Span::empty(Dir::RIGHT).add(ui);
-        let span_add_ = span_add.clone();
+        let span_add_ = span_add.weak();
 
         let add_button = rect(Color::LIME)
             .radius(30)
-            .on(CursorSense::click(), move |ctx: &mut Client, _| {
+            .on(CursorSense::click(), move |ctx| {
-                let child = ctx
+                let child = image(include_bytes!("assets/sungals.png"))
-                    .ui
+                    .center()
-                    .add(image(include_bytes!("assets/sungals.png")).center())
+                    .add(ctx.data.ui);
-                    .any();
+                span_add_.get_mut().children.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: &mut Client, _| {
+            .on(CursorSense::click(), move |_| {
-                ctx.ui[&span_add_].children.pop();
+                span_add_.get_mut().children.pop();
             })
             .sized((150, 150))
             .align(Align::BOT_LEFT);
 
-        let span_add_test = (span_add, add_button, del_button).stack().add(&mut ui);
+        let span_add_test = (span_add, add_button, del_button).stack().add(ui);
 
         let btext = |content| wtext(content).size(30);
 
@@ -99,17 +95,18 @@ impl DefaultUiState for Client {
             wtext("pretty cool right?").size(50),
         )
             .span(Dir::DOWN)
-            .add(&mut ui);
+            .add(ui);
 
-        let texts = Span::empty(Dir::DOWN).gap(10).add(&mut ui);
+        let texts = Span::empty(Dir::DOWN).gap(10).add(ui);
-        let msg_area = texts.clone().scroll().masked().background(rect(Color::SKY));
+        let texts_ = texts.weak();
+        let msg_area = texts.scroll().masked().background(rect(Color::SKY));
         let add_text = wtext("add")
             .editable(false)
             .text_align(Align::LEFT)
             .size(30)
             .attr::<Selectable>(())
-            .id_on(Submit, move |id, client: &mut Client, _| {
+            .on(Submit, move |ctx| {
-                let content = client.ui.text(id).take();
+                let content = ctx.widget.get_mut().take();
                 let text = wtext(content)
                     .editable(false)
                     .size(30)
@@ -118,19 +115,20 @@ impl DefaultUiState for Client {
                     .attr::<Selectable>(());
                 let msg_box = text
                     .background(rect(Color::WHITE.darker(0.5)))
-                    .add(&mut client.ui);
+                    .add(&mut Ui::new());
-                client.ui[&texts].children.push(msg_box.any());
+                texts_.get_mut().children.push(msg_box);
             })
-            .add(&mut ui);
+            .add(ui);
+        let add_text_ = add_text.weak();
         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 |client: &mut Client, _| {
+                        .on(CursorSense::click(), move |ctx| {
-                            client.run_event(&add_text, Submit, ());
+                            Events::<Submit, _>::run(add_text_.id(), &mut (), ctx.state);
                         })
                         .sized((40, 40)),
                 )
@@ -143,69 +141,73 @@ impl DefaultUiState for Client {
                 .align(Align::BOT),
         )
             .span(Dir::DOWN)
-            .add(&mut ui);
+            .add(ui);
 
-        let main = pad_test.clone().pad(10).add(&mut ui);
+        let main = pad_test.pad(10).add(ui);
+        let main_ = main.weak();
 
-        let switch_button = |color, to: WidgetId, label| {
+        let tab_handles = Handle::from((0, Vec::new()));
-            let main_ = main.clone();
+
+        let switch_button = |color, to: Option<WidgetHandle>, label| {
+            let tab_handles = tab_handles.clone();
+            let i = tab_handles.get().1.len();
+            tab_handles.get_mut().1.push(to);
             let rect = rect(color)
-                .id_on(CursorSense::click(), move |id, ui: &mut Ui, _| {
+                .on(CursorSense::click(), move |ctx| {
-                    ui[&main_.clone()].inner = to.clone();
+                    let (prev, all) = &mut *tab_handles.get_mut();
-                    ui[id].color = color.darker(0.3);
+                    if let Some(to) = &mut all[i] {
+                        let mut main = main_.get_mut();
+                        std::mem::swap(&mut main.inner, to);
+                        all.swap(*prev, i);
+                        *prev = i;
+                    }
+                    ctx.widget.get_mut().color = color.darker(0.3);
                 })
-                .edit_on(
+                .on(
                     CursorSense::HoverStart | CursorSense::unclick(),
-                    move |r, _| {
+                    move |ctx| {
-                        r.color = color.brighter(0.2);
+                        ctx.widget.get_mut().color = color.brighter(0.2);
                     },
                 )
-                .edit_on(CursorSense::HoverEnd, move |r, _| {
+                .on(CursorSense::HoverEnd, move |ctx| {
-                    r.color = color;
+                    ctx.widget.get_mut().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, None, "pad"),
-            switch_button(Color::GREEN, span_test.any(), "span"),
+            switch_button(Color::GREEN, Some(span_test), "span"),
-            switch_button(Color::BLUE, span_add_test.any(), "image span"),
+            switch_button(Color::BLUE, Some(span_add_test), "image span"),
-            switch_button(Color::MAGENTA, text_test.any(), "text layout"),
+            switch_button(Color::MAGENTA, Some(text_test), "text layout"),
             switch_button(
                 Color::YELLOW.mul_rgb(0.5),
-                text_edit_scroll.any(),
+                Some(text_edit_scroll),
                 "text edit scroll",
             ),
         )
             .span(Dir::RIGHT);
 
-        let info = wtext("").add(&mut ui);
+        let info_ = wtext("").add(ui);
-        let info_sect = info.clone().pad(10).align(Align::RIGHT);
+        let info = info_.weak();
+        let info_sect = info_.pad(10).align(Align::RIGHT);
 
         ((tabs.height(40), main).span(Dir::DOWN), info_sect)
             .stack()
-            .set_root(&mut ui);
+            .set_root(ui);
 
-        Self { ui, info }
+        Self { info }
     }
 
-    fn ui(&mut self) -> &mut DefaultUi {
+    fn window_event(&mut self, _: WindowEvent, ui: &mut Ui, state: &UiState) {
-        &mut self.ui
-    }
-
-    fn window_event(&mut self, _: WindowEvent) {
         let new = format!(
             "widgets: {}\nactive:{}\nviews: {}",
-            self.ui.num_widgets(),
+            total_widgets(),
-            self.ui.active_widgets(),
+            ui.active_widgets(),
-            self.ui.renderer.ui.view_count()
+            state.renderer.ui.view_count()
         );
-        if new != *self.ui[&self.info].content {
+        if new != *self.info.get().content {
-            *self.ui[&self.info].content = new;
+            *self.info.get_mut().content = new;
-        }
+        }
-        if self.ui.needs_redraw() {
-            self.ui.window.request_redraw();
-        }
-        self.ui.input.end_frame();
     }
 }

src/core/sense.rs

@@ -1,386 +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);
-            }
-        }
-    }
-}
-
-pub trait SensorCtx: UiCtx {
-    fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2);
-}
-
-impl<Ctx: UiCtx + 'static> SensorCtx for Ctx {
-    fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2) {
-        CursorModule::<Ctx>::run(self, cursor, window_size);
-    }
-}
-
-impl<Ctx: UiCtx + 'static> CursorModule<Ctx> {
-    pub fn run(ctx: &mut Ctx, cursor: &CursorState, window_size: Vec2) {
-        let layers = std::mem::take(&mut ctx.ui().data.layers);
-        let mut module = std::mem::take(ctx.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)(ctx, data);
-                    }
-                }
-            }
-            if sensed {
-                break;
-            }
-        }
-
-        let ui_mod = ctx.ui().data.modules.get_mut::<Self>();
-        std::mem::swap(ui_mod, &mut module);
-        ui_mod.merge(module);
-        ctx.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(&mut Ctx, E::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: &mut Ctx, data: CursorData| {
-                for f in &fs {
-                    f(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/default/app.rs

@@ -5,7 +5,7 @@ use winit::{
     window::WindowId,
 };
 
-pub trait UiState {
+pub trait AppState {
     type Event: 'static;
     fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self;
     fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop);
@@ -13,22 +13,22 @@ pub trait UiState {
     fn exit(&mut self);
 }
 
-pub struct UiApp<State: UiState> {
+pub struct App<State: AppState> {
     state: Option<State>,
     proxy: EventLoopProxy<State::Event>,
 }
 
-impl<State: UiState> UiApp<State> {
+impl<State: AppState> App<State> {
     pub fn run() {
         let event_loop = EventLoop::with_user_event().build().unwrap();
         let proxy = event_loop.create_proxy();
         event_loop
-            .run_app(&mut UiApp::<State> { state: None, proxy })
+            .run_app(&mut App::<State> { state: None, proxy })
             .unwrap();
     }
 }
 
-impl<State: UiState> ApplicationHandler<State::Event> for UiApp<State> {
+impl<State: AppState> ApplicationHandler<State::Event> for App<State> {
     fn resumed(&mut self, event_loop: &ActiveEventLoop) {
         if self.state.is_none() {
             let state = State::new(event_loop, self.proxy.clone());

src/default/attr.rs

@@ -0,0 +1,64 @@
+use crate::{default::UiState, prelude::*};
+use std::time::{Duration, Instant};
+use winit::dpi::{LogicalPosition, LogicalSize};
+
+event_ctx!(UiState);
+
+pub struct Selector;
+
+impl<W: Widget + 'static> WidgetAttr<W> for Selector {
+    type Input = WidgetRef<TextEdit>;
+
+    fn run(ui: &mut Ui, container: WidgetRef<W>, id: Self::Input) {
+        container.on(CursorSense::click_or_drag(), move |ctx| {
+            let ui = &mut ctx.data.ui;
+            let region = ui.window_region(&id).unwrap();
+            let id_pos = region.top_left;
+            let container_pos = ui.window_region(&container).unwrap().top_left;
+            let pos = ctx.data.pos + container_pos - id_pos;
+            let size = region.size();
+            select(ui, id, ctx.state, pos, size, ctx.data.sense.is_dragging());
+        });
+    }
+}
+
+pub struct Selectable;
+
+impl WidgetAttr<TextEdit> for Selectable {
+    type Input = ();
+
+    fn run(ui: &mut Ui, id: WidgetRef<TextEdit>, _: Self::Input) {
+        id.on(CursorSense::click_or_drag(), move |ctx| {
+            select(
+                ctx.data.ui,
+                id,
+                ctx.state,
+                ctx.data.pos,
+                ctx.data.size,
+                ctx.data.sense.is_dragging(),
+            );
+        });
+    }
+}
+
+fn select(
+    ui: &mut Ui,
+    id: WidgetRef<TextEdit>,
+    state: &mut UiState,
+    pos: Vec2,
+    size: Vec2,
+    dragging: bool,
+) {
+    let now = Instant::now();
+    let recent = (now - state.last_click) < Duration::from_millis(300);
+    state.last_click = now;
+    id.get_mut().select(pos, size, dragging, recent);
+    if let Some(region) = ui.window_region(&id) {
+        state.window.set_ime_allowed(true);
+        state.window.set_ime_cursor_area(
+            LogicalPosition::<f32>::from(region.top_left.tuple()),
+            LogicalSize::<f32>::from(region.size().tuple()),
+        );
+    }
+    state.focus = Some(id);
+}

src/default/event.rs

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

src/default/input.rs

@@ -1,7 +1,7 @@
 use crate::{
-    core::{CursorState, Modifiers},
+    widget::{CursorState, Modifiers},
     layout::Vec2,
-    winit::DefaultUi,
+    default::UiState,
 };
 use winit::{
     event::{MouseButton, MouseScrollDelta, WindowEvent},
@@ -70,7 +70,7 @@ impl Input {
     }
 }
 
-impl DefaultUi {
+impl UiState {
     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,180 @@
+use crate::prelude::*;
+use arboard::Clipboard;
+use std::sync::Arc;
+use std::time::Instant;
+use winit::event::{Ime, WindowEvent};
+use winit::event_loop::{ActiveEventLoop, EventLoopProxy};
+use winit::window::{Window, WindowAttributes};
+
+mod app;
+mod attr;
+mod event;
+mod input;
+mod render;
+
+pub use app::*;
+pub use attr::*;
+pub use event::*;
+pub use input::*;
+pub use render::*;
+
+pub type Proxy<Event> = EventLoopProxy<Event>;
+pub type DefaultApp<Data> = App<DefaultState<Data>>;
+
+pub struct DefaultState<AppState> {
+    ui: Ui,
+    ui_state: UiState,
+    app_state: AppState,
+}
+
+pub struct UiState {
+    pub renderer: UiRenderer,
+    pub input: Input,
+    pub focus: Option<WidgetRef<TextEdit>>,
+    pub clipboard: Clipboard,
+    pub window: Arc<Window>,
+    pub ime: usize,
+    pub last_click: Instant,
+}
+
+pub trait DefaultAppState: 'static {
+    type Event: 'static = ();
+    fn new(ui: &mut Ui, state: &UiState, proxy: Proxy<Self::Event>) -> Self;
+    #[allow(unused_variables)]
+    fn event(&mut self, event: Self::Event, ui: &mut Ui, state: &UiState) {}
+    #[allow(unused_variables)]
+    fn exit(&mut self, ui: &mut Ui, state: &UiState) {}
+    #[allow(unused_variables)]
+    fn window_event(&mut self, event: WindowEvent, ui: &mut Ui, state: &UiState) {}
+    fn window_attrs() -> WindowAttributes {
+        WindowAttributes::default()
+    }
+}
+
+impl<State: DefaultAppState> AppState for DefaultState<State> {
+    type Event = State::Event;
+
+    fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
+        let window = Arc::new(
+            event_loop
+                .create_window(State::window_attrs())
+                .expect("failed to create window "),
+        );
+        let mut ui = Ui::new();
+        let ui_state = UiState {
+            renderer: UiRenderer::new(window.clone()),
+            window,
+            input: Input::default(),
+            clipboard: Clipboard::new().unwrap(),
+            ime: 0,
+            last_click: Instant::now(),
+            focus: None,
+        };
+        let app_state = State::new(&mut ui, &ui_state, proxy);
+        Self {
+            ui,
+            ui_state,
+            app_state,
+        }
+    }
+
+    fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
+        self.app_state.event(event, &mut self.ui, &self.ui_state);
+    }
+
+    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
+        let Self {
+            ui,
+            ui_state,
+            app_state,
+        } = self;
+
+        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();
+            // call sensors with all 3 important contexts
+            // TODO: allow user to specify custom contexts?
+            // and give them both states in case they need both
+            ui.run_sensors(&mut (), &cursor_state, window_size);
+            ui.run_sensors(ui_state, &cursor_state, window_size);
+            ui.run_sensors(app_state, &cursor_state, window_size);
+        }
+        if old != ui_state.focus
+            && let Some(old) = old
+        {
+            old.get_mut().deselect();
+        }
+        match &event {
+            WindowEvent::CloseRequested => event_loop.exit(),
+            WindowEvent::RedrawRequested => {
+                ui_state.renderer.update(ui);
+                ui_state.renderer.draw();
+            }
+            WindowEvent::Resized(size) => {
+                ui.resize((size.width, size.height));
+                ui_state.renderer.resize(size)
+            }
+            WindowEvent::KeyboardInput { event, .. } => {
+                if let Some(sel) = ui_state.focus
+                    && event.state.is_pressed()
+                {
+                    let res = sel.get_mut().apply_event(event, &ui_state.input.modifiers);
+                    match res {
+                        TextInputResult::Unfocus => {
+                            ui_state.focus = None;
+                            ui_state.window.set_ime_allowed(false);
+                        }
+                        TextInputResult::Submit => {
+                            Events::<Submit, _>::run(sel.id(), &mut (), app_state);
+                        }
+                        TextInputResult::Paste => {
+                            if let Ok(t) = ui_state.clipboard.get_text() {
+                                sel.get_mut().insert(&t);
+                            }
+                            Events::<Edited, _>::run(sel.id(), &mut (), app_state);
+                        }
+                        TextInputResult::Copy(text) => {
+                            if let Err(err) = ui_state.clipboard.set_text(text) {
+                                eprintln!("failed to copy text to clipboard: {err}")
+                            }
+                        }
+                        TextInputResult::Used => {
+                            Events::<Edited, _>::run(sel.id(), &mut (), app_state);
+                        }
+                        TextInputResult::Unused => {}
+                    }
+                }
+            }
+            WindowEvent::Ime(ime) => {
+                if let Some(sel) = &ui_state.focus {
+                    match ime {
+                        Ime::Enabled | Ime::Disabled => (),
+                        Ime::Preedit(content, _pos) => {
+                            // TODO: highlight once that's real
+                            sel.get_mut().replace(ui_state.ime, content);
+                            ui_state.ime = content.chars().count();
+                        }
+                        Ime::Commit(content) => {
+                            sel.get_mut().insert(content);
+                        }
+                    }
+                }
+            }
+            _ => (),
+        }
+        app_state.window_event(event, ui, ui_state);
+        if ui.update() {
+            ui_state.renderer.window().request_redraw();
+        }
+        ui_state.input.end_frame();
+    }
+
+    fn exit(&mut self) {
+        self.app_state.exit(&mut self.ui, &self.ui_state);
+    }
+}

src/event.rs

@@ -0,0 +1,66 @@
+use crate::prelude::*;
+use iris_macro::widget_trait;
+
+pub mod eventable {
+    use super::*;
+
+    widget_trait! {
+        pub trait Eventable;
+        fn on<E: EventAlias, Ctx: 'static>(
+            self,
+            event: E,
+            f: impl for<'a> EventIdFn<Ctx, <E::Event as Event>::Data<'a>, WL::Widget>,
+        ) -> impl WidgetIdFn<WL::Widget> {
+            move |ui| {
+                let id = self.add(ui);
+                Events::<E::Event, Ctx>::register(id.weak(), event.into_event(), f);
+                id
+            }
+        }
+    }
+}
+
+// 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::*;
+
+            widget_trait! {
+                #[allow(unused)]
+                pub trait EventableCtx;
+                fn on<E: EventAlias>(
+                    self,
+                    event: E,
+                    f: impl for<'a> EventIdFn<$ty, <E::Event as Event>::Data<'a>, WL::Widget>,
+                ) -> impl WidgetIdFn<WL::Widget> {
+                    eventable::Eventable::on(self, event, f)
+                }
+            }
+            use std::marker::Sized;
+            #[allow(unused)]
+            pub trait EventableCtxRef<W: Widget + ?Sized> {
+                fn on<E: EventAlias>(
+                    self,
+                    event: E,
+                    f: impl for<'a> EventIdFn<$ty, <E::Event as Event>::Data<'a>, W>,
+                );
+            }
+
+            impl<W: Widget + ?Sized> EventableCtxRef<W> for WidgetRef<W> {
+                fn on<E: EventAlias>(
+                    self,
+                    event: E,
+                    f: impl for<'a> EventIdFn<$ty, <E::Event as Event>::Data<'a>, W>,
+                ) {
+                    Events::<E::Event, $ty>::register(self, event.into_event(), f);
+                }
+            }
+        }
+        use local_event_trait::*;
+    };
+}
+pub use event_ctx;

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,201 +0,0 @@
-use std::{hash::Hash, rc::Rc};
-
-use crate::{
-    layout::{IdFnTag, Ui, UiModule, Widget, WidgetId, WidgetIdFn, WidgetLike},
-    util::{HashMap, Id},
-};
-
-pub trait UiCtx {
-    fn ui(&mut self) -> &mut Ui;
-}
-
-impl UiCtx for Ui {
-    fn ui(&mut self) -> &mut Ui {
-        self
-    }
-}
-
-pub trait Event: Sized {
-    type Module<Ctx: 'static>: EventModule<Self, Ctx>;
-    type Data: Clone;
-}
-
-pub trait EventFn<Ctx, Data>: Fn(&mut Ctx, Data) + 'static {}
-impl<F: Fn(&mut Ctx, Data) + 'static, Ctx, Data> EventFn<Ctx, Data> for F {}
-
-pub trait Eventable<W, Tag> {
-    fn on<E: Event, Ctx: 'static>(
-        self,
-        event: E,
-        f: impl EventFn<Ctx, E::Data>,
-    ) -> impl WidgetIdFn<W> + Eventable<W, IdFnTag>;
-
-    fn id_on<E: Event, Ctx: 'static>(
-        self,
-        event: E,
-        f: impl Fn(&WidgetId<W>, &mut Ctx, E::Data) + 'static,
-    ) -> impl WidgetIdFn<W> + Eventable<W, IdFnTag>
-    where
-        W: Widget;
-
-    fn edit_on<E: Event>(
-        self,
-        event: E,
-        f: impl Fn(&mut W, E::Data) + 'static,
-    ) -> impl WidgetIdFn<W> + Eventable<W, IdFnTag>
-    where
-        W: Widget;
-}
-
-impl<W: WidgetLike<Tag>, Tag> Eventable<W::Widget, Tag> for W {
-    fn on<E: Event, Ctx: 'static>(
-        self,
-        event: E,
-        f: impl EventFn<Ctx, E::Data>,
-    ) -> impl WidgetIdFn<W::Widget> {
-        move |ui| {
-            let id = self.add(ui);
-            ui.register_event(&id, event, f);
-            id
-        }
-    }
-
-    fn id_on<E: Event, Ctx: 'static>(
-        self,
-        event: E,
-        f: impl Fn(&WidgetId<W::Widget>, &mut Ctx, E::Data) + 'static,
-    ) -> impl WidgetIdFn<W::Widget>
-    where
-        W::Widget: Widget,
-    {
-        self.with_id(move |ui, id| {
-            // needed so that this widget can actually be dropped
-            let id2 = id.weak();
-            id.on(event, move |ctx, pos| f(&id2.strong(), ctx, pos))
-                .add(ui)
-        })
-    }
-
-    fn edit_on<E: Event>(
-        self,
-        event: E,
-        f: impl Fn(&mut W::Widget, E::Data) + 'static,
-    ) -> impl WidgetIdFn<W::Widget>
-    where
-        W::Widget: Widget,
-    {
-        self.id_on(event, move |id, ui: &mut Ui, pos| f(&mut ui[id], pos))
-    }
-}
-
-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(&mut 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(&mut 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: &mut Ctx, data: E::Data| {
-                for f in &fs {
-                    f(ctx, data.clone())
-                }
-            })
-        } else {
-            None
-        }
-    }
-}
-
-impl<E: HashableEvent, Ctx: 'static> DefaultEventModule<E, Ctx> {
-    pub fn run_all(&self, ctx: &mut Ctx, event: E, data: E::Data)
-    where
-        E::Data: Clone,
-    {
-        if let Some(map) = self.map.get(&event) {
-            for fs in map.values() {
-                for f in fs {
-                    f(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: UiCtx + 'static, W>(
-        ctx: &mut Ctx,
-        id: &WidgetId<W>,
-        event: E,
-        data: E::Data,
-    ) {
-        if let Some(f) = ctx
-            .ui()
-            .data
-            .modules
-            .get_mut::<E::Module<Ctx>>()
-            .run(&id.id, event)
-        {
-            f(ctx, data);
-        }
-    }
-}
-
-pub trait EventCtx: UiCtx {
-    fn run_event<E: Event + Clone, W>(&mut self, id: &WidgetId<W>, event: E, data: E::Data);
-}
-
-impl<Ctx: UiCtx + 'static> EventCtx for Ctx {
-    fn run_event<E: Event + Clone, W>(&mut self, id: &WidgetId<W>, event: E, data: E::Data) {
-        Ui::run_event(self, id, event.clone(), data.clone());
-    }
-}

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/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/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,23 @@
-#![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)]
 
-pub mod core;
+mod default;
-pub mod layout;
+mod event;
-pub mod render;
+mod widget;
-pub mod util;
+
-pub mod winit;
+pub use iris_core::*;
+pub use iris_macro::*;
 
 pub mod prelude {
-    pub use crate::core::*;
+    pub use super::default::*;
-    pub use crate::layout::*;
+    pub use super::event::*;
-    pub use crate::render::*;
+    pub use super::widget::*;
+
+    pub use iris_core::layout::*;
+    pub use iris_core::render::*;
+    pub use iris_core::util::Handle;
+
+    pub use iris_macro::*;
 }

src/util/borrow.rs

@@ -1,35 +0,0 @@
-use std::ops::{Deref, DerefMut};
-
-pub struct DynBorrower<'a, T: ?Sized> {
-    data: &'a mut T,
-    borrowed: &'a mut bool,
-}
-
-impl<'a, T: ?Sized> DynBorrower<'a, T> {
-    pub fn new(data: &'a mut T, borrowed: &'a mut bool) -> Self {
-        if *borrowed {
-            panic!("tried to mutably borrow the same thing twice");
-        }
-        Self { data, borrowed }
-    }
-}
-
-impl<T: ?Sized> Drop for DynBorrower<'_, T> {
-    fn drop(&mut self) {
-        *self.borrowed = false;
-    }
-}
-
-impl<T: ?Sized> Deref for DynBorrower<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.data
-    }
-}
-
-impl<T: ?Sized> DerefMut for DynBorrower<'_, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.data
-    }
-}

src/widget/image.rs

@@ -1,5 +1,5 @@
-use crate::prelude::*;
 use image::DynamicImage;
+use crate::prelude::*;
 
 pub struct Image {
     handle: TextureHandle,

src/widget/mask.rs

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

src/widget/position/align.rs

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

src/widget/position/layer.rs

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

src/widget/position/max_size.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub struct MaxSize {
-    pub inner: WidgetId,
+    pub inner: WidgetHandle,
     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: WidgetHandle,
     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: WidgetHandle,
 }
 
 impl Widget for Pad {

src/widget/position/scroll.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 pub struct Scroll {
-    inner: WidgetId,
+    inner: WidgetHandle,
     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: WidgetHandle, 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: WidgetHandle,
     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<WidgetHandle>,
     pub dir: Dir,
     pub gap: f32,
 }
@@ -158,7 +158,7 @@ impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> FnOnce<(&mut Ui,)>
 
     extern "rust-call" fn call_once(self, args: (&mut Ui,)) -> Self::Output {
         Span {
-            children: self.children.ui(args.0).arr.to_vec(),
+            children: self.children.ui(args.0).arr.into_iter().collect(),
             dir: self.dir,
             gap: self.gap,
         }
@@ -180,3 +180,17 @@ impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> SpanBuilder<LEN, Wa, Ta
         self
     }
 }
+
+impl std::ops::Deref for Span {
+    type Target = Vec<WidgetHandle>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.children
+    }
+}
+
+impl std::ops::DerefMut for Span {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut 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<WidgetHandle>,
     pub size: StackSize,
 }
 
@@ -55,7 +55,7 @@ impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> FnOnce<(&mut Ui,)>
 
     extern "rust-call" fn call_once(self, args: (&mut Ui,)) -> Self::Output {
         Stack {
-            children: self.children.ui(args.0).arr.to_vec(),
+            children: self.children.ui(args.0).arr.into_iter().collect(),
             size: self.size,
         }
     }

src/widget/ptr.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 
 #[derive(Default)]
 pub struct WidgetPtr {
-    pub inner: Option<WidgetId>,
+    pub inner: Option<WidgetHandle>,
 }
 
 impl Widget for WidgetPtr {

src/widget/sense.rs

@@ -0,0 +1,298 @@
+use crate::layout::{UiRegion, Vec2};
+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(&self, data: &mut Self::Data<'_>) -> bool {
+        if let Some(sense) = should_run(self, data.cursor, data.hover) {
+            data.sense = sense;
+            true
+        } else {
+            false
+        }
+    }
+}
+
+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, Data> {
+    pub senses: CursorSenses,
+    pub f: Rc<dyn EventFn<Ctx, Data>>,
+}
+
+pub type SenseShape = UiRegion;
+
+#[derive(Default, Debug)]
+pub struct SensorState {
+    pub hover: ActivationState,
+}
+
+pub struct CursorData<'a> {
+    /// where this widget was hit
+    pub pos: Vec2,
+    pub size: Vec2,
+    pub scroll_delta: Vec2,
+    pub hover: ActivationState,
+    pub cursor: &'a CursorState,
+    pub ui: &'a mut Ui,
+    /// the first sense that triggered this
+    pub sense: CursorSense,
+}
+
+pub trait SensorUi {
+    fn run_sensors<Ctx: 'static>(&mut self, ctx: &mut Ctx, cursor: &CursorState, window_size: Vec2);
+}
+
+impl SensorUi for Ui {
+    fn run_sensors<Ctx: 'static>(
+        &mut self,
+        ctx: &mut Ctx,
+        cursor: &CursorState,
+        window_size: Vec2,
+    ) {
+        let ui_id = self.id();
+        let layers = std::mem::take(&mut self.data_mut().layers);
+        let mut active = std::mem::take(&mut *Events::<CursorSenses, Ctx>::active(ui_id));
+        for i in layers.indices().rev() {
+            let mut sensed = false;
+            for (id, state) in active.get_mut(&i).into_iter().flatten() {
+                let shape = self.active().get(id).unwrap().region;
+                let region = shape.to_px(window_size);
+                let in_shape = cursor.exists && region.contains(cursor.pos);
+                state.hover.update(in_shape);
+                if state.hover == ActivationState::Off {
+                    continue;
+                }
+                sensed = true;
+
+                let mut data = CursorData {
+                    pos: cursor.pos - region.top_left,
+                    size: region.bot_right - region.top_left,
+                    scroll_delta: cursor.scroll_delta,
+                    hover: state.hover,
+                    cursor,
+                    ui: self,
+                    // this does not have any meaning;
+                    // might wanna set up Event to have a prepare stage
+                    sense: CursorSense::Hovering,
+                };
+                Events::<CursorSenses, Ctx>::run(*id, &mut data, ctx);
+            }
+            if sensed {
+                break;
+            }
+        }
+
+        *Events::<CursorSenses, Ctx>::active(ui_id) = active;
+        self.data_mut().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 EventAlias for CursorSense {
+    type Event = CursorSenses;
+    fn into_event(self) -> Self::Event {
+        CursorSenses::from(self)
+    }
+}
+
+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/widget/text/build.rs

@@ -12,7 +12,7 @@ pub struct TextBuilder<O = TextOutput, H: WidgetOption = ()> {
 impl<O, H: WidgetOption> TextBuilder<O, H> {
     pub fn size(mut self, size: impl UiNum) -> Self {
         self.attrs.font_size = size.to_f32();
-        self.attrs.line_height = self.attrs.font_size * 1.1;
+        self.attrs.line_height = self.attrs.font_size * LINE_HEIGHT_MULT;
         self
     }
     pub fn color(mut self, color: UiColor) -> Self {
@@ -31,6 +31,10 @@ impl<O, H: WidgetOption> TextBuilder<O, H> {
         self.attrs.align = align.into();
         self
     }
+    pub fn center_text(mut self) -> Self {
+        self.attrs.align = Align::CENTER;
+        self
+    }
     pub fn wrap(mut self, wrap: bool) -> Self {
         self.attrs.wrap = wrap;
         self
@@ -71,7 +75,7 @@ impl TextBuilderOutput for TextOutput {
             builder.attrs.line_height,
         ));
         let hint = builder.hint.get(ui);
-        let font_system = &mut ui.data.text.font_system;
+        let font_system = &mut ui.data().text.get_mut().font_system;
         buf.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
         let mut text = Text {
             content: builder.content.into(),
@@ -97,8 +101,9 @@ impl TextBuilderOutput for TextEditOutput {
         let mut text = TextEdit::new(
             TextView::new(buf, builder.attrs, builder.hint.get(ui)),
             builder.output.single_line,
+            ui.data().text.clone(),
         );
-        let font_system = &mut ui.data.text.font_system;
+        let font_system = &mut ui.data().text.get_mut().font_system;
         text.buf
             .set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
         builder.attrs.apply(font_system, &mut text.buf, None);

src/widget/text/edit.rs

@@ -1,7 +1,7 @@
 use std::ops::{Deref, DerefMut};
 
 use crate::prelude::*;
-use cosmic_text::{Affinity, Attrs, Cursor, FontSystem, LayoutRun, Motion};
+use cosmic_text::{Affinity, Attrs, Cursor, LayoutRun, Motion};
 use unicode_segmentation::UnicodeSegmentation;
 use winit::{
     event::KeyEvent,
@@ -13,17 +13,19 @@ pub struct TextEdit {
     selection: TextSelection,
     history: Vec<(String, TextSelection)>,
     double_hit: Option<Cursor>,
+    data: TextData,
     pub single_line: bool,
 }
 
 impl TextEdit {
-    pub fn new(view: TextView, single_line: bool) -> Self {
+    pub fn new(view: TextView, single_line: bool, data: TextData) -> Self {
         Self {
             view,
             selection: Default::default(),
             history: Default::default(),
             double_hit: None,
             single_line,
+            data,
         }
     }
     pub fn select_content(&self, start: Cursor, end: Cursor) -> String {
@@ -42,6 +44,369 @@ impl TextEdit {
             str
         }
     }
+
+    pub fn take(&mut self) -> String {
+        let text = self
+            .buf
+            .lines
+            .drain(..)
+            .map(|l| l.into_text())
+            .collect::<Vec<_>>()
+            .join("\n");
+        self.set("");
+        text
+    }
+
+    pub fn set(&mut self, text: &str) {
+        let text = self.string(text);
+        self.view.buf.set_text(
+            &mut self.data.get_mut().font_system,
+            &text,
+            &Attrs::new(),
+            SHAPING,
+            None,
+        );
+        self.selection.clear();
+    }
+
+    pub fn motion(&mut self, motion: Motion, select: bool) {
+        if let TextSelection::Pos(cursor) = self.selection
+            && let Some(new) = self.buf_motion(cursor, motion)
+        {
+            self.selection = if select {
+                TextSelection::Span {
+                    start: cursor,
+                    end: new,
+                }
+            } else {
+                TextSelection::Pos(new)
+            };
+        } else if let TextSelection::Span { start, end } = self.selection {
+            if select {
+                if let Some(cursor) = self.buf_motion(end, motion) {
+                    self.selection = TextSelection::Span { start, end: cursor };
+                }
+            } else {
+                let (start, end) = sort_cursors(start, end);
+                match motion {
+                    Motion::Left | Motion::LeftWord => self.selection = TextSelection::Pos(start),
+                    Motion::Right | Motion::RightWord => self.selection = TextSelection::Pos(end),
+                    _ => {
+                        if let Some(cursor) = self.buf_motion(end, motion) {
+                            self.selection = TextSelection::Pos(cursor);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn replace(&mut self, len: usize, text: &str) {
+        let text = self.string(text);
+        for _ in 0..len {
+            self.delete(false);
+        }
+        self.insert_inner(&text, false);
+    }
+
+    fn string(&self, text: &str) -> String {
+        if self.single_line {
+            text.replace('\n', "")
+        } else {
+            text.to_string()
+        }
+    }
+
+    pub fn insert(&mut self, text: &str) {
+        let text = self.string(text);
+        let mut lines = text.split('\n');
+        let Some(first) = lines.next() else {
+            return;
+        };
+        self.insert_inner(first, true);
+        for line in lines {
+            self.newline();
+            self.insert_inner(line, true);
+        }
+    }
+
+    pub fn clear_span(&mut self) -> bool {
+        if let TextSelection::Span { start, end } = self.selection {
+            self.delete_between(start, end);
+            let (start, _) = sort_cursors(start, end);
+            self.selection = TextSelection::Pos(start);
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn delete_between(&mut self, start: Cursor, end: Cursor) {
+        let lines = &mut self.view.buf.lines;
+        let (start, end) = sort_cursors(start, end);
+        if start.line == end.line {
+            let line = &mut lines[start.line];
+            let text = line.text();
+            let text = text[..start.index].to_string() + &text[end.index..];
+            edit_line(line, text);
+        } else {
+            // start
+            let start_text = lines[start.line].text()[..start.index].to_string();
+            let end_text = &lines[end.line].text()[end.index..];
+            let text = start_text + end_text;
+            edit_line(&mut lines[start.line], text);
+        }
+        // between
+        let range = (start.line + 1)..=end.line;
+        if !range.is_empty() {
+            lines.splice(range, None);
+        }
+    }
+
+    fn insert_inner(&mut self, text: &str, mov: bool) {
+        self.clear_span();
+        if let TextSelection::Pos(cursor) = self.selection {
+            let line = &mut self.view.buf.lines[cursor.line];
+            let mut line_text = line.text().to_string();
+            line_text.insert_str(cursor.index, text);
+            edit_line(line, line_text);
+            if mov {
+                for _ in 0..text.chars().count() {
+                    self.motion(Motion::Right, false);
+                }
+            }
+        }
+    }
+
+    pub fn newline(&mut self) {
+        if self.single_line {
+            return;
+        }
+        self.clear_span();
+        if let TextSelection::Pos(cursor) = &mut self.selection {
+            let lines = &mut self.view.buf.lines;
+            let line = &mut lines[cursor.line];
+            let new = line.split_off(cursor.index);
+            cursor.line += 1;
+            lines.insert(cursor.line, new);
+            cursor.index = 0;
+        }
+    }
+
+    pub fn backspace(&mut self, word: bool) {
+        if !self.clear_span()
+            && let TextSelection::Pos(cursor) = &mut self.selection
+            && (cursor.index != 0 || cursor.line != 0)
+        {
+            self.motion(if word { Motion::LeftWord } else { Motion::Left }, false);
+            self.delete(word);
+        }
+    }
+
+    pub fn delete(&mut self, word: bool) {
+        if self.clear_span() {
+            return;
+        }
+        if let TextSelection::Pos(cursor) = &mut self.selection {
+            if word {
+                let start = *cursor;
+                if let Some(end) = self.buf_motion(start, Motion::RightWord) {
+                    self.delete_between(start, end);
+                }
+            } else {
+                let lines = &mut self.view.buf.lines;
+                let line = &mut lines[cursor.line];
+                if cursor.index == line.text().len() {
+                    if cursor.line == lines.len() - 1 {
+                        return;
+                    }
+                    let add = lines.remove(cursor.line + 1).into_text();
+                    let line = &mut lines[cursor.line];
+                    let mut cur = line.text().to_string();
+                    cur.push_str(&add);
+                    edit_line(line, cur);
+                } else {
+                    let mut text = line.text().to_string();
+                    text.remove(cursor.index);
+                    edit_line(line, text);
+                }
+            }
+        }
+    }
+
+    fn buf_motion(&mut self, cursor: Cursor, motion: Motion) -> Option<Cursor> {
+        self.view
+            .buf
+            .cursor_motion(
+                &mut self.data.get_mut().font_system,
+                cursor,
+                None,
+                motion,
+            )
+            .map(|r| r.0)
+    }
+
+    pub fn select_word_at(&mut self, cursor: Cursor) {
+        if let (Some(start), Some(end)) = (
+            self.buf_motion(cursor, Motion::LeftWord),
+            self.buf_motion(cursor, Motion::RightWord),
+        ) {
+            self.selection = TextSelection::Span { start, end };
+        }
+    }
+
+    pub fn select_line_at(&mut self, cursor: Cursor) {
+        let end = self.buf.lines[cursor.line].text().len();
+        self.selection = TextSelection::Span {
+            start: Cursor::new(cursor.line, 0),
+            end: Cursor::new(cursor.line, end),
+        }
+    }
+
+    pub fn select(&mut self, pos: Vec2, size: Vec2, drag: bool, recent: bool) {
+        let pos = pos - self.region().top_left().to_abs(size);
+        let hit = self.buf.hit(pos.x, pos.y);
+        let sel = &mut self.selection;
+        match sel {
+            TextSelection::None => {
+                if !drag && let Some(hit) = hit {
+                    *sel = TextSelection::Pos(hit)
+                }
+            }
+            TextSelection::Pos(pos) => match (hit, drag) {
+                (None, false) => *sel = TextSelection::None,
+                (None, true) => (),
+                (Some(hit), false) => {
+                    if recent && hit == *pos {
+                        self.double_hit = Some(hit);
+                        return self.select_word_at(hit);
+                    } else {
+                        *pos = hit
+                    }
+                }
+                (Some(end), true) => *sel = TextSelection::Span { start: *pos, end },
+            },
+            TextSelection::Span { start, end } => match (hit, drag) {
+                (None, false) => *sel = TextSelection::None,
+                (None, true) => *sel = TextSelection::Pos(*start),
+                (Some(hit), false) => {
+                    if recent
+                        && let Some(double) = self.double_hit
+                        && double == hit
+                    {
+                        return self.select_line_at(hit);
+                    } else {
+                        *sel = TextSelection::Pos(hit)
+                    }
+                }
+                (Some(hit), true) => *end = hit,
+            },
+        }
+        if let TextSelection::Span { start, end } = sel
+            && start == end
+        {
+            *sel = TextSelection::Pos(*start);
+        }
+    }
+
+    pub fn deselect(&mut self) {
+        self.selection = TextSelection::None;
+    }
+
+    pub fn apply_event(&mut self, event: &KeyEvent, modifiers: &Modifiers) -> TextInputResult {
+        let old = (self.content(), self.selection);
+        let mut undo = false;
+        let res = self.apply_event_inner(event, modifiers, &mut undo);
+        if undo && let Some((old, selection)) = self.history.pop() {
+            self.set(&old);
+            self.selection = selection;
+        } else if self.content() != old.0 {
+            self.history.push(old);
+        }
+        res
+    }
+
+    fn apply_event_inner(
+        &mut self,
+        event: &KeyEvent,
+        modifiers: &Modifiers,
+        undo: &mut bool,
+    ) -> TextInputResult {
+        match &event.logical_key {
+            Key::Named(named) => match named {
+                NamedKey::Backspace => self.backspace(modifiers.control),
+                NamedKey::Delete => self.delete(modifiers.control),
+                NamedKey::Space => self.insert(" "),
+                NamedKey::Enter => {
+                    if modifiers.shift {
+                        self.newline();
+                    } else {
+                        return TextInputResult::Submit;
+                    }
+                }
+                NamedKey::ArrowRight => {
+                    if modifiers.control {
+                        self.motion(Motion::RightWord, modifiers.shift)
+                    } else {
+                        self.motion(Motion::Right, modifiers.shift)
+                    }
+                }
+                NamedKey::ArrowLeft => {
+                    if modifiers.control {
+                        self.motion(Motion::LeftWord, modifiers.shift)
+                    } else {
+                        self.motion(Motion::Left, modifiers.shift)
+                    }
+                }
+                NamedKey::ArrowUp => self.motion(Motion::Up, modifiers.shift),
+                NamedKey::ArrowDown => self.motion(Motion::Down, modifiers.shift),
+                NamedKey::Escape => {
+                    self.deselect();
+                    return TextInputResult::Unfocus;
+                }
+                _ => return TextInputResult::Unused,
+            },
+            Key::Character(text) => {
+                if modifiers.control {
+                    match text.as_str() {
+                        "v" => return TextInputResult::Paste,
+                        "c" => {
+                            if let TextSelection::Span { start, end } = self.selection {
+                                let content = self.select_content(start, end);
+                                return TextInputResult::Copy(content);
+                            }
+                        }
+                        "x" => {
+                            if let TextSelection::Span { start, end } = self.selection {
+                                let content = self.select_content(start, end);
+                                self.clear_span();
+                                return TextInputResult::Copy(content);
+                            }
+                        }
+                        "a" => {
+                            if !self.buf.lines[0].text().is_empty() || self.buf.lines.len() > 1 {
+                                let lines = &self.buf.lines;
+                                let last_line = lines.len() - 1;
+                                let last_idx = lines[last_line].text().len();
+                                self.selection = TextSelection::Span {
+                                    start: Cursor::new(0, 0),
+                                    end: Cursor::new(last_line, last_idx),
+                                };
+                            }
+                        }
+                        "z" => {
+                            *undo = true;
+                        }
+                        _ => self.insert(text),
+                    }
+                } else {
+                    self.insert(text);
+                }
+            }
+            _ => return TextInputResult::Unused,
+        }
+        TextInputResult::Used
+    }
 }
 
 impl Widget for TextEdit {
@@ -175,373 +540,6 @@ fn cursor_pos(cursor: Cursor, buf: &TextBuffer) -> Option<Vec2> {
     prev
 }
 
-pub struct TextEditCtx<'a> {
-    pub text: &'a mut TextEdit,
-    pub font_system: &'a mut FontSystem,
-}
-
-impl<'a> TextEditCtx<'a> {
-    pub fn take(&mut self) -> String {
-        let text = self
-            .text
-            .buf
-            .lines
-            .drain(..)
-            .map(|l| l.into_text())
-            .collect::<Vec<_>>()
-            .join("\n");
-        self.text
-            .buf
-            .set_text(self.font_system, "", &Attrs::new(), SHAPING, None);
-        self.text.selection.clear();
-        text
-    }
-
-    pub fn set(&mut self, text: &str) {
-        let text = self.string(text);
-        self.text
-            .buf
-            .set_text(self.font_system, &text, &Attrs::new(), SHAPING, None);
-        self.text.selection.clear();
-    }
-
-    pub fn motion(&mut self, motion: Motion, select: bool) {
-        if let TextSelection::Pos(cursor) = self.text.selection
-            && let Some(new) = self.buf_motion(cursor, motion)
-        {
-            if select {
-                self.text.selection = TextSelection::Span {
-                    start: cursor,
-                    end: new,
-                };
-            } else {
-                self.text.selection = TextSelection::Pos(new);
-            }
-        } else if let TextSelection::Span { start, end } = self.text.selection {
-            if select {
-                if let Some(cursor) = self.buf_motion(end, motion) {
-                    self.text.selection = TextSelection::Span { start, end: cursor };
-                }
-            } else {
-                let (start, end) = sort_cursors(start, end);
-                let sel = &mut self.text.selection;
-                match motion {
-                    Motion::Left | Motion::LeftWord => *sel = TextSelection::Pos(start),
-                    Motion::Right | Motion::RightWord => *sel = TextSelection::Pos(end),
-                    _ => {
-                        if let Some(cursor) = self.buf_motion(end, motion) {
-                            self.text.selection = TextSelection::Pos(cursor);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    pub fn replace(&mut self, len: usize, text: &str) {
-        let text = self.string(text);
-        for _ in 0..len {
-            self.delete(false);
-        }
-        self.insert_inner(&text, false);
-    }
-
-    fn string(&self, text: &str) -> String {
-        if self.text.single_line {
-            text.replace('\n', "")
-        } else {
-            text.to_string()
-        }
-    }
-
-    pub fn insert(&mut self, text: &str) {
-        let text = self.string(text);
-        let mut lines = text.split('\n');
-        let Some(first) = lines.next() else {
-            return;
-        };
-        self.insert_inner(first, true);
-        for line in lines {
-            self.newline();
-            self.insert_inner(line, true);
-        }
-    }
-
-    pub fn clear_span(&mut self) -> bool {
-        if let TextSelection::Span { start, end } = self.text.selection {
-            self.delete_between(start, end);
-            let (start, _) = sort_cursors(start, end);
-            self.text.selection = TextSelection::Pos(start);
-            true
-        } else {
-            false
-        }
-    }
-
-    pub fn delete_between(&mut self, start: Cursor, end: Cursor) {
-        let lines = &mut self.text.view.buf.lines;
-        let (start, end) = sort_cursors(start, end);
-        if start.line == end.line {
-            let line = &mut lines[start.line];
-            let text = line.text();
-            let text = text[..start.index].to_string() + &text[end.index..];
-            edit_line(line, text);
-        } else {
-            // start
-            let start_text = lines[start.line].text()[..start.index].to_string();
-            let end_text = &lines[end.line].text()[end.index..];
-            let text = start_text + end_text;
-            edit_line(&mut lines[start.line], text);
-        }
-        // between
-        let range = (start.line + 1)..=end.line;
-        if !range.is_empty() {
-            lines.splice(range, None);
-        }
-    }
-
-    fn insert_inner(&mut self, text: &str, mov: bool) {
-        self.clear_span();
-        if let TextSelection::Pos(cursor) = &mut self.text.selection {
-            let line = &mut self.text.view.buf.lines[cursor.line];
-            let mut line_text = line.text().to_string();
-            line_text.insert_str(cursor.index, text);
-            edit_line(line, line_text);
-            if mov {
-                for _ in 0..text.chars().count() {
-                    self.motion(Motion::Right, false);
-                }
-            }
-        }
-    }
-
-    pub fn newline(&mut self) {
-        if self.text.single_line {
-            return;
-        }
-        self.clear_span();
-        if let TextSelection::Pos(cursor) = &mut self.text.selection {
-            let lines = &mut self.text.view.buf.lines;
-            let line = &mut lines[cursor.line];
-            let new = line.split_off(cursor.index);
-            cursor.line += 1;
-            lines.insert(cursor.line, new);
-            cursor.index = 0;
-        }
-    }
-
-    pub fn backspace(&mut self, word: bool) {
-        if !self.clear_span()
-            && let TextSelection::Pos(cursor) = &mut self.text.selection
-            && (cursor.index != 0 || cursor.line != 0)
-        {
-            self.motion(if word { Motion::LeftWord } else { Motion::Left }, false);
-            self.delete(word);
-        }
-    }
-
-    pub fn delete(&mut self, word: bool) {
-        if !self.clear_span()
-            && let TextSelection::Pos(cursor) = &mut self.text.selection
-        {
-            if word {
-                let start = *cursor;
-                if let Some(end) = self.buf_motion(start, Motion::RightWord) {
-                    self.delete_between(start, end);
-                }
-            } else {
-                let lines = &mut self.text.view.buf.lines;
-                let line = &mut lines[cursor.line];
-                if cursor.index == line.text().len() {
-                    if cursor.line == lines.len() - 1 {
-                        return;
-                    }
-                    let add = lines.remove(cursor.line + 1).into_text();
-                    let line = &mut lines[cursor.line];
-                    let mut cur = line.text().to_string();
-                    cur.push_str(&add);
-                    edit_line(line, cur);
-                } else {
-                    let mut text = line.text().to_string();
-                    text.remove(cursor.index);
-                    edit_line(line, text);
-                }
-            }
-        }
-    }
-
-    fn buf_motion(&mut self, cursor: Cursor, motion: Motion) -> Option<Cursor> {
-        self.text
-            .buf
-            .cursor_motion(self.font_system, cursor, None, motion)
-            .map(|r| r.0)
-    }
-
-    pub fn select_word_at(&mut self, cursor: Cursor) {
-        if let (Some(start), Some(end)) = (
-            self.buf_motion(cursor, Motion::LeftWord),
-            self.buf_motion(cursor, Motion::RightWord),
-        ) {
-            self.text.selection = TextSelection::Span { start, end };
-        }
-    }
-
-    pub fn select_line_at(&mut self, cursor: Cursor) {
-        let end = self.text.buf.lines[cursor.line].text().len();
-        self.text.selection = TextSelection::Span {
-            start: Cursor::new(cursor.line, 0),
-            end: Cursor::new(cursor.line, end),
-        }
-    }
-
-    pub fn select(&mut self, pos: Vec2, size: Vec2, drag: bool, recent: bool) {
-        let pos = pos - self.text.region().top_left().to_abs(size);
-        let hit = self.text.buf.hit(pos.x, pos.y);
-        let sel = &mut self.text.selection;
-        match sel {
-            TextSelection::None => {
-                if !drag && let Some(hit) = hit {
-                    *sel = TextSelection::Pos(hit)
-                }
-            }
-            TextSelection::Pos(pos) => match (hit, drag) {
-                (None, false) => *sel = TextSelection::None,
-                (None, true) => (),
-                (Some(hit), false) => {
-                    if recent && hit == *pos {
-                        self.text.double_hit = Some(hit);
-                        return self.select_word_at(hit);
-                    } else {
-                        *pos = hit
-                    }
-                }
-                (Some(end), true) => *sel = TextSelection::Span { start: *pos, end },
-            },
-            TextSelection::Span { start, end } => match (hit, drag) {
-                (None, false) => *sel = TextSelection::None,
-                (None, true) => *sel = TextSelection::Pos(*start),
-                (Some(hit), false) => {
-                    if recent
-                        && let Some(double) = self.text.double_hit
-                        && double == hit
-                    {
-                        return self.select_line_at(hit);
-                    } else {
-                        *sel = TextSelection::Pos(hit)
-                    }
-                }
-                (Some(hit), true) => *end = hit,
-            },
-        }
-        if let TextSelection::Span { start, end } = sel
-            && start == end
-        {
-            *sel = TextSelection::Pos(*start);
-        }
-    }
-
-    pub fn deselect(&mut self) {
-        self.text.selection = TextSelection::None;
-    }
-
-    pub fn apply_event(&mut self, event: &KeyEvent, modifiers: &Modifiers) -> TextInputResult {
-        let old = (self.text.content(), self.text.selection);
-        let mut undo = false;
-        let res = self.apply_event_inner(event, modifiers, &mut undo);
-        if undo && let Some((old, selection)) = self.text.history.pop() {
-            self.set(&old);
-            self.text.selection = selection;
-        } else if self.text.content() != old.0 {
-            self.text.history.push(old);
-        }
-        res
-    }
-
-    fn apply_event_inner(
-        &mut self,
-        event: &KeyEvent,
-        modifiers: &Modifiers,
-        undo: &mut bool,
-    ) -> TextInputResult {
-        match &event.logical_key {
-            Key::Named(named) => match named {
-                NamedKey::Backspace => self.backspace(modifiers.control),
-                NamedKey::Delete => self.delete(modifiers.control),
-                NamedKey::Space => self.insert(" "),
-                NamedKey::Enter => {
-                    if modifiers.shift {
-                        self.newline();
-                    } else {
-                        return TextInputResult::Submit;
-                    }
-                }
-                NamedKey::ArrowRight => {
-                    if modifiers.control {
-                        self.motion(Motion::RightWord, modifiers.shift)
-                    } else {
-                        self.motion(Motion::Right, modifiers.shift)
-                    }
-                }
-                NamedKey::ArrowLeft => {
-                    if modifiers.control {
-                        self.motion(Motion::LeftWord, modifiers.shift)
-                    } else {
-                        self.motion(Motion::Left, modifiers.shift)
-                    }
-                }
-                NamedKey::ArrowUp => self.motion(Motion::Up, modifiers.shift),
-                NamedKey::ArrowDown => self.motion(Motion::Down, modifiers.shift),
-                NamedKey::Escape => {
-                    self.deselect();
-                    return TextInputResult::Unfocus;
-                }
-                _ => return TextInputResult::Unused,
-            },
-            Key::Character(text) => {
-                if modifiers.control {
-                    match text.as_str() {
-                        "v" => return TextInputResult::Paste,
-                        "c" => {
-                            if let TextSelection::Span { start, end } = self.text.selection {
-                                let content = self.text.select_content(start, end);
-                                return TextInputResult::Copy(content);
-                            }
-                        }
-                        "x" => {
-                            if let TextSelection::Span { start, end } = self.text.selection {
-                                let content = self.text.select_content(start, end);
-                                self.clear_span();
-                                return TextInputResult::Copy(content);
-                            }
-                        }
-                        "a" => {
-                            if !self.text.buf.lines[0].text().is_empty()
-                                || self.text.buf.lines.len() > 1
-                            {
-                                let lines = &self.text.buf.lines;
-                                let last_line = lines.len() - 1;
-                                let last_idx = lines[last_line].text().len();
-                                self.text.selection = TextSelection::Span {
-                                    start: Cursor::new(0, 0),
-                                    end: Cursor::new(last_line, last_idx),
-                                };
-                            }
-                        }
-                        "z" => {
-                            *undo = true;
-                        }
-                        _ => self.insert(text),
-                    }
-                } else {
-                    self.insert(text);
-                }
-            }
-            _ => return TextInputResult::Unused,
-        }
-        TextInputResult::Used
-    }
-}
-
 #[derive(Default)]
 pub struct Modifiers {
     pub shift: bool,

src/widget/text/mod.rs

@@ -21,11 +21,11 @@ pub struct TextView {
     // cache
     tex: Option<RenderedText>,
     width: Option<f32>,
-    pub hint: Option<WidgetId>,
+    pub hint: Option<WidgetHandle>,
 }
 
 impl TextView {
-    pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option<WidgetId>) -> Self {
+    pub fn new(buf: TextBuffer, attrs: TextAttrs, hint: Option<WidgetHandle>) -> Self {
         Self {
             attrs: attrs.into(),
             buf: buf.into(),
@@ -67,9 +67,12 @@ impl TextView {
             return tex.clone();
         }
         self.width = width;
-        let font_system = &mut ctx.text.font_system;
+        let mut text_data = ctx.text.get_mut();
-        self.attrs.apply(font_system, &mut self.buf, width);
+        self.attrs
-        self.buf.shape_until_scroll(font_system, false);
+            .apply(&mut text_data.font_system, &mut self.buf, width);
+        self.buf
+            .shape_until_scroll(&mut text_data.font_system, false);
+        drop(text_data);
         let tex = ctx.draw_text(&mut self.buf, &self.attrs);
         self.tex = Some(tex.clone());
         self.attrs.changed = false;
@@ -136,7 +139,7 @@ impl Text {
         if self.content.changed {
             self.content.changed = false;
             self.view.buf.set_text(
-                &mut ctx.text.font_system,
+                &mut ctx.text.get_mut().font_system,
                 &self.content,
                 &Attrs::new().family(self.view.attrs.family),
                 SHAPING,

src/widget/trait_fns.rs

@@ -1,36 +1,22 @@
-use super::*;
 use crate::prelude::*;
+use iris_macro::widget_trait;
 
-pub trait CoreWidget<W, Tag> {
+// these methods should "not require any context" (require unit) because they're in core
-    fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Pad>;
+event_ctx!(());
-    fn align(self, align: impl Into<Align>) -> impl WidgetFn<Aligned>;
+
-    fn center(self) -> impl WidgetFn<Aligned>;
+widget_trait! {
-    fn label(self, label: impl Into<String>) -> impl WidgetIdFn<W>;
+    pub trait CoreWidget;
-    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(),
+            inner: self.add(ui),
         }
     }
 
     fn align(self, align: impl Into<Align>) -> impl WidgetFn<Aligned> {
         move |ui| Aligned {
-            inner: self.add(ui).any(),
+            inner: self.add(ui),
             align: align.into(),
         }
     }
@@ -39,10 +25,10 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
         self.align(Align::CENTER)
     }
 
-    fn label(self, label: impl Into<String>) -> impl WidgetIdFn<W::Widget> {
+    fn label(self, label: impl Into<String>) -> impl WidgetIdFn<WL::Widget> {
         |ui| {
             let id = self.add(ui);
-            ui.set_label(&id, label.into());
+            id.set_label(label);
             id
         }
     }
@@ -50,7 +36,7 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
     fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Sized> {
         let size = size.into();
         move |ui| Sized {
-            inner: self.add(ui).any(),
+            inner: self.add(ui),
             x: Some(size.x),
             y: Some(size.y),
         }
@@ -59,7 +45,7 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
     fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<MaxSize> {
         let len = len.into();
         move |ui| MaxSize {
-            inner: self.add(ui).any(),
+            inner: self.add(ui),
             x: Some(len),
             y: None,
         }
@@ -68,7 +54,7 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
     fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<MaxSize> {
         let len = len.into();
         move |ui| MaxSize {
-            inner: self.add(ui).any(),
+            inner: self.add(ui),
             x: None,
             y: Some(len),
         }
@@ -77,7 +63,7 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
     fn width(self, len: impl Into<Len>) -> impl WidgetFn<Sized> {
         let len = len.into();
         move |ui| Sized {
-            inner: self.add(ui).any(),
+            inner: self.add(ui),
             x: Some(len),
             y: None,
         }
@@ -86,7 +72,7 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
     fn height(self, len: impl Into<Len>) -> impl WidgetFn<Sized> {
         let len = len.into();
         move |ui| Sized {
-            inner: self.add(ui).any(),
+            inner: self.add(ui),
             x: None,
             y: Some(len),
         }
@@ -94,16 +80,17 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
 
     fn offset(self, amt: impl Into<UiVec2>) -> impl WidgetFn<Offset> {
         move |ui| Offset {
-            inner: self.add(ui).any(),
+            inner: self.add(ui),
             amt: amt.into(),
         }
     }
 
     fn scroll(self) -> impl WidgetIdFn<Scroll> {
         move |ui| {
-            Scroll::new(self.add(ui).any(), Axis::Y)
+            Scroll::new(self.add(ui), Axis::Y)
-                .edit_on(CursorSense::Scroll, |w, data| {
+                .on(CursorSense::Scroll, |ctx| {
-                    w.scroll(data.scroll_delta.y * 50.0);
+                    let s = &mut *ctx.widget.get_mut();
+                    s.scroll(ctx.data.scroll_delta.y * 50.0);
                 })
                 .add(ui)
         }
@@ -111,33 +98,37 @@ impl<W: WidgetLike<Tag>, Tag> CoreWidget<W::Widget, Tag> for W {
 
     fn masked(self) -> impl WidgetFn<Masked> {
         move |ui| Masked {
-            inner: self.add(ui).any(),
+            inner: self.add(ui),
         }
     }
 
-    fn background<T>(self, w: impl WidgetLike<T>) -> impl WidgetFn<Stack> {
+    fn background<T,>(self, w: impl WidgetLike<T>) -> impl WidgetFn<Stack> {
         move |ui| Stack {
-            children: vec![w.add(ui).any(), self.add(ui).any()],
+            children: vec![w.add(ui), self.add(ui)],
             size: StackSize::Child(1),
         }
     }
 
-    fn foreground<T>(self, w: impl WidgetLike<T>) -> impl WidgetFn<Stack> {
+    fn foreground<T,>(self, w: impl WidgetLike<T>) -> impl WidgetFn<Stack> {
         move |ui| Stack {
-            children: vec![self.add(ui).any(), w.add(ui).any()],
+            children: vec![self.add(ui), w.add(ui)],
             size: StackSize::Child(0),
         }
     }
 
     fn layer_offset(self, offset: usize) -> impl WidgetFn<LayerOffset> {
         move |ui| LayerOffset {
-            inner: self.add(ui).any(),
+            inner: self.add(ui),
             offset,
         }
     }
 
     fn to_any(self) -> impl WidgetRet {
-        |ui| self.add(ui).any()
+        |ui| self.add(ui)
+    }
+
+    fn set_ptr(self, ptr: &WidgetHandle<WidgetPtr>, ui: &mut Ui) {
+        ptr.get_mut().inner = Some(self.add(ui));
     }
 }
 

src/winit/attr.rs

@@ -1,59 +0,0 @@
-use crate::{prelude::*, winit::DefaultUi};
-use std::time::{Duration, Instant};
-use winit::dpi::{LogicalPosition, LogicalSize};
-
-pub struct Selector;
-
-impl<W: 'static> WidgetAttr<W> for Selector {
-    type Input = WidgetId<TextEdit>;
-
-    fn run(ui: &mut Ui, container: &WidgetId<W>, id: Self::Input) {
-        let container = container.clone();
-        ui.register_event(
-            &container.clone(),
-            CursorSense::click_or_drag(),
-            move |ui: &mut DefaultUi, mut data| {
-                let region = ui.window_region(&id).unwrap();
-                let id_pos = region.top_left;
-                let container_pos = ui.window_region(&container).unwrap().top_left;
-                data.cursor += container_pos - id_pos;
-                data.size = region.size();
-                select(id.clone(), ui, data);
-            },
-        );
-    }
-}
-
-pub struct Selectable;
-
-impl WidgetAttr<TextEdit> for Selectable {
-    type Input = ();
-
-    fn run(ui: &mut Ui, id: &WidgetId<TextEdit>, _: Self::Input) {
-        let id = id.clone();
-        ui.register_event(
-            &id.clone(),
-            CursorSense::click_or_drag(),
-            move |ui: &mut DefaultUi, data| {
-                select(id.clone(), ui, data);
-            },
-        );
-    }
-}
-
-fn select(id: WidgetId<TextEdit>, ui: &mut DefaultUi, data: CursorData) {
-    let now = Instant::now();
-    let recent = (now - ui.last_click) < Duration::from_millis(300);
-    ui.last_click = now;
-    ui.ui
-        .text(&id)
-        .select(data.cursor, data.size, data.sense.is_dragging(), recent);
-    if let Some(region) = ui.ui.window_region(&id) {
-        ui.window.set_ime_allowed(true);
-        ui.window.set_ime_cursor_area(
-            LogicalPosition::<f32>::from(region.top_left.tuple()),
-            LogicalSize::<f32>::from(region.size().tuple()),
-        );
-    }
-    ui.focus = Some(id);
-}

src/winit/event.rs

@@ -1,15 +0,0 @@
-use crate::layout::DefaultEvent;
-
-#[derive(Eq, PartialEq, Hash, Clone)]
-pub struct Submit;
-
-#[derive(Eq, PartialEq, Hash, Clone)]
-pub struct Edited;
-
-impl DefaultEvent for Submit {
-    type Data = ();
-}
-
-impl DefaultEvent for Edited {
-    type Data = ();
-}

src/winit/mod.rs

@@ -1,191 +0,0 @@
-use crate::prelude::*;
-use crate::winit::event::{Edited, Submit};
-use crate::winit::{input::Input, render::UiRenderer};
-use arboard::Clipboard;
-use std::ops::{Deref, DerefMut};
-use std::sync::Arc;
-use std::time::Instant;
-use winit::event::{Ime, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, EventLoopProxy};
-use winit::window::{Window, WindowAttributes};
-
-mod app;
-pub mod attr;
-pub mod event;
-pub mod input;
-pub mod render;
-
-pub use app::*;
-
-pub type Proxy<Event> = EventLoopProxy<Event>;
-
-pub struct DefaultUi {
-    pub renderer: UiRenderer,
-    pub input: Input,
-    pub ui: Ui,
-    pub focus: Option<WidgetId<TextEdit>>,
-    pub clipboard: Clipboard,
-    pub window: Arc<Window>,
-    pub ime: usize,
-    pub last_click: Instant,
-}
-
-pub trait DefaultUiState: 'static {
-    type Event: 'static = ();
-    fn new(ui: DefaultUi, proxy: Proxy<Self::Event>) -> Self;
-    fn ui(&mut self) -> &mut DefaultUi;
-    #[allow(unused_variables)]
-    fn event(&mut self, event: Self::Event) {}
-    fn exit(&mut self) {}
-    #[allow(unused_variables)]
-    fn window_event(&mut self, event: WindowEvent) {}
-    fn window_attrs() -> WindowAttributes {
-        WindowAttributes::default()
-    }
-}
-
-impl<State: DefaultUiState> UiState for State {
-    type Event = State::Event;
-
-    fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
-        let window = Arc::new(
-            event_loop
-                .create_window(Self::window_attrs())
-                .expect("failed to create window "),
-        );
-        let ui = DefaultUi {
-            renderer: UiRenderer::new(window.clone()),
-            window,
-            input: Input::default(),
-            ui: Ui::new(),
-            clipboard: Clipboard::new().unwrap(),
-            ime: 0,
-            last_click: Instant::now(),
-            focus: None,
-        };
-        State::new(ui, proxy)
-    }
-
-    fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
-        self.event(event);
-    }
-
-    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
-        let ui = self.ui();
-        let input_changed = ui.input.event(&event);
-        let cursor_state = ui.cursor_state().clone();
-        let old = ui.focus.clone();
-        if cursor_state.buttons.left.is_start() {
-            ui.focus = None;
-        }
-        if input_changed {
-            let window_size = ui.window_size();
-            ui.run_sensors(&cursor_state, window_size);
-            ui.ui.run_sensors(&cursor_state, window_size);
-            self.run_sensors(&cursor_state, window_size);
-        }
-        let ui = self.ui();
-        if old != ui.focus
-            && let Some(old) = old
-        {
-            ui.text(&old).deselect();
-        }
-        match &event {
-            WindowEvent::CloseRequested => event_loop.exit(),
-            WindowEvent::RedrawRequested => {
-                ui.ui.update();
-                ui.renderer.update(&mut ui.ui);
-                ui.renderer.draw();
-            }
-            WindowEvent::Resized(size) => {
-                ui.ui.resize((size.width, size.height));
-                ui.renderer.resize(size)
-            }
-            WindowEvent::KeyboardInput { event, .. } => {
-                if let Some(sel) = &ui.focus
-                    && event.state.is_pressed()
-                {
-                    let sel = &sel.clone();
-                    let mut text = ui.ui.text(sel);
-                    match text.apply_event(event, &ui.input.modifiers) {
-                        TextInputResult::Unfocus => {
-                            ui.focus = None;
-                            ui.window.set_ime_allowed(false);
-                        }
-                        TextInputResult::Submit => {
-                            self.run_event(sel, Submit, ());
-                        }
-                        TextInputResult::Paste => {
-                            if let Ok(t) = ui.clipboard.get_text() {
-                                text.insert(&t);
-                            }
-                            self.run_event(sel, Edited, ());
-                        }
-                        TextInputResult::Copy(text) => {
-                            if let Err(err) = ui.clipboard.set_text(text) {
-                                eprintln!("failed to copy text to clipboard: {err}")
-                            }
-                        }
-                        TextInputResult::Used => {
-                            self.run_event(sel, Edited, ());
-                        }
-                        TextInputResult::Unused => {}
-                    }
-                }
-            }
-            WindowEvent::Ime(ime) => {
-                if let Some(sel) = &ui.focus {
-                    let mut text = ui.ui.text(sel);
-                    match ime {
-                        Ime::Enabled | Ime::Disabled => (),
-                        Ime::Preedit(content, _pos) => {
-                            // TODO: highlight once that's real
-                            text.replace(ui.ime, content);
-                            ui.ime = content.chars().count();
-                        }
-                        Ime::Commit(content) => {
-                            text.insert(content);
-                        }
-                    }
-                }
-            }
-            _ => (),
-        }
-        self.window_event(event);
-        let ui = self.ui();
-        if ui.needs_redraw() {
-            ui.renderer.window().request_redraw();
-        }
-        ui.input.end_frame();
-    }
-
-    fn exit(&mut self) {
-        self.exit();
-    }
-}
-
-impl<T: DefaultUiState> UiCtx for T {
-    fn ui(&mut self) -> &mut Ui {
-        &mut self.ui().ui
-    }
-}
-
-impl UiCtx for DefaultUi {
-    fn ui(&mut self) -> &mut Ui {
-        &mut self.ui
-    }
-}
-
-impl Deref for DefaultUi {
-    type Target = Ui;
-
-    fn deref(&self) -> &Self::Target {
-        &self.ui
-    }
-}
-
-impl DerefMut for DefaultUi {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.ui
-    }
-}