work

core/src/widget/handle.rs

@@ -1,7 +1,7 @@
 use std::{marker::Unsize, ops::CoerceUnsized, sync::mpsc::Sender};
 
 use crate::{
-    HasUi, Widget,
+    UiRsc, Widget,
     util::{RefCounter, SlotId},
 };
 
@@ -12,7 +12,7 @@ pub type WidgetId = SlotId;
 /// a signal is sent to the owning UI to clean up the resources.
 ///
 /// TODO: ergonomic clones when they get put in rust-analyzer & don't cause ICEs?
-pub struct WidgetHandle<W: ?Sized = dyn Widget> {
+pub struct StrongWidget<W: ?Sized = dyn Widget> {
     pub(super) id: WidgetId,
     counter: RefCounter,
     send: Sender<WidgetId>,
@@ -21,24 +21,19 @@ pub struct WidgetHandle<W: ?Sized = dyn Widget> {
 
 /// A weak handle to a widget.
 /// Will not keep it alive, but can still be used for indexing like WidgetHandle.
-pub struct WidgetRef<W: ?Sized = dyn Widget> {
+pub struct WeakWidget<W: ?Sized = dyn Widget> {
     pub(super) id: WidgetId,
     #[allow(unused)]
     ty: *const W,
 }
 
-pub struct WidgetHandles<W: ?Sized = dyn Widget> {
-    pub h: WidgetHandle<W>,
-    pub r: WidgetRef<W>,
-}
-
-impl<W: Widget + ?Sized + Unsize<dyn Widget>> WidgetHandle<W> {
-    pub fn any(self) -> WidgetHandle<dyn Widget> {
+impl<W: Widget + ?Sized + Unsize<dyn Widget>> StrongWidget<W> {
+    pub fn any(self) -> StrongWidget<dyn Widget> {
         self
     }
 }
 
-impl<W: ?Sized> WidgetHandle<W> {
+impl<W: ?Sized> StrongWidget<W> {
     pub(crate) fn new(id: WidgetId, send: Sender<WidgetId>) -> Self {
         Self {
             id,
@@ -56,18 +51,13 @@ impl<W: ?Sized> WidgetHandle<W> {
         self.counter.refs()
     }
 
-    pub fn weak(&self) -> WidgetRef<W> {
+    pub fn weak(&self) -> WeakWidget<W> {
         let Self { ty, id, .. } = *self;
-        WidgetRef { ty, id }
-    }
-
-    pub fn handles(self) -> WidgetHandles<W> {
-        let r = self.weak();
-        WidgetHandles { h: self, r }
+        WeakWidget { ty, id }
     }
 }
 
-impl<W: ?Sized> WidgetRef<W> {
+impl<W: ?Sized> WeakWidget<W> {
     pub(crate) fn new(id: WidgetId) -> Self {
         Self { id, ty: null_ptr() }
     }
@@ -77,12 +67,12 @@ impl<W: ?Sized> WidgetRef<W> {
     }
 
     #[track_caller]
-    pub fn upgrade(self, ui: &mut impl HasUi) -> WidgetHandle<W> {
-        ui.ui_mut().widgets.upgrade(self)
+    pub fn upgrade(self, ui: &mut impl UiRsc) -> StrongWidget<W> {
+        ui.widgets_mut().upgrade(self)
     }
 }
 
-impl<W: ?Sized> Drop for WidgetHandle<W> {
+impl<W: ?Sized> Drop for StrongWidget<W> {
     fn drop(&mut self) {
         if self.counter.drop() {
             let _ = self.send.send(self.id);
@@ -90,29 +80,29 @@ impl<W: ?Sized> Drop for WidgetHandle<W> {
     }
 }
 
-pub trait WidgetIdFn<Rsc, W: ?Sized = dyn Widget>: FnOnce(&mut Rsc) -> WidgetRef<W> {}
-impl<Rsc, W: ?Sized, F: FnOnce(&mut Rsc) -> WidgetRef<W>> WidgetIdFn<Rsc, W> for F {}
+pub trait WidgetIdFn<Rsc, W: ?Sized = dyn Widget>: FnOnce(&mut Rsc) -> WeakWidget<W> {}
+impl<Rsc, W: ?Sized, F: FnOnce(&mut Rsc) -> WeakWidget<W>> WidgetIdFn<Rsc, W> for F {}
 
 pub trait IdLike {
     type Widget: ?Sized;
     fn id(&self) -> WidgetId;
 }
 
-impl<W: ?Sized> IdLike for &WidgetHandle<W> {
+impl<W: ?Sized> IdLike for &StrongWidget<W> {
     type Widget = W;
     fn id(&self) -> WidgetId {
         self.id
     }
 }
 
-impl<W: ?Sized> IdLike for WidgetHandle<W> {
+impl<W: ?Sized> IdLike for StrongWidget<W> {
     type Widget = W;
     fn id(&self) -> WidgetId {
         self.id
     }
 }
 
-impl<W: ?Sized> IdLike for WidgetRef<W> {
+impl<W: ?Sized> IdLike for WeakWidget<W> {
     type Widget = W;
     fn id(&self) -> WidgetId {
         self.id
@@ -126,38 +116,38 @@ impl IdLike for WidgetId {
     }
 }
 
-impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetHandle<U>> for WidgetHandle<T> {}
-impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetRef<U>> for WidgetRef<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<StrongWidget<U>> for StrongWidget<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WeakWidget<U>> for WeakWidget<T> {}
 
-impl<W: ?Sized> Clone for WidgetRef<W> {
+impl<W: ?Sized> Clone for WeakWidget<W> {
     fn clone(&self) -> Self {
         *self
     }
 }
-impl<W: ?Sized> Copy for WidgetRef<W> {}
-impl<W: ?Sized> PartialEq for WidgetRef<W> {
+impl<W: ?Sized> Copy for WeakWidget<W> {}
+impl<W: ?Sized> PartialEq for WeakWidget<W> {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 
-impl<W> PartialEq for WidgetHandle<W> {
+impl<W> PartialEq for StrongWidget<W> {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 
-impl<W> std::fmt::Debug for WidgetHandle<W> {
+impl<W> std::fmt::Debug for StrongWidget<W> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.id.fmt(f)
     }
 }
 
-impl<'a, W: Widget + 'a, State: HasUi> FnOnce<(&'a mut State,)> for WidgetRef<W> {
+impl<'a, W: Widget + 'a, State: UiRsc> FnOnce<(&'a mut State,)> for WeakWidget<W> {
     type Output = &'a mut W;
 
     extern "rust-call" fn call_once(self, args: (&'a mut State,)) -> Self::Output {
-        &mut args.0.ui_mut()[self]
+        &mut args.0.widgets_mut()[self]
     }
 }
 
@@ -170,5 +160,5 @@ fn null_ptr<W: ?Sized>() -> *const W {
     }
 }
 
-unsafe impl<W: ?Sized> Send for WidgetRef<W> {}
-unsafe impl<W: ?Sized> Sync for WidgetRef<W> {}
+unsafe impl<W: ?Sized> Send for WeakWidget<W> {}
+unsafe impl<W: ?Sized> Sync for WeakWidget<W> {}