129 lines
4.0 KiB
Rust
Executable File
129 lines
4.0 KiB
Rust
Executable File
use std::cell::RefCell;
|
|
use std::collections::HashMap;
|
|
use std::rc::Rc;
|
|
use winit::event::{Event, WindowEvent as WinitWindowEvent};
|
|
use winit::event_loop::EventLoop;
|
|
use winit::window::WindowId;
|
|
use crate::context::Context;
|
|
use crate::event::{
|
|
application::Event as ApplicationEvent,
|
|
window::Event as WindowEvent,
|
|
};
|
|
use crate::plugin::Plugin;
|
|
use crate::window::{Window, WindowBuilder};
|
|
|
|
macro_rules! emit_app_event {
|
|
($app:expr, $event:expr) => {
|
|
if let Some(handlers) = $app.events.get_mut(&$event) {
|
|
handlers.iter_mut().for_each(|handler| handler(&mut $app.ctx.borrow_mut()));
|
|
}
|
|
};
|
|
}
|
|
|
|
pub struct Application {
|
|
winit_event_loop: EventLoop<()>,
|
|
windows: HashMap<WindowId, Window>,
|
|
events: HashMap<ApplicationEvent, Vec<Box<dyn FnMut(&mut Context)>>>,
|
|
ctx: Rc<RefCell<Context>>,
|
|
}
|
|
|
|
impl Application {
|
|
pub fn new() -> Self {
|
|
Default::default()
|
|
}
|
|
|
|
pub fn apply_plugin<P>(self, plugin: P) -> Self
|
|
where
|
|
P: Plugin
|
|
{
|
|
plugin.apply(self)
|
|
}
|
|
|
|
pub fn add_window(mut self, builder: WindowBuilder) -> Self {
|
|
let window = builder
|
|
.build(self.ctx.clone(), &self.winit_event_loop)
|
|
.unwrap();
|
|
self.windows.insert(window.id(), window);
|
|
self
|
|
}
|
|
|
|
pub fn add_windows<const N: usize>(mut self,
|
|
builders: [WindowBuilder; N]
|
|
) -> Self {
|
|
self.windows.extend(builders.map(|builder| {
|
|
let window = builder
|
|
.build(self.ctx.clone(), &self.winit_event_loop)
|
|
.unwrap();
|
|
(window.id(), window)
|
|
}));
|
|
self
|
|
}
|
|
|
|
pub fn on_event(mut self,
|
|
event: ApplicationEvent,
|
|
handler: fn(&mut Context),
|
|
) -> Self {
|
|
if let Some(handlers) = self.events.get_mut(&event) {
|
|
handlers.push(Box::new(handler));
|
|
} else {
|
|
self.events.insert(event, vec![Box::new(handler)]);
|
|
}
|
|
|
|
self
|
|
}
|
|
|
|
/// This method enters the event loop. You probably don't want to call this
|
|
/// directly, the `launch` macro will call this in the generated main
|
|
/// function.
|
|
pub fn launch(mut self, rt: tokio::runtime::Runtime) {
|
|
self.ctx.borrow_mut().set_rt(rt);
|
|
|
|
self.winit_event_loop.run(move |event, target, control_flow| {
|
|
*control_flow = self.ctx.borrow().control_flow();
|
|
|
|
while let Some(builder) = self.ctx.borrow_mut().pop_window_builder() {
|
|
let window = builder.build(self.ctx.clone(), target).unwrap();
|
|
self.windows.insert(window.id(), window);
|
|
}
|
|
|
|
match event {
|
|
Event::WindowEvent {
|
|
window_id,
|
|
event: WinitWindowEvent::CloseRequested,
|
|
} => {
|
|
self.windows.get_mut(&window_id).unwrap()
|
|
.emit_event(WindowEvent::Closed);
|
|
self.windows.remove(&window_id);
|
|
|
|
if self.windows.is_empty() {
|
|
emit_app_event!(self, ApplicationEvent::AllWindowsClosed);
|
|
}
|
|
}
|
|
Event::WindowEvent {
|
|
window_id,
|
|
event: WinitWindowEvent::Resized(size)
|
|
} => self.windows.get_mut(&window_id).unwrap().resized(size),
|
|
Event::MainEventsCleared => {
|
|
// determine if state changed and request redraw if needed
|
|
// rinse and repeat for every window
|
|
}
|
|
Event::RedrawRequested(window_id) =>
|
|
self.windows.get_mut(&window_id).unwrap().render(),
|
|
|
|
_ => ()
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Default for Application {
|
|
fn default() -> Self {
|
|
Self {
|
|
winit_event_loop: EventLoop::new(),
|
|
windows: Default::default(),
|
|
events: Default::default(),
|
|
ctx: Rc::new(RefCell::new(Context::new())),
|
|
}
|
|
}
|
|
}
|