Winit version 0.30.3

This new implementation uses:
- The NSAppearanceCustomization protocol for retrieving the appearance
  of the window, instead of using the application-wide
  `-[NSApplication effectiveAppearance]`.
- Key-Value observing for observing the `effectiveAppearance` to compute
  the `ThemeChanged` event, instead of using the undocumented
  `AppleInterfaceThemeChangedNotification` notification.

This also fixes `WindowBuilder::with_theme` not having any effect, and
the conversion between `Theme` and `NSAppearance` is made a bit more
robust.

.github/CODEOWNERS

@@ -1,11 +1,10 @@
 # Android
-/src/platform/android.rs            @MarijnS95
-/src/platform_impl/android          @MarijnS95
+/src/platform/android.rs            @msiglreith @MarijnS95
+/src/platform_impl/android          @msiglreith @MarijnS95
 
-# Apple (AppKit + UIKit)
+# iOS
 /src/platform/ios.rs                @madsmtm
-/src/platform/macos.rs              @madsmtm
-/src/platform_impl/apple            @madsmtm
+/src/platform_impl/ios              @madsmtm
 
 # Unix
 /src/platform_impl/linux/mod.rs     @kchibisov
@@ -18,13 +17,17 @@
 /src/platform/x11.rs                @kchibisov @notgull
 /src/platform_impl/linux/x11        @kchibisov @notgull
 
+# macOS
+/src/platform/macos.rs              @madsmtm
+/src/platform_impl/macos            @madsmtm
+
 # Web
 /src/platform/web.rs                @daxpedda
 /src/platform_impl/web              @daxpedda
 
 # Windows
-/src/platform/windows.rs            @notgull
-/src/platform_impl/windows          @notgull
+/src/platform/windows.rs            @msiglreith
+/src/platform_impl/windows          @msiglreith
 
 # Orbital (Redox OS)
 /src/platform/orbital.rs            @jackpot51

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ jobs:
     name: Check formatting
     runs-on: ubuntu-latest
     steps:
-    - uses: taiki-e/checkout-action@v1
+    - uses: actions/checkout@v4
     - uses: dtolnay/rust-toolchain@nightly
       with:
         components: rustfmt
@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: taiki-e/checkout-action@v1
+      - uses: actions/checkout@v4
       - uses: taiki-e/install-action@v2
         with:
           tool: typos-cli
@@ -42,7 +42,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        toolchain: [stable, nightly, '1.73']
+        toolchain: [stable, nightly, '1.70.0']
         platform:
           # Note: Make sure that we test all the `docs.rs` targets defined in Cargo.toml!
           - { name: 'Windows 64bit MSVC', target: x86_64-pc-windows-msvc,   os: windows-latest,  }
@@ -61,10 +61,10 @@ jobs:
           - { name: 'web',                target: wasm32-unknown-unknown,   os: ubuntu-latest,   }
         exclude:
           # Android is tested on stable-3
-          - toolchain: '1.73'
+          - toolchain: '1.70.0'
             platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
         include:
-          - toolchain: '1.73'
+          - toolchain: '1.70.0'
             platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
           - toolchain: 'nightly'
             platform: {
@@ -88,7 +88,7 @@ jobs:
       CMD: ${{ matrix.platform.cmd }}
 
     steps:
-    - uses: taiki-e/checkout-action@v1
+    - uses: actions/checkout@v4
 
     - name: Restore cache of cargo folder
       # We use `restore` and later `save`, so that we can create the key after
@@ -149,13 +149,13 @@ jobs:
     - name: Test dpi crate
       if: >
         contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.70.0'
       run: cargo test -p dpi
 
     - name: Build tests
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.70.0'
       run: cargo $CMD test --no-run $OPTIONS
 
     - name: Run tests
@@ -164,7 +164,7 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.70.0'
       run: cargo $CMD test $OPTIONS
 
     - name: Lint with clippy
@@ -174,7 +174,7 @@ jobs:
     - name: Build tests with serde enabled
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.70.0'
       run: cargo $CMD test --no-run $OPTIONS --features serde
 
     - name: Run tests with serde enabled
@@ -183,7 +183,7 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.70.0'
       run: cargo $CMD test $OPTIONS --features serde
 
     - name: Check docs.rs documentation
@@ -220,7 +220,7 @@ jobs:
           - { name: 'Windows', target: x86_64-pc-windows-gnu }
 
     steps:
-    - uses: taiki-e/checkout-action@v1
+    - uses: actions/checkout@v4
     - uses: EmbarkStudios/cargo-deny-action@v1
       with:
         command: check
@@ -232,7 +232,8 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: taiki-e/checkout-action@v1
+      - name: Checkout
+        uses: actions/checkout@v4
       - name: Install SWC
         run: sudo npm i -g @swc/cli
       - name: Run SWC

Cargo.toml

@@ -86,11 +86,11 @@ rwh_06 = { package = "raw-window-handle", version = "0.6", features = [
 ], optional = true }
 serde = { workspace = true, optional = true }
 smol_str = "0.2.0"
-tracing = { version = "0.1.40", default-features = false }
+tracing = { version = "0.1.40", default_features = false }
 
 [dev-dependencies]
 image = { version = "0.25.0", default-features = false, features = ["png"] }
-tracing = { version = "0.1.40", default-features = false, features = ["log"] }
+tracing = { version = "0.1.40", default_features = false, features = ["log"] }
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 winit = { path = ".", features = ["rwh_05"] }
 
@@ -102,21 +102,21 @@ softbuffer = { version = "0.4.0", default-features = false, features = [
     "wayland-dlopen",
 ] }
 
-# Android
 [target.'cfg(target_os = "android")'.dependencies]
 android-activity = "0.6.0"
 ndk = { version = "0.9.0", default-features = false }
 
-# AppKit or UIKit
-[target.'cfg(target_vendor = "apple")'.dependencies]
+[target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
 core-foundation = "0.9.3"
 objc2 = "0.5.2"
 
-# AppKit
 [target.'cfg(target_os = "macos")'.dependencies]
 core-graphics = "0.23.1"
 block2 = "0.5.1"
-objc2-foundation = { version = "0.2.2", features = [
+
+[target.'cfg(target_os = "macos")'.dependencies.objc2-foundation]
+version = "0.2.2"
+features = [
     "block2",
     "dispatch",
     "NSArray",
@@ -134,8 +134,11 @@ objc2-foundation = { version = "0.2.2", features = [
     "NSString",
     "NSThread",
     "NSValue",
-] }
-objc2-app-kit = { version = "0.2.2", features = [
+]
+
+[target.'cfg(target_os = "macos")'.dependencies.objc2-app-kit]
+version = "0.2.2"
+features = [
     "NSAppearance",
     "NSApplication",
     "NSBitmapImageRep",
@@ -162,11 +165,11 @@ objc2-app-kit = { version = "0.2.2", features = [
     "NSWindow",
     "NSWindowScripting",
     "NSWindowTabGroup",
-] }
+]
 
-# UIKit
-[target.'cfg(all(target_vendor = "apple", not(target_os = "macos")))'.dependencies]
-objc2-foundation = { version = "0.2.2", features = [
+[target.'cfg(target_os = "ios")'.dependencies.objc2-foundation]
+version = "0.2.2"
+features = [
     "dispatch",
     "NSArray",
     "NSEnumerator",
@@ -176,8 +179,11 @@ objc2-foundation = { version = "0.2.2", features = [
     "NSProcessInfo",
     "NSThread",
     "NSSet",
-] }
-objc2-ui-kit = { version = "0.2.2", features = [
+]
+
+[target.'cfg(target_os = "ios")'.dependencies.objc2-ui-kit]
+version = "0.2.2"
+features = [
     "UIApplication",
     "UIDevice",
     "UIEvent",
@@ -196,12 +202,14 @@ objc2-ui-kit = { version = "0.2.2", features = [
     "UIView",
     "UIViewController",
     "UIWindow",
-] }
+]
 
-# Windows
 [target.'cfg(target_os = "windows")'.dependencies]
 unicode-segmentation = "1.7.1"
-windows-sys = { version = "0.52.0", features = [
+
+[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
+version = "0.52.0"
+features = [
     "Win32_Devices_HumanInterfaceDevice",
     "Win32_Foundation",
     "Win32_Globalization",
@@ -226,10 +234,9 @@ windows-sys = { version = "0.52.0", features = [
     "Win32_UI_Shell",
     "Win32_UI_TextServices",
     "Win32_UI_WindowsAndMessaging",
-] }
+]
 
-# Linux
-[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_vendor = "apple"))))'.dependencies]
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies]
 ahash = { version = "0.8.7", features = ["no-rng"], optional = true }
 bytemuck = { version = "1.13.1", default-features = false, optional = true }
 calloop = "0.12.3"
@@ -245,8 +252,8 @@ rustix = { version = "0.38.4", default-features = false, features = [
 sctk = { package = "smithay-client-toolkit", version = "0.18.0", default-features = false, features = [
     "calloop",
 ], optional = true }
-sctk-adwaita = { version = "0.9.0", default-features = false, optional = true }
-wayland-backend = { version = "0.3.0", default-features = false, features = [
+sctk-adwaita = { version = "0.9.0", default_features = false, optional = true }
+wayland-backend = { version = "0.3.0", default_features = false, features = [
     "client_system",
 ], optional = true }
 wayland-client = { version = "0.31.1", optional = true }
@@ -267,14 +274,14 @@ x11rb = { version = "0.13.0", default-features = false, features = [
 ], optional = true }
 xkbcommon-dl = "0.4.2"
 
-# Orbital
 [target.'cfg(target_os = "redox")'.dependencies]
 orbclient = { version = "0.3.47", default-features = false }
 redox_syscall = "0.4.1"
 
-# Web
-[target.'cfg(target_family = "wasm")'.dependencies]
-web_sys = { package = "web-sys", version = "0.3.64", features = [
+[target.'cfg(target_family = "wasm")'.dependencies.web_sys]
+package = "web-sys"
+version = "0.3.64"
+features = [
     'AbortController',
     'AbortSignal',
     'Blob',
@@ -316,7 +323,9 @@ web_sys = { package = "web-sys", version = "0.3.64", features = [
     'WheelEvent',
     'Worker',
     'Url',
-] }
+]
+
+[target.'cfg(target_family = "wasm")'.dependencies]
 js-sys = "0.3.64"
 pin-project = "1"
 wasm-bindgen = "0.2"
@@ -340,7 +349,7 @@ resolver = "2"
 members = ["dpi"]
 
 [workspace.package]
-rust-version = "1.73"
+rust-version = "1.70.0"
 repository = "https://github.com/rust-windowing/winit"
 license = "Apache-2.0"
 edition = "2021"

FEATURES.md

@@ -154,6 +154,7 @@ If your PR makes notable changes to Winit's features, please update this section
 * Home indicator visibility
 * Status bar visibility and style
 * Deferring system gestures
+* Getting the device idiom
 * Getting the preferred video mode
 
 ### Web

README.md

@@ -35,7 +35,7 @@ another library.
 
 ## MSRV Policy
 
-This crate's Minimum Supported Rust Version (MSRV) is **1.73**. Changes to
+This crate's Minimum Supported Rust Version (MSRV) is **1.70**. Changes to
 the MSRV will be accompanied by a minor version bump.
 
 As a **tentative** policy, the upper bound of the MSRV is given by the following

build.rs

@@ -10,9 +10,10 @@ fn main() {
         android_platform: { target_os = "android" },
         web_platform: { all(target_family = "wasm", target_os = "unknown") },
         macos_platform: { target_os = "macos" },
-        ios_platform: { all(target_vendor = "apple", not(target_os = "macos")) },
+        ios_platform: { target_os = "ios" },
         windows_platform: { target_os = "windows" },
-        free_unix: { all(unix, not(target_vendor = "apple"), not(android_platform), not(target_os = "emscripten")) },
+        apple: { any(target_os = "ios", target_os = "macos") },
+        free_unix: { all(unix, not(apple), not(android_platform), not(target_os = "emscripten")) },
         redox: { target_os = "redox" },
 
         // Native displays.

clippy.toml

@@ -12,6 +12,4 @@ disallowed-methods = [
     { path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },
     { path = "objc2_app_kit::NSView::visibleRect", reason = "We expose a render target to the user, and visibility is not really relevant to that (and can break if you don't use the rectangle position as well). Use `frame` instead." },
     { path = "objc2_app_kit::NSWindow::setFrameTopLeftPoint", reason = "Not sufficient when working with Winit's coordinate system, use `flip_window_screen_coordinates` instead" },
-    { path = "core_foundation::runloop::kCFRunLoopCommonModes", reason = "Using the common modes includes the modal panel mode, which we usually want to avoid" },
-    { path = "objc2_foundation::NSRunLoopCommonModes", reason = "Using the common modes includes the modal panel mode, which we usually want to avoid" }
 ]

examples/child_window.rs

@@ -3,75 +3,15 @@
 fn main() -> Result<(), impl std::error::Error> {
     use std::collections::HashMap;
 
-    use winit::application::ApplicationHandler;
     use winit::dpi::{LogicalPosition, LogicalSize, Position};
-    use winit::event::{ElementState, KeyEvent, WindowEvent};
+    use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
     use winit::event_loop::{ActiveEventLoop, EventLoop};
     use winit::raw_window_handle::HasRawWindowHandle;
-    use winit::window::{Window, WindowId};
+    use winit::window::Window;
 
     #[path = "util/fill.rs"]
     mod fill;
 
-    #[derive(Default)]
-    struct Application {
-        parent_window_id: Option<WindowId>,
-        windows: HashMap<WindowId, Window>,
-    }
-
-    impl ApplicationHandler for Application {
-        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-            let attributes = Window::default_attributes()
-                .with_title("parent window")
-                .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
-                .with_inner_size(LogicalSize::new(640.0f32, 480.0f32));
-            let window = event_loop.create_window(attributes).unwrap();
-
-            println!("Parent window id: {:?})", window.id());
-            self.parent_window_id = Some(window.id());
-
-            self.windows.insert(window.id(), window);
-        }
-
-        fn window_event(
-            &mut self,
-            event_loop: &ActiveEventLoop,
-            window_id: winit::window::WindowId,
-            event: WindowEvent,
-        ) {
-            match event {
-                WindowEvent::CloseRequested => {
-                    self.windows.clear();
-                    event_loop.exit();
-                },
-                WindowEvent::CursorEntered { device_id: _ } => {
-                    // On x11, println when the cursor entered in a window even if the child window
-                    // is created by some key inputs.
-                    // the child windows are always placed at (0, 0) with size (200, 200) in the
-                    // parent window, so we also can see this log when we move
-                    // the cursor around (200, 200) in parent window.
-                    println!("cursor entered in the window {window_id:?}");
-                },
-                WindowEvent::KeyboardInput {
-                    event: KeyEvent { state: ElementState::Pressed, .. },
-                    ..
-                } => {
-                    let parent_window = self.windows.get(&self.parent_window_id.unwrap()).unwrap();
-                    let child_window = spawn_child_window(parent_window, event_loop);
-                    let child_id = child_window.id();
-                    println!("Child window created with id: {child_id:?}");
-                    self.windows.insert(child_id, child_window);
-                },
-                WindowEvent::RedrawRequested => {
-                    if let Some(window) = self.windows.get(&window_id) {
-                        fill::fill_window(window);
-                    }
-                },
-                _ => (),
-            }
-        }
-    }
-
     fn spawn_child_window(parent: &Window, event_loop: &ActiveEventLoop) -> Window {
         let parent = parent.raw_window_handle().unwrap();
         let mut window_attributes = Window::default_attributes()
@@ -85,9 +25,58 @@ fn main() -> Result<(), impl std::error::Error> {
         event_loop.create_window(window_attributes).unwrap()
     }
 
-    let event_loop = EventLoop::new().unwrap();
-    let mut app = Application::default();
-    event_loop.run_app(&mut app)
+    let mut windows = HashMap::new();
+
+    let event_loop: EventLoop<()> = EventLoop::new().unwrap();
+    let mut parent_window_id = None;
+
+    event_loop.run(move |event: Event<()>, event_loop| {
+        match event {
+            Event::Resumed => {
+                let attributes = Window::default_attributes()
+                    .with_title("parent window")
+                    .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
+                    .with_inner_size(LogicalSize::new(640.0f32, 480.0f32));
+                let window = event_loop.create_window(attributes).unwrap();
+
+                parent_window_id = Some(window.id());
+
+                println!("Parent window id: {parent_window_id:?})");
+                windows.insert(window.id(), window);
+            },
+            Event::WindowEvent { window_id, event } => match event {
+                WindowEvent::CloseRequested => {
+                    windows.clear();
+                    event_loop.exit();
+                },
+                WindowEvent::CursorEntered { device_id: _ } => {
+                    // On x11, println when the cursor entered in a window even if the child window
+                    // is created by some key inputs.
+                    // the child windows are always placed at (0, 0) with size (200, 200) in the
+                    // parent window, so we also can see this log when we move
+                    // the cursor around (200, 200) in parent window.
+                    println!("cursor entered in the window {window_id:?}");
+                },
+                WindowEvent::KeyboardInput {
+                    event: KeyEvent { state: ElementState::Pressed, .. },
+                    ..
+                } => {
+                    let parent_window = windows.get(&parent_window_id.unwrap()).unwrap();
+                    let child_window = spawn_child_window(parent_window, event_loop);
+                    let child_id = child_window.id();
+                    println!("Child window created with id: {child_id:?}");
+                    windows.insert(child_id, child_window);
+                },
+                WindowEvent::RedrawRequested => {
+                    if let Some(window) = windows.get(&window_id) {
+                        fill::fill_window(window);
+                    }
+                },
+                _ => (),
+            },
+            _ => (),
+        }
+    })
 }
 
 #[cfg(all(feature = "rwh_06", not(any(x11_platform, macos_platform, windows_platform))))]

examples/window.rs

@@ -44,7 +44,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     tracing::init();
 
-    let event_loop = EventLoop::new()?;
+    let event_loop = EventLoop::<UserEvent>::with_user_event().build()?;
     let _event_loop_proxy = event_loop.create_proxy();
 
     // Wire the user event from another thread.
@@ -54,7 +54,7 @@ fn main() -> Result<(), Box<dyn Error>> {
         // from a different thread.
         info!("Starting to send user event every second");
         loop {
-            _event_loop_proxy.wake_up();
+            let _ = _event_loop_proxy.send_event(UserEvent::WakeUp);
             std::thread::sleep(std::time::Duration::from_secs(1));
         }
     });
@@ -64,6 +64,12 @@ fn main() -> Result<(), Box<dyn Error>> {
     event_loop.run_app(&mut state).map_err(Into::into)
 }
 
+#[allow(dead_code)]
+#[derive(Debug, Clone, Copy)]
+enum UserEvent {
+    WakeUp,
+}
+
 /// Application state and event handling.
 struct Application {
     /// Custom cursors assets.
@@ -79,7 +85,7 @@ struct Application {
 }
 
 impl Application {
-    fn new(event_loop: &EventLoop) -> Self {
+    fn new<T>(event_loop: &EventLoop<T>) -> Self {
         // SAFETY: we drop the context right before the event loop is stopped, thus making it safe.
         #[cfg(not(any(android_platform, ios_platform)))]
         let context = Some(
@@ -302,9 +308,9 @@ impl Application {
     }
 }
 
-impl ApplicationHandler for Application {
-    fn proxy_wake_up(&mut self, _event_loop: &ActiveEventLoop) {
-        info!("User wake up");
+impl ApplicationHandler<UserEvent> for Application {
+    fn user_event(&mut self, _event_loop: &ActiveEventLoop, event: UserEvent) {
+        info!("User event: {event:?}");
     }
 
     fn window_event(

src/application.rs

@@ -5,7 +5,7 @@ use crate::event_loop::ActiveEventLoop;
 use crate::window::WindowId;
 
 /// The handler of the application events.
-pub trait ApplicationHandler {
+pub trait ApplicationHandler<T: 'static = ()> {
     /// Emitted when new events arrive from the OS to be processed.
     ///
     /// This is a useful place to put code that should be done before you start processing
@@ -82,95 +82,11 @@ pub trait ApplicationHandler {
     /// [`Suspended`]: Self::suspended
     fn resumed(&mut self, event_loop: &ActiveEventLoop);
 
-    /// Called after a wake up is requested using [`EventLoopProxy::wake_up()`].
+    /// Emitted when an event is sent from [`EventLoopProxy::send_event`].
     ///
-    /// Multiple calls to the aforementioned method will be merged, and will only wake the event
-    /// loop once; however, due to the nature of multi-threading some wake ups may appear
-    /// spuriously. For these reasons, you should not rely on the number of times that this was
-    /// called.
-    ///
-    /// The order in which this is emitted in relation to other events is not guaranteed. The time
-    /// at which this will be emitted is not guaranteed, only that it will happen "soon". That is,
-    /// there may be several executions of the event loop, including multiple redraws to windows,
-    /// between [`EventLoopProxy::wake_up()`] being called and the event being delivered.
-    ///
-    /// [`EventLoopProxy::wake_up()`]: crate::event_loop::EventLoopProxy::wake_up
-    ///
-    /// # Example
-    ///
-    /// Use a [`std::sync::mpsc`] channel to handle events from a different thread.
-    ///
-    /// ```no_run
-    /// use std::sync::mpsc;
-    /// use std::thread;
-    /// use std::time::Duration;
-    ///
-    /// use winit::application::ApplicationHandler;
-    /// use winit::event_loop::{ActiveEventLoop, EventLoop};
-    ///
-    /// struct MyApp {
-    ///     receiver: mpsc::Receiver<u64>,
-    /// }
-    ///
-    /// impl ApplicationHandler for MyApp {
-    ///     # fn window_event(
-    ///     #     &mut self,
-    ///     #     _event_loop: &ActiveEventLoop,
-    ///     #     _window_id: winit::window::WindowId,
-    ///     #     _event: winit::event::WindowEvent,
-    ///     # ) {
-    ///     # }
-    ///     #
-    ///     # fn resumed(&mut self, _event_loop: &ActiveEventLoop) {}
-    ///     #
-    ///     fn proxy_wake_up(&mut self, _event_loop: &ActiveEventLoop) {
-    ///         // Iterate current events, since wake-ups may have been merged.
-    ///         //
-    ///         // Note: We take care not to use `recv` or `iter` here, as those are blocking,
-    ///         // and that would be bad for performance and might lead to a deadlock.
-    ///         for i in self.receiver.try_iter() {
-    ///             println!("received: {i}");
-    ///         }
-    ///     }
-    ///
-    ///     // Rest of `ApplicationHandler`
-    /// }
-    ///
-    /// fn main() -> Result<(), Box<dyn std::error::Error>> {
-    ///     let event_loop = EventLoop::new()?;
-    ///
-    ///     let (sender, receiver) = mpsc::channel();
-    ///
-    ///     let mut app = MyApp { receiver };
-    ///
-    ///     // Send an event in a loop
-    ///     let proxy = event_loop.create_proxy();
-    ///     let background_thread = thread::spawn(move || {
-    ///         let mut i = 0;
-    ///         loop {
-    ///             println!("sending: {i}");
-    ///             if sender.send(i).is_err() {
-    ///                 // Stop sending once `MyApp` is dropped
-    ///                 break;
-    ///             }
-    ///             // Trigger the wake-up _after_ we placed the event in the channel.
-    ///             // Otherwise, `proxy_wake_up` might be triggered prematurely.
-    ///             proxy.wake_up();
-    ///             i += 1;
-    ///             thread::sleep(Duration::from_secs(1));
-    ///         }
-    ///     });
-    ///
-    ///     event_loop.run_app(&mut app)?;
-    ///
-    ///     drop(app);
-    ///     background_thread.join().unwrap();
-    ///
-    ///     Ok(())
-    /// }
-    /// ```
-    fn proxy_wake_up(&mut self, event_loop: &ActiveEventLoop) {
-        let _ = event_loop;
+    /// [`EventLoopProxy::send_event`]: crate::event_loop::EventLoopProxy::send_event
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T) {
+        let _ = (event_loop, event);
     }
 
     /// Emitted when the OS sends an event to a winit window.
@@ -308,7 +224,7 @@ pub trait ApplicationHandler {
     }
 }
 
-impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
+impl<A: ?Sized + ApplicationHandler<T>, T: 'static> ApplicationHandler<T> for &mut A {
     #[inline]
     fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
         (**self).new_events(event_loop, cause);
@@ -320,8 +236,8 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
     }
 
     #[inline]
-    fn proxy_wake_up(&mut self, event_loop: &ActiveEventLoop) {
-        (**self).proxy_wake_up(event_loop);
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T) {
+        (**self).user_event(event_loop, event);
     }
 
     #[inline]
@@ -365,7 +281,7 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
     }
 }
 
-impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
+impl<A: ?Sized + ApplicationHandler<T>, T: 'static> ApplicationHandler<T> for Box<A> {
     #[inline]
     fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
         (**self).new_events(event_loop, cause);
@@ -377,8 +293,8 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
     }
 
     #[inline]
-    fn proxy_wake_up(&mut self, event_loop: &ActiveEventLoop) {
-        (**self).proxy_wake_up(event_loop);
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T) {
+        (**self).user_event(event_loop, event);
     }
 
     #[inline]

src/changelog/unreleased.md

@@ -39,27 +39,3 @@ The migration guide could reference other migration examples in the current
 changelog entry.
 
 ## Unreleased
-
-### Changed
-
-- On Web, let events wake up event loop immediately when using `ControlFlow::Poll`.
-- Bump MSRV from `1.70` to `1.73`.
-- Changed `ApplicationHandler::user_event` to `user_wake_up`, removing the
-  generic user event.
-
-  Winit will now only indicate that wake up happened, you will have to pair
-  this with an external mechanism like `std::sync::mpsc::channel` if you want
-  to send specific data to be processed on the main thread.
-- Changed `EventLoopProxy::send_event` to `EventLoopProxy::wake_up`, it now
-  only wakes up the loop.
-
-### Removed
-
-- Remove `EventLoop::run`.
-- Remove `EventLoopExtRunOnDemand::run_on_demand`.
-- Remove `EventLoopExtPumpEvents::pump_events`.
-- Remove `Event`.
-- On iOS, remove `platform::ios::EventLoopExtIOS` and related `platform::ios::Idiom` type.
-
-  This feature was incomplete, and the equivalent functionality can be trivially achieved outside
-  of `winit` using `objc2-ui-kit` and calling `UIDevice::currentDevice().userInterfaceIdiom()`.

src/changelog/v0.30.md

@@ -35,7 +35,6 @@
 
 - Reexport `raw-window-handle` versions 0.4 and 0.5 as `raw_window_handle_04` and `raw_window_handle_05`.
 - Implement `ApplicationHandler` for `&mut` references and heap allocations to something that implements `ApplicationHandler`.
-- Add traits `EventLoopExtWayland` and `EventLoopExtX11`, providing methods `is_wayland` and `is_x11` on `EventLoop`.
 
 ### Fixed
 
@@ -112,7 +111,7 @@
   `Fn`. The semantics are mostly the same, given that the capture list of the
   closure is your new `State`. Consider the following code:
 
-  ```rust,no_run,ignore
+  ```rust,no_run
   use winit::event::Event;
   use winit::event_loop::EventLoop;
   use winit::window::Window;
@@ -148,7 +147,7 @@
   we move particular `match event` arms into methods on `ApplicationHandler`,
   for example:
 
-  ```rust,no_run,ignore
+  ```rust,no_run
   use winit::application::ApplicationHandler;
   use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
   use winit::event_loop::{EventLoop, ActiveEventLoop};
@@ -211,7 +210,7 @@
 
   Using the migration example from above, you can change your code as follows:
 
-  ```rust,no_run,ignore
+  ```rust,no_run
   use winit::application::ApplicationHandler;
   use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
   use winit::event_loop::{EventLoop, ActiveEventLoop};

src/event.rs

@@ -1,4 +1,4 @@
-//! The event enums and assorted supporting types.
+//! The [`Event`] enum and assorted supporting types.
 //!
 //! These are sent to the closure given to [`EventLoop::run_app(...)`], where they get
 //! processed and used to modify the program state. For more details, see the root-level
@@ -54,15 +54,11 @@ use crate::platform_impl;
 use crate::window::Window;
 use crate::window::{ActivationToken, Theme, WindowId};
 
-// TODO: Remove once the backends can call `ApplicationHandler` methods directly. For now backends
-// like Windows and Web require `Event` to wire user events, otherwise each backend will have to
-// wrap `Event` in some other structure.
 /// Describes a generic event.
 ///
 /// See the module-level docs for more information on the event loop manages each event.
-#[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq)]
-pub(crate) enum Event {
+pub enum Event<T: 'static> {
     /// See [`ApplicationHandler::new_events`] for details.
     ///
     /// [`ApplicationHandler::new_events`]: crate::application::ApplicationHandler::new_events
@@ -71,15 +67,18 @@ pub(crate) enum Event {
     /// See [`ApplicationHandler::window_event`] for details.
     ///
     /// [`ApplicationHandler::window_event`]: crate::application::ApplicationHandler::window_event
-    #[allow(clippy::enum_variant_names)]
     WindowEvent { window_id: WindowId, event: WindowEvent },
 
     /// See [`ApplicationHandler::device_event`] for details.
     ///
     /// [`ApplicationHandler::device_event`]: crate::application::ApplicationHandler::device_event
-    #[allow(clippy::enum_variant_names)]
     DeviceEvent { device_id: DeviceId, event: DeviceEvent },
 
+    /// See [`ApplicationHandler::user_event`] for details.
+    ///
+    /// [`ApplicationHandler::user_event`]: crate::application::ApplicationHandler::user_event
+    UserEvent(T),
+
     /// See [`ApplicationHandler::suspended`] for details.
     ///
     /// [`ApplicationHandler::suspended`]: crate::application::ApplicationHandler::suspended
@@ -104,9 +103,24 @@ pub(crate) enum Event {
     ///
     /// [`ApplicationHandler::memory_warning`]: crate::application::ApplicationHandler::memory_warning
     MemoryWarning,
+}
 
-    /// User requested a wake up.
-    UserWakeUp,
+impl<T> Event<T> {
+    #[allow(clippy::result_large_err)]
+    pub fn map_nonuser_event<U>(self) -> Result<Event<U>, Event<T>> {
+        use self::Event::*;
+        match self {
+            UserEvent(_) => Err(self),
+            WindowEvent { window_id, event } => Ok(WindowEvent { window_id, event }),
+            DeviceEvent { device_id, event } => Ok(DeviceEvent { device_id, event }),
+            NewEvents(cause) => Ok(NewEvents(cause)),
+            AboutToWait => Ok(AboutToWait),
+            LoopExiting => Ok(LoopExiting),
+            Suspended => Ok(Suspended),
+            Resumed => Ok(Resumed),
+            MemoryWarning => Ok(MemoryWarning),
+        }
+    }
 }
 
 /// Describes the reason the event loop is resuming.
@@ -1018,6 +1032,7 @@ mod tests {
 
                 // Mainline events.
                 let wid = unsafe { WindowId::dummy() };
+                x(UserEvent(()));
                 x(NewEvents(event::StartCause::Init));
                 x(AboutToWait);
                 x(LoopExiting);
@@ -1101,12 +1116,25 @@ mod tests {
     #[allow(clippy::redundant_clone)]
     #[test]
     fn test_event_clone() {
-        foreach_event!(|event: event::Event| {
+        foreach_event!(|event: event::Event<()>| {
             let event2 = event.clone();
             assert_eq!(event, event2);
         })
     }
 
+    #[test]
+    fn test_map_nonuser_event() {
+        foreach_event!(|event: event::Event<()>| {
+            let is_user = matches!(event, event::Event::UserEvent(()));
+            let event2 = event.map_nonuser_event::<()>();
+            if is_user {
+                assert_eq!(event2, Err(event::Event::UserEvent(())));
+            } else {
+                assert!(event2.is_ok());
+            }
+        })
+    }
+
     #[test]
     fn test_force_normalize() {
         let force = event::Force::Normalized(0.0);
@@ -1127,7 +1155,7 @@ mod tests {
     #[allow(clippy::clone_on_copy)]
     #[test]
     fn ensure_attrs_do_not_panic() {
-        foreach_event!(|event: event::Event| {
+        foreach_event!(|event: event::Event<()>| {
             let _ = format!("{:?}", event);
         });
         let _ = event::StartCause::Init.clone();

src/event_loop.rs

@@ -3,16 +3,15 @@
 //!
 //! If you want to send custom events to the event loop, use
 //! [`EventLoop::create_proxy`] to acquire an [`EventLoopProxy`] and call its
-//! [`wake_up`][EventLoopProxy::wake_up] method. Then during handling the wake up
-//! you can poll your event sources.
+//! [`send_event`][EventLoopProxy::send_event] method.
 //!
 //! See the root-level documentation for information on how to create and use an event loop to
 //! handle events.
-use std::fmt;
 use std::marker::PhantomData;
 #[cfg(any(x11_platform, wayland_platform))]
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::{error, fmt};
 
 #[cfg(not(web_platform))]
 use std::time::{Duration, Instant};
@@ -21,6 +20,7 @@ use web_time::{Duration, Instant};
 
 use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, OsError};
+use crate::event::Event;
 use crate::monitor::MonitorHandle;
 use crate::platform_impl;
 use crate::window::{CustomCursor, CustomCursorSource, Window, WindowAttributes};
@@ -40,8 +40,8 @@ use crate::window::{CustomCursor, CustomCursorSource, Window, WindowAttributes};
 /// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread.
 ///
 /// [`Window`]: crate::window::Window
-pub struct EventLoop {
-    pub(crate) event_loop: platform_impl::EventLoop,
+pub struct EventLoop<T: 'static> {
+    pub(crate) event_loop: platform_impl::EventLoop<T>,
     pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
 }
 
@@ -59,15 +59,16 @@ pub struct ActiveEventLoop {
 /// This is used to make specifying options that affect the whole application
 /// easier. But note that constructing multiple event loops is not supported.
 ///
-/// This can be created using [`EventLoop::builder`].
+/// This can be created using [`EventLoop::new`] or [`EventLoop::with_user_event`].
 #[derive(Default)]
-pub struct EventLoopBuilder {
+pub struct EventLoopBuilder<T: 'static> {
     pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
+    _p: PhantomData<T>,
 }
 
 static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
 
-impl EventLoopBuilder {
+impl EventLoopBuilder<()> {
     /// Start building a new event loop.
     #[inline]
     #[deprecated = "use `EventLoop::builder` instead"]
@@ -76,7 +77,7 @@ impl EventLoopBuilder {
     }
 }
 
-impl EventLoopBuilder {
+impl<T> EventLoopBuilder<T> {
     /// Builds a new event loop.
     ///
     /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
@@ -111,7 +112,7 @@ impl EventLoopBuilder {
         doc = "[`.with_android_app(app)`]: #only-available-on-android"
     )]
     #[inline]
-    pub fn build(&mut self) -> Result<EventLoop, EventLoopError> {
+    pub fn build(&mut self) -> Result<EventLoop<T>, EventLoopError> {
         let _span = tracing::debug_span!("winit::EventLoopBuilder::build").entered();
 
         if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
@@ -132,7 +133,7 @@ impl EventLoopBuilder {
     }
 }
 
-impl fmt::Debug for EventLoop {
+impl<T> fmt::Debug for EventLoop<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("EventLoop { .. }")
     }
@@ -146,12 +147,11 @@ impl fmt::Debug for ActiveEventLoop {
 
 /// Set through [`ActiveEventLoop::set_control_flow()`].
 ///
-/// Indicates the desired behavior of the event loop after [`about_to_wait`] is called.
+/// Indicates the desired behavior of the event loop after [`Event::AboutToWait`] is emitted.
 ///
 /// Defaults to [`Wait`].
 ///
 /// [`Wait`]: Self::Wait
-/// [`about_to_wait`]: crate::application::ApplicationHandler::about_to_wait
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 pub enum ControlFlow {
     /// When the current loop iteration finishes, immediately begin a new iteration regardless of
@@ -189,12 +189,12 @@ impl ControlFlow {
     }
 }
 
-impl EventLoop {
+impl EventLoop<()> {
     /// Create the event loop.
     ///
     /// This is an alias of `EventLoop::builder().build()`.
     #[inline]
-    pub fn new() -> Result<EventLoop, EventLoopError> {
+    pub fn new() -> Result<EventLoop<()>, EventLoopError> {
         Self::builder().build()
     }
 
@@ -204,12 +204,33 @@ impl EventLoop {
     ///
     /// To get the actual event loop, call [`build`][EventLoopBuilder::build] on that.
     #[inline]
-    pub fn builder() -> EventLoopBuilder {
-        EventLoopBuilder { platform_specific: Default::default() }
+    pub fn builder() -> EventLoopBuilder<()> {
+        Self::with_user_event()
     }
 }
 
-impl EventLoop {
+impl<T> EventLoop<T> {
+    /// Start building a new event loop, with the given type as the user event
+    /// type.
+    pub fn with_user_event() -> EventLoopBuilder<T> {
+        EventLoopBuilder { platform_specific: Default::default(), _p: PhantomData }
+    }
+
+    /// See [`run_app`].
+    ///
+    /// [`run_app`]: Self::run_app
+    #[inline]
+    #[deprecated = "use `EventLoop::run_app` instead"]
+    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
+    pub fn run<F>(self, event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<T>, &ActiveEventLoop),
+    {
+        let _span = tracing::debug_span!("winit::EventLoop::run").entered();
+
+        self.event_loop.run(event_handler)
+    }
+
     /// Run the application with the event loop on the calling thread.
     ///
     /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
@@ -240,13 +261,13 @@ impl EventLoop {
     /// [^1]: `EventLoopExtWebSys::spawn_app()` is only available on Web.
     #[inline]
     #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
-    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> Result<(), EventLoopError> {
-        self.event_loop.run_app(app)
+    pub fn run_app<A: ApplicationHandler<T>>(self, app: &mut A) -> Result<(), EventLoopError> {
+        self.event_loop.run(|event, event_loop| dispatch_event_for_app(app, event_loop, event))
     }
 
     /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
     /// to the main event loop, possibly from another thread.
-    pub fn create_proxy(&self) -> EventLoopProxy {
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
         EventLoopProxy { event_loop_proxy: self.event_loop.create_proxy() }
     }
 
@@ -302,14 +323,14 @@ impl EventLoop {
 }
 
 #[cfg(feature = "rwh_06")]
-impl rwh_06::HasDisplayHandle for EventLoop {
+impl<T> rwh_06::HasDisplayHandle for EventLoop<T> {
     fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
         rwh_06::HasDisplayHandle::display_handle(self.event_loop.window_target())
     }
 }
 
 #[cfg(feature = "rwh_05")]
-unsafe impl rwh_05::HasRawDisplayHandle for EventLoop {
+unsafe impl<T> rwh_05::HasRawDisplayHandle for EventLoop<T> {
     /// Returns a [`rwh_05::RawDisplayHandle`] for the event loop.
     fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
         rwh_05::HasRawDisplayHandle::raw_display_handle(self.event_loop.window_target())
@@ -317,7 +338,7 @@ unsafe impl rwh_05::HasRawDisplayHandle for EventLoop {
 }
 
 #[cfg(any(x11_platform, wayland_platform))]
-impl AsFd for EventLoop {
+impl<T> AsFd for EventLoop<T> {
     /// Get the underlying [EventLoop]'s `fd` which you can register
     /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
     /// loop must be polled with the [`pump_app_events`] API.
@@ -331,7 +352,7 @@ impl AsFd for EventLoop {
 }
 
 #[cfg(any(x11_platform, wayland_platform))]
-impl AsRawFd for EventLoop {
+impl<T> AsRawFd for EventLoop<T> {
     /// Get the underlying [EventLoop]'s raw `fd` which you can register
     /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
     /// loop must be polled with the [`pump_app_events`] API.
@@ -428,7 +449,7 @@ impl ActiveEventLoop {
 
     /// This exits the event loop.
     ///
-    /// See [`exiting`][crate::application::ApplicationHandler::exiting].
+    /// See [`LoopExiting`][Event::LoopExiting].
     pub fn exit(&self) {
         let _span = tracing::debug_span!("winit::ActiveEventLoop::exit",).entered();
 
@@ -513,39 +534,53 @@ unsafe impl rwh_05::HasRawDisplayHandle for OwnedDisplayHandle {
     }
 }
 
-/// Control the [`EventLoop`], possibly from a different thread, without referencing it directly.
-#[derive(Clone)]
-pub struct EventLoopProxy {
-    event_loop_proxy: platform_impl::EventLoopProxy,
+/// Used to send custom events to [`EventLoop`].
+pub struct EventLoopProxy<T: 'static> {
+    event_loop_proxy: platform_impl::EventLoopProxy<T>,
 }
 
-impl EventLoopProxy {
-    /// Wake up the [`EventLoop`], resulting in [`ApplicationHandler::proxy_wake_up()`] being
-    /// called.
-    ///
-    /// Calls to this method are coalesced into a single call to [`proxy_wake_up`], see the
-    /// documentation on that for details.
-    ///
-    /// If the event loop is no longer running, this is a no-op.
-    ///
-    /// [`proxy_wake_up`]: ApplicationHandler::proxy_wake_up
-    ///
-    /// # Platform-specific
-    ///
-    /// - **Windows**: The wake-up may be ignored under high contention, see [#3687].
-    ///
-    /// [#3687]: https://github.com/rust-windowing/winit/pull/3687
-    pub fn wake_up(&self) {
-        self.event_loop_proxy.wake_up();
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        Self { event_loop_proxy: self.event_loop_proxy.clone() }
     }
 }
 
-impl fmt::Debug for EventLoopProxy {
+impl<T: 'static> EventLoopProxy<T> {
+    /// Send an event to the [`EventLoop`] from which this proxy was created. This emits a
+    /// `UserEvent(event)` event in the event loop, where `event` is the value passed to this
+    /// function.
+    ///
+    /// Returns an `Err` if the associated [`EventLoop`] no longer exists.
+    ///
+    /// [`UserEvent(event)`]: Event::UserEvent
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        let _span = tracing::debug_span!("winit::EventLoopProxy::send_event",).entered();
+
+        self.event_loop_proxy.send_event(event)
+    }
+}
+
+impl<T: 'static> fmt::Debug for EventLoopProxy<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("EventLoopProxy { .. }")
     }
 }
 
+/// The error that is returned when an [`EventLoopProxy`] attempts to wake up an [`EventLoop`] that
+/// no longer exists.
+///
+/// Contains the original event given to [`EventLoopProxy::send_event`].
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventLoopClosed<T>(pub T);
+
+impl<T> fmt::Display for EventLoopClosed<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("Tried to wake up a closed `EventLoop`")
+    }
+}
+
+impl<T: fmt::Debug> error::Error for EventLoopClosed<T> {}
+
 /// Control when device events are captured.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
 pub enum DeviceEvents {
@@ -583,3 +618,23 @@ impl AsyncRequestSerial {
         Self { serial }
     }
 }
+
+/// Shim for various run APIs.
+#[inline(always)]
+pub(crate) fn dispatch_event_for_app<T: 'static, A: ApplicationHandler<T>>(
+    app: &mut A,
+    event_loop: &ActiveEventLoop,
+    event: Event<T>,
+) {
+    match event {
+        Event::NewEvents(cause) => app.new_events(event_loop, cause),
+        Event::WindowEvent { window_id, event } => app.window_event(event_loop, window_id, event),
+        Event::DeviceEvent { device_id, event } => app.device_event(event_loop, device_id, event),
+        Event::UserEvent(event) => app.user_event(event_loop, event),
+        Event::Suspended => app.suspended(event_loop),
+        Event::Resumed => app.resumed(event_loop),
+        Event::AboutToWait => app.about_to_wait(event_loop),
+        Event::LoopExiting => app.exiting(event_loop),
+        Event::MemoryWarning => app.memory_warning(event_loop),
+    }
+}

src/lib.rs

@@ -19,11 +19,12 @@
 //! window or a key getting pressed while the window is focused. Devices can generate
 //! [`DeviceEvent`]s, which contain unfiltered event data that isn't specific to a certain window.
 //! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
-//! [`DeviceEvent`].
+//! [`DeviceEvent`]. You can also create and handle your own custom [`Event::UserEvent`]s, if
+//! desired.
 //!
 //! You can retrieve events by calling [`EventLoop::run_app()`]. This function will
 //! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
-//! will run until [`exit()`] is used, at which point [`exiting()`] is called.
+//! will run until [`exit()`] is used, at which point [`Event::LoopExiting`].
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
 //! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works
@@ -162,7 +163,7 @@
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
 //! [`Event::UserEvent`]: event::Event::UserEvent
-//! [`exiting()`]: crate::application::ApplicationHandler::exiting
+//! [`Event::LoopExiting`]: event::Event::LoopExiting
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 //! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
 //! [^1]: `EventLoopExtPumpEvents::pump_app_events()` is only available on Windows, macOS, Android, X11 and Wayland.

src/platform/android.rs

@@ -78,7 +78,7 @@ use self::activity::{AndroidApp, ConfigurationRef, Rect};
 /// Additional methods on [`EventLoop`] that are specific to Android.
 pub trait EventLoopExtAndroid {}
 
-impl EventLoopExtAndroid for EventLoop {}
+impl<T> EventLoopExtAndroid for EventLoop<T> {}
 
 /// Additional methods on [`ActiveEventLoop`] that are specific to Android.
 pub trait ActiveEventLoopExtAndroid {}
@@ -119,7 +119,7 @@ pub trait EventLoopBuilderExtAndroid {
     fn handle_volume_keys(&mut self) -> &mut Self;
 }
 
-impl EventLoopBuilderExtAndroid for EventLoopBuilder {
+impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
     fn with_android_app(&mut self, app: AndroidApp) -> &mut Self {
         self.platform_specific.android_app = Some(app);
         self

src/platform/ios.rs

@@ -66,9 +66,22 @@
 
 use std::os::raw::c_void;
 
+use crate::event_loop::EventLoop;
 use crate::monitor::{MonitorHandle, VideoModeHandle};
 use crate::window::{Window, WindowAttributes};
 
+/// Additional methods on [`EventLoop`] that are specific to iOS.
+pub trait EventLoopExtIOS {
+    /// Returns the [`Idiom`] (phone/tablet/tv/etc) for the current device.
+    fn idiom(&self) -> Idiom;
+}
+
+impl<T: 'static> EventLoopExtIOS for EventLoop<T> {
+    fn idiom(&self) -> Idiom {
+        self.event_loop.idiom()
+    }
+}
+
 /// Additional methods on [`Window`] that are specific to iOS.
 pub trait WindowExtIOS {
     /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
@@ -366,6 +379,24 @@ pub enum ValidOrientations {
     Portrait,
 }
 
+/// The device [idiom].
+///
+/// [idiom]: https://developer.apple.com/documentation/uikit/uidevice/1620037-userinterfaceidiom?language=objc
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Idiom {
+    Unspecified,
+
+    /// iPhone and iPod touch.
+    Phone,
+
+    /// iPad.
+    Pad,
+
+    /// tvOS and Apple TV.
+    TV,
+    CarPlay,
+}
+
 bitflags::bitflags! {
     /// The [edges] of a screen.
     ///

src/platform/macos.rs

@@ -338,7 +338,7 @@ pub trait EventLoopBuilderExtMacOS {
     fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self;
 }
 
-impl EventLoopBuilderExtMacOS for EventLoopBuilder {
+impl<T> EventLoopBuilderExtMacOS for EventLoopBuilder<T> {
     #[inline]
     fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self {
         self.platform_specific.activation_policy = activation_policy;

src/platform/pump_events.rs

@@ -1,10 +1,14 @@
 use std::time::Duration;
 
 use crate::application::ApplicationHandler;
-use crate::event_loop::EventLoop;
+use crate::event::Event;
+use crate::event_loop::{self, ActiveEventLoop, EventLoop};
 
 /// Additional methods on [`EventLoop`] for pumping events within an external event loop
 pub trait EventLoopExtPumpEvents {
+    /// A type provided by the user that can be passed through [`Event::UserEvent`].
+    type UserEvent: 'static;
+
     /// Pump the `EventLoop` to check for and dispatch pending events.
     ///
     /// This API is designed to enable applications to integrate Winit into an
@@ -99,20 +103,34 @@ pub trait EventLoopExtPumpEvents {
     ///   If you render outside of Winit you are likely to see window resizing artifacts
     ///   since MacOS expects applications to render synchronously during any `drawRect`
     ///   callback.
-    fn pump_app_events<A: ApplicationHandler>(
-        &mut self,
-        timeout: Option<Duration>,
-        app: &mut A,
-    ) -> PumpStatus;
-}
-
-impl EventLoopExtPumpEvents for EventLoop {
-    fn pump_app_events<A: ApplicationHandler>(
+    fn pump_app_events<A: ApplicationHandler<Self::UserEvent>>(
         &mut self,
         timeout: Option<Duration>,
         app: &mut A,
     ) -> PumpStatus {
-        self.event_loop.pump_app_events(timeout, app)
+        #[allow(deprecated)]
+        self.pump_events(timeout, |event, event_loop| {
+            event_loop::dispatch_event_for_app(app, event_loop, event)
+        })
+    }
+
+    /// See [`pump_app_events`].
+    ///
+    /// [`pump_app_events`]: Self::pump_app_events
+    #[deprecated = "use EventLoopExtPumpEvents::pump_app_events"]
+    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
+    where
+        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
+}
+
+impl<T> EventLoopExtPumpEvents for EventLoop<T> {
+    type UserEvent = T;
+
+    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
+    where
+        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
+    {
+        self.event_loop.pump_events(timeout, event_handler)
     }
 }
 

src/platform/run_on_demand.rs

@@ -1,12 +1,24 @@
 use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
-use crate::event_loop::{ActiveEventLoop, EventLoop};
+use crate::event::Event;
+use crate::event_loop::{self, ActiveEventLoop, EventLoop};
 
 #[cfg(doc)]
 use crate::{platform::pump_events::EventLoopExtPumpEvents, window::Window};
 
 /// Additional methods on [`EventLoop`] to return control flow to the caller.
 pub trait EventLoopExtRunOnDemand {
+    /// A type provided by the user that can be passed through [`Event::UserEvent`].
+    type UserEvent: 'static;
+
+    /// See [`run_app_on_demand`].
+    ///
+    /// [`run_app_on_demand`]: Self::run_app_on_demand
+    #[deprecated = "use EventLoopExtRunOnDemand::run_app_on_demand"]
+    fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
+
     /// Run the application with the event loop on the calling thread.
     ///
     /// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`)
@@ -53,19 +65,26 @@ pub trait EventLoopExtRunOnDemand {
     ///
     /// [`exit()`]: ActiveEventLoop::exit()
     /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
-    fn run_app_on_demand<A: ApplicationHandler>(
-        &mut self,
-        app: &mut A,
-    ) -> Result<(), EventLoopError>;
-}
-
-impl EventLoopExtRunOnDemand for EventLoop {
-    fn run_app_on_demand<A: ApplicationHandler>(
+    fn run_app_on_demand<A: ApplicationHandler<Self::UserEvent>>(
         &mut self,
         app: &mut A,
     ) -> Result<(), EventLoopError> {
+        #[allow(deprecated)]
+        self.run_on_demand(|event, event_loop| {
+            event_loop::dispatch_event_for_app(app, event_loop, event)
+        })
+    }
+}
+
+impl<T> EventLoopExtRunOnDemand for EventLoop<T> {
+    type UserEvent = T;
+
+    fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
+    {
         self.event_loop.window_target().clear_exit();
-        self.event_loop.run_app_on_demand(app)
+        self.event_loop.run_on_demand(event_handler)
     }
 }
 

src/platform/wayland.rs

@@ -38,7 +38,7 @@ pub trait EventLoopExtWayland {
     fn is_wayland(&self) -> bool;
 }
 
-impl EventLoopExtWayland for EventLoop {
+impl<T: 'static> EventLoopExtWayland for EventLoop<T> {
     #[inline]
     fn is_wayland(&self) -> bool {
         self.event_loop.is_wayland()
@@ -57,7 +57,7 @@ pub trait EventLoopBuilderExtWayland {
     fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
 }
 
-impl EventLoopBuilderExtWayland for EventLoopBuilder {
+impl<T> EventLoopBuilderExtWayland for EventLoopBuilder<T> {
     #[inline]
     fn with_wayland(&mut self) -> &mut Self {
         self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::Wayland);

src/platform/web.rs

@@ -55,7 +55,8 @@ use web_sys::HtmlCanvasElement;
 
 use crate::application::ApplicationHandler;
 use crate::cursor::CustomCursorSource;
-use crate::event_loop::{ActiveEventLoop, EventLoop};
+use crate::event::Event;
+use crate::event_loop::{self, ActiveEventLoop, EventLoop};
 #[cfg(web_platform)]
 use crate::platform_impl::CustomCursorFuture as PlatformCustomCursorFuture;
 use crate::platform_impl::PlatformCustomCursorSource;
@@ -155,6 +156,9 @@ impl WindowAttributesExtWebSys for WindowAttributes {
 
 /// Additional methods on `EventLoop` that are specific to the web.
 pub trait EventLoopExtWebSys {
+    /// A type provided by the user that can be passed through `Event::UserEvent`.
+    type UserEvent: 'static;
+
     /// Initializes the winit event loop.
     ///
     /// Unlike
@@ -177,7 +181,15 @@ pub trait EventLoopExtWebSys {
         doc = "[`run_app()`]: EventLoop::run_app()"
     )]
     /// [^1]: `run_app()` is _not_ available on WASM when the target supports `exception-handling`.
-    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A);
+    fn spawn_app<A: ApplicationHandler<Self::UserEvent> + 'static>(self, app: A);
+
+    /// See [`spawn_app`].
+    ///
+    /// [`spawn_app`]: Self::spawn_app
+    #[deprecated = "use EventLoopExtWebSys::spawn_app"]
+    fn spawn<F>(self, event_handler: F)
+    where
+        F: 'static + FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
 
     /// Sets the strategy for [`ControlFlow::Poll`].
     ///
@@ -208,9 +220,20 @@ pub trait EventLoopExtWebSys {
     fn wait_until_strategy(&self) -> WaitUntilStrategy;
 }
 
-impl EventLoopExtWebSys for EventLoop {
-    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A) {
-        self.event_loop.spawn_app(app);
+impl<T> EventLoopExtWebSys for EventLoop<T> {
+    type UserEvent = T;
+
+    fn spawn_app<A: ApplicationHandler<Self::UserEvent> + 'static>(self, mut app: A) {
+        self.event_loop.spawn(move |event, event_loop| {
+            event_loop::dispatch_event_for_app(&mut app, event_loop, event)
+        });
+    }
+
+    fn spawn<F>(self, event_handler: F)
+    where
+        F: 'static + FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
+    {
+        self.event_loop.spawn(event_handler)
     }
 
     fn set_poll_strategy(&self, strategy: PollStrategy) {

src/platform/windows.rs

@@ -227,7 +227,7 @@ pub trait EventLoopBuilderExtWindows {
         F: FnMut(*const c_void) -> bool + 'static;
 }
 
-impl EventLoopBuilderExtWindows for EventLoopBuilder {
+impl<T> EventLoopBuilderExtWindows for EventLoopBuilder<T> {
     #[inline]
     fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
         self.platform_specific.any_thread = any_thread;

src/platform/x11.rs

@@ -105,7 +105,7 @@ pub trait EventLoopExtX11 {
     fn is_x11(&self) -> bool;
 }
 
-impl EventLoopExtX11 for EventLoop {
+impl<T: 'static> EventLoopExtX11 for EventLoop<T> {
     #[inline]
     fn is_x11(&self) -> bool {
         !self.event_loop.is_wayland()
@@ -124,7 +124,7 @@ pub trait EventLoopBuilderExtX11 {
     fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
 }
 
-impl EventLoopBuilderExtX11 for EventLoopBuilder {
+impl<T> EventLoopBuilderExtX11 for EventLoopBuilder<T> {
     #[inline]
     fn with_x11(&mut self) -> &mut Self {
         self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::X);

src/platform_impl/android/mod.rs

@@ -3,7 +3,7 @@ use std::collections::VecDeque;
 use std::hash::Hash;
 use std::marker::PhantomData;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
+use std::sync::{mpsc, Arc, Mutex};
 use std::time::{Duration, Instant};
 
 use android_activity::input::{InputEvent, KeyAction, Keycode, MotionAction};
@@ -12,13 +12,12 @@ use android_activity::{
 };
 use tracing::{debug, trace, warn};
 
-use crate::application::ApplicationHandler;
 use crate::cursor::Cursor;
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error;
 use crate::error::EventLoopError;
 use crate::event::{self, Force, InnerSizeWriter, StartCause};
-use crate::event_loop::{self, ControlFlow, DeviceEvents};
+use crate::event_loop::{self, ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents};
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::Fullscreen;
 use crate::window::{
@@ -42,6 +41,41 @@ fn min_timeout(a: Option<Duration>, b: Option<Duration>) -> Option<Duration> {
     a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
 }
 
+struct PeekableReceiver<T> {
+    recv: mpsc::Receiver<T>,
+    first: Option<T>,
+}
+
+impl<T> PeekableReceiver<T> {
+    pub fn from_recv(recv: mpsc::Receiver<T>) -> Self {
+        Self { recv, first: None }
+    }
+
+    pub fn has_incoming(&mut self) -> bool {
+        if self.first.is_some() {
+            return true;
+        }
+        match self.recv.try_recv() {
+            Ok(v) => {
+                self.first = Some(v);
+                true
+            },
+            Err(mpsc::TryRecvError::Empty) => false,
+            Err(mpsc::TryRecvError::Disconnected) => {
+                warn!("Channel was disconnected when checking incoming");
+                false
+            },
+        }
+    }
+
+    pub fn try_recv(&mut self) -> Result<T, mpsc::TryRecvError> {
+        if let Some(first) = self.first.take() {
+            return Ok(first);
+        }
+        self.recv.try_recv()
+    }
+}
+
 #[derive(Clone)]
 struct SharedFlagSetter {
     flag: Arc<AtomicBool>,
@@ -97,12 +131,13 @@ impl RedrawRequester {
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct KeyEventExtra {}
 
-pub struct EventLoop {
+pub struct EventLoop<T: 'static> {
     android_app: AndroidApp,
     window_target: event_loop::ActiveEventLoop,
     redraw_flag: SharedFlag,
-    proxy_wake_up: Arc<AtomicBool>,
-    loop_running: bool, // Dispatched `NewEvents<Init>`
+    user_events_sender: mpsc::Sender<T>,
+    user_events_receiver: PeekableReceiver<T>, // must wake looper whenever something gets sent
+    loop_running: bool,                        // Dispatched `NewEvents<Init>`
     running: bool,
     pending_redraw: bool,
     cause: StartCause,
@@ -122,11 +157,11 @@ impl Default for PlatformSpecificEventLoopAttributes {
     }
 }
 
-impl EventLoop {
+impl<T: 'static> EventLoop<T> {
     pub(crate) fn new(
         attributes: &PlatformSpecificEventLoopAttributes,
     ) -> Result<Self, EventLoopError> {
-        let proxy_wake_up = Arc::new(AtomicBool::new(false));
+        let (user_events_sender, user_events_receiver) = mpsc::channel();
 
         let android_app = attributes.android_app.as_ref().expect(
             "An `AndroidApp` as passed to android_main() is required to create an `EventLoop` on \
@@ -149,7 +184,8 @@ impl EventLoop {
                 _marker: PhantomData,
             },
             redraw_flag,
-            proxy_wake_up,
+            user_events_sender,
+            user_events_receiver: PeekableReceiver::from_recv(user_events_receiver),
             loop_running: false,
             running: false,
             pending_redraw: false,
@@ -159,28 +195,27 @@ impl EventLoop {
         })
     }
 
-    fn single_iteration<A: ApplicationHandler>(
-        &mut self,
-        main_event: Option<MainEvent<'_>>,
-        app: &mut A,
-    ) {
+    fn single_iteration<F>(&mut self, main_event: Option<MainEvent<'_>>, callback: &mut F)
+    where
+        F: FnMut(event::Event<T>, &RootAEL),
+    {
         trace!("Mainloop iteration");
 
         let cause = self.cause;
         let mut pending_redraw = self.pending_redraw;
         let mut resized = false;
 
-        app.new_events(self.window_target(), cause);
+        callback(event::Event::NewEvents(cause), self.window_target());
 
         if let Some(event) = main_event {
             trace!("Handling main event {:?}", event);
 
             match event {
                 MainEvent::InitWindow { .. } => {
-                    app.resumed(self.window_target());
+                    callback(event::Event::Resumed, self.window_target());
                 },
                 MainEvent::TerminateWindow { .. } => {
-                    app.suspended(self.window_target());
+                    callback(event::Event::Suspended, self.window_target());
                 },
                 MainEvent::WindowResized { .. } => resized = true,
                 MainEvent::RedrawNeeded { .. } => pending_redraw = true,
@@ -189,15 +224,23 @@ impl EventLoop {
                 },
                 MainEvent::GainedFocus => {
                     HAS_FOCUS.store(true, Ordering::Relaxed);
-                    let window_id = window::WindowId(WindowId);
-                    let event = event::WindowEvent::Focused(true);
-                    app.window_event(self.window_target(), window_id, event);
+                    callback(
+                        event::Event::WindowEvent {
+                            window_id: window::WindowId(WindowId),
+                            event: event::WindowEvent::Focused(true),
+                        },
+                        self.window_target(),
+                    );
                 },
                 MainEvent::LostFocus => {
                     HAS_FOCUS.store(false, Ordering::Relaxed);
-                    let window_id = window::WindowId(WindowId);
-                    let event = event::WindowEvent::Focused(false);
-                    app.window_event(self.window_target(), window_id, event);
+                    callback(
+                        event::Event::WindowEvent {
+                            window_id: window::WindowId(WindowId),
+                            event: event::WindowEvent::Focused(false),
+                        },
+                        self.window_target(),
+                    );
                 },
                 MainEvent::ConfigChanged { .. } => {
                     let monitor = MonitorHandle::new(self.android_app.clone());
@@ -207,19 +250,20 @@ impl EventLoop {
                         let new_inner_size = Arc::new(Mutex::new(
                             MonitorHandle::new(self.android_app.clone()).size(),
                         ));
-                        let window_id = window::WindowId(WindowId);
-                        let event = event::WindowEvent::ScaleFactorChanged {
-                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                                &new_inner_size,
-                            )),
-                            scale_factor,
+                        let event = event::Event::WindowEvent {
+                            window_id: window::WindowId(WindowId),
+                            event: event::WindowEvent::ScaleFactorChanged {
+                                inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
+                                    &new_inner_size,
+                                )),
+                                scale_factor,
+                            },
                         };
-
-                        app.window_event(self.window_target(), window_id, event);
+                        callback(event, self.window_target());
                     }
                 },
                 MainEvent::LowMemory => {
-                    app.memory_warning(self.window_target());
+                    callback(event::Event::MemoryWarning, self.window_target());
                 },
                 MainEvent::Start => {
                     // XXX: how to forward this state to applications?
@@ -267,7 +311,7 @@ impl EventLoop {
         match android_app.input_events_iter() {
             Ok(mut input_iter) => loop {
                 let read_event =
-                    input_iter.next(|event| self.handle_input_event(&android_app, event, app));
+                    input_iter.next(|event| self.handle_input_event(&android_app, event, callback));
 
                 if !read_event {
                     break;
@@ -278,8 +322,11 @@ impl EventLoop {
             },
         }
 
-        if self.proxy_wake_up.swap(false, Ordering::Relaxed) {
-            app.proxy_wake_up(self.window_target());
+        // Empty the user event buffer
+        {
+            while let Ok(event) = self.user_events_receiver.try_recv() {
+                callback(crate::event::Event::UserEvent(event), self.window_target());
+            }
         }
 
         if self.running {
@@ -291,32 +338,39 @@ impl EventLoop {
                 } else {
                     PhysicalSize::new(0, 0)
                 };
-                let window_id = window::WindowId(WindowId);
-                let event = event::WindowEvent::Resized(size);
-                app.window_event(self.window_target(), window_id, event);
+                let event = event::Event::WindowEvent {
+                    window_id: window::WindowId(WindowId),
+                    event: event::WindowEvent::Resized(size),
+                };
+                callback(event, self.window_target());
             }
 
             pending_redraw |= self.redraw_flag.get_and_reset();
             if pending_redraw {
                 pending_redraw = false;
-                let window_id = window::WindowId(WindowId);
-                let event = event::WindowEvent::RedrawRequested;
-                app.window_event(self.window_target(), window_id, event);
+                let event = event::Event::WindowEvent {
+                    window_id: window::WindowId(WindowId),
+                    event: event::WindowEvent::RedrawRequested,
+                };
+                callback(event, self.window_target());
             }
         }
 
         // This is always the last event we dispatch before poll again
-        app.about_to_wait(self.window_target());
+        callback(event::Event::AboutToWait, self.window_target());
 
         self.pending_redraw = pending_redraw;
     }
 
-    fn handle_input_event<A: ApplicationHandler>(
+    fn handle_input_event<F>(
         &mut self,
         android_app: &AndroidApp,
         event: &InputEvent<'_>,
-        app: &mut A,
-    ) -> InputStatus {
+        callback: &mut F,
+    ) -> InputStatus
+    where
+        F: FnMut(event::Event<T>, &RootAEL),
+    {
         let mut input_status = InputStatus::Handled;
         match event {
             InputEvent::MotionEvent(motion_event) => {
@@ -354,16 +408,17 @@ impl EventLoop {
                             "Input event {device_id:?}, {phase:?}, loc={location:?}, \
                              pointer={pointer:?}"
                         );
-
-                        let event = event::WindowEvent::Touch(event::Touch {
-                            device_id,
-                            phase,
-                            location,
-                            id: pointer.pointer_id() as u64,
-                            force: Some(Force::Normalized(pointer.pressure() as f64)),
-                        });
-
-                        app.window_event(self.window_target(), window_id, event);
+                        let event = event::Event::WindowEvent {
+                            window_id,
+                            event: event::WindowEvent::Touch(event::Touch {
+                                device_id,
+                                phase,
+                                location,
+                                id: pointer.pointer_id() as u64,
+                                force: Some(Force::Normalized(pointer.pressure() as f64)),
+                            }),
+                        };
+                        callback(event, self.window_target());
                     }
                 }
             },
@@ -391,22 +446,23 @@ impl EventLoop {
                             &mut self.combining_accent,
                         );
 
-                        let window_id = window::WindowId(WindowId);
-                        let event = event::WindowEvent::KeyboardInput {
-                            device_id: event::DeviceId(DeviceId(key.device_id())),
-                            event: event::KeyEvent {
-                                state,
-                                physical_key: keycodes::to_physical_key(keycode),
-                                logical_key: keycodes::to_logical(key_char, keycode),
-                                location: keycodes::to_location(keycode),
-                                repeat: key.repeat_count() > 0,
-                                text: None,
-                                platform_specific: KeyEventExtra {},
+                        let event = event::Event::WindowEvent {
+                            window_id: window::WindowId(WindowId),
+                            event: event::WindowEvent::KeyboardInput {
+                                device_id: event::DeviceId(DeviceId(key.device_id())),
+                                event: event::KeyEvent {
+                                    state,
+                                    physical_key: keycodes::to_physical_key(keycode),
+                                    logical_key: keycodes::to_logical(key_char, keycode),
+                                    location: keycodes::to_location(keycode),
+                                    repeat: key.repeat_count() > 0,
+                                    text: None,
+                                    platform_specific: KeyEventExtra {},
+                                },
+                                is_synthetic: false,
                             },
-                            is_synthetic: false,
                         };
-
-                        app.window_event(self.window_target(), window_id, event);
+                        callback(event, self.window_target());
                     },
                 }
             },
@@ -418,16 +474,19 @@ impl EventLoop {
         input_status
     }
 
-    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
+    pub fn run<F>(mut self, event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(event::Event<T>, &event_loop::ActiveEventLoop),
+    {
+        self.run_on_demand(event_handler)
     }
 
-    pub fn run_app_on_demand<A: ApplicationHandler>(
-        &mut self,
-        app: &mut A,
-    ) -> Result<(), EventLoopError> {
+    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(event::Event<T>, &event_loop::ActiveEventLoop),
+    {
         loop {
-            match self.pump_app_events(None, app) {
+            match self.pump_events(None, &mut event_handler) {
                 PumpStatus::Exit(0) => {
                     break Ok(());
                 },
@@ -441,11 +500,10 @@ impl EventLoop {
         }
     }
 
-    pub fn pump_app_events<A: ApplicationHandler>(
-        &mut self,
-        timeout: Option<Duration>,
-        app: &mut A,
-    ) -> PumpStatus {
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
+    where
+        F: FnMut(event::Event<T>, &RootAEL),
+    {
         if !self.loop_running {
             self.loop_running = true;
 
@@ -456,18 +514,18 @@ impl EventLoop {
             self.cause = StartCause::Init;
 
             // run the initial loop iteration
-            self.single_iteration(None, app);
+            self.single_iteration(None, &mut callback);
         }
 
         // Consider the possibility that the `StartCause::Init` iteration could
         // request to Exit
         if !self.exiting() {
-            self.poll_events_with_timeout(timeout, app);
+            self.poll_events_with_timeout(timeout, &mut callback);
         }
         if self.exiting() {
             self.loop_running = false;
 
-            app.exiting(self.window_target());
+            callback(event::Event::LoopExiting, self.window_target());
 
             PumpStatus::Exit(0)
         } else {
@@ -475,34 +533,32 @@ impl EventLoop {
         }
     }
 
-    fn poll_events_with_timeout<A: ApplicationHandler>(
-        &mut self,
-        mut timeout: Option<Duration>,
-        app: &mut A,
-    ) {
+    fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
+    where
+        F: FnMut(event::Event<T>, &RootAEL),
+    {
         let start = Instant::now();
 
         self.pending_redraw |= self.redraw_flag.get_and_reset();
 
-        timeout = if self.running
-            && (self.pending_redraw || self.proxy_wake_up.load(Ordering::Relaxed))
-        {
-            // If we already have work to do then we don't want to block on the next poll
-            Some(Duration::ZERO)
-        } else {
-            let control_flow_timeout = match self.control_flow() {
-                ControlFlow::Wait => None,
-                ControlFlow::Poll => Some(Duration::ZERO),
-                ControlFlow::WaitUntil(wait_deadline) => {
-                    Some(wait_deadline.saturating_duration_since(start))
-                },
+        timeout =
+            if self.running && (self.pending_redraw || self.user_events_receiver.has_incoming()) {
+                // If we already have work to do then we don't want to block on the next poll
+                Some(Duration::ZERO)
+            } else {
+                let control_flow_timeout = match self.control_flow() {
+                    ControlFlow::Wait => None,
+                    ControlFlow::Poll => Some(Duration::ZERO),
+                    ControlFlow::WaitUntil(wait_deadline) => {
+                        Some(wait_deadline.saturating_duration_since(start))
+                    },
+                };
+
+                min_timeout(control_flow_timeout, timeout)
             };
 
-            min_timeout(control_flow_timeout, timeout)
-        };
-
-        let android_app = self.android_app.clone(); // Don't borrow self as part of poll expression
-        android_app.poll_events(timeout, |poll_event| {
+        let app = self.android_app.clone(); // Don't borrow self as part of poll expression
+        app.poll_events(timeout, |poll_event| {
             let mut main_event = None;
 
             match poll_event {
@@ -517,7 +573,7 @@ impl EventLoop {
                     // We also ignore wake ups while suspended.
                     self.pending_redraw |= self.redraw_flag.get_and_reset();
                     if !self.running
-                        || (!self.pending_redraw && !self.proxy_wake_up.load(Ordering::Relaxed))
+                        || (!self.pending_redraw && !self.user_events_receiver.has_incoming())
                     {
                         return;
                     }
@@ -543,7 +599,7 @@ impl EventLoop {
                 },
             };
 
-            self.single_iteration(main_event, app);
+            self.single_iteration(main_event, &mut callback);
         });
     }
 
@@ -551,9 +607,9 @@ impl EventLoop {
         &self.window_target
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy {
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
         EventLoopProxy {
-            proxy_wake_up: self.proxy_wake_up.clone(),
+            user_events_sender: self.user_events_sender.clone(),
             waker: self.android_app.create_waker(),
         }
     }
@@ -567,16 +623,25 @@ impl EventLoop {
     }
 }
 
-#[derive(Clone)]
-pub struct EventLoopProxy {
-    proxy_wake_up: Arc<AtomicBool>,
+pub struct EventLoopProxy<T: 'static> {
+    user_events_sender: mpsc::Sender<T>,
     waker: AndroidAppWaker,
 }
 
-impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        self.proxy_wake_up.store(true, Ordering::Relaxed);
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        EventLoopProxy {
+            user_events_sender: self.user_events_sender.clone(),
+            waker: self.waker.clone(),
+        }
+    }
+}
+
+impl<T> EventLoopProxy<T> {
+    pub fn send_event(&self, event: T) -> Result<(), event_loop::EventLoopClosed<T>> {
+        self.user_events_sender.send(event).map_err(|err| event_loop::EventLoopClosed(err.0))?;
         self.waker.wake();
+        Ok(())
     }
 }
 

src/platform_impl/apple/mod.rs

@@ -1,11 +0,0 @@
-//! Apple/Darwin-specific implementations
-
-#[cfg(target_os = "macos")]
-mod appkit;
-#[cfg(not(target_os = "macos"))]
-mod uikit;
-
-#[cfg(target_os = "macos")]
-pub use self::appkit::*;
-#[cfg(not(target_os = "macos"))]
-pub use self::uikit::*;

src/platform_impl/ios/app_state.rs

@@ -10,7 +10,7 @@ use std::{fmt, mem, ptr};
 use core_foundation::base::CFRelease;
 use core_foundation::date::CFAbsoluteTimeGetCurrent;
 use core_foundation::runloop::{
-    kCFRunLoopDefaultMode, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
+    kCFRunLoopCommonModes, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
     CFRunLoopTimerInvalidate, CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate,
 };
 use objc2::rc::Retained;
@@ -40,9 +40,12 @@ macro_rules! bug_assert {
     };
 }
 
+#[derive(Debug)]
+pub(crate) struct HandlePendingUserEvents;
+
 pub(crate) struct EventLoopHandler {
     #[allow(clippy::type_complexity)]
-    pub(crate) handler: Box<dyn FnMut(Event, &RootActiveEventLoop)>,
+    pub(crate) handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
     pub(crate) event_loop: RootActiveEventLoop,
 }
 
@@ -56,14 +59,14 @@ impl fmt::Debug for EventLoopHandler {
 }
 
 impl EventLoopHandler {
-    fn handle_event(&mut self, event: Event) {
+    fn handle_event(&mut self, event: Event<HandlePendingUserEvents>) {
         (self.handler)(event, &self.event_loop)
     }
 }
 
 #[derive(Debug)]
 pub(crate) enum EventWrapper {
-    StaticEvent(Event),
+    StaticEvent(Event<HandlePendingUserEvents>),
     ScaleFactorChanged(ScaleFactorChanged),
 }
 
@@ -85,7 +88,7 @@ enum UserCallbackTransitionResult<'a> {
     },
 }
 
-impl Event {
+impl Event<HandlePendingUserEvents> {
     fn is_redraw(&self) -> bool {
         matches!(self, Event::WindowEvent { event: WindowEvent::RedrawRequested, .. })
     }
@@ -622,7 +625,7 @@ fn handle_user_events(mtm: MainThreadMarker) {
     }
     drop(this);
 
-    handler.handle_event(Event::UserWakeUp);
+    handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
 
     loop {
         let mut this = AppState::get_mut(mtm);
@@ -655,7 +658,7 @@ fn handle_user_events(mtm: MainThreadMarker) {
             }
         }
 
-        handler.handle_event(Event::UserWakeUp);
+        handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
     }
 }
 
@@ -802,7 +805,7 @@ impl EventLoopWaker {
                 wakeup_main_loop,
                 ptr::null_mut(),
             );
-            CFRunLoopAddTimer(rl, timer, kCFRunLoopDefaultMode);
+            CFRunLoopAddTimer(rl, timer, kCFRunLoopCommonModes);
 
             EventLoopWaker { timer }
         }

src/platform_impl/ios/event_loop.rs

@@ -2,26 +2,27 @@ use std::collections::VecDeque;
 use std::ffi::{c_char, c_int, c_void};
 use std::marker::PhantomData;
 use std::ptr::{self, NonNull};
-use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
-use std::sync::Arc;
+use std::sync::mpsc::{self, Receiver, Sender};
 
 use core_foundation::base::{CFIndex, CFRelease};
 use core_foundation::runloop::{
-    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopDefaultMode, kCFRunLoopExit,
-    CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
+    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes, kCFRunLoopDefaultMode,
+    kCFRunLoopExit, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
     CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext, CFRunLoopSourceCreate,
     CFRunLoopSourceInvalidate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
 };
 use objc2::rc::Retained;
 use objc2::{msg_send_id, ClassType};
 use objc2_foundation::{MainThreadMarker, NSString};
-use objc2_ui_kit::{UIApplication, UIApplicationMain, UIScreen};
+use objc2_ui_kit::{UIApplication, UIApplicationMain, UIDevice, UIScreen, UIUserInterfaceIdiom};
 
-use super::app_state::EventLoopHandler;
-use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
 use crate::event::Event;
-use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents};
+use crate::event_loop::{
+    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents, EventLoopClosed,
+};
+use crate::platform::ios::Idiom;
+use crate::platform_impl::platform::app_state::{EventLoopHandler, HandlePendingUserEvents};
 use crate::window::{CustomCursor, CustomCursorSource};
 
 use super::app_delegate::AppDelegate;
@@ -107,44 +108,34 @@ impl OwnedDisplayHandle {
     }
 }
 
-fn map_user_event<A: ApplicationHandler>(
-    app: &mut A,
-    proxy_wake_up: Arc<AtomicBool>,
-) -> impl FnMut(Event, &RootActiveEventLoop) + '_ {
-    move |event, window_target| match event {
-        Event::NewEvents(cause) => app.new_events(window_target, cause),
-        Event::WindowEvent { window_id, event } => {
-            app.window_event(window_target, window_id, event)
-        },
-        Event::DeviceEvent { device_id, event } => {
-            app.device_event(window_target, device_id, event)
-        },
-        Event::UserWakeUp => {
-            if proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
-                app.proxy_wake_up(window_target);
+fn map_user_event<T: 'static>(
+    mut handler: impl FnMut(Event<T>, &RootActiveEventLoop),
+    receiver: mpsc::Receiver<T>,
+) -> impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) {
+    move |event, window_target| match event.map_nonuser_event() {
+        Ok(event) => (handler)(event, window_target),
+        Err(_) => {
+            for event in receiver.try_iter() {
+                (handler)(Event::UserEvent(event), window_target);
             }
         },
-        Event::Suspended => app.suspended(window_target),
-        Event::Resumed => app.resumed(window_target),
-        Event::AboutToWait => app.about_to_wait(window_target),
-        Event::LoopExiting => app.exiting(window_target),
-        Event::MemoryWarning => app.memory_warning(window_target),
     }
 }
 
-pub struct EventLoop {
+pub struct EventLoop<T: 'static> {
     mtm: MainThreadMarker,
-    proxy_wake_up: Arc<AtomicBool>,
+    sender: Sender<T>,
+    receiver: Receiver<T>,
     window_target: RootActiveEventLoop,
 }
 
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct PlatformSpecificEventLoopAttributes {}
 
-impl EventLoop {
+impl<T: 'static> EventLoop<T> {
     pub(crate) fn new(
         _: &PlatformSpecificEventLoopAttributes,
-    ) -> Result<EventLoop, EventLoopError> {
+    ) -> Result<EventLoop<T>, EventLoopError> {
         let mtm = MainThreadMarker::new()
             .expect("On iOS, `EventLoop` must be created on the main thread");
 
@@ -157,19 +148,23 @@ impl EventLoop {
             SINGLETON_INIT = true;
         }
 
+        let (sender, receiver) = mpsc::channel();
+
         // this line sets up the main run loop before `UIApplicationMain`
         setup_control_flow_observers();
 
-        let proxy_wake_up = Arc::new(AtomicBool::new(false));
-
         Ok(EventLoop {
             mtm,
-            proxy_wake_up,
+            sender,
+            receiver,
             window_target: RootActiveEventLoop { p: ActiveEventLoop { mtm }, _marker: PhantomData },
         })
     }
 
-    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> ! {
+    pub fn run<F>(self, handler: F) -> !
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
         let application: Option<Retained<UIApplication>> =
             unsafe { msg_send_id![UIApplication::class(), sharedApplication] };
         assert!(
@@ -179,12 +174,12 @@ impl EventLoop {
              `EventLoop::run_app` calls `UIApplicationMain` on iOS",
         );
 
-        let handler = map_user_event(app, self.proxy_wake_up.clone());
+        let handler = map_user_event(handler, self.receiver);
 
         let handler = unsafe {
             std::mem::transmute::<
-                Box<dyn FnMut(Event, &RootActiveEventLoop)>,
-                Box<dyn FnMut(Event, &RootActiveEventLoop)>,
+                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
+                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
             >(Box::new(handler))
         };
 
@@ -212,8 +207,8 @@ impl EventLoop {
         unreachable!()
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy {
-        EventLoopProxy::new(self.proxy_wake_up.clone())
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.sender.clone())
     }
 
     pub fn window_target(&self) -> &RootActiveEventLoop {
@@ -221,21 +216,35 @@ impl EventLoop {
     }
 }
 
-pub struct EventLoopProxy {
-    proxy_wake_up: Arc<AtomicBool>,
-    source: CFRunLoopSourceRef,
-}
-
-unsafe impl Send for EventLoopProxy {}
-unsafe impl Sync for EventLoopProxy {}
-
-impl Clone for EventLoopProxy {
-    fn clone(&self) -> EventLoopProxy {
-        EventLoopProxy::new(self.proxy_wake_up.clone())
+// EventLoopExtIOS
+impl<T: 'static> EventLoop<T> {
+    pub fn idiom(&self) -> Idiom {
+        match UIDevice::currentDevice(self.mtm).userInterfaceIdiom() {
+            UIUserInterfaceIdiom::Unspecified => Idiom::Unspecified,
+            UIUserInterfaceIdiom::Phone => Idiom::Phone,
+            UIUserInterfaceIdiom::Pad => Idiom::Pad,
+            UIUserInterfaceIdiom::TV => Idiom::TV,
+            UIUserInterfaceIdiom::CarPlay => Idiom::CarPlay,
+            _ => Idiom::Unspecified,
+        }
     }
 }
 
-impl Drop for EventLoopProxy {
+pub struct EventLoopProxy<T> {
+    sender: Sender<T>,
+    source: CFRunLoopSourceRef,
+}
+
+unsafe impl<T: Send> Send for EventLoopProxy<T> {}
+unsafe impl<T: Send> Sync for EventLoopProxy<T> {}
+
+impl<T> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.sender.clone())
+    }
+}
+
+impl<T> Drop for EventLoopProxy<T> {
     fn drop(&mut self) {
         unsafe {
             CFRunLoopSourceInvalidate(self.source);
@@ -244,8 +253,8 @@ impl Drop for EventLoopProxy {
     }
 }
 
-impl EventLoopProxy {
-    fn new(proxy_wake_up: Arc<AtomicBool>) -> EventLoopProxy {
+impl<T> EventLoopProxy<T> {
+    fn new(sender: Sender<T>) -> EventLoopProxy<T> {
         unsafe {
             // just wake up the eventloop
             extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
@@ -266,21 +275,22 @@ impl EventLoopProxy {
                 perform: event_loop_proxy_handler,
             };
             let source = CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::MAX - 1, &mut context);
-            CFRunLoopAddSource(rl, source, kCFRunLoopDefaultMode);
+            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
             CFRunLoopWakeUp(rl);
 
-            EventLoopProxy { proxy_wake_up, source }
+            EventLoopProxy { sender, source }
         }
     }
 
-    pub fn wake_up(&self) {
-        self.proxy_wake_up.store(true, AtomicOrdering::Relaxed);
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.sender.send(event).map_err(|::std::sync::mpsc::SendError(x)| EventLoopClosed(x))?;
         unsafe {
             // let the main thread know there's a new event
             CFRunLoopSourceSignal(self.source);
             let rl = CFRunLoopGetMain();
             CFRunLoopWakeUp(rl);
         }
+        Ok(())
     }
 }
 

src/platform_impl/ios/monitor.rs

@@ -9,9 +9,9 @@ use objc2::Message;
 use objc2_foundation::{run_on_main, MainThreadBound, MainThreadMarker, NSInteger};
 use objc2_ui_kit::{UIScreen, UIScreenMode};
 
-use super::app_state;
 use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::monitor::VideoModeHandle as RootVideoModeHandle;
+use crate::platform_impl::platform::app_state;
 
 // Workaround for `MainThreadBound` implementing almost no traits
 #[derive(Debug)]

src/platform_impl/ios/view.rs

@@ -14,9 +14,9 @@ use objc2_ui_kit::{
 
 use super::app_state::{self, EventWrapper};
 use super::window::WinitUIWindow;
-use super::DEVICE_ID;
 use crate::dpi::PhysicalPosition;
 use crate::event::{Event, Force, Touch, TouchPhase, WindowEvent};
+use crate::platform_impl::platform::DEVICE_ID;
 use crate::window::{WindowAttributes, WindowId as RootWindowId};
 
 pub struct WinitViewState {

src/platform_impl/ios/window.rs

@@ -17,13 +17,15 @@ use tracing::{debug, warn};
 use super::app_state::EventWrapper;
 use super::view::WinitView;
 use super::view_controller::WinitViewController;
-use super::{app_state, monitor, ActiveEventLoop, Fullscreen, MonitorHandle};
 use crate::cursor::Cursor;
 use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
 use crate::event::{Event, WindowEvent};
 use crate::icon::Icon;
 use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
+use crate::platform_impl::platform::{
+    app_state, monitor, ActiveEventLoop, Fullscreen, MonitorHandle,
+};
 use crate::window::{
     CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, WindowAttributes,
     WindowButtons, WindowId as RootWindowId, WindowLevel,

src/platform_impl/linux/mod.rs

@@ -11,8 +11,6 @@ use std::{env, fmt};
 #[cfg(x11_platform)]
 use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Mutex};
 
-use crate::application::ApplicationHandler;
-use crate::platform::pump_events::PumpStatus;
 #[cfg(x11_platform)]
 use crate::utils::Lazy;
 use smol_str::SmolStr;
@@ -21,9 +19,12 @@ use smol_str::SmolStr;
 use self::x11::{X11Error, XConnection, XError, XNotSupported};
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{EventLoopError, ExternalError, NotSupportedError, OsError as RootOsError};
-use crate::event_loop::{AsyncRequestSerial, ControlFlow, DeviceEvents};
+use crate::event_loop::{
+    ActiveEventLoop as RootELW, AsyncRequestSerial, ControlFlow, DeviceEvents, EventLoopClosed,
+};
 use crate::icon::Icon;
 use crate::keyboard::Key;
+use crate::platform::pump_events::PumpStatus;
 #[cfg(x11_platform)]
 use crate::platform::x11::{WindowType as XWindowType, XlibErrorHook};
 use crate::window::{
@@ -691,22 +692,27 @@ unsafe extern "C" fn x_error_callback(
     0
 }
 
-pub enum EventLoop {
+pub enum EventLoop<T: 'static> {
     #[cfg(wayland_platform)]
-    Wayland(Box<wayland::EventLoop>),
+    Wayland(Box<wayland::EventLoop<T>>),
     #[cfg(x11_platform)]
-    X(x11::EventLoop),
+    X(x11::EventLoop<T>),
 }
 
-#[derive(Clone)]
-pub enum EventLoopProxy {
+pub enum EventLoopProxy<T: 'static> {
     #[cfg(x11_platform)]
-    X(x11::EventLoopProxy),
+    X(x11::EventLoopProxy<T>),
     #[cfg(wayland_platform)]
-    Wayland(wayland::EventLoopProxy),
+    Wayland(wayland::EventLoopProxy<T>),
 }
 
-impl EventLoop {
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.clone(); as EventLoopProxy)
+    }
+}
+
+impl<T: 'static> EventLoop<T> {
     pub(crate) fn new(
         attributes: &PlatformSpecificEventLoopAttributes,
     ) -> Result<Self, EventLoopError> {
@@ -765,12 +771,12 @@ impl EventLoop {
     }
 
     #[cfg(wayland_platform)]
-    fn new_wayland_any_thread() -> Result<EventLoop, EventLoopError> {
+    fn new_wayland_any_thread() -> Result<EventLoop<T>, EventLoopError> {
         wayland::EventLoop::new().map(|evlp| EventLoop::Wayland(Box::new(evlp)))
     }
 
     #[cfg(x11_platform)]
-    fn new_x11_any_thread() -> Result<EventLoop, EventLoopError> {
+    fn new_x11_any_thread() -> Result<EventLoop<T>, EventLoopError> {
         let xconn = match X11_BACKEND.lock().unwrap().as_ref() {
             Ok(xconn) => xconn.clone(),
             Err(_) => return Err(EventLoopError::NotSupported(NotSupportedError::new())),
@@ -789,27 +795,29 @@ impl EventLoop {
         }
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy {
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.create_proxy(); as EventLoopProxy)
     }
 
-    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> Result<(), EventLoopError> {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app(app))
+    pub fn run<F>(mut self, callback: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(crate::event::Event<T>, &RootELW),
+    {
+        self.run_on_demand(callback)
     }
 
-    pub fn run_app_on_demand<A: ApplicationHandler>(
-        &mut self,
-        app: &mut A,
-    ) -> Result<(), EventLoopError> {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app_on_demand(app))
+    pub fn run_on_demand<F>(&mut self, callback: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(crate::event::Event<T>, &RootELW),
+    {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_on_demand(callback))
     }
 
-    pub fn pump_app_events<A: ApplicationHandler>(
-        &mut self,
-        timeout: Option<Duration>,
-        app: &mut A,
-    ) -> PumpStatus {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_app_events(timeout, app))
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus
+    where
+        F: FnMut(crate::event::Event<T>, &RootELW),
+    {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_events(timeout, callback))
     }
 
     pub fn window_target(&self) -> &crate::event_loop::ActiveEventLoop {
@@ -817,21 +825,21 @@ impl EventLoop {
     }
 }
 
-impl AsFd for EventLoop {
+impl<T> AsFd for EventLoop<T> {
     fn as_fd(&self) -> BorrowedFd<'_> {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_fd())
     }
 }
 
-impl AsRawFd for EventLoop {
+impl<T> AsRawFd for EventLoop<T> {
     fn as_raw_fd(&self) -> RawFd {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_raw_fd())
     }
 }
 
-impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.wake_up())
+impl<T: 'static> EventLoopProxy<T> {
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.send_event(event))
     }
 }
 

src/platform_impl/linux/wayland/event_loop/mod.rs

@@ -5,6 +5,7 @@ use std::io::Result as IOResult;
 use std::marker::PhantomData;
 use std::mem;
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+use std::rc::Rc;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
@@ -13,7 +14,6 @@ use sctk::reexports::calloop::Error as CalloopError;
 use sctk::reexports::calloop_wayland_source::WaylandSource;
 use sctk::reexports::client::{globals, Connection, QueueHandle};
 
-use crate::application::ApplicationHandler;
 use crate::cursor::OnlyCursorImage;
 use crate::dpi::LogicalSize;
 use crate::error::{EventLoopError, OsError as RootOsError};
@@ -39,7 +39,7 @@ use super::{logical_to_physical_rounded, DeviceId, WaylandError, WindowId};
 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;
 
 /// The Wayland event loop.
-pub struct EventLoop {
+pub struct EventLoop<T: 'static> {
     /// Has `run` or `run_on_demand` been called or a call to `pump_events` that starts the loop
     loop_running: bool,
 
@@ -47,8 +47,13 @@ pub struct EventLoop {
     compositor_updates: Vec<WindowCompositorUpdate>,
     window_ids: Vec<WindowId>,
 
-    /// Event loop proxy
-    event_loop_proxy: EventLoopProxy,
+    /// Sender of user events.
+    user_events_sender: calloop::channel::Sender<T>,
+
+    // XXX can't remove RefCell out of here, unless we can plumb generics into the `Window`, which
+    // we don't really want, since it'll break public API by a lot.
+    /// Pending events from the user.
+    pending_user_events: Rc<RefCell<Vec<T>>>,
 
     /// The Wayland dispatcher to has raw access to the queue when needed, such as
     /// when creating a new window.
@@ -65,8 +70,8 @@ pub struct EventLoop {
     event_loop: calloop::EventLoop<'static, WinitState>,
 }
 
-impl EventLoop {
-    pub fn new() -> Result<EventLoop, EventLoopError> {
+impl<T: 'static> EventLoop<T> {
+    pub fn new() -> Result<EventLoop<T>, EventLoopError> {
         macro_rules! map_err {
             ($e:expr, $err:expr) => {
                 $e.map_err(|error| os_error!($err(error).into()))
@@ -109,12 +114,16 @@ impl EventLoop {
         )?;
 
         // Setup the user proxy.
-        let (ping, ping_source) = calloop::ping::make_ping().unwrap();
+        let pending_user_events = Rc::new(RefCell::new(Vec::new()));
+        let pending_user_events_clone = pending_user_events.clone();
+        let (user_events_sender, user_events_channel) = calloop::channel::channel();
         let result = event_loop
             .handle()
-            .insert_source(ping_source, move |_, _, winit_state: &mut WinitState| {
-                winit_state.dispatched_events = true;
-                winit_state.proxy_wake_up = true;
+            .insert_source(user_events_channel, move |event, _, winit_state: &mut WinitState| {
+                if let calloop::channel::Event::Msg(msg) = event {
+                    winit_state.dispatched_events = true;
+                    pending_user_events_clone.borrow_mut().push(msg);
+                }
             })
             .map_err(|error| error.error);
         map_err!(result, WaylandError::Calloop)?;
@@ -152,7 +161,8 @@ impl EventLoop {
             window_ids: Vec::new(),
             connection,
             wayland_dispatcher,
-            event_loop_proxy: EventLoopProxy::new(ping),
+            user_events_sender,
+            pending_user_events,
             event_loop,
             window_target: RootActiveEventLoop {
                 p: PlatformActiveEventLoop::Wayland(window_target),
@@ -163,16 +173,12 @@ impl EventLoop {
         Ok(event_loop)
     }
 
-    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
-    }
-
-    pub fn run_app_on_demand<A: ApplicationHandler>(
-        &mut self,
-        app: &mut A,
-    ) -> Result<(), EventLoopError> {
+    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
         let exit = loop {
-            match self.pump_app_events(None, app) {
+            match self.pump_events(None, &mut event_handler) {
                 PumpStatus::Exit(0) => {
                     break Ok(());
                 },
@@ -194,27 +200,26 @@ impl EventLoop {
         exit
     }
 
-    pub fn pump_app_events<A: ApplicationHandler>(
-        &mut self,
-        timeout: Option<Duration>,
-        app: &mut A,
-    ) -> PumpStatus {
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
         if !self.loop_running {
             self.loop_running = true;
 
             // Run the initial loop iteration.
-            self.single_iteration(app, StartCause::Init);
+            self.single_iteration(&mut callback, StartCause::Init);
         }
 
         // Consider the possibility that the `StartCause::Init` iteration could
         // request to Exit.
         if !self.exiting() {
-            self.poll_events_with_timeout(timeout, app);
+            self.poll_events_with_timeout(timeout, &mut callback);
         }
         if let Some(code) = self.exit_code() {
             self.loop_running = false;
 
-            app.exiting(&self.window_target);
+            callback(Event::LoopExiting, self.window_target());
 
             PumpStatus::Exit(code)
         } else {
@@ -222,11 +227,10 @@ impl EventLoop {
         }
     }
 
-    pub fn poll_events_with_timeout<A: ApplicationHandler>(
-        &mut self,
-        mut timeout: Option<Duration>,
-        app: &mut A,
-    ) {
+    pub fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
         let cause = loop {
             let start = Instant::now();
 
@@ -288,10 +292,13 @@ impl EventLoop {
             break cause;
         };
 
-        self.single_iteration(app, cause);
+        self.single_iteration(&mut callback, cause);
     }
 
-    fn single_iteration<A: ApplicationHandler>(&mut self, app: &mut A, cause: StartCause) {
+    fn single_iteration<F>(&mut self, callback: &mut F, cause: StartCause)
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
         // NOTE currently just indented to simplify the diff
 
         // We retain these grow-only scratch buffers as part of the EventLoop
@@ -302,17 +309,18 @@ impl EventLoop {
         let mut buffer_sink = std::mem::take(&mut self.buffer_sink);
         let mut window_ids = std::mem::take(&mut self.window_ids);
 
-        app.new_events(&self.window_target, cause);
+        callback(Event::NewEvents(cause), &self.window_target);
 
         // NB: For consistency all platforms must emit a 'resumed' event even though Wayland
         // applications don't themselves have a formal suspend/resume lifecycle.
         if cause == StartCause::Init {
-            app.resumed(&self.window_target);
+            callback(Event::Resumed, &self.window_target);
         }
 
-        // Indicate user wake up.
-        if self.with_state(|state| mem::take(&mut state.proxy_wake_up)) {
-            app.proxy_wake_up(&self.window_target);
+        // Handle pending user events. We don't need back buffer, since we can't dispatch
+        // user events indirectly via callback to the user.
+        for user_event in self.pending_user_events.borrow_mut().drain(..) {
+            callback(Event::UserEvent(user_event), &self.window_target);
         }
 
         // Drain the pending compositor updates.
@@ -333,13 +341,18 @@ impl EventLoop {
                 let old_physical_size = physical_size;
 
                 let new_inner_size = Arc::new(Mutex::new(physical_size));
-                let root_window_id = crate::window::WindowId(window_id);
-                let event = WindowEvent::ScaleFactorChanged {
-                    scale_factor,
-                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
-                };
-
-                app.window_event(&self.window_target, root_window_id, event);
+                callback(
+                    Event::WindowEvent {
+                        window_id: crate::window::WindowId(window_id),
+                        event: WindowEvent::ScaleFactorChanged {
+                            scale_factor,
+                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
+                                &new_inner_size,
+                            )),
+                        },
+                    },
+                    &self.window_target,
+                );
 
                 let physical_size = *new_inner_size.lock().unwrap();
                 drop(new_inner_size);
@@ -382,14 +395,23 @@ impl EventLoop {
                     size
                 });
 
-                let window_id = crate::window::WindowId(window_id);
-                let event = WindowEvent::Resized(physical_size);
-                app.window_event(&self.window_target, window_id, event);
+                callback(
+                    Event::WindowEvent {
+                        window_id: crate::window::WindowId(window_id),
+                        event: WindowEvent::Resized(physical_size),
+                    },
+                    &self.window_target,
+                );
             }
 
             if compositor_update.close_window {
-                let window_id = crate::window::WindowId(window_id);
-                app.window_event(&self.window_target, window_id, WindowEvent::CloseRequested);
+                callback(
+                    Event::WindowEvent {
+                        window_id: crate::window::WindowId(window_id),
+                        event: WindowEvent::CloseRequested,
+                    },
+                    &self.window_target,
+                );
             }
         }
 
@@ -398,15 +420,8 @@ impl EventLoop {
             buffer_sink.append(&mut state.window_events_sink.lock().unwrap());
         });
         for event in buffer_sink.drain() {
-            match event {
-                Event::WindowEvent { window_id, event } => {
-                    app.window_event(&self.window_target, window_id, event)
-                },
-                Event::DeviceEvent { device_id, event } => {
-                    app.device_event(&self.window_target, device_id, event)
-                },
-                _ => unreachable!("event which is neither device nor window event."),
-            }
+            let event = event.map_nonuser_event().unwrap();
+            callback(event, &self.window_target);
         }
 
         // Handle non-synthetic events.
@@ -414,15 +429,8 @@ impl EventLoop {
             buffer_sink.append(&mut state.events_sink);
         });
         for event in buffer_sink.drain() {
-            match event {
-                Event::WindowEvent { window_id, event } => {
-                    app.window_event(&self.window_target, window_id, event)
-                },
-                Event::DeviceEvent { device_id, event } => {
-                    app.device_event(&self.window_target, device_id, event)
-                },
-                _ => unreachable!("event which is neither device nor window event."),
-            }
+            let event = event.map_nonuser_event().unwrap();
+            callback(event, &self.window_target);
         }
 
         // Collect the window ids
@@ -458,8 +466,10 @@ impl EventLoop {
             });
 
             if let Some(event) = event {
-                let window_id = crate::window::WindowId(*window_id);
-                app.window_event(&self.window_target, window_id, event);
+                callback(
+                    Event::WindowEvent { window_id: crate::window::WindowId(*window_id), event },
+                    &self.window_target,
+                );
             }
         }
 
@@ -469,7 +479,7 @@ impl EventLoop {
         });
 
         // This is always the last event we dispatch before poll again
-        app.about_to_wait(&self.window_target);
+        callback(Event::AboutToWait, &self.window_target);
 
         // Update the window frames and schedule redraws.
         let mut wake_up = false;
@@ -513,8 +523,8 @@ impl EventLoop {
     }
 
     #[inline]
-    pub fn create_proxy(&self) -> EventLoopProxy {
-        self.event_loop_proxy.clone()
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.user_events_sender.clone())
     }
 
     #[inline]
@@ -576,13 +586,13 @@ impl EventLoop {
     }
 }
 
-impl AsFd for EventLoop {
+impl<T> AsFd for EventLoop<T> {
     fn as_fd(&self) -> BorrowedFd<'_> {
         self.event_loop.as_fd()
     }
 }
 
-impl AsRawFd for EventLoop {
+impl<T> AsRawFd for EventLoop<T> {
     fn as_raw_fd(&self) -> RawFd {
         self.event_loop.as_raw_fd()
     }

src/platform_impl/linux/wayland/event_loop/proxy.rs

@@ -1,19 +1,28 @@
 //! An event loop proxy.
 
-use sctk::reexports::calloop::ping::Ping;
+use std::sync::mpsc::SendError;
+
+use sctk::reexports::calloop::channel::Sender;
+
+use crate::event_loop::EventLoopClosed;
 
 /// A handle that can be sent across the threads and used to wake up the `EventLoop`.
-#[derive(Clone)]
-pub struct EventLoopProxy {
-    ping: Ping,
+pub struct EventLoopProxy<T: 'static> {
+    user_events_sender: Sender<T>,
 }
 
-impl EventLoopProxy {
-    pub fn new(ping: Ping) -> Self {
-        Self { ping }
-    }
-
-    pub fn wake_up(&self) {
-        self.ping.ping();
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        EventLoopProxy { user_events_sender: self.user_events_sender.clone() }
+    }
+}
+
+impl<T: 'static> EventLoopProxy<T> {
+    pub fn new(user_events_sender: Sender<T>) -> Self {
+        Self { user_events_sender }
+    }
+
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.user_events_sender.send(event).map_err(|SendError(error)| EventLoopClosed(error))
     }
 }

src/platform_impl/linux/wayland/event_loop/sink.rs

@@ -12,7 +12,7 @@ use super::{DeviceId, WindowId};
 /// to the winit's user.
 #[derive(Default)]
 pub struct EventSink {
-    pub(crate) window_events: Vec<Event>,
+    pub window_events: Vec<Event<()>>,
 }
 
 impl EventSink {
@@ -47,7 +47,7 @@ impl EventSink {
     }
 
     #[inline]
-    pub(crate) fn drain(&mut self) -> Drain<'_, Event> {
+    pub fn drain(&mut self) -> Drain<'_, Event<()>> {
         self.window_events.drain(..)
     }
 }

src/platform_impl/linux/wayland/state.rs

@@ -115,9 +115,6 @@ pub struct WinitState {
     /// Whether we have dispatched events to the user thus we want to
     /// send `AboutToWait` and normally wakeup the user.
     pub dispatched_events: bool,
-
-    /// Whether the user initiated a wake up.
-    pub proxy_wake_up: bool,
 }
 
 impl WinitState {
@@ -195,7 +192,6 @@ impl WinitState {
             loop_handle,
             // Make it true by default.
             dispatched_events: true,
-            proxy_wake_up: false,
         })
     }
 

src/platform_impl/linux/x11/event_processor.rs

@@ -72,9 +72,9 @@ pub struct EventProcessor {
 }
 
 impl EventProcessor {
-    pub(crate) fn process_event<F>(&mut self, xev: &mut XEvent, mut callback: F)
+    pub fn process_event<T: 'static, F>(&mut self, xev: &mut XEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         self.process_xevent(xev, &mut callback);
 
@@ -139,9 +139,9 @@ impl EventProcessor {
         }
     }
 
-    fn process_xevent<F>(&mut self, xev: &mut XEvent, mut callback: F)
+    fn process_xevent<T: 'static, F>(&mut self, xev: &mut XEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let event_type = xev.get_type();
 
@@ -387,9 +387,9 @@ impl EventProcessor {
         }
     }
 
-    fn client_message<F>(&mut self, xev: &XClientMessageEvent, mut callback: F)
+    fn client_message<T: 'static, F>(&mut self, xev: &XClientMessageEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
         let atoms = wt.xconn.atoms();
@@ -552,9 +552,9 @@ impl EventProcessor {
         }
     }
 
-    fn selection_notify<F>(&mut self, xev: &XSelectionEvent, mut callback: F)
+    fn selection_notify<T: 'static, F>(&mut self, xev: &XSelectionEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
         let atoms = wt.xconn.atoms();
@@ -586,9 +586,9 @@ impl EventProcessor {
         }
     }
 
-    fn configure_notify<F>(&self, xev: &XConfigureEvent, mut callback: F)
+    fn configure_notify<T: 'static, F>(&self, xev: &XConfigureEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -781,9 +781,9 @@ impl EventProcessor {
         });
     }
 
-    fn map_notify<F>(&self, xev: &XMapEvent, mut callback: F)
+    fn map_notify<T: 'static, F>(&self, xev: &XMapEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let window = xev.window as xproto::Window;
         let window_id = mkwid(window);
@@ -799,9 +799,9 @@ impl EventProcessor {
         callback(&self.target, event);
     }
 
-    fn destroy_notify<F>(&self, xev: &XDestroyWindowEvent, mut callback: F)
+    fn destroy_notify<T: 'static, F>(&self, xev: &XDestroyWindowEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -823,9 +823,9 @@ impl EventProcessor {
         callback(&self.target, Event::WindowEvent { window_id, event: WindowEvent::Destroyed });
     }
 
-    fn property_notify<F>(&mut self, xev: &XPropertyEvent, mut callback: F)
+    fn property_notify<T: 'static, F>(&mut self, xev: &XPropertyEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
         let atoms = wt.x_connection().atoms();
@@ -838,9 +838,9 @@ impl EventProcessor {
         }
     }
 
-    fn visibility_notify<F>(&self, xev: &XVisibilityEvent, mut callback: F)
+    fn visibility_notify<T: 'static, F>(&self, xev: &XVisibilityEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let xwindow = xev.window as xproto::Window;
 
@@ -855,9 +855,9 @@ impl EventProcessor {
         });
     }
 
-    fn expose<F>(&self, xev: &XExposeEvent, mut callback: F)
+    fn expose<T: 'static, F>(&self, xev: &XExposeEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         // Multiple Expose events may be received for subareas of a window.
         // We issue `RedrawRequested` only for the last event of such a series.
@@ -871,9 +871,13 @@ impl EventProcessor {
         }
     }
 
-    fn xinput_key_input<F>(&mut self, xev: &mut XKeyEvent, state: ElementState, mut callback: F)
-    where
-        F: FnMut(&RootAEL, Event),
+    fn xinput_key_input<T: 'static, F>(
+        &mut self,
+        xev: &mut XKeyEvent,
+        state: ElementState,
+        mut callback: F,
+    ) where
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -985,13 +989,13 @@ impl EventProcessor {
         }
     }
 
-    fn send_synthic_modifier_from_core<F>(
+    fn send_synthic_modifier_from_core<T: 'static, F>(
         &mut self,
         window_id: crate::window::WindowId,
         state: u16,
         mut callback: F,
     ) where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let keymap = match self.xkb_context.keymap_mut() {
             Some(keymap) => keymap,
@@ -1018,9 +1022,13 @@ impl EventProcessor {
         callback(&self.target, event);
     }
 
-    fn xinput2_button_input<F>(&self, event: &XIDeviceEvent, state: ElementState, mut callback: F)
-    where
-        F: FnMut(&RootAEL, Event),
+    fn xinput2_button_input<T: 'static, F>(
+        &self,
+        event: &XIDeviceEvent,
+        state: ElementState,
+        mut callback: F,
+    ) where
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
         let window_id = mkwid(event.event as xproto::Window);
@@ -1071,9 +1079,9 @@ impl EventProcessor {
         callback(&self.target, event);
     }
 
-    fn xinput2_mouse_motion<F>(&self, event: &XIDeviceEvent, mut callback: F)
+    fn xinput2_mouse_motion<T: 'static, F>(&self, event: &XIDeviceEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -1149,9 +1157,9 @@ impl EventProcessor {
         }
     }
 
-    fn xinput2_mouse_enter<F>(&self, event: &XIEnterEvent, mut callback: F)
+    fn xinput2_mouse_enter<T: 'static, F>(&self, event: &XIEnterEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -1194,9 +1202,9 @@ impl EventProcessor {
         }
     }
 
-    fn xinput2_mouse_left<F>(&self, event: &XILeaveEvent, mut callback: F)
+    fn xinput2_mouse_left<T: 'static, F>(&self, event: &XILeaveEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
         let window = event.event as xproto::Window;
@@ -1217,9 +1225,9 @@ impl EventProcessor {
         }
     }
 
-    fn xinput2_focused<F>(&mut self, xev: &XIFocusInEvent, mut callback: F)
+    fn xinput2_focused<T: 'static, F>(&mut self, xev: &XIFocusInEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
         let window = xev.event as xproto::Window;
@@ -1276,9 +1284,9 @@ impl EventProcessor {
         callback(&self.target, event);
     }
 
-    fn xinput2_unfocused<F>(&mut self, xev: &XIFocusOutEvent, mut callback: F)
+    fn xinput2_unfocused<T: 'static, F>(&mut self, xev: &XIFocusOutEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
         let window = xev.event as xproto::Window;
@@ -1328,9 +1336,13 @@ impl EventProcessor {
         }
     }
 
-    fn xinput2_touch<F>(&mut self, xev: &XIDeviceEvent, phase: TouchPhase, mut callback: F)
-    where
-        F: FnMut(&RootAEL, Event),
+    fn xinput2_touch<T: 'static, F>(
+        &mut self,
+        xev: &XIDeviceEvent,
+        phase: TouchPhase,
+        mut callback: F,
+    ) where
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -1370,9 +1382,13 @@ impl EventProcessor {
         }
     }
 
-    fn xinput2_raw_button_input<F>(&self, xev: &XIRawEvent, state: ElementState, mut callback: F)
-    where
-        F: FnMut(&RootAEL, Event),
+    fn xinput2_raw_button_input<T: 'static, F>(
+        &self,
+        xev: &XIRawEvent,
+        state: ElementState,
+        mut callback: F,
+    ) where
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -1388,9 +1404,9 @@ impl EventProcessor {
         }
     }
 
-    fn xinput2_raw_mouse_motion<F>(&self, xev: &XIRawEvent, mut callback: F)
+    fn xinput2_raw_mouse_motion<T: 'static, F>(&self, xev: &XIRawEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -1448,9 +1464,13 @@ impl EventProcessor {
         }
     }
 
-    fn xinput2_raw_key_input<F>(&mut self, xev: &XIRawEvent, state: ElementState, mut callback: F)
-    where
-        F: FnMut(&RootAEL, Event),
+    fn xinput2_raw_key_input<T: 'static, F>(
+        &mut self,
+        xev: &XIRawEvent,
+        state: ElementState,
+        mut callback: F,
+    ) where
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -1470,9 +1490,9 @@ impl EventProcessor {
         });
     }
 
-    fn xinput2_hierarchy_changed<F>(&mut self, xev: &XIHierarchyEvent, mut callback: F)
+    fn xinput2_hierarchy_changed<T: 'static, F>(&mut self, xev: &XIHierarchyEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -1497,9 +1517,9 @@ impl EventProcessor {
         }
     }
 
-    fn xkb_event<F>(&mut self, xev: &XkbAnyEvent, mut callback: F)
+    fn xkb_event<T: 'static, F>(&mut self, xev: &XkbAnyEvent, mut callback: F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
         match xev.xkb_type {
@@ -1576,14 +1596,14 @@ impl EventProcessor {
         }
     }
 
-    pub(crate) fn update_mods_from_xinput2_event<F>(
+    pub fn update_mods_from_xinput2_event<T: 'static, F>(
         &mut self,
         mods: &XIModifierState,
         group: &XIModifierState,
         force: bool,
         mut callback: F,
     ) where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         if let Some(state) = self.xkb_context.state_mut() {
             state.update_modifiers(
@@ -1607,9 +1627,12 @@ impl EventProcessor {
         }
     }
 
-    fn update_mods_from_query<F>(&mut self, window_id: crate::window::WindowId, mut callback: F)
-    where
-        F: FnMut(&RootAEL, Event),
+    fn update_mods_from_query<T: 'static, F>(
+        &mut self,
+        window_id: crate::window::WindowId,
+        mut callback: F,
+    ) where
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
 
@@ -1638,13 +1661,13 @@ impl EventProcessor {
         self.send_modifiers(window_id, mods.into(), true, &mut callback)
     }
 
-    pub(crate) fn update_mods_from_core_event<F>(
+    pub fn update_mods_from_core_event<T: 'static, F>(
         &mut self,
         window_id: crate::window::WindowId,
         state: u16,
         mut callback: F,
     ) where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let xkb_mask = self.xkb_mod_mask_from_core(state);
         let xkb_state = match self.xkb_context.state_mut() {
@@ -1717,7 +1740,7 @@ impl EventProcessor {
     ///
     /// The event won't be sent when the `modifiers` match the previously `sent` modifiers value,
     /// unless `force` is passed. The `force` should be passed when the active window changes.
-    fn send_modifiers<F: FnMut(&RootAEL, Event)>(
+    fn send_modifiers<T: 'static, F: FnMut(&RootAEL, Event<T>)>(
         &self,
         window_id: crate::window::WindowId,
         modifiers: ModifiersState,
@@ -1735,14 +1758,14 @@ impl EventProcessor {
         }
     }
 
-    fn handle_pressed_keys<F>(
+    fn handle_pressed_keys<T: 'static, F>(
         target: &RootAEL,
         window_id: crate::window::WindowId,
         state: ElementState,
         xkb_context: &mut Context,
         callback: &mut F,
     ) where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let device_id = mkdid(util::VIRTUAL_CORE_KEYBOARD);
 
@@ -1777,9 +1800,9 @@ impl EventProcessor {
         }
     }
 
-    fn process_dpi_change<F>(&self, callback: &mut F)
+    fn process_dpi_change<T: 'static, F>(&self, callback: &mut F)
     where
-        F: FnMut(&RootAEL, Event),
+        F: FnMut(&RootAEL, Event<T>),
     {
         let wt = Self::window_target(&self.target);
         wt.xconn.reload_database().expect("failed to reload Xft database");

src/platform_impl/linux/x11/mod.rs

@@ -9,7 +9,7 @@ use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
 use std::sync::{Arc, Weak};
 use std::time::{Duration, Instant};
-use std::{fmt, mem, ptr, slice, str};
+use std::{fmt, ptr, slice, str};
 
 use calloop::generic::Generic;
 use calloop::ping::Ping;
@@ -25,10 +25,9 @@ use x11rb::protocol::xproto::{self, ConnectionExt as _};
 use x11rb::x11_utils::X11Error as LogicalError;
 use x11rb::xcb_ffi::ReplyOrIdError;
 
-use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, OsError as RootOsError};
 use crate::event::{Event, StartCause, WindowEvent};
-use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents};
+use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents, EventLoopClosed};
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::common::xkb::Context;
 use crate::platform_impl::platform::{min_timeout, WindowId};
@@ -81,11 +80,12 @@ impl<T> Clone for WakeSender<T> {
 }
 
 impl<T> WakeSender<T> {
-    pub fn send(&self, t: T) {
-        let res = self.sender.send(t);
+    pub fn send(&self, t: T) -> Result<(), EventLoopClosed<T>> {
+        let res = self.sender.send(t).map_err(|e| EventLoopClosed(e.0));
         if res.is_ok() {
             self.waker.ping();
         }
+        res
     }
 }
 
@@ -140,13 +140,15 @@ pub struct ActiveEventLoop {
     device_events: Cell<DeviceEvents>,
 }
 
-pub struct EventLoop {
+pub struct EventLoop<T: 'static> {
     loop_running: bool,
     event_loop: Loop<'static, EventLoopState>,
+    waker: calloop::ping::Ping,
     event_processor: EventProcessor,
     redraw_receiver: PeekableReceiver<WindowId>,
+    user_receiver: PeekableReceiver<T>,
     activation_receiver: PeekableReceiver<ActivationToken>,
-    event_loop_proxy: EventLoopProxy,
+    user_sender: Sender<T>,
 
     /// The current state of the event loop.
     state: EventLoopState,
@@ -157,13 +159,20 @@ type ActivationToken = (WindowId, crate::event_loop::AsyncRequestSerial);
 struct EventLoopState {
     /// The latest readiness state for the x11 file descriptor
     x11_readiness: Readiness,
-
-    /// User requested a wake up.
-    proxy_wake_up: bool,
 }
 
-impl EventLoop {
-    pub(crate) fn new(xconn: Arc<XConnection>) -> EventLoop {
+pub struct EventLoopProxy<T: 'static> {
+    user_sender: WakeSender<T>,
+}
+
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        EventLoopProxy { user_sender: self.user_sender.clone() }
+    }
+}
+
+impl<T: 'static> EventLoop<T> {
+    pub(crate) fn new(xconn: Arc<XConnection>) -> EventLoop<T> {
         let root = xconn.default_root().root;
         let atoms = xconn.atoms();
 
@@ -267,16 +276,7 @@ impl EventLoop {
         let (activation_token_sender, activation_token_channel) = mpsc::channel();
 
         // Create a channel for sending user events.
-        let (user_waker, user_waker_source) =
-            calloop::ping::make_ping().expect("Failed to create user event loop waker.");
-        event_loop
-            .handle()
-            .insert_source(user_waker_source, move |_, _, state| {
-                // No extra handling is required, we just need to wake-up.
-                state.proxy_wake_up = true;
-            })
-            .expect("Failed to register the event loop waker source");
-        let event_loop_proxy = EventLoopProxy::new(user_waker);
+        let (user_sender, user_channel) = mpsc::channel();
 
         let xkb_context =
             Context::from_x11_xkb(xconn.xcb_connection().get_raw_xcb_connection()).unwrap();
@@ -357,32 +357,32 @@ impl EventLoop {
         EventLoop {
             loop_running: false,
             event_loop,
+            waker,
             event_processor,
             redraw_receiver: PeekableReceiver::from_recv(redraw_channel),
             activation_receiver: PeekableReceiver::from_recv(activation_token_channel),
-            event_loop_proxy,
-            state: EventLoopState { x11_readiness: Readiness::EMPTY, proxy_wake_up: false },
+            user_receiver: PeekableReceiver::from_recv(user_channel),
+            user_sender,
+            state: EventLoopState { x11_readiness: Readiness::EMPTY },
         }
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy {
-        self.event_loop_proxy.clone()
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy {
+            user_sender: WakeSender { sender: self.user_sender.clone(), waker: self.waker.clone() },
+        }
     }
 
     pub(crate) fn window_target(&self) -> &RootAEL {
         &self.event_processor.target
     }
 
-    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
-    }
-
-    pub fn run_app_on_demand<A: ApplicationHandler>(
-        &mut self,
-        app: &mut A,
-    ) -> Result<(), EventLoopError> {
+    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<T>, &RootAEL),
+    {
         let exit = loop {
-            match self.pump_app_events(None, app) {
+            match self.pump_events(None, &mut event_handler) {
                 PumpStatus::Exit(0) => {
                     break Ok(());
                 },
@@ -407,27 +407,26 @@ impl EventLoop {
         exit
     }
 
-    pub fn pump_app_events<A: ApplicationHandler>(
-        &mut self,
-        timeout: Option<Duration>,
-        app: &mut A,
-    ) -> PumpStatus {
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
+    where
+        F: FnMut(Event<T>, &RootAEL),
+    {
         if !self.loop_running {
             self.loop_running = true;
 
             // run the initial loop iteration
-            self.single_iteration(app, StartCause::Init);
+            self.single_iteration(&mut callback, StartCause::Init);
         }
 
         // Consider the possibility that the `StartCause::Init` iteration could
         // request to Exit.
         if !self.exiting() {
-            self.poll_events_with_timeout(timeout, app);
+            self.poll_events_with_timeout(timeout, &mut callback);
         }
         if let Some(code) = self.exit_code() {
             self.loop_running = false;
 
-            app.exiting(self.window_target());
+            callback(Event::LoopExiting, self.window_target());
 
             PumpStatus::Exit(code)
         } else {
@@ -437,15 +436,14 @@ impl EventLoop {
 
     fn has_pending(&mut self) -> bool {
         self.event_processor.poll()
-            || self.state.proxy_wake_up
+            || self.user_receiver.has_incoming()
             || self.redraw_receiver.has_incoming()
     }
 
-    pub fn poll_events_with_timeout<A: ApplicationHandler>(
-        &mut self,
-        mut timeout: Option<Duration>,
-        app: &mut A,
-    ) {
+    pub fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
+    where
+        F: FnMut(Event<T>, &RootAEL),
+    {
         let start = Instant::now();
 
         let has_pending = self.has_pending();
@@ -503,20 +501,23 @@ impl EventLoop {
             return;
         }
 
-        self.single_iteration(app, cause);
+        self.single_iteration(&mut callback, cause);
     }
 
-    fn single_iteration<A: ApplicationHandler>(&mut self, app: &mut A, cause: StartCause) {
-        app.new_events(&self.event_processor.target, cause);
+    fn single_iteration<F>(&mut self, callback: &mut F, cause: StartCause)
+    where
+        F: FnMut(Event<T>, &RootAEL),
+    {
+        callback(Event::NewEvents(cause), &self.event_processor.target);
 
         // NB: For consistency all platforms must emit a 'resumed' event even though X11
         // applications don't themselves have a formal suspend/resume lifecycle.
         if cause == StartCause::Init {
-            app.resumed(&self.event_processor.target)
+            callback(Event::Resumed, &self.event_processor.target);
         }
 
         // Process all pending events
-        self.drain_events(app);
+        self.drain_events(callback);
 
         // Empty activation tokens.
         while let Ok((window_id, serial)) = self.activation_receiver.try_recv() {
@@ -526,12 +527,14 @@ impl EventLoop {
 
             match token {
                 Some(Ok(token)) => {
-                    let window_id = crate::window::WindowId(window_id);
-                    let event = WindowEvent::ActivationTokenDone {
-                        serial,
-                        token: crate::window::ActivationToken::_new(token),
+                    let event = Event::WindowEvent {
+                        window_id: crate::window::WindowId(window_id),
+                        event: WindowEvent::ActivationTokenDone {
+                            serial,
+                            token: crate::window::ActivationToken::_new(token),
+                        },
                     };
-                    app.window_event(&self.event_processor.target, window_id, event);
+                    callback(event, &self.event_processor.target)
                 },
                 Some(Err(e)) => {
                     tracing::error!("Failed to get activation token: {}", e);
@@ -541,8 +544,10 @@ impl EventLoop {
         }
 
         // Empty the user event buffer
-        if mem::take(&mut self.state.proxy_wake_up) {
-            app.proxy_wake_up(&self.event_processor.target);
+        {
+            while let Ok(event) = self.user_receiver.try_recv() {
+                callback(Event::UserEvent(event), &self.event_processor.target);
+            }
         }
 
         // Empty the redraw requests
@@ -555,41 +560,37 @@ impl EventLoop {
 
             for window_id in windows {
                 let window_id = crate::window::WindowId(window_id);
-                app.window_event(
+                callback(
+                    Event::WindowEvent { window_id, event: WindowEvent::RedrawRequested },
                     &self.event_processor.target,
-                    window_id,
-                    WindowEvent::RedrawRequested,
                 );
             }
         }
 
         // This is always the last event we dispatch before poll again
-        app.about_to_wait(&self.event_processor.target);
+        {
+            callback(Event::AboutToWait, &self.event_processor.target);
+        }
     }
 
-    fn drain_events<A: ApplicationHandler>(&mut self, app: &mut A) {
+    fn drain_events<F>(&mut self, callback: &mut F)
+    where
+        F: FnMut(Event<T>, &RootAEL),
+    {
         let mut xev = MaybeUninit::uninit();
 
         while unsafe { self.event_processor.poll_one_event(xev.as_mut_ptr()) } {
             let mut xev = unsafe { xev.assume_init() };
-            self.event_processor.process_event(&mut xev, |window_target, event: Event| {
+            self.event_processor.process_event(&mut xev, |window_target, event| {
                 if let Event::WindowEvent {
                     window_id: crate::window::WindowId(wid),
                     event: WindowEvent::RedrawRequested,
                 } = event
                 {
                     let window_target = EventProcessor::window_target(window_target);
-                    window_target.redraw_sender.send(wid);
+                    window_target.redraw_sender.send(wid).unwrap();
                 } else {
-                    match event {
-                        Event::WindowEvent { window_id, event } => {
-                            app.window_event(window_target, window_id, event)
-                        },
-                        Event::DeviceEvent { device_id, event } => {
-                            app.device_event(window_target, device_id, event)
-                        },
-                        _ => unreachable!("event which is neither device nor window event."),
-                    }
+                    callback(event, window_target);
                 }
             });
         }
@@ -616,13 +617,13 @@ impl EventLoop {
     }
 }
 
-impl AsFd for EventLoop {
+impl<T> AsFd for EventLoop<T> {
     fn as_fd(&self) -> BorrowedFd<'_> {
         self.event_loop.as_fd()
     }
 }
 
-impl AsRawFd for EventLoop {
+impl<T> AsRawFd for EventLoop<T> {
     fn as_raw_fd(&self) -> RawFd {
         self.event_loop.as_raw_fd()
     }
@@ -722,9 +723,9 @@ impl ActiveEventLoop {
     }
 }
 
-impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        self.ping.ping();
+impl<T: 'static> EventLoopProxy<T> {
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.user_sender.send(event).map_err(|e| EventLoopClosed(e.0))
     }
 }
 
@@ -808,17 +809,6 @@ impl Drop for Window {
     }
 }
 
-#[derive(Clone)]
-pub struct EventLoopProxy {
-    ping: Ping,
-}
-
-impl EventLoopProxy {
-    fn new(ping: Ping) -> Self {
-        Self { ping }
-    }
-}
-
 /// Generic sum error type for X11 errors.
 #[derive(Debug)]
 pub enum X11Error {

src/platform_impl/linux/x11/window.rs

@@ -876,11 +876,11 @@ impl UnownedWindow {
 
     /// Refresh the API for the given monitor.
     #[inline]
-    pub(super) fn refresh_dpi_for_monitor(
+    pub(super) fn refresh_dpi_for_monitor<T: 'static>(
         &self,
         new_monitor: &X11MonitorHandle,
         maybe_prev_scale_factor: Option<f64>,
-        mut callback: impl FnMut(Event),
+        mut callback: impl FnMut(Event<T>),
     ) {
         // Check if the self is on this monitor
         let monitor = self.shared_state_lock().last_monitor.clone();
@@ -1805,7 +1805,9 @@ impl UnownedWindow {
     #[inline]
     pub fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError> {
         let serial = AsyncRequestSerial::get();
-        self.activation_sender.send((self.id(), serial));
+        self.activation_sender
+            .send((self.id(), serial))
+            .expect("activation token channel should never be closed");
         Ok(serial)
     }
 
@@ -1816,7 +1818,7 @@ impl UnownedWindow {
 
     #[inline]
     pub fn request_redraw(&self) {
-        self.redraw_sender.send(WindowId(self.xwindow as _));
+        self.redraw_sender.send(WindowId(self.xwindow as _)).unwrap();
     }
 
     #[inline]

src/platform_impl/macos/app.rs

@@ -5,7 +5,6 @@ use objc2_app_kit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType, N
 use objc2_foundation::{MainThreadMarker, NSObject};
 
 use super::app_state::ApplicationDelegate;
-use super::DEVICE_ID;
 use crate::event::{DeviceEvent, ElementState};
 
 declare_class!(
@@ -58,47 +57,29 @@ fn maybe_dispatch_device_event(delegate: &ApplicationDelegate, event: &NSEvent)
             let delta_y = unsafe { event.deltaY() } as f64;
 
             if delta_x != 0.0 {
-                delegate.maybe_queue_with_handler(move |app, event_loop| {
-                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::Motion {
-                        axis: 0,
-                        value: delta_x,
-                    });
-                });
+                delegate.maybe_queue_device_event(DeviceEvent::Motion { axis: 0, value: delta_x });
             }
 
             if delta_y != 0.0 {
-                delegate.maybe_queue_with_handler(move |app, event_loop| {
-                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::Motion {
-                        axis: 1,
-                        value: delta_y,
-                    });
-                })
+                delegate.maybe_queue_device_event(DeviceEvent::Motion { axis: 1, value: delta_y })
             }
 
             if delta_x != 0.0 || delta_y != 0.0 {
-                delegate.maybe_queue_with_handler(move |app, event_loop| {
-                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseMotion {
-                        delta: (delta_x, delta_y),
-                    });
+                delegate.maybe_queue_device_event(DeviceEvent::MouseMotion {
+                    delta: (delta_x, delta_y),
                 });
             }
         },
         NSEventType::LeftMouseDown | NSEventType::RightMouseDown | NSEventType::OtherMouseDown => {
-            let button = unsafe { event.buttonNumber() } as u32;
-            delegate.maybe_queue_with_handler(move |app, event_loop| {
-                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
-                    button,
-                    state: ElementState::Pressed,
-                });
+            delegate.maybe_queue_device_event(DeviceEvent::Button {
+                button: unsafe { event.buttonNumber() } as u32,
+                state: ElementState::Pressed,
             });
         },
         NSEventType::LeftMouseUp | NSEventType::RightMouseUp | NSEventType::OtherMouseUp => {
-            let button = unsafe { event.buttonNumber() } as u32;
-            delegate.maybe_queue_with_handler(move |app, event_loop| {
-                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
-                    button,
-                    state: ElementState::Released,
-                });
+            delegate.maybe_queue_device_event(DeviceEvent::Button {
+                button: unsafe { event.buttonNumber() } as u32,
+                state: ElementState::Released,
             });
         },
         _ => (),

src/platform_impl/macos/app_state.rs

@@ -1,8 +1,6 @@
 use std::cell::{Cell, RefCell};
 use std::mem;
 use std::rc::Weak;
-use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
-use std::sync::Arc;
 use std::time::Instant;
 
 use objc2::rc::Retained;
@@ -10,15 +8,13 @@ use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
 use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSApplicationDelegate};
 use objc2_foundation::{MainThreadMarker, NSNotification, NSObject, NSObjectProtocol};
 
-use crate::application::ApplicationHandler;
-use crate::event::{StartCause, WindowEvent};
-use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
-use crate::window::WindowId as RootWindowId;
-
 use super::event_handler::EventHandler;
 use super::event_loop::{stop_app_immediately, ActiveEventLoop, PanicInfo};
 use super::observer::{EventLoopWaker, RunLoop};
-use super::{menu, WindowId};
+use super::{menu, WindowId, DEVICE_ID};
+use crate::event::{DeviceEvent, Event, StartCause, WindowEvent};
+use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
+use crate::window::WindowId as RootWindowId;
 
 #[derive(Debug)]
 pub(super) struct AppState {
@@ -26,7 +22,6 @@ pub(super) struct AppState {
     default_menu: bool,
     activate_ignoring_other_apps: bool,
     run_loop: RunLoop,
-    proxy_wake_up: Arc<AtomicBool>,
     event_handler: EventHandler,
     stop_on_launch: Cell<bool>,
     stop_before_wait: Cell<bool>,
@@ -80,13 +75,11 @@ impl ApplicationDelegate {
     pub(super) fn new(
         mtm: MainThreadMarker,
         activation_policy: NSApplicationActivationPolicy,
-        proxy_wake_up: Arc<AtomicBool>,
         default_menu: bool,
         activate_ignoring_other_apps: bool,
     ) -> Retained<Self> {
         let this = mtm.alloc().set_ivars(AppState {
             activation_policy,
-            proxy_wake_up,
             default_menu,
             activate_ignoring_other_apps,
             run_loop: RunLoop::main(mtm),
@@ -173,7 +166,7 @@ impl ApplicationDelegate {
     /// of the given closure.
     pub fn set_event_handler<R>(
         &self,
-        handler: &mut dyn ApplicationHandler,
+        handler: impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop),
         closure: impl FnOnce() -> R,
     ) -> R {
         self.ivars().event_handler.set(handler, closure)
@@ -207,9 +200,7 @@ impl ApplicationDelegate {
     /// NOTE: that if the `NSApplication` has been launched then that state is preserved,
     /// and we won't need to re-launch the app if subsequent EventLoops are run.
     pub fn internal_exit(&self) {
-        self.with_handler(|app, event_loop| {
-            app.exiting(event_loop);
-        });
+        self.handle_event(Event::LoopExiting);
 
         self.set_is_running(false);
         self.set_stop_on_redraw(false);
@@ -250,13 +241,26 @@ impl ApplicationDelegate {
         self.ivars().control_flow.get()
     }
 
+    pub fn maybe_queue_window_event(&self, window_id: WindowId, event: WindowEvent) {
+        self.maybe_queue_event(Event::WindowEvent { window_id: RootWindowId(window_id), event });
+    }
+
+    pub fn handle_window_event(&self, window_id: WindowId, event: WindowEvent) {
+        self.handle_event(Event::WindowEvent { window_id: RootWindowId(window_id), event });
+    }
+
+    pub fn maybe_queue_device_event(&self, event: DeviceEvent) {
+        self.maybe_queue_event(Event::DeviceEvent { device_id: DEVICE_ID, event });
+    }
+
     pub fn handle_redraw(&self, window_id: WindowId) {
         let mtm = MainThreadMarker::from(self);
         // Redraw request might come out of order from the OS.
         // -> Don't go back into the event handler when our callstack originates from there
         if !self.ivars().event_handler.in_use() {
-            self.with_handler(|app, event_loop| {
-                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
+            self.handle_event(Event::WindowEvent {
+                window_id: RootWindowId(window_id),
+                event: WindowEvent::RedrawRequested,
             });
 
             // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested
@@ -278,10 +282,7 @@ impl ApplicationDelegate {
     }
 
     #[track_caller]
-    pub fn maybe_queue_with_handler(
-        &self,
-        callback: impl FnOnce(&mut dyn ApplicationHandler, &RootActiveEventLoop) + 'static,
-    ) {
+    fn maybe_queue_event(&self, event: Event<HandlePendingUserEvents>) {
         // Most programmer actions in AppKit (e.g. change window fullscreen, set focused, etc.)
         // result in an event being queued, and applied at a later point.
         //
@@ -289,31 +290,25 @@ impl ApplicationDelegate {
         // so to make sure that we don't encounter re-entrancy issues, we first check if we're
         // currently handling another event, and if we are, we queue the event instead.
         if !self.ivars().event_handler.in_use() {
-            self.with_handler(callback);
+            self.handle_event(event);
         } else {
-            tracing::debug!("had to queue event since another is currently being handled");
+            tracing::debug!(?event, "had to queue event since another is currently being handled");
             let this = self.retain();
-            self.ivars().run_loop.queue_closure(move || {
-                this.with_handler(callback);
-            });
+            self.ivars().run_loop.queue_closure(move || this.handle_event(event));
         }
     }
 
     #[track_caller]
-    fn with_handler(
-        &self,
-        callback: impl FnOnce(&mut dyn ApplicationHandler, &RootActiveEventLoop),
-    ) {
-        let event_loop = ActiveEventLoop::new_root(self.retain());
-        self.ivars().event_handler.handle(callback, &event_loop);
+    fn handle_event(&self, event: Event<HandlePendingUserEvents>) {
+        self.ivars().event_handler.handle_event(event, &ActiveEventLoop::new_root(self.retain()))
     }
 
     /// dispatch `NewEvents(Init)` + `Resumed`
     pub fn dispatch_init_events(&self) {
-        self.with_handler(|app, event_loop| app.new_events(event_loop, StartCause::Init));
+        self.handle_event(Event::NewEvents(StartCause::Init));
         // NB: For consistency all platforms must emit a 'resumed' event even though macOS
         // applications don't themselves have a formal suspend/resume lifecycle.
-        self.with_handler(|app, event_loop| app.resumed(event_loop));
+        self.handle_event(Event::Resumed);
     }
 
     // Called by RunLoopObserver after finishing waiting for new events
@@ -323,7 +318,8 @@ impl ApplicationDelegate {
             .upgrade()
             .expect("The panic info must exist here. This failure indicates a developer error.");
 
-        if panic_info.is_panicking() || !self.is_running() {
+        // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
+        if panic_info.is_panicking() || !self.ivars().event_handler.ready() || !self.is_running() {
             return;
         }
 
@@ -345,7 +341,7 @@ impl ApplicationDelegate {
             },
         };
 
-        self.with_handler(|app, event_loop| app.new_events(event_loop, cause));
+        self.handle_event(Event::NewEvents(cause));
     }
 
     // Called by RunLoopObserver before waiting for new events
@@ -355,23 +351,24 @@ impl ApplicationDelegate {
             .upgrade()
             .expect("The panic info must exist here. This failure indicates a developer error.");
 
-        if panic_info.is_panicking() || !self.is_running() {
+        // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
+        // XXX: how does it make sense that `event_handler.ready()` can ever return `false` here if
+        // we're about to return to the `CFRunLoop` to poll for new events?
+        if panic_info.is_panicking() || !self.ivars().event_handler.ready() || !self.is_running() {
             return;
         }
 
-        if self.ivars().proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
-            self.with_handler(|app, event_loop| app.proxy_wake_up(event_loop));
-        }
+        self.handle_event(Event::UserEvent(HandlePendingUserEvents));
 
         let redraw = mem::take(&mut *self.ivars().pending_redraw.borrow_mut());
         for window_id in redraw {
-            self.with_handler(|app, event_loop| {
-                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
+            self.handle_event(Event::WindowEvent {
+                window_id: RootWindowId(window_id),
+                event: WindowEvent::RedrawRequested,
             });
         }
-        self.with_handler(|app, event_loop| {
-            app.about_to_wait(event_loop);
-        });
+
+        self.handle_event(Event::AboutToWait);
 
         if self.exiting() {
             let app = NSApplication::sharedApplication(mtm);
@@ -393,6 +390,9 @@ impl ApplicationDelegate {
     }
 }
 
+#[derive(Debug)]
+pub(crate) struct HandlePendingUserEvents;
+
 /// Returns the minimum `Option<Instant>`, taking into account that `None`
 /// equates to an infinite timeout, not a zero timeout (so can't just use
 /// `Option::min`)

src/platform_impl/macos/event.rs

@@ -7,12 +7,12 @@ use objc2_app_kit::{NSEvent, NSEventModifierFlags, NSEventSubtype, NSEventType};
 use objc2_foundation::{run_on_main, NSPoint};
 use smol_str::SmolStr;
 
-use super::ffi;
 use crate::event::{ElementState, KeyEvent, Modifiers};
 use crate::keyboard::{
     Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey, NativeKeyCode,
     PhysicalKey,
 };
+use crate::platform_impl::platform::ffi;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct KeyEventExtra {

src/platform_impl/macos/event_handler.rs

@@ -1,31 +1,32 @@
 use std::cell::RefCell;
 use std::{fmt, mem};
 
-use crate::application::ApplicationHandler;
+use super::app_state::HandlePendingUserEvents;
+use crate::event::Event;
 use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;
 
-#[derive(Default)]
+struct EventHandlerData {
+    #[allow(clippy::type_complexity)]
+    handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
+}
+
+impl fmt::Debug for EventHandlerData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventHandlerData").finish_non_exhaustive()
+    }
+}
+
+#[derive(Debug)]
 pub(crate) struct EventHandler {
     /// This can be in the following states:
     /// - Not registered by the event loop (None).
     /// - Present (Some(handler)).
     /// - Currently executing the handler / in use (RefCell borrowed).
-    inner: RefCell<Option<&'static mut dyn ApplicationHandler>>,
-}
-
-impl fmt::Debug for EventHandler {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let state = match self.inner.try_borrow().as_deref() {
-            Ok(Some(_)) => "<available>",
-            Ok(None) => "<not set>",
-            Err(_) => "<in use>",
-        };
-        f.debug_struct("EventHandler").field("state", &state).finish_non_exhaustive()
-    }
+    inner: RefCell<Option<EventHandlerData>>,
 }
 
 impl EventHandler {
-    pub(crate) fn new() -> Self {
+    pub(crate) const fn new() -> Self {
         Self { inner: RefCell::new(None) }
     }
 
@@ -36,7 +37,7 @@ impl EventHandler {
     /// from within the closure.
     pub(crate) fn set<'handler, R>(
         &self,
-        app: &'handler mut dyn ApplicationHandler,
+        handler: impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler,
         closure: impl FnOnce() -> R,
     ) -> R {
         // SAFETY: We extend the lifetime of the handler here so that we can
@@ -47,9 +48,9 @@ impl EventHandler {
         // extended beyond `'handler`.
         let handler = unsafe {
             mem::transmute::<
-                &'handler mut dyn ApplicationHandler,
-                &'static mut dyn ApplicationHandler,
-            >(app)
+                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler>,
+                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
+            >(Box::new(handler))
         };
 
         match self.inner.try_borrow_mut().as_deref_mut() {
@@ -57,7 +58,7 @@ impl EventHandler {
                 unreachable!("tried to set handler while another was already set");
             },
             Ok(data @ None) => {
-                *data = Some(handler);
+                *data = Some(EventHandlerData { handler });
             },
             Err(_) => {
                 unreachable!("tried to set handler that is currently in use");
@@ -104,20 +105,24 @@ impl EventHandler {
         self.inner.try_borrow().is_err()
     }
 
-    pub(crate) fn handle(
+    pub(crate) fn ready(&self) -> bool {
+        matches!(self.inner.try_borrow().as_deref(), Ok(Some(_)))
+    }
+
+    pub(crate) fn handle_event(
         &self,
-        callback: impl FnOnce(&mut dyn ApplicationHandler, &RootActiveEventLoop),
+        event: Event<HandlePendingUserEvents>,
         event_loop: &RootActiveEventLoop,
     ) {
         match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(user_app)) => {
+            Ok(Some(EventHandlerData { handler })) => {
                 // It is important that we keep the reference borrowed here,
                 // so that `in_use` can properly detect that the handler is
                 // still in use.
                 //
                 // If the handler unwinds, the `RefMut` will ensure that the
                 // handler is no longer borrowed.
-                callback(*user_app, event_loop);
+                (handler)(event, event_loop);
             },
             Ok(None) => {
                 // `NSApplication`, our app delegate and this handler are all

src/platform_impl/macos/event_loop.rs

@@ -6,13 +6,12 @@ use std::os::raw::c_void;
 use std::panic::{catch_unwind, resume_unwind, RefUnwindSafe, UnwindSafe};
 use std::ptr;
 use std::rc::{Rc, Weak};
-use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
-use std::sync::Arc;
+use std::sync::mpsc;
 use std::time::{Duration, Instant};
 
 use core_foundation::base::{CFIndex, CFRelease};
 use core_foundation::runloop::{
-    kCFRunLoopDefaultMode, CFRunLoopAddSource, CFRunLoopGetMain, CFRunLoopSourceContext,
+    kCFRunLoopCommonModes, CFRunLoopAddSource, CFRunLoopGetMain, CFRunLoopSourceContext,
     CFRunLoopSourceCreate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
 };
 use objc2::rc::{autoreleasepool, Retained};
@@ -22,16 +21,18 @@ use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSWindow};
 use objc2_foundation::{MainThreadMarker, NSObjectProtocol};
 
 use super::app::WinitApplication;
-use super::app_state::ApplicationDelegate;
-use super::cursor::CustomCursor;
+use super::app_state::{ApplicationDelegate, HandlePendingUserEvents};
 use super::event::dummy_event;
 use super::monitor::{self, MonitorHandle};
 use super::observer::setup_control_flow_observers;
-use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
-use crate::event_loop::{ActiveEventLoop as RootWindowTarget, ControlFlow, DeviceEvents};
+use crate::event::Event;
+use crate::event_loop::{
+    ActiveEventLoop as RootWindowTarget, ControlFlow, DeviceEvents, EventLoopClosed,
+};
 use crate::platform::macos::ActivationPolicy;
 use crate::platform::pump_events::PumpStatus;
+use crate::platform_impl::platform::cursor::CustomCursor;
 use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource};
 
 #[derive(Default)]
@@ -154,7 +155,21 @@ impl ActiveEventLoop {
     }
 }
 
-pub struct EventLoop {
+fn map_user_event<T: 'static>(
+    mut handler: impl FnMut(Event<T>, &RootWindowTarget),
+    receiver: Rc<mpsc::Receiver<T>>,
+) -> impl FnMut(Event<HandlePendingUserEvents>, &RootWindowTarget) {
+    move |event, window_target| match event.map_nonuser_event() {
+        Ok(event) => (handler)(event, window_target),
+        Err(_) => {
+            for event in receiver.try_iter() {
+                (handler)(Event::UserEvent(event), window_target);
+            }
+        },
+    }
+}
+
+pub struct EventLoop<T: 'static> {
     /// Store a reference to the application for convenience.
     ///
     /// We intentionally don't store `WinitApplication` since we want to have
@@ -166,7 +181,9 @@ pub struct EventLoop {
     /// keep it around here as well.
     delegate: Retained<ApplicationDelegate>,
 
-    proxy_wake_up: Arc<AtomicBool>,
+    // Event sender and receiver, used for EventLoopProxy.
+    sender: mpsc::Sender<T>,
+    receiver: Rc<mpsc::Receiver<T>>,
 
     window_target: RootWindowTarget,
     panic_info: Rc<PanicInfo>,
@@ -189,7 +206,7 @@ impl Default for PlatformSpecificEventLoopAttributes {
     }
 }
 
-impl EventLoop {
+impl<T> EventLoop<T> {
     pub(crate) fn new(
         attributes: &PlatformSpecificEventLoopAttributes,
     ) -> Result<Self, EventLoopError> {
@@ -211,13 +228,9 @@ impl EventLoop {
             ActivationPolicy::Accessory => NSApplicationActivationPolicy::Accessory,
             ActivationPolicy::Prohibited => NSApplicationActivationPolicy::Prohibited,
         };
-
-        let proxy_wake_up = Arc::new(AtomicBool::new(false));
-
         let delegate = ApplicationDelegate::new(
             mtm,
             activation_policy,
-            proxy_wake_up.clone(),
             attributes.default_menu,
             attributes.activate_ignoring_other_apps,
         );
@@ -229,14 +242,16 @@ impl EventLoop {
         let panic_info: Rc<PanicInfo> = Default::default();
         setup_control_flow_observers(mtm, Rc::downgrade(&panic_info));
 
+        let (sender, receiver) = mpsc::channel();
         Ok(EventLoop {
             app,
             delegate: delegate.clone(),
+            sender,
+            receiver: Rc::new(receiver),
             window_target: RootWindowTarget {
                 p: ActiveEventLoop { delegate, mtm },
                 _marker: PhantomData,
             },
-            proxy_wake_up,
             panic_info,
         })
     }
@@ -245,19 +260,24 @@ impl EventLoop {
         &self.window_target
     }
 
-    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
+    pub fn run<F>(mut self, handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<T>, &RootWindowTarget),
+    {
+        self.run_on_demand(handler)
     }
 
     // NB: we don't base this on `pump_events` because for `MacOs` we can't support
     // `pump_events` elegantly (we just ask to run the loop for a "short" amount of
     // time and so a layered implementation would end up using a lot of CPU due to
     // redundant wake ups.
-    pub fn run_app_on_demand<A: ApplicationHandler>(
-        &mut self,
-        app: &mut A,
-    ) -> Result<(), EventLoopError> {
-        self.delegate.set_event_handler(app, || {
+    pub fn run_on_demand<F>(&mut self, handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<T>, &RootWindowTarget),
+    {
+        let handler = map_user_event(handler, self.receiver.clone());
+
+        self.delegate.set_event_handler(handler, || {
             autoreleasepool(|_| {
                 // clear / normalize pump_events state
                 self.delegate.set_wait_timeout(None);
@@ -290,12 +310,13 @@ impl EventLoop {
         Ok(())
     }
 
-    pub fn pump_app_events<A: ApplicationHandler>(
-        &mut self,
-        timeout: Option<Duration>,
-        app: &mut A,
-    ) -> PumpStatus {
-        self.delegate.set_event_handler(app, || {
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, handler: F) -> PumpStatus
+    where
+        F: FnMut(Event<T>, &RootWindowTarget),
+    {
+        let handler = map_user_event(handler, self.receiver.clone());
+
+        self.delegate.set_event_handler(handler, || {
             autoreleasepool(|_| {
                 // As a special case, if the application hasn't been launched yet then we at least
                 // run the loop until it has fully launched.
@@ -359,8 +380,8 @@ impl EventLoop {
         })
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy {
-        EventLoopProxy::new(self.proxy_wake_up.clone())
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.sender.clone())
     }
 }
 
@@ -418,15 +439,15 @@ pub fn stop_app_on_panic<F: FnOnce() -> R + UnwindSafe, R>(
     }
 }
 
-pub struct EventLoopProxy {
-    proxy_wake_up: Arc<AtomicBool>,
+pub struct EventLoopProxy<T> {
+    sender: mpsc::Sender<T>,
     source: CFRunLoopSourceRef,
 }
 
-unsafe impl Send for EventLoopProxy {}
-unsafe impl Sync for EventLoopProxy {}
+unsafe impl<T: Send> Send for EventLoopProxy<T> {}
+unsafe impl<T: Send> Sync for EventLoopProxy<T> {}
 
-impl Drop for EventLoopProxy {
+impl<T> Drop for EventLoopProxy<T> {
     fn drop(&mut self) {
         unsafe {
             CFRelease(self.source as _);
@@ -434,14 +455,14 @@ impl Drop for EventLoopProxy {
     }
 }
 
-impl Clone for EventLoopProxy {
+impl<T> Clone for EventLoopProxy<T> {
     fn clone(&self) -> Self {
-        EventLoopProxy::new(self.proxy_wake_up.clone())
+        EventLoopProxy::new(self.sender.clone())
     }
 }
 
-impl EventLoopProxy {
-    fn new(proxy_wake_up: Arc<AtomicBool>) -> Self {
+impl<T> EventLoopProxy<T> {
+    fn new(sender: mpsc::Sender<T>) -> Self {
         unsafe {
             // just wake up the eventloop
             extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
@@ -462,20 +483,21 @@ impl EventLoopProxy {
                 perform: event_loop_proxy_handler,
             };
             let source = CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::MAX - 1, &mut context);
-            CFRunLoopAddSource(rl, source, kCFRunLoopDefaultMode);
+            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
             CFRunLoopWakeUp(rl);
 
-            EventLoopProxy { proxy_wake_up, source }
+            EventLoopProxy { sender, source }
         }
     }
 
-    pub fn wake_up(&self) {
-        self.proxy_wake_up.store(true, AtomicOrdering::Relaxed);
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.sender.send(event).map_err(|mpsc::SendError(x)| EventLoopClosed(x))?;
         unsafe {
             // let the main thread know there's a new event
             CFRunLoopSourceSignal(self.source);
             let rl = CFRunLoopGetMain();
             CFRunLoopWakeUp(rl);
         }
+        Ok(())
     }
 }

src/platform_impl/macos/observer.rs

@@ -13,8 +13,8 @@ use block2::Block;
 use core_foundation::base::{CFIndex, CFOptionFlags, CFRelease, CFTypeRef};
 use core_foundation::date::CFAbsoluteTimeGetCurrent;
 use core_foundation::runloop::{
-    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopDefaultMode, kCFRunLoopExit,
-    CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddTimer, CFRunLoopGetMain,
+    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes, kCFRunLoopDefaultMode,
+    kCFRunLoopExit, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddTimer, CFRunLoopGetMain,
     CFRunLoopObserverCallBack, CFRunLoopObserverContext, CFRunLoopObserverCreate,
     CFRunLoopObserverRef, CFRunLoopRef, CFRunLoopTimerCreate, CFRunLoopTimerInvalidate,
     CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate, CFRunLoopWakeUp,
@@ -129,7 +129,7 @@ impl RunLoop {
                 context,
             )
         };
-        unsafe { CFRunLoopAddObserver(self.0, observer, kCFRunLoopDefaultMode) };
+        unsafe { CFRunLoopAddObserver(self.0, observer, kCFRunLoopCommonModes) };
     }
 
     /// Submit a closure to run on the main thread as the next step in the run loop, before other
@@ -267,7 +267,7 @@ impl EventLoopWaker {
                 wakeup_main_loop,
                 ptr::null_mut(),
             );
-            CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopDefaultMode);
+            CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopCommonModes);
             Self { timer, start_instant: Instant::now(), next_fire_date: None }
         }
     }

src/platform_impl/macos/util.rs

@@ -2,8 +2,7 @@ use tracing::trace;
 
 macro_rules! trace_scope {
     ($s:literal) => {
-        let _crate =
-            $crate::platform_impl::platform::appkit::util::TraceGuard::new(module_path!(), $s);
+        let _crate = $crate::platform_impl::platform::util::TraceGuard::new(module_path!(), $s);
     };
 }
 

src/platform_impl/macos/view.rs

@@ -31,7 +31,6 @@ use crate::event::{
 };
 use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey};
 use crate::platform::macos::OptionAsAlt;
-use crate::window::WindowId as RootWindowId;
 
 #[derive(Debug)]
 struct CursorState {
@@ -687,9 +686,7 @@ declare_class!(
 
             self.update_modifiers(event, false);
 
-            self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop|
-                app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseWheel { delta })
-            );
+            self.ivars().app_delegate.maybe_queue_device_event(DeviceEvent::MouseWheel { delta });
             self.queue_event(WindowEvent::MouseWheel {
                 device_id: DEVICE_ID,
                 delta,
@@ -833,10 +830,7 @@ impl WinitView {
     }
 
     fn queue_event(&self, event: WindowEvent) {
-        let window_id = RootWindowId(self.window().id());
-        self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop| {
-            app.window_event(event_loop, window_id, event);
-        });
+        self.ivars().app_delegate.maybe_queue_window_event(self.window().id(), event);
     }
 
     fn scale_factor(&self) -> f64 {

src/platform_impl/macos/window_delegate.rs

@@ -39,7 +39,7 @@ use crate::event::{InnerSizeWriter, WindowEvent};
 use crate::platform::macos::{OptionAsAlt, WindowExtMacOS};
 use crate::window::{
     Cursor, CursorGrabMode, Icon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-    WindowAttributes, WindowButtons, WindowId as RootWindowId, WindowLevel,
+    WindowAttributes, WindowButtons, WindowLevel,
 };
 
 #[derive(Clone, Debug)]
@@ -807,13 +807,11 @@ impl WindowDelegate {
     }
 
     pub(crate) fn queue_event(&self, event: WindowEvent) {
-        let window_id = RootWindowId(self.window().id());
-        self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop| {
-            app.window_event(event_loop, window_id, event);
-        });
+        self.ivars().app_delegate.maybe_queue_window_event(self.window().id(), event);
     }
 
     fn handle_scale_factor_changed(&self, scale_factor: CGFloat) {
+        let app_delegate = &self.ivars().app_delegate;
         let window = self.window();
 
         let content_size = window.contentRectForFrameRect(window.frame()).size;
@@ -821,7 +819,7 @@ impl WindowDelegate {
 
         let suggested_size = content_size.to_physical(scale_factor);
         let new_inner_size = Arc::new(Mutex::new(suggested_size));
-        self.queue_event(WindowEvent::ScaleFactorChanged {
+        app_delegate.handle_window_event(window.id(), WindowEvent::ScaleFactorChanged {
             scale_factor,
             inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
         });
@@ -833,7 +831,7 @@ impl WindowDelegate {
             let size = NSSize::new(logical_size.width, logical_size.height);
             window.setContentSize(size);
         }
-        self.queue_event(WindowEvent::Resized(physical_size));
+        app_delegate.handle_window_event(window.id(), WindowEvent::Resized(physical_size));
     }
 
     fn emit_move_event(&self) {

src/platform_impl/mod.rs

@@ -1,31 +1,27 @@
 use crate::monitor::{MonitorHandle as RootMonitorHandle, VideoModeHandle as RootVideoModeHandle};
 use crate::window::Fullscreen as RootFullscreen;
 
-#[cfg(android_platform)]
-mod android;
-#[cfg(target_vendor = "apple")]
-mod apple;
-#[cfg(any(x11_platform, wayland_platform))]
-mod linux;
-#[cfg(orbital_platform)]
-mod orbital;
-#[cfg(web_platform)]
-mod web;
 #[cfg(windows_platform)]
-mod windows;
-
-#[cfg(android_platform)]
-use self::android as platform;
-#[cfg(target_vendor = "apple")]
-use self::apple as platform;
+#[path = "windows/mod.rs"]
+mod platform;
 #[cfg(any(x11_platform, wayland_platform))]
-use self::linux as platform;
-#[cfg(orbital_platform)]
-use self::orbital as platform;
+#[path = "linux/mod.rs"]
+mod platform;
+#[cfg(macos_platform)]
+#[path = "macos/mod.rs"]
+mod platform;
+#[cfg(android_platform)]
+#[path = "android/mod.rs"]
+mod platform;
+#[cfg(ios_platform)]
+#[path = "ios/mod.rs"]
+mod platform;
 #[cfg(web_platform)]
-use self::web as platform;
-#[cfg(windows_platform)]
-use self::windows as platform;
+#[path = "web/mod.rs"]
+mod platform;
+#[cfg(orbital_platform)]
+#[path = "orbital/mod.rs"]
+mod platform;
 
 pub use self::platform::*;
 

src/platform_impl/orbital/event_loop.rs

@@ -12,7 +12,6 @@ use orbclient::{
 };
 use smol_str::SmolStr;
 
-use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
 use crate::event::{self, Ime, Modifiers, StartCause};
 use crate::event_loop::{self, ControlFlow, DeviceEvents};
@@ -272,18 +271,16 @@ impl EventState {
     }
 }
 
-pub struct EventLoop {
+pub struct EventLoop<T> {
     windows: Vec<(Arc<RedoxSocket>, EventState)>,
     window_target: event_loop::ActiveEventLoop,
-    user_events_sender: mpsc::SyncSender<()>,
-    user_events_receiver: mpsc::Receiver<()>,
+    user_events_sender: mpsc::Sender<T>,
+    user_events_receiver: mpsc::Receiver<T>,
 }
 
-impl EventLoop {
+impl<T: 'static> EventLoop<T> {
     pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
-        // NOTE: Create a channel which can hold only one event to automatically _squash_ user
-        // events.
-        let (user_events_sender, user_events_receiver) = mpsc::sync_channel(1);
+        let (user_events_sender, user_events_receiver) = mpsc::channel();
 
         let event_socket = Arc::new(
             RedoxSocket::event()
@@ -325,13 +322,14 @@ impl EventLoop {
         })
     }
 
-    fn process_event<A: ApplicationHandler>(
+    fn process_event<F>(
         window_id: WindowId,
         event_option: EventOption,
         event_state: &mut EventState,
-        window_target: &event_loop::ActiveEventLoop,
-        app: &mut A,
-    ) {
+        mut event_handler: F,
+    ) where
+        F: FnMut(event::Event<T>),
+    {
         match event_option {
             EventOption::Key(KeyEvent { character, scancode, pressed }) => {
                 // Convert scancode
@@ -373,128 +371,125 @@ impl EventLoop {
                     key_without_modifiers = logical_key.clone();
                 }
 
-                let window_id = RootWindowId(window_id);
-                let event = event::WindowEvent::KeyboardInput {
-                    device_id: event::DeviceId(DeviceId),
-                    event: event::KeyEvent {
-                        logical_key,
-                        physical_key,
-                        location: KeyLocation::Standard,
-                        state: element_state(pressed),
-                        repeat: false,
-                        text,
-                        platform_specific: KeyEventExtra {
-                            key_without_modifiers,
-                            text_with_all_modifiers,
+                event_handler(event::Event::WindowEvent {
+                    window_id: RootWindowId(window_id),
+                    event: event::WindowEvent::KeyboardInput {
+                        device_id: event::DeviceId(DeviceId),
+                        event: event::KeyEvent {
+                            logical_key,
+                            physical_key,
+                            location: KeyLocation::Standard,
+                            state: element_state(pressed),
+                            repeat: false,
+                            text,
+                            platform_specific: KeyEventExtra {
+                                key_without_modifiers,
+                                text_with_all_modifiers,
+                            },
                         },
+                        is_synthetic: false,
                     },
-                    is_synthetic: false,
-                };
-
-                app.window_event(window_target, window_id, event);
+                });
 
                 // If the state of the modifiers has changed, send the event.
                 if modifiers_before != event_state.keyboard {
-                    app.window_event(
-                        window_target,
-                        window_id,
-                        event::WindowEvent::ModifiersChanged(event_state.modifiers()),
-                    );
+                    event_handler(event::Event::WindowEvent {
+                        window_id: RootWindowId(window_id),
+                        event: event::WindowEvent::ModifiersChanged(event_state.modifiers()),
+                    })
                 }
             },
             EventOption::TextInput(TextInputEvent { character }) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::Ime(Ime::Preedit("".into(), None)),
-                );
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::Ime(Ime::Commit(character.into())),
-                );
+                event_handler(event::Event::WindowEvent {
+                    window_id: RootWindowId(window_id),
+                    event: event::WindowEvent::Ime(Ime::Preedit("".into(), None)),
+                });
+                event_handler(event::Event::WindowEvent {
+                    window_id: RootWindowId(window_id),
+                    event: event::WindowEvent::Ime(Ime::Commit(character.into())),
+                });
             },
             EventOption::Mouse(MouseEvent { x, y }) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::CursorMoved {
+                event_handler(event::Event::WindowEvent {
+                    window_id: RootWindowId(window_id),
+                    event: event::WindowEvent::CursorMoved {
                         device_id: event::DeviceId(DeviceId),
                         position: (x, y).into(),
                     },
-                );
+                });
             },
             EventOption::MouseRelative(MouseRelativeEvent { dx, dy }) => {
-                app.device_event(
-                    window_target,
-                    event::DeviceId(DeviceId),
-                    event::DeviceEvent::MouseMotion { delta: (dx as f64, dy as f64) },
-                );
+                event_handler(event::Event::DeviceEvent {
+                    device_id: event::DeviceId(DeviceId),
+                    event: event::DeviceEvent::MouseMotion { delta: (dx as f64, dy as f64) },
+                });
             },
             EventOption::Button(ButtonEvent { left, middle, right }) => {
                 while let Some((button, state)) = event_state.mouse(left, middle, right) {
-                    app.window_event(
-                        window_target,
-                        RootWindowId(window_id),
-                        event::WindowEvent::MouseInput {
+                    event_handler(event::Event::WindowEvent {
+                        window_id: RootWindowId(window_id),
+                        event: event::WindowEvent::MouseInput {
                             device_id: event::DeviceId(DeviceId),
                             state,
                             button,
                         },
-                    );
+                    });
                 }
             },
             EventOption::Scroll(ScrollEvent { x, y }) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::MouseWheel {
+                event_handler(event::Event::WindowEvent {
+                    window_id: RootWindowId(window_id),
+                    event: event::WindowEvent::MouseWheel {
                         device_id: event::DeviceId(DeviceId),
                         delta: event::MouseScrollDelta::LineDelta(x as f32, y as f32),
                         phase: event::TouchPhase::Moved,
                     },
-                );
+                });
             },
             EventOption::Quit(QuitEvent {}) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::CloseRequested,
-                );
+                event_handler(event::Event::WindowEvent {
+                    window_id: RootWindowId(window_id),
+                    event: event::WindowEvent::CloseRequested,
+                });
             },
             EventOption::Focus(FocusEvent { focused }) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::Focused(focused),
-                );
+                event_handler(event::Event::WindowEvent {
+                    window_id: RootWindowId(window_id),
+                    event: event::WindowEvent::Focused(focused),
+                });
             },
             EventOption::Move(MoveEvent { x, y }) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::Moved((x, y).into()),
-                );
+                event_handler(event::Event::WindowEvent {
+                    window_id: RootWindowId(window_id),
+                    event: event::WindowEvent::Moved((x, y).into()),
+                });
             },
             EventOption::Resize(ResizeEvent { width, height }) => {
-                app.window_event(
-                    window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::Resized((width, height).into()),
-                );
+                event_handler(event::Event::WindowEvent {
+                    window_id: RootWindowId(window_id),
+                    event: event::WindowEvent::Resized((width, height).into()),
+                });
 
                 // Acknowledge resize after event loop.
                 event_state.resize_opt = Some((width, height));
             },
             // TODO: Screen, Clipboard, Drop
             EventOption::Hover(HoverEvent { entered }) => {
-                let event = if entered {
-                    event::WindowEvent::CursorEntered { device_id: event::DeviceId(DeviceId) }
+                if entered {
+                    event_handler(event::Event::WindowEvent {
+                        window_id: RootWindowId(window_id),
+                        event: event::WindowEvent::CursorEntered {
+                            device_id: event::DeviceId(DeviceId),
+                        },
+                    });
                 } else {
-                    event::WindowEvent::CursorLeft { device_id: event::DeviceId(DeviceId) }
-                };
-
-                app.window_event(window_target, RootWindowId(window_id), event);
+                    event_handler(event::Event::WindowEvent {
+                        window_id: RootWindowId(window_id),
+                        event: event::WindowEvent::CursorLeft {
+                            device_id: event::DeviceId(DeviceId),
+                        },
+                    });
+                }
             },
             other => {
                 tracing::warn!("unhandled event: {:?}", other);
@@ -502,13 +497,22 @@ impl EventLoop {
         }
     }
 
-    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
+    pub fn run<F>(mut self, mut event_handler_inner: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(event::Event<T>, &event_loop::ActiveEventLoop),
+    {
+        let mut event_handler =
+            move |event: event::Event<T>, window_target: &event_loop::ActiveEventLoop| {
+                event_handler_inner(event, window_target);
+            };
+
         let mut start_cause = StartCause::Init;
+
         loop {
-            app.new_events(&self.window_target, start_cause);
+            event_handler(event::Event::NewEvents(start_cause), &self.window_target);
 
             if start_cause == StartCause::Init {
-                app.resumed(&self.window_target);
+                event_handler(event::Event::Resumed, &self.window_target);
             }
 
             // Handle window creates.
@@ -524,15 +528,23 @@ impl EventLoop {
 
                 self.windows.push((window, EventState::default()));
 
-                let window_id = RootWindowId(window_id);
-
                 // Send resize event on create to indicate first size.
-                let event = event::WindowEvent::Resized((properties.w, properties.h).into());
-                app.window_event(&self.window_target, window_id, event);
+                event_handler(
+                    event::Event::WindowEvent {
+                        window_id: RootWindowId(window_id),
+                        event: event::WindowEvent::Resized((properties.w, properties.h).into()),
+                    },
+                    &self.window_target,
+                );
 
-                // Send moved event on create to indicate first position.
-                let event = event::WindowEvent::Moved((properties.x, properties.y).into());
-                app.window_event(&self.window_target, window_id, event);
+                // Send resize event on create to indicate first position.
+                event_handler(
+                    event::Event::WindowEvent {
+                        window_id: RootWindowId(window_id),
+                        event: event::WindowEvent::Moved((properties.x, properties.y).into()),
+                    },
+                    &self.window_target,
+                );
             }
 
             // Handle window destroys.
@@ -540,8 +552,14 @@ impl EventLoop {
                 let mut destroys = self.window_target.p.destroys.lock().unwrap();
                 destroys.pop_front()
             } {
-                let window_id = RootWindowId(destroy_id);
-                app.window_event(&self.window_target, window_id, event::WindowEvent::Destroyed);
+                event_handler(
+                    event::Event::WindowEvent {
+                        window_id: RootWindowId(destroy_id),
+                        event: event::WindowEvent::Destroyed,
+                    },
+                    &self.window_target,
+                );
+
                 self.windows.retain(|(window, _event_state)| window.fd as u64 != destroy_id.fd);
             }
 
@@ -568,8 +586,7 @@ impl EventLoop {
                         window_id,
                         orbital_event.to_option(),
                         event_state,
-                        &self.window_target,
-                        app,
+                        |event| event_handler(event, &self.window_target),
                     );
                 }
 
@@ -596,8 +613,8 @@ impl EventLoop {
                 i += 1;
             }
 
-            while self.user_events_receiver.try_recv().is_ok() {
-                app.proxy_wake_up(&self.window_target);
+            while let Ok(event) = self.user_events_receiver.try_recv() {
+                event_handler(event::Event::UserEvent(event), &self.window_target);
             }
 
             // To avoid deadlocks the redraws lock is not held during event processing.
@@ -605,14 +622,16 @@ impl EventLoop {
                 let mut redraws = self.window_target.p.redraws.lock().unwrap();
                 redraws.pop_front()
             } {
-                app.window_event(
+                event_handler(
+                    event::Event::WindowEvent {
+                        window_id: RootWindowId(window_id),
+                        event: event::WindowEvent::RedrawRequested,
+                    },
                     &self.window_target,
-                    RootWindowId(window_id),
-                    event::WindowEvent::RedrawRequested,
                 );
             }
 
-            app.about_to_wait(&self.window_target);
+            event_handler(event::Event::AboutToWait, &self.window_target);
 
             if self.window_target.p.exiting() {
                 break;
@@ -676,7 +695,7 @@ impl EventLoop {
             }
         }
 
-        app.exiting(&self.window_target);
+        event_handler(event::Event::LoopExiting, &self.window_target);
 
         Ok(())
     }
@@ -685,7 +704,7 @@ impl EventLoop {
         &self.window_target
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy {
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
         EventLoopProxy {
             user_events_sender: self.user_events_sender.clone(),
             wake_socket: self.window_target.p.wake_socket.clone(),
@@ -693,22 +712,24 @@ impl EventLoop {
     }
 }
 
-pub struct EventLoopProxy {
-    user_events_sender: mpsc::SyncSender<()>,
+pub struct EventLoopProxy<T: 'static> {
+    user_events_sender: mpsc::Sender<T>,
     wake_socket: Arc<TimeSocket>,
 }
 
-impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        // When we fail to send the event it means that we haven't woken up to read the previous
-        // event.
-        if self.user_events_sender.try_send(()).is_ok() {
-            self.wake_socket.wake().unwrap();
-        }
+impl<T> EventLoopProxy<T> {
+    pub fn send_event(&self, event: T) -> Result<(), event_loop::EventLoopClosed<T>> {
+        self.user_events_sender
+            .send(event)
+            .map_err(|mpsc::SendError(x)| event_loop::EventLoopClosed(x))?;
+
+        self.wake_socket.wake().unwrap();
+
+        Ok(())
     }
 }
 
-impl Clone for EventLoopProxy {
+impl<T> Clone for EventLoopProxy<T> {
     fn clone(&self) -> Self {
         Self {
             user_events_sender: self.user_events_sender.clone(),
@@ -717,7 +738,7 @@ impl Clone for EventLoopProxy {
     }
 }
 
-impl Unpin for EventLoopProxy {}
+impl<T> Unpin for EventLoopProxy<T> {}
 
 pub struct ActiveEventLoop {
     control_flow: Cell<ControlFlow>,

src/platform_impl/web/async/channel.rs

@@ -1,7 +1,8 @@
 use std::future;
+use std::rc::Rc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{self, RecvError, SendError, TryRecvError};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use std::task::Poll;
 
 use super::AtomicWaker;
@@ -10,35 +11,54 @@ pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
     let (sender, receiver) = mpsc::channel();
     let shared = Arc::new(Shared { closed: AtomicBool::new(false), waker: AtomicWaker::new() });
 
-    let sender = Sender { sender, shared: Arc::clone(&shared) };
-    let receiver = Receiver { receiver, shared };
+    let sender =
+        Sender(Arc::new(SenderInner { sender: Mutex::new(sender), shared: Arc::clone(&shared) }));
+    let receiver = Receiver { receiver: Rc::new(receiver), shared };
 
     (sender, receiver)
 }
 
-pub struct Sender<T> {
-    sender: mpsc::Sender<T>,
+pub struct Sender<T>(Arc<SenderInner<T>>);
+
+struct SenderInner<T> {
+    // We need to wrap it into a `Mutex` to make it `Sync`. So the sender can't
+    // be accessed on the main thread, as it could block. Additionally we need
+    // to wrap `Sender` in an `Arc` to make it clonable on the main thread without
+    // having to block.
+    sender: Mutex<mpsc::Sender<T>>,
     shared: Arc<Shared>,
 }
 
 impl<T> Sender<T> {
     pub fn send(&self, event: T) -> Result<(), SendError<T>> {
-        self.sender.send(event)?;
-        self.shared.waker.wake();
+        self.0.sender.lock().unwrap().send(event)?;
+        self.0.shared.waker.wake();
 
         Ok(())
     }
 }
 
-impl<T> Drop for Sender<T> {
-    fn drop(&mut self) {
+impl<T> SenderInner<T> {
+    fn close(&self) {
         self.shared.closed.store(true, Ordering::Relaxed);
         self.shared.waker.wake();
     }
 }
 
+impl<T> Clone for Sender<T> {
+    fn clone(&self) -> Self {
+        Self(Arc::clone(&self.0))
+    }
+}
+
+impl<T> Drop for SenderInner<T> {
+    fn drop(&mut self) {
+        self.close();
+    }
+}
+
 pub struct Receiver<T> {
-    receiver: mpsc::Receiver<T>,
+    receiver: Rc<mpsc::Receiver<T>>,
     shared: Arc<Shared>,
 }
 
@@ -75,6 +95,18 @@ impl<T> Receiver<T> {
     }
 }
 
+impl<T> Clone for Receiver<T> {
+    fn clone(&self) -> Self {
+        Self { receiver: Rc::clone(&self.receiver), shared: Arc::clone(&self.shared) }
+    }
+}
+
+impl<T> Drop for Receiver<T> {
+    fn drop(&mut self) {
+        self.shared.closed.store(true, Ordering::Relaxed);
+    }
+}
+
 struct Shared {
     closed: AtomicBool,
     waker: AtomicWaker,

src/platform_impl/web/async/dispatcher.rs

@@ -1,10 +1,9 @@
 use super::super::main_thread::MainThreadMarker;
 use super::{channel, Receiver, Sender, Wrapper};
 use std::cell::Ref;
-use std::rc::Rc;
 use std::sync::{Arc, Condvar, Mutex};
 
-pub struct Dispatcher<T: 'static>(Wrapper<T, Arc<Sender<Closure<T>>>, Closure<T>>);
+pub struct Dispatcher<T: 'static>(Wrapper<T, Sender<Closure<T>>, Closure<T>>);
 
 struct Closure<T>(Box<dyn FnOnce(&T) + Send>);
 
@@ -12,8 +11,6 @@ impl<T> Dispatcher<T> {
     #[track_caller]
     pub fn new(main_thread: MainThreadMarker, value: T) -> Option<(Self, DispatchRunner<T>)> {
         let (sender, receiver) = channel::<Closure<T>>();
-        let sender = Arc::new(sender);
-        let receiver = Rc::new(receiver);
 
         Wrapper::new(
             main_thread,
@@ -24,7 +21,7 @@ impl<T> Dispatcher<T> {
                 closure(value.borrow().as_ref().unwrap())
             },
             {
-                let receiver = Rc::clone(&receiver);
+                let receiver = receiver.clone();
                 move |value| async move {
                     while let Ok(Closure(closure)) = receiver.next().await {
                         // SAFETY: The given `Closure` here isn't really `'static`, so we shouldn't
@@ -92,8 +89,8 @@ impl<T> Dispatcher<T> {
 }
 
 pub struct DispatchRunner<T: 'static> {
-    wrapper: Wrapper<T, Arc<Sender<Closure<T>>>, Closure<T>>,
-    receiver: Rc<Receiver<Closure<T>>>,
+    wrapper: Wrapper<T, Sender<Closure<T>>, Closure<T>>,
+    receiver: Receiver<Closure<T>>,
 }
 
 impl<T> DispatchRunner<T> {

src/platform_impl/web/async/waker.rs

@@ -1,18 +1,19 @@
 use std::future;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::num::NonZeroUsize;
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 use std::task::Poll;
 
 use super::super::main_thread::MainThreadMarker;
 use super::{AtomicWaker, Wrapper};
 
-pub struct WakerSpawner<T: 'static>(Wrapper<Handler<T>, Sender, ()>);
+pub struct WakerSpawner<T: 'static>(Wrapper<Handler<T>, Sender, NonZeroUsize>);
 
-pub struct Waker<T: 'static>(Wrapper<Handler<T>, Sender, ()>);
+pub struct Waker<T: 'static>(Wrapper<Handler<T>, Sender, NonZeroUsize>);
 
 struct Handler<T> {
     value: T,
-    handler: fn(&T, bool),
+    handler: fn(&T, NonZeroUsize, bool),
 }
 
 #[derive(Clone)]
@@ -20,9 +21,13 @@ struct Sender(Arc<Inner>);
 
 impl<T> WakerSpawner<T> {
     #[track_caller]
-    pub fn new(main_thread: MainThreadMarker, value: T, handler: fn(&T, bool)) -> Option<Self> {
+    pub fn new(
+        main_thread: MainThreadMarker,
+        value: T,
+        handler: fn(&T, NonZeroUsize, bool),
+    ) -> Option<Self> {
         let inner = Arc::new(Inner {
-            awoken: AtomicBool::new(false),
+            counter: AtomicUsize::new(0),
             waker: AtomicWaker::new(),
             closed: AtomicBool::new(false),
         });
@@ -34,43 +39,49 @@ impl<T> WakerSpawner<T> {
         let wrapper = Wrapper::new(
             main_thread,
             handler,
-            |handler, _| {
+            |handler, count| {
                 let handler = handler.borrow();
                 let handler = handler.as_ref().unwrap();
-                (handler.handler)(&handler.value, true);
+                (handler.handler)(&handler.value, count, true);
             },
             {
                 let inner = Arc::clone(&inner);
 
                 move |handler| async move {
-                    while future::poll_fn(|cx| {
-                        if inner.awoken.swap(false, Ordering::Relaxed) {
-                            Poll::Ready(true)
-                        } else {
-                            inner.waker.register(cx.waker());
+                    while let Some(count) = future::poll_fn(|cx| {
+                        let count = inner.counter.swap(0, Ordering::Relaxed);
 
-                            if inner.awoken.swap(false, Ordering::Relaxed) {
-                                Poll::Ready(true)
-                            } else {
-                                if inner.closed.load(Ordering::Relaxed) {
-                                    return Poll::Ready(false);
+                        match NonZeroUsize::new(count) {
+                            Some(count) => Poll::Ready(Some(count)),
+                            None => {
+                                inner.waker.register(cx.waker());
+
+                                let count = inner.counter.swap(0, Ordering::Relaxed);
+
+                                match NonZeroUsize::new(count) {
+                                    Some(count) => Poll::Ready(Some(count)),
+                                    None => {
+                                        if inner.closed.load(Ordering::Relaxed) {
+                                            return Poll::Ready(None);
+                                        }
+
+                                        Poll::Pending
+                                    },
                                 }
-
-                                Poll::Pending
-                            }
+                            },
                         }
                     })
                     .await
                     {
                         let handler = handler.borrow();
                         let handler = handler.as_ref().unwrap();
-                        (handler.handler)(&handler.value, false);
+                        (handler.handler)(&handler.value, count, false);
                     }
                 }
             },
             sender,
             |inner, _| {
-                inner.0.awoken.store(true, Ordering::Relaxed);
+                inner.0.counter.fetch_add(1, Ordering::Relaxed);
                 inner.0.waker.wake();
             },
         )?;
@@ -82,13 +93,13 @@ impl<T> WakerSpawner<T> {
         Waker(self.0.clone())
     }
 
-    pub fn take(&self) -> bool {
+    pub fn fetch(&self) -> usize {
         debug_assert!(
             MainThreadMarker::new().is_some(),
             "this should only be called from the main thread"
         );
 
-        self.0.with_sender_data(|inner| inner.0.awoken.swap(false, Ordering::Relaxed))
+        self.0.with_sender_data(|inner| inner.0.counter.swap(0, Ordering::Relaxed))
     }
 }
 
@@ -103,7 +114,7 @@ impl<T> Drop for WakerSpawner<T> {
 
 impl<T> Waker<T> {
     pub fn wake(&self) {
-        self.0.send(())
+        self.0.send(NonZeroUsize::MIN)
     }
 }
 
@@ -114,7 +125,7 @@ impl<T> Clone for Waker<T> {
 }
 
 struct Inner {
-    awoken: AtomicBool,
+    counter: AtomicUsize,
     waker: AtomicWaker,
     closed: AtomicBool,
 }

src/platform_impl/web/event_loop/mod.rs

@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
+use std::sync::mpsc::{self, Receiver, Sender};
 
-use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
 use crate::event::Event;
 use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;
@@ -16,30 +16,48 @@ mod window_target;
 pub(crate) use proxy::EventLoopProxy;
 pub(crate) use window_target::{ActiveEventLoop, OwnedDisplayHandle};
 
-pub struct EventLoop {
+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 EventLoop {
+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 })
+        Ok(EventLoop { elw, user_event_sender, user_event_receiver })
     }
 
-    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> ! {
+    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| handle_event(app, &target, event));
-
+        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::<Box<dyn FnMut(Event)>, Box<dyn FnMut(Event) + 'static>>(handler)
+            std::mem::transmute::<Box<dyn FnMut(Event<()>)>, Box<dyn FnMut(Event<()>) + 'static>>(
+                handler,
+            )
         };
         self.elw.p.run(handler, false);
 
@@ -52,14 +70,31 @@ impl EventLoop {
         unreachable!();
     }
 
-    pub fn spawn_app<A: ApplicationHandler + 'static>(self, mut app: A) {
+    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| handle_event(&mut app, &target, event)), true);
+        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 {
-        EventLoopProxy::new(self.elw.p.waker())
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.elw.p.waker(), self.user_event_sender.clone())
     }
 
     pub fn window_target(&self) -> &RootActiveEventLoop {
@@ -82,17 +117,3 @@ impl EventLoop {
         self.elw.wait_until_strategy()
     }
 }
-
-fn handle_event<A: ApplicationHandler>(app: &mut A, target: &RootActiveEventLoop, event: Event) {
-    match event {
-        Event::NewEvents(cause) => app.new_events(target, cause),
-        Event::WindowEvent { window_id, event } => app.window_event(target, window_id, event),
-        Event::DeviceEvent { device_id, event } => app.device_event(target, device_id, event),
-        Event::UserWakeUp => app.proxy_wake_up(target),
-        Event::Suspended => app.suspended(target),
-        Event::Resumed => app.resumed(target),
-        Event::AboutToWait => app.about_to_wait(target),
-        Event::LoopExiting => app.exiting(target),
-        Event::MemoryWarning => app.memory_warning(target),
-    }
-}

src/platform_impl/web/event_loop/proxy.rs

@@ -1,19 +1,29 @@
 use std::rc::Weak;
+use std::sync::mpsc::{SendError, Sender};
 
 use super::runner::Execution;
+use crate::event_loop::EventLoopClosed;
 use crate::platform_impl::platform::r#async::Waker;
 
-#[derive(Clone)]
-pub struct EventLoopProxy {
+pub struct EventLoopProxy<T: 'static> {
     runner: Waker<Weak<Execution>>,
+    sender: Sender<T>,
 }
 
-impl EventLoopProxy {
-    pub fn new(runner: Waker<Weak<Execution>>) -> Self {
-        Self { runner }
+impl<T: 'static> EventLoopProxy<T> {
+    pub fn new(runner: Waker<Weak<Execution>>, sender: Sender<T>) -> Self {
+        Self { runner, sender }
     }
 
-    pub fn wake_up(&self) {
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.sender.send(event).map_err(|SendError(event)| EventLoopClosed(event))?;
         self.runner.wake();
+        Ok(())
+    }
+}
+
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        Self { runner: self.runner.clone(), sender: self.sender.clone() }
     }
 }

src/platform_impl/web/event_loop/runner.rs

@@ -18,6 +18,7 @@ use js_sys::Function;
 use std::cell::{Cell, RefCell};
 use std::collections::{HashSet, VecDeque};
 use std::iter;
+use std::num::NonZeroUsize;
 use std::ops::Deref;
 use std::rc::{Rc, Weak};
 use wasm_bindgen::prelude::{wasm_bindgen, Closure};
@@ -27,7 +28,7 @@ use web_time::{Duration, Instant};
 
 pub struct Shared(Rc<Execution>);
 
-pub(super) type EventHandler = dyn FnMut(Event);
+pub(super) type EventHandler = dyn FnMut(Event<()>);
 
 impl Clone for Shared {
     fn clone(&self) -> Self {
@@ -136,12 +137,13 @@ impl Shared {
         let document = window.document().expect("Failed to obtain document");
 
         Shared(Rc::<Execution>::new_cyclic(|weak| {
-            let proxy_spawner = WakerSpawner::new(main_thread, weak.clone(), |runner, local| {
-                if let Some(runner) = runner.upgrade() {
-                    Shared(runner).send_proxy_wake_up(local);
-                }
-            })
-            .expect("`EventLoop` has to be created in the main thread");
+            let proxy_spawner =
+                WakerSpawner::new(main_thread, weak.clone(), |runner, count, local| {
+                    if let Some(runner) = runner.upgrade() {
+                        Shared(runner).send_user_events(count, local)
+                    }
+                })
+                .expect("`EventLoop` has to be created in the main thread");
 
             Execution {
                 main_thread,
@@ -201,7 +203,7 @@ impl Shared {
     // Set the event callback to use for the event loop runner
     // This the event callback is a fairly thin layer over the user-provided callback that closes
     // over a RootActiveEventLoop reference
-    pub(crate) fn set_listener(&self, event_handler: Box<EventHandler>) {
+    pub fn set_listener(&self, event_handler: Box<EventHandler>) {
         {
             let mut runner = self.0.runner.borrow_mut();
             assert!(matches!(*runner, RunnerEnum::Pending));
@@ -464,11 +466,11 @@ impl Shared {
         self.send_events(iter::once(event));
     }
 
-    // Add a user event to the event loop runner.
+    // Add a series of user events to the event loop runner
     //
     // This will schedule the event loop to wake up instead of waking it up immediately if its not
     // running.
-    pub(crate) fn send_proxy_wake_up(&self, local: bool) {
+    pub(crate) fn send_user_events(&self, count: NonZeroUsize, local: bool) {
         // If the event loop is closed, it should discard any new events
         if self.is_closed() {
             return;
@@ -476,32 +478,37 @@ impl Shared {
 
         if local {
             // If the loop is not running and triggered locally, queue on next microtick.
-            if let Ok(RunnerEnum::Running(_)) =
+            if let Ok(RunnerEnum::Running(ref runner)) =
                 self.0.runner.try_borrow().as_ref().map(Deref::deref)
             {
-                #[wasm_bindgen]
-                extern "C" {
-                    #[wasm_bindgen(js_name = queueMicrotask)]
-                    fn queue_microtask(task: Function);
-                }
+                // If we're currently polling let `send_events` do its job.
+                if !matches!(runner.state, State::Poll { .. }) {
+                    #[wasm_bindgen]
+                    extern "C" {
+                        #[wasm_bindgen(js_name = queueMicrotask)]
+                        fn queue_microtask(task: Function);
+                    }
 
-                queue_microtask(
-                    Closure::once_into_js({
-                        let this = Rc::downgrade(&self.0);
-                        move || {
-                            if let Some(shared) = this.upgrade() {
-                                Shared(shared).send_event(Event::UserWakeUp)
+                    queue_microtask(
+                        Closure::once_into_js({
+                            let this = Rc::downgrade(&self.0);
+                            move || {
+                                if let Some(shared) = this.upgrade() {
+                                    Shared(shared).send_events(
+                                        iter::repeat(Event::UserEvent(())).take(count.get()),
+                                    )
+                                }
                             }
-                        }
-                    })
-                    .unchecked_into(),
-                );
+                        })
+                        .unchecked_into(),
+                    );
 
-                return;
+                    return;
+                }
             }
         }
 
-        self.send_event(Event::UserWakeUp);
+        self.send_events(iter::repeat(Event::UserEvent(())).take(count.get()))
     }
 
     // Add a series of events to the event loop runner
@@ -515,8 +522,13 @@ impl Shared {
         // If we can run the event processing right now, or need to queue this and wait for later
         let mut process_immediately = true;
         match self.0.runner.try_borrow().as_ref().map(Deref::deref) {
-            // If the runner is attached but not running, we always wake it up.
-            Ok(RunnerEnum::Running(_)) => (),
+            Ok(RunnerEnum::Running(ref runner)) => {
+                // If we're currently polling, queue this and wait for the poll() method to be
+                // called.
+                if let State::Poll { .. } = runner.state {
+                    process_immediately = false;
+                }
+            },
             Ok(RunnerEnum::Pending) => {
                 // The runner still hasn't been attached: queue this event and wait for it to be
                 process_immediately = false;
@@ -644,10 +656,8 @@ impl Shared {
 
                 // Pre-fetch `UserEvent`s to avoid having to wait until the next event loop cycle.
                 events.extend(
-                    self.0
-                        .proxy_spawner
-                        .take()
-                        .then_some(Event::UserWakeUp)
+                    iter::repeat(Event::UserEvent(()))
+                        .take(self.0.proxy_spawner.fetch())
                         .map(EventWrapper::from),
                 );
 
@@ -735,7 +745,7 @@ impl Shared {
         //     * The `register_redraw_request` closure.
         //     * The `destroy_fn` closure.
         if self.0.event_loop_recreation.get() {
-            crate::event_loop::EventLoopBuilder::allow_event_loop_recreation();
+            crate::event_loop::EventLoopBuilder::<()>::allow_event_loop_recreation();
         }
     }
 
@@ -815,12 +825,12 @@ impl Shared {
 }
 
 pub(crate) enum EventWrapper {
-    Event(Event),
+    Event(Event<()>),
     ScaleChange { canvas: Weak<RefCell<backend::Canvas>>, size: PhysicalSize<u32>, scale: f64 },
 }
 
-impl From<Event> for EventWrapper {
-    fn from(value: Event) -> Self {
+impl From<Event<()>> for EventWrapper {
+    fn from(value: Event<()>) -> Self {
         Self::Event(value)
     }
 }

src/platform_impl/web/event_loop/window_target.rs

@@ -55,11 +55,7 @@ impl ActiveEventLoop {
         Self { runner: runner::Shared::new(), modifiers: ModifiersShared::default() }
     }
 
-    pub(crate) fn run(
-        &self,
-        event_handler: Box<runner::EventHandler>,
-        event_loop_recreation: bool,
-    ) {
+    pub fn run(&self, event_handler: Box<runner::EventHandler>, event_loop_recreation: bool) {
         self.runner.event_loop_recreation(event_loop_recreation);
         self.runner.set_listener(event_handler);
     }

src/platform_impl/web/mod.rs

@@ -28,9 +28,11 @@ mod event_loop;
 mod keyboard;
 mod main_thread;
 mod monitor;
-mod web_sys;
 mod window;
 
+#[path = "web_sys/mod.rs"]
+mod backend;
+
 pub use self::device::DeviceId;
 pub use self::error::OsError;
 pub(crate) use self::event_loop::{
@@ -41,7 +43,6 @@ pub use self::monitor::{MonitorHandle, VideoModeHandle};
 pub use self::window::{PlatformSpecificWindowAttributes, Window, WindowId};
 
 pub(crate) use self::keyboard::KeyEventExtra;
-use self::web_sys as backend;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
 pub(crate) use cursor::{

src/platform_impl/web/web_sys/canvas.rs

@@ -483,7 +483,7 @@ impl Canvas {
     pub(crate) fn handle_scale_change(
         &self,
         runner: &super::super::event_loop::runner::Shared,
-        event_handler: impl FnOnce(crate::event::Event),
+        event_handler: impl FnOnce(crate::event::Event<()>),
         current_size: PhysicalSize<u32>,
         scale: f64,
     ) {

src/platform_impl/web/web_sys/schedule.rs

@@ -87,7 +87,7 @@ impl Schedule {
             let duration = duration
                 .as_secs()
                 .checked_mul(1000)
-                .and_then(|secs| secs.checked_add(duration.subsec_micros().div_ceil(1000).into()))
+                .and_then(|secs| secs.checked_add(duration_millis_ceil(duration).into()))
                 .unwrap_or(u64::MAX);
 
             options.delay(duration as f64);
@@ -140,9 +140,7 @@ impl Schedule {
                 .ok()
                 .and_then(|secs: i32| secs.checked_mul(1000))
                 .and_then(|secs: i32| {
-                    let millis: i32 = duration
-                        .subsec_micros()
-                        .div_ceil(1000)
+                    let millis: i32 = duration_millis_ceil(duration)
                         .try_into()
                         .expect("millis are somehow bigger then 1K");
                     secs.checked_add(millis)
@@ -191,7 +189,7 @@ impl Schedule {
             .try_into()
             .ok()
             .and_then(|secs: u32| secs.checked_mul(1000))
-            .and_then(|secs| secs.checked_add(duration.subsec_micros().div_ceil(1000)))
+            .and_then(|secs| secs.checked_add(duration_millis_ceil(duration)))
             .unwrap_or(u32::MAX);
 
         WORKER
@@ -226,6 +224,20 @@ impl Drop for Schedule {
     }
 }
 
+// TODO: Replace with `u32::div_ceil()` when we hit Rust v1.73.
+fn duration_millis_ceil(duration: Duration) -> u32 {
+    let micros = duration.subsec_micros();
+
+    // From <https://doc.rust-lang.org/1.73.0/src/core/num/uint_macros.rs.html#2086-2094>.
+    let d = micros / 1000;
+    let r = micros % 1000;
+    if r > 0 && 1000 > 0 {
+        d + 1
+    } else {
+        d
+    }
+}
+
 fn has_scheduler_support(window: &web_sys::Window) -> bool {
     thread_local! {
         static SCHEDULER_SUPPORT: OnceCell<bool> = const { OnceCell::new() };

src/platform_impl/windows/drop_handler.rs

@@ -25,7 +25,7 @@ pub struct FileDropHandlerData {
     pub interface: IDropTarget,
     refcount: AtomicUsize,
     window: HWND,
-    send_event: Box<dyn Fn(Event)>,
+    send_event: Box<dyn Fn(Event<()>)>,
     cursor_effect: u32,
     hovered_is_valid: bool, /* If the currently hovered item is not valid there must not be any
                              * `HoveredFileCancelled` emitted */
@@ -37,7 +37,7 @@ pub struct FileDropHandler {
 
 #[allow(non_snake_case)]
 impl FileDropHandler {
-    pub(crate) fn new(window: HWND, send_event: Box<dyn Fn(Event)>) -> FileDropHandler {
+    pub fn new(window: HWND, send_event: Box<dyn Fn(Event<()>)>) -> FileDropHandler {
         let data = Box::new(FileDropHandlerData {
             interface: IDropTarget { lpVtbl: &DROP_TARGET_VTBL as *const IDropTargetVtbl },
             refcount: AtomicUsize::new(1),
@@ -211,7 +211,7 @@ impl FileDropHandler {
 }
 
 impl FileDropHandlerData {
-    fn send_event(&self, event: Event) {
+    fn send_event(&self, event: Event<()>) {
         (self.send_event)(event);
     }
 }

src/platform_impl/windows/event_loop.rs

@@ -8,6 +8,7 @@ use std::ffi::c_void;
 use std::marker::PhantomData;
 use std::rc::Rc;
 use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::mpsc::{self, Receiver, Sender};
 use std::sync::{Arc, Mutex, MutexGuard};
 use std::time::{Duration, Instant};
 use std::{mem, panic, ptr};
@@ -56,13 +57,12 @@ use windows_sys::Win32::UI::WindowsAndMessaging::{
     WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT, WS_OVERLAPPED, WS_POPUP, WS_VISIBLE,
 };
 
-use crate::application::ApplicationHandler;
 use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::error::EventLoopError;
 use crate::event::{
     DeviceEvent, Event, Force, Ime, InnerSizeWriter, RawKeyEvent, Touch, TouchPhase, WindowEvent,
 };
-use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents};
+use crate::event_loop::{ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents, EventLoopClosed};
 use crate::keyboard::ModifiersState;
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::platform::dark_mode::try_theme;
@@ -83,14 +83,35 @@ use crate::platform_impl::platform::{
 use crate::window::{
     CustomCursor as RootCustomCursor, CustomCursorSource, WindowId as RootWindowId,
 };
-use runner::EventLoopRunner;
+use runner::{EventLoopRunner, EventLoopRunnerShared};
 
 use super::window::set_skip_taskbar;
 use super::SelectedCursor;
 
+/// some backends like macos uses an uninhabited `Never` type,
+/// on windows, `UserEvent`s are also dispatched through the
+/// WNDPROC callback, and due to the re-entrant nature of the
+/// callback, recursively delivered events must be queued in a
+/// buffer, the current implementation put this queue in
+/// `EventLoopRunner`, which is shared between the event pumping
+/// loop and the callback. because it's hard to decide from the
+/// outside whether a event needs to be buffered, I decided not
+/// use `Event<Never>` for the shared runner state, but use unit
+/// as a placeholder so user events can be buffered as usual,
+/// the real `UserEvent` is pulled from the mpsc channel directly
+/// when the placeholder event is delivered to the event handler
+pub(crate) struct UserEventPlaceholder;
+
+// here below, the generic `EventLoopRunnerShared<T>` is replaced with
+// `EventLoopRunnerShared<UserEventPlaceholder>` so we can get rid
+// of the generic parameter T in types which don't depend on T.
+// this is the approach which requires minimum changes to current
+// backend implementation. it should be considered transitional
+// and should be refactored and cleaned up eventually, I hope.
+
 pub(crate) struct WindowData {
     pub window_state: Arc<Mutex<WindowState>>,
-    pub event_loop_runner: Rc<EventLoopRunner>,
+    pub event_loop_runner: EventLoopRunnerShared<UserEventPlaceholder>,
     pub key_event_builder: KeyEventBuilder,
     pub _file_drop_handler: Option<FileDropHandler>,
     pub userdata_removed: Cell<bool>,
@@ -98,7 +119,7 @@ pub(crate) struct WindowData {
 }
 
 impl WindowData {
-    fn send_event(&self, event: Event) {
+    fn send_event(&self, event: Event<UserEventPlaceholder>) {
         self.event_loop_runner.send_event(event);
     }
 
@@ -108,11 +129,11 @@ impl WindowData {
 }
 
 struct ThreadMsgTargetData {
-    event_loop_runner: Rc<EventLoopRunner>,
+    event_loop_runner: EventLoopRunnerShared<UserEventPlaceholder>,
 }
 
 impl ThreadMsgTargetData {
-    fn send_event(&self, event: Event) {
+    fn send_event(&self, event: Event<UserEventPlaceholder>) {
         self.event_loop_runner.send_event(event);
     }
 }
@@ -124,7 +145,9 @@ pub(crate) enum ProcResult {
     Value(isize),
 }
 
-pub struct EventLoop {
+pub struct EventLoop<T: 'static> {
+    user_event_sender: Sender<T>,
+    user_event_receiver: Receiver<T>,
     window_target: RootAEL,
     msg_hook: Option<Box<dyn FnMut(*const c_void) -> bool + 'static>>,
 }
@@ -144,10 +167,10 @@ impl Default for PlatformSpecificEventLoopAttributes {
 pub struct ActiveEventLoop {
     thread_id: u32,
     thread_msg_target: HWND,
-    pub(crate) runner_shared: Rc<EventLoopRunner>,
+    pub(crate) runner_shared: EventLoopRunnerShared<UserEventPlaceholder>,
 }
 
-impl EventLoop {
+impl<T: 'static> EventLoop<T> {
     pub(crate) fn new(
         attributes: &mut PlatformSpecificEventLoopAttributes,
     ) -> Result<Self, EventLoopError> {
@@ -170,6 +193,7 @@ impl EventLoop {
 
         let runner_shared = Rc::new(EventLoopRunner::new(thread_msg_target));
 
+        let (user_event_sender, user_event_receiver) = mpsc::channel();
         insert_event_target_window_data(thread_msg_target, runner_shared.clone());
         raw_input::register_all_mice_and_keyboards_for_raw_input(
             thread_msg_target,
@@ -177,6 +201,8 @@ impl EventLoop {
         );
 
         Ok(EventLoop {
+            user_event_sender,
+            user_event_receiver,
             window_target: RootAEL {
                 p: ActiveEventLoop { thread_id, thread_msg_target, runner_shared },
                 _marker: PhantomData,
@@ -189,36 +215,42 @@ impl EventLoop {
         &self.window_target
     }
 
-    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
+    pub fn run<F>(mut self, event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<T>, &RootAEL),
+    {
+        self.run_on_demand(event_handler)
     }
 
-    pub fn run_app_on_demand<A: ApplicationHandler>(
-        &mut self,
-        app: &mut A,
-    ) -> Result<(), EventLoopError> {
+    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<T>, &RootAEL),
+    {
         {
             let runner = &self.window_target.p.runner_shared;
 
             let event_loop_windows_ref = &self.window_target;
+            let user_event_receiver = &self.user_event_receiver;
             // # Safety
             // We make sure to call runner.clear_event_handler() before
             // returning
             unsafe {
-                runner.set_event_handler(move |event| match event {
-                    Event::NewEvents(cause) => app.new_events(event_loop_windows_ref, cause),
-                    Event::WindowEvent { window_id, event } => {
-                        app.window_event(event_loop_windows_ref, window_id, event)
-                    },
-                    Event::DeviceEvent { device_id, event } => {
-                        app.device_event(event_loop_windows_ref, device_id, event)
-                    },
-                    Event::UserWakeUp => app.proxy_wake_up(event_loop_windows_ref),
-                    Event::Suspended => app.suspended(event_loop_windows_ref),
-                    Event::Resumed => app.resumed(event_loop_windows_ref),
-                    Event::AboutToWait => app.about_to_wait(event_loop_windows_ref),
-                    Event::LoopExiting => app.exiting(event_loop_windows_ref),
-                    Event::MemoryWarning => app.memory_warning(event_loop_windows_ref),
+                runner.set_event_handler(move |event| {
+                    // the shared `EventLoopRunner` is not parameterized
+                    // `EventLoopProxy::send_event()` calls `PostMessage`
+                    // to wakeup and dispatch a placeholder `UserEvent`,
+                    // when we received the placeholder event here, the
+                    // real UserEvent(T) should already be put in the
+                    // mpsc channel and ready to be pulled
+                    let event = match event.map_nonuser_event() {
+                        Ok(non_user_event) => non_user_event,
+                        Err(_user_event_placeholder) => Event::UserEvent(
+                            user_event_receiver
+                                .try_recv()
+                                .expect("user event signaled but not received"),
+                        ),
+                    };
+                    event_handler(event, event_loop_windows_ref)
                 });
             }
         }
@@ -252,15 +284,14 @@ impl EventLoop {
         }
     }
 
-    pub fn pump_app_events<A: ApplicationHandler>(
-        &mut self,
-        timeout: Option<Duration>,
-        app: &mut A,
-    ) -> PumpStatus {
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut event_handler: F) -> PumpStatus
+    where
+        F: FnMut(Event<T>, &RootAEL),
+    {
         {
             let runner = &self.window_target.p.runner_shared;
             let event_loop_windows_ref = &self.window_target;
-            // let user_event_receiver = &self.user_event_receiver;
+            let user_event_receiver = &self.user_event_receiver;
 
             // # Safety
             // We make sure to call runner.clear_event_handler() before
@@ -270,22 +301,17 @@ impl EventLoop {
             // to leave the runner in an unsound state with an associated
             // event handler.
             unsafe {
-                runner.set_event_handler(move |event| match event {
-                    Event::NewEvents(cause) => app.new_events(event_loop_windows_ref, cause),
-                    Event::WindowEvent { window_id, event } => {
-                        app.window_event(event_loop_windows_ref, window_id, event)
-                    },
-                    Event::DeviceEvent { device_id, event } => {
-                        app.device_event(event_loop_windows_ref, device_id, event)
-                    },
-                    Event::UserWakeUp => app.proxy_wake_up(event_loop_windows_ref),
-                    Event::Suspended => app.suspended(event_loop_windows_ref),
-                    Event::Resumed => app.resumed(event_loop_windows_ref),
-                    Event::AboutToWait => app.about_to_wait(event_loop_windows_ref),
-                    Event::LoopExiting => app.exiting(event_loop_windows_ref),
-                    Event::MemoryWarning => app.memory_warning(event_loop_windows_ref),
+                runner.set_event_handler(move |event| {
+                    let event = match event.map_nonuser_event() {
+                        Ok(non_user_event) => non_user_event,
+                        Err(_user_event_placeholder) => Event::UserEvent(
+                            user_event_receiver
+                                .recv()
+                                .expect("user event signaled but not received"),
+                        ),
+                    };
+                    event_handler(event, event_loop_windows_ref)
                 });
-
                 runner.wakeup();
             }
         }
@@ -468,8 +494,11 @@ impl EventLoop {
         }
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy {
-        EventLoopProxy { target_window: self.window_target.p.thread_msg_target }
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy {
+            target_window: self.window_target.p.thread_msg_target,
+            event_send: self.user_event_sender.clone(),
+        }
     }
 
     fn exit_code(&self) -> Option<i32> {
@@ -641,7 +670,7 @@ fn dur2timeout(dur: Duration) -> u32 {
         .unwrap_or(INFINITE)
 }
 
-impl Drop for EventLoop {
+impl<T> Drop for EventLoop<T> {
     fn drop(&mut self) {
         unsafe {
             DestroyWindow(self.window_target.p.thread_msg_target);
@@ -699,16 +728,27 @@ impl EventLoopThreadExecutor {
 
 type ThreadExecFn = Box<Box<dyn FnMut()>>;
 
-#[derive(Clone)]
-pub struct EventLoopProxy {
+pub struct EventLoopProxy<T: 'static> {
     target_window: HWND,
+    event_send: Sender<T>,
+}
+unsafe impl<T: Send + 'static> Send for EventLoopProxy<T> {}
+
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        Self { target_window: self.target_window, event_send: self.event_send.clone() }
+    }
 }
 
-unsafe impl Send for EventLoopProxy {}
-
-impl EventLoopProxy {
-    pub fn wake_up(&self) {
-        unsafe { PostMessageW(self.target_window, USER_EVENT_MSG_ID.get(), 0, 0) };
+impl<T: 'static> EventLoopProxy<T> {
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.event_send
+            .send(event)
+            .map(|result| {
+                unsafe { PostMessageW(self.target_window, USER_EVENT_MSG_ID.get(), 0, 0) };
+                result
+            })
+            .map_err(|e| EventLoopClosed(e.0))
     }
 }
 
@@ -840,7 +880,7 @@ fn create_event_target_window() -> HWND {
 
 fn insert_event_target_window_data(
     thread_msg_target: HWND,
-    event_loop_runner: Rc<EventLoopRunner>,
+    event_loop_runner: EventLoopRunnerShared<UserEventPlaceholder>,
 ) {
     let userdata = ThreadMsgTargetData { event_loop_runner };
     let input_ptr = Box::into_raw(Box::new(userdata));
@@ -2386,7 +2426,7 @@ unsafe extern "system" fn thread_event_target_callback(
             // user event is still in the mpsc channel and will be pulled
             // once the placeholder event is delivered to the wrapper
             // `event_handler`
-            userdata.send_event(Event::UserWakeUp);
+            userdata.send_event(Event::UserEvent(UserEventPlaceholder));
             0
         },
         _ if msg == EXEC_MSG_ID.get() => {

src/platform_impl/windows/event_loop/runner.rs

@@ -1,6 +1,7 @@
 use std::any::Any;
 use std::cell::{Cell, RefCell};
 use std::collections::VecDeque;
+use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::time::Instant;
 use std::{mem, panic};
@@ -15,9 +16,11 @@ use crate::window::WindowId;
 
 use super::ControlFlow;
 
-type EventHandler = Cell<Option<Box<dyn FnMut(Event)>>>;
+pub(crate) type EventLoopRunnerShared<T> = Rc<EventLoopRunner<T>>;
 
-pub(crate) struct EventLoopRunner {
+type EventHandler<T> = Cell<Option<Box<dyn FnMut(Event<T>)>>>;
+
+pub(crate) struct EventLoopRunner<T: 'static> {
     // The event loop's win32 handles
     pub(super) thread_msg_target: HWND,
 
@@ -30,8 +33,8 @@ pub(crate) struct EventLoopRunner {
     exit: Cell<Option<i32>>,
     runner_state: Cell<RunnerState>,
     last_events_cleared: Cell<Instant>,
-    event_handler: EventHandler,
-    event_buffer: RefCell<VecDeque<BufferedEvent>>,
+    event_handler: EventHandler<T>,
+    event_buffer: RefCell<VecDeque<BufferedEvent<T>>>,
 
     panic_error: Cell<Option<PanicError>>,
 }
@@ -52,13 +55,13 @@ pub(crate) enum RunnerState {
     Destroyed,
 }
 
-enum BufferedEvent {
-    Event(Event),
+enum BufferedEvent<T: 'static> {
+    Event(Event<T>),
     ScaleFactorChanged(WindowId, f64, PhysicalSize<u32>),
 }
 
-impl EventLoopRunner {
-    pub(crate) fn new(thread_msg_target: HWND) -> EventLoopRunner {
+impl<T> EventLoopRunner<T> {
+    pub(crate) fn new(thread_msg_target: HWND) -> EventLoopRunner<T> {
         EventLoopRunner {
             thread_msg_target,
             interrupt_msg_dispatch: Cell::new(false),
@@ -85,12 +88,13 @@ impl EventLoopRunner {
     /// undefined behaviour.
     pub(crate) unsafe fn set_event_handler<F>(&self, f: F)
     where
-        F: FnMut(Event),
+        F: FnMut(Event<T>),
     {
         // Erase closure lifetime.
         // SAFETY: Caller upholds that the lifetime of the closure is upheld.
-        let f =
-            unsafe { mem::transmute::<Box<dyn FnMut(Event)>, Box<dyn FnMut(Event)>>(Box::new(f)) };
+        let f = unsafe {
+            mem::transmute::<Box<dyn FnMut(Event<T>)>, Box<dyn FnMut(Event<T>)>>(Box::new(f))
+        };
         let old_event_handler = self.event_handler.replace(Some(f));
         assert!(old_event_handler.is_none());
     }
@@ -120,7 +124,7 @@ impl EventLoopRunner {
 }
 
 /// State retrieval functions.
-impl EventLoopRunner {
+impl<T> EventLoopRunner<T> {
     #[allow(unused)]
     pub fn thread_msg_target(&self) -> HWND {
         self.thread_msg_target
@@ -162,7 +166,7 @@ impl EventLoopRunner {
 }
 
 /// Misc. functions
-impl EventLoopRunner {
+impl<T> EventLoopRunner<T> {
     pub fn catch_unwind<R>(&self, f: impl FnOnce() -> R) -> Option<R> {
         let panic_error = self.panic_error.take();
         if panic_error.is_none() {
@@ -192,7 +196,7 @@ impl EventLoopRunner {
 }
 
 /// Event dispatch functions.
-impl EventLoopRunner {
+impl<T> EventLoopRunner<T> {
     pub(crate) fn prepare_wait(&self) {
         self.move_state_to(RunnerState::Idle);
     }
@@ -201,7 +205,7 @@ impl EventLoopRunner {
         self.move_state_to(RunnerState::HandlingMainEvents);
     }
 
-    pub(crate) fn send_event(&self, event: Event) {
+    pub(crate) fn send_event(&self, event: Event<T>) {
         if let Event::WindowEvent { event: WindowEvent::RedrawRequested, .. } = event {
             self.call_event_handler(event);
             // As a rule, to ensure that `pump_events` can't block an external event loop
@@ -222,7 +226,7 @@ impl EventLoopRunner {
         self.move_state_to(RunnerState::Destroyed);
     }
 
-    fn call_event_handler(&self, event: Event) {
+    fn call_event_handler(&self, event: Event<T>) {
         self.catch_unwind(|| {
             let mut event_handler = self.event_handler.take().expect(
                 "either event handler is re-entrant (likely), or no event handler is registered \
@@ -354,8 +358,8 @@ impl EventLoopRunner {
     }
 }
 
-impl BufferedEvent {
-    pub fn from_event(event: Event) -> BufferedEvent {
+impl<T> BufferedEvent<T> {
+    pub fn from_event(event: Event<T>) -> BufferedEvent<T> {
         match event {
             Event::WindowEvent {
                 event: WindowEvent::ScaleFactorChanged { scale_factor, inner_size_writer },
@@ -369,7 +373,7 @@ impl BufferedEvent {
         }
     }
 
-    pub fn dispatch_event(self, dispatch: impl FnOnce(Event)) {
+    pub fn dispatch_event(self, dispatch: impl FnOnce(Event<T>)) {
         match self {
             Self::Event(event) => dispatch(event),
             Self::ScaleFactorChanged(window_id, scale_factor, new_inner_size) => {

src/platform_impl/windows/window.rs

@@ -1186,7 +1186,11 @@ impl<'a> InitData<'a> {
             let file_drop_runner = self.event_loop.runner_shared.clone();
             let file_drop_handler = FileDropHandler::new(
                 win.window,
-                Box::new(move |event| file_drop_runner.send_event(event)),
+                Box::new(move |event| {
+                    if let Ok(e) = event.map_nonuser_event() {
+                        file_drop_runner.send_event(e)
+                    }
+                }),
             );
 
             let handler_interface_ptr =

tests/send_objects.rs

@@ -3,11 +3,16 @@ fn needs_send<T: Send>() {}
 
 #[test]
 fn event_loop_proxy_send() {
-    needs_send::<winit::event_loop::EventLoopProxy>();
+    #[allow(dead_code)]
+    fn is_send<T: 'static + Send>() {
+        // ensures that `winit::EventLoopProxy<T: Send>` implements `Send`
+        needs_send::<winit::event_loop::EventLoopProxy<T>>();
+    }
 }
 
 #[test]
 fn window_send() {
+    // ensures that `winit::Window` implements `Send`
     needs_send::<winit::window::Window>();
 }
 
@@ -18,6 +23,7 @@ fn window_builder_send() {
 
 #[test]
 fn ids_send() {
+    // ensures that the various `..Id` types implement `Send`
     needs_send::<winit::window::WindowId>();
     needs_send::<winit::event::DeviceId>();
     needs_send::<winit::monitor::MonitorHandle>();

tests/sync_object.rs

@@ -3,11 +3,16 @@ fn needs_sync<T: Sync>() {}
 
 #[test]
 fn event_loop_proxy_send() {
-    needs_sync::<winit::event_loop::EventLoopProxy>();
+    #[allow(dead_code)]
+    fn is_send<T: 'static + Send>() {
+        // ensures that `winit::EventLoopProxy<T: Send>` implements `Sync`
+        needs_sync::<winit::event_loop::EventLoopProxy<T>>();
+    }
 }
 
 #[test]
 fn window_sync() {
+    // ensures that `winit::Window` implements `Sync`
     needs_sync::<winit::window::Window>();
 }