idk work (r + h)

core/src/attr.rs

@@ -1,8 +1,8 @@
-use crate::{Ui, WidgetIdFn, WidgetLike, WidgetView};
+use crate::{Ui, WidgetIdFn, WidgetLike, WidgetRef};
 
 pub trait WidgetAttr<W: ?Sized> {
     type Input;
-    fn run(ui: &mut Ui, id: WidgetView<W>, input: Self::Input);
+    fn run(ui: &mut Ui, id: WidgetRef<W>, input: Self::Input);
 }
 
 pub trait Attrable<W: ?Sized, Tag> {

core/src/event.rs

@@ -1,5 +1,9 @@
-use crate::{Ui, UiModule, WidgetId, WidgetView, util::HashMap};
-use std::{hash::Hash, rc::Rc};
+use crate::{Ui, UiModule, Widget, WidgetId, WidgetRef, util::HashMap};
+use std::{
+    hash::Hash,
+    ops::{Index, IndexMut},
+    rc::Rc,
+};
 
 pub trait Event: Sized {
     type Module<Ctx: 'static>: EventModule<Self, Ctx>;
@@ -13,12 +17,32 @@ pub struct EventCtx<'a, Ctx, Data> {
 }
 
 pub struct EventIdCtx<'a, Ctx, Data, W: ?Sized> {
-    pub id: WidgetView<W>,
+    pub widget: WidgetRef<W>,
     pub ui: &'a mut Ui,
     pub state: &'a mut Ctx,
     pub data: 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]
+    }
+}
+
 pub trait EventFn<Ctx, Data>: Fn(EventCtx<Ctx, Data>) + 'static {}
 impl<F: Fn(EventCtx<Ctx, Data>) + 'static, Ctx, Data> EventFn<Ctx, Data> for F {}
 
@@ -127,7 +151,7 @@ impl Ui {
     pub fn run_event<E: Event, Ctx: 'static, W>(
         &mut self,
         ctx: &mut Ctx,
-        id: WidgetView<W>,
+        id: WidgetRef<W>,
         event: E,
         data: E::Data,
     ) {

core/src/primitive/color.rs

@@ -1,9 +1,9 @@
-#![allow(clippy::multiple_bound_locations)]
+use std::marker::Destruct;
 
 /// stored in linear for sane manipulation
 #[repr(C)]
 #[derive(Clone, Copy, Hash, PartialEq, Eq, bytemuck::Zeroable, Debug)]
-pub struct Color<T: ColorNum> {
+pub struct Color<T> {
     pub r: T,
     pub g: T,
     pub b: T,
@@ -56,23 +56,47 @@ pub trait ColorNum {
     const MAX: Self;
 }
 
-impl<T: ColorNum + F32Conversion> Color<T> {
-    pub fn mul_rgb(self, amt: impl F32Conversion) -> Self {
+macro_rules! map_rgb {
+    ($x:ident,$self:ident, $e:tt) => {
+        #[allow(unused_braces)]
+        Self {
+            r: {
+                let $x = $self.r;
+                $e
+            },
+            g: {
+                let $x = $self.g;
+                $e
+            },
+            b: {
+                let $x = $self.b;
+                $e
+            },
+            a: $self.a,
+        }
+    };
+}
+
+impl<T: ColorNum + const F32Conversion> Color<T>
+where
+    Self: const Destruct,
+{
+    pub const fn mul_rgb(self, amt: impl const F32Conversion) -> Self {
         let amt = amt.to();
-        self.map_rgb(|x| T::from(x.to() * amt))
+        map_rgb!(x, self, { T::from(x.to() * amt) })
     }
 
-    pub fn add_rgb(self, amt: impl F32Conversion) -> Self {
+    pub const fn add_rgb(self, amt: impl const F32Conversion) -> Self {
         let amt = amt.to();
-        self.map_rgb(|x| T::from(x.to() + amt))
+        map_rgb!(x, self, { T::from(x.to() + amt) })
     }
 
-    pub fn darker(self, amt: f32) -> Self {
+    pub const fn darker(self, amt: f32) -> Self {
         self.mul_rgb(1.0 - amt)
     }
 
-    pub fn brighter(self, amt: f32) -> Self {
-        self.map_rgb(|x| {
+    pub const fn brighter(self, amt: f32) -> Self {
+        map_rgb!(x, self, {
             let x = x.to();
             T::from(x + (1.0 - x) * amt)
         })

core/src/widget/handle.rs

@@ -7,12 +7,9 @@ use crate::{
 
 pub type WidgetId = SlotId;
 
-/// An identifier for a widget that can index a UI to get the associated widget.
-/// It should always remain valid; it keeps a ref count and removes the widget from the UI if all
-/// references are dropped.
-///
-/// W does not need to implement widget so that AnyWidget is valid;
-/// Instead, add generic bounds on methods that take an ID if they need specific data.
+/// An identifier for a widget that can index a UI or event ctx to get it.
+/// This is a strong handle that does not impl Clone, and when it is dropped,
+/// 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> {
@@ -22,13 +19,18 @@ pub struct WidgetHandle<W: ?Sized = dyn Widget> {
     ty: *const W,
 }
 
-pub struct WidgetView<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(super) id: WidgetId,
     #[allow(unused)]
     ty: *const W,
 }
 
-pub type WidgetHandles<W> = (WidgetHandle<W>, WidgetView<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> {
@@ -59,18 +61,18 @@ impl<W: ?Sized> WidgetHandle<W> {
         self.counter.refs()
     }
 
-    pub fn weak(&self) -> WidgetView<W> {
+    pub fn weak(&self) -> WidgetRef<W> {
         let Self { ty, id, .. } = *self;
-        WidgetView { ty, id }
+        WidgetRef { ty, id }
     }
 
     pub fn handles(self) -> WidgetHandles<W> {
-        let weak = self.weak();
-        (self, weak)
+        let r = self.weak();
+        WidgetHandles { h: self, r }
     }
 }
 
-impl<W: ?Sized> WidgetView<W> {
+impl<W: ?Sized> WidgetRef<W> {
     pub fn id(&self) -> WidgetId {
         self.id
     }
@@ -99,7 +101,7 @@ impl<W: Widget + ?Sized> IdLike for WidgetHandle<W> {
     }
 }
 
-impl<W: Widget + ?Sized> IdLike for WidgetView<W> {
+impl<W: Widget + ?Sized> IdLike for WidgetRef<W> {
     type Widget = W;
     fn id(&self) -> WidgetId {
         self.id
@@ -107,15 +109,15 @@ impl<W: Widget + ?Sized> IdLike for WidgetView<W> {
 }
 
 impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetHandle<U>> for WidgetHandle<T> {}
-impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetView<U>> for WidgetView<T> {}
+impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetRef<U>> for WidgetRef<T> {}
 
-impl<W: ?Sized> Clone for WidgetView<W> {
+impl<W: ?Sized> Clone for WidgetRef<W> {
     fn clone(&self) -> Self {
         *self
     }
 }
-impl<W: ?Sized> Copy for WidgetView<W> {}
-impl<W: ?Sized> PartialEq for WidgetView<W> {
+impl<W: ?Sized> Copy for WidgetRef<W> {}
+impl<W: ?Sized> PartialEq for WidgetRef<W> {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }

core/src/widget/widgets.rs

@@ -32,7 +32,7 @@ impl Widgets {
 
     /// get_dyn but dynamic borrow checking of widgets
     /// lets you do recursive (tree) operations, like the painter does
-    pub fn get_dyn_dynamic(&self, id: WidgetId) -> WidgetWrapper<'_> {
+    pub(crate) fn get_dyn_dynamic(&self, id: WidgetId) -> WidgetWrapper<'_> {
         // SAFETY: must guarantee no other mutable references to this widget exist
         // done through the borrow variable
         #[allow(mutable_transmutes)]