remove typed stuff / just specify rsc if needed

src/default/mod.rs

@@ -127,6 +127,12 @@ impl<State: 'static> HasEvents for DefaultRsc<State> {
     }
 }
 
+impl<State: 'static> HasTasks for DefaultRsc<State> {
+    fn tasks_mut(&mut self) -> &mut Tasks<Self> {
+        &mut self.tasks
+    }
+}
+
 pub struct DefaultApp<State: DefaultAppState> {
     rsc: DefaultRsc<State>,
     state: State,
@@ -169,7 +175,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
         if input_changed {
             let window_size = ui_state.window_size();
             self.rsc
-                .run_sensors(&mut self.state, &cursor_state, window_size);
+                .run_sensors(&mut self.state, cursor_state, window_size);
         }
         let ui = &mut self.rsc.ui;
         let ui_state = self.state.default_state_mut();
@@ -200,13 +206,13 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
                             ui_state.window.set_ime_allowed(false);
                         }
                         TextInputResult::Submit => {
-                            self.rsc.run_event::<Submit>(sel, &mut (), &mut self.state);
+                            self.rsc.run_event::<Submit>(sel, (), &mut self.state);
                         }
                         TextInputResult::Paste => {
                             if let Ok(t) = ui_state.clipboard.get_text() {
                                 text.insert(&t);
                             }
-                            self.rsc.run_event::<Edited>(sel, &mut (), &mut self.state);
+                            self.rsc.run_event::<Edited>(sel, (), &mut self.state);
                         }
                         TextInputResult::Copy(text) => {
                             if let Err(err) = ui_state.clipboard.set_text(text) {
@@ -214,7 +220,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
                             }
                         }
                         TextInputResult::Used => {
-                            self.rsc.run_event::<Edited>(sel, &mut (), &mut self.state);
+                            self.rsc.run_event::<Edited>(sel, (), &mut self.state);
                         }
                         TextInputResult::Unused => {}
                     }

src/default/sense.rs

@@ -26,14 +26,15 @@ pub enum CursorSense {
 pub struct CursorSenses(Vec<CursorSense>);
 
 impl Event for CursorSenses {
-    type Data<'a> = CursorData<'a>;
+    type Data = CursorData;
     type State = SensorState;
-    fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
-        if let Some(sense) = should_run(self, data.cursor, data.hover) {
+    fn should_run(&self, data: &Self::Data) -> Option<Self::Data> {
+        if let Some(sense) = should_run(self, &data.cursor, data.hover) {
+            let mut data = data.clone();
             data.sense = sense;
-            true
+            Some(data)
         } else {
-            false
+            None
         }
     }
 }
@@ -127,23 +128,24 @@ pub struct SensorState {
     pub hover: ActivationState,
 }
 
-pub struct CursorData<'a> {
+#[derive(Clone)]
+pub struct CursorData {
     /// where this widget was hit
     pub pos: Vec2,
     pub size: Vec2,
     pub scroll_delta: Vec2,
     pub hover: ActivationState,
-    pub cursor: &'a CursorState,
+    pub cursor: CursorState,
     /// the first sense that triggered this
     pub sense: CursorSense,
 }
 
 pub trait SensorUi<Rsc: HasEvents> {
-    fn run_sensors(&mut self, state: &mut Rsc::State, cursor: &CursorState, window_size: Vec2);
+    fn run_sensors(&mut self, state: &mut Rsc::State, cursor: CursorState, window_size: Vec2);
 }
 
 impl<Rsc: HasEvents> SensorUi<Rsc> for Rsc {
-    fn run_sensors(&mut self, state: &mut Rsc::State, cursor: &CursorState, window_size: Vec2) {
+    fn run_sensors(&mut self, state: &mut Rsc::State, cursor: CursorState, window_size: Vec2) {
         let layers = std::mem::take(&mut self.ui_mut().layers);
         let mut active = std::mem::take(&mut self.events_mut().get_type::<CursorSense>().active);
         for layer in layers.indices().rev() {
@@ -158,7 +160,9 @@ impl<Rsc: HasEvents> SensorUi<Rsc> for Rsc {
                 }
                 sensed = true;
 
-                let mut data = CursorData {
+                let cursor = cursor.clone();
+
+                let data = CursorData {
                     pos: cursor.pos - region.top_left,
                     size: region.bot_right - region.top_left,
                     scroll_delta: cursor.scroll_delta,
@@ -168,7 +172,7 @@ impl<Rsc: HasEvents> SensorUi<Rsc> for Rsc {
                     // might wanna set up Event to have a prepare stage
                     sense: CursorSense::Hovering,
                 };
-                self.run_event::<CursorSense>(*id, &mut data, state);
+                self.run_event::<CursorSense>(*id, data, state);
             }
             if sensed {
                 break;

src/default/task.rs

@@ -62,17 +62,14 @@ impl<Rsc: HasState> Tasks<Rsc> {
         )
     }
 
-    pub fn spawn<F: for<'a> AsyncFnOnce(&'a mut TaskCtx<Rsc>) + 'static + std::marker::Send>(
-        &mut self,
-        task: F,
-    ) where
-        for<'a> <F as AsyncFnOnce<(&'a mut TaskCtx<Rsc>,)>>::CallOnceFuture: Send,
+    pub fn spawn<F: AsyncFnOnce(TaskCtx<Rsc>) + 'static + std::marker::Send>(&mut self, task: F)
+    where
+        F::CallOnceFuture: Send,
     {
         let send = self.msg_send.clone();
         let window = self.window.clone();
         let _ = self.start.send(Box::pin(async move {
-            let mut ctx = TaskCtx::new(send);
-            task(&mut ctx).await;
+            task(TaskCtx::new(send)).await;
             window.request_redraw();
         }));
     }