event_loop: group core API in EventLoopProvider

This helps with portability and defines some top-level structure around
the event loop, so in the future, backends can get an idea of what API
to use.

This also changes the API to be object safe by using `dyn` throughout.

Author: kchibisov

examples/application.rs

@@ -19,7 +19,7 @@ use winit::application::ApplicationHandler;
 use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
 use winit::error::RequestError;
 use winit::event::{DeviceEvent, DeviceId, Ime, MouseButton, MouseScrollDelta, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::event_loop::{ActiveEventLoop, EventLoop, EventLoopProvider};
 use winit::icon::RgbaIcon;
 use winit::keyboard::{Key, ModifiersState};
 use winit::monitor::Fullscreen;
@@ -75,7 +75,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         });
     }
 
-    let app = Application::new(&event_loop, receiver, sender);
+    let app = Box::new(Application::new(&event_loop, receiver, sender));
     Ok(event_loop.run_app(app)?)
 }
 

examples/child_window.rs

@@ -6,7 +6,7 @@ fn main() -> Result<(), impl std::error::Error> {
     use winit::application::ApplicationHandler;
     use winit::dpi::{LogicalPosition, LogicalSize, Position};
     use winit::event::{ElementState, KeyEvent, WindowEvent};
-    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, EventLoopProvider};
     use winit::raw_window_handle::HasRawWindowHandle;
     use winit::window::{Window, WindowAttributes, WindowId};
 
@@ -117,7 +117,7 @@ fn main() -> Result<(), impl std::error::Error> {
     }
 
     let event_loop = EventLoop::new().unwrap();
-    event_loop.run_app(Application::default())
+    event_loop.run_app(Box::new(Application::default()))
 }
 
 #[cfg(not(any(x11_platform, macos_platform, windows_platform)))]

examples/control_flow.rs

@@ -9,7 +9,7 @@ use ::tracing::{info, warn};
 use web_time as time;
 use winit::application::ApplicationHandler;
 use winit::event::{ElementState, KeyEvent, StartCause, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop, EventLoopProvider};
 use winit::keyboard::{Key, NamedKey};
 use winit::window::{Window, WindowAttributes, WindowId};
 
@@ -43,7 +43,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let event_loop = EventLoop::new().unwrap();
 
-    event_loop.run_app(ControlFlowDemo::default())
+    event_loop.run_app(Box::new(ControlFlowDemo::default()))
 }
 
 #[derive(Default, Debug)]

examples/dnd.rs

@@ -2,7 +2,7 @@ use std::error::Error;
 
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::event_loop::{ActiveEventLoop, EventLoop, EventLoopProvider};
 use winit::window::{Window, WindowAttributes, WindowId};
 
 #[path = "util/fill.rs"]
@@ -15,7 +15,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     let event_loop = EventLoop::new()?;
 
-    let app = Application::new();
+    let app = Box::new(Application::new());
     Ok(event_loop.run_app(app)?)
 }
 

examples/window.rs

@@ -4,7 +4,7 @@ use std::error::Error;
 
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::event_loop::{ActiveEventLoop, EventLoop, EventLoopProvider};
 #[cfg(web_platform)]
 use winit::platform::web::WindowAttributesExtWeb;
 use winit::window::{Window, WindowAttributes, WindowId};
@@ -77,7 +77,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let event_loop = EventLoop::new()?;
 
     // For alternative loop run options see `pump_events` and `run_on_demand` examples.
-    event_loop.run_app(App::default())?;
+    event_loop.run_app(Box::new(App::default()))?;
 
     Ok(())
 }

examples/x11_embed.rs

@@ -5,7 +5,7 @@ use std::error::Error;
 fn main() -> Result<(), Box<dyn Error>> {
     use winit::application::ApplicationHandler;
     use winit::event::WindowEvent;
-    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, EventLoopProvider};
     use winit::platform::x11::WindowAttributesExtX11;
     use winit::window::{Window, WindowAttributes, WindowId};
 
@@ -59,7 +59,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     tracing_subscriber::fmt::init();
     let event_loop = EventLoop::new()?;
 
-    Ok(event_loop.run_app(XEmbedDemo { parent_window_id, window: None })?)
+    Ok(event_loop.run_app(Box::new(XEmbedDemo { parent_window_id, window: None }))?)
 }
 
 #[cfg(not(x11_platform))]

src/application.rs

@@ -8,14 +8,14 @@ use crate::window::WindowId;
 
 /// The handler of application-level events.
 ///
-/// See [the top-level docs] for example usage, and [`EventLoop::run_app`] for an overview of when
-/// events are delivered.
+/// See [the top-level docs] for example usage, and [`EventLoopProvider::run_app`] for an overview
+/// of when events are delivered.
 ///
 /// This is [dropped] when the event loop is shut down. Note that this only works if you're passing
-/// the entire state to [`EventLoop::run_app`] (passing `&mut app` won't work).
+/// the entire state to [`EventLoopProvider::run_app`] (passing `&mut app` won't work).
 ///
 /// [the top-level docs]: crate
-/// [`EventLoop::run_app`]: crate::event_loop::EventLoop::run_app
+/// [`EventLoopProvider::run_app`]: crate::event_loop::EventLoopProvider::run_app
 /// [dropped]: std::ops::Drop
 pub trait ApplicationHandler {
     /// Emitted when new events arrive from the OS to be processed.
@@ -136,7 +136,7 @@ pub trait ApplicationHandler {
     /// use std::time::Duration;
     ///
     /// use winit::application::ApplicationHandler;
-    /// use winit::event_loop::{ActiveEventLoop, EventLoop};
+    /// use winit::event_loop::{ActiveEventLoop, EventLoop, EventLoopProvider};
     ///
     /// struct MyApp {
     ///     receiver: mpsc::Receiver<u64>,
@@ -189,7 +189,7 @@ pub trait ApplicationHandler {
     ///         }
     ///     });
     ///
-    ///     event_loop.run_app(MyApp { receiver })?;
+    ///     event_loop.run_app(Box::new(MyApp { receiver }))?;
     ///
     ///     background_thread.join().unwrap();
     ///
@@ -210,9 +210,9 @@ pub trait ApplicationHandler {
 
     /// Emitted when the OS sends an event to a device.
     ///
-    /// For this to be called, it must be enabled with [`EventLoop::listen_device_events`].
+    /// For this to be called, it must be enabled with [`EventLoopProvider::listen_device_events`].
     ///
-    /// [`EventLoop::listen_device_events`]: crate::event_loop::EventLoop::listen_device_events
+    /// [`EventLoopProvider::listen_device_events`]: crate::event_loop::EventLoopProvider::listen_device_events
     fn device_event(
         &mut self,
         event_loop: &dyn ActiveEventLoop,

src/changelog/unreleased.md

@@ -195,6 +195,10 @@ changelog entry.
 - Renamed "super" key to "meta", to match the naming in the W3C specification.
   `NamedKey::Super` still exists, but it's non-functional and deprecated, `NamedKey::Meta` should be used instead.
 - Move `IconExtWindows` into `WinIcon`.
+- `run_app_on_demand`/`pump_app_events` now accept `&mut dyn ApplicationHandler` instead of generic.
+- Moved common `EventLoop` methods like `run_app` into `EventLoopProvider` trait.
+- Moved `event_loop::EventLoop` into `platform::event_loop::EventLoop` keeping the old re-export in place.
+- `EventLoopProvider::run_app` now takes `Box<dyn ApplicationHandler` instead of owned generic.
 
 ### Removed