more refactor

src/bin/client/main.rs

@@ -0,0 +1,203 @@
+#![windows_subsystem = "windows"]
+
+use crate::{
+    app::App,
+    net::NetSender,
+    rsc::{CLIENT_DATA, ClientData},
+    ui::*,
+};
+pub use app::AppHandle;
+use arboard::Clipboard;
+use input::Input;
+use iris::prelude::*;
+use openworm::{
+    net::{ClientMsg, ServerMsg, install_crypto_provider},
+    rsc::DataDir,
+};
+use render::Renderer;
+use std::sync::Arc;
+use winit::{
+    event::{Ime, WindowEvent},
+    event_loop::{ActiveEventLoop, EventLoopProxy},
+    window::Window,
+};
+
+mod app;
+mod input;
+mod net;
+mod render;
+mod rsc;
+mod ui;
+
+fn main() {
+    install_crypto_provider();
+    App::run();
+}
+
+pub enum ClientEvent {
+    Connect { send: NetSender, username: String },
+    ServerMsg(ServerMsg),
+    Err(String),
+}
+
+pub struct Client {
+    renderer: Renderer,
+    input: Input,
+    ui: Ui,
+    focus: Option<WidgetId<TextEdit>>,
+    channel: Option<WidgetId<Span>>,
+    username: String,
+    clipboard: Clipboard,
+    dir: DataDir,
+    data: ClientData,
+    handle: AppHandle,
+    error: Option<WidgetId<WidgetPtr>>,
+    ime: usize,
+}
+
+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 };
+
+        let mut s = Self {
+            handle,
+            renderer,
+            input: Input::default(),
+            ui: Ui::new(),
+            data: dir.load(CLIENT_DATA),
+            dir,
+            channel: None,
+            focus: None,
+            username: "<unknown>".to_string(),
+            clipboard: Clipboard::new().unwrap(),
+            error: None,
+            ime: 0,
+        };
+        ui::init(&mut s);
+        s
+    }
+
+    pub fn event(&mut self, event: ClientEvent, _: &ActiveEventLoop) {
+        match event {
+            ClientEvent::Connect { send, username } => {
+                self.username = username;
+                send.send(ClientMsg::RequestMsgs);
+                main_view(self, send).set_root(&mut self.ui);
+            }
+            ClientEvent::ServerMsg(msg) => match msg {
+                ServerMsg::SendMsg(msg) => {
+                    if let Some(msg_area) = &self.channel {
+                        let msg = msg_widget(msg).add(&mut self.ui);
+                        self.ui[msg_area].children.push(msg.any());
+                    }
+                }
+                ServerMsg::LoadMsgs(msgs) => {
+                    if let Some(msg_area) = &self.channel {
+                        for msg in msgs {
+                            let msg = msg_widget(msg).add(&mut self.ui);
+                            self.ui[msg_area].children.push(msg.any());
+                        }
+                    }
+                }
+            },
+            ClientEvent::Err(msg) => {
+                if let Some(err) = &self.error {
+                    self.ui[err].inner = Some(ui::error(&mut self.ui, &msg));
+                }
+            }
+        }
+    }
+
+    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();
+        if let Some(focus) = &self.focus
+            && cursor_state.buttons.left.is_start()
+        {
+            self.ui.text(focus).deselect();
+            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);
+        }
+        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::Used => {
+                            self.run_event(sel, Edited, ());
+                        }
+                        TextInputResult::Unused => (),
+                    }
+                }
+            }
+            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) {
+        self.dir.save(CLIENT_DATA, &self.data);
+    }
+}
+
+impl UiCtx for Client {
+    fn ui(&mut self) -> &mut Ui {
+        &mut self.ui
+    }
+}