WindowStore + separate IPC thread

apps/magpie/Cargo.toml

@@ -7,5 +7,6 @@ edition = "2021"
 canary = { path = "../.." }
 glium = "0.32"
 mio = { version = "0.8", features = ["net", "os-poll"] }
+mio-extras = "2.0"
 mio-signals = "0.2"
 slab = "0.4"

apps/magpie/src/ipc.rs

@@ -1,13 +1,20 @@
+use super::*;
+
 use mio::net::UnixListener;
 use mio::{Events, Interest, Poll, Token};
 use mio_signals::{Signal, Signals};
 use slab::Slab;
 use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
+use std::sync::mpsc::Sender;
 use std::time::Duration;
 
+use crate::window::{WindowMessage, WindowMessageSender};
+
 const SOCK_NAME: &str = "magpie.sock";
 
+pub enum IpcMessage {}
+
 /// Wraps [mio::net::UnixListener] with automatic file deletion on drop.
 pub struct Listener {
     pub uds: UnixListener,
@@ -40,6 +47,8 @@ impl DerefMut for Listener {
 pub struct Client {}
 
 pub struct Ipc {
+    pub message_recv: MioReceiver<IpcMessage>,
+    pub window_sender: WindowMessageSender,
     pub poll: Poll,
     pub events: Events,
     pub quit: bool,
@@ -47,11 +56,15 @@ pub struct Ipc {
     pub signals: Signals,
     pub listener_token: Token,
     pub signals_token: Token,
+    pub message_recv_token: Token,
     pub clients: Slab<Client>,
 }
 
 impl Ipc {
-    pub fn new() -> std::io::Result<Self> {
+    pub fn new(
+        message_recv: MioReceiver<IpcMessage>,
+        window_sender: WindowMessageSender,
+    ) -> std::io::Result<Self> {
         let sock_dir = std::env::var("XDG_RUNTIME_DIR").expect("XDG_RUNTIME_DIR not set");
         let sock_dir = Path::new(&sock_dir);
         let sock_path = sock_dir.join(SOCK_NAME);
@@ -68,6 +81,7 @@ impl Ipc {
         let poll = Poll::new()?;
         let listener_token = Token(usize::MAX);
         let signals_token = Token(listener_token.0 - 1);
+        let message_recv_token = Token(signals_token.0 - 1);
 
         let registry = poll.registry();
         let interest = Interest::READABLE;
@@ -75,6 +89,8 @@ impl Ipc {
         registry.register(&mut signals, signals_token, interest)?;
 
         Ok(Self {
+            message_recv,
+            window_sender,
             poll,
             events,
             quit: false,
@@ -82,6 +98,7 @@ impl Ipc {
             signals,
             listener_token,
             signals_token,
+            message_recv_token,
             clients: Default::default(),
         })
     }
@@ -103,6 +120,7 @@ impl Ipc {
             } else if event.token() == self.signals_token {
                 while let Some(received) = self.signals.receive()? {
                     eprintln!("Received {:?} signal; exiting...", received);
+                    let _ = self.window_sender.send_event(WindowMessage::Quit);
                     self.quit = true;
                 }
             } else {

apps/magpie/src/main.rs

@@ -1,9 +1,16 @@
+use glium::glutin::event_loop::EventLoopBuilder;
+use mio_extras::channel::{channel as mio_channel, Receiver as MioReceiver, Sender as MioSender};
+
 pub mod gl;
 pub mod ipc;
 pub mod window;
 
 fn main() -> std::io::Result<()> {
-    let ipc = ipc::Ipc::new()?;
-    ipc.run();
-    Ok(())
+    let (ipc_sender, ipc_recv) = mio_channel();
+    let event_loop = EventLoopBuilder::<window::WindowMessage>::with_user_event().build();
+    let window_sender = event_loop.create_proxy();
+    let ipc = ipc::Ipc::new(ipc_recv, window_sender)?;
+    let _ipc_thread = std::thread::spawn(|| ipc.run());
+    let window_store = window::WindowStore::new(ipc_sender);
+    window_store.run(event_loop);
 }

apps/magpie/src/window.rs

@@ -1,12 +1,64 @@
-use canary::PanelId;
+use super::*;
+
+use std::collections::HashMap;
+
+use glium::backend::glutin::DisplayCreationError;
 use glium::glutin;
 use glutin::event::{Event, WindowEvent};
-use glutin::event_loop::{ControlFlow, EventLoop};
+use glutin::event_loop::{ControlFlow, EventLoop, EventLoopProxy};
+use glutin::window::WindowId;
 
 use crate::gl::Graphics;
+use crate::ipc::IpcMessage;
+
+pub enum WindowMessage {
+    Quit,
+}
+
+pub type WindowMessageSender = EventLoopProxy<WindowMessage>;
 
 pub struct Window {
     pub display: glium::Display,
     pub graphics: Graphics,
-    pub panel: PanelId,
+}
+
+impl Window {
+    pub fn new(event_loop: &EventLoop<()>) -> Result<Self, DisplayCreationError> {
+        let wb = glutin::window::WindowBuilder::new();
+        let cb = glutin::ContextBuilder::new();
+        let display = glium::Display::new(wb, cb, &event_loop)?;
+        let graphics = Graphics::new(&display);
+
+        Ok(Self { display, graphics })
+    }
+}
+
+pub struct WindowStore {
+    pub ipc_sender: MioSender<IpcMessage>,
+    pub windows: HashMap<WindowId, Window>,
+}
+
+impl WindowStore {
+    pub fn new(ipc_sender: MioSender<IpcMessage>) -> Self {
+        Self {
+            ipc_sender,
+            windows: Default::default(),
+        }
+    }
+
+    pub fn run(self, event_loop: EventLoop<WindowMessage>) -> ! {
+        event_loop.run(move |event, event_loop, control_flow| {
+            *control_flow = ControlFlow::Poll;
+            match event {
+                Event::WindowEvent { window_id, event } => match event {
+                    _ => {}
+                },
+                Event::MainEventsCleared => {}
+                Event::UserEvent(event) => match event {
+                    WindowMessage::Quit => *control_flow = ControlFlow::Exit,
+                }
+                _ => {}
+            }
+        });
+    }
 }