3fb93b4f83
Creating window when event loop is not running generally doesn't work, since a bunch of events and sync OS requests can't be processed. This is also an issue on e.g. Android, since window can't be created outside event loop easily. Thus deprecate the window creation when event loop is not running, as well as other resource creation to running event loop. Given that all the examples use the bad pattern of creating the window when event loop is not running and also most example existence is questionable, since they show single thing and the majority of their code is window/event loop initialization, they wore merged into a single example 'window.rs' example that showcases very simple application using winit. Fixes #3399.
111 lines
3.6 KiB
Rust
111 lines
3.6 KiB
Rust
use std::marker::PhantomData;
|
|
use std::sync::mpsc::{self, Receiver, Sender};
|
|
|
|
use crate::error::EventLoopError;
|
|
use crate::event::Event;
|
|
use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;
|
|
|
|
use super::{backend, device, window};
|
|
|
|
mod proxy;
|
|
pub(crate) mod runner;
|
|
mod state;
|
|
mod window_target;
|
|
|
|
pub(crate) use proxy::EventLoopProxy;
|
|
pub(crate) use window_target::{ActiveEventLoop, OwnedDisplayHandle};
|
|
|
|
pub struct EventLoop<T: 'static> {
|
|
elw: RootActiveEventLoop,
|
|
user_event_sender: Sender<T>,
|
|
user_event_receiver: Receiver<T>,
|
|
}
|
|
|
|
#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
|
|
pub(crate) struct PlatformSpecificEventLoopAttributes {}
|
|
|
|
impl<T> EventLoop<T> {
|
|
pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
|
|
let (user_event_sender, user_event_receiver) = mpsc::channel();
|
|
let elw = RootActiveEventLoop {
|
|
p: ActiveEventLoop::new(),
|
|
_marker: PhantomData,
|
|
};
|
|
Ok(EventLoop {
|
|
elw,
|
|
user_event_sender,
|
|
user_event_receiver,
|
|
})
|
|
}
|
|
|
|
pub fn run<F>(self, mut event_handler: F) -> !
|
|
where
|
|
F: FnMut(Event<T>, &RootActiveEventLoop),
|
|
{
|
|
let target = RootActiveEventLoop {
|
|
p: self.elw.p.clone(),
|
|
_marker: PhantomData,
|
|
};
|
|
|
|
// SAFETY: Don't use `move` to make sure we leak the `event_handler` and `target`.
|
|
let handler: Box<dyn FnMut(Event<()>)> = Box::new(|event| {
|
|
let event = match event.map_nonuser_event() {
|
|
Ok(event) => event,
|
|
Err(Event::UserEvent(())) => Event::UserEvent(
|
|
self.user_event_receiver
|
|
.try_recv()
|
|
.expect("handler woken up without user event"),
|
|
),
|
|
Err(_) => unreachable!(),
|
|
};
|
|
event_handler(event, &target)
|
|
});
|
|
// SAFETY: The `transmute` is necessary because `run()` requires `'static`. This is safe
|
|
// because this function will never return and all resources not cleaned up by the point we
|
|
// `throw` will leak, making this actually `'static`.
|
|
let handler = unsafe { std::mem::transmute(handler) };
|
|
self.elw.p.run(handler, false);
|
|
|
|
// Throw an exception to break out of Rust execution and use unreachable to tell the
|
|
// compiler this function won't return, giving it a return type of '!'
|
|
backend::throw(
|
|
"Using exceptions for control flow, don't mind me. This isn't actually an error!",
|
|
);
|
|
|
|
unreachable!();
|
|
}
|
|
|
|
pub fn spawn<F>(self, mut event_handler: F)
|
|
where
|
|
F: 'static + FnMut(Event<T>, &RootActiveEventLoop),
|
|
{
|
|
let target = RootActiveEventLoop {
|
|
p: self.elw.p.clone(),
|
|
_marker: PhantomData,
|
|
};
|
|
|
|
self.elw.p.run(
|
|
Box::new(move |event| {
|
|
let event = match event.map_nonuser_event() {
|
|
Ok(event) => event,
|
|
Err(Event::UserEvent(())) => Event::UserEvent(
|
|
self.user_event_receiver
|
|
.try_recv()
|
|
.expect("handler woken up without user event"),
|
|
),
|
|
Err(_) => unreachable!(),
|
|
};
|
|
event_handler(event, &target)
|
|
}),
|
|
true,
|
|
);
|
|
}
|
|
|
|
pub fn create_proxy(&self) -> EventLoopProxy<T> {
|
|
EventLoopProxy::new(self.elw.p.waker(), self.user_event_sender.clone())
|
|
}
|
|
|
|
pub fn window_target(&self) -> &RootActiveEventLoop {
|
|
&self.elw
|
|
}
|
|
}
|