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

RE ADD CONTEXT

Browse Source
This commit is contained in:
shadow cat
2025-12-15 21:50:53 -05:00
parent dc2be7f688
commit 0b8a93c5ce
39 changed files with 925 additions and 713 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
src/default/attr.rs
View File

@@ -1,42 +1,34 @@
use crate::{default::UiState, prelude::*};
use crate::prelude::*;
use std::time::{Duration, Instant};
use winit::dpi::{LogicalPosition, LogicalSize};
pub struct Selector;
impl<W: Widget + 'static> WidgetAttr<W> for Selector {
type Input = WidgetRef<TextEdit>;
impl<State: HasUiState, W: Widget<State> + 'static> WidgetAttr<State, W> for Selector {
type Input = WidgetRef<State, TextEdit<State>>;
fn run(ui: &mut Ui, container: WidgetRef<W>, id: Self::Input) {
fn run(ui: &mut Ui<State>, container: WidgetRef<State, W>, id: Self::Input) {
ui.register_event(container, CursorSense::click_or_drag(), move |ctx| {
let region = ctx.ui.window_region(&id).unwrap();
let region = ctx.state.ui().window_region(&id).unwrap();
let id_pos = region.top_left;
let container_pos = ctx.ui.window_region(&container).unwrap().top_left;
let container_pos = ctx.state.ui().window_region(&container).unwrap().top_left;
let pos = ctx.data.pos + container_pos - id_pos;
let size = region.size();
select(
ctx.ui,
id,
ctx.state,
pos,
size,
ctx.data.sense.is_dragging(),
);
select(ctx.state, id, pos, size, ctx.data.sense.is_dragging());
});
}
}
pub struct Selectable;
impl WidgetAttr<TextEdit> for Selectable {
impl<State: HasUiState> WidgetAttr<State, TextEdit<State>> for Selectable {
type Input = ();
fn run(ui: &mut Ui, id: WidgetRef<TextEdit>, _: Self::Input) {
fn run(ui: &mut Ui<State>, id: WidgetRef<State, TextEdit<State>>, _: Self::Input) {
ui.register_event(id, CursorSense::click_or_drag(), move |ctx| {
select(
ctx.ui,
id,
ctx.state,
id,
ctx.data.pos,
ctx.data.size,
ctx.data.sense.is_dragging(),
@@ -45,24 +37,23 @@ impl WidgetAttr<TextEdit> for Selectable {
}
}
fn select(
ui: &mut Ui,
id: WidgetRef<TextEdit>,
state: &mut UiState,
fn select<State: 'static + HasUiState>(
state: &mut State,
id: WidgetRef<State, TextEdit<State>>,
pos: Vec2,
size: Vec2,
dragging: bool,
) {
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) {
state.window.set_ime_allowed(true);
state.window.set_ime_cursor_area(
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(
LogicalPosition::<f32>::from(region.top_left.tuple()),
LogicalSize::<f32>::from(region.size().tuple()),
);
}
state.focus = Some(id);
state.ui_state().focus = Some(id);
}

2
src/default/input.rs
View File

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

114
src/default/mod.rs
View File

@@ -1,10 +1,11 @@
use crate::prelude::*;
use arboard::Clipboard;
use std::sync::Arc;
use std::time::Instant;
use winit::event::{Ime, WindowEvent};
use winit::event_loop::{ActiveEventLoop, EventLoopProxy};
use winit::window::{Window, WindowAttributes};
use std::{marker::Sized, sync::Arc, time::Instant};
use winit::{
event::{Ime, WindowEvent},
event_loop::{ActiveEventLoop, EventLoopProxy},
window::Window,
};
mod app;
mod attr;
@@ -21,49 +22,21 @@ pub use render::*;
pub use sense::*;
pub type Proxy<Event> = EventLoopProxy<Event>;
pub type DefaultApp<Data> = App<DefaultState<Data>>;
pub struct DefaultState<AppState> {
ui: Ui,
ui_state: UiState,
app_state: AppState,
}
pub struct UiState {
pub struct UiState<State> {
pub renderer: UiRenderer,
pub input: Input,
pub focus: Option<WidgetRef<TextEdit>>,
pub focus: Option<WidgetRef<State, TextEdit<State>>>,
pub clipboard: Clipboard,
pub window: Arc<Window>,
pub ime: usize,
pub last_click: Instant,
}
pub trait DefaultAppState: 'static {
type Event: 'static = ();
fn new(ui: &mut Ui, state: &UiState, proxy: Proxy<Self::Event>) -> Self;
#[allow(unused_variables)]
fn event(&mut self, event: Self::Event, ui: &mut Ui, state: &UiState) {}
#[allow(unused_variables)]
fn exit(&mut self, ui: &mut Ui, state: &UiState) {}
#[allow(unused_variables)]
fn window_event(&mut self, event: WindowEvent, ui: &mut Ui, state: &UiState) {}
fn window_attrs() -> WindowAttributes {
WindowAttributes::default()
}
}
impl<State: DefaultAppState> AppState for DefaultState<State> {
type Event = State::Event;
fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
let window = Arc::new(
event_loop
.create_window(State::window_attrs())
.expect("failed to create window "),
);
let mut ui = Ui::new();
let ui_state = UiState {
impl<State> UiState<State> {
pub fn new(window: impl Into<Arc<Window>>) -> Self {
let window = window.into();
Self {
renderer: UiRenderer::new(window.clone()),
window,
input: Input::default(),
@@ -71,26 +44,42 @@ impl<State: DefaultAppState> AppState for DefaultState<State> {
ime: 0,
last_click: Instant::now(),
focus: None,
};
let app_state = State::new(&mut ui, &ui_state, proxy);
Self {
ui,
ui_state,
app_state,
}
}
}
pub trait HasUiState: Sized + 'static + HasUi {
fn ui_state(&mut self) -> &mut UiState<Self>;
fn ui_with_ui_state(&mut self) -> (&mut Ui<Self>, &mut UiState<Self>) {
// as long as you're not doing anything actually unhinged this should always work safely
(unsafe { std::mem::transmute(self.ui()) }, self.ui_state())
}
}
pub trait DefaultAppState: Sized + 'static + HasUi + HasUiState {
type Event: 'static = ();
fn new(event_loop: &ActiveEventLoop, 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) {}
}
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)
}
fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
self.app_state.event(event, &mut self.ui, &self.ui_state);
self.event(event);
}
fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
let Self {
ui,
ui_state,
app_state,
} = self;
let ui_state = self.ui_state();
let input_changed = ui_state.input.event(&event);
let cursor_state = ui_state.cursor_state().clone();
let old = ui_state.focus;
@@ -99,13 +88,9 @@ impl<State: DefaultAppState> AppState for DefaultState<State> {
}
if input_changed {
let window_size = ui_state.window_size();
// call sensors with all 3 important contexts
// TODO: allow user to specify custom contexts?
// and give them both states in case they need both
ui.run_sensors(&mut (), &cursor_state, window_size);
ui.run_sensors(ui_state, &cursor_state, window_size);
ui.run_sensors(app_state, &cursor_state, window_size);
self.run_sensors(&cursor_state, window_size);
}
let (mut ui, mut ui_state) = self.ui_with_ui_state();
if old != ui_state.focus
&& let Some(old) = old
{
@@ -133,13 +118,13 @@ impl<State: DefaultAppState> AppState for DefaultState<State> {
ui_state.window.set_ime_allowed(false);
}
TextInputResult::Submit => {
ui.run_event::<Submit, _>(app_state, sel, &mut ());
self.run_event::<Submit>(sel, &mut ());
}
TextInputResult::Paste => {
if let Ok(t) = ui_state.clipboard.get_text() {
text.insert(&t);
}
ui.run_event::<Edited, _>(app_state, sel, &mut ());
self.run_event::<Edited>(sel, &mut ());
}
TextInputResult::Copy(text) => {
if let Err(err) = ui_state.clipboard.set_text(text) {
@@ -147,14 +132,14 @@ impl<State: DefaultAppState> AppState for DefaultState<State> {
}
}
TextInputResult::Used => {
ui.run_event::<Edited, _>(app_state, sel, &mut ());
self.run_event::<Edited>(sel, &mut ());
}
TextInputResult::Unused => {}
}
}
}
WindowEvent::Ime(ime) => {
if let Some(sel) = &ui_state.focus {
if let Some(sel) = ui_state.focus {
let mut text = sel.edit(ui);
match ime {
Ime::Enabled | Ime::Disabled => (),
@@ -171,7 +156,8 @@ impl<State: DefaultAppState> AppState for DefaultState<State> {
}
_ => (),
}
app_state.window_event(event, ui, ui_state);
self.window_event(event);
(ui, ui_state) = self.ui_with_ui_state();
if ui.needs_redraw() {
ui_state.renderer.window().request_redraw();
}
@@ -179,6 +165,6 @@ impl<State: DefaultAppState> AppState for DefaultState<State> {
}
fn exit(&mut self) {
self.app_state.exit(&mut self.ui, &self.ui_state);
self.exit();
}
}

2
src/default/render.rs
View File

@@ -18,7 +18,7 @@ pub struct UiRenderer {
}
impl UiRenderer {
pub fn update(&mut self, updates: &mut Ui) {
pub fn update<State>(&mut self, updates: &mut Ui<State>) {
self.ui.update(&self.device, &self.queue, updates);
}

33
src/default/sense.rs
View File

@@ -138,28 +138,23 @@ pub struct CursorData<'a> {
pub sense: CursorSense,
}
pub trait SensorUi {
fn run_sensors<Ctx: 'static>(&mut self, ctx: &mut Ctx, cursor: &CursorState, window_size: Vec2);
pub trait SensorUi<State> {
fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2);
}
impl SensorUi for Ui {
fn run_sensors<Ctx: 'static>(
&mut self,
ctx: &mut Ctx,
cursor: &CursorState,
window_size: Vec2,
) {
let layers = std::mem::take(&mut self.data.layers);
impl<State: 'static + HasUi> SensorUi<State> for State {
fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2) {
let layers = std::mem::take(&mut self.ui().data.layers);
let mut active =
std::mem::take(&mut self.data.events.get_type::<CursorSense, Ctx>().active);
std::mem::take(&mut self.ui().data.events.get_type::<CursorSense>().active);
for layer in layers.indices().rev() {
let mut sensed = false;
for (id, state) in active.get_mut(&layer).into_iter().flatten() {
let shape = self.data.active.get(id).unwrap().region;
for (id, sensor) in active.get_mut(&layer).into_iter().flatten() {
let shape = self.ui().data.active.get(id).unwrap().region;
let region = shape.to_px(window_size);
let in_shape = cursor.exists && region.contains(cursor.pos);
state.hover.update(in_shape);
if state.hover == ActivationState::Off {
sensor.hover.update(in_shape);
if sensor.hover == ActivationState::Off {
continue;
}
sensed = true;
@@ -168,20 +163,20 @@ impl SensorUi for Ui {
pos: cursor.pos - region.top_left,
size: region.bot_right - region.top_left,
scroll_delta: cursor.scroll_delta,
hover: state.hover,
hover: sensor.hover,
cursor,
// this does not have any meaning;
// might wanna set up Event to have a prepare stage
sense: CursorSense::Hovering,
};
self.run_event::<CursorSense, Ctx>(ctx, *id, &mut data);
self.run_event::<CursorSense>(*id, &mut data);
}
if sensed {
break;
}
}
self.data.events.get_type::<CursorSense, Ctx>().active = active;
self.data.layers = layers;
self.ui().data.events.get_type::<CursorSense>().active = active;
self.ui().data.layers = layers;
}
}