separate state from rsc

core/src/widget/like.rs

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

core/src/widget/tag.rs

@@ -3,56 +3,49 @@ use crate::HasUi;
 use std::marker::Unsize;
 
 pub struct WidgetTag;
-impl<State: HasUi + StateLike<State>, W: Widget> WidgetLike<State, WidgetTag> for W {
+impl<Rsc: HasUi, W: Widget> WidgetLike<Rsc, WidgetTag> for W {
     type Widget = W;
-    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
-        state.as_state().get_mut().widgets.add_weak(self)
+    fn add(self, state: &mut Rsc) -> WidgetRef<W> {
+        state.ui_mut().widgets.add_weak(self)
     }
 }
 
 pub struct FnTag;
-impl<State: HasUi + StateLike<State>, W: Widget, F: FnOnce(&mut State) -> W>
-    WidgetLike<State, FnTag> for F
-{
+impl<Rsc: HasUi, W: Widget, F: FnOnce(&mut Rsc) -> W> WidgetLike<Rsc, FnTag> for F {
     type Widget = W;
-    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
-        self(state.as_state()).add(state)
+    fn add(self, state: &mut Rsc) -> WidgetRef<W> {
+        self(state).add(state)
     }
 }
 
-pub trait WidgetFnTrait<State> {
+pub trait WidgetFnTrait<Rsc> {
     type Widget: Widget;
-    fn run(self, state: &mut State) -> Self::Widget;
+    fn run(self, rsc: &mut Rsc) -> Self::Widget;
 }
 pub struct FnTraitTag;
-impl<State: HasUi + StateLike<State>, T: WidgetFnTrait<State>> WidgetLike<State, FnTraitTag> for T {
+impl<Rsc: HasUi, T: WidgetFnTrait<Rsc>> WidgetLike<Rsc, FnTraitTag> for T {
     type Widget = T::Widget;
     #[track_caller]
-    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<T::Widget> {
-        self.run(state.as_state()).add(state)
+    fn add(self, state: &mut Rsc) -> WidgetRef<T::Widget> {
+        self.run(state).add(state)
     }
 }
 
 pub struct IdTag;
-impl<State: HasUi + StateLike<State>, W: ?Sized + Widget + Unsize<dyn Widget>>
-    WidgetLike<State, IdTag> for WidgetRef<W>
-{
+impl<Rsc: HasUi, W: ?Sized + Widget + Unsize<dyn Widget>> WidgetLike<Rsc, IdTag> for WidgetRef<W> {
     type Widget = W;
-    fn add(self, _: &mut impl StateLike<State>) -> WidgetRef<W> {
+    fn add(self, _: &mut Rsc) -> WidgetRef<W> {
         self
     }
 }
 
 pub struct IdFnTag;
-impl<
-    State: HasUi + StateLike<State>,
-    W: ?Sized + Widget + Unsize<dyn Widget>,
-    F: FnOnce(&mut State) -> WidgetRef<W>,
-> WidgetLike<State, IdFnTag> for F
+impl<Rsc: HasUi, W: ?Sized + Widget + Unsize<dyn Widget>, F: FnOnce(&mut Rsc) -> WidgetRef<W>>
+    WidgetLike<Rsc, IdFnTag> for F
 {
     type Widget = W;
-    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
-        self(state.as_state())
+    fn add(self, state: &mut Rsc) -> WidgetRef<W> {
+        self(state)
     }
 }