RE ADD CONTEXT

core/src/event/ctx.rs

@@ -1,36 +1,34 @@
-use std::ops::{Index, IndexMut};
+use std::ops::{Deref, DerefMut};
 
-use crate::{Ui, Widget, WidgetRef};
+use crate::{HasUi, Ui, Widget, WidgetRef};
 
-pub struct EventCtx<'a, Ctx, Data> {
-    pub ui: &'a mut Ui,
-    pub state: &'a mut Ctx,
+pub struct EventCtx<'a, State, Data> {
+    pub state: &'a mut State,
     pub data: &'a mut Data,
 }
 
-pub struct EventIdCtx<'a, Ctx, Data, W: ?Sized> {
-    pub widget: WidgetRef<W>,
-    pub ui: &'a mut Ui,
-    pub state: &'a mut Ctx,
+pub struct EventIdCtx<'a, State, Data, W: ?Sized> {
+    pub widget: WidgetRef<State, W>,
+    pub state: &'a mut State,
     pub data: &'a mut Data,
 }
 
-impl<'a, Ctx, Data, W2, W: Widget> Index<WidgetRef<W>> for EventIdCtx<'a, Ctx, Data, W2> {
-    type Output = W;
+impl<State: HasUi, Data, W: ?Sized> Deref for EventIdCtx<'_, State, Data, W> {
+    type Target = Ui<State>;
 
-    fn index(&self, index: WidgetRef<W>) -> &Self::Output {
-        &self.ui[index]
+    fn deref(&self) -> &Self::Target {
+        self.state.ui_ref()
     }
 }
 
-impl<'a, Ctx, Data, W2, W: Widget> IndexMut<WidgetRef<W>> for EventIdCtx<'a, Ctx, Data, W2> {
-    fn index_mut(&mut self, index: WidgetRef<W>) -> &mut Self::Output {
-        &mut self.ui[index]
+impl<State: HasUi, Data, W: ?Sized> DerefMut for EventIdCtx<'_, State, Data, W> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.state.ui()
     }
 }
 
-impl<'a, Ctx, Data, W: Widget> EventIdCtx<'a, Ctx, Data, W> {
+impl<'a, State: HasUi + 'static, Data, W: Widget<State>> EventIdCtx<'a, State, Data, W> {
     pub fn widget(&mut self) -> &mut W {
-        &mut self.ui[self.widget]
+        &mut self.state.ui()[self.widget]
     }
 }

core/src/event/manager.rs

@@ -1,30 +1,37 @@
 use crate::{
-    ActiveData, Event, EventCtx, EventFn, EventLike, IdLike, LayerId, Ui, WidgetData, WidgetId,
+    ActiveData, Event, EventCtx, EventFn, EventLike, HasUi, IdLike, LayerId, WidgetData, WidgetId,
     util::{HashMap, TypeMap},
 };
 use std::{any::TypeId, rc::Rc};
 
-#[derive(Default)]
-pub struct EventManager {
-    types: TypeMap<dyn EventManagerLike>,
+pub struct EventManager<State> {
+    types: TypeMap<dyn EventManagerLike<State>>,
 }
 
-impl EventManager {
-    pub fn get_type<E: EventLike, Ctx: 'static>(&mut self) -> &mut TypeEventManager<E::Event, Ctx> {
+impl<State> Default for EventManager<State> {
+    fn default() -> Self {
+        Self {
+            types: Default::default(),
+        }
+    }
+}
+
+impl<State: 'static> EventManager<State> {
+    pub fn get_type<E: EventLike>(&mut self) -> &mut TypeEventManager<State, E::Event> {
         self.types.type_or_default()
     }
 
-    pub fn register<I: IdLike, E: EventLike, Ctx: 'static>(
+    pub fn register<I: IdLike<State>, E: EventLike>(
         &mut self,
         id: I,
         event: E,
-        f: impl for<'a> EventFn<Ctx, <E::Event as Event>::Data<'a>>,
+        f: impl for<'a> EventFn<State, <E::Event as Event>::Data<'a>>,
     ) {
-        self.get_type::<E, Ctx>().register(id, event, f);
+        self.get_type::<E>().register(id, event, f);
     }
 
-    pub fn type_key<E: EventLike, Ctx: 'static>() -> TypeId {
-        TypeId::of::<TypeEventManager<E::Event, Ctx>>()
+    pub fn type_key<E: EventLike>() -> TypeId {
+        TypeId::of::<TypeEventManager<State, E::Event>>()
     }
 
     pub fn remove(&mut self, id: WidgetId) {
@@ -33,33 +40,33 @@ impl EventManager {
         }
     }
 
-    pub fn draw(&mut self, data: &WidgetData, active: &ActiveData) {
+    pub fn draw(&mut self, data: &WidgetData<State>, active: &ActiveData) {
         for t in &data.event_mgrs {
             self.types.get_mut(t).unwrap().draw(active);
         }
     }
 
-    pub fn undraw(&mut self, data: &WidgetData, active: &ActiveData) {
+    pub fn undraw(&mut self, data: &WidgetData<State>, active: &ActiveData) {
         for t in &data.event_mgrs {
             self.types.get_mut(t).unwrap().undraw(active);
         }
     }
 }
 
-pub trait EventManagerLike {
+pub trait EventManagerLike<State> {
     fn remove(&mut self, id: WidgetId);
     fn draw(&mut self, data: &ActiveData);
     fn undraw(&mut self, data: &ActiveData);
 }
 
-type EventData<E, Ctx> = (E, Rc<dyn for<'a> EventFn<Ctx, <E as Event>::Data<'a>>>);
-pub struct TypeEventManager<E: Event, Ctx> {
+type EventData<State, E> = (E, Rc<dyn for<'a> EventFn<State, <E as Event>::Data<'a>>>);
+pub struct TypeEventManager<State, E: Event> {
     // TODO: reduce visiblity!!
     pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
-    map: HashMap<WidgetId, Vec<EventData<E, Ctx>>>,
+    map: HashMap<WidgetId, Vec<EventData<State, E>>>,
 }
 
-impl<E: Event, Ctx: 'static> EventManagerLike for TypeEventManager<E, Ctx> {
+impl<State, E: Event> EventManagerLike<State> for TypeEventManager<State, E> {
     fn remove(&mut self, id: WidgetId) {
         self.map.remove(&id);
         for layer in self.active.values_mut() {
@@ -80,7 +87,7 @@ impl<E: Event, Ctx: 'static> EventManagerLike for TypeEventManager<E, Ctx> {
     }
 }
 
-impl<E: Event, Ctx> Default for TypeEventManager<E, Ctx> {
+impl<State, E: Event> Default for TypeEventManager<State, E> {
     fn default() -> Self {
         Self {
             active: Default::default(),
@@ -89,12 +96,12 @@ impl<E: Event, Ctx> Default for TypeEventManager<E, Ctx> {
     }
 }
 
-impl<E: Event, Ctx: 'static> TypeEventManager<E, Ctx> {
+impl<State: 'static, E: Event> TypeEventManager<State, E> {
     fn register(
         &mut self,
-        id: impl IdLike,
+        id: impl IdLike<State>,
         event: impl EventLike<Event = E>,
-        f: impl for<'a> EventFn<Ctx, E::Data<'a>>,
+        f: impl for<'a> EventFn<State, E::Data<'a>>,
     ) {
         let event = event.into_event();
         self.map
@@ -105,14 +112,13 @@ impl<E: Event, Ctx: 'static> TypeEventManager<E, Ctx> {
 
     pub fn run_fn<'a>(
         &mut self,
-        id: impl IdLike,
-    ) -> impl for<'b> FnOnce(EventCtx<Ctx, E::Data<'b>>) + 'a {
+        id: impl IdLike<State>,
+    ) -> impl for<'b> FnOnce(EventCtx<State, E::Data<'b>>) + 'a {
         let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
         move |ctx| {
             for (e, f) in fs {
                 if e.should_run(ctx.data) {
                     f(EventCtx {
-                        ui: ctx.ui,
                         state: ctx.state,
                         data: ctx.data,
                     })
@@ -122,18 +128,21 @@ impl<E: Event, Ctx: 'static> TypeEventManager<E, Ctx> {
     }
 }
 
-impl Ui {
-    pub fn run_event<E: EventLike, Ctx: 'static>(
+pub trait HasEvents: Sized + HasUi {
+    fn run_event<E: EventLike>(
         &mut self,
-        ctx: &mut Ctx,
-        id: impl IdLike,
+        id: impl IdLike<Self>,
+        data: &mut <E::Event as Event>::Data<'_>,
+    );
+}
+
+impl<State: HasUi + 'static> HasEvents for State {
+    fn run_event<E: EventLike>(
+        &mut self,
+        id: impl IdLike<Self>,
         data: &mut <E::Event as Event>::Data<'_>,
     ) {
-        let f = self.data.events.get_type::<E, Ctx>().run_fn(id);
-        f(EventCtx {
-            ui: self,
-            state: ctx,
-            data,
-        })
+        let f = self.ui().data.events.get_type::<E>().run_fn(id);
+        f(EventCtx { state: self, data })
     }
 }

core/src/event/mod.rs

@@ -26,11 +26,11 @@ impl<E: Event> EventLike for E {
     }
 }
 
-pub trait EventFn<Ctx, Data>: Fn(EventCtx<Ctx, Data>) + 'static {}
-impl<F: Fn(EventCtx<Ctx, Data>) + 'static, Ctx, Data> EventFn<Ctx, Data> for F {}
+pub trait EventFn<State, Data>: Fn(EventCtx<State, Data>) + 'static {}
+impl<State, F: Fn(EventCtx<State, Data>) + 'static, Data> EventFn<State, Data> for F {}
 
-pub trait WidgetEventFn<Ctx, Data, W: ?Sized>: Fn(EventIdCtx<Ctx, Data, W>) + 'static {}
-impl<F: Fn(EventIdCtx<Ctx, Data, W>) + 'static, Ctx, Data, W: ?Sized> WidgetEventFn<Ctx, Data, W>
-    for F
+pub trait WidgetEventFn<State, Data, W: ?Sized>: Fn(EventIdCtx<State, Data, W>) + 'static {}
+impl<State, F: Fn(EventIdCtx<State, Data, W>) + 'static, Data, W: ?Sized>
+    WidgetEventFn<State, Data, W> for F
 {
 }