remove typed stuff / just specify rsc if needed

core/src/event/ctx.rs

@@ -2,13 +2,13 @@ use crate::{HasEvents, HasUi, Widget, WidgetRef};
 
 pub struct EventCtx<'a, Rsc: HasEvents, Data> {
     pub state: &'a mut Rsc::State,
-    pub data: &'a mut Data,
+    pub data: Data,
 }
 
 pub struct EventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> {
     pub widget: WidgetRef<W>,
     pub state: &'a mut Rsc::State,
-    pub data: &'a mut Data,
+    pub data: Data,
 }
 
 impl<Rsc: HasEvents + HasUi, Data, W: Widget> EventIdCtx<'_, Rsc, Data, W> {

core/src/event/manager.rs

@@ -28,7 +28,7 @@ impl<Rsc: HasEvents + 'static> EventManager<Rsc> {
         &mut self,
         id: WidgetRef<W>,
         event: E,
-        f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, W>,
+        f: impl WidgetEventFn<Rsc, <E::Event as Event>::Data, W>,
     ) {
         self.get_type::<E>().register(id, event, f);
         self.widget_to_types
@@ -74,7 +74,7 @@ pub trait EventManagerLike<State> {
     fn undraw(&mut self, data: &ActiveData);
 }
 
-type EventData<Rsc, E> = (E, Rc<dyn for<'a> EventFn<Rsc, <E as Event>::Data<'a>>>);
+type EventData<Rsc, E> = (E, Rc<dyn EventFn<Rsc, <E as Event>::Data>>);
 pub struct TypeEventManager<Rsc: HasEvents, E: Event> {
     // TODO: reduce visiblity!!
     pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
@@ -116,18 +116,20 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
         &mut self,
         widget: WidgetRef<W>,
         event: impl EventLike<Event = E>,
-        f: impl for<'a> WidgetEventFn<Rsc, E::Data<'a>, W>,
+        f: impl WidgetEventFn<Rsc, E::Data, W>,
     ) {
         let event = event.into_event();
         self.map.entry(widget.id()).or_default().push((
             event,
             Rc::new(move |ctx, rsc| {
-                let mut test = EventIdCtx {
-                    widget,
-                    state: ctx.state,
-                    data: ctx.data,
-                };
-                f(&mut test, rsc);
+                f(
+                    EventIdCtx {
+                        widget,
+                        state: ctx.state,
+                        data: ctx.data,
+                    },
+                    rsc,
+                );
             }),
         ));
     }
@@ -135,15 +137,15 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
     pub fn run_fn<'a>(
         &mut self,
         id: impl IdLike,
-    ) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) + 'a {
+    ) -> impl FnOnce(EventCtx<'_, Rsc, E::Data>, &mut Rsc) + 'a {
         let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
         move |ctx, rsc| {
             for (e, f) in fs {
-                if e.should_run(ctx.data) {
+                if let Some(data) = e.should_run(&ctx.data) {
                     f(
-                        &mut EventCtx {
+                        EventCtx {
                             state: ctx.state,
-                            data: ctx.data,
+                            data,
                         },
                         rsc,
                     )

core/src/event/mod.rs

@@ -7,11 +7,11 @@ pub use manager::*;
 pub use rsc::*;
 
 pub trait Event: Sized + 'static + Clone {
-    type Data<'a> = ();
+    type Data: Clone = ();
     type State: Default = ();
     #[allow(unused_variables)]
-    fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
-        true
+    fn should_run(&self, data: &Self::Data) -> Option<Self::Data> {
+        Some(data.clone())
     }
 }
 
@@ -28,17 +28,17 @@ impl<E: Event> EventLike for E {
     }
 }
 
-pub trait EventFn<Rsc: HasEvents, Data>: Fn(&mut EventCtx<Rsc, Data>, &mut Rsc) + 'static {}
-impl<Rsc: HasEvents, F: Fn(&mut EventCtx<Rsc, Data>, &mut Rsc) + 'static, Data> EventFn<Rsc, Data>
+pub trait EventFn<Rsc: HasEvents, Data>: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static {}
+impl<Rsc: HasEvents, F: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static, Data> EventFn<Rsc, Data>
     for F
 {
 }
 
 pub trait WidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
-    Fn(&mut EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
+    Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
 {
 }
-impl<Rsc: HasEvents, F: Fn(&mut EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static, Data, W: ?Sized>
+impl<Rsc: HasEvents, F: Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static, Data, W: ?Sized>
     WidgetEventFn<Rsc, Data, W> for F
 {
 }

core/src/event/rsc.rs

@@ -14,7 +14,7 @@ pub trait HasEvents: Sized + HasUi + HasState {
         &mut self,
         id: WidgetRef<W>,
         event: E,
-        f: impl for<'a> WidgetEventFn<Self, <E::Event as Event>::Data<'a>, W>,
+        f: impl WidgetEventFn<Self, <E::Event as Event>::Data, W>,
     ) {
         self.events_mut().register(id, event, f);
     }
@@ -24,7 +24,7 @@ pub trait RunEvents: HasEvents {
     fn run_event<E: EventLike>(
         &mut self,
         id: impl IdLike,
-        data: &mut <E::Event as Event>::Data<'_>,
+        data: <E::Event as Event>::Data,
         state: &mut Self::State,
     ) {
         let f = self.events_mut().get_type::<E>().run_fn(id);

core/src/widget/handle.rs

@@ -171,3 +171,4 @@ fn null_ptr<W: ?Sized>() -> *const W {
 }
 
 unsafe impl<W: ?Sized> Send for WidgetRef<W> {}
+unsafe impl<W: ?Sized> Sync for WidgetRef<W> {}