canary-rs/apps/magpie/src/service/window.rs

use std::collections::HashMap;
use std::path::PathBuf;
use std::time::Instant;

use canary::{Panel, Runtime, Vec2};
use glium::backend::glutin::DisplayCreationError;
use glium::{glutin, Surface};
use glutin::event::{Event, WindowEvent};
use glutin::event_loop::{ControlFlow, EventLoop, EventLoopProxy, EventLoopWindowTarget};
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 },
    Quit,
    SendMessage { id: usize, msg: Vec<u8> },
}

pub type WindowMessageSender = EventLoopProxy<WindowMessage>;

pub struct Window {
    pub graphics: Graphics,
    pub panel: Panel,
    pub last_update: Instant,
}

impl Window {
    pub fn new(
        panel: Panel,
        event_loop: &EventLoopWindowTarget<WindowMessage>,
    ) -> 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);
        let last_update = Instant::now();
        Ok(Self {
            graphics,
            panel,
            last_update,
        })
    }

    pub fn get_id(&self) -> WindowId {
        self.graphics.display.gl_window().window().id()
    }

    pub fn request_redraw(&mut self) {
        self.graphics.display.gl_window().window().request_redraw();
    }

    pub fn update(&mut self) {
        let now = Instant::now();
        let dt = now.duration_since(self.last_update).as_secs_f32();
        self.panel.update(dt);
    }

    pub fn draw(&mut self) {
        let commands = self.panel.draw();
        self.graphics.draw(&commands);
    }

    pub fn send_message(&mut self, msg: Vec<u8>) {
        self.panel.on_message(msg);
    }

    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 {
    pub ipc_sender: IpcMessageSender,
    pub ipc_to_window: HashMap<usize, WindowId>,
    pub windows: HashMap<WindowId, Window>,
    pub runtime: Runtime,
}

impl WindowStore {
    pub fn new(ipc_sender: IpcMessageSender) -> Self {
        let backend = canary::backend::make_default_backend().unwrap();
        let runtime = Runtime::new(backend).unwrap();

        Self {
            ipc_sender,
            ipc_to_window: Default::default(),
            windows: Default::default(),
            runtime,
        }
    }

    pub fn get_ipc_window(&mut self, id: usize) -> Option<&mut Window> {
        self.ipc_to_window
            .get(&id)
            .map(|id| self.windows.get_mut(id))
            .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) {
                    window.on_event(event);
                }
            }
            Event::RedrawRequested(id) => {
                if let Some(window) = self.windows.get_mut(&id) {
                    window.draw();
                }
            }
            Event::MainEventsCleared => {
                for (_id, window) in self.windows.iter_mut() {
                    window.update();
                    window.request_redraw();
                }
            }
            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);
                }
            },
            _ => {}
        });
    }
}