Refactor Magpie window event handling + catch most windowing errors instead of unwrapping

apps/magpie/Cargo.toml

@@ -9,6 +9,7 @@ path = "src/main.rs"
 required-features = ["service"]
 
 [dependencies]
+anyhow = { version = "1", optional = true }
 byteorder = "1.4"
 canary = { path = "../..", optional = true }
 glium = { version = "0.32", optional = true}
@@ -20,4 +21,4 @@ serde_json = "1"
 slab = { version = "0.4", optional = true}
 
 [features]
-service = ["dep:canary", "dep:glium", "dep:mio", "dep:mio-signals", "dep:parking_lot", "dep:slab"]
+service = ["dep:anyhow", "dep:canary", "dep:glium", "dep:mio", "dep:mio-signals", "dep:parking_lot", "dep:slab"]

apps/magpie/src/service/ipc.rs

@@ -11,8 +11,8 @@ use mio_signals::{Signal, Signals};
 use parking_lot::RwLock;
 use slab::Slab;
 
-use crate::service::window::{WindowMessage, WindowMessageSender};
 use crate::protocol::{CreatePanel, MagpieServerMsg, SendMessage, ServerMessenger};
+use crate::service::window::{WindowMessage, WindowMessageSender};
 
 const SOCK_NAME: &str = "magpie.sock";
 

apps/magpie/src/service/window.rs

@@ -12,6 +12,7 @@ use glutin::window::WindowId;
 use crate::service::gl::Graphics;
 use crate::service::ipc::{IpcMessage, IpcMessageSender};
 
+#[derive(Clone, Debug)]
 pub enum WindowMessage {
     OpenWindow { id: usize, script: PathBuf },
     CloseWindow { id: usize },
@@ -70,6 +71,16 @@ impl Window {
     pub fn resize(&mut self, new_size: Vec2) {
         self.panel.on_resize(new_size);
     }
+
+    pub fn on_event(&mut self, event: WindowEvent) {
+        match event {
+            WindowEvent::Resized(size) => {
+                self.resize(Vec2::new(size.width as f32, size.height as f32) * canary::PX_PER_MM);
+                self.request_redraw()
+            }
+            _ => {}
+        }
+    }
 }
 
 pub struct WindowStore {
@@ -99,19 +110,43 @@ impl WindowStore {
             .flatten()
     }
 
+    pub fn on_message(
+        &mut self,
+        event_loop: &EventLoopWindowTarget<WindowMessage>,
+        message: WindowMessage,
+    ) -> anyhow::Result<bool> {
+        match message {
+            WindowMessage::OpenWindow { id, script } => {
+                println!("Opening window {} with script {:?}", id, script);
+                let module = std::fs::read(script)?;
+                let mut script = self.runtime.load_module(&module)?;
+                let panel = script.create_panel(vec![])?;
+                let window = Window::new(panel, &event_loop)?;
+                let window_id = window.get_id();
+                self.windows.insert(window_id, window);
+                self.ipc_to_window.insert(id, window_id);
+            }
+            WindowMessage::CloseWindow { id } => {
+                if let Some(window_id) = self.ipc_to_window.remove(&id) {
+                    self.windows.remove(&window_id);
+                }
+            }
+            WindowMessage::Quit => return Ok(true),
+            WindowMessage::SendMessage { id, msg } => {
+                if let Some(window) = self.get_ipc_window(id) {
+                    window.send_message(msg);
+                }
+            }
+        };
+
+        Ok(false)
+    }
+
     pub fn run(mut self, event_loop: EventLoop<WindowMessage>) -> ! {
         event_loop.run(move |event, event_loop, control_flow| match event {
             Event::WindowEvent { window_id, event } => {
                 if let Some(window) = self.windows.get_mut(&window_id) {
-                    match event {
-                        WindowEvent::Resized(size) => {
-                            window.resize(
-                                Vec2::new(size.width as f32, size.height as f32) * canary::PX_PER_MM
-                            );
-                            window.request_redraw()
-                        },
-                        _ => {}
-                    }
+                    window.on_event(event);
                 }
             }
             Event::RedrawRequested(id) => {
@@ -125,27 +160,11 @@ impl WindowStore {
                     window.request_redraw();
                 }
             }
-            Event::UserEvent(event) => match event {
-                WindowMessage::OpenWindow { id, script } => {
-                    println!("Opening window {} with script {:?}", id, script);
-                    let module = std::fs::read(script).unwrap();
-                    let mut script = self.runtime.load_module(&module).unwrap();
-                    let panel = script.create_panel(vec![]).unwrap();
-                    let window = Window::new(panel, &event_loop).unwrap();
-                    let window_id = window.get_id();
-                    self.windows.insert(window_id, window);
-                    self.ipc_to_window.insert(id, window_id);
-                }
-                WindowMessage::CloseWindow { id } => {
-                    if let Some(window_id) = self.ipc_to_window.remove(&id) {
-                        self.windows.remove(&window_id);
-                    }
-                }
-                WindowMessage::Quit => *control_flow = ControlFlow::Exit,
-                WindowMessage::SendMessage { id, msg } => {
-                    if let Some(window) = self.get_ipc_window(id) {
-                        window.send_message(msg);
-                    }
+            Event::UserEvent(event) => match self.on_message(event_loop, event.clone()) {
+                Ok(false) => {}
+                Ok(true) => *control_flow = ControlFlow::Exit,
+                Err(err) => {
+                    eprintln!("Error while handling message {:?}:\n{}", event, err);
                 }
             },
             _ => {}