remove state generic from a lot of things

src/widget/position/align.rs

@@ -1,12 +1,12 @@
 use crate::prelude::*;
 
-pub struct Aligned<State> {
-    pub inner: WidgetHandle<State>,
+pub struct Aligned {
+    pub inner: WidgetHandle,
     pub align: Align,
 }
 
-impl<State: 'static> Widget<State> for Aligned<State> {
-    fn draw(&mut self, painter: &mut Painter<State>) {
+impl Widget for Aligned {
+    fn draw(&mut self, painter: &mut Painter) {
         let region = match self.align.tuple() {
             (Some(x), Some(y)) => painter
                 .size(&self.inner)
@@ -25,11 +25,11 @@ impl<State: 'static> Widget<State> for Aligned<State> {
         painter.widget_within(&self.inner, region);
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
         ctx.width(&self.inner)
     }
 
-    fn desired_height(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
         ctx.height(&self.inner)
     }
 }

src/widget/position/layer.rs

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

src/widget/position/max_size.rs

@@ -1,13 +1,13 @@
 use crate::prelude::*;
 
-pub struct MaxSize<State> {
-    pub inner: WidgetHandle<State>,
+pub struct MaxSize {
+    pub inner: WidgetHandle,
     pub x: Option<Len>,
     pub y: Option<Len>,
 }
 
-impl<State: 'static> MaxSize<State> {
-    fn apply_to_outer(&self, ctx: &mut SizeCtx<State>) {
+impl MaxSize {
+    fn apply_to_outer(&self, ctx: &mut SizeCtx) {
         if let Some(x) = self.x {
             ctx.outer.x.select_len(x.apply_rest());
         }
@@ -17,12 +17,12 @@ impl<State: 'static> MaxSize<State> {
     }
 }
 
-impl<State: 'static> Widget<State> for MaxSize<State> {
-    fn draw(&mut self, painter: &mut Painter<State>) {
+impl Widget for MaxSize {
+    fn draw(&mut self, painter: &mut Painter) {
         painter.widget(&self.inner);
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
         self.apply_to_outer(ctx);
         let width = ctx.width(&self.inner);
         if let Some(x) = self.x {
@@ -34,7 +34,7 @@ impl<State: 'static> Widget<State> for MaxSize<State> {
         }
     }
 
-    fn desired_height(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
         self.apply_to_outer(ctx);
         let height = ctx.height(&self.inner);
         if let Some(y) = self.y {

src/widget/position/offset.rs

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

src/widget/position/pad.rs

@@ -1,16 +1,16 @@
 use crate::prelude::*;
 
-pub struct Pad<State> {
+pub struct Pad {
     pub padding: Padding,
-    pub inner: WidgetHandle<State>,
+    pub inner: WidgetHandle,
 }
 
-impl<State: 'static> Widget<State> for Pad<State> {
-    fn draw(&mut self, painter: &mut Painter<State>) {
+impl Widget for Pad {
+    fn draw(&mut self, painter: &mut Painter) {
         painter.widget_within(&self.inner, self.padding.region());
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
         let width = self.padding.left + self.padding.right;
         let height = self.padding.top + self.padding.bottom;
         ctx.outer.x.abs -= width;
@@ -20,7 +20,7 @@ impl<State: 'static> Widget<State> for Pad<State> {
         size
     }
 
-    fn desired_height(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
         let width = self.padding.left + self.padding.right;
         let height = self.padding.top + self.padding.bottom;
         ctx.outer.x.abs -= width;

src/widget/position/scroll.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
-pub struct Scroll<State> {
-    inner: WidgetHandle<State>,
+pub struct Scroll {
+    inner: WidgetHandle,
     axis: Axis,
     amt: f32,
     snap_end: bool,
@@ -9,8 +9,8 @@ pub struct Scroll<State> {
     content_len: f32,
 }
 
-impl<State: 'static> Widget<State> for Scroll<State> {
-    fn draw(&mut self, painter: &mut Painter<State>) {
+impl Widget for Scroll {
+    fn draw(&mut self, painter: &mut Painter) {
         let output_len = painter.output_size().axis(self.axis);
         let container_len = painter.region().axis(self.axis).len();
         let content_len = painter
@@ -31,17 +31,17 @@ impl<State: 'static> Widget<State> for Scroll<State> {
         painter.widget_within(&self.inner, region);
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
         ctx.width(&self.inner)
     }
 
-    fn desired_height(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
         ctx.height(&self.inner)
     }
 }
 
-impl<State> Scroll<State> {
-    pub fn new(inner: WidgetHandle<State>, axis: Axis) -> Self {
+impl Scroll {
+    pub fn new(inner: WidgetHandle, axis: Axis) -> Self {
         Self {
             inner,
             axis,

src/widget/position/sized.rs

@@ -1,13 +1,13 @@
 use crate::prelude::*;
 
-pub struct Sized<State> {
-    pub inner: WidgetHandle<State>,
+pub struct Sized {
+    pub inner: WidgetHandle,
     pub x: Option<Len>,
     pub y: Option<Len>,
 }
 
-impl<State: 'static> Sized<State> {
-    fn apply_to_outer(&self, ctx: &mut SizeCtx<State>) {
+impl Sized {
+    fn apply_to_outer(&self, ctx: &mut SizeCtx) {
         if let Some(x) = self.x {
             ctx.outer.x.select_len(x.apply_rest());
         }
@@ -17,17 +17,17 @@ impl<State: 'static> Sized<State> {
     }
 }
 
-impl<State: 'static> Widget<State> for Sized<State> {
-    fn draw(&mut self, painter: &mut Painter<State>) {
+impl Widget for Sized {
+    fn draw(&mut self, painter: &mut Painter) {
         painter.widget(&self.inner);
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
         self.apply_to_outer(ctx);
         self.x.unwrap_or_else(|| ctx.width(&self.inner))
     }
 
-    fn desired_height(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
         self.apply_to_outer(ctx);
         self.y.unwrap_or_else(|| ctx.height(&self.inner))
     }

src/widget/position/span.rs

@@ -1,14 +1,14 @@
 use crate::prelude::*;
 use std::marker::PhantomData;
 
-pub struct Span<State> {
-    pub children: Vec<WidgetHandle<State>>,
+pub struct Span {
+    pub children: Vec<WidgetHandle>,
     pub dir: Dir,
     pub gap: f32,
 }
 
-impl<State: 'static> Widget<State> for Span<State> {
-    fn draw(&mut self, painter: &mut Painter<State>) {
+impl Widget for Span {
+    fn draw(&mut self, painter: &mut Painter) {
         let total = self.len_sum(&mut painter.size_ctx());
         let mut start = UiScalar::rel_min();
         for child in &self.children {
@@ -33,14 +33,14 @@ impl<State: 'static> Widget<State> for Span<State> {
         }
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
         match self.dir.axis {
             Axis::X => self.desired_len(ctx),
             Axis::Y => self.desired_ortho(ctx),
         }
     }
 
-    fn desired_height(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
         match self.dir.axis {
             Axis::X => self.desired_ortho(ctx),
             Axis::Y => self.desired_len(ctx),
@@ -48,7 +48,7 @@ impl<State: 'static> Widget<State> for Span<State> {
     }
 }
 
-impl<State: 'static> Span<State> {
+impl Span {
     pub fn empty(dir: Dir) -> Self {
         Self {
             children: Vec::new(),
@@ -62,7 +62,7 @@ impl<State: 'static> Span<State> {
         self
     }
 
-    fn len_sum(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn len_sum(&mut self, ctx: &mut SizeCtx) -> Len {
         let gap = self.gap * self.children.len().saturating_sub(1) as f32;
         self.children.iter().fold(Len::abs(gap), |mut s, id| {
             // it's tempting to subtract the abs & rel from the ctx outer,
@@ -78,7 +78,7 @@ impl<State: 'static> Span<State> {
         })
     }
 
-    fn desired_len(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_len(&mut self, ctx: &mut SizeCtx) -> Len {
         let len = self.len_sum(ctx);
         if len.rest == 0.0 && len.rel == 0.0 {
             len
@@ -87,7 +87,7 @@ impl<State: 'static> Span<State> {
         }
     }
 
-    fn desired_ortho(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_ortho(&mut self, ctx: &mut SizeCtx) -> Len {
         // this is a weird hack to get text wrapping to work properly when in a downward span
         // the correct solution here is to add a function to widget that lets them
         // request that ctx.outer has an axis "resolved" before checking the other,
@@ -151,14 +151,14 @@ pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Ta
     _pd: PhantomData<(State, Tag)>,
 }
 
-impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> FnOnce<(&mut Ui<State>,)>
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> FnOnce<(&mut State,)>
     for SpanBuilder<State, LEN, Wa, Tag>
 {
-    type Output = Span<State>;
+    type Output = Span;
 
-    extern "rust-call" fn call_once(self, args: (&mut Ui<State>,)) -> Self::Output {
+    extern "rust-call" fn call_once(self, args: (&mut State,)) -> Self::Output {
         Span {
-            children: self.children.ui(args.0).arr.into_iter().collect(),
+            children: self.children.add(args.0).arr.into_iter().collect(),
             dir: self.dir,
             gap: self.gap,
         }
@@ -183,15 +183,15 @@ impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
     }
 }
 
-impl<State> std::ops::Deref for Span<State> {
-    type Target = Vec<WidgetHandle<State>>;
+impl std::ops::Deref for Span {
+    type Target = Vec<WidgetHandle>;
 
     fn deref(&self) -> &Self::Target {
         &self.children
     }
 }
 
-impl<State> std::ops::DerefMut for Span<State> {
+impl std::ops::DerefMut for Span {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.children
     }

src/widget/position/stack.rs

@@ -2,13 +2,13 @@ use std::marker::PhantomData;
 
 use crate::prelude::*;
 
-pub struct Stack<State> {
-    pub children: Vec<WidgetHandle<State>>,
+pub struct Stack {
+    pub children: Vec<WidgetHandle>,
     pub size: StackSize,
 }
 
-impl<State: 'static> Widget<State> for Stack<State> {
-    fn draw(&mut self, painter: &mut Painter<State>) {
+impl Widget for Stack {
+    fn draw(&mut self, painter: &mut Painter) {
         let mut iter = self.children.iter();
         if let Some(child) = iter.next() {
             painter.child_layer();
@@ -20,14 +20,14 @@ impl<State: 'static> Widget<State> for Stack<State> {
         }
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
         match self.size {
             StackSize::Default => Len::default(),
             StackSize::Child(i) => ctx.width(&self.children[i]),
         }
     }
 
-    fn desired_height(&mut self, ctx: &mut SizeCtx<State>) -> Len {
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
         match self.size {
             StackSize::Default => Len::default(),
             StackSize::Child(i) => ctx.height(&self.children[i]),
@@ -48,14 +48,14 @@ pub struct StackBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, T
     _pd: PhantomData<(State, Tag)>,
 }
 
-impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> FnOnce<(&mut Ui<State>,)>
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> FnOnce<(&mut State,)>
     for StackBuilder<State, LEN, Wa, Tag>
 {
-    type Output = Stack<State>;
+    type Output = Stack;
 
-    extern "rust-call" fn call_once(self, args: (&mut Ui<State>,)) -> Self::Output {
+    extern "rust-call" fn call_once(self, args: (&mut State,)) -> Self::Output {
         Stack {
-            children: self.children.ui(args.0).arr.into_iter().collect(),
+            children: self.children.add(args.0).arr.into_iter().collect(),
             size: self.size,
         }
     }