shadowcat/iris
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove state generic from a lot of things

Browse Source
This commit is contained in:
shadow cat
2025-12-17 21:37:55 -05:00
parent 7e6369029f
commit 30bc55c78e
45 changed files with 740 additions and 856 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
core/src/widget/data.rs
View File

@@ -2,16 +2,16 @@ use std::any::TypeId;
use crate::{Widget, util::HashSet};
pub struct WidgetData<State> {
pub widget: Box<dyn Widget<State>>,
pub struct WidgetData {
pub widget: Box<dyn Widget>,
pub label: String,
pub event_mgrs: HashSet<TypeId>,
/// dynamic borrow checking
pub borrowed: bool,
}
impl<State> WidgetData<State> {
pub fn new<W: Widget<State>>(widget: W) -> Self {
impl WidgetData {
pub fn new<W: Widget>(widget: W) -> Self {
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;

82
core/src/widget/handle.rs
View File

@@ -1,12 +1,7 @@
use std::{
marker::{PhantomData, Unsize},
mem::MaybeUninit,
ops::CoerceUnsized,
sync::mpsc::Sender,
};
use std::{marker::Unsize, mem::MaybeUninit, ops::CoerceUnsized, sync::mpsc::Sender};
use crate::{
Ui, Widget,
Widget,
util::{RefCounter, SlotId},
};
@@ -17,42 +12,39 @@ 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<State, W: ?Sized = dyn Widget<State>> {
pub struct WidgetHandle<W: ?Sized = dyn Widget> {
pub(super) id: WidgetId,
counter: RefCounter,
send: Sender<WidgetId>,
ty: *const W,
state: PhantomData<State>,
}
/// A weak handle to a widget.
/// Will not keep it alive, but can still be used for indexing like WidgetHandle.
pub struct WidgetRef<State, W: ?Sized = dyn Widget<State>> {
pub struct WidgetRef<W: ?Sized = dyn Widget> {
pub(super) id: WidgetId,
#[allow(unused)]
ty: *const W,
state: PhantomData<State>,
}
pub struct WidgetHandles<State, W: ?Sized = dyn Widget<State>> {
pub h: WidgetHandle<State, W>,
pub r: WidgetRef<State, W>,
pub struct WidgetHandles<W: ?Sized = dyn Widget> {
pub h: WidgetHandle<W>,
pub r: WidgetRef<W>,
}
impl<State, W: Widget<State> + ?Sized + Unsize<dyn Widget<State>>> WidgetHandle<State, W> {
pub fn any(self) -> WidgetHandle<State, dyn Widget<State>> {
impl<W: Widget + ?Sized + Unsize<dyn Widget>> WidgetHandle<W> {
pub fn any(self) -> WidgetHandle<dyn Widget> {
self
}
}
impl<State, W: ?Sized> WidgetHandle<State, W> {
impl<W: ?Sized> WidgetHandle<W> {
pub(crate) fn new(id: WidgetId, send: Sender<WidgetId>) -> Self {
Self {
id,
counter: RefCounter::new(),
send,
ty: unsafe { MaybeUninit::zeroed().assume_init() },
state: PhantomData,
}
}
@@ -64,28 +56,24 @@ impl<State, W: ?Sized> WidgetHandle<State, W> {
self.counter.refs()
}
pub fn weak(&self) -> WidgetRef<State, W> {
pub fn weak(&self) -> WidgetRef<W> {
let Self { ty, id, .. } = *self;
WidgetRef {
ty,
id,
state: PhantomData,
}
WidgetRef { ty, id }
}
pub fn handles(self) -> WidgetHandles<State, W> {
pub fn handles(self) -> WidgetHandles<W> {
let r = self.weak();
WidgetHandles { h: self, r }
}
}
impl<State, W: ?Sized> WidgetRef<State, W> {
impl<W: ?Sized> WidgetRef<W> {
pub fn id(&self) -> WidgetId {
self.id
}
}
impl<State, W: ?Sized> Drop for WidgetHandle<State, W> {
impl<W: ?Sized> Drop for WidgetHandle<W> {
fn drop(&mut self) {
if self.counter.drop() {
let _ = self.send.send(self.id);
@@ -93,64 +81,52 @@ impl<State, W: ?Sized> Drop for WidgetHandle<State, W> {
}
}
pub trait WidgetIdFn<State, W: ?Sized = dyn Widget<State>>:
FnOnce(&mut Ui<State>) -> WidgetHandle<State, W>
{
}
impl<State, W: ?Sized, F: FnOnce(&mut Ui<State>) -> WidgetHandle<State, W>> WidgetIdFn<State, W>
for F
{
}
pub trait WidgetIdFn<State, W: ?Sized = dyn Widget>: FnOnce(&mut State) -> WidgetHandle<W> {}
impl<State, W: ?Sized, F: FnOnce(&mut State) -> WidgetHandle<W>> WidgetIdFn<State, W> for F {}
pub trait IdLike<State> {
type Widget: Widget<State> + ?Sized + 'static;
pub trait IdLike {
type Widget: Widget + ?Sized + 'static;
fn id(&self) -> WidgetId;
}
impl<State, W: Widget<State> + ?Sized> IdLike<State> for &WidgetHandle<State, W> {
impl<W: Widget + ?Sized> IdLike for &WidgetHandle<W> {
type Widget = W;
fn id(&self) -> WidgetId {
self.id
}
}
impl<State, W: Widget<State> + ?Sized> IdLike<State> for WidgetHandle<State, W> {
impl<W: Widget + ?Sized> IdLike for WidgetHandle<W> {
type Widget = W;
fn id(&self) -> WidgetId {
self.id
}
}
impl<State, W: Widget<State> + ?Sized> IdLike<State> for WidgetRef<State, W> {
impl<W: Widget + ?Sized> IdLike for WidgetRef<W> {
type Widget = W;
fn id(&self) -> WidgetId {
self.id
}
}
impl<State: 'static> IdLike<State> for WidgetId {
type Widget = dyn Widget<State>;
impl IdLike for WidgetId {
type Widget = dyn Widget;
fn id(&self) -> WidgetId {
*self
}
}
impl<T: ?Sized + Unsize<U>, U: ?Sized, State> CoerceUnsized<WidgetHandle<State, U>>
for WidgetHandle<State, T>
{
}
impl<State, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<WidgetRef<State, U>>
for WidgetRef<State, T>
{
}
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<State, W: ?Sized> Clone for WidgetRef<State, W> {
impl<W: ?Sized> Clone for WidgetRef<W> {
fn clone(&self) -> Self {
*self
}
}
impl<State, W: ?Sized> Copy for WidgetRef<State, W> {}
impl<State, W: ?Sized> PartialEq for WidgetRef<State, 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
}

36
core/src/widget/like.rs
View File

@@ -1,36 +1,38 @@
use crate::HasUi;
use super::*;
use std::marker::Unsize;
pub trait WidgetLike<State: 'static, Tag>: Sized {
type Widget: Widget<State> + ?Sized + Unsize<dyn Widget<State>> + 'static;
pub trait WidgetLike<State: 'static + HasUi, Tag>: Sized {
type Widget: Widget + ?Sized + Unsize<dyn Widget> + 'static;
fn add(self, ui: &mut Ui<State>) -> WidgetHandle<State, Self::Widget>;
fn add(self, state: &mut State) -> WidgetHandle<Self::Widget>;
fn with_id<W2>(
self,
f: impl FnOnce(&mut Ui<State>, WidgetHandle<State, Self::Widget>) -> WidgetHandle<State, W2>,
f: impl FnOnce(&mut State, WidgetHandle<Self::Widget>) -> WidgetHandle<W2>,
) -> impl WidgetIdFn<State, W2> {
move |ui| {
let id = self.add(ui);
f(ui, id)
move |state| {
let id = self.add(state);
f(state, id)
}
}
fn set_root(self, ui: &mut Ui<State>) {
ui.set_root(self);
fn set_root(self, state: &mut State) {
state.ui().root = Some(self.add(state));
}
fn handles(self, ui: &mut Ui<State>) -> WidgetHandles<State, Self::Widget> {
self.add(ui).handles()
fn handles(self, state: &mut State) -> WidgetHandles<Self::Widget> {
self.add(state).handles()
}
}
pub trait WidgetArrLike<State, const LEN: usize, Tag> {
fn ui(self, ui: &mut Ui<State>) -> WidgetArr<State, LEN>;
fn add(self, state: &mut State) -> WidgetArr<LEN>;
}
impl<State, const LEN: usize> WidgetArrLike<State, LEN, ArrTag> for WidgetArr<State, LEN> {
fn ui(self, _: &mut Ui<State>) -> WidgetArr<State, LEN> {
impl<State, const LEN: usize> WidgetArrLike<State, LEN, ArrTag> for WidgetArr<LEN> {
fn add(self, _: &mut State) -> WidgetArr<LEN> {
self
}
}
@@ -41,12 +43,12 @@ macro_rules! impl_widget_arr {
impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*);
};
($n:expr;$($W:ident)*;$($Tag:ident)*) => {
impl<State: 'static, $($W: WidgetLike<State, $Tag>,$Tag,)*> WidgetArrLike<State, $n, ($($Tag,)*)> for ($($W,)*) {
fn ui(self, ui: &mut Ui<State>) -> WidgetArr<State, $n> {
impl<State: 'static + HasUi, $($W: WidgetLike<State, $Tag>,$Tag,)*> WidgetArrLike<State, $n, ($($Tag,)*)> for ($($W,)*) {
fn add(self, state: &mut State) -> WidgetArr<$n> {
#[allow(non_snake_case)]
let ($($W,)*) = self;
WidgetArr::new(
[$($W.add(ui),)*],
[$($W.add(state),)*],
)
}
}

50
core/src/widget/mod.rs
View File

@@ -1,4 +1,4 @@
use crate::{Axis, AxisT, Len, Painter, SizeCtx, Ui};
use crate::{Axis, AxisT, Len, Painter, SizeCtx};
use std::any::Any;
mod data;
@@ -13,18 +13,18 @@ pub use like::*;
pub use tag::*;
pub use widgets::*;
pub trait Widget<State>: Any {
fn draw(&mut self, painter: &mut Painter<State>);
fn desired_width(&mut self, ctx: &mut SizeCtx<State>) -> Len;
fn desired_height(&mut self, ctx: &mut SizeCtx<State>) -> Len;
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;
}
pub trait WidgetAxisFns<State> {
fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx<State>) -> Len;
pub trait WidgetAxisFns {
fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len;
}
impl<State, W: Widget<State> + ?Sized> WidgetAxisFns<State> for W {
fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx<State>) -> Len {
impl<W: Widget + ?Sized> WidgetAxisFns for W {
fn desired_len<A: AxisT>(&mut self, ctx: &mut SizeCtx) -> Len {
match A::get() {
Axis::X => self.desired_width(ctx),
Axis::Y => self.desired_height(ctx),
@@ -32,17 +32,17 @@ impl<State, W: Widget<State> + ?Sized> WidgetAxisFns<State> for W {
}
}
impl<State> Widget<State> for () {
fn draw(&mut self, _: &mut Painter<State>) {}
fn desired_width(&mut self, _: &mut SizeCtx<State>) -> 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<State>) -> Len {
fn desired_height(&mut self, _: &mut SizeCtx) -> Len {
Len::ZERO
}
}
impl<State> dyn Widget<State> {
impl dyn Widget {
pub fn as_any(&self) -> &dyn Any {
self
}
@@ -55,31 +55,31 @@ impl<State> dyn Widget<State> {
/// 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<State, W: Widget<State> + ?Sized>: FnOnce(&mut Ui<State>) -> W {}
impl<State, W: Widget<State> + ?Sized, F: FnOnce(&mut Ui<State>) -> W> WidgetFn<State, W> for F {}
pub trait WidgetFn<State, W: Widget + ?Sized>: FnOnce(&mut State) -> W {}
impl<State, W: Widget + ?Sized, F: FnOnce(&mut State) -> W> WidgetFn<State, W> for F {}
pub struct WidgetArr<State, const LEN: usize> {
pub arr: [WidgetHandle<State>; LEN],
pub struct WidgetArr<const LEN: usize> {
pub arr: [WidgetHandle; LEN],
}
impl<State, const LEN: usize> WidgetArr<State, LEN> {
pub fn new(arr: [WidgetHandle<State>; LEN]) -> Self {
impl<const LEN: usize> WidgetArr<LEN> {
pub fn new(arr: [WidgetHandle; LEN]) -> Self {
Self { arr }
}
}
pub trait WidgetOption<State> {
fn get(self, ui: &mut Ui<State>) -> Option<WidgetHandle<State>>;
fn get(self, state: &mut State) -> Option<WidgetHandle>;
}
impl<State> WidgetOption<State> for () {
fn get(self, _: &mut Ui<State>) -> Option<WidgetHandle<State>> {
fn get(self, _: &mut State) -> Option<WidgetHandle> {
None
}
}
impl<State, F: FnOnce(&mut Ui<State>) -> Option<WidgetHandle<State>>> WidgetOption<State> for F {
fn get(self, ui: &mut Ui<State>) -> Option<WidgetHandle<State>> {
self(ui)
impl<State, F: FnOnce(&mut State) -> Option<WidgetHandle>> WidgetOption<State> for F {
fn get(self, state: &mut State) -> Option<WidgetHandle> {
self(state)
}
}

32
core/src/widget/tag.rs
View File

@@ -1,46 +1,46 @@
use std::marker::Unsize;
use crate::HasUi;
use super::*;
pub struct ArrTag;
pub struct WidgetTag;
impl<State: 'static, W: Widget<State>> WidgetLike<State, WidgetTag> for W {
impl<State: HasUi, W: Widget> WidgetLike<State, WidgetTag> for W {
type Widget = W;
fn add(self, ui: &mut Ui<State>) -> WidgetHandle<State, W> {
ui.add_widget(self)
fn add(self, state: &mut State) -> WidgetHandle<W> {
state.ui().add_widget(self)
}
}
pub struct FnTag;
impl<State: 'static, W: Widget<State>, F: FnOnce(&mut Ui<State>) -> W> WidgetLike<State, FnTag>
for F
{
impl<State: HasUi, W: Widget, F: FnOnce(&mut State) -> W> WidgetLike<State, FnTag> for F {
type Widget = W;
fn add(self, ui: &mut Ui<State>) -> WidgetHandle<State, W> {
self(ui).add(ui)
fn add(self, state: &mut State) -> WidgetHandle<W> {
self(state).add(state)
}
}
pub struct IdTag;
impl<State: 'static, W: ?Sized + Widget<State> + Unsize<dyn Widget<State>> + 'static>
WidgetLike<State, IdTag> for WidgetHandle<State, W>
impl<State: HasUi, W: ?Sized + Widget + Unsize<dyn Widget> + 'static> WidgetLike<State, IdTag>
for WidgetHandle<W>
{
type Widget = W;
fn add(self, _: &mut Ui<State>) -> WidgetHandle<State, W> {
fn add(self, _: &mut State) -> WidgetHandle<W> {
self
}
}
pub struct IdFnTag;
impl<
State: 'static,
W: ?Sized + Widget<State> + Unsize<dyn Widget<State>> + 'static,
F: FnOnce(&mut Ui<State>) -> WidgetHandle<State, W>,
State: HasUi,
W: ?Sized + Widget + Unsize<dyn Widget> + 'static,
F: FnOnce(&mut State) -> WidgetHandle<W>,
> WidgetLike<State, IdFnTag> for F
{
type Widget = W;
fn add(self, ui: &mut Ui<State>) -> WidgetHandle<State, W> {
self(ui)
fn add(self, state: &mut State) -> WidgetHandle<W> {
self(state)
}
}

30
core/src/widget/widgets.rs
View File

@@ -3,12 +3,12 @@ use crate::{
util::{DynBorrower, HashSet, SlotVec, forget_mut, to_mut},
};
pub struct Widgets<State> {
pub struct Widgets {
pub needs_redraw: HashSet<WidgetId>,
vec: SlotVec<WidgetData<State>>,
vec: SlotVec<WidgetData>,
}
impl<State> Default for Widgets<State> {
impl Default for Widgets {
fn default() -> Self {
Self {
needs_redraw: Default::default(),
@@ -17,23 +17,23 @@ impl<State> Default for Widgets<State> {
}
}
impl<State: 'static> Widgets<State> {
impl Widgets {
pub fn has_updates(&self) -> bool {
!self.needs_redraw.is_empty()
}
pub fn get_dyn(&self, id: WidgetId) -> Option<&dyn Widget<State>> {
pub fn get_dyn(&self, id: WidgetId) -> Option<&dyn Widget> {
Some(self.vec.get(id)?.widget.as_ref())
}
pub fn get_dyn_mut(&mut self, id: WidgetId) -> Option<&mut dyn Widget<State>> {
pub fn get_dyn_mut(&mut self, id: WidgetId) -> Option<&mut dyn Widget> {
self.needs_redraw.insert(id);
Some(self.vec.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(crate) fn get_dyn_dynamic<'a>(&self, id: WidgetId) -> WidgetWrapper<'a, State> {
pub(crate) fn get_dyn_dynamic<'a>(&self, id: WidgetId) -> WidgetWrapper<'a> {
// SAFETY: must guarantee no other mutable references to this widget exist
// done through the borrow variable
let data = unsafe { forget_mut(to_mut(self.vec.get(id).unwrap())) };
@@ -43,37 +43,37 @@ impl<State: 'static> Widgets<State> {
WidgetWrapper::new(data.widget.as_mut(), &mut data.borrowed)
}
pub fn get<I: IdLike<State>>(&self, id: &I) -> Option<&I::Widget>
pub fn get<I: IdLike>(&self, id: &I) -> Option<&I::Widget>
where
I::Widget: Sized,
{
self.get_dyn(id.id())?.as_any().downcast_ref()
}
pub fn get_mut<I: IdLike<State>>(&mut self, id: &I) -> Option<&mut I::Widget>
pub fn get_mut<I: IdLike>(&mut self, id: &I) -> Option<&mut I::Widget>
where
I::Widget: Sized,
{
self.get_dyn_mut(id.id())?.as_any_mut().downcast_mut()
}
pub fn add<W: Widget<State>>(&mut self, widget: W) -> WidgetId {
pub fn add<W: Widget>(&mut self, widget: W) -> WidgetId {
self.vec.add(WidgetData::new(widget))
}
pub fn data(&self, id: impl IdLike<State>) -> Option<&WidgetData<State>> {
pub fn data(&self, id: impl IdLike) -> Option<&WidgetData> {
self.vec.get(id.id())
}
pub fn label(&self, id: impl IdLike<State>) -> &String {
pub fn label(&self, id: impl IdLike) -> &String {
&self.data(id.id()).unwrap().label
}
pub fn data_mut(&mut self, id: impl IdLike<State>) -> Option<&mut WidgetData<State>> {
pub fn data_mut(&mut self, id: impl IdLike) -> Option<&mut WidgetData> {
self.vec.get_mut(id.id())
}
pub fn delete(&mut self, id: impl IdLike<State>) {
pub fn delete(&mut self, id: impl IdLike) {
self.vec.free(id.id());
// not sure if there's any point in this
// self.updates.remove(&id);
@@ -85,4 +85,4 @@ impl<State: 'static> Widgets<State> {
}
}
pub type WidgetWrapper<'a, State> = DynBorrower<'a, dyn Widget<State>>;
pub type WidgetWrapper<'a> = DynBorrower<'a, dyn Widget>;