move everything out of layout

core/src/widget/id.rs

@@ -0,0 +1,152 @@
+use std::{any::TypeId, marker::PhantomData, sync::mpsc::Sender};
+
+use crate::{
+    Ui, Widget,
+    util::{Id, RefCounter},
+};
+
+pub struct AnyWidget;
+
+/// 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.
+///
+/// TODO: ergonomic clones when they get put in rust-analyzer & don't cause ICEs?
+#[repr(C)]
+pub struct WidgetHandle<W = AnyWidget> {
+    pub(super) ty: TypeId,
+    pub(super) id: Id,
+    counter: RefCounter,
+    send: Sender<Id>,
+    _pd: PhantomData<W>,
+}
+
+#[repr(C)]
+pub struct WidgetView<W = AnyWidget> {
+    pub(super) ty: TypeId,
+    pub(super) id: Id,
+    counter: RefCounter,
+    send: Sender<Id>,
+    _pd: PhantomData<W>,
+}
+
+impl<W> PartialEq for WidgetHandle<W> {
+    fn eq(&self, other: &Self) -> bool {
+        self.ty == other.ty && self.id == other.id
+    }
+}
+
+impl<W> std::fmt::Debug for WidgetHandle<W> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.id.fmt(f)
+    }
+}
+
+impl<W> Clone for WidgetHandle<W> {
+    fn clone(&self) -> Self {
+        Self {
+            id: self.id,
+            ty: self.ty,
+            counter: self.counter.clone(),
+            send: self.send.clone(),
+            _pd: PhantomData,
+        }
+    }
+}
+
+impl<W> WidgetHandle<W> {
+    pub(crate) fn new(id: Id, ty: TypeId, send: Sender<Id>) -> Self {
+        Self {
+            ty,
+            id,
+            counter: RefCounter::new(),
+            send,
+            _pd: PhantomData,
+        }
+    }
+
+    pub fn any(self) -> WidgetHandle<AnyWidget> {
+        self.cast_type()
+    }
+
+    pub fn as_any(&self) -> &WidgetHandle<AnyWidget> {
+        // SAFETY: self is repr(C) and generic only used for phantom data
+        unsafe { std::mem::transmute(self) }
+    }
+
+    pub fn id(&self) -> Id {
+        self.id
+    }
+
+    pub(super) fn cast_type<W2>(self) -> WidgetHandle<W2> {
+        // SAFETY: self is repr(C) and generic only used for phantom data
+        unsafe { std::mem::transmute(self) }
+    }
+
+    pub fn refs(&self) -> u32 {
+        self.counter.refs()
+    }
+
+    pub fn weak(&self) -> WidgetView<W> {
+        let Self {
+            ty,
+            id,
+            ref counter,
+            ref send,
+            _pd,
+        } = *self;
+        WidgetView {
+            ty,
+            id,
+            counter: counter.quiet_clone(),
+            send: send.clone(),
+            _pd,
+        }
+    }
+}
+
+impl<W> Drop for WidgetHandle<W> {
+    fn drop(&mut self) {
+        if self.counter.drop() {
+            let _ = self.send.send(self.id);
+        }
+    }
+}
+
+pub trait WidgetIdFn<W>: FnOnce(&mut Ui) -> WidgetHandle<W> {}
+impl<W, F: FnOnce(&mut Ui) -> WidgetHandle<W>> WidgetIdFn<W> for F {}
+
+pub trait WidgetRet: FnOnce(&mut Ui) -> WidgetHandle<AnyWidget> {}
+impl<F: FnOnce(&mut Ui) -> WidgetHandle<AnyWidget>> WidgetRet for F {}
+
+pub trait WidgetIdLike<W> {
+    fn id(self, send: &Sender<Id>) -> WidgetHandle<W>;
+}
+
+impl<W> WidgetIdLike<W> for &WidgetHandle<W> {
+    fn id(self, _: &Sender<Id>) -> WidgetHandle<W> {
+        self.clone()
+    }
+}
+
+pub trait IdLike {
+    type Widget: Widget + 'static;
+    fn id(&self) -> Id;
+}
+
+impl<W: Widget> IdLike for WidgetHandle<W> {
+    type Widget = W;
+    fn id(&self) -> Id {
+        self.id
+    }
+}
+
+impl<W: Widget> IdLike for WidgetView<W> {
+    type Widget = W;
+    fn id(&self) -> Id {
+        self.id
+    }
+}

core/src/widget/like.rs

@@ -0,0 +1,78 @@
+use super::*;
+
+pub trait WidgetLike<Tag> {
+    type Widget: 'static;
+
+    fn add(self, ui: &mut Ui) -> WidgetHandle<Self::Widget>;
+
+    fn with_id<W2>(
+        self,
+        f: impl FnOnce(&mut Ui, WidgetHandle<Self::Widget>) -> WidgetHandle<W2>,
+    ) -> impl WidgetIdFn<W2>
+    where
+        Self: Sized,
+    {
+        move |ui| {
+            let id = self.add(ui);
+            f(ui, id)
+        }
+    }
+
+    fn set_root(self, ui: &mut Ui)
+    where
+        Self: Sized,
+    {
+        ui.set_root(self);
+    }
+}
+
+pub trait WidgetArrLike<const LEN: usize, Tag> {
+    type Ws;
+    fn ui(self, ui: &mut Ui) -> WidgetArr<LEN, Self::Ws>;
+}
+
+impl<const LEN: usize, Ws> WidgetArrLike<LEN, ArrTag> for WidgetArr<LEN, Ws> {
+    type Ws = Ws;
+    fn ui(self, _: &mut Ui) -> WidgetArr<LEN, Ws> {
+        self
+    }
+}
+
+impl<W: WidgetLike<WidgetTag>> WidgetArrLike<1, WidgetTag> for W {
+    type Ws = (W::Widget,);
+    fn ui(self, ui: &mut Ui) -> WidgetArr<1, (W::Widget,)> {
+        WidgetArr::new([self.add(ui).any()])
+    }
+}
+
+// I hate this language it's so bad why do I even use it
+macro_rules! impl_widget_arr {
+    ($n:expr;$($W:ident)*) => {
+        impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*);
+    };
+    ($n:expr;$($W:ident)*;$($Tag:ident)*) => {
+        impl<$($W: WidgetLike<$Tag>,$Tag,)*> WidgetArrLike<$n, ($($Tag,)*)> for ($($W,)*) {
+            type Ws = ($($W::Widget,)*);
+            fn ui(self, ui: &mut Ui) -> WidgetArr<$n, ($($W::Widget,)*)> {
+                #[allow(non_snake_case)]
+                let ($($W,)*) = self;
+                WidgetArr::new(
+                    [$($W.add(ui).cast_type(),)*],
+                )
+            }
+        }
+    };
+}
+
+impl_widget_arr!(1;A);
+impl_widget_arr!(2;A B);
+impl_widget_arr!(3;A B C);
+impl_widget_arr!(4;A B C D);
+impl_widget_arr!(5;A B C D E);
+impl_widget_arr!(6;A B C D E F);
+impl_widget_arr!(7;A B C D E F G);
+impl_widget_arr!(8;A B C D E F G H);
+impl_widget_arr!(9;A B C D E F G H I);
+impl_widget_arr!(10;A B C D E F G H I J);
+impl_widget_arr!(11;A B C D E F G H I J K);
+impl_widget_arr!(12;A B C D E F G H I J K L);

core/src/widget/mod.rs

@@ -0,0 +1,64 @@
+use crate::{Len, Painter, SizeCtx, Ui};
+use std::{any::Any, marker::PhantomData};
+
+mod id;
+mod like;
+mod tag;
+mod widgets;
+
+pub use id::*;
+pub use like::*;
+pub use tag::*;
+pub use widgets::*;
+
+pub trait Widget: Any {
+    fn draw(&mut self, painter: &mut Painter);
+    fn desired_width(&mut self, ctx: &mut SizeCtx) -> Len;
+    fn desired_height(&mut self, ctx: &mut SizeCtx) -> Len;
+}
+
+impl Widget for () {
+    fn draw(&mut self, _: &mut Painter) {}
+    fn desired_width(&mut self, _: &mut SizeCtx) -> Len {
+        Len::ZERO
+    }
+    fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
+        Len::ZERO
+    }
+}
+
+/// A function that returns a widget given a UI.
+/// Useful for defining trait functions on widgets that create a parent widget so that the children
+/// don't need to be IDs yet
+pub trait WidgetFn<W: Widget>: FnOnce(&mut Ui) -> W {}
+impl<W: Widget, F: FnOnce(&mut Ui) -> W> WidgetFn<W> for F {}
+
+pub struct WidgetArr<const LEN: usize, Ws> {
+    pub arr: [WidgetHandle; LEN],
+    _pd: PhantomData<Ws>,
+}
+
+impl<const LEN: usize, Ws> WidgetArr<LEN, Ws> {
+    pub fn new(arr: [WidgetHandle; LEN]) -> Self {
+        Self {
+            arr,
+            _pd: PhantomData,
+        }
+    }
+}
+
+pub trait WidgetOption {
+    fn get(self, ui: &mut Ui) -> Option<WidgetHandle>;
+}
+
+impl WidgetOption for () {
+    fn get(self, _: &mut Ui) -> Option<WidgetHandle> {
+        None
+    }
+}
+
+impl<F: FnOnce(&mut Ui) -> Option<WidgetHandle>> WidgetOption for F {
+    fn get(self, ui: &mut Ui) -> Option<WidgetHandle> {
+        self(ui)
+    }
+}

core/src/widget/tag.rs

@@ -0,0 +1,36 @@
+use super::*;
+
+pub struct ArrTag;
+
+pub struct WidgetTag;
+impl<W: Widget> WidgetLike<WidgetTag> for W {
+    type Widget = W;
+    fn add(self, ui: &mut Ui) -> WidgetHandle<W> {
+        ui.add_widget(self)
+    }
+}
+
+pub struct FnTag;
+impl<W: Widget, F: FnOnce(&mut Ui) -> W> WidgetLike<FnTag> for F {
+    type Widget = W;
+    fn add(self, ui: &mut Ui) -> WidgetHandle<W> {
+        self(ui).add(ui)
+    }
+}
+
+pub struct IdTag;
+impl<W: 'static> WidgetLike<IdTag> for WidgetHandle<W> {
+    type Widget = W;
+    fn add(self, _: &mut Ui) -> WidgetHandle<W> {
+        self
+    }
+}
+
+pub struct IdFnTag;
+impl<W: 'static, F: FnOnce(&mut Ui) -> WidgetHandle<W>> WidgetLike<IdFnTag> for F {
+    type Widget = W;
+    fn add(self, ui: &mut Ui) -> WidgetHandle<W> {
+        self(ui)
+    }
+}
+

core/src/widget/widgets.rs

@@ -0,0 +1,106 @@
+use crate::{
+    IdLike, Widget,
+    util::{DynBorrower, HashMap, HashSet, Id, IdTracker},
+};
+
+#[derive(Default)]
+pub struct Widgets {
+    pub updates: HashSet<Id>,
+    ids: IdTracker,
+    map: HashMap<Id, WidgetData>,
+}
+
+pub struct WidgetData {
+    pub widget: Box<dyn Widget>,
+    pub label: String,
+    /// dynamic borrow checking
+    pub borrowed: bool,
+}
+
+impl Widgets {
+    pub fn has_updates(&self) -> bool {
+        !self.updates.is_empty()
+    }
+
+    pub fn get_dyn(&self, id: Id) -> Option<&dyn Widget> {
+        Some(self.map.get(&id)?.widget.as_ref())
+    }
+
+    pub fn get_dyn_mut(&mut self, id: Id) -> Option<&mut dyn Widget> {
+        self.updates.insert(id);
+        Some(self.map.get_mut(&id)?.widget.as_mut())
+    }
+
+    /// 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: Id) -> WidgetWrapper<'_> {
+        // SAFETY: must guarantee no other mutable references to this widget exist
+        // done through the borrow variable
+        #[allow(mutable_transmutes)]
+        let data = unsafe {
+            std::mem::transmute::<&WidgetData, &mut WidgetData>(self.map.get(&id).unwrap())
+        };
+        if data.borrowed {
+            panic!("tried to mutably borrow the same widget twice");
+        }
+        WidgetWrapper::new(data.widget.as_mut(), &mut data.borrowed)
+    }
+
+    pub fn get<I: IdLike>(&self, id: &I) -> Option<&I::Widget> {
+        self.get_dyn(id.id())?.as_any().downcast_ref()
+    }
+
+    pub fn get_mut<I: IdLike>(&mut self, id: &I) -> Option<&mut I::Widget> {
+        self.get_dyn_mut(id.id())?.as_any_mut().downcast_mut()
+    }
+
+    pub fn insert<W: Widget>(&mut self, id: Id, widget: W) {
+        let mut label = std::any::type_name::<W>().to_string();
+        if let (Some(first), Some(last)) = (label.find(":"), label.rfind(":")) {
+            label = label.split_at(first).0.to_string() + "::" + label.split_at(last + 1).1;
+        }
+        self.insert_any(id, Box::new(widget), label);
+    }
+
+    pub fn data(&self, id: &Id) -> Option<&WidgetData> {
+        self.map.get(id)
+    }
+
+    pub fn label(&self, id: &Id) -> &String {
+        &self.data(id).unwrap().label
+    }
+
+    pub fn data_mut(&mut self, id: &Id) -> Option<&mut WidgetData> {
+        self.map.get_mut(id)
+    }
+
+    pub fn insert_any(&mut self, id: Id, widget: Box<dyn Widget>, label: String) {
+        self.map.insert(
+            id,
+            WidgetData {
+                widget,
+                label,
+                borrowed: false,
+            },
+        );
+    }
+
+    pub fn delete(&mut self, id: Id) {
+        self.map.remove(&id);
+        self.ids.free(id);
+    }
+
+    pub fn reserve(&mut self) -> Id {
+        self.ids.next()
+    }
+
+    pub fn len(&self) -> usize {
+        self.map.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.map.is_empty()
+    }
+}
+
+pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>;