RE ADD CONTEXT

src/widget/position/span.rs

@@ -1,14 +1,14 @@
 use crate::prelude::*;
 use std::marker::PhantomData;
 
-pub struct Span {
-    pub children: Vec<WidgetHandle>,
+pub struct Span<State> {
+    pub children: Vec<WidgetHandle<State>>,
     pub dir: Dir,
     pub gap: f32,
 }
 
-impl Widget for Span {
-    fn draw(&mut self, painter: &mut Painter) {
+impl<State: 'static> Widget<State> for Span<State> {
+    fn draw(&mut self, painter: &mut Painter<State>) {
         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 Widget for Span {
         }
     }
 
-    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len {
+    fn desired_width(&mut self, ctx: &mut SizeCtx<State>) -> Len {
         match self.dir.axis {
             Axis::X => self.desired_len(ctx),
             Axis::Y => self.desired_ortho(ctx),
         }
     }
 
-    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len {
+    fn desired_height(&mut self, ctx: &mut SizeCtx<State>) -> Len {
         match self.dir.axis {
             Axis::X => self.desired_ortho(ctx),
             Axis::Y => self.desired_len(ctx),
@@ -48,7 +48,7 @@ impl Widget for Span {
     }
 }
 
-impl Span {
+impl<State: 'static> Span<State> {
     pub fn empty(dir: Dir) -> Self {
         Self {
             children: Vec::new(),
@@ -62,7 +62,7 @@ impl Span {
         self
     }
 
-    fn len_sum(&mut self, ctx: &mut SizeCtx) -> Len {
+    fn len_sum(&mut self, ctx: &mut SizeCtx<State>) -> 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 Span {
         })
     }
 
-    fn desired_len(&mut self, ctx: &mut SizeCtx) -> Len {
+    fn desired_len(&mut self, ctx: &mut SizeCtx<State>) -> Len {
         let len = self.len_sum(ctx);
         if len.rest == 0.0 && len.rel == 0.0 {
             len
@@ -87,7 +87,7 @@ impl Span {
         }
     }
 
-    fn desired_ortho(&mut self, ctx: &mut SizeCtx) -> Len {
+    fn desired_ortho(&mut self, ctx: &mut SizeCtx<State>) -> 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,
@@ -144,19 +144,19 @@ impl Span {
     }
 }
 
-pub struct SpanBuilder<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> {
+pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
     pub children: Wa,
     pub dir: Dir,
     pub gap: f32,
-    _pd: PhantomData<Tag>,
+    _pd: PhantomData<(State, Tag)>,
 }
 
-impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> FnOnce<(&mut Ui,)>
-    for SpanBuilder<LEN, Wa, Tag>
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> FnOnce<(&mut Ui<State>,)>
+    for SpanBuilder<State, LEN, Wa, Tag>
 {
-    type Output = Span;
+    type Output = Span<State>;
 
-    extern "rust-call" fn call_once(self, args: (&mut Ui,)) -> Self::Output {
+    extern "rust-call" fn call_once(self, args: (&mut Ui<State>,)) -> Self::Output {
         Span {
             children: self.children.ui(args.0).arr.into_iter().collect(),
             dir: self.dir,
@@ -165,7 +165,9 @@ impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> FnOnce<(&mut Ui,)>
     }
 }
 
-impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> SpanBuilder<LEN, Wa, Tag> {
+impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
+    SpanBuilder<State, LEN, Wa, Tag>
+{
     pub fn new(children: Wa, dir: Dir) -> Self {
         Self {
             children,
@@ -181,15 +183,15 @@ impl<const LEN: usize, Wa: WidgetArrLike<LEN, Tag>, Tag> SpanBuilder<LEN, Wa, Ta
     }
 }
 
-impl std::ops::Deref for Span {
-    type Target = Vec<WidgetHandle>;
+impl<State> std::ops::Deref for Span<State> {
+    type Target = Vec<WidgetHandle<State>>;
 
     fn deref(&self) -> &Self::Target {
         &self.children
     }
 }
 
-impl std::ops::DerefMut for Span {
+impl<State> std::ops::DerefMut for Span<State> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.children
     }