RE ADD CONTEXT

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 })
     }
 }