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

7
src/default/app.rs
View File

@@ -11,6 +11,13 @@ pub trait AppState {
fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop);
fn event(&mut self, event: Self::Event, event_loop: &ActiveEventLoop);
fn exit(&mut self);
fn run()
where
Self: Sized,
{
App::<Self>::run();
}
}
pub struct App<State: AppState> {

30
src/default/attr.rs
View File

@@ -4,35 +4,36 @@ use winit::dpi::{LogicalPosition, LogicalSize};
pub struct Selector;
impl<State: HasEvents, W: Widget + 'static> WidgetAttr<State, W> for Selector
impl<Rsc: HasEvents, W: Widget + 'static> WidgetAttr<Rsc, W> for Selector
where
State::State: HasDefaultUiState,
Rsc::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.ui().window_region(&id).unwrap();
fn run(rsc: &mut Rsc, container: WidgetRef<W>, id: Self::Input) {
rsc.register_event(container, CursorSense::click_or_drag(), move |ctx, rsc| {
let region = rsc.ui().window_region(&id).unwrap();
let id_pos = region.top_left;
let container_pos = ctx.state.ui().window_region(&container).unwrap().top_left;
let container_pos = rsc.ui().window_region(&container).unwrap().top_left;
let pos = ctx.data.pos + container_pos - id_pos;
let size = region.size();
select(ctx.state, id, pos, size, ctx.data.sense.is_dragging());
select(rsc, ctx.state, id, pos, size, ctx.data.sense.is_dragging());
});
}
}
pub struct Selectable;
impl<State: HasEvents> WidgetAttr<State, TextEdit> for Selectable
impl<Rsc: HasEvents> WidgetAttr<Rsc, TextEdit> for Selectable
where
State::State: HasDefaultUiState,
Rsc::State: HasDefaultUiState,
{
type Input = ();
fn run(state: &mut State, id: WidgetRef<TextEdit>, _: Self::Input) {
state.register_event(id, CursorSense::click_or_drag(), move |ctx| {
fn run(rsc: &mut Rsc, id: WidgetRef<TextEdit>, _: Self::Input) {
rsc.register_event(id, CursorSense::click_or_drag(), move |ctx, rsc| {
select(
rsc,
ctx.state,
id,
ctx.data.pos,
@@ -44,18 +45,19 @@ where
}
fn select(
rsc: &mut impl HasUi,
state: &mut impl HasDefaultUiState,
id: WidgetRef<TextEdit>,
pos: Vec2,
size: Vec2,
dragging: bool,
) {
let (ui, state) = HasDefaultUiState::ui_with_state(state);
let state = state.default_state_mut();
let now = Instant::now();
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) {
id.edit(rsc).select(pos, size, dragging, recent);
if let Some(region) = rsc.ui().window_region(&id) {
state.window.set_ime_allowed(true);
state.window.set_ime_cursor_area(
LogicalPosition::<f32>::from(region.top_left.tuple()),

129
src/default/mod.rs
View File

@@ -1,7 +1,10 @@
use crate::prelude::*;
use arboard::Clipboard;
use iris_core::util::forget_mut;
use std::{marker::Sized, sync::Arc, time::Instant};
use std::{
marker::{PhantomData, Sized},
sync::Arc,
time::Instant,
};
use winit::{
event::{Ime, WindowEvent},
event_loop::{ActiveEventLoop, EventLoopProxy},
@@ -49,53 +52,97 @@ impl DefaultUiState {
}
}
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_mut()) },
HasDefaultUiState::get_mut(self),
)
}
pub trait HasAppEvent {
type Event: 'static;
}
pub trait DefaultAppState: RunEvents + HasDefaultUiState {
type Event: 'static = ();
fn new(ui_state: DefaultUiState, proxy: Proxy<Self::Event>) -> Self;
impl<T> HasAppEvent for T {
type Event = ();
}
pub trait HasDefaultUiState: Sized + 'static + HasAppEvent {
fn default_state(&self) -> &DefaultUiState;
fn default_state_mut(&mut self) -> &mut DefaultUiState;
}
pub trait DefaultAppState: HasDefaultUiState {
fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self::Event>)
-> Self;
#[allow(unused_variables)]
fn event(&mut self, event: Self::Event) {}
fn event(&mut self, event: Self::Event, rsc: &mut DefaultRsc<Self>) {}
#[allow(unused_variables)]
fn exit(&mut self) {}
fn exit(&mut self, rsc: &mut DefaultRsc<Self>) {}
#[allow(unused_variables)]
fn window_event(&mut self, event: WindowEvent) {}
fn window_event(&mut self, event: WindowEvent, rsc: &mut DefaultRsc<Self>) {}
fn window_attributes() -> WindowAttributes {
Default::default()
}
}
impl<State: DefaultAppState> AppState for State {
pub struct DefaultRsc<State> {
pub ui: Ui,
pub events: EventManager<Self>,
_state: PhantomData<State>,
}
impl<State> Default for DefaultRsc<State> {
fn default() -> Self {
Self {
ui: Default::default(),
events: Default::default(),
_state: Default::default(),
}
}
}
impl<State> HasUi for DefaultRsc<State> {
fn ui(&self) -> &Ui {
&self.ui
}
fn ui_mut(&mut self) -> &mut Ui {
&mut self.ui
}
}
impl<State: 'static> HasEvents for DefaultRsc<State> {
type State = State;
fn events(&self) -> &EventManager<Self> {
&self.events
}
fn events_mut(&mut self) -> &mut EventManager<Self> {
&mut self.events
}
}
pub struct DefaultApp<State: DefaultAppState> {
rsc: DefaultRsc<State>,
state: State,
}
// impl StateLike for DefaultRsc<State> {
// }
//
impl<State: DefaultAppState> AppState for DefaultApp<State> {
type Event = State::Event;
fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
let window = event_loop.create_window(Self::window_attributes()).unwrap();
Self::new(DefaultUiState::new(window), proxy)
let window = event_loop
.create_window(State::window_attributes())
.unwrap();
let mut rsc = DefaultRsc::default();
let state = State::new(DefaultUiState::new(window), &mut rsc, proxy);
Self { rsc, state }
}
fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
self.event(event);
self.state.event(event, &mut self.rsc);
}
fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
let events = unsafe { forget_mut(self.events_mut()) };
let ui_state = HasDefaultUiState::get_mut(self);
let ui_state = self.state.default_state_mut();
let input_changed = ui_state.input.event(&event);
let cursor_state = ui_state.cursor_state().clone();
let old = ui_state.focus;
@@ -104,9 +151,11 @@ impl<State: DefaultAppState> AppState for State {
}
if input_changed {
let window_size = ui_state.window_size();
self.run_sensors(&cursor_state, window_size);
self.rsc
.run_sensors(&mut self.state, &cursor_state, window_size);
}
let (mut ui, mut ui_state) = self.ui_with_state();
let ui = &mut self.rsc.ui;
let ui_state = self.state.default_state_mut();
if old != ui_state.focus
&& let Some(old) = old
{
@@ -115,7 +164,7 @@ impl<State: DefaultAppState> AppState for State {
match &event {
WindowEvent::CloseRequested => event_loop.exit(),
WindowEvent::RedrawRequested => {
ui.update(events);
ui.update(&mut self.rsc.events);
ui_state.renderer.update(ui);
ui_state.renderer.draw();
}
@@ -134,13 +183,13 @@ impl<State: DefaultAppState> AppState for State {
ui_state.window.set_ime_allowed(false);
}
TextInputResult::Submit => {
self.run_event::<Submit>(sel, &mut ());
self.rsc.run_event::<Submit>(sel, &mut (), &mut self.state);
}
TextInputResult::Paste => {
if let Ok(t) = ui_state.clipboard.get_text() {
text.insert(&t);
}
self.run_event::<Edited>(sel, &mut ());
self.rsc.run_event::<Edited>(sel, &mut (), &mut self.state);
}
TextInputResult::Copy(text) => {
if let Err(err) = ui_state.clipboard.set_text(text) {
@@ -148,7 +197,7 @@ impl<State: DefaultAppState> AppState for State {
}
}
TextInputResult::Used => {
self.run_event::<Edited>(sel, &mut ());
self.rsc.run_event::<Edited>(sel, &mut (), &mut self.state);
}
TextInputResult::Unused => {}
}
@@ -172,15 +221,15 @@ impl<State: DefaultAppState> AppState for State {
}
_ => (),
}
self.window_event(event);
(ui, ui_state) = self.ui_with_state();
if ui.needs_redraw() {
self.state.window_event(event, &mut self.rsc);
let ui_state = self.state.default_state_mut();
if self.rsc.ui.needs_redraw() {
ui_state.renderer.window().request_redraw();
}
ui_state.input.end_frame();
}
fn exit(&mut self) {
self.exit();
self.state.exit(&mut self.rsc);
}
}

12
src/default/sense.rs
View File

@@ -115,7 +115,7 @@ pub enum ActivationState {
/// or basically have some way to have custom senses
/// that depend on active widget positions
/// but I'm not sure how or if worth it
pub struct Sensor<Ctx, Data> {
pub struct Sensor<Ctx: HasEvents, Data> {
pub senses: CursorSenses,
pub f: Rc<dyn EventFn<Ctx, Data>>,
}
@@ -138,12 +138,12 @@ pub struct CursorData<'a> {
pub sense: CursorSense,
}
pub trait SensorUi<State> {
fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2);
pub trait SensorUi<Rsc: HasEvents> {
fn run_sensors(&mut self, state: &mut Rsc::State, cursor: &CursorState, window_size: Vec2);
}
impl<State: RunEvents> SensorUi<State> for State {
fn run_sensors(&mut self, 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) {
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() {
@@ -168,7 +168,7 @@ impl<State: RunEvents> SensorUi<State> for State {
// might wanna set up Event to have a prepare stage
sense: CursorSense::Hovering,
};
self.run_event::<CursorSense>(*id, &mut data);
self.run_event::<CursorSense>(*id, &mut data, state);
}
if sensed {
break;