FINALLY transition events to global; slow text sending bug tho

core/src/layout/widget/handle.rs

@@ -1,13 +1,11 @@
-use std::{
-    marker::Unsize,
-    mem::MaybeUninit,
-    ops::{CoerceUnsized, Deref, DerefMut},
-    sync::mpsc::Sender,
-};
+use std::{marker::Unsize, mem::MaybeUninit, ops::CoerceUnsized};
 
 use crate::{
-    layout::{IdFnTag, IdTag, Ui, WIDGETS, Widget, WidgetLike},
-    util::{Handle, Ref, RefMap, RefMapMut, RefMut, WeakHandle},
+    layout::{EventManager, IdFnTag, IdTag, Ui, WIDGETS, Widget, WidgetData, WidgetLike},
+    util::{
+        Handle, MappedRefGuard, MappedRefGuardMut, Ref, RefGuard, RefGuardMut, RefMap, RefMapMut,
+        RefMut, WeakHandle,
+    },
 };
 
 pub(super) type SlotTy = u32;
@@ -24,17 +22,7 @@ pub struct WidgetHandle<W: ?Sized = dyn Widget>(WidgetId, Handle<WidgetData<W>>)
 /// A weak handle to a widget. Implements Copy so you can easily pass into closures
 pub struct WidgetRef<W: ?Sized = dyn Widget>(WidgetId, *const W);
 
-pub(crate) struct WidgetData<W: ?Sized> {
-    pub id: WidgetId,
-    pub send: Option<Sender<WidgetUpdate>>,
-    pub label: String,
-    pub widget: W,
-}
-
-pub enum WidgetUpdate {
-    Drop(WidgetId),
-    Mutate(WidgetId),
-}
+pub type WidgetUpdate = WidgetId;
 
 impl<W: Widget> WidgetHandle<W> {
     pub(super) fn new(id: WidgetId, widget: W) -> Self {
@@ -49,6 +37,7 @@ impl<W: Widget> WidgetHandle<W> {
                 widget,
                 send: None,
                 label,
+                event_managers: Default::default(),
             }
             .into(),
         )
@@ -82,16 +71,20 @@ impl<W: ?Sized> WidgetHandle<W> {
     pub fn get_mut(&self) -> RefMapMut<'_, W> {
         let inner = self.1.get_mut();
         if let Some(send) = &inner.send {
-            let _ = send.send(WidgetUpdate::Mutate(self.0));
+            let _ = send.send(self.0);
         }
         RefMut::map(inner, |i| &mut i.widget)
     }
 
+    pub fn data(&self) -> Ref<'_, WidgetData<W>> {
+        self.1.get()
+    }
+
     pub(crate) fn data_mut(&self) -> RefMut<'_, WidgetData<W>> {
         self.1.get_mut()
     }
 
-    pub fn get_mut_quiet(&self) -> RefMapMut<'_, W> {
+    pub(crate) fn get_mut_quiet(&self) -> RefMapMut<'_, W> {
         RefMut::map(self.1.get_mut(), |i| &mut i.widget)
     }
 
@@ -109,65 +102,53 @@ impl<W: ?Sized> WidgetHandle<W> {
     }
 
     pub fn weak(&self) -> WidgetRef<W> {
-        WidgetRef(self.0, null_ptr())
+        WidgetRef::new(self.0)
     }
 }
 
+pub type WRef<'a, W> = MappedRefGuard<'a, WidgetData<W>, W>;
+pub type WRefMut<'a, W> = MappedRefGuardMut<'a, WidgetData<W>, W>;
+
 impl<W: Widget> WidgetRef<W> {
     fn handle(&self) -> Handle<WidgetData<W>> {
         WIDGETS.get_type(self.0).unwrap()
     }
 
     pub fn get<'a>(&self) -> WRef<'a, W> {
-        let handle = self.handle();
-        WRef {
-            val: unsafe {
-                std::mem::transmute::<RefMap<'_, W>, RefMap<'_, W>>(Ref::map(handle.get(), |i| {
-                    &mut i.widget
-                }))
-            },
-            _handle: handle,
-        }
+        RefGuard::map(self.handle().get_take(), |i| &mut i.widget)
     }
 
     pub fn get_mut<'a>(&self) -> WRefMut<'a, W> {
-        let handle = self.handle();
-        if let Some(send) = &handle.get().send {
-            let _ = send.send(WidgetUpdate::Mutate(self.0));
-        }
-        WRefMut {
-            val: unsafe {
-                std::mem::transmute::<RefMapMut<'_, W>, RefMapMut<'_, W>>(RefMut::map(
-                    handle.get_mut(),
-                    |i| &mut i.widget,
-                ))
-            },
-            _handle: handle,
+        let inner = self.handle().get_take_mut();
+
+        if let Some(send) = &inner.send {
+            let _ = send.send(self.0);
         }
+        RefGuardMut::map(inner, |i| &mut i.widget)
     }
 }
 
-pub struct WRef<'a, W> {
-    _handle: Handle<WidgetData<W>>,
-    val: RefMap<'a, W>,
-}
+impl<W: ?Sized + Widget> WidgetRef<W> {
+    pub fn data<'a>(&self) -> Option<RefGuard<'a, WidgetData<dyn Widget>>> {
+        Some(WIDGETS.get(self.0)?.get_take())
+    }
 
-pub struct WRefMut<'a, W> {
-    _handle: Handle<WidgetData<W>>,
-    val: RefMapMut<'a, W>,
+    pub(crate) fn data_mut(&self) -> Option<RefGuardMut<'_, WidgetData<dyn Widget>>> {
+        Some(WIDGETS.get(self.0)?.get_take_mut())
+    }
 }
 
 impl<W: Widget + ?Sized + Unsize<dyn Widget>> WidgetRef<W> {
     pub fn any(self) -> WidgetRef<dyn Widget> {
-        WidgetRef(self.0, null_ptr())
+        WidgetRef::new(self.0)
     }
 }
 
-fn null_ptr<T: ?Sized>() -> *const T {
-    unsafe { MaybeUninit::zeroed().assume_init() }
-}
-
 impl<W: ?Sized> WidgetRef<W> {
+    fn new(id: WidgetId) -> Self {
+        Self(id, unsafe { MaybeUninit::zeroed().assume_init() })
+    }
+
     pub fn id(&self) -> WidgetId {
         self.0
     }
@@ -178,13 +159,17 @@ impl WidgetId {
     pub(crate) fn strong(self) -> Option<WidgetHandle> {
         Some(WidgetHandle(self, WIDGETS.get(self)?))
     }
-}
 
-impl<W: ?Sized> Drop for WidgetData<W> {
-    fn drop(&mut self) {
-        if let Some(send) = &self.send {
-            WIDGETS.remove(self.id);
-            let _ = send.send(WidgetUpdate::Drop(self.id));
+    pub fn weak(self) -> WidgetRef {
+        WidgetRef::new(self)
+    }
+
+    pub(crate) fn map_event_managers(&self, f: impl Fn(&mut dyn EventManager)) {
+        let Some(data) = self.weak().data() else {
+            return;
+        };
+        for mut m in data.event_managers() {
+            f(&mut *m)
         }
     }
 }
@@ -252,28 +237,8 @@ impl<W: ?Sized> Copy for WidgetRef<W> {}
 
 impl<W: ?Sized> PartialEq for WidgetRef<W> {
     fn eq(&self, other: &Self) -> bool {
-        self.0 == other.0 && self.1 == other.1
-    }
-}
-
-impl<T> Deref for WRef<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.val
-    }
-}
-
-impl<T> Deref for WRefMut<'_, T> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        &self.val
-    }
-}
-
-impl<T> DerefMut for WRefMut<'_, T> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.val
+        self.0 == other.0
     }
 }
+unsafe impl<W: ?Sized> Send for WidgetRef<W> {}
+unsafe impl<W: ?Sized> Sync for WidgetRef<W> {}