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

remove typed stuff / just specify rsc if needed

Browse Source
This commit is contained in:
shadow cat
2026-01-03 18:06:05 -05:00
parent 59901b6580
commit f2ac6f195f
14 changed files with 126 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -2,13 +2,13 @@ use crate::{HasEvents, HasUi, Widget, WidgetRef};
pub struct EventCtx<'a, Rsc: HasEvents, Data> {
pub state: &'a mut Rsc::State,
pub data: &'a mut Data,
pub data: Data,
}
pub struct EventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> {
pub widget: WidgetRef<W>,
pub state: &'a mut Rsc::State,
pub data: &'a mut Data,
pub data: Data,
}
impl<Rsc: HasEvents + HasUi, Data, W: Widget> EventIdCtx<'_, Rsc, Data, W> {

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

@@ -28,7 +28,7 @@ impl<Rsc: HasEvents + 'static> EventManager<Rsc> {
&mut self,
id: WidgetRef<W>,
event: E,
f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, W>,
f: impl WidgetEventFn<Rsc, <E::Event as Event>::Data, W>,
) {
self.get_type::<E>().register(id, event, f);
self.widget_to_types
@@ -74,7 +74,7 @@ pub trait EventManagerLike<State> {
fn undraw(&mut self, data: &ActiveData);
}
type EventData<Rsc, E> = (E, Rc<dyn for<'a> EventFn<Rsc, <E as Event>::Data<'a>>>);
type EventData<Rsc, E> = (E, Rc<dyn EventFn<Rsc, <E as Event>::Data>>);
pub struct TypeEventManager<Rsc: HasEvents, E: Event> {
// TODO: reduce visiblity!!
pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
@@ -116,18 +116,20 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
&mut self,
widget: WidgetRef<W>,
event: impl EventLike<Event = E>,
f: impl for<'a> WidgetEventFn<Rsc, E::Data<'a>, W>,
f: impl WidgetEventFn<Rsc, E::Data, W>,
) {
let event = event.into_event();
self.map.entry(widget.id()).or_default().push((
event,
Rc::new(move |ctx, rsc| {
let mut test = EventIdCtx {
f(
EventIdCtx {
widget,
state: ctx.state,
data: ctx.data,
};
f(&mut test, rsc);
},
rsc,
);
}),
));
}
@@ -135,15 +137,15 @@ impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
pub fn run_fn<'a>(
&mut self,
id: impl IdLike,
) -> impl for<'b> FnOnce(EventCtx<'_, Rsc, E::Data<'b>>, &mut Rsc) + 'a {
) -> impl FnOnce(EventCtx<'_, Rsc, E::Data>, &mut Rsc) + 'a {
let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
move |ctx, rsc| {
for (e, f) in fs {
if e.should_run(ctx.data) {
if let Some(data) = e.should_run(&ctx.data) {
f(
&mut EventCtx {
EventCtx {
state: ctx.state,
data: ctx.data,
data,
},
rsc,
)

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

@@ -7,11 +7,11 @@ pub use manager::*;
pub use rsc::*;
pub trait Event: Sized + 'static + Clone {
type Data<'a> = ();
type Data: Clone = ();
type State: Default = ();
#[allow(unused_variables)]
fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
true
fn should_run(&self, data: &Self::Data) -> Option<Self::Data> {
Some(data.clone())
}
}
@@ -28,17 +28,17 @@ impl<E: Event> EventLike for E {
}
}
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>
pub trait EventFn<Rsc: HasEvents, Data>: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static {}
impl<Rsc: HasEvents, F: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static, Data> EventFn<Rsc, Data>
for F
{
}
pub trait WidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
Fn(&mut EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
{
}
impl<Rsc: HasEvents, F: Fn(&mut EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static, Data, W: ?Sized>
impl<Rsc: HasEvents, F: Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static, Data, W: ?Sized>
WidgetEventFn<Rsc, Data, W> for F
{
}

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

@@ -14,7 +14,7 @@ pub trait HasEvents: Sized + HasUi + HasState {
&mut self,
id: WidgetRef<W>,
event: E,
f: impl for<'a> WidgetEventFn<Self, <E::Event as Event>::Data<'a>, W>,
f: impl WidgetEventFn<Self, <E::Event as Event>::Data, W>,
) {
self.events_mut().register(id, event, f);
}
@@ -24,7 +24,7 @@ pub trait RunEvents: HasEvents {
fn run_event<E: EventLike>(
&mut self,
id: impl IdLike,
data: &mut <E::Event as Event>::Data<'_>,
data: <E::Event as Event>::Data,
state: &mut Self::State,
) {
let f = self.events_mut().get_type::<E>().run_fn(id);

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

@@ -171,3 +171,4 @@ fn null_ptr<W: ?Sized>() -> *const W {
}
unsafe impl<W: ?Sized> Send for WidgetRef<W> {}
unsafe impl<W: ?Sized> Sync for WidgetRef<W> {}

8
examples/tabs/main.rs
View File

@@ -2,7 +2,8 @@ use cosmic_text::Family;
use std::{cell::RefCell, rc::Rc};
use winit::event::WindowEvent;
iris::state_prelude!(DefaultRsc<Client>);
use iris::prelude::*;
type ClientRsc = DefaultRsc<Client>;
fn main() {
DefaultApp::<Client>::run();
@@ -119,6 +120,7 @@ impl DefaultAppState for Client {
texts(rsc).push(msg_box);
})
.add(rsc);
let text_edit_scroll = (
msg_area.height(rest(1)),
(
@@ -126,8 +128,8 @@ impl DefaultAppState for Client {
(
add_text.width(rest(1)),
Rect::new(Color::GREEN)
.on(CursorSense::click(), move |ctx, rsc| {
rsc.run_event::<Submit>(add_text, &mut (), ctx.state);
.on(CursorSense::click(), move |ctx, rsc: &mut ClientRsc| {
rsc.run_event::<Submit>(add_text, (), ctx.state);
})
.sized((40, 40)),
)

9
examples/task.rs
View File

@@ -1,7 +1,6 @@
use iris::prelude::*;
use std::time::Duration;
iris::state_prelude!(DefaultRsc<State>);
fn main() {
DefaultApp::<State>::run();
}
@@ -14,10 +13,9 @@ struct State {
impl DefaultAppState for State {
fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self::Event>) -> Self {
let rect = rect(Color::RED).add(rsc);
rect.on(CursorSense::click(), move |_, rsc| {
rsc.tasks.spawn(async move |ctx| {
rect.task_on(CursorSense::click(), async move |mut ctx| {
tokio::time::sleep(Duration::from_secs(1)).await;
ctx.update(move |_, rsc| {
ctx.task.update(move |_, rsc| {
let rect = rect(rsc);
if rect.color == Color::RED {
rect.color = Color::GREEN;
@@ -25,7 +23,6 @@ impl DefaultAppState for State {
rect.color = Color::RED;
}
});
});
})
.set_root(rsc);
Self { ui_state }

14
src/default/mod.rs
View File

@@ -127,6 +127,12 @@ impl<State: 'static> HasEvents for DefaultRsc<State> {
}
}
impl<State: 'static> HasTasks for DefaultRsc<State> {
fn tasks_mut(&mut self) -> &mut Tasks<Self> {
&mut self.tasks
}
}
pub struct DefaultApp<State: DefaultAppState> {
rsc: DefaultRsc<State>,
state: State,
@@ -169,7 +175,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
if input_changed {
let window_size = ui_state.window_size();
self.rsc
.run_sensors(&mut self.state, &cursor_state, window_size);
.run_sensors(&mut self.state, cursor_state, window_size);
}
let ui = &mut self.rsc.ui;
let ui_state = self.state.default_state_mut();
@@ -200,13 +206,13 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
ui_state.window.set_ime_allowed(false);
}
TextInputResult::Submit => {
self.rsc.run_event::<Submit>(sel, &mut (), &mut self.state);
self.rsc.run_event::<Submit>(sel, (), &mut self.state);
}
TextInputResult::Paste => {
if let Ok(t) = ui_state.clipboard.get_text() {
text.insert(&t);
}
self.rsc.run_event::<Edited>(sel, &mut (), &mut self.state);
self.rsc.run_event::<Edited>(sel, (), &mut self.state);
}
TextInputResult::Copy(text) => {
if let Err(err) = ui_state.clipboard.set_text(text) {
@@ -214,7 +220,7 @@ impl<State: DefaultAppState> AppState for DefaultApp<State> {
}
}
TextInputResult::Used => {
self.rsc.run_event::<Edited>(sel, &mut (), &mut self.state);
self.rsc.run_event::<Edited>(sel, (), &mut self.state);
}
TextInputResult::Unused => {}
}

26
src/default/sense.rs
View File

@@ -26,14 +26,15 @@ pub enum CursorSense {
pub struct CursorSenses(Vec<CursorSense>);
impl Event for CursorSenses {
type Data<'a> = CursorData<'a>;
type Data = CursorData;
type State = SensorState;
fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
if let Some(sense) = should_run(self, data.cursor, data.hover) {
fn should_run(&self, data: &Self::Data) -> Option<Self::Data> {
if let Some(sense) = should_run(self, &data.cursor, data.hover) {
let mut data = data.clone();
data.sense = sense;
true
Some(data)
} else {
false
None
}
}
}
@@ -127,23 +128,24 @@ pub struct SensorState {
pub hover: ActivationState,
}
pub struct CursorData<'a> {
#[derive(Clone)]
pub struct CursorData {
/// where this widget was hit
pub pos: Vec2,
pub size: Vec2,
pub scroll_delta: Vec2,
pub hover: ActivationState,
pub cursor: &'a CursorState,
pub cursor: CursorState,
/// the first sense that triggered this
pub sense: CursorSense,
}
pub trait SensorUi<Rsc: HasEvents> {
fn run_sensors(&mut self, state: &mut Rsc::State, cursor: &CursorState, window_size: Vec2);
fn run_sensors(&mut self, state: &mut Rsc::State, cursor: CursorState, window_size: Vec2);
}
impl<Rsc: HasEvents> SensorUi<Rsc> for Rsc {
fn run_sensors(&mut self, state: &mut Rsc::State, cursor: &CursorState, window_size: Vec2) {
fn run_sensors(&mut self, state: &mut Rsc::State, cursor: CursorState, window_size: Vec2) {
let layers = std::mem::take(&mut self.ui_mut().layers);
let mut active = std::mem::take(&mut self.events_mut().get_type::<CursorSense>().active);
for layer in layers.indices().rev() {
@@ -158,7 +160,9 @@ impl<Rsc: HasEvents> SensorUi<Rsc> for Rsc {
}
sensed = true;
let mut data = CursorData {
let cursor = cursor.clone();
let data = CursorData {
pos: cursor.pos - region.top_left,
size: region.bot_right - region.top_left,
scroll_delta: cursor.scroll_delta,
@@ -168,7 +172,7 @@ impl<Rsc: HasEvents> SensorUi<Rsc> for Rsc {
// might wanna set up Event to have a prepare stage
sense: CursorSense::Hovering,
};
self.run_event::<CursorSense>(*id, &mut data, state);
self.run_event::<CursorSense>(*id, data, state);
}
if sensed {
break;

11
src/default/task.rs
View File

@@ -62,17 +62,14 @@ impl<Rsc: HasState> Tasks<Rsc> {
)
}
pub fn spawn<F: for<'a> AsyncFnOnce(&'a mut TaskCtx<Rsc>) + 'static + std::marker::Send>(
&mut self,
task: F,
) where
for<'a> <F as AsyncFnOnce<(&'a mut TaskCtx<Rsc>,)>>::CallOnceFuture: Send,
pub fn spawn<F: AsyncFnOnce(TaskCtx<Rsc>) + 'static + std::marker::Send>(&mut self, task: F)
where
F::CallOnceFuture: Send,
{
let send = self.msg_send.clone();
let window = self.window.clone();
let _ = self.start.send(Box::pin(async move {
let mut ctx = TaskCtx::new(send);
task(&mut ctx).await;
task(TaskCtx::new(send)).await;
window.request_redraw();
}));
}

79
src/event.rs
View File

@@ -1,54 +1,60 @@
use iris_core::*;
use iris_macro::*;
use std::sync::Arc;
use crate::default::{TaskCtx, Tasks};
pub mod eventable {
use super::*;
widget_trait! {
pub trait Eventable<Rsc: HasEvents>;
pub trait Eventable<Rsc: HasEvents, Tag>: WidgetLike<Rsc, Tag> {
fn on<E: EventLike>(
self,
event: E,
f: impl for<'a> WidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, WL::Widget>,
) -> impl WidgetIdFn<Rsc, WL::Widget> {
f: impl WidgetEventFn<Rsc, <E::Event as Event>::Data, Self::Widget>,
) -> impl WidgetIdFn<Rsc, Self::Widget> {
move |rsc| {
let id = self.add(rsc);
rsc.register_event(id, event.into_event(), move |ctx, rsc| {
f(&mut EventIdCtx {
f(
EventIdCtx {
widget: id,
state: ctx.state,
data: ctx.data,
}, rsc);
},
rsc,
);
});
id
}
}
}
impl<WL: WidgetLike<Rsc, Tag>, Rsc: HasEvents, Tag> Eventable<Rsc, Tag> for WL {}
// widget_trait! {
// pub trait TaskEventable<Rsc: HasEvents + HasTasks>;
// fn task_on<E: EventLike>(
// self,
// event: E,
// f: impl for<'a> AsyncWidgetEventFn<Rsc, <E::Event as Event>::Data<'a>, WL::Widget>,
// ) -> impl WidgetIdFn<Rsc, WL::Widget> {
// move |rsc| {
// let id = self.add(rsc);
// rsc.register_event(id, event.into_event(), move |ctx, rsc| {
// rsc.tasks_mut().spawn(async move |task| {
// f(&mut AsyncEventIdCtx {
// widget: id,
// state: ctx.state,
// data: ctx.data,
// task,
// }, rsc).await;
// });
// });
// id
// }
// }
// }
widget_trait! {
pub trait TaskEventable<Rsc: HasEvents + HasTasks>;
fn task_on<E: EventLike, F: AsyncWidgetEventFn<Rsc, <E::Event as Event>::Data, WL::Widget>>(
self,
event: E,
f: F,
) -> impl WidgetIdFn<Rsc, WL::Widget>
where <E::Event as Event>::Data: Send,
for<'a> F::CallRefFuture<'a>: Send,
{
let f = Arc::new(f);
move |rsc| {
let id = self.add(rsc);
rsc.register_event(id, event.into_event(), move |ctx, rsc| {
let data = ctx.data;
let f = f.clone();
rsc.tasks_mut().spawn(async move |task| {
f(AsyncEventIdCtx {
widget: id,
data,
task,
}).await;
});
});
id
}
}
}
pub trait HasTasks: Sized + HasState + HasEvents {
@@ -56,21 +62,20 @@ pub trait HasTasks: Sized + HasState + HasEvents {
}
pub trait AsyncWidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
AsyncFn(&mut AsyncEventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
AsyncFn(AsyncEventIdCtx<Rsc, Data, W>) + Send + Sync + 'static
{
}
impl<
Rsc: HasEvents,
F: AsyncFn(&mut AsyncEventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static,
F: AsyncFn(AsyncEventIdCtx<Rsc, Data, W>) + Send + Sync + 'static,
Data,
W: ?Sized,
> AsyncWidgetEventFn<Rsc, Data, W> for F
{
}
pub struct AsyncEventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> {
pub struct AsyncEventIdCtx<Rsc: HasEvents, Data, W: ?Sized> {
pub widget: WidgetRef<W>,
pub state: &'a mut Rsc::State,
pub data: &'a mut Data,
pub task: &'a mut TaskCtx<Rsc>,
pub data: Data,
pub task: TaskCtx<Rsc>,
}

16
src/lib.rs
View File

@@ -8,25 +8,11 @@
pub mod default;
pub mod event;
pub mod typed;
pub mod widget;
pub use iris_core as core;
pub use iris_macro as macros;
#[macro_export]
macro_rules! state_prelude {
($vis:vis $state:ty) => {
iris::event_state!($vis $state);
$vis use iris::{
default::*,
core::{len_fns::*, util::Vec2, *},
macros::*,
widget::*,
};
};
}
pub mod prelude {
use super::*;
pub use default::*;
@@ -36,5 +22,5 @@ pub mod prelude {
pub use widget::*;
pub use iris_core::util::Vec2;
pub use typed::*;
pub use len_fns::*;
}

37
src/typed.rs
View File

@@ -1,37 +0,0 @@
#[macro_export]
macro_rules! event_state {
($vis:vis $rsc:ty) => {
mod local_event_trait {
use super::*;
#[allow(unused_imports)]
use $crate::prelude::*;
pub trait EventableCtx<WL: WidgetLike<$rsc, Tag>, Tag> {
fn on<E: EventLike>(
self,
event: E,
f: impl for<'a> WidgetEventFn<
$rsc,
<E::Event as Event>::Data<'a>,
WL::Widget
>,
) -> impl WidgetIdFn<$rsc, WL::Widget>;
}
impl<WL: WidgetLike<$rsc, Tag>, Tag> EventableCtx<WL, Tag> for WL {
fn on<E: EventLike>(
self,
event: E,
f: impl for<'a> WidgetEventFn<
$rsc,
<E::Event as Event>::Data<'a>,
WL::Widget
>,
) -> impl WidgetIdFn<$rsc, WL::Widget> {
eventable::Eventable::on(self, event, f)
}
}
}
$vis type EventManager = $crate::prelude::EventManager<<$rsc as HasState>::State>;
$vis use local_event_trait::*;
};
}
pub use event_state;

7
src/widget/trait_fns.rs
View File

@@ -84,7 +84,6 @@ widget_trait! {
}
fn scrollable(self) -> impl WidgetIdFn<Rsc, Scroll> where Rsc: HasEvents {
use eventable::Eventable;
move |state| {
Scroll::new(self.add_strong(state), Axis::Y)
.on(CursorSense::Scroll, |ctx, rsc| {
@@ -132,9 +131,9 @@ widget_trait! {
}
}
pub trait CoreWidgetArr<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
fn span(self, dir: Dir) -> SpanBuilder<State, LEN, Wa, Tag>;
fn stack(self) -> StackBuilder<State, LEN, Wa, Tag>;
pub trait CoreWidgetArr<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> {
fn span(self, dir: Dir) -> SpanBuilder<Rsc, LEN, Wa, Tag>;
fn stack(self) -> StackBuilder<Rsc, LEN, Wa, Tag>;
}
impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>