refactor events

core/src/event/ctx.rs

@@ -0,0 +1,36 @@
+use std::ops::{Index, IndexMut};
+
+use crate::{Ui, Widget, WidgetRef};
+
+pub struct EventCtx<'a, Ctx, Data> {
+    pub ui: &'a mut Ui,
+    pub state: &'a mut Ctx,
+    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 data: &'a mut Data,
+}
+
+impl<'a, Ctx, Data, W2, W: Widget> Index<WidgetRef<W>> for EventIdCtx<'a, Ctx, Data, W2> {
+    type Output = W;
+
+    fn index(&self, index: WidgetRef<W>) -> &Self::Output {
+        &self.ui[index]
+    }
+}
+
+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<'a, Ctx, Data, W: Widget> EventIdCtx<'a, Ctx, Data, W> {
+    pub fn widget(&mut self) -> &mut W {
+        &mut self.ui[self.widget]
+    }
+}

core/src/event/manager.rs

@@ -0,0 +1,151 @@
+use crate::{
+    ActiveData, Event, EventCtx, EventFn, EventLike, IdLike, LayerId, Ui, WidgetData, WidgetId,
+    util::HashMap,
+};
+use std::{
+    any::{Any, TypeId},
+    rc::Rc,
+};
+
+#[derive(Default)]
+pub struct EventManager {
+    types: HashMap<TypeId, Box<dyn EventManagerLike>>,
+}
+
+impl EventManager {
+    pub fn get_type<E: EventLike, Ctx: 'static>(&mut self) -> &mut TypeEventManager<E::Event, Ctx> {
+        self.types
+            .entry(Self::type_key::<E, Ctx>())
+            .or_insert(Box::new(TypeEventManager::<E::Event, Ctx>::default()))
+            .as_any()
+            .downcast_mut()
+            .unwrap()
+    }
+
+    pub fn register<I: IdLike, E: EventLike, Ctx: 'static>(
+        &mut self,
+        id: I,
+        event: E,
+        f: impl for<'a> EventFn<Ctx, <E::Event as Event>::Data<'a>>,
+    ) {
+        self.get_type::<E, Ctx>().register(id, event, f);
+    }
+
+    pub fn type_key<E: EventLike, Ctx: 'static>() -> TypeId {
+        TypeId::of::<TypeEventManager<E::Event, Ctx>>()
+    }
+
+    pub fn remove(&mut self, id: WidgetId) {
+        for m in self.types.values_mut() {
+            m.remove(id);
+        }
+    }
+
+    pub fn draw(&mut self, data: &WidgetData, 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) {
+        for t in &data.event_mgrs {
+            self.types.get_mut(t).unwrap().undraw(active);
+        }
+    }
+}
+
+pub trait EventManagerLike {
+    fn remove(&mut self, id: WidgetId);
+    fn draw(&mut self, data: &ActiveData);
+    fn undraw(&mut self, data: &ActiveData);
+    fn as_any(&mut self) -> &mut dyn Any;
+}
+
+type EventData<E, Ctx> = (E, Rc<dyn for<'a> EventFn<Ctx, <E as Event>::Data<'a>>>);
+pub struct TypeEventManager<E: Event, Ctx> {
+    // TODO: reduce visiblity!!
+    pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
+    map: HashMap<WidgetId, Vec<EventData<E, Ctx>>>,
+}
+
+impl<E: Event, Ctx: 'static> EventManagerLike for TypeEventManager<E, Ctx> {
+    fn remove(&mut self, id: WidgetId) {
+        self.map.remove(&id);
+        for layer in self.active.values_mut() {
+            layer.remove(&id);
+        }
+    }
+    fn draw(&mut self, data: &ActiveData) {
+        self.active
+            .entry(data.layer)
+            .or_default()
+            .entry(data.id)
+            .or_default();
+    }
+    fn undraw(&mut self, data: &ActiveData) {
+        if let Some(layer) = self.active.get_mut(&data.layer) {
+            layer.remove(&data.id);
+        }
+    }
+    fn as_any(&mut self) -> &mut dyn Any {
+        self
+    }
+}
+
+impl<E: Event, Ctx> Default for TypeEventManager<E, Ctx> {
+    fn default() -> Self {
+        Self {
+            active: Default::default(),
+            map: Default::default(),
+        }
+    }
+}
+
+impl<E: Event, Ctx: 'static> TypeEventManager<E, Ctx> {
+    fn register(
+        &mut self,
+        id: impl IdLike,
+        event: impl EventLike<Event = E>,
+        f: impl for<'a> EventFn<Ctx, E::Data<'a>>,
+    ) {
+        let event = event.into_event();
+        self.map
+            .entry(id.id())
+            .or_default()
+            .push((event, Rc::new(f)));
+    }
+
+    pub fn run_fn<'a>(
+        &mut self,
+        id: impl IdLike,
+    ) -> impl for<'b> FnOnce(EventCtx<Ctx, 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,
+                    })
+                }
+            }
+        }
+    }
+}
+
+impl Ui {
+    pub fn run_event<E: EventLike, Ctx: 'static>(
+        &mut self,
+        ctx: &mut Ctx,
+        id: impl IdLike,
+        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,
+        })
+    }
+}

core/src/event/mod.rs

@@ -0,0 +1,36 @@
+mod ctx;
+mod manager;
+
+pub use ctx::*;
+pub use manager::*;
+
+pub trait Event: Sized + 'static + Clone {
+    type Data<'a> = ();
+    type State: Default = ();
+    #[allow(unused_variables)]
+    fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
+        true
+    }
+}
+
+pub trait EventLike {
+    type Event: Event;
+    fn into_event(self) -> Self::Event;
+}
+
+impl<E: Event> EventLike for E {
+    type Event = Self;
+
+    fn into_event(self) -> Self::Event {
+        self
+    }
+}
+
+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 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
+{
+}