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

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);
}
}