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

better global state structure?

Browse Source
This commit is contained in:
Shadow Cat
2025-12-19 21:54:48 -05:00
parent 30bc55c78e
commit bae17235c6
23 changed files with 335 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Cargo.lock generated
View File

@@ -1068,6 +1068,7 @@ dependencies = [
name = "iris-macro"
version = "0.1.0"
dependencies = [
"proc-macro2",
"quote",
"syn",
]

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

@@ -1,7 +1,6 @@
use crate::{HasEvents, HasState, HasUi, Ui, Widget, WidgetRef};
use std::ops::{Deref, DerefMut};
use crate::{HasUi, Ui, Widget, WidgetRef};
pub struct EventCtx<'a, State, Data> {
pub state: &'a mut State,
pub data: &'a mut Data,
@@ -14,21 +13,47 @@ pub struct EventIdCtx<'a, State, Data, W: ?Sized> {
}
impl<State: HasUi, Data, W: ?Sized> Deref for EventIdCtx<'_, State, Data, W> {
type Target = Ui;
type Target = State;
fn deref(&self) -> &Self::Target {
self.state.ui_ref()
self.state
}
}
impl<State: HasUi, Data, W: ?Sized> DerefMut for EventIdCtx<'_, State, Data, W> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.state.ui()
self.state
}
}
impl<'a, State: HasUi + 'static, Data, W: Widget> EventIdCtx<'a, State, Data, W> {
impl<'a, State: HasUi, Data, W: Widget> EventIdCtx<'a, State, Data, W> {
pub fn widget(&mut self) -> &mut W {
&mut self.state.ui()[self.widget]
&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()
}
}

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

@@ -1,6 +1,6 @@
use crate::{
ActiveData, Event, EventCtx, EventFn, EventLike, HasRsc, HasUi, IdLike, LayerId, WidgetData,
WidgetId,
ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, IdLike, LayerId, Widget,
WidgetData, WidgetEventFn, WidgetId, WidgetRef,
util::{HashMap, TypeMap},
};
use std::{any::TypeId, rc::Rc};
@@ -22,11 +22,11 @@ impl<State: 'static> EventManager<State> {
self.types.type_or_default()
}
pub fn register<I: IdLike, E: EventLike>(
pub fn register<W: Widget + ?Sized, E: EventLike>(
&mut self,
id: I,
id: WidgetRef<W>,
event: E,
f: impl for<'a> EventFn<State, <E::Event as Event>::Data<'a>>,
f: impl for<'a> WidgetEventFn<State, <E::Event as Event>::Data<'a>, W>,
) {
self.get_type::<E>().register(id, event, f);
}
@@ -106,17 +106,23 @@ impl<State, E: Event> Default for TypeEventManager<State, E> {
}
impl<State: 'static, E: Event> TypeEventManager<State, E> {
fn register(
fn register<W: Widget + ?Sized>(
&mut self,
id: impl IdLike,
widget: WidgetRef<W>,
event: impl EventLike<Event = E>,
f: impl for<'a> EventFn<State, E::Data<'a>>,
f: impl for<'a> WidgetEventFn<State, E::Data<'a>, W>,
) {
let event = event.into_event();
self.map
.entry(id.id())
.or_default()
.push((event, Rc::new(f)));
self.map.entry(widget.id()).or_default().push((
event,
Rc::new(move |ctx| {
f(&mut EventIdCtx {
widget,
state: ctx.state,
data: ctx.data,
});
}),
));
}
pub fn run_fn<'a>(
@@ -127,7 +133,7 @@ impl<State: 'static, E: Event> TypeEventManager<State, E> {
move |ctx| {
for (e, f) in fs {
if e.should_run(ctx.data) {
f(EventCtx {
f(&mut EventCtx {
state: ctx.state,
data: ctx.data,
})
@@ -136,27 +142,3 @@ impl<State: 'static, E: Event> TypeEventManager<State, E> {
}
}
}
pub trait HasEvents: Sized {
type State: HasRsc<Rsc = Self>;
fn events(&mut self) -> &mut EventManager<Self::State>;
fn register_event<I: IdLike, E: EventLike>(
&mut self,
id: I,
event: E,
f: impl for<'a> EventFn<Self::State, <E::Event as Event>::Data<'a>>,
) where
Self: HasUi,
{
let id = id.id();
self.events().register(id, event, f);
self.ui()
.widgets
.data_mut(id)
.unwrap()
.event_mgrs
.insert(EventManager::<Self::State>::type_key::<E>());
}
}

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

@@ -28,11 +28,14 @@ impl<E: Event> EventLike for E {
}
}
pub trait EventFn<State, Data>: Fn(EventCtx<State, Data>) + 'static {}
impl<State, F: Fn(EventCtx<State, Data>) + 'static, Data> EventFn<State, Data> for F {}
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 WidgetEventFn<State, Data, W: ?Sized>: Fn(EventIdCtx<State, Data, W>) + 'static {}
impl<State, F: Fn(EventIdCtx<State, Data, W>) + 'static, Data, W: ?Sized>
pub trait WidgetEventFn<State, Data, W: ?Sized>:
Fn(&mut EventIdCtx<State, Data, W>) + 'static
{
}
impl<State, F: Fn(&mut EventIdCtx<State, Data, W>) + 'static, Data, W: ?Sized>
WidgetEventFn<State, Data, W> for F
{
}

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

@@ -1,29 +1,47 @@
use crate::{Event, EventCtx, EventLike, EventManager, HasEvents, HasUi, IdLike};
use crate::{
Event, EventCtx, EventLike, EventManager, HasUi, IdLike, Widget, WidgetEventFn, WidgetRef,
};
pub trait HasRsc: Sized + 'static {
type Rsc: HasEvents<State = Self> + HasUi;
fn rsc(&self) -> &Self::Rsc;
fn rsc_mut(&mut self) -> &mut Self::Rsc;
pub trait HasState {
type State: HasUi;
}
fn run_event<E: EventLike>(&mut self, id: impl IdLike, data: &mut <E::Event as Event>::Data<'_>)
where
Self: 'static,
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 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,
{
let f = self.rsc_mut().events().get_type::<E>().run_fn(id);
self.events_mut().register(id, event, f);
self.ui_mut()
.widgets
.data_mut(id)
.unwrap()
.event_mgrs
.insert(EventManager::<Self::State>::type_key::<E>());
}
}
pub trait RunEvents: HasEvents + HasState<State = Self> + 'static {
fn run_event<E: EventLike>(
&mut self,
id: impl IdLike,
data: &mut <E::Event as Event>::Data<'_>,
) {
let f = self.events_mut().get_type::<E>().run_fn(id);
f(EventCtx { state: self, data })
}
fn events(&mut self) -> &mut EventManager<Self> {
self.rsc_mut().events()
}
}
impl<R: HasRsc> HasUi for R {
fn ui_ref(&self) -> &crate::Ui {
self.rsc().ui_ref()
}
fn ui(&mut self) -> &mut crate::Ui {
self.rsc_mut().ui()
}
}
impl<T: HasEvents + HasState<State = Self> + 'static> RunEvents for T {}

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

@@ -42,9 +42,25 @@ pub struct Ui {
resized: bool,
}
pub trait HasUi: Sized + 'static {
fn ui_ref(&self) -> &Ui;
fn ui(&mut self) -> &mut 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()
}
}
impl HasUi for Ui {
fn get(&self) -> &Ui {
self
}
fn get_mut(&mut self) -> &mut Ui {
self
}
}
impl Ui {

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

@@ -1,7 +1,7 @@
use std::{marker::Unsize, mem::MaybeUninit, ops::CoerceUnsized, sync::mpsc::Sender};
use crate::{
Widget,
HasUi, Widget,
util::{RefCounter, SlotId},
};
@@ -143,3 +143,11 @@ impl<W> std::fmt::Debug for WidgetHandle<W> {
self.id.fmt(f)
}
}
impl<'a, W: Widget + 'a, State: HasUi> FnOnce<(&'a mut State,)> for WidgetRef<W> {
type Output = &'a mut W;
extern "rust-call" fn call_once(self, args: (&'a mut State,)) -> Self::Output {
&mut args.0.ui_mut()[self]
}
}

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

@@ -19,7 +19,7 @@ pub trait WidgetLike<State: 'static + HasUi, Tag>: Sized {
}
fn set_root(self, state: &mut State) {
state.ui().root = Some(self.add(state));
state.get_mut().root = Some(self.add(state));
}
fn handles(self, state: &mut State) -> WidgetHandles<Self::Widget> {

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

@@ -7,15 +7,15 @@ use super::*;
pub struct ArrTag;
pub struct WidgetTag;
impl<State: HasUi, W: Widget> WidgetLike<State, WidgetTag> for W {
impl<State: HasUi + 'static, W: Widget> WidgetLike<State, WidgetTag> for W {
type Widget = W;
fn add(self, state: &mut State) -> WidgetHandle<W> {
state.ui().add_widget(self)
state.get_mut().add_widget(self)
}
}
pub struct FnTag;
impl<State: HasUi, W: Widget, F: FnOnce(&mut State) -> W> WidgetLike<State, FnTag> for F {
impl<State: HasUi + 'static, W: Widget, F: FnOnce(&mut State) -> W> WidgetLike<State, FnTag> for F {
type Widget = W;
fn add(self, state: &mut State) -> WidgetHandle<W> {
self(state).add(state)
@@ -23,8 +23,8 @@ impl<State: HasUi, W: Widget, F: FnOnce(&mut State) -> W> WidgetLike<State, FnTa
}
pub struct IdTag;
impl<State: HasUi, W: ?Sized + Widget + Unsize<dyn Widget> + 'static> WidgetLike<State, IdTag>
for WidgetHandle<W>
impl<State: HasUi + 'static, W: ?Sized + Widget + Unsize<dyn Widget> + 'static>
WidgetLike<State, IdTag> for WidgetHandle<W>
{
type Widget = W;
fn add(self, _: &mut State) -> WidgetHandle<W> {
@@ -34,7 +34,7 @@ impl<State: HasUi, W: ?Sized + Widget + Unsize<dyn Widget> + 'static> WidgetLike
pub struct IdFnTag;
impl<
State: HasUi,
State: HasUi + 'static,
W: ?Sized + Widget + Unsize<dyn Widget> + 'static,
F: FnOnce(&mut State) -> WidgetHandle<W>,
> WidgetLike<State, IdFnTag> for F

18
examples/minimal.rs
View File

@@ -1,22 +1,20 @@
use iris::prelude::*;
use winit::event_loop::ActiveEventLoop;
fn main() {
App::<State>::run();
}
#[derive(DefaultUiState)]
struct State {
ui: Ui<Self>,
ui_state: UiState<Self>,
}
#[default_ui_state]
struct State {}
impl DefaultAppState for State {
fn new(event_loop: &ActiveEventLoop, _proxy: Proxy<Self::Event>) -> Self {
fn new(ui_state: DefaultUiState, _proxy: Proxy<Self::Event>) -> Self {
let mut ui = Ui::new();
let window = event_loop.create_window(Default::default()).unwrap();
let ui_state = UiState::new(window);
rect(Color::RED).set_root(&mut ui);
Self { ui, ui_state }
Self {
ui,
ui_state,
events: EventManager::default(),
}
}
}

1
macro/Cargo.toml
View File

@@ -4,6 +4,7 @@ version.workspace = true
edition.workspace = true
[dependencies]
proc-macro2 = "1.0.103"
quote = "1.0.42"
syn = { version = "2.0.111", features = ["full"] }

88
macro/src/lib.rs
View File

@@ -2,10 +2,11 @@ extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn::{
Attribute, Block, Error, GenericParam, Generics, Ident, ItemTrait, Signature, Token,
Visibility,
Attribute, Block, Error, Fields, FieldsNamed, GenericParam, Generics, Ident, ItemStruct,
ItemTrait, Meta, Signature, Token, Visibility,
parse::{Parse, ParseStream, Result},
parse_macro_input, parse_quote,
spanned::Spanned,
};
struct Input {
@@ -94,3 +95,86 @@ pub fn widget_trait(input: TokenStream) -> TokenStream {
}
.into()
}
#[proc_macro_derive(UiState, attributes(rsc))]
pub fn derive_ui_state(input: TokenStream) -> TokenStream {
let mut output = proc_macro2::TokenStream::new();
let state: ItemStruct = parse_macro_input!(input);
let sname = state.ident;
let rscname = Ident::new(&(sname.to_string() + "Rsc"), sname.span());
let mut rsc_fields = Vec::new();
for field in state.fields {
let Some(attr) = field.attrs.iter().find(|a| a.path().is_ident("rsc")) else {
continue;
};
let Meta::List(list) = &attr.meta else {
output.extend(Error::new(attr.span(), "invalid attr syntax").into_compile_error());
continue;
};
let tname: Ident = match list.parse_args::<Ident>() {
Ok(ident) => ident,
Err(err) => {
output.extend(err.to_compile_error());
continue;
}
};
let fty = &field.ty;
let fname = &field.ident.unwrap();
rsc_fields.extend(quote! {#fname: #fty,});
output.extend(quote! {
impl #tname for #sname {
fn get(&self) -> &#fty {
&self.#fname
}
fn get_mut(&mut self) -> &mut #fty {
&mut self.#fname
}
}
impl #tname for #rscname {
fn get(&self) -> &#fty {
&self.#fname
}
fn get_mut(&mut self) -> &mut #fty {
&mut self.#fname
}
}
});
}
let vis = state.vis;
output.extend(quote! {
#vis struct #rscname {
#(#rsc_fields)*
}
impl HasState for #sname {
type State = #sname;
}
impl HasState for #rscname {
type State = #sname;
}
});
output.into()
}
#[proc_macro_attribute]
pub fn default_ui_state(_attr: TokenStream, input: TokenStream) -> TokenStream {
let mut state: ItemStruct = parse_macro_input!(input);
let Fields::Named(fields) = &mut state.fields else {
panic!("must be on named fields struct");
};
let name = &state.ident;
state.attrs.push(parse_quote! {#[derive(UiState)]});
let new: FieldsNamed = parse_quote! {{
#[rsc(HasUi)]
pub ui: Ui,
#[rsc(HasDefaultUiState)]
pub ui_state: DefaultUiState,
#[rsc(HasEvents)]
pub events: iris::prelude::EventManager<#name>,
}};
fields.named.extend(new.named);
quote! {#state}.into()
}

78
src/bin/test/main.rs
View File

@@ -1,36 +1,26 @@
use cosmic_text::Family;
use std::{cell::RefCell, rc::Rc};
use winit::{event::WindowEvent, event_loop::ActiveEventLoop, window::WindowAttributes};
use winit::event::WindowEvent;
iris::state_prelude!(DefaultUiRsc<Client>);
iris::state_prelude!(ClientRsc);
fn main() {
App::<Client>::run();
}
#[default_ui_state]
pub struct Client {
rsc: DefaultUiRsc<Self>,
info: WidgetRef<Text>,
}
impl HasRsc for Client {
type Rsc = DefaultUiRsc<Self>;
fn rsc(&self) -> &Self::Rsc {
&self.rsc
}
fn rsc_mut(&mut self) -> &mut Self::Rsc {
&mut self.rsc
}
}
impl DefaultAppState for Client {
fn new(event_loop: &ActiveEventLoop, _proxy: Proxy<Self::Event>) -> Self {
let window = event_loop
.create_window(WindowAttributes::default())
.unwrap();
let mut rsc = DefaultUiRsc::new(window);
fn new(ui_state: DefaultUiState, _proxy: Proxy<Self::Event>) -> Self {
let mut rsc = ClientRsc {
ui: Ui::new(),
ui_state,
events: EventManager::default(),
};
let info;
let rrect = rect(Color::WHITE).radius(20);
let pad_test = (
@@ -71,19 +61,19 @@ impl DefaultAppState for Client {
let add_button = rect(Color::LIME)
.radius(30)
.on(CursorSense::click(), move |mut ctx| {
.on(CursorSense::click(), move |ctx| {
let child = image(include_bytes!("assets/sungals.png"))
.center()
.add(&mut ctx.state.rsc);
ctx[span_add.r].children.push(child);
.add(ctx.state);
(span_add.r)(ctx).children.push(child);
})
.sized((150, 150))
.align(Align::BOT_RIGHT);
let del_button = rect(Color::RED)
.radius(30)
.on(CursorSense::click(), move |mut ctx| {
ctx[span_add.r].children.pop();
.on(CursorSense::click(), move |ctx| {
(span_add.r)(ctx).children.pop();
})
.sized((150, 150))
.align(Align::BOT_LEFT);
@@ -120,8 +110,9 @@ impl DefaultAppState for Client {
.text_align(Align::LEFT)
.size(30)
.attr::<Selectable>(())
.on(Submit, move |mut ctx| {
let content = ctx.widget.edit(ctx.state.ui()).take();
.on(Submit, move |ctx| {
let w = ctx.widget;
let content = w.edit(ctx).take();
let text = wtext(content)
.editable(EditMode::MultiLine)
.size(30)
@@ -130,8 +121,8 @@ impl DefaultAppState for Client {
.attr::<Selectable>(());
let msg_box = text
.background(rect(Color::WHITE.darker(0.5)))
.add(&mut ctx.state.rsc);
ctx[texts.r].children.push(msg_box);
.add(ctx.state);
(texts.r)(ctx).children.push(msg_box);
})
.handles(&mut rsc);
let text_edit_scroll = (
@@ -171,21 +162,21 @@ impl DefaultAppState for Client {
}
let vals = vals.clone();
let rect = rect(color)
.on(CursorSense::click(), move |mut ctx| {
.on(CursorSense::click(), move |ctx| {
let (prev, vec) = &mut *vals.borrow_mut();
if let Some(h) = vec[i].take() {
vec[*prev] = ctx[main.r].replace(h);
vec[*prev] = (main.r)(ctx).replace(h);
*prev = i;
}
ctx.widget().color = color.darker(0.3);
})
.on(
CursorSense::HoverStart | CursorSense::unclick(),
move |mut ctx| {
move |ctx| {
ctx.widget().color = color.brighter(0.2);
},
)
.on(CursorSense::HoverEnd, move |mut ctx| {
.on(CursorSense::HoverEnd, move |ctx| {
ctx.widget().color = color;
});
(rect, wtext(label).size(30).text_align(Align::CENTER)).stack()
@@ -211,21 +202,26 @@ impl DefaultAppState for Client {
.stack()
.set_root(&mut rsc);
Self { rsc, info: info.r }
Self {
ui: rsc.ui,
ui_state: rsc.ui_state,
events: rsc.events,
info: info.r,
}
}
fn window_event(&mut self, _: WindowEvent) {
let new = format!(
"widgets: {}\nactive:{}\nviews: {}",
self.ui().num_widgets(),
self.ui().active_widgets(),
self.ui_state().renderer.ui.view_count()
self.ui.num_widgets(),
self.ui.active_widgets(),
self.ui_state.renderer.ui.view_count()
);
if new != *self.rsc.ui[self.info].content {
*self.rsc.ui[self.info].content = new;
if new != *self.ui[self.info].content {
*self.ui[self.info].content = new;
}
if self.ui().needs_redraw() {
self.ui_state().window.request_redraw();
if self.ui.needs_redraw() {
self.ui_state.window.request_redraw();
}
}
}

29
src/default/attr.rs
View File

@@ -4,12 +4,15 @@ use winit::dpi::{LogicalPosition, LogicalSize};
pub struct Selector;
impl<State: HasUiState + HasEvents, W: Widget + 'static> WidgetAttr<State, W> for Selector {
impl<State: HasEvents, W: Widget + 'static> WidgetAttr<State, W> for Selector
where
State::State: HasDefaultUiState,
{
type Input = WidgetRef<TextEdit>;
fn run(state: &mut State, container: WidgetRef<W>, id: Self::Input) {
state.register_event(container, CursorSense::click_or_drag(), move |ctx| {
let region = ctx.state.ui().window_region(&id).unwrap();
let region = ctx.ui().window_region(&id).unwrap();
let id_pos = region.top_left;
let container_pos = ctx.state.ui().window_region(&container).unwrap().top_left;
let pos = ctx.data.pos + container_pos - id_pos;
@@ -21,7 +24,10 @@ impl<State: HasUiState + HasEvents, W: Widget + 'static> WidgetAttr<State, W> fo
pub struct Selectable;
impl<State: HasUiState + HasEvents> WidgetAttr<State, TextEdit> for Selectable {
impl<State: HasEvents> WidgetAttr<State, TextEdit> for Selectable
where
State::State: HasDefaultUiState,
{
type Input = ();
fn run(state: &mut State, id: WidgetRef<TextEdit>, _: Self::Input) {
@@ -38,22 +44,23 @@ impl<State: HasUiState + HasEvents> WidgetAttr<State, TextEdit> for Selectable {
}
fn select(
state: &mut impl HasUiState,
state: &mut impl HasDefaultUiState,
id: WidgetRef<TextEdit>,
pos: Vec2,
size: Vec2,
dragging: bool,
) {
let (ui, state) = HasDefaultUiState::ui_with_state(state);
let now = Instant::now();
let recent = (now - state.ui_state().last_click) < Duration::from_millis(300);
state.ui_state().last_click = now;
id.edit(state.ui()).select(pos, size, dragging, recent);
if let Some(region) = state.ui().window_region(&id) {
state.ui_state().window.set_ime_allowed(true);
state.ui_state().window.set_ime_cursor_area(
let recent = (now - state.last_click) < Duration::from_millis(300);
state.last_click = now;
id.edit(ui).select(pos, size, dragging, recent);
if let Some(region) = ui.window_region(&id) {
state.window.set_ime_allowed(true);
state.window.set_ime_cursor_area(
LogicalPosition::<f32>::from(region.top_left.tuple()),
LogicalSize::<f32>::from(region.size().tuple()),
);
}
state.ui_state().focus = Some(id);
state.focus = Some(id);
}

2
src/default/input.rs
View File

@@ -66,7 +66,7 @@ impl Input {
}
}
impl UiState {
impl DefaultUiState {
pub fn window_size(&self) -> Vec2 {
let size = self.renderer.window().inner_size();
(size.width, size.height).into()

91
src/default/mod.rs
View File

@@ -5,7 +5,7 @@ use std::{marker::Sized, sync::Arc, time::Instant};
use winit::{
event::{Ime, WindowEvent},
event_loop::{ActiveEventLoop, EventLoopProxy},
window::Window,
window::{Window, WindowAttributes},
};
mod app;
@@ -24,47 +24,7 @@ pub use sense::*;
pub type Proxy<Event> = EventLoopProxy<Event>;
pub struct DefaultUiRsc<State> {
pub ui: Ui,
pub ui_state: UiState,
pub events: EventManager<State>,
}
impl<State> DefaultUiRsc<State> {
pub fn new(window: impl Into<Arc<Window>>) -> Self {
Self {
ui: Ui::new(),
ui_state: UiState::new(window),
events: EventManager::default(),
}
}
}
impl<State: 'static> HasUi for DefaultUiRsc<State> {
fn ui_ref(&self) -> &Ui {
&self.ui
}
fn ui(&mut self) -> &mut Ui {
&mut self.ui
}
}
impl<State: 'static + HasRsc<Rsc = Self>> HasEvents for DefaultUiRsc<State> {
type State = State;
fn events(&mut self) -> &mut EventManager<State> {
&mut self.events
}
}
impl<State: 'static> HasUiState for DefaultUiRsc<State> {
fn ui_state(&mut self) -> &mut UiState {
&mut self.ui_state
}
}
pub struct UiState {
pub struct DefaultUiState {
pub renderer: UiRenderer,
pub input: Input,
pub focus: Option<WidgetRef<TextEdit>>,
@@ -74,7 +34,7 @@ pub struct UiState {
pub last_click: Instant,
}
impl UiState {
impl DefaultUiState {
pub fn new(window: impl Into<Arc<Window>>) -> Self {
let window = window.into();
Self {
@@ -89,39 +49,44 @@ impl UiState {
}
}
pub trait HasUiState: Sized + 'static + HasUi {
fn ui_state(&mut self) -> &mut UiState;
fn ui_with_ui_state(&mut self) -> (&mut Ui, &mut UiState) {
pub trait HasDefaultUiState: Sized + 'static + HasUi {
fn get(&self) -> &DefaultUiState;
fn get_mut(&mut self) -> &mut DefaultUiState;
fn ui_state(&self) -> &DefaultUiState {
HasDefaultUiState::get(self)
}
fn ui_state_mut(&mut self) -> &mut DefaultUiState {
HasDefaultUiState::get_mut(self)
}
fn ui_with_state(&mut self) -> (&mut Ui, &mut DefaultUiState) {
// as long as you're not doing anything actually unhinged this should always work safely
(unsafe { forget_mut(self.ui()) }, self.ui_state())
(
unsafe { forget_mut(self.ui_mut()) },
HasDefaultUiState::get_mut(self),
)
}
}
impl<R: HasRsc> HasUiState for R
where
R::Rsc: HasUiState,
{
fn ui_state(&mut self) -> &mut UiState {
self.rsc_mut().ui_state()
}
}
pub trait DefaultAppState: Sized + 'static + HasRsc + HasUi + HasUiState {
pub trait DefaultAppState: RunEvents + HasDefaultUiState {
type Event: 'static = ();
fn new(event_loop: &ActiveEventLoop, proxy: Proxy<Self::Event>) -> Self;
fn new(ui_state: DefaultUiState, proxy: Proxy<Self::Event>) -> Self;
#[allow(unused_variables)]
fn event(&mut self, event: Self::Event) {}
#[allow(unused_variables)]
fn exit(&mut self) {}
#[allow(unused_variables)]
fn window_event(&mut self, event: WindowEvent) {}
fn window_attributes() -> WindowAttributes {
Default::default()
}
}
impl<State: DefaultAppState> AppState for State {
type Event = State::Event;
fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
Self::new(event_loop, proxy)
let window = event_loop.create_window(Self::window_attributes()).unwrap();
Self::new(DefaultUiState::new(window), proxy)
}
fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
@@ -129,8 +94,8 @@ impl<State: DefaultAppState> AppState for State {
}
fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
let events = unsafe { forget_mut(self.events()) };
let ui_state = self.ui_state();
let events = unsafe { forget_mut(self.events_mut()) };
let ui_state = HasDefaultUiState::get_mut(self);
let input_changed = ui_state.input.event(&event);
let cursor_state = ui_state.cursor_state().clone();
let old = ui_state.focus;
@@ -141,7 +106,7 @@ impl<State: DefaultAppState> AppState for State {
let window_size = ui_state.window_size();
self.run_sensors(&cursor_state, window_size);
}
let (mut ui, mut ui_state) = self.ui_with_ui_state();
let (mut ui, mut ui_state) = self.ui_with_state();
if old != ui_state.focus
&& let Some(old) = old
{
@@ -208,7 +173,7 @@ impl<State: DefaultAppState> AppState for State {
_ => (),
}
self.window_event(event);
(ui, ui_state) = self.ui_with_ui_state();
(ui, ui_state) = self.ui_with_state();
if ui.needs_redraw() {
ui_state.renderer.window().request_redraw();
}

10
src/default/sense.rs
View File

@@ -142,10 +142,10 @@ pub trait SensorUi<State> {
fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2);
}
impl<State: 'static + HasRsc> SensorUi<State> for State {
impl<State: RunEvents> SensorUi<State> for State {
fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2) {
let layers = std::mem::take(&mut self.ui().layers);
let mut active = std::mem::take(&mut self.events().get_type::<CursorSense>().active);
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() {
let mut sensed = false;
for (id, sensor) in active.get_mut(&layer).into_iter().flatten() {
@@ -174,8 +174,8 @@ impl<State: 'static + HasRsc> SensorUi<State> for State {
break;
}
}
self.events().get_type::<CursorSense>().active = active;
self.ui().layers = layers;
self.events_mut().get_type::<CursorSense>().active = active;
self.ui_mut().layers = layers;
}
}

4
src/event.rs
View File

@@ -3,7 +3,7 @@ use crate::prelude::*;
pub mod eventable {
use super::*;
widget_trait! {
pub trait Eventable<State: HasUi + HasEvents>;
pub trait Eventable<State: HasEvents + 'static>;
fn on<E: EventLike>(
self,
event: E,
@@ -12,7 +12,7 @@ pub mod eventable {
move |state| {
let id = self.handles(state);
state.register_event(id.r, event.into_event(), move |ctx| {
f(EventIdCtx {
f(&mut EventIdCtx {
widget: id.r,
state: ctx.state,
data: ctx.data,

6
src/typed.rs
View File

@@ -10,7 +10,7 @@ macro_rules! event_state {
self,
event: E,
f: impl for<'a> WidgetEventFn<
<$state as HasEvents>::State,
<$state as HasState>::State,
<E::Event as Event>::Data<'a>,
WL::Widget
>,
@@ -21,7 +21,7 @@ macro_rules! event_state {
self,
event: E,
f: impl for<'a> WidgetEventFn<
<$state as HasEvents>::State,
<$state as HasState>::State,
<E::Event as Event>::Data<'a>,
WL::Widget
>,
@@ -30,7 +30,7 @@ macro_rules! event_state {
}
}
}
$vis type EventManager = $crate::prelude::EventManager<$state>;
$vis type EventManager = $crate::prelude::EventManager<<$state as HasState>::State>;
$vis use local_event_trait::*;
};
}

2
src/widget/image.rs
View File

@@ -22,7 +22,7 @@ impl Widget for Image {
pub fn image<State: HasUi>(image: impl LoadableImage) -> impl WidgetFn<State, Image> {
let image = image.get_image().expect("Failed to load image");
move |state| Image {
handle: state.ui().add_texture(image),
handle: state.get_mut().add_texture(image),
}
}

6
src/widget/text/build.rs
View File

@@ -51,7 +51,7 @@ impl<State, O, H: WidgetOption<State>> TextBuilder<State, O, H> {
}
}
impl<State: HasUi, O> TextBuilder<State, O> {
impl<State: HasUi + 'static, O> TextBuilder<State, O> {
pub fn hint<W: WidgetLike<State, Tag>, Tag>(
self,
hint: W,
@@ -87,7 +87,7 @@ impl<State: HasUi> TextBuilderOutput<State> for TextOutput {
builder.attrs.line_height,
));
let hint = builder.hint.get(state);
let font_system = &mut state.ui().text.font_system;
let font_system = &mut state.get_mut().text.font_system;
buf.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
let mut text = Text {
content: builder.content.into(),
@@ -118,7 +118,7 @@ impl<State: HasUi> TextBuilderOutput<State> for TextEditOutput {
TextView::new(buf, builder.attrs, builder.hint.get(state)),
builder.output.mode,
);
let font_system = &mut state.ui().text.font_system;
let font_system = &mut state.get_mut().text.font_system;
text.buf
.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
builder.attrs.apply(font_system, &mut text.buf, None);

5
src/widget/text/edit.rs
View File

@@ -617,11 +617,12 @@ impl DerefMut for TextEdit {
}
pub trait TextEditable {
fn edit<'a>(&self, ui: &'a mut Ui) -> TextEditCtx<'a>;
fn edit<'a>(&self, ui: &'a mut impl HasUi) -> TextEditCtx<'a>;
}
impl<I: IdLike<Widget = TextEdit>> TextEditable for I {
fn edit<'a>(&self, ui: &'a mut Ui) -> TextEditCtx<'a> {
fn edit<'a>(&self, ui: &'a mut impl HasUi) -> TextEditCtx<'a> {
let ui = ui.ui_mut();
TextEditCtx {
text: ui.widgets.get_mut(self).unwrap(),
font_system: &mut ui.text.font_system,

8
src/widget/trait_fns.rs
View File

@@ -3,7 +3,7 @@ use crate::prelude::*;
// these methods should "not require any context" (require unit) because they're in core
widget_trait! {
pub trait CoreWidget<State: HasUi>;
pub trait CoreWidget<State: HasUi + 'static>;
fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<State, Pad> {
|state| Pad {
@@ -26,7 +26,7 @@ widget_trait! {
fn label(self, label: impl Into<String>) -> impl WidgetIdFn<State, WL::Widget> {
|state| {
let id = self.add(state);
state.ui().set_label(&id, label.into());
state.get_mut().set_label(&id, label.into());
id
}
}
@@ -87,7 +87,7 @@ widget_trait! {
use eventable::*;
move |state| {
Scroll::new(self.add(state), Axis::Y)
.on(CursorSense::Scroll, |mut ctx| {
.on(CursorSense::Scroll, |ctx: &mut EventIdCtx<'_, State::State, CursorData<'_>, Scroll>| {
let delta = ctx.data.scroll_delta.y * 50.0;
ctx.widget().scroll(delta);
})
@@ -128,7 +128,7 @@ widget_trait! {
fn set_ptr(self, ptr: WidgetRef<WidgetPtr>, state: &mut State) {
let id = self.add(state);
state.ui()[ptr].inner = Some(id);
state.get_mut()[ptr].inner = Some(id);
}
}