Winit version 0.30.5

It has low amount of users and not active, so better direct people
straight to matrix at this point.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.30.4"
+version = "0.30.5"
 authors = [
     "The winit contributors",
     "Pierre Krieger <pierre.krieger1708@gmail.com>",

README.md

@@ -8,7 +8,7 @@
 
 ```toml
 [dependencies]
-winit = "0.30.4"
+winit = "0.30.5"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -19,7 +19,7 @@ For features _outside_ the scope of winit, see [Are we GUI Yet?](https://arewegu
 
 ## Contact Us
 
-Join us in our [![Matrix](https://img.shields.io/badge/Matrix-%23rust--windowing%3Amatrix.org-blueviolet.svg)](https://matrix.to/#/#rust-windowing:matrix.org) room. If you don't get an answer there, try [![Libera.Chat](https://img.shields.io/badge/libera.chat-%23winit-red.svg)](https://web.libera.chat/#winit).
+Join us in our [![Matrix](https://img.shields.io/badge/Matrix-%23rust--windowing%3Amatrix.org-blueviolet.svg)](https://matrix.to/#/#rust-windowing:matrix.org) room.
 
 The maintainers have a meeting every friday at UTC 15. The meeting notes can be found [here](https://hackmd.io/@winit-meetings).
 

src/changelog/v0.20.md

@@ -137,7 +137,7 @@
 
 - On X11, non-resizable windows now have maximize explicitly disabled.
 - On Windows, support paths longer than MAX_PATH (260 characters) in `WindowEvent::DroppedFile`
-and `WindowEvent::HoveredFile`.
+  and `WindowEvent::HoveredFile`.
 - On Mac, implement `DeviceEvent::Button`.
 - Change `Event::Suspended(true / false)` to `Event::Suspended` and `Event::Resumed`.
 - On X11, fix sanity check which checks that a monitor's reported width and height (in millimeters) are non-zero when calculating the DPI factor.

src/changelog/v0.30.md

@@ -1,3 +1,18 @@
+## 0.30.5
+
+### Added
+
+- Add `ActiveEventLoop::system_theme()`, returning the current system theme.
+- On Web, implement `Error` for `platform::web::CustomCursorError`.
+- On Android, add `{Active,}EventLoopExtAndroid::android_app()` to access the app used to create the loop.
+
+### Fixed
+
+- On MacOS, fix building with `feature = "rwh_04"`.
+- On Web, pen events are now routed through to `WindowEvent::Cursor*`.
+- On macOS, fix panic when releasing not available monitor.
+- On MacOS, return the system theme in `Window::theme()` if no theme override is set.
+
 ## 0.30.4
 
 ### Changed

src/changelog/v0.9.md

@@ -3,20 +3,20 @@
 - Added event `WindowEvent::HiDPIFactorChanged`.
 - Added method `MonitorId::get_hidpi_factor`.
 - Deprecated `get_inner_size_pixels` and `get_inner_size_points` methods of `Window` in favor of
-`get_inner_size`.
+  `get_inner_size`.
 - **Breaking:** `EventsLoop` is `!Send` and `!Sync` because of platform-dependant constraints,
   but `Window`, `WindowId`, `DeviceId` and `MonitorId` guaranteed to be `Send`.
 - `MonitorId::get_position` now returns `(i32, i32)` instead of `(u32, u32)`.
 - Rewrite of the wayland backend to use wayland-client-0.11
 - Support for dead keys on wayland for keyboard utf8 input
 - Monitor enumeration on Windows is now implemented using `EnumDisplayMonitors` instead of
-`EnumDisplayDevices`. This changes the value returned by `MonitorId::get_name()`.
+  `EnumDisplayDevices`. This changes the value returned by `MonitorId::get_name()`.
 - On Windows added `MonitorIdExt::hmonitor` method
 - Impl `Clone` for `EventsLoopProxy`
 - `EventsLoop::get_primary_monitor()` on X11 will fallback to any available monitor if no primary is found
 - Support for touch event on wayland
 - `WindowEvent`s `MouseMoved`, `MouseEntered`, and `MouseLeft` have been renamed to
-`CursorMoved`, `CursorEntered`, and `CursorLeft`.
+  `CursorMoved`, `CursorEntered`, and `CursorLeft`.
 - New `DeviceEvent`s added, `MouseMotion` and `MouseWheel`.
 - Send `CursorMoved` event after `CursorEntered` and `Focused` events.
 - Add support for `ModifiersState`, `MouseMove`, `MouseInput`, `MouseMotion` for emscripten backend.

src/event.rs

@@ -532,11 +532,11 @@ pub struct KeyEvent {
     /// ## Caveats
     ///
     /// - Certain niche hardware will shuffle around physical key positions, e.g. a keyboard that
-    /// implements DVORAK in hardware (or firmware)
+    ///   implements DVORAK in hardware (or firmware)
     /// - Your application will likely have to handle keyboards which are missing keys that your
-    /// own keyboard has.
+    ///   own keyboard has.
     /// - Certain `KeyCode`s will move between a couple of different positions depending on what
-    /// layout the keyboard was manufactured to support.
+    ///   layout the keyboard was manufactured to support.
     ///
     ///  **Because of these caveats, it is important that you provide users with a way to configure
     ///  most (if not all) keybinds in your application.**
@@ -558,8 +558,7 @@ pub struct KeyEvent {
     ///
     /// This has two use cases:
     /// - Allows querying whether the current input is a Dead key.
-    /// - Allows handling key-bindings on platforms which don't
-    /// support [`key_without_modifiers`].
+    /// - Allows handling key-bindings on platforms which don't support [`key_without_modifiers`].
     ///
     /// If you use this field (or [`key_without_modifiers`] for that matter) for keyboard
     /// shortcuts, **it is important that you provide users with a way to configure your
@@ -567,8 +566,8 @@ pub struct KeyEvent {
     /// incompatible keyboard layout.**
     ///
     /// ## Platform-specific
-    /// - **Web:** Dead keys might be reported as the real key instead
-    /// of `Dead` depending on the browser/OS.
+    /// - **Web:** Dead keys might be reported as the real key instead of `Dead` depending on the
+    ///   browser/OS.
     ///
     /// [`key_without_modifiers`]: crate::platform::modifier_supplement::KeyEventExtModifierSupplement::key_without_modifiers
     pub logical_key: keyboard::Key,
@@ -850,8 +849,8 @@ pub struct Touch {
     ///
     /// - Only available on **iOS** 9.0+, **Windows** 8+, **Web**, and **Android**.
     /// - **Android**: This will never be [None]. If the device doesn't support pressure
-    /// sensitivity, force will either be 0.0 or 1.0. Also see the
-    /// [android documentation](https://developer.android.com/reference/android/view/MotionEvent#AXIS_PRESSURE).
+    ///   sensitivity, force will either be 0.0 or 1.0. Also see the
+    ///   [android documentation](https://developer.android.com/reference/android/view/MotionEvent#AXIS_PRESSURE).
     pub force: Option<Force>,
     /// Unique identifier of a finger.
     pub id: u64,

src/event_loop.rs

@@ -23,7 +23,7 @@ use crate::error::{EventLoopError, OsError};
 use crate::event::Event;
 use crate::monitor::MonitorHandle;
 use crate::platform_impl;
-use crate::window::{CustomCursor, CustomCursorSource, Window, WindowAttributes};
+use crate::window::{CustomCursor, CustomCursorSource, Theme, Window, WindowAttributes};
 
 /// Provides a way to retrieve events from the system and from the windows that were registered to
 /// the events loop.
@@ -437,6 +437,17 @@ impl ActiveEventLoop {
         self.p.listen_device_events(allowed);
     }
 
+    /// Returns the current system theme.
+    ///
+    /// Returns `None` if it cannot be determined on the current platform.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Wayland / x11 / Orbital:** Unsupported.
+    pub fn system_theme(&self) -> Option<Theme> {
+        self.p.system_theme()
+    }
+
     /// Sets the [`ControlFlow`].
     pub fn set_control_flow(&self, control_flow: ControlFlow) {
         self.p.set_control_flow(control_flow)

src/platform/android.rs

@@ -62,7 +62,7 @@
 //! If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building
 //! with `cargo apk`, then the minimal changes would be:
 //! 1. Remove `ndk-glue` from your `Cargo.toml`
-//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.4",
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.5",
 //!    features = [ "android-native-activity" ] }`
 //! 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc
 //!    macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize
@@ -76,12 +76,22 @@ use crate::window::{Window, WindowAttributes};
 use self::activity::{AndroidApp, ConfigurationRef, Rect};
 
 /// Additional methods on [`EventLoop`] that are specific to Android.
-pub trait EventLoopExtAndroid {}
+pub trait EventLoopExtAndroid {
+    /// Get the [`AndroidApp`] which was used to create this event loop.
+    fn android_app(&self) -> &AndroidApp;
+}
 
-impl<T> EventLoopExtAndroid for EventLoop<T> {}
+impl<T> EventLoopExtAndroid for EventLoop<T> {
+    fn android_app(&self) -> &AndroidApp {
+        &self.event_loop.android_app
+    }
+}
 
 /// Additional methods on [`ActiveEventLoop`] that are specific to Android.
-pub trait ActiveEventLoopExtAndroid {}
+pub trait ActiveEventLoopExtAndroid {
+    /// Get the [`AndroidApp`] which was used to create this event loop.
+    fn android_app(&self) -> &AndroidApp;
+}
 
 /// Additional methods on [`Window`] that are specific to Android.
 pub trait WindowExtAndroid {
@@ -100,7 +110,11 @@ impl WindowExtAndroid for Window {
     }
 }
 
-impl ActiveEventLoopExtAndroid for ActiveEventLoop {}
+impl ActiveEventLoopExtAndroid for ActiveEventLoop {
+    fn android_app(&self) -> &AndroidApp {
+        &self.p.app
+    }
+}
 
 /// Additional methods on [`WindowAttributes`] that are specific to Android.
 pub trait WindowAttributesExtAndroid {}
@@ -108,9 +122,9 @@ pub trait WindowAttributesExtAndroid {}
 impl WindowAttributesExtAndroid for WindowAttributes {}
 
 pub trait EventLoopBuilderExtAndroid {
-    /// Associates the `AndroidApp` that was passed to `android_main()` with the event loop
+    /// Associates the [`AndroidApp`] that was passed to `android_main()` with the event loop
     ///
-    /// This must be called on Android since the `AndroidApp` is not global state.
+    /// This must be called on Android since the [`AndroidApp`] is not global state.
     fn with_android_app(&mut self, app: AndroidApp) -> &mut Self;
 
     /// Calling this will mark the volume keys to be manually handled by the application
@@ -147,7 +161,7 @@ impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
 /// depending on the `android_activity` crate, and instead consume the API that
 /// is re-exported by Winit.
 ///
-/// For compatibility applications should then import the `AndroidApp` type for
+/// For compatibility applications should then import the [`AndroidApp`] type for
 /// their `android_main(app: AndroidApp)` function like:
 /// ```rust
 /// #[cfg(target_os = "android")]

src/platform/pump_events.rs

@@ -52,18 +52,18 @@ pub trait EventLoopExtPumpEvents {
     /// - `RedrawRequested` events, used to schedule rendering.
     ///
     ///     macOS for example uses a `drawRect` callback to drive rendering
-    /// within applications and expects rendering to be finished before
-    /// the `drawRect` callback returns.
+    ///     within applications and expects rendering to be finished before
+    ///     the `drawRect` callback returns.
     ///
     ///     For portability it's strongly recommended that applications should
-    /// keep their rendering inside the closure provided to Winit.
+    ///     keep their rendering inside the closure provided to Winit.
     /// - Any lifecycle events, such as `Suspended` / `Resumed`.
     ///
     ///     The handling of these events needs to be synchronized with the
-    /// operating system and it would never be appropriate to buffer a
-    /// notification that your application has been suspended or resumed and
-    /// then handled that later since there would always be a chance that
-    /// other lifecycle events occur while the event is buffered.
+    ///     operating system and it would never be appropriate to buffer a
+    ///     notification that your application has been suspended or resumed and
+    ///     then handled that later since there would always be a chance that
+    ///     other lifecycle events occur while the event is buffered.
     ///
     /// ## Supported Platforms
     ///
@@ -74,13 +74,13 @@ pub trait EventLoopExtPumpEvents {
     ///
     /// ## Unsupported Platforms
     ///
-    /// - **Web:**  This API is fundamentally incompatible with the event-based way in which
-    /// Web browsers work because it's not possible to have a long-running external
-    /// loop that would block the browser and there is nothing that can be
-    /// polled to ask for new new events. Events are delivered via callbacks based
-    /// on an event loop that is internal to the browser itself.
+    /// - **Web:**  This API is fundamentally incompatible with the event-based way in which Web
+    ///   browsers work because it's not possible to have a long-running external loop that would
+    ///   block the browser and there is nothing that can be polled to ask for new new events.
+    ///   Events are delivered via callbacks based on an event loop that is internal to the browser
+    ///   itself.
     /// - **iOS:** It's not possible to stop and start an `NSApplication` repeatedly on iOS so
-    /// there's no way to support the same approach to polling as on MacOS.
+    ///   there's no way to support the same approach to polling as on MacOS.
     ///
     /// ## Platform-specific
     ///

src/platform/web.rs

@@ -461,3 +461,5 @@ impl Display for CustomCursorError {
         }
     }
 }
+
+impl Error for CustomCursorError {}

src/platform_impl/android/mod.rs

@@ -132,7 +132,7 @@ impl RedrawRequester {
 pub struct KeyEventExtra {}
 
 pub struct EventLoop<T: 'static> {
-    android_app: AndroidApp,
+    pub(crate) android_app: AndroidApp,
     window_target: event_loop::ActiveEventLoop,
     redraw_flag: SharedFlag,
     user_events_sender: mpsc::Sender<T>,
@@ -646,7 +646,7 @@ impl<T> EventLoopProxy<T> {
 }
 
 pub struct ActiveEventLoop {
-    app: AndroidApp,
+    pub(crate) app: AndroidApp,
     control_flow: Cell<ControlFlow>,
     exit: Cell<bool>,
     redraw_requester: RedrawRequester,
@@ -677,6 +677,11 @@ impl ActiveEventLoop {
         rwh_05::RawDisplayHandle::Android(rwh_05::AndroidDisplayHandle::empty())
     }
 
+    #[inline]
+    pub fn system_theme(&self) -> Option<Theme> {
+        None
+    }
+
     #[cfg(feature = "rwh_06")]
     #[inline]
     pub fn raw_display_handle_rwh_06(

src/platform_impl/ios/event_loop.rs

@@ -22,8 +22,8 @@ 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 crate::platform_impl::ios::app_state::{EventLoopHandler, HandlePendingUserEvents};
+use crate::window::{CustomCursor, CustomCursorSource, Theme};
 
 use super::app_delegate::AppDelegate;
 use super::app_state::AppState;
@@ -58,6 +58,11 @@ impl ActiveEventLoop {
         rwh_05::RawDisplayHandle::UiKit(rwh_05::UiKitDisplayHandle::empty())
     }
 
+    #[inline]
+    pub fn system_theme(&self) -> Option<Theme> {
+        None
+    }
+
     #[cfg(feature = "rwh_06")]
     #[inline]
     pub fn raw_display_handle_rwh_06(

src/platform_impl/linux/mod.rs

@@ -897,6 +897,11 @@ impl ActiveEventLoop {
         x11_or_wayland!(match self; Self(evlp) => evlp.raw_display_handle_rwh_05())
     }
 
+    #[inline]
+    pub fn system_theme(&self) -> Option<Theme> {
+        None
+    }
+
     #[cfg(feature = "rwh_06")]
     #[inline]
     pub fn raw_display_handle_rwh_06(

src/platform_impl/macos/event_loop.rs

@@ -16,7 +16,7 @@ use core_foundation::runloop::{
 };
 use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::ProtocolObject;
-use objc2::{msg_send_id, ClassType};
+use objc2::{msg_send_id, sel, ClassType};
 use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSWindow};
 use objc2_foundation::{MainThreadMarker, NSObjectProtocol};
 
@@ -33,7 +33,7 @@ use crate::event_loop::{
 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};
+use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme};
 
 #[derive(Default)]
 pub struct PanicInfo {
@@ -106,6 +106,17 @@ impl ActiveEventLoop {
         rwh_05::RawDisplayHandle::AppKit(rwh_05::AppKitDisplayHandle::empty())
     }
 
+    #[inline]
+    pub fn system_theme(&self) -> Option<Theme> {
+        let app = NSApplication::sharedApplication(self.mtm);
+
+        if app.respondsToSelector(sel!(effectiveAppearance)) {
+            Some(super::window_delegate::appearance_to_theme(&app.effectiveAppearance()))
+        } else {
+            Some(Theme::Light)
+        }
+    }
+
     #[cfg(feature = "rwh_06")]
     #[inline]
     pub fn raw_display_handle_rwh_06(

src/platform_impl/macos/window_delegate.rs

@@ -1426,13 +1426,7 @@ impl WindowDelegate {
                 toggle_fullscreen(self.window());
             },
             (Some(Fullscreen::Exclusive(ref video_mode)), None) => {
-                unsafe {
-                    ffi::CGRestorePermanentDisplayConfiguration();
-                    assert_eq!(
-                        ffi::CGDisplayRelease(video_mode.monitor().native_identifier()),
-                        ffi::kCGErrorSuccess
-                    );
-                };
+                restore_and_release_display(&video_mode.monitor());
                 toggle_fullscreen(self.window());
             },
             (Some(Fullscreen::Borderless(_)), Some(Fullscreen::Exclusive(_))) => {
@@ -1463,13 +1457,7 @@ impl WindowDelegate {
                 );
                 app.setPresentationOptions(presentation_options);
 
-                unsafe {
-                    ffi::CGRestorePermanentDisplayConfiguration();
-                    assert_eq!(
-                        ffi::CGDisplayRelease(video_mode.monitor().native_identifier()),
-                        ffi::kCGErrorSuccess
-                    );
-                };
+                restore_and_release_display(&video_mode.monitor());
 
                 // Restore the normal window level following the Borderless fullscreen
                 // `CGShieldingWindowLevel() + 1` hack.
@@ -1613,7 +1601,7 @@ impl WindowDelegate {
     pub fn raw_window_handle_rwh_04(&self) -> rwh_04::RawWindowHandle {
         let mut window_handle = rwh_04::AppKitHandle::empty();
         window_handle.ns_window = self.window() as *const WinitWindow as *mut _;
-        window_handle.ns_view = Retained::as_ptr(&self.contentView().unwrap()) as *mut _;
+        window_handle.ns_view = Retained::as_ptr(&self.view()) as *mut _;
         rwh_04::RawWindowHandle::AppKit(window_handle)
     }
 
@@ -1657,14 +1645,18 @@ impl WindowDelegate {
     }
 
     pub fn theme(&self) -> Option<Theme> {
-        // Note: We could choose between returning the value of `effectiveAppearance` or
-        // `appearance`, depending on what the user is asking about:
-        // - "how should I render on this particular frame".
-        // - "what is the configuration for this window".
-        //
-        // We choose the latter for consistency with the `set_theme` call, though it might also be
-        // useful to expose the former.
-        Some(appearance_to_theme(unsafe { &*self.window().appearance()? }))
+        unsafe { self.window().appearance() }
+            .map(|appearance| appearance_to_theme(&appearance))
+            .or_else(|| {
+                let mtm = MainThreadMarker::from(self);
+                let app = NSApplication::sharedApplication(mtm);
+
+                if app.respondsToSelector(sel!(effectiveAppearance)) {
+                    Some(super::window_delegate::appearance_to_theme(&app.effectiveAppearance()))
+                } else {
+                    Some(Theme::Light)
+                }
+            })
     }
 
     pub fn set_theme(&self, theme: Option<Theme>) {
@@ -1689,6 +1681,21 @@ impl WindowDelegate {
     }
 }
 
+fn restore_and_release_display(monitor: &MonitorHandle) {
+    let available_monitors = monitor::available_monitors();
+    if available_monitors.contains(monitor) {
+        unsafe {
+            ffi::CGRestorePermanentDisplayConfiguration();
+            assert_eq!(ffi::CGDisplayRelease(monitor.native_identifier()), ffi::kCGErrorSuccess);
+        };
+    } else {
+        warn!(
+            monitor = monitor.name(),
+            "Tried to restore exclusive fullscreen on a monitor that is no longer available"
+        );
+    }
+}
+
 impl WindowExtMacOS for WindowDelegate {
     #[inline]
     fn simple_fullscreen(&self) -> bool {
@@ -1832,7 +1839,7 @@ fn dark_appearance_name() -> &'static NSString {
     ns_string!("NSAppearanceNameDarkAqua")
 }
 
-fn appearance_to_theme(appearance: &NSAppearance) -> Theme {
+pub fn appearance_to_theme(appearance: &NSAppearance) -> Theme {
     let best_match = appearance.bestMatchFromAppearancesWithNames(&NSArray::from_id_slice(&[
         unsafe { NSAppearanceNameAqua.copy() },
         dark_appearance_name().copy(),

src/platform_impl/orbital/event_loop.rs

@@ -20,7 +20,7 @@ use crate::keyboard::{
     PhysicalKey,
 };
 use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, WindowId as RootWindowId,
+    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, WindowId as RootWindowId,
 };
 
 use super::{
@@ -775,6 +775,11 @@ impl ActiveEventLoop {
         rwh_05::RawDisplayHandle::Orbital(rwh_05::OrbitalDisplayHandle::empty())
     }
 
+    #[inline]
+    pub fn system_theme(&self) -> Option<Theme> {
+        None
+    }
+
     #[cfg(feature = "rwh_06")]
     #[inline]
     pub fn raw_display_handle_rwh_06(

src/platform_impl/web/event_loop/runner.rs

@@ -245,21 +245,10 @@ impl Shared {
                     return;
                 }
 
-                let pointer_type = event.pointer_type();
-
-                if pointer_type != "mouse" {
-                    return;
-                }
-
                 // chorded button event
                 let device_id = RootDeviceId(DeviceId(event.pointer_id()));
 
                 if let Some(button) = backend::event::mouse_button(&event) {
-                    debug_assert_eq!(
-                        pointer_type, "mouse",
-                        "expect pointer type of a chorded button event to be a mouse"
-                    );
-
                     let state = if backend::event::mouse_buttons(&event).contains(button.into()) {
                         ElementState::Pressed
                     } else {
@@ -323,10 +312,6 @@ impl Shared {
                     return;
                 }
 
-                if event.pointer_type() != "mouse" {
-                    return;
-                }
-
                 let button = backend::event::mouse_button(&event).expect("no mouse button pressed");
                 runner.send_event(Event::DeviceEvent {
                     device_id: RootDeviceId(DeviceId(event.pointer_id())),
@@ -346,10 +331,6 @@ impl Shared {
                     return;
                 }
 
-                if event.pointer_type() != "mouse" {
-                    return;
-                }
-
                 let button = backend::event::mouse_button(&event).expect("no mouse button pressed");
                 runner.send_event(Event::DeviceEvent {
                     device_id: RootDeviceId(DeviceId(event.pointer_id())),

src/platform_impl/web/event_loop/window_target.rs

@@ -258,21 +258,6 @@ impl ActiveEventLoop {
         });
 
         canvas.on_cursor_move(
-            {
-                let runner = self.runner.clone();
-                let has_focus = has_focus.clone();
-                let modifiers = self.modifiers.clone();
-
-                move |active_modifiers| {
-                    if has_focus.get() && modifiers.get() != active_modifiers {
-                        modifiers.set(active_modifiers);
-                        runner.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                        })
-                    }
-                }
-            },
             {
                 let runner = self.runner.clone();
                 let has_focus = has_focus.clone();
@@ -372,20 +357,6 @@ impl ActiveEventLoop {
         );
 
         canvas.on_mouse_press(
-            {
-                let runner = self.runner.clone();
-                let modifiers = self.modifiers.clone();
-
-                move |active_modifiers| {
-                    if modifiers.get() != active_modifiers {
-                        modifiers.set(active_modifiers);
-                        runner.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                        })
-                    }
-                }
-            },
             {
                 let runner = self.runner.clone();
                 let modifiers = self.modifiers.clone();
@@ -450,21 +421,6 @@ impl ActiveEventLoop {
         );
 
         canvas.on_mouse_release(
-            {
-                let runner = self.runner.clone();
-                let has_focus = has_focus.clone();
-                let modifiers = self.modifiers.clone();
-
-                move |active_modifiers| {
-                    if has_focus.get() && modifiers.get() != active_modifiers {
-                        modifiers.set(active_modifiers);
-                        runner.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(id),
-                            event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                        });
-                    }
-                }
-            },
             {
                 let runner = self.runner.clone();
                 let has_focus = has_focus.clone();
@@ -658,6 +614,16 @@ impl ActiveEventLoop {
         self.runner.listen_device_events(allowed)
     }
 
+    pub fn system_theme(&self) -> Option<Theme> {
+        backend::is_dark_mode(self.runner.window()).map(|is_dark_mode| {
+            if is_dark_mode {
+                Theme::Dark
+            } else {
+                Theme::Light
+            }
+        })
+    }
+
     pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
         self.runner.set_control_flow(control_flow)
     }

src/platform_impl/web/web_sys/canvas.rs

@@ -329,51 +329,29 @@ impl Canvas {
         self.pointer_handler.on_cursor_enter(&self.common, handler)
     }
 
-    pub fn on_mouse_release<MOD, M, T>(
-        &mut self,
-        modifier_handler: MOD,
-        mouse_handler: M,
-        touch_handler: T,
-    ) where
-        MOD: 'static + FnMut(ModifiersState),
+    pub fn on_mouse_release<M, T>(&mut self, mouse_handler: M, touch_handler: T)
+    where
         M: 'static + FnMut(ModifiersState, i32, PhysicalPosition<f64>, MouseButton),
         T: 'static + FnMut(ModifiersState, i32, PhysicalPosition<f64>, Force),
     {
-        self.pointer_handler.on_mouse_release(
-            &self.common,
-            modifier_handler,
-            mouse_handler,
-            touch_handler,
-        )
+        self.pointer_handler.on_mouse_release(&self.common, mouse_handler, touch_handler)
     }
 
-    pub fn on_mouse_press<MOD, M, T>(
-        &mut self,
-        modifier_handler: MOD,
-        mouse_handler: M,
-        touch_handler: T,
-    ) where
-        MOD: 'static + FnMut(ModifiersState),
+    pub fn on_mouse_press<M, T>(&mut self, mouse_handler: M, touch_handler: T)
+    where
         M: 'static + FnMut(ModifiersState, i32, PhysicalPosition<f64>, MouseButton),
         T: 'static + FnMut(ModifiersState, i32, PhysicalPosition<f64>, Force),
     {
         self.pointer_handler.on_mouse_press(
             &self.common,
-            modifier_handler,
             mouse_handler,
             touch_handler,
             Rc::clone(&self.prevent_default),
         )
     }
 
-    pub fn on_cursor_move<MOD, M, T, B>(
-        &mut self,
-        modifier_handler: MOD,
-        mouse_handler: M,
-        touch_handler: T,
-        button_handler: B,
-    ) where
-        MOD: 'static + FnMut(ModifiersState),
+    pub fn on_cursor_move<M, T, B>(&mut self, mouse_handler: M, touch_handler: T, button_handler: B)
+    where
         M: 'static + FnMut(ModifiersState, i32, &mut dyn Iterator<Item = PhysicalPosition<f64>>),
         T: 'static
             + FnMut(ModifiersState, i32, &mut dyn Iterator<Item = (PhysicalPosition<f64>, Force)>),
@@ -381,7 +359,6 @@ impl Canvas {
     {
         self.pointer_handler.on_cursor_move(
             &self.common,
-            modifier_handler,
             mouse_handler,
             touch_handler,
             button_handler,

src/platform_impl/web/web_sys/pointer.rs

@@ -44,7 +44,7 @@ impl PointerHandler {
                 // touch events are handled separately
                 // handling them here would produce duplicate mouse events, inconsistent with
                 // other platforms.
-                let pointer_id = (event.pointer_type() == "mouse").then(|| event.pointer_id());
+                let pointer_id = (event.pointer_type() != "touch").then(|| event.pointer_id());
 
                 handler(modifiers, pointer_id);
             }));
@@ -61,20 +61,18 @@ impl PointerHandler {
                 // touch events are handled separately
                 // handling them here would produce duplicate mouse events, inconsistent with
                 // other platforms.
-                let pointer_id = (event.pointer_type() == "mouse").then(|| event.pointer_id());
+                let pointer_id = (event.pointer_type() != "touch").then(|| event.pointer_id());
 
                 handler(modifiers, pointer_id);
             }));
     }
 
-    pub fn on_mouse_release<MOD, M, T>(
+    pub fn on_mouse_release<M, T>(
         &mut self,
         canvas_common: &Common,
-        mut modifier_handler: MOD,
         mut mouse_handler: M,
         mut touch_handler: T,
     ) where
-        MOD: 'static + FnMut(ModifiersState),
         M: 'static + FnMut(ModifiersState, i32, PhysicalPosition<f64>, MouseButton),
         T: 'static + FnMut(ModifiersState, i32, PhysicalPosition<f64>, Force),
     {
@@ -90,26 +88,23 @@ impl PointerHandler {
                         event::mouse_position(&event).to_physical(super::scale_factor(&window)),
                         Force::Normalized(event.pressure() as f64),
                     ),
-                    "mouse" => mouse_handler(
+                    _ => mouse_handler(
                         modifiers,
                         event.pointer_id(),
                         event::mouse_position(&event).to_physical(super::scale_factor(&window)),
                         event::mouse_button(&event).expect("no mouse button released"),
                     ),
-                    _ => modifier_handler(modifiers),
                 }
             }));
     }
 
-    pub fn on_mouse_press<MOD, M, T>(
+    pub fn on_mouse_press<M, T>(
         &mut self,
         canvas_common: &Common,
-        mut modifier_handler: MOD,
         mut mouse_handler: M,
         mut touch_handler: T,
         prevent_default: Rc<Cell<bool>>,
     ) where
-        MOD: 'static + FnMut(ModifiersState),
         M: 'static + FnMut(ModifiersState, i32, PhysicalPosition<f64>, MouseButton),
         T: 'static + FnMut(ModifiersState, i32, PhysicalPosition<f64>, Force),
     {
@@ -125,8 +120,9 @@ impl PointerHandler {
                 }
 
                 let modifiers = event::mouse_modifiers(&event);
+                let pointer_type = &event.pointer_type();
 
-                match event.pointer_type().as_str() {
+                match pointer_type.as_str() {
                     "touch" => {
                         touch_handler(
                             modifiers,
@@ -135,7 +131,7 @@ impl PointerHandler {
                             Force::Normalized(event.pressure() as f64),
                         );
                     },
-                    "mouse" => {
+                    _ => {
                         mouse_handler(
                             modifiers,
                             event.pointer_id(),
@@ -143,27 +139,27 @@ impl PointerHandler {
                             event::mouse_button(&event).expect("no mouse button pressed"),
                         );
 
-                        // Error is swallowed here since the error would occur every time the mouse
-                        // is clicked when the cursor is grabbed, and there
-                        // is probably not a situation where this could
-                        // fail, that we care if it fails.
-                        let _e = canvas.set_pointer_capture(event.pointer_id());
+                        if pointer_type == "mouse" {
+                            // Error is swallowed here since the error would occur every time the
+                            // mouse is clicked when the cursor is
+                            // grabbed, and there is probably not a
+                            // situation where this could fail, that we
+                            // care if it fails.
+                            let _e = canvas.set_pointer_capture(event.pointer_id());
+                        }
                     },
-                    _ => modifier_handler(modifiers),
                 }
             }));
     }
 
-    pub fn on_cursor_move<MOD, M, T, B>(
+    pub fn on_cursor_move<M, T, B>(
         &mut self,
         canvas_common: &Common,
-        mut modifier_handler: MOD,
         mut mouse_handler: M,
         mut touch_handler: T,
         mut button_handler: B,
         prevent_default: Rc<Cell<bool>>,
     ) where
-        MOD: 'static + FnMut(ModifiersState),
         M: 'static + FnMut(ModifiersState, i32, &mut dyn Iterator<Item = PhysicalPosition<f64>>),
         T: 'static
             + FnMut(ModifiersState, i32, &mut dyn Iterator<Item = (PhysicalPosition<f64>, Force)>),
@@ -175,23 +171,10 @@ impl PointerHandler {
             Some(canvas_common.add_event("pointermove", move |event: PointerEvent| {
                 let modifiers = event::mouse_modifiers(&event);
 
-                let pointer_type = event.pointer_type();
-
-                if let "touch" | "mouse" = pointer_type.as_str() {
-                } else {
-                    modifier_handler(modifiers);
-                    return;
-                }
-
                 let id = event.pointer_id();
 
                 // chorded button event
                 if let Some(button) = event::mouse_button(&event) {
-                    debug_assert_eq!(
-                        pointer_type, "mouse",
-                        "expect pointer type of a chorded button event to be a mouse"
-                    );
-
                     if prevent_default.get() {
                         // prevent text selection
                         event.prevent_default();
@@ -212,13 +195,7 @@ impl PointerHandler {
 
                 // pointer move event
                 let scale = super::scale_factor(&window);
-                match pointer_type.as_str() {
-                    "mouse" => mouse_handler(
-                        modifiers,
-                        id,
-                        &mut event::pointer_move_event(event)
-                            .map(|event| event::mouse_position(&event).to_physical(scale)),
-                    ),
+                match event.pointer_type().as_str() {
                     "touch" => touch_handler(
                         modifiers,
                         id,
@@ -229,7 +206,12 @@ impl PointerHandler {
                             )
                         }),
                     ),
-                    _ => unreachable!("didn't return early before"),
+                    _ => mouse_handler(
+                        modifiers,
+                        id,
+                        &mut event::pointer_move_event(event)
+                            .map(|event| event::mouse_position(&event).to_physical(scale)),
+                    ),
                 };
             }));
     }

src/platform_impl/windows/dark_mode.rs

@@ -123,7 +123,7 @@ fn set_dark_mode_for_window(hwnd: HWND, is_dark_mode: bool) -> bool {
     }
 }
 
-fn should_use_dark_mode() -> bool {
+pub fn should_use_dark_mode() -> bool {
     should_apps_use_dark_mode() && !is_high_contrast()
 }
 

src/platform_impl/windows/event_loop.rs

@@ -81,7 +81,7 @@ use crate::platform_impl::platform::{
     raw_input, util, wrap_device_id, Fullscreen, WindowId, DEVICE_ID,
 };
 use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, WindowId as RootWindowId,
+    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, WindowId as RootWindowId,
 };
 use runner::{EventLoopRunner, EventLoopRunnerShared};
 
@@ -550,6 +550,10 @@ impl ActiveEventLoop {
         raw_input::register_all_mice_and_keyboards_for_raw_input(self.thread_msg_target, allowed);
     }
 
+    pub fn system_theme(&self) -> Option<Theme> {
+        Some(if super::dark_mode::should_use_dark_mode() { Theme::Dark } else { Theme::Light })
+    }
+
     pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
         self.runner_shared.set_control_flow(control_flow)
     }
@@ -2441,7 +2445,7 @@ unsafe extern "system" fn thread_event_target_callback(
     if userdata_removed {
         drop(userdata);
     } else {
-        Box::into_raw(userdata);
+        Box::leak(userdata);
     }
     result
 }

src/platform_impl/windows/raw_input.rs

@@ -263,39 +263,37 @@ pub fn get_keyboard_physical_key(keyboard: RAWKEYBOARD) -> Option<PhysicalKey> {
         scancode_to_physicalkey(scancode as u32)
     };
     if keyboard.VKey == VK_SHIFT {
-        if let PhysicalKey::Code(code) = physical_key {
-            match code {
-                KeyCode::NumpadDecimal
-                | KeyCode::Numpad0
-                | KeyCode::Numpad1
-                | KeyCode::Numpad2
-                | KeyCode::Numpad3
-                | KeyCode::Numpad4
-                | KeyCode::Numpad5
-                | KeyCode::Numpad6
-                | KeyCode::Numpad7
-                | KeyCode::Numpad8
-                | KeyCode::Numpad9 => {
-                    // On Windows, holding the Shift key makes numpad keys behave as if NumLock
-                    // wasn't active. The way this is exposed to applications by the system is that
-                    // the application receives a fake key release event for the shift key at the
-                    // moment when the numpad key is pressed, just before receiving the numpad key
-                    // as well.
-                    //
-                    // The issue is that in the raw device event (here), the fake shift release
-                    // event reports the numpad key as the scancode. Unfortunately, the event
-                    // doesn't have any information to tell whether it's the
-                    // left shift or the right shift that needs to get the fake
-                    // release (or press) event so we don't forward this
-                    // event to the application at all.
-                    //
-                    // For more on this, read the article by Raymond Chen, titled:
-                    // "The shift key overrides NumLock"
-                    // https://devblogs.microsoft.com/oldnewthing/20040906-00/?p=37953
-                    return None;
-                },
-                _ => (),
-            }
+        if let PhysicalKey::Code(
+            KeyCode::NumpadDecimal
+            | KeyCode::Numpad0
+            | KeyCode::Numpad1
+            | KeyCode::Numpad2
+            | KeyCode::Numpad3
+            | KeyCode::Numpad4
+            | KeyCode::Numpad5
+            | KeyCode::Numpad6
+            | KeyCode::Numpad7
+            | KeyCode::Numpad8
+            | KeyCode::Numpad9,
+        ) = physical_key
+        {
+            // On Windows, holding the Shift key makes numpad keys behave as if NumLock
+            // wasn't active. The way this is exposed to applications by the system is that
+            // the application receives a fake key release event for the shift key at the
+            // moment when the numpad key is pressed, just before receiving the numpad key
+            // as well.
+            //
+            // The issue is that in the raw device event (here), the fake shift release
+            // event reports the numpad key as the scancode. Unfortunately, the event
+            // doesn't have any information to tell whether it's the
+            // left shift or the right shift that needs to get the fake
+            // release (or press) event so we don't forward this
+            // event to the application at all.
+            //
+            // For more on this, read the article by Raymond Chen, titled:
+            // "The shift key overrides NumLock"
+            // https://devblogs.microsoft.com/oldnewthing/20040906-00/?p=37953
+            return None;
         }
     }
 

src/window.rs

@@ -417,8 +417,8 @@ impl WindowAttributes {
     ///
     /// ## Platform-specific
     ///
-    /// - **macOS**: if `false`, [`NSWindowSharingNone`] is used but doesn't completely
-    /// prevent all apps from reading the window content, for instance, QuickTime.
+    /// - **macOS**: if `false`, [`NSWindowSharingNone`] is used but doesn't completely prevent all
+    ///   apps from reading the window content, for instance, QuickTime.
     /// - **iOS / Android / Web / x11 / Orbital:** Ignored.
     ///
     /// [`NSWindowSharingNone`]: https://developer.apple.com/documentation/appkit/nswindowsharingtype/nswindowsharingnone
@@ -466,8 +466,8 @@ impl WindowAttributes {
     /// ## Platform-specific
     ///
     /// - **Windows** : A child window has the WS_CHILD style and is confined
-    /// to the client area of its parent window. For more information, see
-    /// <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#child-windows>
+    ///   to the client area of its parent window. For more information, see
+    ///   <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#child-windows>
     /// - **X11**: A child window is confined to the client area of its parent window.
     /// - **Android / iOS / Wayland / Web:** Unsupported.
     #[cfg(feature = "rwh_06")]
@@ -530,9 +530,9 @@ impl Window {
     ///     provided by XRandR.
     ///
     ///   If `WINIT_X11_SCALE_FACTOR` is set to `randr`, it'll ignore the `Xft.dpi` field and use
-    /// the   XRandR scaling method. Generally speaking, you should try to configure the
-    /// standard system   variables to do what you want before resorting to
-    /// `WINIT_X11_SCALE_FACTOR`.
+    ///   the   XRandR scaling method. Generally speaking, you should try to configure the
+    ///   standard system   variables to do what you want before resorting to
+    ///   `WINIT_X11_SCALE_FACTOR`.
     /// - **Wayland:** The scale factor is suggested by the compositor for each window individually
     ///   by using the wp-fractional-scale protocol if available. Falls back to integer-scale
     ///   factors otherwise.
@@ -1371,14 +1371,14 @@ impl Window {
         self.window.maybe_queue_on_main(move |w| w.set_theme(theme))
     }
 
-    /// Returns the current window theme override.
+    /// Returns the current window theme.
     ///
-    /// Returns `None` if the current theme is set as the system default, or if it cannot be
-    /// determined on the current platform.
+    /// Returns `None` if it cannot be determined on the current platform.
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Wayland / x11 / Orbital:** Unsupported, returns `None`.
+    /// - **iOS / Android / x11 / Orbital:** Unsupported.
+    /// - **Wayland:** Only returns theme overrides.
     #[inline]
     pub fn theme(&self) -> Option<Theme> {
         let _span = tracing::debug_span!("winit::Window::theme",).entered();
@@ -1389,8 +1389,8 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// - **macOS**: if `false`, [`NSWindowSharingNone`] is used but doesn't completely
-    /// prevent all apps from reading the window content, for instance, QuickTime.
+    /// - **macOS**: if `false`, [`NSWindowSharingNone`] is used but doesn't completely prevent all
+    ///   apps from reading the window content, for instance, QuickTime.
     /// - **iOS / Android / x11 / Wayland / Web / Orbital:** Unsupported.
     ///
     /// [`NSWindowSharingNone`]: https://developer.apple.com/documentation/appkit/nswindowsharingtype/nswindowsharingnone