switch to default iris app

src/bin/client/main.rs

@@ -1,56 +1,37 @@
 #![windows_subsystem = "windows"]
 
 use crate::{
-    app::App,
     net::{NetHandle, NetSender},
     rsc::{CLIENT_DATA, ClientData},
     state::{ClientState, LoggedIn, Login},
     ui::*,
 };
-pub use app::AppHandle;
-use arboard::Clipboard;
-use input::Input;
-use iris::prelude::*;
+use iris::{prelude::*, winit::*};
 use openworm::{
     net::{ClientMsg, ServerMsg, install_crypto_provider},
     rsc::DataDir,
 };
-use render::Renderer;
-use std::{sync::Arc, time::Instant};
-use winit::{
-    event::{ElementState, Ime, MouseButton, WindowEvent},
-    event_loop::{ActiveEventLoop, EventLoopProxy},
-    window::Window,
-};
+use winit::event::{ElementState, MouseButton, WindowEvent};
 
-mod app;
 mod debug;
-mod input;
 mod net;
-mod render;
 mod rsc;
 mod state;
 mod ui;
 
 fn main() {
     install_crypto_provider();
-    App::run();
+    UiApp::<Client>::run();
 }
 
 pub struct Client {
-    renderer: Renderer,
-    input: Input,
-    ui: Ui,
-    focus: Option<WidgetId<TextEdit>>,
-    clipboard: Clipboard,
     dir: DataDir,
     data: ClientData,
-    handle: AppHandle,
     state: ClientState,
-    ime: usize,
-    last_click: Instant,
     main_ui: WidgetId<WidgetPtr>,
     notif: WidgetId<WidgetPtr>,
+    ui: DefaultUi,
+    proxy: Proxy<ClientEvent>,
 }
 
 pub enum ClientEvent {
@@ -59,18 +40,15 @@ pub enum ClientEvent {
     Err(String),
 }
 
-impl Client {
-    pub fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<ClientEvent>) -> Self {
-        let window = Arc::new(
-            event_loop
-                .create_window(Window::default_attributes().with_title("OPENWORM"))
-                .unwrap(),
-        );
-        let renderer = Renderer::new(window.clone());
-        let dir = DataDir::default();
-        let handle = AppHandle { proxy, window };
+impl DefaultUiState for Client {
+    type Event = ClientEvent;
 
-        let mut ui = Ui::new();
+    fn ui(&mut self) -> &mut DefaultUi {
+        &mut self.ui
+    }
+
+    fn new(mut ui: DefaultUi, proxy: Proxy<Self::Event>) -> Self {
+        let dir = DataDir::default();
         let notif = WidgetPtr::default().add(&mut ui);
         let main_ui = WidgetPtr::default().add(&mut ui);
         (
@@ -81,31 +59,25 @@ impl Client {
             .set_root(&mut ui);
 
         let mut s = Self {
-            handle,
-            renderer,
-            input: Input::default(),
-            ui,
             data: dir.load(CLIENT_DATA),
             state: Default::default(),
             dir,
-            focus: None,
-            clipboard: Clipboard::new().unwrap(),
-            ime: 0,
-            last_click: Instant::now(),
             main_ui: main_ui.clone(),
             notif,
+            ui,
+            proxy,
         };
-        connect_screen(&mut s).set_ptr(&main_ui, &mut s.ui);
+        connect_screen(&mut s).set_ptr(&s.main_ui, &mut s.ui);
         s
     }
 
-    pub fn event(&mut self, event: ClientEvent, _: &ActiveEventLoop) {
+    fn event(&mut self, event: ClientEvent) {
         match event {
             ClientEvent::Connect { send } => {
-                let ClientState::Connect(state) = self.state.take() else {
+                let ClientState::Connect(connect) = self.state.take() else {
                     panic!("invalid state");
                 };
-                let th = state.handle.unwrap();
+                let th = connect.handle.unwrap();
                 self.state = ClientState::Login(Login {
                     handle: NetHandle {
                         send: send.clone(),
@@ -158,105 +130,19 @@ impl Client {
         }
     }
 
-    pub fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
-        let input_changed = self.input.event(&event);
-        let cursor_state = self.cursor_state().clone();
-        let old = self.focus.clone();
-        if cursor_state.buttons.left.is_start() {
-            self.focus = None;
-        }
-        if input_changed {
-            let window_size = self.window_size();
-            self.run_sensors(&cursor_state, window_size);
-            self.ui.run_sensors(&cursor_state, window_size);
-        }
-        if old != self.focus
-            && let Some(old) = old
-        {
-            self.ui.text(&old).deselect();
-        }
-        match event {
-            WindowEvent::CloseRequested => event_loop.exit(),
-            WindowEvent::RedrawRequested => {
-                self.ui.update();
-                self.renderer.update(&mut self.ui);
-                self.renderer.draw();
-            }
-            WindowEvent::Resized(size) => {
-                self.ui.resize((size.width, size.height));
-                self.renderer.resize(&size)
-            }
-            WindowEvent::KeyboardInput { event, .. } => {
-                if let Some(sel) = &self.focus
-                    && event.state.is_pressed()
-                {
-                    let sel = &sel.clone();
-                    let mut text = self.ui.text(sel);
-                    match text.apply_event(&event, &self.input.modifiers) {
-                        TextInputResult::Unfocus => {
-                            self.focus = None;
-                            self.handle.window.set_ime_allowed(false);
-                        }
-                        TextInputResult::Submit => {
-                            self.run_event(sel, Submit, ());
-                        }
-                        TextInputResult::Paste => {
-                            if let Ok(t) = self.clipboard.get_text() {
-                                text.insert(&t);
-                            }
-                            self.run_event(sel, Edited, ());
-                        }
-                        TextInputResult::Copy(text) => {
-                            if let Err(err) = self.clipboard.set_text(text) {
-                                eprintln!("failed to copy text to clipboard: {err}")
-                            }
-                        }
-                        TextInputResult::Used => {
-                            self.run_event(sel, Edited, ());
-                        }
-                        TextInputResult::Unused => {}
-                    }
-                }
-            }
-            WindowEvent::MouseInput {
-                state: ElementState::Pressed,
-                button: MouseButton::Middle,
-                ..
-            } => {
-                debug::debug(self);
-            }
-            WindowEvent::Ime(ime) => {
-                if let Some(sel) = &self.focus {
-                    let mut text = self.ui.text(sel);
-                    match ime {
-                        Ime::Enabled | Ime::Disabled => (),
-                        Ime::Preedit(content, _pos) => {
-                            // TODO: highlight once that's real
-                            text.replace(self.ime, &content);
-                            self.ime = content.chars().count();
-                        }
-                        Ime::Commit(content) => {
-                            text.insert(&content);
-                        }
-                    }
-                }
-            }
-            _ => (),
-        }
-        if self.ui.needs_redraw() {
-            self.renderer.window().request_redraw();
-        }
-        self.input.end_frame();
-    }
-
-    pub fn exit(&mut self) {
+    fn exit(&mut self) {
         self.state.exit();
         self.dir.save(CLIENT_DATA, &self.data);
     }
-}
 
-impl UiCtx for Client {
-    fn ui(&mut self) -> &mut Ui {
-        &mut self.ui
+    fn window_event(&mut self, event: WindowEvent) {
+        if let WindowEvent::MouseInput {
+            state: ElementState::Pressed,
+            button: MouseButton::Middle,
+            ..
+        } = event
+        {
+            debug::debug(self);
+        }
     }
 }