iris/src/default/mod.rs

use crate::prelude::*;
use arboard::Clipboard;
use std::{
    marker::{PhantomData, Sized},
    sync::Arc,
    time::Instant,
};
use winit::{
    event::{Ime, WindowEvent},
    event_loop::{ActiveEventLoop, EventLoopProxy},
    window::{Window, WindowAttributes},
};

mod app;
mod attr;
mod event;
mod input;
mod render;
mod sense;
mod task;

pub use app::*;
pub use attr::*;
pub use event::*;
pub use input::*;
pub use render::*;
pub use sense::*;
pub use task::*;

pub type Proxy<Event> = EventLoopProxy<Event>;

pub struct DefaultUiState {
    pub renderer: UiRenderer,
    pub input: Input,
    pub focus: Option<WidgetRef<TextEdit>>,
    pub clipboard: Clipboard,
    pub window: Arc<Window>,
    pub ime: usize,
    pub last_click: Instant,
}

impl DefaultUiState {
    pub fn new(window: impl Into<Arc<Window>>) -> Self {
        let window = window.into();
        Self {
            renderer: UiRenderer::new(window.clone()),
            window,
            input: Input::default(),
            clipboard: Clipboard::new().unwrap(),
            ime: 0,
            last_click: Instant::now(),
            focus: None,
        }
    }
}

pub trait HasAppEvent {
    type Event: 'static;
}

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, rsc: &mut DefaultRsc<Self>) {}
    #[allow(unused_variables)]
    fn exit(&mut self, rsc: &mut DefaultRsc<Self>) {}
    #[allow(unused_variables)]
    fn window_event(&mut self, event: WindowEvent, rsc: &mut DefaultRsc<Self>) {}
    fn window_attributes() -> WindowAttributes {
        Default::default()
    }
}

pub struct DefaultRsc<State: 'static> {
    pub ui: Ui,
    pub events: EventManager<Self>,
    pub tasks: Tasks<Self>,
    _state: PhantomData<State>,
}

impl<State> DefaultRsc<State> {
    fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Self>) {
        let (tasks, recv) = Tasks::init(window);
        (
            Self {
                ui: Default::default(),
                events: Default::default(),
                tasks,
                _state: Default::default(),
            },
            recv,
        )
    }
}

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> HasState for DefaultRsc<State> {
    type State = State;
}

impl<State: 'static> HasEvents for DefaultRsc<State> {
    fn events(&self) -> &EventManager<Self> {
        &self.events
    }

    fn events_mut(&mut self) -> &mut EventManager<Self> {
        &mut self.events
    }
}

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,
    task_recv: TaskMsgReceiver<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(State::window_attributes())
            .unwrap();
        let default_state = DefaultUiState::new(window);
        let (mut rsc, task_recv) = DefaultRsc::init(default_state.window.clone());
        let state = State::new(default_state, &mut rsc, proxy);
        Self {
            rsc,
            state,
            task_recv,
        }
    }

    fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
        self.state.event(event, &mut self.rsc);
    }

    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
        for update in self.task_recv.try_iter() {
            update(&mut self.state, &mut self.rsc);
        }

        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;
        if cursor_state.buttons.left.is_start() {
            ui_state.focus = None;
        }
        if input_changed {
            let window_size = ui_state.window_size();
            self.rsc
                .run_sensors(&mut self.state, cursor_state, window_size);
        }
        let ui = &mut self.rsc.ui;
        let ui_state = self.state.default_state_mut();
        if old != ui_state.focus
            && let Some(old) = old
        {
            old.edit(ui).deselect();
        }
        match &event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::RedrawRequested => {
                ui.update(&mut self.rsc.events);
                ui_state.renderer.update(ui);
                ui_state.renderer.draw();
            }
            WindowEvent::Resized(size) => {
                ui.resize((size.width, size.height));
                ui_state.renderer.resize(size)
            }
            WindowEvent::KeyboardInput { event, .. } => {
                if let Some(sel) = ui_state.focus
                    && event.state.is_pressed()
                {
                    let mut text = sel.edit(ui);
                    match text.apply_event(event, &ui_state.input.modifiers) {
                        TextInputResult::Unfocus => {
                            ui_state.focus = None;
                            ui_state.window.set_ime_allowed(false);
                        }
                        TextInputResult::Submit => {
                            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 self.state);
                        }
                        TextInputResult::Copy(text) => {
                            if let Err(err) = ui_state.clipboard.set_text(text) {
                                eprintln!("failed to copy text to clipboard: {err}")
                            }
                        }
                        TextInputResult::Used => {
                            self.rsc.run_event::<Edited>(sel, (), &mut self.state);
                        }
                        TextInputResult::Unused => {}
                    }
                }
            }
            WindowEvent::Ime(ime) => {
                if let Some(sel) = ui_state.focus {
                    let mut text = sel.edit(ui);
                    match ime {
                        Ime::Enabled | Ime::Disabled => (),
                        Ime::Preedit(content, _pos) => {
                            // TODO: highlight once that's real
                            text.replace(ui_state.ime, content);
                            ui_state.ime = content.chars().count();
                        }
                        Ime::Commit(content) => {
                            text.insert(content);
                        }
                    }
                }
            }
            _ => (),
        }
        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.state.exit(&mut self.rsc);
    }
}