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

separate state from rsc

Browse Source
This commit is contained in:
shadow cat
2026-01-01 22:18:08 -05:00
parent 462c0e6416
commit 5da1e9e767
22 changed files with 373 additions and 492 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
core/src/attr.rs
View File

@@ -1,24 +1,22 @@
use crate::{HasUi, StateLike, WidgetIdFn, WidgetLike, WidgetRef};
use crate::{HasUi, WidgetIdFn, WidgetLike, WidgetRef};
pub trait WidgetAttr<State, W: ?Sized> {
pub trait WidgetAttr<Rsc, W: ?Sized> {
type Input;
fn run(state: &mut State, id: WidgetRef<W>, input: Self::Input);
fn run(rsc: &mut Rsc, id: WidgetRef<W>, input: Self::Input);
}
pub trait Attrable<State, W: ?Sized, Tag> {
fn attr<A: WidgetAttr<State, W>>(self, input: A::Input) -> impl WidgetIdFn<State, W>;
pub trait Attrable<Rsc, W: ?Sized, Tag> {
fn attr<A: WidgetAttr<Rsc, W>>(self, input: A::Input) -> impl WidgetIdFn<Rsc, W>;
}
impl<State: HasUi + StateLike<State>, WL: WidgetLike<State, Tag>, Tag>
Attrable<State, WL::Widget, Tag> for WL
{
fn attr<A: WidgetAttr<State, WL::Widget>>(
impl<Rsc: HasUi, WL: WidgetLike<Rsc, Tag>, Tag> Attrable<Rsc, WL::Widget, Tag> for WL {
fn attr<A: WidgetAttr<Rsc, WL::Widget>>(
self,
input: A::Input,
) -> impl WidgetIdFn<State, WL::Widget> {
|state| {
let id = self.add(state);
A::run(state, id, input);
) -> impl WidgetIdFn<Rsc, WL::Widget> {
|rsc| {
let id = self.add(rsc);
A::run(rsc, id, input);
id
}
}

114
core/src/event/ctx.rs
View File

@@ -1,116 +1,18 @@
use crate::{HasEvents, HasState, HasUi, StateLike, Ui, Widget, WidgetRef};
use std::ops::{Deref, DerefMut};
use crate::{HasEvents, HasUi, Widget, WidgetRef};
pub struct EventCtx<'a, State, Data> {
pub state: &'a mut State,
pub struct EventCtx<'a, Rsc: HasEvents, Data> {
pub state: &'a mut Rsc::State,
pub data: &'a mut Data,
}
pub struct EventIdCtx<'a, State, Data, W: ?Sized> {
pub struct EventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> {
pub widget: WidgetRef<W>,
pub state: &'a mut State,
pub state: &'a mut Rsc::State,
pub data: &'a mut Data,
}
impl<State: HasUi, Data, W: ?Sized> Deref for EventIdCtx<'_, State, Data, W> {
type Target = State;
fn deref(&self) -> &Self::Target {
self.state
impl<Rsc: HasEvents + HasUi, Data, W: Widget> EventIdCtx<'_, Rsc, Data, W> {
pub fn widget<'a>(&self, rsc: &'a mut Rsc) -> &'a mut W {
&mut rsc.ui_mut()[self.widget]
}
}
impl<State: HasUi, Data, W: ?Sized> DerefMut for EventIdCtx<'_, State, Data, W> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.state
}
}
impl<State: HasUi, Data, W: Widget> EventIdCtx<'_, State, Data, W> {
pub fn widget(&mut self) -> &mut W {
&mut self.state.get_mut()[self.widget]
}
}
impl<State: HasUi, Data, W: Widget> HasUi for EventIdCtx<'_, State, Data, W> {
fn get(&self) -> &Ui {
self.state.ui()
}
fn get_mut(&mut self) -> &mut Ui {
self.state.ui_mut()
}
}
impl<State: HasUi, Data, W: Widget> HasState for EventIdCtx<'_, State, Data, W> {
type State = State;
}
impl<State: HasEvents<State = State>, Data, W: Widget> HasEvents
for EventIdCtx<'_, State, Data, W>
{
fn get(&self) -> &super::EventManager<Self::State> {
self.state.events()
}
fn get_mut(&mut self) -> &mut super::EventManager<Self::State> {
self.state.events_mut()
}
}
impl<State, Data, W: Widget> StateLike<State> for EventIdCtx<'_, State, Data, W> {
fn as_state(&mut self) -> &mut State {
self.state
}
}
// fn test() {
// use crate::*;
// struct ClientRsc;
// impl<State, Data> HasUi for EventCtx<'_, State, Data> {
// fn get(&self) -> &Ui {
// todo!()
// }
//
// fn get_mut(&mut self) -> &mut Ui {
// todo!()
// }
// }
// fn on(_: impl for<'a> EventFn<ClientRsc, &'a mut i32>) {}
//
// pub trait WidgetLike<State: HasUi, Tag>: Sized {
// type Widget: Widget + ?Sized + std::marker::Unsize<dyn Widget>;
//
// fn add(self, state: &mut State) -> WidgetHandle<Self::Widget>;
//
// fn with_id<W2>(
// self,
// f: impl FnOnce(&mut State, WidgetHandle<Self::Widget>) -> WidgetHandle<W2>,
// ) -> impl WidgetIdFn<State, W2> {
// move |state| {
// let id = self.add(state);
// f(state, id)
// }
// }
//
// fn set_root(self, state: &mut State) {
// state.get_mut().root = Some(self.add(state));
// }
//
// fn handles(self, state: &mut State) -> WidgetHandles<Self::Widget> {
// self.add(state).handles()
// }
// }
//
// pub struct WidgetTag;
// impl<State: HasUi, W: Widget> WidgetLike<State, WidgetTag> for W {
// type Widget = W;
// fn add(self, state: &mut State) -> WidgetHandle<W> {
// state.get_mut().add_widget(self)
// }
// }
//
// on(move |ctx| {
// ().add(ctx);
// });
// }

53
core/src/event/manager.rs
View File

@@ -1,16 +1,16 @@
use crate::{
ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, IdLike, LayerId, Widget,
WidgetEventFn, WidgetId, WidgetRef,
ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, HasEvents, IdLike, LayerId,
Widget, WidgetEventFn, WidgetId, WidgetRef,
util::{HashMap, HashSet, TypeMap},
};
use std::{any::TypeId, rc::Rc};
pub struct EventManager<State> {
pub struct EventManager<Rsc> {
widget_to_types: HashMap<WidgetId, HashSet<TypeId>>,
types: TypeMap<dyn EventManagerLike<State>>,
types: TypeMap<dyn EventManagerLike<Rsc>>,
}
impl<State> Default for EventManager<State> {
impl<Rsc> Default for EventManager<Rsc> {
fn default() -> Self {
Self {
widget_to_types: Default::default(),
@@ -19,8 +19,8 @@ impl<State> Default for EventManager<State> {
}
}
impl<State: 'static> EventManager<State> {
pub fn get_type<E: EventLike>(&mut self) -> &mut TypeEventManager<State, E::Event> {
impl<Rsc: HasEvents + 'static> EventManager<Rsc> {
pub fn get_type<E: EventLike>(&mut self) -> &mut TypeEventManager<Rsc, E::Event> {
self.types.type_or_default()
}
@@ -28,7 +28,7 @@ impl<State: 'static> EventManager<State> {
&mut self,
id: WidgetRef<W>,
event: E,
f: impl for<'a> WidgetEventFn<State, <E::Event as Event>::Data<'a>, W>,
f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, W>,
) {
self.get_type::<E>().register(id, event, f);
self.widget_to_types
@@ -38,7 +38,7 @@ impl<State: 'static> EventManager<State> {
}
pub fn type_key<E: EventLike>() -> TypeId {
TypeId::of::<TypeEventManager<State, E::Event>>()
TypeId::of::<TypeEventManager<Rsc, E::Event>>()
}
}
@@ -48,7 +48,7 @@ pub trait EventsLike {
fn undraw(&mut self, active: &ActiveData);
}
impl<State: 'static> EventsLike for EventManager<State> {
impl<Rsc: HasEvents + 'static> EventsLike for EventManager<Rsc> {
fn remove(&mut self, id: WidgetId) {
for t in self.widget_to_types.get(&id).into_flat_iter() {
self.types.get_mut(t).unwrap().remove(id);
@@ -74,14 +74,14 @@ pub trait EventManagerLike<State> {
fn undraw(&mut self, data: &ActiveData);
}
type EventData<State, E> = (E, Rc<dyn for<'a> EventFn<State, <E as Event>::Data<'a>>>);
pub struct TypeEventManager<State, E: Event> {
type EventData<Rsc, E> = (E, Rc<dyn for<'a> EventFn<Rsc, <E as Event>::Data<'a>>>);
pub struct TypeEventManager<Rsc: HasEvents, E: Event> {
// TODO: reduce visiblity!!
pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
map: HashMap<WidgetId, Vec<EventData<State, E>>>,
map: HashMap<WidgetId, Vec<EventData<Rsc, E>>>,
}
impl<State, E: Event> EventManagerLike<State> for TypeEventManager<State, E> {
impl<Rsc: HasEvents, E: Event> EventManagerLike<Rsc> for TypeEventManager<Rsc, E> {
fn remove(&mut self, id: WidgetId) {
self.map.remove(&id);
for layer in self.active.values_mut() {
@@ -102,7 +102,7 @@ impl<State, E: Event> EventManagerLike<State> for TypeEventManager<State, E> {
}
}
impl<State, E: Event> Default for TypeEventManager<State, E> {
impl<Rsc: HasEvents, E: Event> Default for TypeEventManager<Rsc, E> {
fn default() -> Self {
Self {
active: Default::default(),
@@ -111,23 +111,23 @@ impl<State, E: Event> Default for TypeEventManager<State, E> {
}
}
impl<State: 'static, E: Event> TypeEventManager<State, E> {
impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
fn register<W: Widget + ?Sized>(
&mut self,
widget: WidgetRef<W>,
event: impl EventLike<Event = E>,
f: impl for<'a> WidgetEventFn<State, E::Data<'a>, W>,
f: impl for<'a> WidgetEventFn<Rsc, E::Data<'a>, W>,
) {
let event = event.into_event();
self.map.entry(widget.id()).or_default().push((
event,
Rc::new(move |ctx| {
Rc::new(move |ctx, rsc| {
let mut test = EventIdCtx {
widget,
state: ctx.state,
data: ctx.data,
};
f(&mut test);
f(&mut test, rsc);
}),
));
}
@@ -135,15 +135,18 @@ impl<State: 'static, E: Event> TypeEventManager<State, E> {
pub fn run_fn<'a>(
&mut self,
id: impl IdLike,
) -> impl for<'b> FnOnce(EventCtx<'_, State, E::Data<'b>>) + 'a {
) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) + 'a {
let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
move |ctx| {
move |ctx, rsc| {
for (e, f) in fs {
if e.should_run(ctx.data) {
f(&mut EventCtx {
state: ctx.state,
data: ctx.data,
})
f(
&mut EventCtx {
state: ctx.state,
data: ctx.data,
},
rsc,
)
}
}
}

15
core/src/event/mod.rs
View File

@@ -28,14 +28,17 @@ impl<E: Event> EventLike for E {
}
}
pub trait EventFn<State, Data>: Fn(&mut EventCtx<State, Data>) + 'static {}
impl<State, F: Fn(&mut EventCtx<State, Data>) + 'static, Data> EventFn<State, Data> for F {}
pub trait EventFn<Rsc: HasEvents, Data>: Fn(&mut EventCtx<Rsc, Data>, &mut Rsc) + 'static {}
impl<Rsc: HasEvents, F: Fn(&mut EventCtx<Rsc, Data>, &mut Rsc) + 'static, Data> EventFn<Rsc, Data>
for F
{
}
pub trait WidgetEventFn<State, Data, W: ?Sized>:
Fn(&mut EventIdCtx<State, Data, W>) + 'static
pub trait WidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
Fn(&mut EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
{
}
impl<State, F: Fn(&mut EventIdCtx<State, Data, W>) + 'static, Data, W: ?Sized>
WidgetEventFn<State, Data, W> for F
impl<Rsc: HasEvents, F: Fn(&mut EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static, Data, W: ?Sized>
WidgetEventFn<Rsc, Data, W> for F
{
}

29
core/src/event/rsc.rs
View File

@@ -2,40 +2,31 @@ use crate::{
Event, EventCtx, EventLike, EventManager, HasUi, IdLike, Widget, WidgetEventFn, WidgetRef,
};
pub trait HasState {
type State: HasUi;
}
pub trait HasEvents: Sized + HasUi + 'static {
type State;
pub trait HasEvents: Sized + HasState + HasUi {
fn get(&self) -> &EventManager<Self::State>;
fn get_mut(&mut self) -> &mut EventManager<Self::State>;
fn events(&self) -> &EventManager<Self::State> {
HasEvents::get(self)
}
fn events_mut(&mut self) -> &mut EventManager<Self::State> {
HasEvents::get_mut(self)
}
fn events(&self) -> &EventManager<Self>;
fn events_mut(&mut self) -> &mut EventManager<Self>;
fn register_event<W: Widget + ?Sized, E: EventLike>(
&mut self,
id: WidgetRef<W>,
event: E,
f: impl for<'a> WidgetEventFn<Self::State, <E::Event as Event>::Data<'a>, W>,
) where
Self::State: 'static,
{
f: impl for<'a> WidgetEventFn<Self, <E::Event as Event>::Data<'a>, W>,
) {
self.events_mut().register(id, event, f);
}
}
pub trait RunEvents: HasEvents + HasState<State = Self> + 'static {
pub trait RunEvents: HasEvents + 'static {
fn run_event<E: EventLike>(
&mut self,
id: impl IdLike,
data: &mut <E::Event as Event>::Data<'_>,
state: &mut Self::State,
) {
let f = self.events_mut().get_type::<E>().run_fn(id);
f(EventCtx { state: self, data })
f(EventCtx { state, data }, self)
}
}
impl<T: HasEvents + HasState<State = Self> + 'static> RunEvents for T {}
impl<T: HasEvents + 'static> RunEvents for T {}

14
core/src/ui/mod.rs
View File

@@ -42,22 +42,16 @@ pub struct Ui {
}
pub trait HasUi: Sized {
fn get(&self) -> &Ui;
fn get_mut(&mut self) -> &mut Ui;
fn ui(&self) -> &Ui {
self.get()
}
fn ui_mut(&mut self) -> &mut Ui {
self.get_mut()
}
fn ui(&self) -> &Ui;
fn ui_mut(&mut self) -> &mut Ui;
}
impl HasUi for Ui {
fn get(&self) -> &Ui {
fn ui(&self) -> &Ui {
self
}
fn get_mut(&mut self) -> &mut Ui {
fn ui_mut(&mut self) -> &mut Ui {
self
}
}

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

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

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

@@ -3,56 +3,49 @@ use crate::HasUi;
use std::marker::Unsize;
pub struct WidgetTag;
impl<State: HasUi + StateLike<State>, W: Widget> WidgetLike<State, WidgetTag> for W {
impl<Rsc: HasUi, W: Widget> WidgetLike<Rsc, WidgetTag> for W {
type Widget = W;
fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
state.as_state().get_mut().widgets.add_weak(self)
fn add(self, state: &mut Rsc) -> WidgetRef<W> {
state.ui_mut().widgets.add_weak(self)
}
}
pub struct FnTag;
impl<State: HasUi + StateLike<State>, W: Widget, F: FnOnce(&mut State) -> W>
WidgetLike<State, FnTag> for F
{
impl<Rsc: HasUi, W: Widget, F: FnOnce(&mut Rsc) -> W> WidgetLike<Rsc, FnTag> for F {
type Widget = W;
fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
self(state.as_state()).add(state)
fn add(self, state: &mut Rsc) -> WidgetRef<W> {
self(state).add(state)
}
}
pub trait WidgetFnTrait<State> {
pub trait WidgetFnTrait<Rsc> {
type Widget: Widget;
fn run(self, state: &mut State) -> Self::Widget;
fn run(self, rsc: &mut Rsc) -> Self::Widget;
}
pub struct FnTraitTag;
impl<State: HasUi + StateLike<State>, T: WidgetFnTrait<State>> WidgetLike<State, FnTraitTag> for T {
impl<Rsc: HasUi, T: WidgetFnTrait<Rsc>> WidgetLike<Rsc, FnTraitTag> for T {
type Widget = T::Widget;
#[track_caller]
fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<T::Widget> {
self.run(state.as_state()).add(state)
fn add(self, state: &mut Rsc) -> WidgetRef<T::Widget> {
self.run(state).add(state)
}
}
pub struct IdTag;
impl<State: HasUi + StateLike<State>, W: ?Sized + Widget + Unsize<dyn Widget>>
WidgetLike<State, IdTag> for WidgetRef<W>
{
impl<Rsc: HasUi, W: ?Sized + Widget + Unsize<dyn Widget>> WidgetLike<Rsc, IdTag> for WidgetRef<W> {
type Widget = W;
fn add(self, _: &mut impl StateLike<State>) -> WidgetRef<W> {
fn add(self, _: &mut Rsc) -> WidgetRef<W> {
self
}
}
pub struct IdFnTag;
impl<
State: HasUi + StateLike<State>,
W: ?Sized + Widget + Unsize<dyn Widget>,
F: FnOnce(&mut State) -> WidgetRef<W>,
> WidgetLike<State, IdFnTag> for F
impl<Rsc: HasUi, W: ?Sized + Widget + Unsize<dyn Widget>, F: FnOnce(&mut Rsc) -> WidgetRef<W>>
WidgetLike<Rsc, IdFnTag> for F
{
type Widget = W;
fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
self(state.as_state())
fn add(self, state: &mut Rsc) -> WidgetRef<W> {
self(state)
}
}