iris/src/default/mod.rs

use crate::prelude::*;
use arboard::Clipboard;
use std::{marker::PhantomData, 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 state;
mod task;

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

/// Sends an application's own events to its event loop. It wraps the proxy
/// rather than being one because task updates travel the same way: what an
/// application sends is its `Event`, not the loop's whole message type.
pub struct Proxy<State: DefaultAppState>(EventLoopProxy<DefaultEvent<State>>);

impl<State: DefaultAppState> Clone for Proxy<State> {
    fn clone(&self) -> Self {
        Self(self.0.clone())
    }
}

impl<State: DefaultAppState> Proxy<State> {
    pub fn send_event(&self, event: State::Event) {
        let _ = self.0.send_event(DefaultEvent::User(event));
    }
}

/// What the event loop carries: the application's own events, and the
/// updates tasks send back to the ui thread.
pub enum DefaultEvent<State: DefaultAppState> {
    User(State::Event),
    Update(Box<dyn TaskUpdate<DefaultRsc<State>>>),
}

impl<State: DefaultAppState> TaskQueue<DefaultRsc<State>> for Proxy<State> {
    fn send(&self, update: Box<dyn TaskUpdate<DefaultRsc<State>>>) {
        let _ = self.0.send_event(DefaultEvent::Update(update));
    }
}

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

impl HasRoot for DefaultUiState {
    fn set_root(&mut self, root: StrongWidget) {
        self.root = Some(root);
    }
}

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

pub trait HasDefaultUiState: Sized + 'static {
    fn default_state(&self) -> &DefaultUiState;
    fn default_state_mut(&mut self) -> &mut DefaultUiState;
}

pub trait DefaultAppState: HasDefaultUiState {
    type Event: Send = ();
    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self>) -> Self;
    #[allow(unused_variables)]
    fn event(
        &mut self,
        event: Self::Event,
        rsc: &mut DefaultRsc<Self>,
        render: &mut UiRenderState,
    ) {
    }
    #[allow(unused_variables)]
    fn exit(&mut self, rsc: &mut DefaultRsc<Self>, render: &mut UiRenderState) {}
    #[allow(unused_variables)]
    fn window_event(
        &mut self,
        event: WindowEvent,
        rsc: &mut DefaultRsc<Self>,
        render: &mut UiRenderState,
    ) {
    }
    fn window_attributes() -> WindowAttributes {
        Default::default()
    }
}

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

impl<State> DefaultRsc<State> {
    pub fn init(queue: Arc<dyn TaskQueue<Self>>) -> Self {
        Self {
            ui: Default::default(),
            events: Default::default(),
            tasks: Tasks::init(queue),
            state: Default::default(),
            _state: Default::default(),
        }
    }

    pub fn create_state<T: 'static>(&mut self, id: impl IdLike, data: T) -> WeakState<T> {
        self.state.add(id.id(), data)
    }
}

impl<State> UiRsc for DefaultRsc<State> {
    fn ui(&self) -> &UiData {
        &self.ui
    }

    fn ui_mut(&mut self) -> &mut UiData {
        &mut self.ui
    }

    fn on_draw(&mut self, active: &ActiveData) {
        self.events.draw(active);
    }

    fn on_undraw(&mut self, active: &ActiveData) {
        self.events.undraw(active);
    }

    fn on_remove(&mut self, id: WidgetId) {
        self.events.remove(id);
        self.state.remove(id);
    }
}

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

impl<State: 'static> HasWidgetState for DefaultRsc<State> {
    fn widget_state(&self) -> &WidgetState {
        &self.state
    }

    fn widget_state_mut(&mut self) -> &mut WidgetState {
        &mut self.state
    }
}

pub struct DefaultApp<State: DefaultAppState> {
    rsc: DefaultRsc<State>,
    render: UiRenderState,
    state: State,
}

impl<State: DefaultAppState> AppState for DefaultApp<State> {
    type Event = DefaultEvent<State>;

    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 = DefaultRsc::init(Arc::new(Proxy(proxy.clone())));
        let state = State::new(default_state, &mut rsc, Proxy(proxy));
        let render = UiRenderState::new();
        Self { rsc, state, render }
    }

    fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
        match event {
            DefaultEvent::User(event) => self.state.event(event, &mut self.rsc, &mut self.render),
            DefaultEvent::Update(update) => update(&mut self.state, &mut self.rsc),
        }
        self.request_redraw_if_needed();
    }

    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
        let Self { rsc, render, state } = self;

        let ui_state = 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 {
            render.run_sensors(rsc, state, cursor_state);
        }
        let ui_state = state.default_state_mut();
        if old != ui_state.focus
            && let Some(old) = old
        {
            old.edit(rsc).deselect();
        }
        match &event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::RedrawRequested => {
                render.update(&ui_state.root, rsc);
                ui_state.renderer.update(&mut rsc.ui, render);
                ui_state.renderer.draw();
            }
            WindowEvent::Resized(size) => {
                render.resize((size.width, size.height), rsc.widgets_mut());
                ui_state.renderer.resize(size)
            }
            WindowEvent::KeyboardInput { event, .. } => {
                if let Some(sel) = ui_state.focus
                    && event.state.is_pressed()
                {
                    let mut text = sel.edit(rsc);
                    match text.apply_event(event, &ui_state.input.modifiers) {
                        TextInputResult::Unfocus => {
                            ui_state.focus = None;
                            ui_state.window.set_ime_allowed(false);
                        }
                        TextInputResult::Submit => {
                            rsc.run_event::<Submit>(sel, (), state);
                        }
                        TextInputResult::Paste => {
                            if let Ok(t) = ui_state.clipboard.get_text() {
                                text.insert(&t);
                            }
                            rsc.run_event::<Edited>(sel, (), state);
                        }
                        TextInputResult::Copy(text) => {
                            if let Err(err) = ui_state.clipboard.set_text(text) {
                                eprintln!("failed to copy text to clipboard: {err}")
                            }
                        }
                        TextInputResult::Used => {
                            rsc.run_event::<Edited>(sel, (), state);
                        }
                        TextInputResult::Unused => {}
                    }
                }
            }
            WindowEvent::Ime(ime) => {
                if let Some(sel) = ui_state.focus {
                    let mut text = sel.edit(rsc);
                    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);
                        }
                    }
                }
            }
            _ => (),
        }
        state.window_event(event, rsc, render);
        self.request_redraw_if_needed();
        self.state.default_state_mut().input.end_frame();
    }

    fn exit(&mut self) {
        self.state.exit(&mut self.rsc, &mut self.render);
    }
}

impl<State: DefaultAppState> DefaultApp<State> {
    fn request_redraw_if_needed(&mut self) {
        let ui_state = self.state.default_state_mut();
        if self.render.needs_redraw(&ui_state.root, self.rsc.widgets()) {
            ui_state.renderer.window().request_redraw();
        }
    }
}

pub trait RscIdx<Rsc> {
    type Output;
    fn get(self, rsc: &Rsc) -> &Self::Output;
    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output;
}

impl<State: 'static, I: RscIdx<DefaultRsc<State>>> std::ops::Index<I> for DefaultRsc<State> {
    type Output = I::Output;

    fn index(&self, index: I) -> &Self::Output {
        index.get(self)
    }
}

impl<State: 'static, I: RscIdx<DefaultRsc<State>>> std::ops::IndexMut<I> for DefaultRsc<State> {
    fn index_mut(&mut self, index: I) -> &mut Self::Output {
        index.get_mut(self)
    }
}

impl<W: Widget, Rsc: UiRsc> RscIdx<Rsc> for WeakWidget<W> {
    type Output = W;

    fn get(self, rsc: &Rsc) -> &Self::Output {
        &rsc.ui().widgets[self]
    }

    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
        &mut rsc.ui_mut().widgets[self]
    }
}

impl<T: 'static, Rsc: HasWidgetState> RscIdx<Rsc> for WeakState<T> {
    type Output = T;

    fn get(self, rsc: &Rsc) -> &Self::Output {
        rsc.widget_state().get(self)
    }

    fn get_mut(self, rsc: &mut Rsc) -> &mut Self::Output {
        rsc.widget_state_mut().get_mut(self)
    }
}