DPI version 0.1.2

This commit does not represent a release and only synchronizes CHANGELOG
from the latest release.

.github/workflows/ci.yml

@@ -185,6 +185,12 @@ jobs:
         contains(matrix.platform.name, 'Linux 64bit') &&
         matrix.toolchain != '1.73'
       run: cargo test -p dpi
+      
+    - name: Check dpi crate (no_std)
+      if: >
+        contains(matrix.platform.name, 'Linux 64bit') &&
+        matrix.toolchain != '1.73'
+      run: cargo check -p dpi --no-default-features
 
     - name: Build tests
       if: >

CONTRIBUTING.md

@@ -22,7 +22,12 @@ to the branch" checkbox.
 We use unstable Rustfmt options across the project, so please run
 `cargo +nightly fmt` before submitting your work. If you are unable to do so,
 the maintainers can do it for you before merging, just state so in your pull
-request description.
+request description. For details on how to use nightly, consult [the
+documentation][toolchains].
+
+When editing markdown files (`.md`) they must be wrapped at 80 characters.
+
+[toolchains]: https://rust-lang.github.io/rustup/concepts/toolchains.html
 
 #### Handling review
 

Cargo.toml

@@ -21,7 +21,7 @@ name = "winit"
 readme = "README.md"
 repository.workspace = true
 rust-version.workspace = true
-version = "0.30.9"
+version = "0.30.10"
 
 [package.metadata.docs.rs]
 features = [
@@ -78,7 +78,7 @@ cfg_aliases = "0.2.1"
 [dependencies]
 bitflags = "2"
 cursor-icon = "1.1.0"
-dpi = { version = "0.1.1", path = "dpi" }
+dpi = { version = "0.1.2", path = "dpi" }
 rwh_06 = { package = "raw-window-handle", version = "0.6", features = ["std"] }
 serde = { workspace = true, optional = true }
 smol_str = "0.3"
@@ -104,13 +104,13 @@ ndk = { version = "0.9.0", features = ["rwh_06"], default-features = false }
 
 # AppKit or UIKit
 [target.'cfg(target_vendor = "apple")'.dependencies]
-block2 = "0.6.0"
-dispatch2 = { version = "0.2.0", default-features = false, features = ["std", "objc2"] }
-objc2 = "0.6.0"
+block2 = "0.6.1"
+dispatch2 = { version = "0.3.0", default-features = false, features = ["std", "objc2"] }
+objc2 = "0.6.1"
 
 # AppKit
 [target.'cfg(target_os = "macos")'.dependencies]
-objc2-app-kit = { version = "0.3.0", default-features = false, features = [
+objc2-app-kit = { version = "0.3.1", default-features = false, features = [
     "std",
     "objc2-core-foundation",
     "NSAppearance",
@@ -142,7 +142,7 @@ objc2-app-kit = { version = "0.3.0", default-features = false, features = [
     "NSWindowScripting",
     "NSWindowTabGroup",
 ] }
-objc2-core-foundation = { version = "0.3.0", default-features = false, features = [
+objc2-core-foundation = { version = "0.3.1", default-features = false, features = [
     "std",
     "block2",
     "CFBase",
@@ -152,7 +152,7 @@ objc2-core-foundation = { version = "0.3.0", default-features = false, features
     "CFString",
     "CFUUID",
 ] }
-objc2-core-graphics = { version = "0.3.0", default-features = false, features = [
+objc2-core-graphics = { version = "0.3.1", default-features = false, features = [
     "std",
     "libc",
     "CGDirectDisplay",
@@ -162,14 +162,14 @@ objc2-core-graphics = { version = "0.3.0", default-features = false, features =
     "CGRemoteOperation",
     "CGWindowLevel",
 ] }
-objc2-core-video = { version = "0.3.0", default-features = false, features = [
+objc2-core-video = { version = "0.3.1", default-features = false, features = [
     "std",
     "objc2-core-graphics",
     "CVBase",
     "CVReturn",
     "CVDisplayLink",
 ] }
-objc2-foundation = { version = "0.3.0", default-features = false, features = [
+objc2-foundation = { version = "0.3.1", default-features = false, features = [
     "std",
     "block2",
     "objc2-core-foundation",
@@ -194,14 +194,14 @@ objc2-foundation = { version = "0.3.0", default-features = false, features = [
 
 # UIKit
 [target.'cfg(all(target_vendor = "apple", not(target_os = "macos")))'.dependencies]
-objc2-core-foundation = { version = "0.3.0", default-features = false, features = [
+objc2-core-foundation = { version = "0.3.1", default-features = false, features = [
     "std",
     "CFCGTypes",
     "CFBase",
     "CFRunLoop",
     "CFString",
 ] }
-objc2-foundation = { version = "0.3.0", default-features = false, features = [
+objc2-foundation = { version = "0.3.1", default-features = false, features = [
     "std",
     "block2",
     "objc2-core-foundation",
@@ -214,7 +214,7 @@ objc2-foundation = { version = "0.3.0", default-features = false, features = [
     "NSThread",
     "NSSet",
 ] }
-objc2-ui-kit = { version = "0.3.0", default-features = false, features = [
+objc2-ui-kit = { version = "0.3.1", default-features = false, features = [
     "std",
     "objc2-core-foundation",
     "UIApplication",
@@ -288,12 +288,12 @@ sctk = { package = "smithay-client-toolkit", version = "0.19.2", default-feature
     "calloop",
 ], optional = true }
 sctk-adwaita = { version = "0.10.1", default-features = false, optional = true }
-wayland-backend = { version = "0.3.5", default-features = false, features = [
+wayland-backend = { version = "0.3.10", default-features = false, features = [
     "client_system",
 ], optional = true }
-wayland-client = { version = "0.31.4", optional = true }
-wayland-protocols = { version = "0.32.2", features = ["staging"], optional = true }
-wayland-protocols-plasma = { version = "0.3.2", features = ["client"], optional = true }
+wayland-client = { version = "0.31.10", optional = true }
+wayland-protocols = { version = "0.32.8", features = ["staging"], optional = true }
+wayland-protocols-plasma = { version = "0.3.8", features = ["client"], optional = true }
 x11-dl = { version = "2.19.1", optional = true }
 x11rb = { version = "0.13.0", default-features = false, features = [
     "allow-unsafe-code",

README.md

@@ -8,7 +8,7 @@
 
 ```toml
 [dependencies]
-winit = "0.30.9"
+winit = "0.30.10"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -33,6 +33,10 @@ Winit is designed to be a low-level brick in a hierarchy of libraries. Consequen
 show something on the window you need to use the platform-specific getters provided by winit, or
 another library.
 
+## CONTRIBUING
+
+For contributing guidelines see [CONTRIBUTING.md](./CONTRIBUTING.md).
+
 ## MSRV Policy
 
 This crate's Minimum Supported Rust Version (MSRV) is **1.73**. Changes to
@@ -67,3 +71,9 @@ same MSRV policy.
 ### Platform-specific usage
 
 Check out the [`winit::platform`](https://docs.rs/winit/latest/winit/platform/index.html) module for platform-specific usage.
+
+### Repository License
+
+Note that the license in `LICENSE` doesn't apply in full to the DPI package [./dpi](./dpi).
+Full details can be found in that folder's README.
+<!-- This doesn't apply to users of the Winit crate, but this is also the repository level README -->

dpi/CHANGELOG.md

@@ -11,7 +11,10 @@ Unreleased` header.
 
 ## Unreleased
 
+## 0.1.2
+
 - Added `Insets`, `LogicalInsets` and `PhysicalInsets` types.
+- Make `no_std` compatible. If you use this functionality, DPI's license has changed.
 
 ## 0.1.1
 

dpi/Cargo.toml

@@ -3,16 +3,22 @@ categories = ["gui"]
 description = "Types for handling UI scaling"
 edition.workspace = true
 keywords = ["DPI", "HiDPI", "scale-factor"]
-license.workspace = true
+# N.B. This is "AND", because of the imported libm code.
+license = "Apache-2.0 AND MIT"
 name = "dpi"
 repository.workspace = true
 rust-version.workspace = true
-version = "0.1.1"
+version = "0.1.2"
 
 [features]
+default = ["std"]
+
 mint = ["dep:mint"]
 serde = ["dep:serde"]
 
+# Access mathematical functions using the standard library implementations
+std = []
+
 [dependencies]
 mint = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }

dpi/LICENSE-LIBM-MIT

@@ -0,0 +1,51 @@
+rust-lang/libm as a whole is available for use under the MIT license:
+
+------------------------------------------------------------------------------
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+
+This Rust library contains the following copyrights:
+
+    Copyright (c) 2018 Jorge Aparicio
+
+Portions of this software are derived from third-party works licensed under
+terms compatible with the above MIT license:
+
+* musl libc https://www.musl-libc.org/. This library contains the following
+  copyright:
+
+      Copyright © 2005-2020 Rich Felker, et al.
+
+* The CORE-MATH project https://core-math.gitlabpages.inria.fr/. CORE-MATH
+  routines are available under the MIT license on a per-file basis.
+
+The musl libc COPYRIGHT file also includes the following notice relevant to
+math portions of the library:
+
+------------------------------------------------------------------------------
+Much of the math library code (src/math/* and src/complex/*) is
+Copyright © 1993,2004 Sun Microsystems or
+Copyright © 2003-2011 David Schultz or
+Copyright © 2003-2009 Steven G. Kargl or
+Copyright © 2003-2009 Bruce D. Evans or
+Copyright © 2008 Stephen L. Moshier or
+Copyright © 2017-2018 Arm Limited
+and labelled as such in comments in the individual source files. All
+have been licensed under extremely permissive terms.
+------------------------------------------------------------------------------

dpi/README.md

@@ -0,0 +1,18 @@
+# DPI
+
+Full docs can be found on docs.rs.
+
+## License
+
+Most of DPI is licensed under the Apache License, Version 2.0 ([LICENSE](LICENSE)).
+All files except for `src/libm.rs` (and `LICENSE-LIBM-MIT`) are available solely under that license.
+
+For its `no_std` support, DPI uses code from the [libm](https://crates.io/crates/libm) crate.
+This is in the `libm.rs` file, and is licensed solely under the MIT Licence ([LICENSE-LIBM-MIT](LICENSE-LIBM-MIT)).
+That file contains details of all potentially applicable copyright notices.
+This is feature gated to only be included if you disable the `std` feature, otherwise it will not be compiled into your final binary
+(and so these license terms will not apply).
+
+Overall, this means that the license for this crate depends on what features you have enabled.
+If you enable the `std` feature, then DPI uses only code available under the Apache-2.0 license, and so can be used under the terms of that license.
+However, if you disable the `std` feature, then both these licenses must be followed to use the crate as a whole.

dpi/src/lib.rs

@@ -54,13 +54,25 @@
 //!
 //! * `serde`: Enables serialization/deserialization of certain types with [Serde](https://crates.io/crates/serde).
 //! * `mint`: Enables mint (math interoperability standard types) conversions.
+//! * `std` (enabled by default): Uses the standard library mathematical functions (normally through
+//!   your target platform's libm). This feature also changes the library's license from `Apache-2.0
+//!   AND MIT` to `APACHE-2.0` (only). For full details, see the package README.
 //!
+//! To use this library on a target without the standard library available, you should disable
+//! default features (thus disabling the `std` feature, with the license consequences thereof).
 //!
 //! [points]: https://en.wikipedia.org/wiki/Point_(typography)
 //! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)
 
 #![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
-#![forbid(unsafe_code)]
+#![cfg_attr(feature = "std", forbid(unsafe_code))]
+#![no_std]
+
+#[cfg(not(feature = "std"))]
+mod libm;
+
+#[cfg(any(feature = "std", test))]
+extern crate std;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -74,32 +86,32 @@ pub trait Pixel: Copy + Into<f64> {
 
 impl Pixel for u8 {
     fn from_f64(f: f64) -> Self {
-        f.round() as u8
+        round(f) as u8
     }
 }
 impl Pixel for u16 {
     fn from_f64(f: f64) -> Self {
-        f.round() as u16
+        round(f) as u16
     }
 }
 impl Pixel for u32 {
     fn from_f64(f: f64) -> Self {
-        f.round() as u32
+        round(f) as u32
     }
 }
 impl Pixel for i8 {
     fn from_f64(f: f64) -> Self {
-        f.round() as i8
+        round(f) as i8
     }
 }
 impl Pixel for i16 {
     fn from_f64(f: f64) -> Self {
-        f.round() as i16
+        round(f) as i16
     }
 }
 impl Pixel for i32 {
     fn from_f64(f: f64) -> Self {
-        f.round() as i32
+        round(f) as i32
     }
 }
 impl Pixel for f32 {
@@ -113,6 +125,15 @@ impl Pixel for f64 {
     }
 }
 
+/// Round f to the closest integer, rounding away from `0.0`
+#[inline]
+fn round(f: f64) -> f64 {
+    #[cfg(feature = "std")]
+    return f.round();
+    #[cfg(not(feature = "std"))]
+    return libm::round(f);
+}
+
 /// Checks that the scale factor is a normal positive `f64`.
 ///
 /// All functions that take a scale factor assert that this will return `true`. If you're sourcing
@@ -1270,20 +1291,20 @@ mod tests {
     // Eat coverage for the Debug impls et al
     #[test]
     fn ensure_attrs_do_not_panic() {
-        let _ = format!("{:?}", LogicalPosition::<u32>::default().clone());
+        let _ = std::format!("{:?}", LogicalPosition::<u32>::default().clone());
         HashSet::new().insert(LogicalPosition::<u32>::default());
 
-        let _ = format!("{:?}", PhysicalPosition::<u32>::default().clone());
+        let _ = std::format!("{:?}", PhysicalPosition::<u32>::default().clone());
         HashSet::new().insert(PhysicalPosition::<u32>::default());
 
-        let _ = format!("{:?}", LogicalSize::<u32>::default().clone());
+        let _ = std::format!("{:?}", LogicalSize::<u32>::default().clone());
         HashSet::new().insert(LogicalSize::<u32>::default());
 
-        let _ = format!("{:?}", PhysicalSize::<u32>::default().clone());
+        let _ = std::format!("{:?}", PhysicalSize::<u32>::default().clone());
         HashSet::new().insert(PhysicalSize::<u32>::default());
 
-        let _ = format!("{:?}", Size::Physical((1, 2).into()).clone());
-        let _ = format!("{:?}", Position::Physical((1, 2).into()).clone());
+        let _ = std::format!("{:?}", Size::Physical((1, 2).into()).clone());
+        let _ = std::format!("{:?}", Position::Physical((1, 2).into()).clone());
     }
 
     #[test]

dpi/src/libm.rs

@@ -0,0 +1,56 @@
+// Copyright (c) 2018 Jorge Aparicio
+// Copyright © 2005-2020 Rich Felker, et al.
+// Copyright © 1993,2004 Sun Microsystems or
+// Copyright © 2003-2011 David Schultz or
+// Copyright © 2003-2009 Steven G. Kargl or
+// Copyright © 2003-2009 Bruce D. Evans or
+// Copyright © 2008 Stephen L. Moshier or
+// Copyright © 2017-2018 Arm Limited
+// SPDX-License-Identifier: MIT
+// This file is licensed solely under the terms discussed in LICENSE-LIBM-MIT at the crate root.
+// See the package-level README for full details.
+
+// Taken from https://github.com/rust-lang/libm/blob/master/src/math/mod.rs#L1
+macro_rules! force_eval {
+    ($e:expr) => {
+        unsafe { ::core::ptr::read_volatile(&$e) }
+    };
+}
+
+// Taken from https://github.com/rust-lang/libm/blob/libm-v0.2.11/src/math/round.rs
+pub(crate) fn round(x: f64) -> f64 {
+    trunc(x + copysign(0.5 - 0.25 * f64::EPSILON, x))
+}
+
+// Adapted from: https://github.com/rust-lang/libm/blob/libm-v0.2.11/src/math/trunc.rs#L8-L12
+#[allow(clippy::needless_late_init /*, reason = "The original libm code uses this style" */)]
+fn trunc(x: f64) -> f64 {
+    let x1p120 = f64::from_bits(0x4770000000000000); // 0x1p120f === 2 ^ 120
+
+    let mut i: u64 = x.to_bits();
+    let mut e: i64 = ((i >> 52) & 0x7ff) as i64 - 0x3ff + 12;
+    let m: u64;
+
+    if e >= 52 + 12 {
+        return x;
+    }
+    if e < 12 {
+        e = 1;
+    }
+    m = -1i64 as u64 >> e;
+    if (i & m) == 0 {
+        return x;
+    }
+    force_eval!(x + x1p120);
+    i &= !m;
+    f64::from_bits(i)
+}
+
+// Taken from https://github.com/rust-lang/libm/blob/libm-v0.2.11/src/math/copysign.rs
+fn copysign(x: f64, y: f64) -> f64 {
+    let mut ux = x.to_bits();
+    let uy = y.to_bits();
+    ux &= (!0) >> 1;
+    ux |= uy & (1 << 63);
+    f64::from_bits(ux)
+}

examples/application.rs

@@ -20,7 +20,9 @@ use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
 use winit::error::RequestError;
 use winit::event::{DeviceEvent, DeviceId, Ime, MouseButton, MouseScrollDelta, WindowEvent};
 use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::icon::RgbaIcon;
 use winit::keyboard::{Key, ModifiersState};
+use winit::monitor::Fullscreen;
 #[cfg(macos_platform)]
 use winit::platform::macos::{
     ApplicationHandlerExtMacOS, OptionAsAlt, WindowAttributesExtMacOS, WindowExtMacOS,
@@ -30,17 +32,20 @@ use winit::platform::startup_notify::{
     self, EventLoopExtStartupNotify, WindowAttributesExtStartupNotify, WindowExtStartupNotify,
 };
 #[cfg(web_platform)]
-use winit::platform::web::{ActiveEventLoopExtWeb, CustomCursorExtWeb, WindowAttributesExtWeb};
+use winit::platform::web::{ActiveEventLoopExtWeb, WindowAttributesExtWeb};
 #[cfg(x11_platform)]
 use winit::platform::x11::WindowAttributesExtX11;
 use winit::window::{
-    Cursor, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, Icon, ResizeDirection,
-    Theme, Window, WindowAttributes, WindowId,
+    Cursor, CursorGrabMode, CustomCursor, CustomCursorSource, Icon, ResizeDirection, Theme, Window,
+    WindowAttributes, WindowId,
 };
 
 #[path = "util/tracing.rs"]
 mod tracing;
 
+#[path = "util/fill.rs"]
+mod fill;
+
 /// The amount of points to around the window for drag resize direction calculations.
 const BORDER_SIZE: f64 = 20.;
 
@@ -313,6 +318,13 @@ impl Application {
                 self.sender.send(Action::Message).unwrap();
                 event_loop.create_proxy().wake_up();
             },
+            Action::ToggleAnimatedFillColor => {
+                window.animated_fill_color = !window.animated_fill_color;
+            },
+            Action::ToggleContinuousRedraw => {
+                window.continuous_redraw = !window.continuous_redraw;
+                window.window.request_redraw();
+            },
         }
     }
 
@@ -440,6 +452,9 @@ impl ApplicationHandler for Application {
                 if let Err(err) = window.draw() {
                     error!("Error drawing window: {err}");
                 }
+                if window.continuous_redraw {
+                    window.window.request_redraw();
+                }
             },
             WindowEvent::Occluded(occluded) => {
                 window.set_occluded(occluded);
@@ -465,7 +480,7 @@ impl ApplicationHandler for Application {
 
                 // Dispatch actions only on press.
                 if event.state.is_pressed() {
-                    let action = if let Key::Character(ch) = event.logical_key.as_ref() {
+                    let action = if let Key::Character(ch) = event.key_without_modifiers.as_ref() {
                         Self::process_key_binding(&ch.to_uppercase(), &mods)
                     } else {
                         None
@@ -578,18 +593,18 @@ impl ApplicationHandler for Application {
         }
     }
 
-    #[cfg(not(android_platform))]
-    fn exiting(&mut self, _event_loop: &dyn ActiveEventLoop) {
-        // We must drop the context here.
-        self.context = None;
-    }
-
     #[cfg(target_os = "macos")]
     fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
         Some(self)
     }
 }
 
+impl Drop for Application {
+    fn drop(&mut self) {
+        info!("Application exited");
+    }
+}
+
 #[cfg(target_os = "macos")]
 impl ApplicationHandlerExtMacOS for Application {
     fn standard_key_binding(
@@ -615,6 +630,13 @@ struct WindowState {
     window: Arc<dyn Window>,
     /// The window theme we're drawing with.
     theme: Theme,
+    /// Fill the window with animated color
+    animated_fill_color: bool,
+    /// The application start time. Used for color fill animation
+    #[cfg(not(android_platform))]
+    start_time: std::time::Instant,
+    /// Redraw continuously
+    continuous_redraw: bool,
     /// Cursor position over the window.
     cursor_position: Option<PhysicalPosition<f64>>,
     /// Window modifiers state.
@@ -668,6 +690,10 @@ impl WindowState {
             surface,
             window,
             theme,
+            animated_fill_color: false,
+            continuous_redraw: false,
+            #[cfg(not(android_platform))]
+            start_time: std::time::Instant::now(),
             ime,
             cursor_position: Default::default(),
             cursor_hidden: Default::default(),
@@ -835,7 +861,7 @@ impl WindowState {
             custom_cursors[1].clone(),
             event_loop.create_custom_cursor(url_custom_cursor())?,
         ];
-        let cursor = CustomCursor::from_animation(Duration::from_secs(3), cursors).unwrap();
+        let cursor = CustomCursorSource::from_animation(Duration::from_secs(3), cursors).unwrap();
         let cursor = event_loop.create_custom_cursor(cursor)?;
 
         self.window.set_cursor(cursor.into());
@@ -946,6 +972,11 @@ impl WindowState {
             return Ok(());
         }
 
+        if self.animated_fill_color {
+            fill::fill_window_with_animated_color(&*self.window, self.start_time);
+            return Ok(());
+        }
+
         let mut buffer = self.surface.buffer_mut()?;
 
         // Draw a different color inside the safe area
@@ -1037,6 +1068,8 @@ enum Action {
     RequestResize,
     DumpMonitors,
     Message,
+    ToggleAnimatedFillColor,
+    ToggleContinuousRedraw,
 }
 
 impl Action {
@@ -1081,6 +1114,8 @@ impl Action {
                  information"
             },
             Action::Message => "Prints a message through a user wake up",
+            Action::ToggleAnimatedFillColor => "Toggle animated fill color",
+            Action::ToggleContinuousRedraw => "Toggle continuous redraw",
         }
     }
 }
@@ -1096,7 +1131,7 @@ fn decode_cursor(bytes: &[u8]) -> CustomCursorSource {
     let samples = img.into_flat_samples();
     let (_, w, h) = samples.extents();
     let (w, h) = (w as u16, h as u16);
-    CustomCursor::from_rgba(samples.samples, w, h, w / 2, h / 2).unwrap()
+    CustomCursorSource::from_rgba(samples.samples, w, h, w / 2, h / 2).unwrap()
 }
 
 #[cfg(web_platform)]
@@ -1105,11 +1140,14 @@ fn url_custom_cursor() -> CustomCursorSource {
 
     static URL_COUNTER: AtomicU64 = AtomicU64::new(0);
 
-    CustomCursor::from_url(
-        format!("https://picsum.photos/128?random={}", URL_COUNTER.fetch_add(1, Ordering::Relaxed)),
-        64,
-        64,
-    )
+    CustomCursorSource::Url {
+        hotspot_x: 64,
+        hotspot_y: 64,
+        url: format!(
+            "https://picsum.photos/128?random={}",
+            URL_COUNTER.fetch_add(1, Ordering::Relaxed)
+        ),
+    }
 }
 
 fn load_icon(bytes: &[u8]) -> Icon {
@@ -1119,14 +1157,23 @@ fn load_icon(bytes: &[u8]) -> Icon {
         let rgba = image.into_raw();
         (rgba, width, height)
     };
-    Icon::from_rgba(icon_rgba, icon_width, icon_height).expect("Failed to open icon")
+    RgbaIcon::new(icon_rgba, icon_width, icon_height).expect("Failed to open icon").into()
 }
 
 fn modifiers_to_string(mods: ModifiersState) -> String {
     let mut mods_line = String::new();
     // Always add + since it's printed as a part of the bindings.
     for (modifier, desc) in [
-        (ModifiersState::SUPER, "Super+"),
+        (
+            ModifiersState::META,
+            if cfg!(target_os = "windows") {
+                "Win+"
+            } else if cfg!(target_vendor = "apple") {
+                "Cmd+"
+            } else {
+                "Super+"
+            },
+        ),
         (ModifiersState::ALT, "Alt+"),
         (ModifiersState::CONTROL, "Ctrl+"),
         (ModifiersState::SHIFT, "Shift+"),
@@ -1192,6 +1239,7 @@ const CURSORS: &[CursorIcon] = &[
 const KEY_BINDINGS: &[Binding<&'static str>] = &[
     Binding::new("Q", ModifiersState::CONTROL, Action::CloseWindow),
     Binding::new("H", ModifiersState::CONTROL, Action::PrintHelp),
+    Binding::new("F", ModifiersState::SHIFT, Action::ToggleAnimatedFillColor),
     Binding::new("F", ModifiersState::CONTROL, Action::ToggleFullscreen),
     #[cfg(macos_platform)]
     Binding::new("F", ModifiersState::ALT, Action::ToggleSimpleFullscreen),
@@ -1201,6 +1249,7 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
     Binding::new("P", ModifiersState::CONTROL, Action::ToggleResizeIncrements),
     Binding::new("R", ModifiersState::CONTROL, Action::ToggleResizable),
     Binding::new("R", ModifiersState::ALT, Action::RequestResize),
+    Binding::new("R", ModifiersState::SHIFT, Action::ToggleContinuousRedraw),
     // M.
     Binding::new("M", ModifiersState::CONTROL.union(ModifiersState::ALT), Action::DumpMonitors),
     Binding::new("M", ModifiersState::CONTROL, Action::ToggleMaximize),
@@ -1225,10 +1274,10 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
     Binding::new("Z", ModifiersState::CONTROL, Action::ToggleCursorVisibility),
     // K.
     Binding::new("K", ModifiersState::empty(), Action::SetTheme(None)),
-    Binding::new("K", ModifiersState::SUPER, Action::SetTheme(Some(Theme::Light))),
+    Binding::new("K", ModifiersState::META, Action::SetTheme(Some(Theme::Light))),
     Binding::new("K", ModifiersState::CONTROL, Action::SetTheme(Some(Theme::Dark))),
     #[cfg(macos_platform)]
-    Binding::new("T", ModifiersState::SUPER, Action::CreateNewTab),
+    Binding::new("T", ModifiersState::META, Action::CreateNewTab),
     #[cfg(macos_platform)]
     Binding::new("O", ModifiersState::CONTROL, Action::CycleOptionAsAlt),
     Binding::new("S", ModifiersState::CONTROL, Action::Message),

examples/child_window.rs

@@ -13,6 +13,7 @@ fn main() -> Result<(), impl std::error::Error> {
     #[path = "util/fill.rs"]
     mod fill;
 
+    #[derive(Debug)]
     struct WindowData {
         window: Box<dyn Window>,
         color: u32,
@@ -24,7 +25,7 @@ fn main() -> Result<(), impl std::error::Error> {
         }
     }
 
-    #[derive(Default)]
+    #[derive(Default, Debug)]
     struct Application {
         parent_window_id: Option<WindowId>,
         windows: HashMap<WindowId, WindowData>,

examples/control_flow.rs

@@ -46,7 +46,7 @@ fn main() -> Result<(), impl std::error::Error> {
     event_loop.run_app(ControlFlowDemo::default())
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 struct ControlFlowDemo {
     mode: Mode,
     request_redraw: bool,

examples/dnd.rs

@@ -20,6 +20,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 }
 
 /// Application state and event handling.
+#[derive(Debug)]
 struct Application {
     window: Option<Box<dyn Window>>,
 }

examples/pump_events.rs

@@ -16,7 +16,7 @@ fn main() -> std::process::ExitCode {
     #[path = "util/fill.rs"]
     mod fill;
 
-    #[derive(Default)]
+    #[derive(Default, Debug)]
     struct PumpDemo {
         window: Option<Box<dyn Window>>,
     }

examples/run_on_demand.rs

@@ -14,7 +14,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     #[path = "util/fill.rs"]
     mod fill;
 
-    #[derive(Default)]
+    #[derive(Default, Debug)]
     struct App {
         idx: usize,
         window_id: Option<WindowId>,

examples/util/fill.rs

@@ -12,6 +12,8 @@ pub use platform::cleanup_window;
 #[allow(unused_imports)]
 pub use platform::fill_window;
 #[allow(unused_imports)]
+pub use platform::fill_window_with_animated_color;
+#[allow(unused_imports)]
 pub use platform::fill_window_with_color;
 
 #[cfg(not(any(target_os = "android", target_os = "ios")))]
@@ -102,6 +104,16 @@ mod platform {
         fill_window_with_color(window, 0xff181818);
     }
 
+    #[allow(dead_code)]
+    pub fn fill_window_with_animated_color(window: &dyn Window, start: std::time::Instant) {
+        let time = start.elapsed().as_secs_f32() * 1.5;
+        let blue = (time.sin() * 255.0) as u32;
+        let green = ((time.cos() * 255.0) as u32) << 8;
+        let red = ((1.0 - time.sin() * 255.0) as u32) << 16;
+        let color = red | green | blue;
+        fill_window_with_color(window, color);
+    }
+
     #[allow(dead_code)]
     pub fn cleanup_window(window: &dyn Window) {
         GC.with(|gc| {
@@ -115,6 +127,7 @@ mod platform {
 
 #[cfg(any(target_os = "android", target_os = "ios"))]
 mod platform {
+    #[allow(dead_code)]
     pub fn fill_window(_window: &dyn winit::window::Window) {
         // No-op on mobile platforms.
     }
@@ -124,6 +137,14 @@ mod platform {
         // No-op on mobile platforms.
     }
 
+    #[allow(dead_code)]
+    pub fn fill_window_with_animated_color(
+        _window: &dyn winit::window::Window,
+        _start: std::time::Instant,
+    ) {
+        // No-op on mobile platforms.
+    }
+
     #[allow(dead_code)]
     pub fn cleanup_window(_window: &dyn winit::window::Window) {
         // No-op on mobile platforms.

examples/window.rs

@@ -11,8 +11,10 @@ use winit::window::{Window, WindowAttributes, WindowId};
 
 #[path = "util/fill.rs"]
 mod fill;
+#[path = "util/tracing.rs"]
+mod tracing;
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 struct App {
     window: Option<Box<dyn Window>>,
 }
@@ -70,9 +72,12 @@ fn main() -> Result<(), Box<dyn Error>> {
     #[cfg(web_platform)]
     console_error_panic_hook::set_once();
 
+    tracing::init();
+
     let event_loop = EventLoop::new()?;
-    let mut app = App::default();
 
     // For alternative loop run options see `pump_events` and `run_on_demand` examples.
-    event_loop.run_app(&mut app).map_err(Into::into)
+    event_loop.run_app(App::default())?;
+
+    Ok(())
 }

examples/x11_embed.rs

@@ -12,6 +12,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     #[path = "util/fill.rs"]
     mod fill;
 
+    #[derive(Debug)]
     pub struct XEmbedDemo {
         parent_window_id: u32,
         window: Option<Box<dyn Window>>,

src/application.rs

@@ -2,11 +2,21 @@
 
 use crate::event::{DeviceEvent, DeviceId, StartCause, WindowEvent};
 use crate::event_loop::ActiveEventLoop;
-#[cfg(any(docsrs, macos_platform))]
+#[cfg(macos_platform)]
 use crate::platform::macos::ApplicationHandlerExtMacOS;
 use crate::window::WindowId;
 
-/// The handler of the application events.
+/// The handler of application-level events.
+///
+/// See [the top-level docs] for example usage, and [`EventLoop::run_app`] for an overview of when
+/// events are delivered.
+///
+/// This is [dropped] when the event loop is shut down. Note that this only works if you're passing
+/// the entire state to [`EventLoop::run_app`] (passing `&mut app` won't work).
+///
+/// [the top-level docs]: crate
+/// [`EventLoop::run_app`]: crate::event_loop::EventLoop::run_app
+/// [dropped]: std::ops::Drop
 pub trait ApplicationHandler {
     /// Emitted when new events arrive from the OS to be processed.
     ///
@@ -57,7 +67,6 @@ pub trait ApplicationHandler {
     ///
     /// [`resumed()`]: Self::resumed()
     /// [`suspended()`]: Self::suspended()
-    /// [`exiting()`]: Self::exiting()
     fn resumed(&mut self, event_loop: &dyn ActiveEventLoop) {
         let _ = event_loop;
     }
@@ -162,8 +171,6 @@ pub trait ApplicationHandler {
     ///
     ///     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 || {
@@ -171,7 +178,7 @@ pub trait ApplicationHandler {
     ///         loop {
     ///             println!("sending: {i}");
     ///             if sender.send(i).is_err() {
-    ///                 // Stop sending once `MyApp` is dropped
+    ///                 // Stop sending once the receiver is dropped
     ///                 break;
     ///             }
     ///             // Trigger the wake-up _after_ we placed the event in the channel.
@@ -182,9 +189,8 @@ pub trait ApplicationHandler {
     ///         }
     ///     });
     ///
-    ///     event_loop.run_app(&mut app)?;
+    ///     event_loop.run_app(MyApp { receiver })?;
     ///
-    ///     drop(app);
     ///     background_thread.join().unwrap();
     ///
     ///     Ok(())
@@ -203,6 +209,10 @@ pub trait ApplicationHandler {
     );
 
     /// Emitted when the OS sends an event to a device.
+    ///
+    /// For this to be called, it must be enabled with [`EventLoop::listen_device_events`].
+    ///
+    /// [`EventLoop::listen_device_events`]: crate::event_loop::EventLoop::listen_device_events
     fn device_event(
         &mut self,
         event_loop: &dyn ActiveEventLoop,
@@ -258,7 +268,7 @@ pub trait ApplicationHandler {
     /// to the user. This is a good place to stop refreshing UI, running animations and other visual
     /// things. It is driven by Android's [`onStop()`] method.
     ///
-    /// After this event the application either receives [`resumed()`] again, or [`exiting()`].
+    /// After this event the application either receives [`resumed()`] again, or will exit.
     ///
     /// [`onStop()`]: https://developer.android.com/reference/android/app/Activity#onStop()
     ///
@@ -268,7 +278,6 @@ pub trait ApplicationHandler {
     ///
     /// [`resumed()`]: Self::resumed()
     /// [`suspended()`]: Self::suspended()
-    /// [`exiting()`]: Self::exiting()
     fn suspended(&mut self, event_loop: &dyn ActiveEventLoop) {
         let _ = event_loop;
     }
@@ -310,14 +319,6 @@ pub trait ApplicationHandler {
         let _ = event_loop;
     }
 
-    /// Emitted when the event loop is being shut down.
-    ///
-    /// This is irreversible - if this method is called, it is guaranteed that the event loop
-    /// will exit right after.
-    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
-        let _ = event_loop;
-    }
-
     /// Emitted when the application has received a memory warning.
     ///
     /// ## Platform-specific
@@ -349,7 +350,7 @@ pub trait ApplicationHandler {
     /// The macOS-specific handler.
     ///
     /// The return value from this should not change at runtime.
-    #[cfg(any(docsrs, macos_platform))]
+    #[cfg(macos_platform)]
     #[inline(always)]
     fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
         None
@@ -413,17 +414,12 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
         (**self).destroy_surfaces(event_loop);
     }
 
-    #[inline]
-    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
-        (**self).exiting(event_loop);
-    }
-
     #[inline]
     fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
         (**self).memory_warning(event_loop);
     }
 
-    #[cfg(any(docsrs, macos_platform))]
+    #[cfg(macos_platform)]
     #[inline]
     fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
         (**self).macos_handler()
@@ -487,17 +483,12 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
         (**self).destroy_surfaces(event_loop);
     }
 
-    #[inline]
-    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
-        (**self).exiting(event_loop);
-    }
-
     #[inline]
     fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
         (**self).memory_warning(event_loop);
     }
 
-    #[cfg(any(docsrs, macos_platform))]
+    #[cfg(macos_platform)]
     #[inline]
     fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
         (**self).macos_handler()

src/changelog/unreleased.md

@@ -71,12 +71,17 @@ changelog entry.
 - Added `Window::safe_area`, which describes the area of the surface that is unobstructed.
 - On X11, Wayland, Windows and macOS, improved scancode conversions for more obscure key codes.
 - Add ability to make non-activating window on macOS using `NSPanel` with `NSWindowStyleMask::NonactivatingPanel`.
-- On Windows, add `IconExtWindows::from_resource_name`.
+- Implement `MonitorHandleProvider` for `MonitorHandle` to access common monitor API.
+- On X11, set an "area" attribute on XIM input connection to convey the cursor area.
+- Implement `CustomCursorProvider` for `CustomCursor` to access cursor API.
+- Add `CustomCursorSource::Url`, `CustomCursorSource::from_animation`.
+- Implement `CustomIconProvider` for `RgbaIcon`.
+- Add `icon` module that exposes winit's icon API.
 
 ### Changed
 
-- Change `ActiveEventLoop` to be a trait.
-- Change `Window` to be a trait.
+- Change `ActiveEventLoop` and `Window` to be traits, and added `cast_ref`/`cast_mut`/`cast`
+  methods to extract the backend type from those.
 - `ActiveEventLoop::create_window` now returns `Box<dyn Window>`.
 - `ApplicationHandler` now uses `dyn ActiveEventLoop`.
 - On Web, let events wake up event loop immediately when using `ControlFlow::Poll`.
@@ -109,10 +114,8 @@ changelog entry.
 - Changed how `ModifiersState` is serialized by Serde.
 - `VideoModeHandle::refresh_rate_millihertz()` and `bit_depth()` now return a `Option<NonZero*>`.
 - `MonitorHandle::position()` now returns an `Option`.
-- On iOS and macOS, remove custom application delegates. You are now allowed to override the
+- On macOS, remove custom application delegates. You are now allowed to override the
   application delegate yourself.
-- On iOS, no longer act as-if the application successfully open all URLs. Override
-  `application:didFinishLaunchingWithOptions:` and provide the desired behaviour yourself.
 - On X11, remove our dependency on libXcursor. (#3749)
 - Renamed the following APIs to make it clearer that the sizes apply to the underlying surface:
   - `WindowEvent::Resized` to `SurfaceResized`.
@@ -186,9 +189,12 @@ changelog entry.
 - Updated `windows-sys` to `v0.59`.
   - To match the corresponding changes in `windows-sys`, the `HWND`, `HMONITOR`, and `HMENU` types
     now alias to `*mut c_void` instead of `isize`.
-- On macOS, no longer need control of the main `NSApplication` class (which means you can now override it yourself).
 - Removed `KeyEventExtModifierSupplement`, and made the fields `text_with_all_modifiers` and
   `key_without_modifiers` public on `KeyEvent` instead.
+- Move `window::Fullscreen` to `monitor::Fullscreen`.
+- Renamed "super" key to "meta", to match the naming in the W3C specification.
+  `NamedKey::Super` still exists, but it's non-functional and deprecated, `NamedKey::Meta` should be used instead.
+- Move `IconExtWindows` into `WinIcon`.
 
 ### Removed
 
@@ -220,7 +226,13 @@ changelog entry.
 - Remove `WindowEvent::Touch` and `Touch` in favor of the new `PointerKind`, `PointerSource` and
  `ButtonSource` as part of the new pointer event overhaul.
 - Remove `Force::altitude_angle`.
-- Removed `Window::inner_position`, use the new `Window::surface_position` instead.
+- Remove `Window::inner_position`, use the new `Window::surface_position` instead.
+- Remove `CustomCursorExtWeb`, use the `CustomCursorSource`.
+- Remove `CustomCursor::from_rgba`, use `CustomCursorSource` instead.
+- Remove `ApplicationHandler::exited`, the event loop being shut down can now be listened to in
+  the `Drop` impl on the application handler.
+- Remove `NamedKey::Space`, match on `Key::Character(" ")` instead.
+- Remove `PartialEq` impl for `WindowAttributes`.
 
 ### Fixed
 

src/changelog/v0.30.md

@@ -1,3 +1,33 @@
+## 0.30.10
+
+### Added
+
+- On Windows, add `IconExtWindows::from_resource_name`.
+- On Windows, add `CursorGrabMode::Locked`.
+- On Wayland, add `WindowExtWayland::xdg_toplevel`.
+
+### Changed
+
+- On macOS, no longer need control of the main `NSApplication` class (which means you can now override it yourself).
+- On iOS, remove custom application delegates. You are now allowed to override the
+  application delegate yourself.
+- On iOS, no longer act as-if the application successfully open all URLs. Override
+  `application:didFinishLaunchingWithOptions:` and provide the desired behaviour yourself.
+
+### Fixed
+
+- On Windows, fixed ~500 ms pause when clicking the title bar during continuous redraw.
+- On macOS, `WindowExtMacOS::set_simple_fullscreen` now honors `WindowExtMacOS::set_borderless_game`
+- On X11 and Wayland, fixed pump_events with `Some(Duration::Zero)` blocking with `Wait` polling mode
+- On Wayland, fixed a crash when consequently calling `set_cursor_grab` without pointer focus.
+- On Wayland, ensure that external event loop is woken-up when using pump_events and integrating via `FD`.
+- On Wayland, apply fractional scaling to custom cursors.
+- On macOS, fixed `run_app_on_demand` returning without closing open windows.
+- On macOS, fixed `VideoMode::refresh_rate_millihertz` for fractional refresh rates.
+- On macOS, store monitor handle to avoid panics after going in/out of sleep.
+- On macOS, allow certain invalid monitor handles and return `None` instead of panicking.
+- On Windows, fixed `Ime::Preedit` cursor offset calculation.
+
 ## 0.30.9
 
 ### Changed

src/cursor.rs

@@ -1,13 +1,15 @@
 use core::fmt;
 use std::error::Error;
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
+use std::ops::Deref;
 use std::sync::Arc;
+use std::time::Duration;
 
 use cursor_icon::CursorIcon;
 
-use crate::platform_impl::{PlatformCustomCursor, PlatformCustomCursorSource};
+use crate::utils::{impl_dyn_casting, AsAny};
 
-/// The maximum width and height for a cursor when using [`CustomCursor::from_rgba`].
+/// The maximum width and height for a cursor when using [`CustomCursorSource::from_rgba`].
 pub const MAX_CURSOR_SIZE: u16 = 2048;
 
 const PIXEL_SIZE: usize = 4;
@@ -51,19 +53,20 @@ impl From<CustomCursor> for Cursor {
 /// # use winit::event_loop::ActiveEventLoop;
 /// # use winit::window::Window;
 /// # fn scope(event_loop: &dyn ActiveEventLoop, window: &dyn Window) {
-/// use winit::window::CustomCursor;
+/// use winit::window::CustomCursorSource;
 ///
 /// let w = 10;
 /// let h = 10;
 /// let rgba = vec![255; (w * h * 4) as usize];
 ///
 /// #[cfg(not(target_family = "wasm"))]
-/// let source = CustomCursor::from_rgba(rgba, w, h, w / 2, h / 2).unwrap();
+/// let source = CustomCursorSource::from_rgba(rgba, w, h, w / 2, h / 2).unwrap();
 ///
 /// #[cfg(target_family = "wasm")]
-/// let source = {
-///     use winit::platform::web::CustomCursorExtWeb;
-///     CustomCursor::from_url(String::from("http://localhost:3000/cursor.png"), 0, 0)
+/// let source = CustomCursorSource::Url {
+///     url: String::from("http://localhost:3000/cursor.png"),
+///     hotspot_x: 0,
+///     hotspot_y: 0,
 /// };
 ///
 /// if let Ok(custom_cursor) = event_loop.create_custom_cursor(source) {
@@ -71,50 +74,96 @@ impl From<CustomCursor> for Cursor {
 /// }
 /// # }
 /// ```
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct CustomCursor {
-    /// Platforms should make sure this is cheap to clone.
-    pub(crate) inner: PlatformCustomCursor,
+#[derive(Clone, Debug)]
+pub struct CustomCursor(pub(crate) Arc<dyn CustomCursorProvider>);
+
+pub trait CustomCursorProvider: AsAny + fmt::Debug + Send + Sync {
+    /// Whether a cursor was backed by animation.
+    fn is_animated(&self) -> bool;
 }
 
-impl CustomCursor {
-    /// Creates a new cursor from an rgba buffer.
-    ///
-    /// The alpha channel is assumed to be **not** premultiplied.
-    pub fn from_rgba(
-        rgba: impl Into<Vec<u8>>,
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    ) -> Result<CustomCursorSource, BadImage> {
-        let _span =
-            tracing::debug_span!("winit::Cursor::from_rgba", width, height, hotspot_x, hotspot_y)
-                .entered();
-
-        Ok(CustomCursorSource {
-            inner: PlatformCustomCursorSource::from_rgba(
-                rgba.into(),
-                width,
-                height,
-                hotspot_x,
-                hotspot_y,
-            )?,
-        })
+impl PartialEq for CustomCursor {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.0, &other.0)
     }
 }
 
+impl Eq for CustomCursor {}
+
+impl Hash for CustomCursor {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        Arc::as_ptr(&self.0).hash(state);
+    }
+}
+
+impl Deref for CustomCursor {
+    type Target = dyn CustomCursorProvider;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.deref()
+    }
+}
+
+impl_dyn_casting!(CustomCursorProvider);
+
 /// Source for [`CustomCursor`].
 ///
 /// See [`CustomCursor`] for more details.
 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
-pub struct CustomCursorSource {
-    // Some platforms don't support custom cursors.
-    #[allow(dead_code)]
-    pub(crate) inner: PlatformCustomCursorSource,
+pub enum CustomCursorSource {
+    /// Cursor that is backed by RGBA image.
+    ///
+    /// See [CustomCursorSource::from_rgba] for more.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Orbital:** Unsupported
+    Image(CursorImage),
+    /// Animated cursor.
+    ///
+    /// See [CustomCursorSource::from_animation] for more.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Wayland / Windows / X11 / macOS / Orbital:** Unsupported
+    Animation(CursorAnimation),
+    /// Creates a new cursor from a URL pointing to an image.
+    /// It uses the [url css function](https://developer.mozilla.org/en-US/docs/Web/CSS/url),
+    /// but browser support for image formats is inconsistent. Using [PNG] is recommended.
+    ///
+    /// [PNG]: https://en.wikipedia.org/wiki/PNG
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Wayland / Windows / X11 / macOS / Orbital:** Unsupported
+    Url { hotspot_x: u16, hotspot_y: u16, url: String },
 }
 
-/// An error produced when using [`CustomCursor::from_rgba`] with invalid arguments.
+impl CustomCursorSource {
+    /// Creates a new cursor from an rgba buffer.
+    ///
+    /// The alpha channel is assumed to be **not** premultiplied.
+    pub fn from_rgba(
+        rgba: Vec<u8>,
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    ) -> Result<Self, BadImage> {
+        CursorImage::from_rgba(rgba, width, height, hotspot_x, hotspot_y).map(Self::Image)
+    }
+
+    /// Crates a new animated cursor from multiple [`CustomCursor`]s
+    /// Supplied `cursors` can't be empty or other animations.
+    pub fn from_animation(
+        duration: Duration,
+        cursors: Vec<CustomCursor>,
+    ) -> Result<Self, BadAnimation> {
+        CursorAnimation::new(duration, cursors).map(Self::Animation)
+    }
+}
+
+/// An error produced when using [`CustomCursorSource::from_rgba`] with invalid arguments.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum BadImage {
@@ -164,47 +213,30 @@ impl fmt::Display for BadImage {
 
 impl Error for BadImage {}
 
-/// Platforms export this directly as `PlatformCustomCursorSource` if they need to only work with
-/// images.
-#[allow(dead_code)]
-#[derive(Debug, Clone, Eq, Hash, PartialEq)]
-pub(crate) struct OnlyCursorImageSource(pub(crate) CursorImage);
+/// An error produced when using [`CustomCursorSource::from_animation`] with invalid arguments.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum BadAnimation {
+    /// Produced when no cursors were supplied.
+    Empty,
+    /// Produced when a supplied cursor is an animation.
+    Animation,
+}
 
-#[allow(dead_code)]
-impl OnlyCursorImageSource {
-    pub(crate) fn from_rgba(
-        rgba: Vec<u8>,
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    ) -> Result<Self, BadImage> {
-        CursorImage::from_rgba(rgba, width, height, hotspot_x, hotspot_y).map(Self)
+impl fmt::Display for BadAnimation {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Empty => write!(f, "No cursors supplied"),
+            Self::Animation => write!(f, "A supplied cursor is an animation"),
+        }
     }
 }
 
-/// Platforms export this directly as `PlatformCustomCursor` if they don't implement caching.
-#[allow(dead_code)]
-#[derive(Debug, Clone)]
-pub(crate) struct OnlyCursorImage(pub(crate) Arc<CursorImage>);
-
-impl Hash for OnlyCursorImage {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        Arc::as_ptr(&self.0).hash(state);
-    }
-}
-
-impl PartialEq for OnlyCursorImage {
-    fn eq(&self, other: &Self) -> bool {
-        Arc::ptr_eq(&self.0, &other.0)
-    }
-}
-
-impl Eq for OnlyCursorImage {}
+impl Error for BadAnimation {}
 
 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
 #[allow(dead_code)]
-pub(crate) struct CursorImage {
+pub struct CursorImage {
     pub(crate) rgba: Vec<u8>,
     pub(crate) width: u16,
     pub(crate) height: u16,
@@ -247,20 +279,22 @@ impl CursorImage {
     }
 }
 
-// Platforms that don't support cursors will export this as `PlatformCustomCursor`.
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
-pub(crate) struct NoCustomCursor;
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CursorAnimation {
+    pub(crate) duration: Duration,
+    pub(crate) cursors: Vec<CustomCursor>,
+}
 
-#[allow(dead_code)]
-impl NoCustomCursor {
-    pub(crate) fn from_rgba(
-        rgba: Vec<u8>,
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    ) -> Result<Self, BadImage> {
-        CursorImage::from_rgba(rgba, width, height, hotspot_x, hotspot_y)?;
-        Ok(Self)
+impl CursorAnimation {
+    pub fn new(duration: Duration, cursors: Vec<CustomCursor>) -> Result<Self, BadAnimation> {
+        if cursors.is_empty() {
+            return Err(BadAnimation::Empty);
+        }
+
+        if cursors.iter().any(|cursor| cursor.is_animated()) {
+            return Err(BadAnimation::Animation);
+        }
+
+        Ok(Self { duration, cursors })
     }
 }

src/event.rs

@@ -1,39 +1,4 @@
 //! The event enums 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
-//! documentation.
-//!
-//! Some of these events represent different "parts" of a traditional event-handling loop. You could
-//! approximate the basic ordering loop of [`EventLoop::run_app(...)`] like this:
-//!
-//! ```rust,ignore
-//! let mut start_cause = StartCause::Init;
-//!
-//! while !elwt.exiting() {
-//!     app.new_events(event_loop, start_cause);
-//!
-//!     for event in (window events, user events, device events) {
-//!         // This will pick the right method on the application based on the event.
-//!         app.handle_event(event_loop, event);
-//!     }
-//!
-//!     for window_id in (redraw windows) {
-//!         app.window_event(event_loop, window_id, RedrawRequested);
-//!     }
-//!
-//!     app.about_to_wait(event_loop);
-//!     start_cause = wait_if_necessary();
-//! }
-//!
-//! app.exiting(event_loop);
-//! ```
-//!
-//! This leaves out timing details like [`ControlFlow::WaitUntil`] but hopefully
-//! describes what happens in what order.
-//!
-//! [`EventLoop::run_app(...)`]: crate::event_loop::EventLoop::run_app
-//! [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
 use std::path::PathBuf;
 use std::sync::{Mutex, Weak};
 #[cfg(not(web_platform))]
@@ -641,10 +606,12 @@ impl FingerId {
 ///
 /// Useful for interactions that diverge significantly from a conventional 2D GUI, such as 3D camera
 /// or first-person game controls. Many physical actions, such as mouse movement, can produce both
-/// device and window events. Because window events typically arise from virtual devices
+/// device and [window events]. Because window events typically arise from virtual devices
 /// (corresponding to GUI pointers and keyboard focus) the device IDs may not match.
 ///
 /// Note that these events are delivered regardless of input focus.
+///
+/// [window events]: WindowEvent
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub enum DeviceEvent {
     /// Change in physical position of a pointing device.
@@ -657,11 +624,11 @@ pub enum DeviceEvent {
     /// **Web:** Only returns raw data, not OS accelerated, if [`CursorGrabMode::Locked`] is used
     /// and browser support is available, see
     #[cfg_attr(
-        any(web_platform, docsrs),
+        web_platform,
         doc = "[`ActiveEventLoopExtWeb::is_cursor_lock_raw()`][crate::platform::web::ActiveEventLoopExtWeb::is_cursor_lock_raw()]."
     )]
     #[cfg_attr(
-        not(any(web_platform, docsrs)),
+        not(web_platform),
         doc = "`ActiveEventLoopExtWeb::is_cursor_lock_raw()`."
     )]
     ///
@@ -902,12 +869,12 @@ impl Modifiers {
 
     /// The state of the left super key.
     pub fn lsuper_state(&self) -> ModifiersKeyState {
-        self.mod_state(ModifiersKeys::LSUPER)
+        self.mod_state(ModifiersKeys::LMETA)
     }
 
     /// The state of the right super key.
     pub fn rsuper_state(&self) -> ModifiersKeyState {
-        self.mod_state(ModifiersKeys::RSUPER)
+        self.mod_state(ModifiersKeys::RMETA)
     }
 
     fn mod_state(&self, modifier: ModifiersKeys) -> ModifiersKeyState {

src/event_loop.rs

@@ -25,7 +25,7 @@ use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, RequestError};
 use crate::monitor::MonitorHandle;
 use crate::platform_impl;
-use crate::utils::AsAny;
+use crate::utils::{impl_dyn_casting, AsAny};
 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
@@ -43,6 +43,7 @@ use crate::window::{CustomCursor, CustomCursorSource, Theme, Window, WindowAttri
 /// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread.
 ///
 /// [`Window`]: crate::window::Window
+#[derive(Debug)]
 pub struct EventLoop {
     pub(crate) event_loop: platform_impl::EventLoop,
     pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
@@ -54,7 +55,7 @@ pub struct EventLoop {
 /// easier. But note that constructing multiple event loops is not supported.
 ///
 /// This can be created using [`EventLoop::builder`].
-#[derive(Default, PartialEq, Eq, Hash)]
+#[derive(Default, Debug, PartialEq, Eq, Hash)]
 pub struct EventLoopBuilder {
     pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
 }
@@ -117,18 +118,6 @@ impl EventLoopBuilder {
     }
 }
 
-impl fmt::Debug for EventLoopBuilder {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventLoopBuilder").finish_non_exhaustive()
-    }
-}
-
-impl fmt::Debug for EventLoop {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventLoop").finish_non_exhaustive()
-    }
-}
-
 /// Set through [`ActiveEventLoop::set_control_flow()`].
 ///
 /// Indicates the desired behavior of the event loop after [`about_to_wait`] is called.
@@ -197,7 +186,56 @@ impl EventLoop {
 impl EventLoop {
     /// 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.
+    /// ## Event loop flow
+    ///
+    /// This function internally handles the different parts of a traditional event-handling loop.
+    /// You can imagine this method as being implemented like this:
+    ///
+    /// ```rust,ignore
+    /// let mut start_cause = StartCause::Init;
+    ///
+    /// // Run the event loop.
+    /// while !event_loop.exiting() {
+    ///     // Wake up.
+    ///     app.new_events(event_loop, start_cause);
+    ///
+    ///     // Indicate that surfaces can now safely be created.
+    ///     if start_cause == StartCause::Init {
+    ///         app.can_create_surfaces(event_loop);
+    ///     }
+    ///
+    ///     // Handle proxy wake-up event.
+    ///     if event_loop.proxy_wake_up_set() {
+    ///         event_loop.proxy_wake_up_clear();
+    ///         app.proxy_wake_up(event_loop);
+    ///     }
+    ///
+    ///     // Handle actions done by the user / system such as moving the cursor, resizing the
+    ///     // window, changing the window theme, etc.
+    ///     for event in event_loop.events() {
+    ///         match event {
+    ///             window event => app.window_event(event_loop, window_id, event),
+    ///             device event => app.device_event(event_loop, device_id, event),
+    ///         }
+    ///     }
+    ///
+    ///     // Handle redraws.
+    ///     for window_id in event_loop.pending_redraws() {
+    ///         app.window_event(event_loop, window_id, WindowEvent::RedrawRequested);
+    ///     }
+    ///
+    ///     // Done handling events, wait until we're woken up again.
+    ///     app.about_to_wait(event_loop);
+    ///     start_cause = event_loop.wait_if_necessary();
+    /// }
+    ///
+    /// // Finished running, drop application state.
+    /// drop(app);
+    /// ```
+    ///
+    /// This is of course a very coarse-grained overview, and leaves out timing details like
+    /// [`ControlFlow::WaitUntil`] and life-cycle methods like [`ApplicationHandler::resumed`], but
+    /// it should give you an idea of how things fit together.
     ///
     /// ## Platform-specific
     ///
@@ -209,10 +247,10 @@ impl EventLoop {
     ///
     ///   Web applications are recommended to use
     #[cfg_attr(
-        any(web_platform, docsrs),
+        web_platform,
         doc = "  [`EventLoopExtWeb::spawn_app()`][crate::platform::web::EventLoopExtWeb::spawn_app()]"
     )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  `EventLoopExtWeb::spawn_app()`")]
+    #[cfg_attr(not(web_platform), doc = "  `EventLoopExtWeb::spawn_app()`")]
     ///   [^1] instead of [`run_app()`] to avoid the need for the Javascript exception trick, and to
     ///   make   it clearer that the event loop runs asynchronously (via the browser's own,
     ///   internal, event   loop) and doesn't block the current thread of execution like it does
@@ -309,7 +347,7 @@ impl AsRawFd for EventLoop {
     }
 }
 
-pub trait ActiveEventLoop: AsAny {
+pub trait ActiveEventLoop: AsAny + fmt::Debug {
     /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
     /// to the main event loop, possibly from another thread.
     fn create_proxy(&self) -> EventLoopProxy;
@@ -343,10 +381,10 @@ pub trait ActiveEventLoop: AsAny {
     ///
     /// **Web:** Only returns the current monitor without
     #[cfg_attr(
-        any(web_platform, docsrs),
+        web_platform,
         doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
     )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
+    #[cfg_attr(not(web_platform), doc = "detailed monitor permissions.")]
     fn available_monitors(&self) -> Box<dyn Iterator<Item = MonitorHandle>>;
 
     /// Returns the primary monitor of the system.
@@ -358,10 +396,10 @@ pub trait ActiveEventLoop: AsAny {
     /// - **Wayland:** Always returns `None`.
     /// - **Web:** Always returns `None` without
     #[cfg_attr(
-        any(web_platform, docsrs),
+        web_platform,
         doc = "  [detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
     )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  detailed monitor permissions.")]
+    #[cfg_attr(not(web_platform), doc = "  detailed monitor permissions.")]
     fn primary_monitor(&self) -> Option<MonitorHandle>;
 
     /// Change if or when [`DeviceEvent`]s are captured.
@@ -392,14 +430,21 @@ pub trait ActiveEventLoop: AsAny {
     /// Gets the current [`ControlFlow`].
     fn control_flow(&self) -> ControlFlow;
 
-    /// This exits the event loop.
+    /// Stop the event loop.
     ///
-    /// See [`exiting`][crate::application::ApplicationHandler::exiting].
+    /// ## Platform-specific
+    ///
+    /// ### iOS
+    ///
+    /// It is not possible to programmatically exit/quit an application on iOS, so this function is
+    /// a no-op there. See also [this technical Q&A][qa1561].
+    ///
+    /// [qa1561]: https://developer.apple.com/library/archive/qa/qa1561/_index.html
     fn exit(&self);
 
-    /// Returns if the [`EventLoop`] is about to stop.
+    /// Returns whether the [`EventLoop`] is about to stop.
     ///
-    /// See [`exit()`][Self::exit].
+    /// Set by [`exit()`][Self::exit].
     fn exiting(&self) -> bool;
 
     /// Gets a persistent reference to the underlying platform display.
@@ -417,6 +462,8 @@ impl HasDisplayHandle for dyn ActiveEventLoop + '_ {
     }
 }
 
+impl_dyn_casting!(ActiveEventLoop);
+
 /// A proxy for the underlying display handle.
 ///
 /// The purpose of this type is to provide a cheaply cloneable handle to the underlying
@@ -463,23 +510,17 @@ impl PartialEq for OwnedDisplayHandle {
 
 impl Eq for OwnedDisplayHandle {}
 
-pub(crate) trait EventLoopProxyProvider: Send + Sync {
+pub(crate) trait EventLoopProxyProvider: Send + Sync + fmt::Debug {
     /// See [`EventLoopProxy::wake_up`] for details.
     fn wake_up(&self);
 }
 
 /// Control the [`EventLoop`], possibly from a different thread, without referencing it directly.
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct EventLoopProxy {
     pub(crate) proxy: Arc<dyn EventLoopProxyProvider>,
 }
 
-impl fmt::Debug for EventLoopProxy {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventLoopProxy").finish_non_exhaustive()
-    }
-}
-
 impl EventLoopProxy {
     /// Wake up the [`EventLoop`], resulting in [`ApplicationHandler::proxy_wake_up()`] being
     /// called.

src/icon.rs

@@ -1,7 +1,20 @@
 use std::error::Error;
+use std::sync::Arc;
 use std::{fmt, io, mem};
 
-use crate::platform_impl::PlatformIcon;
+use crate::utils::{impl_dyn_casting, AsAny};
+
+pub(crate) const PIXEL_SIZE: usize = mem::size_of::<Pixel>();
+
+/// An icon used for the window titlebar, taskbar, etc.
+#[allow(dead_code)]
+#[derive(Debug, Clone)]
+pub struct Icon(pub(crate) Arc<dyn IconProvider>);
+
+// TODO remove that once split.
+pub trait IconProvider: AsAny + fmt::Debug + Send + Sync {}
+
+impl_dyn_casting!(IconProvider);
 
 #[repr(C)]
 #[derive(Debug)]
@@ -12,10 +25,8 @@ pub(crate) struct Pixel {
     pub(crate) a: u8,
 }
 
-pub(crate) const PIXEL_SIZE: usize = mem::size_of::<Pixel>();
-
 #[derive(Debug)]
-/// An error produced when using [`Icon::from_rgba`] with invalid arguments.
+/// An error produced when using [`RgbaIcon::new`] with invalid arguments.
 pub enum BadIcon {
     /// Produced when the length of the `rgba` argument isn't divisible by 4, thus `rgba` can't be
     /// safely interpreted as 32bpp RGBA pixels.
@@ -50,69 +61,48 @@ impl fmt::Display for BadIcon {
 
 impl Error for BadIcon {}
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct RgbaIcon {
-    pub(crate) rgba: Vec<u8>,
+#[derive(Debug, Clone)]
+pub struct RgbaIcon {
     pub(crate) width: u32,
     pub(crate) height: u32,
+    pub(crate) rgba: Vec<u8>,
 }
 
-/// For platforms which don't have window icons (e.g. Web)
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct NoIcon;
-
-#[allow(dead_code)] // These are not used on every platform
-mod constructors {
-    use super::*;
-
-    impl RgbaIcon {
-        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
-            if rgba.len() % PIXEL_SIZE != 0 {
-                return Err(BadIcon::ByteCountNotDivisibleBy4 { byte_count: rgba.len() });
-            }
-            let pixel_count = rgba.len() / PIXEL_SIZE;
-            if pixel_count != (width * height) as usize {
-                Err(BadIcon::DimensionsVsPixelCount {
-                    width,
-                    height,
-                    width_x_height: (width * height) as usize,
-                    pixel_count,
-                })
-            } else {
-                Ok(RgbaIcon { rgba, width, height })
-            }
+impl RgbaIcon {
+    pub fn new(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+        if rgba.len() % PIXEL_SIZE != 0 {
+            return Err(BadIcon::ByteCountNotDivisibleBy4 { byte_count: rgba.len() });
+        }
+        let pixel_count = rgba.len() / PIXEL_SIZE;
+        if pixel_count != (width * height) as usize {
+            Err(BadIcon::DimensionsVsPixelCount {
+                width,
+                height,
+                width_x_height: (width * height) as usize,
+                pixel_count,
+            })
+        } else {
+            Ok(RgbaIcon { rgba, width, height })
         }
     }
 
-    impl NoIcon {
-        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
-            // Create the rgba icon anyway to validate the input
-            let _ = RgbaIcon::from_rgba(rgba, width, height)?;
-            Ok(NoIcon)
-        }
+    pub fn width(&self) -> u32 {
+        self.width
+    }
+
+    pub fn height(&self) -> u32 {
+        self.height
+    }
+
+    pub fn buffer(&self) -> &[u8] {
+        self.rgba.as_slice()
     }
 }
 
-/// An icon used for the window titlebar, taskbar, etc.
-#[derive(Clone, Eq, Hash, PartialEq)]
-pub struct Icon {
-    pub(crate) inner: PlatformIcon,
-}
+impl IconProvider for RgbaIcon {}
 
-impl fmt::Debug for Icon {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        fmt::Debug::fmt(&self.inner, formatter)
-    }
-}
-
-impl Icon {
-    /// Creates an icon from 32bpp RGBA data.
-    ///
-    /// The length of `rgba` must be divisible by 4, and `width * height` must equal
-    /// `rgba.len() / 4`. Otherwise, this will return a `BadIcon` error.
-    pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
-        let _span = tracing::debug_span!("winit::Icon::from_rgba", width, height).entered();
-
-        Ok(Icon { inner: PlatformIcon::from_rgba(rgba, width, height)? })
+impl From<RgbaIcon> for Icon {
+    fn from(value: RgbaIcon) -> Self {
+        Self(Arc::new(value))
     }
 }

src/keyboard.rs

@@ -1,4 +1,5 @@
 //! Types related to the keyboard.
+#![cfg_attr(feature = "serde", allow(deprecated))] // https://github.com/serde-rs/serde/issues/2195
 
 // This file contains a substantial portion of the UI Events Specification by the W3C. In
 // particular, the variant names within `Key` and `KeyCode` and their documentation are modified
@@ -283,11 +284,7 @@ impl PartialEq<PhysicalKey> for NativeKeyCode {
 
 /// Code representing the location of a physical key
 ///
-/// This mostly conforms to the UI Events Specification's [`KeyboardEvent.code`] with a few
-/// exceptions:
-/// - The keys that the specification calls "MetaLeft" and "MetaRight" are named "SuperLeft" and
-///   "SuperRight" here.
-/// - The key that the specification calls "Super" is reported as `Unidentified` here.
+/// This conforms to the UI Events Specification's [`KeyboardEvent.code`].
 ///
 /// [`KeyboardEvent.code`]: https://w3c.github.io/uievents-code/#code-value-tables
 #[non_exhaustive]
@@ -420,7 +417,7 @@ pub enum KeyCode {
     /// <kbd>CapsLock</kbd> or <kbd>⇪</kbd>
     CapsLock,
     /// The application context menu key, which is typically found between the right
-    /// <kbd>Super</kbd> key and the right <kbd>Control</kbd> key.
+    /// <kbd>Meta</kbd> key and the right <kbd>Control</kbd> key.
     ContextMenu,
     /// <kbd>Control</kbd> or <kbd>⌃</kbd>
     ControlLeft,
@@ -429,9 +426,9 @@ pub enum KeyCode {
     /// <kbd>Enter</kbd> or <kbd>↵</kbd>. Labeled <kbd>Return</kbd> on Apple keyboards.
     Enter,
     /// The Windows, <kbd>⌘</kbd>, <kbd>Command</kbd>, or other OS symbol key.
-    SuperLeft,
+    MetaLeft,
     /// The Windows, <kbd>⌘</kbd>, <kbd>Command</kbd>, or other OS symbol key.
-    SuperRight,
+    MetaRight,
     /// <kbd>Shift</kbd> or <kbd>⇧</kbd>
     ShiftLeft,
     /// <kbd>Shift</kbd> or <kbd>⇧</kbd>
@@ -613,9 +610,11 @@ pub enum KeyCode {
     AudioVolumeMute,
     AudioVolumeUp,
     WakeUp,
-    // Legacy modifier key. Also called "Super" in certain places.
-    Meta,
     // Legacy modifier key.
+    #[deprecated = "marked as legacy in the spec, use Meta instead"]
+    Super,
+    // Legacy modifier key.
+    #[deprecated = "marked as legacy in the spec, use Meta instead"]
     Hyper,
     Turbo,
     Abort,
@@ -741,12 +740,7 @@ pub enum KeyCode {
 
 /// A [`Key::Named`] value
 ///
-/// This mostly conforms to the UI Events Specification's [`KeyboardEvent.key`] with a few
-/// exceptions:
-/// - The `Super` variant here, is named `Meta` in the aforementioned specification. (There's
-///   another key which the specification calls `Super`. That does not exist here.)
-/// - The `Space` variant here, can be identified by the character it generates in the
-///   specification.
+/// This conforms to the UI Events Specification's [`KeyboardEvent.key`].
 ///
 /// [`KeyboardEvent.key`]: https://w3c.github.io/uievents-key/
 #[non_exhaustive]
@@ -791,24 +785,22 @@ pub enum NamedKey {
     /// The Symbol modifier key (used on some virtual keyboards).
     Symbol,
     SymbolLock,
-    // Legacy modifier key. Also called "Super" in certain places.
-    Meta,
     // Legacy modifier key.
+    #[deprecated = "marked as legacy in the spec, use Meta instead"]
+    Super,
+    // Legacy modifier key.
+    #[deprecated = "marked as legacy in the spec, use Meta instead"]
     Hyper,
-    /// Used to enable "super" modifier function for interpreting concurrent or subsequent keyboard
+    /// Used to enable "meta" modifier function for interpreting concurrent or subsequent keyboard
     /// input. This key value is used for the "Windows Logo" key and the Apple `Command` or `⌘`
     /// key.
-    ///
-    /// Note: In some contexts (e.g. the Web) this is referred to as the "Meta" key.
-    Super,
+    Meta,
     /// The `Enter` or `↵` key. Used to activate current selection or accept current input. This
     /// key value is also used for the `Return` (Macintosh numpad) key. This key value is also
     /// used for the Android `KEYCODE_DPAD_CENTER`.
     Enter,
     /// The Horizontal Tabulation `Tab` key.
     Tab,
-    /// Used in text to insert a space between words. Usually located below the character keys.
-    Space,
     /// Navigate or traverse downward. (`KEYCODE_DPAD_DOWN`)
     ArrowDown,
     /// Navigate or traverse leftward. (`KEYCODE_DPAD_LEFT`)
@@ -864,7 +856,7 @@ pub enum NamedKey {
     Attn,
     Cancel,
     /// Show the application’s context menu.
-    /// This key is commonly found between the right `Super` key and the right `Control` key.
+    /// This key is commonly found between the right `Meta` key and the right `Control` key.
     ContextMenu,
     /// The `Esc` key. This key was originally used to initiate an escape sequence, but is
     /// now more generally used to exit or "escape" the current context, such as closing a dialog
@@ -1583,7 +1575,6 @@ impl NamedKey {
             NamedKey::Enter => Some("\r"),
             NamedKey::Backspace => Some("\x08"),
             NamedKey::Tab => Some("\t"),
-            NamedKey::Space => Some(" "),
             NamedKey::Escape => Some("\x1b"),
             _ => None,
         }
@@ -1709,7 +1700,9 @@ bitflags! {
         /// The "alt" key.
         const ALT = 0b100 << 6;
         /// This is the "windows" key on PC and "command" key on Mac.
-        const SUPER = 0b100 << 9;
+        const META = 0b100 << 9;
+        #[deprecated = "use META instead"]
+        const SUPER = Self::META.bits();
     }
 }
 
@@ -1729,9 +1722,9 @@ impl ModifiersState {
         self.intersects(Self::ALT)
     }
 
-    /// Returns `true` if the super key is pressed.
-    pub fn super_key(&self) -> bool {
-        self.intersects(Self::SUPER)
+    /// Returns `true` if the meta key is pressed.
+    pub fn meta_key(&self) -> bool {
+        self.intersects(Self::META)
     }
 }
 
@@ -1764,7 +1757,11 @@ bitflags! {
         const RCONTROL = 0b0000_1000;
         const LALT     = 0b0001_0000;
         const RALT     = 0b0010_0000;
-        const LSUPER   = 0b0100_0000;
-        const RSUPER   = 0b1000_0000;
+        const LMETA    = 0b0100_0000;
+        const RMETA    = 0b1000_0000;
+        #[deprecated = "use LMETA instead"]
+        const LSUPER   = Self::LMETA.bits();
+        #[deprecated = "use RMETA instead"]
+        const RSUPER   = Self::RMETA.bits();
     }
 }

src/lib.rs

@@ -26,9 +26,8 @@
 //! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
 //! [`DeviceEvent`].
 //!
-//! 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.
+//! You can retrieve events by calling [`EventLoop::run_app()`]. This function will dispatch events
+//! for every [`Window`] that was created with that particular [`EventLoop`].
 //!
 //! 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
@@ -58,10 +57,19 @@
 //!
 //! impl ApplicationHandler for App {
 //!     fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
+//!         // The event loop has launched, and we can initialize our UI state.
+//!
+//!         // Create a simple window with default attributes.
 //!         self.window = Some(event_loop.create_window(WindowAttributes::default()).unwrap());
 //!     }
 //!
-//!     fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, id: WindowId, event: WindowEvent) {
+//!     fn window_event(
+//!         &mut self,
+//!         event_loop: &dyn ActiveEventLoop,
+//!         id: WindowId,
+//!         event: WindowEvent,
+//!     ) {
+//!         // Called by `EventLoop::run_app` when a new event happens on the window.
 //!         match event {
 //!             WindowEvent::CloseRequested => {
 //!                 println!("The close button was pressed; stopping");
@@ -82,15 +90,18 @@
 //!                 // applications which do not always need to. Applications that redraw continuously
 //!                 // can render here instead.
 //!                 self.window.as_ref().unwrap().request_redraw();
-//!             }
+//!             },
 //!             _ => (),
 //!         }
 //!     }
 //! }
 //!
 //! # // Intentionally use `fn main` for clarity
-//! fn main() {
-//!     let event_loop = EventLoop::new().unwrap();
+//! fn main() -> Result<(), Box<dyn std::error::Error>> {
+//!     // Create a new event loop.
+//!     let event_loop = EventLoop::new()?;
+//!
+//!     // Configure settings before launching.
 //!
 //!     // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
 //!     // dispatched any events. This is ideal for games and similar applications.
@@ -101,8 +112,10 @@
 //!     // input, and uses significantly less power/CPU time than ControlFlow::Poll.
 //!     event_loop.set_control_flow(ControlFlow::Wait);
 //!
-//!     let mut app = App::default();
-//!     event_loop.run_app(&mut app);
+//!     // Launch and begin running the event loop.
+//!     event_loop.run_app(App::default())?;
+//!
+//!     Ok(())
 //! }
 //! ```
 //!
@@ -261,7 +274,6 @@
 //! [`Window::id()`]: window::Window::id
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
-//! [`exiting()`]: crate::application::ApplicationHandler::exiting
 //! [`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.
@@ -276,6 +288,8 @@
 #![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
 #![allow(clippy::missing_safety_doc)]
 #![warn(clippy::uninlined_format_args)]
+// TODO: wasm-binding needs to be updated for that to be resolved, for now just silence it.
+#![cfg_attr(web_platform, allow(unknown_lints, wasm_c_abi))]
 
 // Re-export DPI types so that users don't have to put it in Cargo.toml.
 #[doc(inline)]
@@ -290,7 +304,7 @@ pub mod error;
 mod cursor;
 pub mod event;
 pub mod event_loop;
-mod icon;
+pub mod icon;
 pub mod keyboard;
 pub mod monitor;
 mod platform_impl;

src/monitor.rs

@@ -1,13 +1,158 @@
 //! Types useful for interacting with a user's monitors.
+//!
+//! If you want to get basic information about a monitor, you can use the
+//! [`MonitorHandle`] type. This is retrieved from one of the following
+//! methods, which return an iterator of [`MonitorHandle`]:
+//! - [`ActiveEventLoop::available_monitors`][crate::event_loop::ActiveEventLoop::available_monitors].
+//! - [`Window::available_monitors`][crate::window::Window::available_monitors].
+use std::borrow::Cow;
 use std::fmt;
 use std::num::{NonZeroU16, NonZeroU32};
+use std::ops::Deref;
+use std::sync::Arc;
 
 use crate::dpi::{PhysicalPosition, PhysicalSize};
-use crate::platform_impl;
+use crate::utils::{impl_dyn_casting, AsAny};
+
+/// Handle to a monitor.
+///
+/// Allows you to retrieve basic information and metadata about a monitor.
+///
+/// Can be used in [`Window`] creation to place the window on a specific
+/// monitor.
+///
+/// This can be retrieved from one of the following methods, which return an
+/// iterator of [`MonitorHandle`]s:
+/// - [`ActiveEventLoop::available_monitors`](crate::event_loop::ActiveEventLoop::available_monitors).
+/// - [`Window::available_monitors`](crate::window::Window::available_monitors).
+///
+/// ## Platform-specific
+///
+/// **Web:** A [`MonitorHandle`] created without
+#[cfg_attr(
+    web_platform,
+    doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+)]
+#[cfg_attr(not(web_platform), doc = "detailed monitor permissions.")]
+/// will always represent the current monitor the browser window is in instead of a specific
+/// monitor. See
+#[cfg_attr(
+    web_platform,
+    doc = "[`MonitorHandleExtWeb::is_detailed()`][crate::platform::web::MonitorHandleExtWeb::is_detailed]"
+)]
+#[cfg_attr(not(web_platform), doc = "`MonitorHandleExtWeb::is_detailed()`")]
+/// to check.
+///
+/// [`Window`]: crate::window::Window
+#[derive(Debug, Clone)]
+pub struct MonitorHandle(pub(crate) Arc<dyn MonitorHandleProvider>);
+
+impl Deref for MonitorHandle {
+    type Target = dyn MonitorHandleProvider;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.as_ref()
+    }
+}
+
+impl PartialEq for MonitorHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.as_ref().eq(other.0.as_ref())
+    }
+}
+
+impl Eq for MonitorHandle {}
+
+/// Provider of the [`MonitorHandle`].
+pub trait MonitorHandleProvider: AsAny + fmt::Debug + Send + Sync {
+    /// Identifier for this monitor.
+    ///
+    /// The representation of this modifier is not guaranteed and should be used only to compare
+    /// monitors.
+    fn id(&self) -> u128;
+
+    /// Native platform identifier of this monitor.
+    ///
+    /// # Platform-specific
+    ///
+    /// - **Windows**: This is `HMONITOR`.
+    /// - **macOS**: This is `CGDirectDisplayID`.
+    /// - **iOS**: This is `UIScreen*`.
+    /// - **Wayland**: This is the ID of the `wl_output` device.
+    /// - **X11**: This is the ID of the CRTC.
+    /// - **Web**: This is an internal ID not meant for consumption.
+    fn native_id(&self) -> u64;
+
+    /// Returns a human-readable name of the monitor.
+    ///
+    /// Returns `None` if the monitor doesn't exist anymore or the name couldn't be obtained.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Always returns [`None`] without
+    #[cfg_attr(
+        web_platform,
+        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+    )]
+    #[cfg_attr(not(web_platform), doc = "detailed monitor permissions.")]
+    fn name(&self) -> Option<Cow<'_, str>>;
+
+    /// Returns the top-left corner position of the monitor in desktop coordinates.
+    ///
+    /// This position is in the same coordinate system as [`Window::outer_position`].
+    ///
+    /// [`Window::outer_position`]: crate::window::Window::outer_position
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Always returns [`None`] without
+    #[cfg_attr(
+        web_platform,
+        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+    )]
+    #[cfg_attr(not(web_platform), doc = "detailed monitor permissions.")]
+    fn position(&self) -> Option<PhysicalPosition<i32>>;
+
+    /// Returns the scale factor of the underlying monitor. To map logical pixels to physical
+    /// pixels and vice versa, use [`Window::scale_factor`].
+    ///
+    /// See the [`dpi`] module for more information.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
+    /// - **Wayland:** May differ from [`Window::scale_factor`].
+    /// - **Android:** Always returns 1.0.
+    /// - **Web:** Always returns `0.0` without
+    #[cfg_attr(
+        web_platform,
+        doc = "  [detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
+    )]
+    #[cfg_attr(not(web_platform), doc = "  detailed monitor permissions.")]
+    ///
+    #[rustfmt::skip]
+    /// [`Window::scale_factor`]: crate::window::Window::scale_factor
+    fn scale_factor(&self) -> f64;
+
+    fn current_video_mode(&self) -> Option<VideoMode>;
+
+    /// Returns all fullscreen video modes supported by this monitor.
+    fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>>;
+}
+
+impl PartialEq for dyn MonitorHandleProvider + '_ {
+    fn eq(&self, other: &Self) -> bool {
+        self.id() == other.id()
+    }
+}
+
+impl Eq for dyn MonitorHandleProvider + '_ {}
+
+impl_dyn_casting!(MonitorHandleProvider);
 
 /// Describes a fullscreen video mode of a monitor.
 ///
-/// Can be retrieved with [`MonitorHandle::video_modes()`].
+/// Can be acquired with [`MonitorHandleProvider::video_modes`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub struct VideoMode {
     pub(crate) size: PhysicalSize<u32>,
@@ -39,131 +184,22 @@ impl VideoMode {
 
 impl fmt::Display for VideoMode {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}x{}", self.size.width, self.size.height)?;
-
-        if let Some(refresh_rate) = self.refresh_rate_millihertz {
-            write!(f, "@{refresh_rate}mHz")?;
-        }
-
-        if let Some(bit_depth) = self.bit_depth {
-            write!(f, " ({bit_depth} bpp)")?;
-        }
-
-        Ok(())
+        write!(
+            f,
+            "{}x{} {}{}",
+            self.size.width,
+            self.size.height,
+            self.refresh_rate_millihertz.map(|rate| format!("@ {rate} mHz ")).unwrap_or_default(),
+            self.bit_depth.map(|bit_depth| format!("({bit_depth} bpp)")).unwrap_or_default(),
+        )
     }
 }
 
-/// Handle to a monitor.
-///
-/// Allows you to retrieve basic information and metadata about a monitor.
-///
-/// Can be used in [`Window`] creation to place the window on a specific
-/// monitor.
-///
-/// This can be retrieved from one of the following methods, which return an
-/// iterator of [`MonitorHandle`]s:
-/// - [`ActiveEventLoop::available_monitors`](crate::event_loop::ActiveEventLoop::available_monitors).
-/// - [`Window::available_monitors`](crate::window::Window::available_monitors).
-///
-/// ## Platform-specific
-///
-/// **Web:** A [`MonitorHandle`] created without
-#[cfg_attr(
-    any(web_platform, docsrs),
-    doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-)]
-#[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
-/// will always represent the current monitor the browser window is in instead of a specific
-/// monitor. See
-#[cfg_attr(
-    any(web_platform, docsrs),
-    doc = "[`MonitorHandleExtWeb::is_detailed()`][crate::platform::web::MonitorHandleExtWeb::is_detailed]"
-)]
-#[cfg_attr(not(any(web_platform, docsrs)), doc = "`MonitorHandleExtWeb::is_detailed()`")]
-/// to check.
-///
-/// [`Window`]: crate::window::Window
-#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct MonitorHandle {
-    pub(crate) inner: platform_impl::MonitorHandle,
-}
-
-impl std::fmt::Debug for MonitorHandle {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.inner.fmt(f)
-    }
-}
-
-impl MonitorHandle {
-    /// Returns a human-readable name of the monitor.
-    ///
-    /// Returns `None` if the monitor doesn't exist anymore.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Always returns [`None`] without
-    #[cfg_attr(
-        any(web_platform, docsrs),
-        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
-    #[inline]
-    pub fn name(&self) -> Option<String> {
-        self.inner.name()
-    }
-
-    /// Returns the top-left corner position of the monitor in desktop coordinates.
-    ///
-    /// This position is in the same coordinate system as [`Window::outer_position`].
-    ///
-    /// [`Window::outer_position`]: crate::window::Window::outer_position
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Always returns [`None`] without
-    #[cfg_attr(
-        any(web_platform, docsrs),
-        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
-    #[inline]
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        self.inner.position()
-    }
-
-    /// Returns the scale factor of the underlying monitor. To map logical pixels to physical
-    /// pixels and vice versa, use [`Window::scale_factor`].
-    ///
-    /// See the [`dpi`] module for more information.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
-    /// - **Wayland:** May differ from [`Window::scale_factor`].
-    /// - **Android:** Always returns 1.0.
-    /// - **Web:** Always returns `0.0` without
-    #[cfg_attr(
-        any(web_platform, docsrs),
-        doc = "  [detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  detailed monitor permissions.")]
-    ///
-    #[rustfmt::skip]
-    /// [`Window::scale_factor`]: crate::window::Window::scale_factor
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        self.inner.scale_factor()
-    }
-
-    /// Returns the currently active video mode of this monitor.
-    #[inline]
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        self.inner.current_video_mode()
-    }
-
-    /// Returns all fullscreen video modes supported by this monitor.
-    #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        self.inner.video_modes()
-    }
+/// Fullscreen modes.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Fullscreen {
+    Exclusive(MonitorHandle, VideoMode),
+
+    /// Providing `None` to `Borderless` will fullscreen on the current monitor.
+    Borderless(Option<MonitorHandle>),
 }

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.9",
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.10",
 //!    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
@@ -101,20 +101,19 @@ pub trait WindowExtAndroid {
 
 impl WindowExtAndroid for dyn Window + '_ {
     fn content_rect(&self) -> Rect {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.content_rect()
     }
 
     fn config(&self) -> ConfigurationRef {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.config()
     }
 }
 
 impl ActiveEventLoopExtAndroid for dyn ActiveEventLoop + '_ {
     fn android_app(&self) -> &AndroidApp {
-        let event_loop =
-            self.as_any().downcast_ref::<crate::platform_impl::ActiveEventLoop>().unwrap();
+        let event_loop = self.cast_ref::<crate::platform_impl::ActiveEventLoop>().unwrap();
         &event_loop.app
     }
 }

src/platform/ios.rs

@@ -85,12 +85,9 @@
 //!
 //!  - applicationDidBecomeActive is Resumed
 //!  - applicationWillResignActive is Suspended
-//!  - applicationWillTerminate is LoopExiting
+//!  - applicationWillTerminate corresponds to `Drop`ping the application handler.
 //!
-//! Keep in mind that after LoopExiting event is received every attempt to draw with
-//! opengl will result in segfault.
-//!
-//! Also note that app may not receive the LoopExiting event if suspended; it might be SIGKILL'ed.
+//! Note that an app may not receive the `Drop` event if suspended; it might be SIGKILL'ed.
 //!
 //! ## Custom `UIApplicationDelegate`
 //!
@@ -108,6 +105,7 @@ use std::os::raw::c_void;
 use serde::{Deserialize, Serialize};
 
 use crate::monitor::{MonitorHandle, VideoMode};
+use crate::platform_impl::MonitorHandle as IosMonitorHandle;
 use crate::window::{Window, WindowAttributes};
 
 /// Additional methods on [`Window`] that are specific to iOS.
@@ -115,10 +113,11 @@ pub trait WindowExtIOS {
     /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
     ///
     /// The default value is device dependent, and it's recommended GLES or Metal applications set
-    /// this to [`MonitorHandle::scale_factor()`].
+    /// this to [`MonitorHandleProvider::scale_factor()`].
     ///
     /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
     /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
+    /// [`MonitorHandleProvider::scale_factor()`]: crate::monitor::MonitorHandleProvider::scale_factor()
     fn set_scale_factor(&self, scale_factor: f64);
 
     /// Sets the valid orientations for the [`Window`].
@@ -212,25 +211,25 @@ pub trait WindowExtIOS {
 impl WindowExtIOS for dyn Window + '_ {
     #[inline]
     fn set_scale_factor(&self, scale_factor: f64) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_scale_factor(scale_factor));
     }
 
     #[inline]
     fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_valid_orientations(valid_orientations));
     }
 
     #[inline]
     fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_prefers_home_indicator_hidden(hidden));
     }
 
     #[inline]
     fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| {
             w.set_preferred_screen_edges_deferring_system_gestures(edges)
         });
@@ -238,19 +237,19 @@ impl WindowExtIOS for dyn Window + '_ {
 
     #[inline]
     fn set_prefers_status_bar_hidden(&self, hidden: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_prefers_status_bar_hidden(hidden));
     }
 
     #[inline]
     fn set_preferred_status_bar_style(&self, status_bar_style: StatusBarStyle) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_preferred_status_bar_style(status_bar_style))
     }
 
     #[inline]
     fn recognize_pinch_gesture(&self, should_recognize: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.recognize_pinch_gesture(should_recognize));
     }
 
@@ -261,7 +260,7 @@ impl WindowExtIOS for dyn Window + '_ {
         minimum_number_of_touches: u8,
         maximum_number_of_touches: u8,
     ) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| {
             w.recognize_pan_gesture(
                 should_recognize,
@@ -273,13 +272,13 @@ impl WindowExtIOS for dyn Window + '_ {
 
     #[inline]
     fn recognize_doubletap_gesture(&self, should_recognize: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.recognize_doubletap_gesture(should_recognize));
     }
 
     #[inline]
     fn recognize_rotation_gesture(&self, should_recognize: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.recognize_rotation_gesture(should_recognize));
     }
 }
@@ -289,10 +288,11 @@ pub trait WindowAttributesExtIOS {
     /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
     ///
     /// The default value is device dependent, and it's recommended GLES or Metal applications set
-    /// this to [`MonitorHandle::scale_factor()`].
+    /// this to [`MonitorHandleProvider::scale_factor()`].
     ///
     /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
     /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
+    /// [`MonitorHandleProvider::scale_factor()`]: crate::monitor::MonitorHandleProvider::scale_factor()
     fn with_scale_factor(self, scale_factor: f64) -> Self;
 
     /// Sets the valid orientations for the [`Window`].
@@ -395,12 +395,14 @@ impl MonitorHandleExtIOS for MonitorHandle {
     fn ui_screen(&self) -> *mut c_void {
         // SAFETY: The marker is only used to get the pointer of the screen
         let mtm = unsafe { objc2::MainThreadMarker::new_unchecked() };
-        objc2::rc::Retained::as_ptr(self.inner.ui_screen(mtm)) as *mut c_void
+        let monitor = self.cast_ref::<IosMonitorHandle>().unwrap();
+        objc2::rc::Retained::as_ptr(monitor.ui_screen(mtm)) as *mut c_void
     }
 
     #[inline]
     fn preferred_video_mode(&self) -> VideoMode {
-        self.inner.preferred_video_mode()
+        let monitor = self.cast_ref::<IosMonitorHandle>().unwrap();
+        monitor.preferred_video_mode()
     }
 }
 

src/platform/macos.rs

@@ -73,6 +73,7 @@ use serde::{Deserialize, Serialize};
 use crate::application::ApplicationHandler;
 use crate::event_loop::{ActiveEventLoop, EventLoopBuilder};
 use crate::monitor::MonitorHandle;
+use crate::platform_impl::MonitorHandle as MacOsMonitorHandle;
 use crate::window::{Window, WindowAttributes, WindowId};
 
 /// Additional methods on [`Window`] that are specific to MacOS.
@@ -150,7 +151,9 @@ pub trait WindowExtMacOS {
     /// Getter for the [`WindowExtMacOS::set_option_as_alt`].
     fn option_as_alt(&self) -> OptionAsAlt;
 
-    /// Disable the Menu Bar and Dock in Borderless Fullscreen mode. Useful for games.
+    /// Disable the Menu Bar and Dock in Simple or Borderless Fullscreen mode. Useful for games.
+    /// The effect is applied when [`WindowExtMacOS::set_simple_fullscreen`] or
+    /// [`Window::set_fullscreen`] is called.
     fn set_borderless_game(&self, borderless_game: bool);
 
     /// Getter for the [`WindowExtMacOS::set_borderless_game`].
@@ -167,109 +170,109 @@ pub trait WindowExtMacOS {
 impl WindowExtMacOS for dyn Window + '_ {
     #[inline]
     fn simple_fullscreen(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.simple_fullscreen())
     }
 
     #[inline]
     fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_simple_fullscreen(fullscreen))
     }
 
     #[inline]
     fn has_shadow(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.has_shadow())
     }
 
     #[inline]
     fn set_has_shadow(&self, has_shadow: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_has_shadow(has_shadow));
     }
 
     #[inline]
     fn set_tabbing_identifier(&self, identifier: &str) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.set_tabbing_identifier(identifier))
     }
 
     #[inline]
     fn tabbing_identifier(&self) -> String {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.tabbing_identifier())
     }
 
     #[inline]
     fn select_next_tab(&self) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.select_next_tab());
     }
 
     #[inline]
     fn select_previous_tab(&self) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.select_previous_tab());
     }
 
     #[inline]
     fn select_tab_at_index(&self, index: usize) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.select_tab_at_index(index));
     }
 
     #[inline]
     fn num_tabs(&self) -> usize {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.num_tabs())
     }
 
     #[inline]
     fn is_document_edited(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.is_document_edited())
     }
 
     #[inline]
     fn set_document_edited(&self, edited: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_document_edited(edited));
     }
 
     #[inline]
     fn set_option_as_alt(&self, option_as_alt: OptionAsAlt) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_option_as_alt(option_as_alt));
     }
 
     #[inline]
     fn option_as_alt(&self) -> OptionAsAlt {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.option_as_alt())
     }
 
     #[inline]
     fn set_borderless_game(&self, borderless_game: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.set_borderless_game(borderless_game))
     }
 
     #[inline]
     fn is_borderless_game(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.is_borderless_game())
     }
 
     #[inline]
     fn set_unified_titlebar(&self, unified_titlebar: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.set_unified_titlebar(unified_titlebar))
     }
 
     #[inline]
     fn unified_titlebar(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.maybe_wait_on_main(|w| w.unified_titlebar())
     }
 }
@@ -499,22 +502,16 @@ impl EventLoopBuilderExtMacOS for EventLoopBuilder {
 
 /// Additional methods on [`MonitorHandle`] that are specific to MacOS.
 pub trait MonitorHandleExtMacOS {
-    /// Returns the identifier of the monitor for Cocoa.
-    fn native_id(&self) -> u32;
     /// Returns a pointer to the NSScreen representing this monitor.
     fn ns_screen(&self) -> Option<*mut c_void>;
 }
 
 impl MonitorHandleExtMacOS for MonitorHandle {
-    #[inline]
-    fn native_id(&self) -> u32 {
-        self.inner.native_identifier()
-    }
-
     fn ns_screen(&self) -> Option<*mut c_void> {
+        let monitor = self.cast_ref::<MacOsMonitorHandle>().unwrap();
         // SAFETY: We only use the marker to get a pointer
         let mtm = unsafe { objc2::MainThreadMarker::new_unchecked() };
-        self.inner.ns_screen(mtm).map(|s| objc2::rc::Retained::as_ptr(&s) as _)
+        monitor.ns_screen(mtm).map(|s| objc2::rc::Retained::as_ptr(&s) as _)
     }
 }
 
@@ -537,32 +534,28 @@ pub trait ActiveEventLoopExtMacOS {
 impl ActiveEventLoopExtMacOS for dyn ActiveEventLoop + '_ {
     fn hide_application(&self) {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non macOS event loop on macOS");
         event_loop.hide_application()
     }
 
     fn hide_other_applications(&self) {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non macOS event loop on macOS");
         event_loop.hide_other_applications()
     }
 
     fn set_allows_automatic_window_tabbing(&self, enabled: bool) {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non macOS event loop on macOS");
         event_loop.set_allows_automatic_window_tabbing(enabled);
     }
 
     fn allows_automatic_window_tabbing(&self) -> bool {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non macOS event loop on macOS");
         event_loop.allows_automatic_window_tabbing()
     }

src/platform/mod.rs

@@ -2,23 +2,23 @@
 //!
 //! Only the modules corresponding to the platform you're compiling to will be available.
 
-#[cfg(any(android_platform, docsrs))]
+#[cfg(android_platform)]
 pub mod android;
-#[cfg(any(ios_platform, docsrs))]
+#[cfg(ios_platform)]
 pub mod ios;
-#[cfg(any(macos_platform, docsrs))]
+#[cfg(macos_platform)]
 pub mod macos;
-#[cfg(any(orbital_platform, docsrs))]
+#[cfg(orbital_platform)]
 pub mod orbital;
-#[cfg(any(x11_platform, wayland_platform, docsrs))]
+#[cfg(any(x11_platform, wayland_platform))]
 pub mod startup_notify;
-#[cfg(any(wayland_platform, docsrs))]
+#[cfg(wayland_platform)]
 pub mod wayland;
-#[cfg(any(web_platform, docsrs))]
+#[cfg(web_platform)]
 pub mod web;
-#[cfg(any(windows_platform, docsrs))]
+#[cfg(windows_platform)]
 pub mod windows;
-#[cfg(any(x11_platform, docsrs))]
+#[cfg(x11_platform)]
 pub mod x11;
 
 #[allow(unused_imports)]

src/platform/pump_events.rs

@@ -47,19 +47,19 @@ pub trait EventLoopExtPumpEvents {
     /// buffered and handled outside of Winit include:
     /// - `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.
+    ///   macOS for example uses a `drawRect` callback to drive rendering
+    ///   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.
+    ///   For portability it's strongly recommended that applications should
+    ///   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.
+    ///   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.
     ///
     /// ## Supported Platforms
     ///

src/platform/run_on_demand.rs

@@ -33,10 +33,10 @@ pub trait EventLoopExtRunOnDemand {
     ///   to the caller (specifically this is impossible on iOS and Web - though with the Web
     ///   backend it is possible to use
     #[cfg_attr(
-        any(web_platform, docsrs),
+        web_platform,
         doc = "  [`EventLoopExtWeb::spawn_app()`][crate::platform::web::EventLoopExtWeb::spawn_app()]"
     )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  `EventLoopExtWeb::spawn_app()`")]
+    #[cfg_attr(not(web_platform), doc = "  `EventLoopExtWeb::spawn_app()`")]
     ///   [^1] more than once instead).
     /// - No [`Window`] state can be carried between separate runs of the event loop.
     ///

src/platform/startup_notify.rs

@@ -75,15 +75,12 @@ impl EventLoopExtStartupNotify for dyn ActiveEventLoop + '_ {
 impl WindowExtStartupNotify for dyn Window + '_ {
     fn request_activation_token(&self) -> Result<AsyncRequestSerial, RequestError> {
         #[cfg(wayland_platform)]
-        if let Some(window) = self.as_any().downcast_ref::<crate::platform_impl::wayland::Window>()
-        {
+        if let Some(window) = self.cast_ref::<crate::platform_impl::wayland::Window>() {
             return window.request_activation_token();
         }
 
         #[cfg(x11_platform)]
-        if let Some(window) =
-            self.as_any().downcast_ref::<crate::platform_impl::x11::window::Window>()
-        {
+        if let Some(window) = self.cast_ref::<crate::platform_impl::x11::window::Window>() {
             return window.request_activation_token();
         }
 

src/platform/wayland.rs

@@ -13,8 +13,12 @@
 //! * `wayland-csd-adwaita` (default).
 //! * `wayland-csd-adwaita-crossfont`.
 //! * `wayland-csd-adwaita-notitle`.
+
+use std::ffi::c_void;
+use std::ptr::NonNull;
+
 use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
-use crate::monitor::MonitorHandle;
+use crate::platform_impl::wayland::Window;
 pub use crate::window::Theme;
 use crate::window::{Window as CoreWindow, WindowAttributes};
 
@@ -27,7 +31,7 @@ pub trait ActiveEventLoopExtWayland {
 impl ActiveEventLoopExtWayland for dyn ActiveEventLoop + '_ {
     #[inline]
     fn is_wayland(&self) -> bool {
-        self.as_any().downcast_ref::<crate::platform_impl::wayland::ActiveEventLoop>().is_some()
+        self.cast_ref::<crate::platform_impl::wayland::ActiveEventLoop>().is_some()
     }
 }
 
@@ -73,9 +77,17 @@ impl EventLoopBuilderExtWayland for EventLoopBuilder {
 /// Additional methods on [`Window`] that are specific to Wayland.
 ///
 /// [`Window`]: crate::window::Window
-pub trait WindowExtWayland {}
+pub trait WindowExtWayland {
+    /// Returns `xdg_toplevel` of the window or [`None`] if the window is X11 window.
+    fn xdg_toplevel(&self) -> Option<NonNull<c_void>>;
+}
 
-impl WindowExtWayland for dyn CoreWindow + '_ {}
+impl WindowExtWayland for dyn CoreWindow + '_ {
+    #[inline]
+    fn xdg_toplevel(&self) -> Option<NonNull<c_void>> {
+        self.cast_ref::<Window>()?.xdg_toplevel()
+    }
+}
 
 /// Additional methods on [`WindowAttributes`] that are specific to Wayland.
 pub trait WindowAttributesExtWayland {
@@ -97,16 +109,3 @@ impl WindowAttributesExtWayland for WindowAttributes {
         self
     }
 }
-
-/// Additional methods on `MonitorHandle` that are specific to Wayland.
-pub trait MonitorHandleExtWayland {
-    /// Returns the inner identifier of the monitor.
-    fn native_id(&self) -> u32;
-}
-
-impl MonitorHandleExtWayland for MonitorHandle {
-    #[inline]
-    fn native_id(&self) -> u32 {
-        self.inner.native_identifier()
-    }
-}

src/platform/web.rs

@@ -46,8 +46,8 @@ use std::error::Error;
 use std::fmt::{self, Display, Formatter};
 use std::future::Future;
 use std::pin::Pin;
+use std::sync::Arc;
 use std::task::{Context, Poll};
-use std::time::Duration;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -58,8 +58,8 @@ use crate::application::ApplicationHandler;
 use crate::cursor::CustomCursorSource;
 use crate::error::NotSupportedError;
 use crate::event_loop::{ActiveEventLoop, EventLoop};
-use crate::monitor::MonitorHandle;
-use crate::platform_impl::PlatformCustomCursorSource;
+use crate::monitor::MonitorHandleProvider;
+use crate::platform_impl::MonitorHandle as WebMonitorHandle;
 #[cfg(web_platform)]
 use crate::platform_impl::{
     CustomCursorFuture as PlatformCustomCursorFuture,
@@ -105,29 +105,23 @@ pub trait WindowExtWeb {
 impl WindowExtWeb for dyn Window + '_ {
     #[inline]
     fn canvas(&self) -> Option<Ref<'_, HtmlCanvasElement>> {
-        self.as_any()
-            .downcast_ref::<crate::platform_impl::Window>()
-            .expect("non Web window on Web")
-            .canvas()
+        self.cast_ref::<crate::platform_impl::Window>().expect("non Web window on Web").canvas()
     }
 
     fn prevent_default(&self) -> bool {
-        self.as_any()
-            .downcast_ref::<crate::platform_impl::Window>()
+        self.cast_ref::<crate::platform_impl::Window>()
             .expect("non Web window on Web")
             .prevent_default()
     }
 
     fn set_prevent_default(&self, prevent_default: bool) {
-        self.as_any()
-            .downcast_ref::<crate::platform_impl::Window>()
+        self.cast_ref::<crate::platform_impl::Window>()
             .expect("non Web window on Web")
             .set_prevent_default(prevent_default)
     }
 
     fn is_cursor_lock_raw(&self) -> bool {
-        self.as_any()
-            .downcast_ref::<crate::platform_impl::Window>()
+        self.cast_ref::<crate::platform_impl::Window>()
             .expect("non Web window on Web")
             .is_cursor_lock_raw()
     }
@@ -253,12 +247,18 @@ pub trait EventLoopExtWeb {
     ///
     /// [`MonitorHandle`]s don't automatically make use of this after permission is granted. New
     /// [`MonitorHandle`]s have to be created instead.
+    ///
+    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
     fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture;
 
     /// Returns whether the user has given permission to access detailed monitor information.
     ///
     /// [`MonitorHandle`]s don't automatically make use of detailed monitor information after
     /// permission is granted. New [`MonitorHandle`]s have to be created instead.
+    ///
+    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
+    ///
+    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
     fn has_detailed_monitor_permission(&self) -> HasMonitorPermissionFuture;
 }
 
@@ -348,12 +348,16 @@ pub trait ActiveEventLoopExtWeb {
     ///
     /// [`MonitorHandle`]s don't automatically make use of this after permission is granted. New
     /// [`MonitorHandle`]s have to be created instead.
+    ///
+    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
     fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture;
 
     /// Returns whether the user has given permission to access detailed monitor information.
     ///
     /// [`MonitorHandle`]s don't automatically make use of detailed monitor information after
     /// permission is granted. New [`MonitorHandle`]s have to be created instead.
+    ///
+    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
     fn has_detailed_monitor_permission(&self) -> bool;
 }
 
@@ -361,8 +365,7 @@ impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non Web event loop on Web");
         event_loop.create_custom_cursor_async(source)
     }
@@ -370,8 +373,7 @@ impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn set_poll_strategy(&self, strategy: PollStrategy) {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non Web event loop on Web");
         event_loop.set_poll_strategy(strategy);
     }
@@ -379,8 +381,7 @@ impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn poll_strategy(&self) -> PollStrategy {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non Web event loop on Web");
         event_loop.poll_strategy()
     }
@@ -388,8 +389,7 @@ impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non Web event loop on Web");
         event_loop.set_wait_until_strategy(strategy);
     }
@@ -397,8 +397,7 @@ impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn wait_until_strategy(&self) -> WaitUntilStrategy {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non Web event loop on Web");
         event_loop.wait_until_strategy()
     }
@@ -406,8 +405,7 @@ impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn is_cursor_lock_raw(&self) -> bool {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non Web event loop on Web");
         event_loop.is_cursor_lock_raw()
     }
@@ -415,8 +413,7 @@ impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn has_multiple_screens(&self) -> Result<bool, NotSupportedError> {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non Web event loop on Web");
         event_loop.has_multiple_screens()
     }
@@ -424,8 +421,7 @@ impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non Web event loop on Web");
         MonitorPermissionFuture(event_loop.request_detailed_monitor_permission())
     }
@@ -433,8 +429,7 @@ impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn has_detailed_monitor_permission(&self) -> bool {
         let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
+            .cast_ref::<crate::platform_impl::ActiveEventLoop>()
             .expect("non Web event loop on Web");
         event_loop.has_detailed_monitor_permission()
     }
@@ -491,73 +486,6 @@ pub enum WaitUntilStrategy {
     Worker,
 }
 
-pub trait CustomCursorExtWeb {
-    /// Returns if this cursor is an animation.
-    fn is_animation(&self) -> bool;
-
-    /// Creates a new cursor from a URL pointing to an image.
-    /// It uses the [url css function](https://developer.mozilla.org/en-US/docs/Web/CSS/url),
-    /// but browser support for image formats is inconsistent. Using [PNG] is recommended.
-    ///
-    /// [PNG]: https://en.wikipedia.org/wiki/PNG
-    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorSource;
-
-    /// Crates a new animated cursor from multiple [`CustomCursor`]s.
-    /// Supplied `cursors` can't be empty or other animations.
-    fn from_animation(
-        duration: Duration,
-        cursors: Vec<CustomCursor>,
-    ) -> Result<CustomCursorSource, BadAnimation>;
-}
-
-impl CustomCursorExtWeb for CustomCursor {
-    fn is_animation(&self) -> bool {
-        self.inner.animation
-    }
-
-    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorSource {
-        CustomCursorSource { inner: PlatformCustomCursorSource::Url { url, hotspot_x, hotspot_y } }
-    }
-
-    fn from_animation(
-        duration: Duration,
-        cursors: Vec<CustomCursor>,
-    ) -> Result<CustomCursorSource, BadAnimation> {
-        if cursors.is_empty() {
-            return Err(BadAnimation::Empty);
-        }
-
-        if cursors.iter().any(CustomCursor::is_animation) {
-            return Err(BadAnimation::Animation);
-        }
-
-        Ok(CustomCursorSource {
-            inner: PlatformCustomCursorSource::Animation { duration, cursors },
-        })
-    }
-}
-
-/// An error produced when using [`CustomCursor::from_animation`] with invalid arguments.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum BadAnimation {
-    /// Produced when no cursors were supplied.
-    Empty,
-    /// Produced when a supplied cursor is an animation.
-    Animation,
-}
-
-impl fmt::Display for BadAnimation {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Empty => write!(f, "No cursors supplied"),
-            Self::Animation => write!(f, "A supplied cursor is an animation"),
-        }
-    }
-}
-
-impl Error for BadAnimation {}
-
 #[cfg(not(web_platform))]
 struct PlatformCustomCursorFuture;
 
@@ -568,7 +496,7 @@ impl Future for CustomCursorFuture {
     type Output = Result<CustomCursor, CustomCursorError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        Pin::new(&mut self.0).poll(cx).map_ok(|cursor| CustomCursor { inner: cursor })
+        Pin::new(&mut self.0).poll(cx).map_ok(|cursor| CustomCursor(Arc::new(cursor)))
     }
 }
 
@@ -650,6 +578,8 @@ impl Future for HasMonitorPermissionFuture {
 }
 
 /// Additional methods on [`MonitorHandle`] that are specific to the Web.
+///
+/// [`MonitorHandle`]: crate::monitor::MonitorHandle
 pub trait MonitorHandleExtWeb {
     /// Returns whether the screen is internal to the device or external.
     ///
@@ -677,28 +607,31 @@ pub trait MonitorHandleExtWeb {
     /// specific monitor.
     ///
     /// See [`ActiveEventLoopExtWeb::request_detailed_monitor_permission()`].
+    ///
+    /// [`MonitorHandle`]: crate::monitor::MonitorHandle
     fn is_detailed(&self) -> bool;
 }
 
-impl MonitorHandleExtWeb for MonitorHandle {
+impl MonitorHandleExtWeb for dyn MonitorHandleProvider + '_ {
     fn is_internal(&self) -> Option<bool> {
-        self.inner.is_internal()
+        self.cast_ref::<WebMonitorHandle>().unwrap().is_internal()
     }
 
     fn orientation(&self) -> OrientationData {
-        self.inner.orientation()
+        self.cast_ref::<WebMonitorHandle>().unwrap().orientation()
     }
 
     fn request_lock(&self, orientation_lock: OrientationLock) -> OrientationLockFuture {
-        OrientationLockFuture(self.inner.request_lock(orientation_lock))
+        let future = self.cast_ref::<WebMonitorHandle>().unwrap().request_lock(orientation_lock);
+        OrientationLockFuture(future)
     }
 
     fn unlock(&self) -> Result<(), OrientationLockError> {
-        self.inner.unlock()
+        self.cast_ref::<WebMonitorHandle>().unwrap().unlock()
     }
 
     fn is_detailed(&self) -> bool {
-        self.inner.is_detailed()
+        self.cast_ref::<WebMonitorHandle>().unwrap().is_detailed()
     }
 }
 

src/platform/windows.rs

@@ -6,6 +6,7 @@ use std::borrow::Borrow;
 use std::ffi::c_void;
 use std::ops::Deref;
 use std::path::Path;
+use std::sync::Arc;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -15,8 +16,9 @@ use windows_sys::Win32::Foundation::HANDLE;
 use crate::dpi::PhysicalSize;
 use crate::event::DeviceId;
 use crate::event_loop::EventLoopBuilder;
-use crate::monitor::MonitorHandle;
-use crate::window::{BadIcon, Icon, Window, WindowAttributes};
+use crate::icon::BadIcon;
+use crate::platform_impl::RaiiIcon;
+use crate::window::{Icon, Window, WindowAttributes};
 
 /// Window Handle type used by Win32 API
 pub type HWND = *mut c_void;
@@ -344,37 +346,37 @@ pub trait WindowExtWindows {
 impl WindowExtWindows for dyn Window + '_ {
     #[inline]
     fn set_enable(&self, enabled: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.set_enable(enabled)
     }
 
     #[inline]
     fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.set_taskbar_icon(taskbar_icon)
     }
 
     #[inline]
     fn set_skip_taskbar(&self, skip: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.set_skip_taskbar(skip)
     }
 
     #[inline]
     fn set_undecorated_shadow(&self, shadow: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.set_undecorated_shadow(shadow)
     }
 
     #[inline]
     fn set_system_backdrop(&self, backdrop_type: BackdropType) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.set_system_backdrop(backdrop_type)
     }
 
     #[inline]
     fn set_border_color(&self, color: Option<Color>) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.set_border_color(color.unwrap_or(Color::NONE))
     }
 
@@ -383,26 +385,26 @@ impl WindowExtWindows for dyn Window + '_ {
         // The windows docs don't mention NONE as a valid options but it works in practice and is
         // useful to circumvent the Windows option "Show accent color on title bars and
         // window borders"
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.set_title_background_color(color.unwrap_or(Color::NONE))
     }
 
     #[inline]
     fn set_title_text_color(&self, color: Color) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.set_title_text_color(color)
     }
 
     #[inline]
     fn set_corner_preference(&self, preference: CornerPreference) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         window.set_corner_preference(preference)
     }
 
     unsafe fn window_handle_any_thread(
         &self,
     ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<crate::platform_impl::Window>().unwrap();
         unsafe {
             let handle = window.rwh_06_no_thread_check()?;
 
@@ -618,27 +620,6 @@ impl WindowAttributesExtWindows for WindowAttributes {
     }
 }
 
-/// Additional methods on `MonitorHandle` that are specific to Windows.
-pub trait MonitorHandleExtWindows {
-    /// Returns the name of the monitor adapter specific to the Win32 API.
-    fn native_id(&self) -> String;
-
-    /// Returns the handle of the monitor - `HMONITOR`.
-    fn hmonitor(&self) -> HMONITOR;
-}
-
-impl MonitorHandleExtWindows for MonitorHandle {
-    #[inline]
-    fn native_id(&self) -> String {
-        self.inner.native_identifier()
-    }
-
-    #[inline]
-    fn hmonitor(&self) -> HMONITOR {
-        self.inner.hmonitor()
-    }
-}
-
 /// Additional methods on `DeviceId` that are specific to Windows.
 pub trait DeviceIdExtWindows {
     /// Returns an identifier that persistently refers to this specific device.
@@ -659,7 +640,7 @@ impl DeviceIdExtWindows for DeviceId {
     }
 }
 
-/// Additional methods on `Icon` that are specific to Windows.
+/// Windows specific `Icon`.
 ///
 /// Windows icons can be created from files, or from the [`embedded resources`](https://learn.microsoft.com/en-us/windows/win32/menurc/about-resource-files).
 ///
@@ -671,7 +652,12 @@ impl DeviceIdExtWindows for DeviceId {
 /// `filename` is the name of the file that contains the resource.
 ///
 /// More information about the `ICON` resource can be found at [`Microsoft Learn`](https://learn.microsoft.com/en-us/windows/win32/menurc/icon-resource) portal.
-pub trait IconExtWindows: Sized {
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct WinIcon {
+    pub(crate) inner: Arc<RaiiIcon>,
+}
+
+impl WinIcon {
     /// Create an icon from a file path.
     ///
     /// Specify `size` to load a specific icon size from the file, or `None` to load the default
@@ -679,22 +665,31 @@ pub trait IconExtWindows: Sized {
     ///
     /// In cases where the specified size does not exist in the file, Windows may perform scaling
     /// to get an icon of the desired size.
-    fn from_path<P: AsRef<Path>>(path: P, size: Option<PhysicalSize<u32>>)
-        -> Result<Self, BadIcon>;
+    pub fn from_path<P: AsRef<Path>>(
+        path: P,
+        size: Option<PhysicalSize<u32>>,
+    ) -> Result<Self, BadIcon> {
+        Self::from_path_impl(path, size)
+    }
 
     /// Create an icon from a resource embedded in this executable or library by its ordinal id.
     ///
     /// The valid `ordinal` values range from 1 to [`u16::MAX`] (inclusive). The value `0` is an
     /// invalid ordinal id, but it can be used with [`from_resource_name`] as `"0"`.
     ///
-    /// [`from_resource_name`]: IconExtWindows::from_resource_name
+    /// [`from_resource_name`]: Self::from_resource_name
     ///
     /// Specify `size` to load a specific icon size from the file, or `None` to load the default
     /// icon size from the file.
     ///
     /// In cases where the specified size does not exist in the file, Windows may perform scaling
     /// to get an icon of the desired size.
-    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
+    pub fn from_resource(
+        resource_id: u16,
+        size: Option<PhysicalSize<u32>>,
+    ) -> Result<Self, BadIcon> {
+        Self::from_resource_impl(resource_id, size)
+    }
 
     /// Create an icon from a resource embedded in this executable or library by its name.
     ///
@@ -719,17 +714,16 @@ pub trait IconExtWindows: Sized {
     /// `"002"`, etc.) cannot be used as valid resource names, and instead should be passed into
     /// [`from_resource`]:
     ///
-    /// [`from_resource`]: IconExtWindows::from_resource
+    /// [`from_resource`]: Self::from_resource
     ///
     /// ```rust,no_run
-    /// use winit::platform::windows::IconExtWindows;
-    /// use winit::window::Icon;
+    /// use winit::platform::windows::WinIcon;
     ///
-    /// assert!(Icon::from_resource_name("app", None).is_ok());
-    /// assert!(Icon::from_resource(1, None).is_ok());
-    /// assert!(Icon::from_resource(27, None).is_ok());
-    /// assert!(Icon::from_resource_name("27", None).is_err());
-    /// assert!(Icon::from_resource_name("0027", None).is_err());
+    /// assert!(WinIcon::from_resource_name("app", None).is_ok());
+    /// assert!(WinIcon::from_resource(1, None).is_ok());
+    /// assert!(WinIcon::from_resource(27, None).is_ok());
+    /// assert!(WinIcon::from_resource_name("27", None).is_err());
+    /// assert!(WinIcon::from_resource_name("0027", None).is_err());
     /// ```
     ///
     /// While `0` cannot be used as an ordinal id (see [`from_resource`]), it can be used as a
@@ -738,30 +732,21 @@ pub trait IconExtWindows: Sized {
     /// [`from_resource`]: IconExtWindows::from_resource
     ///
     /// ```rust,no_run
-    /// # use winit::platform::windows::IconExtWindows;
+    /// # use winit::platform::windows::WinIcon;
     /// # use winit::window::Icon;
-    /// assert!(Icon::from_resource_name("0", None).is_ok());
-    /// assert!(Icon::from_resource(0, None).is_err());
+    /// assert!(WinIcon::from_resource_name("0", None).is_ok());
+    /// assert!(WinIcon::from_resource(0, None).is_err());
     /// ```
-    fn from_resource_name(name: &str, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
-}
-
-impl IconExtWindows for Icon {
-    fn from_path<P: AsRef<Path>>(
-        path: P,
+    pub fn from_resource_name(
+        resource_name: &str,
         size: Option<PhysicalSize<u32>>,
     ) -> Result<Self, BadIcon> {
-        let win_icon = crate::platform_impl::WinIcon::from_path(path, size)?;
-        Ok(Icon { inner: win_icon })
-    }
-
-    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
-        let win_icon = crate::platform_impl::WinIcon::from_resource(ordinal, size)?;
-        Ok(Icon { inner: win_icon })
-    }
-
-    fn from_resource_name(name: &str, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
-        let win_icon = crate::platform_impl::WinIcon::from_resource_name(name, size)?;
-        Ok(Icon { inner: win_icon })
+        Self::from_resource_name_impl(resource_name, size)
+    }
+}
+
+impl From<WinIcon> for Icon {
+    fn from(value: WinIcon) -> Self {
+        Self(Arc::new(value))
     }
 }

src/platform/x11.rs

@@ -4,7 +4,6 @@ use serde::{Deserialize, Serialize};
 
 use crate::dpi::Size;
 use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
-use crate::monitor::MonitorHandle;
 use crate::window::{Window as CoreWindow, WindowAttributes};
 
 /// X window type. Maps directly to
@@ -80,7 +79,7 @@ pub type XWindow = u32;
 #[inline]
 pub fn register_xlib_error_hook(hook: XlibErrorHook) {
     // Append new hook.
-    crate::platform_impl::XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
+    crate::platform_impl::x11::XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
 }
 
 /// Additional methods on [`ActiveEventLoop`] that are specific to X11.
@@ -92,7 +91,7 @@ pub trait ActiveEventLoopExtX11 {
 impl ActiveEventLoopExtX11 for dyn ActiveEventLoop + '_ {
     #[inline]
     fn is_x11(&self) -> bool {
-        self.as_any().downcast_ref::<crate::platform_impl::x11::ActiveEventLoop>().is_some()
+        self.cast_ref::<crate::platform_impl::x11::ActiveEventLoop>().is_some()
     }
 }
 
@@ -240,16 +239,3 @@ impl WindowAttributesExtX11 for WindowAttributes {
         self
     }
 }
-
-/// Additional methods on `MonitorHandle` that are specific to X11.
-pub trait MonitorHandleExtX11 {
-    /// Returns the inner identifier of the monitor.
-    fn native_id(&self) -> u32;
-}
-
-impl MonitorHandleExtX11 for MonitorHandle {
-    #[inline]
-    fn native_id(&self) -> u32 {
-        self.inner.native_identifier()
-    }
-}

src/platform_impl/android/keycodes.rs

@@ -143,8 +143,8 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         Keycode::AltLeft => KeyCode::AltLeft,
         Keycode::AltRight => KeyCode::AltRight,
 
-        Keycode::MetaLeft => KeyCode::SuperLeft,
-        Keycode::MetaRight => KeyCode::SuperRight,
+        Keycode::MetaLeft => KeyCode::MetaLeft,
+        Keycode::MetaRight => KeyCode::MetaRight,
 
         Keycode::LeftBracket => KeyCode::BracketLeft,
         Keycode::RightBracket => KeyCode::BracketRight,
@@ -309,7 +309,7 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
             ShiftLeft => Key::Named(NamedKey::Shift),
             ShiftRight => Key::Named(NamedKey::Shift),
             Tab => Key::Named(NamedKey::Tab),
-            Space => Key::Named(NamedKey::Space),
+            Space => Key::Character(" ".into()),
             Sym => Key::Named(NamedKey::Symbol),
             Explorer => Key::Named(NamedKey::LaunchWebBrowser),
             Envelope => Key::Named(NamedKey::LaunchMail),
@@ -340,8 +340,8 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
             CtrlRight => Key::Named(NamedKey::Control),
             CapsLock => Key::Named(NamedKey::CapsLock),
             ScrollLock => Key::Named(NamedKey::ScrollLock),
-            MetaLeft => Key::Named(NamedKey::Super),
-            MetaRight => Key::Named(NamedKey::Super),
+            MetaLeft => Key::Named(NamedKey::Meta),
+            MetaRight => Key::Named(NamedKey::Meta),
             Function => Key::Named(NamedKey::Fn),
             Sysrq => Key::Named(NamedKey::PrintScreen),
             Break => Key::Named(NamedKey::Pause),

src/platform_impl/android/mod.rs

@@ -20,21 +20,15 @@ use crate::event_loop::{
     EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
     OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
-use crate::monitor::{MonitorHandle as RootMonitorHandle, VideoMode};
+use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
 use crate::platform::pump_events::PumpStatus;
 use crate::window::{
-    self, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, ImePurpose,
-    ResizeDirection, Theme, Window as CoreWindow, WindowAttributes, WindowButtons, WindowId,
-    WindowLevel,
+    self, CursorGrabMode, CustomCursor, CustomCursorSource, ImePurpose, ResizeDirection, Theme,
+    Window as CoreWindow, WindowAttributes, WindowButtons, WindowId, WindowLevel,
 };
 
 mod keycodes;
 
-pub(crate) use crate::cursor::{
-    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
-};
-pub(crate) use crate::icon::NoIcon as PlatformIcon;
-
 static HAS_FOCUS: AtomicBool = AtomicBool::new(true);
 
 /// Returns the minimum `Option<Duration>`, taking into account that `None`
@@ -44,7 +38,7 @@ 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))))
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 struct SharedFlagSetter {
     flag: Arc<AtomicBool>,
 }
@@ -54,6 +48,7 @@ impl SharedFlagSetter {
     }
 }
 
+#[derive(Debug)]
 struct SharedFlag {
     flag: Arc<AtomicBool>,
 }
@@ -82,6 +77,12 @@ pub struct RedrawRequester {
     waker: AndroidAppWaker,
 }
 
+impl fmt::Debug for RedrawRequester {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RedrawRequester").field("flag", &self.flag).finish_non_exhaustive()
+    }
+}
+
 impl RedrawRequester {
     fn new(flag: &SharedFlag, waker: AndroidAppWaker) -> Self {
         RedrawRequester { flag: flag.setter(), waker }
@@ -96,6 +97,7 @@ impl RedrawRequester {
     }
 }
 
+#[derive(Debug)]
 pub struct EventLoop {
     pub(crate) android_app: AndroidApp,
     window_target: ActiveEventLoop,
@@ -543,8 +545,6 @@ impl EventLoop {
         if self.exiting() {
             self.loop_running = false;
 
-            app.exiting(&self.window_target);
-
             PumpStatus::Exit(0)
         } else {
             PumpStatus::Continue
@@ -639,6 +639,12 @@ pub struct EventLoopProxy {
     waker: AndroidAppWaker,
 }
 
+impl fmt::Debug for EventLoopProxy {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventLoopProxy").field("wake_up", &self.wake_up).finish_non_exhaustive()
+    }
+}
+
 impl EventLoopProxy {
     fn new(waker: AndroidAppWaker) -> Self {
         Self { wake_up: AtomicBool::new(false), waker }
@@ -652,6 +658,7 @@ impl EventLoopProxyProvider for EventLoopProxy {
     }
 }
 
+#[derive(Debug)]
 pub struct ActiveEventLoop {
     pub(crate) app: AndroidApp,
     control_flow: Cell<ControlFlow>,
@@ -685,11 +692,11 @@ impl RootActiveEventLoop for ActiveEventLoop {
         Err(NotSupportedError::new("create_custom_cursor is not supported").into())
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         Box::new(std::iter::empty())
     }
 
-    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
         None
     }
 
@@ -744,6 +751,7 @@ impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub struct PlatformSpecificWindowAttributes;
 
+#[derive(Debug)]
 pub(crate) struct Window {
     app: AndroidApp,
     redraw_requester: RedrawRequester,
@@ -808,15 +816,15 @@ impl CoreWindow for Window {
         GLOBAL_WINDOW
     }
 
-    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
         None
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         Box::new(std::iter::empty())
     }
 
-    fn current_monitor(&self) -> Option<RootMonitorHandle> {
+    fn current_monitor(&self) -> Option<CoreMonitorHandle> {
         None
     }
 
@@ -1002,31 +1010,6 @@ impl Display for OsError {
     }
 }
 
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct MonitorHandle;
-
-impl MonitorHandle {
-    pub fn name(&self) -> Option<String> {
-        unreachable!()
-    }
-
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        unreachable!()
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        unreachable!()
-    }
-
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        unreachable!()
-    }
-
-    pub fn video_modes(&self) -> std::iter::Empty<VideoMode> {
-        unreachable!()
-    }
-}
-
 fn screen_size(app: &AndroidApp) -> PhysicalSize<u32> {
     if let Some(native_window) = app.native_window() {
         PhysicalSize::new(native_window.width() as _, native_window.height() as _)

src/platform_impl/apple/appkit/app_state.rs

@@ -11,7 +11,7 @@ use objc2_foundation::NSNotification;
 
 use super::super::event_handler::EventHandler;
 use super::super::event_loop_proxy::EventLoopProxy;
-use super::event_loop::{stop_app_immediately, ActiveEventLoop, PanicInfo};
+use super::event_loop::{notify_windows_of_exit, stop_app_immediately, ActiveEventLoop, PanicInfo};
 use super::menu;
 use super::observer::{EventLoopWaker, RunLoop};
 use crate::application::ApplicationHandler;
@@ -156,7 +156,9 @@ impl AppState {
 
     pub fn will_terminate(self: &Rc<Self>, _notification: &NSNotification) {
         trace_scope!("NSApplicationWillTerminateNotification");
-        // TODO: Notify every window that it will be destroyed, like done in iOS?
+        let app = NSApplication::sharedApplication(self.mtm);
+        notify_windows_of_exit(&app);
+        self.event_handler.terminate();
         self.internal_exit();
     }
 
@@ -164,10 +166,10 @@ impl AppState {
     /// of the given closure.
     pub fn set_event_handler<R>(
         &self,
-        handler: &mut dyn ApplicationHandler,
+        handler: impl ApplicationHandler,
         closure: impl FnOnce() -> R,
     ) -> R {
-        self.event_handler.set(handler, closure)
+        self.event_handler.set(Box::new(handler), closure)
     }
 
     pub fn event_loop_proxy(&self) -> &Arc<EventLoopProxy> {
@@ -202,10 +204,6 @@ impl AppState {
     /// 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: &Rc<Self>) {
-        self.with_handler(|app, event_loop| {
-            app.exiting(event_loop);
-        });
-
         self.set_is_running(false);
         self.set_stop_on_redraw(false);
         self.set_stop_before_wait(false);
@@ -368,6 +366,7 @@ impl AppState {
         if self.exiting() {
             let app = NSApplication::sharedApplication(self.mtm);
             stop_app_immediately(&app);
+            notify_windows_of_exit(&app);
         }
 
         if self.stop_before_wait.get() {

src/platform_impl/apple/appkit/cursor.rs

@@ -10,21 +10,34 @@ use objc2_foundation::{
     ns_string, NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString,
 };
 
-use crate::cursor::{CursorImage, OnlyCursorImageSource};
-use crate::error::RequestError;
+use crate::cursor::{CursorImage, CustomCursorProvider, CustomCursorSource};
+use crate::error::{NotSupportedError, RequestError};
 use crate::window::CursorIcon;
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct CustomCursor(pub(crate) Retained<NSCursor>);
 
+impl CustomCursorProvider for CustomCursor {
+    fn is_animated(&self) -> bool {
+        false
+    }
+}
+
 // SAFETY: NSCursor is immutable and thread-safe
 // TODO(madsmtm): Put this logic in objc2-app-kit itself
 unsafe impl Send for CustomCursor {}
 unsafe impl Sync for CustomCursor {}
 
 impl CustomCursor {
-    pub(crate) fn new(cursor: OnlyCursorImageSource) -> Result<CustomCursor, RequestError> {
-        cursor_from_image(&cursor.0).map(Self)
+    pub(crate) fn new(cursor: CustomCursorSource) -> Result<CustomCursor, RequestError> {
+        let cursor = match cursor {
+            CustomCursorSource::Image(cursor_image) => cursor_image,
+            CustomCursorSource::Animation { .. } | CustomCursorSource::Url { .. } => {
+                return Err(NotSupportedError::new("unsupported cursor kind").into())
+            },
+        };
+
+        cursor_from_image(&cursor).map(Self)
     }
 }
 

src/platform_impl/apple/appkit/event.rs

@@ -3,7 +3,7 @@ use std::ptr::NonNull;
 use dispatch2::run_on_main;
 use objc2::rc::Retained;
 use objc2_app_kit::{NSEvent, NSEventModifierFlags, NSEventSubtype, NSEventType};
-use objc2_core_foundation::{CFData, CFDataGetBytePtr, CFRetained};
+use objc2_core_foundation::{CFData, CFRetained};
 use objc2_foundation::NSPoint;
 use smol_str::SmolStr;
 
@@ -30,7 +30,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
         return Key::Unidentified(NativeKey::MacOS(scancode));
     };
 
-    let layout = unsafe { CFDataGetBytePtr(layout_data).cast() };
+    let layout = layout_data.byte_ptr().cast();
     let keyboard_type = run_on_main(|_mtm| unsafe { ffi::LMGetKbdType() });
 
     let mut result_len = 0;
@@ -168,11 +168,11 @@ pub fn code_to_key(key: PhysicalKey, scancode: u16) -> Key {
     Key::Named(match code {
         KeyCode::Enter => NamedKey::Enter,
         KeyCode::Tab => NamedKey::Tab,
-        KeyCode::Space => NamedKey::Space,
+        KeyCode::Space => return Key::Character(" ".into()),
         KeyCode::Backspace => NamedKey::Backspace,
         KeyCode::Escape => NamedKey::Escape,
-        KeyCode::SuperRight => NamedKey::Super,
-        KeyCode::SuperLeft => NamedKey::Super,
+        KeyCode::MetaRight => NamedKey::Meta,
+        KeyCode::MetaLeft => NamedKey::Meta,
         KeyCode::ShiftLeft => NamedKey::Shift,
         KeyCode::AltLeft => NamedKey::Alt,
         KeyCode::ControlLeft => NamedKey::Control,
@@ -242,8 +242,8 @@ pub fn code_to_location(key: PhysicalKey) -> KeyLocation {
     };
 
     match code {
-        KeyCode::SuperRight => KeyLocation::Right,
-        KeyCode::SuperLeft => KeyLocation::Left,
+        KeyCode::MetaRight => KeyLocation::Right,
+        KeyCode::MetaLeft => KeyLocation::Left,
         KeyCode::ShiftLeft => KeyLocation::Left,
         KeyCode::AltLeft => KeyLocation::Left,
         KeyCode::ControlLeft => KeyLocation::Left,
@@ -326,9 +326,9 @@ pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
     pressed_mods.set(ModifiersKeys::LALT, flags.contains(NX_DEVICELALTKEYMASK));
     pressed_mods.set(ModifiersKeys::RALT, flags.contains(NX_DEVICERALTKEYMASK));
 
-    state.set(ModifiersState::SUPER, flags.contains(NSEventModifierFlags::Command));
-    pressed_mods.set(ModifiersKeys::LSUPER, flags.contains(NX_DEVICELCMDKEYMASK));
-    pressed_mods.set(ModifiersKeys::RSUPER, flags.contains(NX_DEVICERCMDKEYMASK));
+    state.set(ModifiersState::META, flags.contains(NSEventModifierFlags::Command));
+    pressed_mods.set(ModifiersKeys::LMETA, flags.contains(NX_DEVICELCMDKEYMASK));
+    pressed_mods.set(ModifiersKeys::RMETA, flags.contains(NX_DEVICERCMDKEYMASK));
 
     Modifiers { state, pressed_mods }
 }
@@ -409,8 +409,8 @@ pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32>
         KeyCode::Backquote => Some(0x32),
         KeyCode::Backspace => Some(0x33),
         KeyCode::Escape => Some(0x35),
-        KeyCode::SuperRight => Some(0x36),
-        KeyCode::SuperLeft => Some(0x37),
+        KeyCode::MetaRight => Some(0x36),
+        KeyCode::MetaLeft => Some(0x37),
         KeyCode::ShiftLeft => Some(0x38),
         KeyCode::CapsLock => Some(0x39),
         KeyCode::AltLeft => Some(0x3a),
@@ -555,8 +555,8 @@ pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         0x33 => KeyCode::Backspace,
         // 0x34 => unknown, // kVK_Powerbook_KeypadEnter
         0x35 => KeyCode::Escape,
-        0x36 => KeyCode::SuperRight,
-        0x37 => KeyCode::SuperLeft,
+        0x36 => KeyCode::MetaRight,
+        0x37 => KeyCode::MetaLeft,
         0x38 => KeyCode::ShiftLeft,
         0x39 => KeyCode::CapsLock,
         0x3a => KeyCode::AltLeft,

src/platform_impl/apple/appkit/event_loop.rs

@@ -1,5 +1,6 @@
 use std::any::Any;
 use std::cell::Cell;
+use std::fmt;
 use std::panic::{catch_unwind, resume_unwind, RefUnwindSafe, UnwindSafe};
 use std::rc::{Rc, Weak};
 use std::sync::Arc;
@@ -28,17 +29,23 @@ use crate::event_loop::{
     ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
     EventLoopProxy as CoreEventLoopProxy, OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
-use crate::monitor::MonitorHandle as RootMonitorHandle;
+use crate::monitor::MonitorHandle as CoreMonitorHandle;
 use crate::platform::macos::ActivationPolicy;
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::Window;
-use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme};
+use crate::window::{CustomCursor as CoreCustomCursor, CustomCursorSource, Theme};
 
 #[derive(Default)]
 pub struct PanicInfo {
     inner: Cell<Option<Box<dyn Any + Send + 'static>>>,
 }
 
+impl fmt::Debug for PanicInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PanicInfo").finish_non_exhaustive()
+    }
+}
+
 // WARNING:
 // As long as this struct is used through its `impl`, it is UnwindSafe.
 // (If `get_mut` is called on `inner`, unwind safety may get broken.)
@@ -103,17 +110,21 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_custom_cursor(
         &self,
         source: CustomCursorSource,
-    ) -> Result<RootCustomCursor, RequestError> {
-        Ok(RootCustomCursor { inner: CustomCursor::new(source.inner)? })
+    ) -> Result<CoreCustomCursor, RequestError> {
+        Ok(CoreCustomCursor(Arc::new(CustomCursor::new(source)?)))
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
-        Box::new(monitor::available_monitors().into_iter().map(|inner| RootMonitorHandle { inner }))
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
+        Box::new(
+            monitor::available_monitors()
+                .into_iter()
+                .map(|monitor| CoreMonitorHandle(Arc::new(monitor))),
+        )
     }
 
     fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
         let monitor = monitor::primary_monitor();
-        Some(RootMonitorHandle { inner: monitor })
+        Some(CoreMonitorHandle(Arc::new(monitor)))
     }
 
     fn listen_device_events(&self, _allowed: DeviceEvents) {}
@@ -161,6 +172,7 @@ impl rwh_06::HasDisplayHandle for ActiveEventLoop {
     }
 }
 
+#[derive(Debug)]
 pub struct EventLoop {
     /// Store a reference to the application for convenience.
     ///
@@ -273,10 +285,10 @@ impl EventLoop {
     // redundant wake ups.
     pub fn run_app_on_demand<A: ApplicationHandler>(
         &mut self,
-        mut app: A,
+        app: A,
     ) -> Result<(), EventLoopError> {
         self.app_state.clear_exit();
-        self.app_state.set_event_handler(&mut app, || {
+        self.app_state.set_event_handler(app, || {
             autoreleasepool(|_| {
                 // clear / normalize pump_events state
                 self.app_state.set_wait_timeout(None);
@@ -312,9 +324,9 @@ impl EventLoop {
     pub fn pump_app_events<A: ApplicationHandler>(
         &mut self,
         timeout: Option<Duration>,
-        mut app: A,
+        app: A,
     ) -> PumpStatus {
-        self.app_state.set_event_handler(&mut app, || {
+        self.app_state.set_event_handler(app, || {
             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.
@@ -395,6 +407,22 @@ pub(super) fn stop_app_immediately(app: &NSApplication) {
     });
 }
 
+/// Tell all windows to close.
+///
+/// This will synchronously trigger `WindowEvent::Destroyed` within
+/// `windowWillClose:`, giving the application one last chance to handle
+/// those events. It doesn't matter if the user also ends up closing the
+/// windows in `Window`'s `Drop` impl, once a window has been closed once, it
+/// stays closed.
+///
+/// This ensures that no windows linger on after the event loop has exited,
+/// see <https://github.com/rust-windowing/winit/issues/4135>.
+pub(super) fn notify_windows_of_exit(app: &NSApplication) {
+    for window in app.windows() {
+        window.close();
+    }
+}
+
 /// Catches panics that happen inside `f` and when a panic
 /// happens, stops the `sharedApplication`
 #[inline]

src/platform_impl/apple/appkit/ffi.rs

@@ -1,6 +1,6 @@
 // TODO: Upstream these
 
-#![allow(dead_code, non_snake_case, non_upper_case_globals)]
+#![allow(non_upper_case_globals)]
 
 use std::ffi::c_void;
 
@@ -9,27 +9,10 @@ use objc2::runtime::AnyObject;
 use objc2_core_foundation::{cf_type, CFString, CFUUID};
 use objc2_core_graphics::CGDirectDisplayID;
 
-pub const kCGDisplayBlendNormal: f32 = 0.0;
-pub const kCGDisplayBlendSolidColor: f32 = 1.0;
-
-pub type CGDisplayFadeReservationToken = u32;
-pub const kCGDisplayFadeReservationInvalidToken: CGDisplayFadeReservationToken = 0;
-
-pub const IO1BitIndexedPixels: &str = "P";
-pub const IO2BitIndexedPixels: &str = "PP";
-pub const IO4BitIndexedPixels: &str = "PPPP";
-pub const IO8BitIndexedPixels: &str = "PPPPPPPP";
 pub const IO16BitDirectPixels: &str = "-RRRRRGGGGGBBBBB";
 pub const IO32BitDirectPixels: &str = "--------RRRRRRRRGGGGGGGGBBBBBBBB";
 
 pub const kIO30BitDirectPixels: &str = "--RRRRRRRRRRGGGGGGGGGGBBBBBBBBBB";
-pub const kIO64BitDirectPixels: &str = "-16R16G16B16";
-
-pub const kIO16BitFloatPixels: &str = "-16FR16FG16FB16";
-pub const kIO32BitFloatPixels: &str = "-32FR32FG32FB32";
-
-pub const IOYUV422Pixels: &str = "Y4U2V2";
-pub const IO8BitOverlayPixels: &str = "O8";
 
 // `CGDisplayCreateUUIDFromDisplayID` comes from the `ColorSync` framework.
 // However, that framework was only introduced "publicly" in macOS 10.13.
@@ -41,6 +24,8 @@ pub const IO8BitOverlayPixels: &str = "O8";
 #[link(name = "ApplicationServices", kind = "framework")]
 extern "C" {
     pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> *mut CFUUID;
+
+    pub fn CGDisplayGetDisplayIDFromUUID(uuid: &CFUUID) -> CGDirectDisplayID;
 }
 
 #[link(name = "CoreGraphics", kind = "framework")]
@@ -58,7 +43,6 @@ extern "C" {
 pub struct TISInputSource(std::ffi::c_void);
 
 cf_type!(
-    #[encoding_name = "__TISInputSource"]
     unsafe impl TISInputSource {}
 );
 
@@ -103,45 +87,3 @@ extern "C" {
         unicodeString: *mut UniChar,
     ) -> OSStatus;
 }
-
-// CGWindowLevel.h
-//
-// Note: There are two different things at play in this header:
-// `CGWindowLevel` and `CGWindowLevelKey`.
-//
-// It seems like there was a push towards using "key" values instead of the
-// raw window level values, and then you were supposed to use
-// `CGWindowLevelForKey` to get the actual level.
-//
-// But the values that `NSWindowLevel` has are compiled in, and as such has
-// to remain ABI compatible, so they're safe for us to hardcode as well.
-#[allow(dead_code, non_upper_case_globals)]
-mod window_level {
-    const kCGNumReservedWindowLevels: i32 = 16;
-    const kCGNumReservedBaseWindowLevels: i32 = 5;
-
-    pub const kCGBaseWindowLevel: i32 = i32::MIN;
-    pub const kCGMinimumWindowLevel: i32 = kCGBaseWindowLevel + kCGNumReservedBaseWindowLevels;
-    pub const kCGMaximumWindowLevel: i32 = i32::MAX - kCGNumReservedWindowLevels;
-
-    pub const kCGDesktopWindowLevel: i32 = kCGMinimumWindowLevel + 20;
-    pub const kCGDesktopIconWindowLevel: i32 = kCGDesktopWindowLevel + 20;
-    pub const kCGBackstopMenuLevel: i32 = -20;
-    pub const kCGNormalWindowLevel: i32 = 0;
-    pub const kCGFloatingWindowLevel: i32 = 3;
-    pub const kCGTornOffMenuWindowLevel: i32 = 3;
-    pub const kCGModalPanelWindowLevel: i32 = 8;
-    pub const kCGUtilityWindowLevel: i32 = 19;
-    pub const kCGDockWindowLevel: i32 = 20;
-    pub const kCGMainMenuWindowLevel: i32 = 24;
-    pub const kCGStatusWindowLevel: i32 = 25;
-    pub const kCGPopUpMenuWindowLevel: i32 = 101;
-    pub const kCGOverlayWindowLevel: i32 = 102;
-    pub const kCGHelpWindowLevel: i32 = 200;
-    pub const kCGDraggingWindowLevel: i32 = 500;
-    pub const kCGScreenSaverWindowLevel: i32 = 1000;
-    pub const kCGAssistiveTechHighWindowLevel: i32 = 1500;
-    pub const kCGCursorWindowLevel: i32 = kCGMaximumWindowLevel - 1;
-}
-
-pub use window_level::*;

src/platform_impl/apple/appkit/mod.rs

@@ -14,7 +14,6 @@ mod view;
 mod window;
 mod window_delegate;
 
-pub(crate) use self::cursor::CustomCursor as PlatformCustomCursor;
 pub(crate) use self::event::{physicalkey_to_scancode, scancode_to_physicalkey};
 pub(crate) use self::event_loop::{
     ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
@@ -22,6 +21,3 @@ pub(crate) use self::event_loop::{
 pub(crate) use self::monitor::MonitorHandle;
 pub(crate) use self::window::Window;
 pub(crate) use self::window_delegate::PlatformSpecificWindowAttributes;
-pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
-pub(crate) use crate::icon::NoIcon as PlatformIcon;
-pub(crate) use crate::platform_impl::Fullscreen;

src/platform_impl/apple/appkit/monitor.rs

@@ -9,27 +9,19 @@ use dispatch2::run_on_main;
 use objc2::rc::Retained;
 use objc2::MainThreadMarker;
 use objc2_app_kit::NSScreen;
-use objc2_core_foundation::{
-    CFArrayGetCount, CFArrayGetValueAtIndex, CFRetained, CFUUIDGetUUIDBytes,
-};
-#[allow(deprecated)]
+use objc2_core_foundation::{CFArray, CFRetained, CFUUID};
 use objc2_core_graphics::{
     CGDirectDisplayID, CGDisplayBounds, CGDisplayCopyAllDisplayModes, CGDisplayCopyDisplayMode,
-    CGDisplayMode, CGDisplayModeCopyPixelEncoding, CGDisplayModeGetPixelHeight,
-    CGDisplayModeGetPixelWidth, CGDisplayModeGetRefreshRate, CGDisplayModelNumber,
-    CGGetActiveDisplayList, CGMainDisplayID,
-};
-#[allow(deprecated)]
-use objc2_core_video::{
-    kCVReturnSuccess, CVDisplayLinkCreateWithCGDisplay,
-    CVDisplayLinkGetNominalOutputVideoRefreshPeriod, CVTimeFlags,
+    CGDisplayMode, CGDisplayModelNumber, CGGetActiveDisplayList, CGMainDisplayID,
 };
+use objc2_core_video::{kCVReturnSuccess, CVDisplayLink, CVTimeFlags};
 use objc2_foundation::{ns_string, NSNumber, NSPoint, NSRect};
+use tracing::warn;
 
 use super::ffi;
 use super::util::cgerr;
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use crate::monitor::VideoMode;
+use crate::monitor::{MonitorHandleProvider, VideoMode};
 
 #[derive(Clone)]
 pub struct VideoModeHandle {
@@ -54,7 +46,7 @@ impl std::hash::Hash for VideoModeHandle {
 
 impl std::fmt::Debug for VideoModeHandle {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("VideoMode")
+        f.debug_struct("VideoModeHandle")
             .field("mode", &self.mode)
             .field("monitor", &self.monitor)
             .finish()
@@ -76,7 +68,7 @@ impl VideoModeHandle {
         unsafe {
             #[allow(deprecated)]
             let pixel_encoding =
-                CGDisplayModeCopyPixelEncoding(Some(&native_mode.0)).unwrap().to_string();
+                CGDisplayMode::pixel_encoding(Some(&native_mode.0)).unwrap().to_string();
             let bit_depth = if pixel_encoding.eq_ignore_ascii_case(ffi::IO32BitDirectPixels) {
                 32
             } else if pixel_encoding.eq_ignore_ascii_case(ffi::IO16BitDirectPixels) {
@@ -89,8 +81,8 @@ impl VideoModeHandle {
 
             let mode = VideoMode {
                 size: PhysicalSize::new(
-                    CGDisplayModeGetPixelWidth(Some(&native_mode.0)) as u32,
-                    CGDisplayModeGetPixelHeight(Some(&native_mode.0)) as u32,
+                    CGDisplayMode::pixel_width(Some(&native_mode.0)) as u32,
+                    CGDisplayMode::pixel_height(Some(&native_mode.0)) as u32,
                 ),
                 refresh_rate_millihertz,
                 bit_depth: NonZeroU16::new(bit_depth),
@@ -101,44 +93,142 @@ impl VideoModeHandle {
     }
 }
 
-#[derive(Clone)]
-pub struct MonitorHandle(CGDirectDisplayID);
+/// `CGDirectDisplayID` is documented as:
+/// > a framebuffer, a color correction (gamma) table, and possibly an attached monitor.
+///
+/// That is, it doesn't actually represent the monitor itself. Instead, we use the UUID of the
+/// monitor, as retrieved from `CGDisplayCreateUUIDFromDisplayID` (this makes the monitor ID stable,
+/// even across reboots and video mode changes).
+///
+/// NOTE: I'd be perfectly valid to store `[u8; 16]` in here instead, we only store `CFUUID` to
+/// avoid having to re-create it when we want to fetch the display ID.
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct MonitorHandle(CFRetained<CFUUID>);
 
 impl MonitorHandle {
     /// Internal comparisons of [`MonitorHandle`]s are done first requesting a UUID for the handle.
-    fn uuid(&self) -> [u8; 16] {
-        let ptr = unsafe { ffi::CGDisplayCreateUUIDFromDisplayID(self.0) };
-        let cf_uuid = unsafe { CFRetained::from_raw(NonNull::new(ptr).unwrap()) };
-        unsafe { CFUUIDGetUUIDBytes(&cf_uuid) }.into()
+    fn uuid(&self) -> u128 {
+        u128::from_ne_bytes(self.0.uuid_bytes().into())
+    }
+
+    fn display_id(&self) -> CGDirectDisplayID {
+        unsafe { ffi::CGDisplayGetDisplayIDFromUUID(&self.0) }
+    }
+
+    #[track_caller]
+    pub(crate) fn new(display_id: CGDirectDisplayID) -> Option<Self> {
+        // kCGNullDirectDisplay
+        if display_id == 0 {
+            // `CGDisplayCreateUUIDFromDisplayID` checks kCGNullDirectDisplay internally.
+            warn!("constructing monitor from invalid display ID 0; falling back to main monitor");
+        }
+        // SAFETY: Valid to call.
+        let ptr = unsafe { ffi::CGDisplayCreateUUIDFromDisplayID(display_id) };
+        let ptr = NonNull::new(ptr)?;
+        // SAFETY: `CGDisplayCreateUUIDFromDisplayID` is a "create" function, so the pointer has
+        // +1 retain count.
+        let uuid = unsafe { CFRetained::from_raw(ptr) };
+        Some(Self(uuid))
+    }
+
+    fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
+        let current_display_mode =
+            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.display_id()) }.unwrap());
+        refresh_rate_millihertz(self.display_id(), &current_display_mode)
+    }
+
+    pub fn video_mode_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
+        let refresh_rate_millihertz = self.refresh_rate_millihertz();
+        let monitor = self.clone();
+
+        let array = unsafe { CGDisplayCopyAllDisplayModes(self.display_id(), None) };
+        let modes = if let Some(array) = array {
+            // SAFETY: `CGDisplayCopyAllDisplayModes` is documented to return an array of
+            // display modes.
+            unsafe { CFRetained::cast_unchecked::<CFArray<CGDisplayMode>>(array) }
+        } else {
+            // Occasionally, certain CalDigit Thunderbolt Hubs report a spurious monitor during
+            // sleep/wake/cycling monitors. It tends to have null or 1 video mode only.
+            // See <https://github.com/bevyengine/bevy/issues/17827>.
+            warn!(monitor = ?self, "failed to get a list of display modes");
+            CFArray::empty()
+        };
+
+        modes.into_iter().map(move |mode| {
+            let cg_refresh_rate_hertz = unsafe { CGDisplayMode::refresh_rate(Some(&mode)) };
+
+            // CGDisplayModeGetRefreshRate returns 0.0 for any display that
+            // isn't a CRT
+            let refresh_rate_millihertz = if cg_refresh_rate_hertz > 0.0 {
+                NonZeroU32::new((cg_refresh_rate_hertz * 1000.0).round() as u32)
+            } else {
+                refresh_rate_millihertz
+            };
+
+            VideoModeHandle::new(monitor.clone(), NativeDisplayMode(mode), refresh_rate_millihertz)
+        })
+    }
+
+    pub(crate) fn ns_screen(&self, mtm: MainThreadMarker) -> Option<Retained<NSScreen>> {
+        let uuid = self.uuid();
+        NSScreen::screens(mtm).into_iter().find(|screen| {
+            let other_native_id = get_display_id(screen);
+            if let Some(other) = MonitorHandle::new(other_native_id) {
+                uuid == other.uuid()
+            } else {
+                // Display ID was just fetched from live NSScreen, but can still result in `None`
+                // with certain Thunderbolt docked monitors.
+                warn!(other_native_id, "comparing against screen with invalid display ID");
+                false
+            }
+        })
     }
 }
 
-// `CGDirectDisplayID` changes on video mode change, so we cannot rely on that
-// for comparisons, but we can use `CGDisplayCreateUUIDFromDisplayID` to get an
-// unique identifier that persists even across system reboots
-impl PartialEq for MonitorHandle {
-    fn eq(&self, other: &Self) -> bool {
-        self.uuid() == other.uuid()
+impl MonitorHandleProvider for MonitorHandle {
+    fn id(&self) -> u128 {
+        self.uuid()
     }
-}
 
-impl Eq for MonitorHandle {}
-
-impl PartialOrd for MonitorHandle {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
+    fn native_id(&self) -> u64 {
+        self.display_id() as _
     }
-}
 
-impl Ord for MonitorHandle {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.uuid().cmp(&other.uuid())
+    // TODO: Be smarter about this:
+    //
+    // <https://github.com/glfw/glfw/blob/57cbded0760a50b9039ee0cb3f3c14f60145567c/src/cocoa_monitor.m#L44-L126>
+    fn name(&self) -> Option<std::borrow::Cow<'_, str>> {
+        let screen_num = unsafe { CGDisplayModelNumber(self.display_id()) };
+        Some(format!("Monitor #{screen_num}").into())
     }
-}
 
-impl std::hash::Hash for MonitorHandle {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.uuid().hash(state);
+    fn position(&self) -> Option<PhysicalPosition<i32>> {
+        // This is already in screen coordinates. If we were using `NSScreen`,
+        // then a conversion would've been needed:
+        // flip_window_screen_coordinates(self.ns_screen(mtm)?.frame())
+        let bounds = unsafe { CGDisplayBounds(self.display_id()) };
+        let position = LogicalPosition::new(bounds.origin.x, bounds.origin.y);
+        Some(position.to_physical(self.scale_factor()))
+    }
+
+    fn scale_factor(&self) -> f64 {
+        run_on_main(|mtm| {
+            match self.ns_screen(mtm) {
+                Some(screen) => screen.backingScaleFactor() as f64,
+                None => 1.0, // default to 1.0 when we can't find the screen
+            }
+        })
+    }
+
+    fn current_video_mode(&self) -> Option<VideoMode> {
+        let mode =
+            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.display_id()) }.unwrap());
+        let refresh_rate_millihertz = refresh_rate_millihertz(self.display_id(), &mode);
+        Some(VideoModeHandle::new(self.clone(), mode, refresh_rate_millihertz).mode)
+    }
+
+    fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
+        Box::new(self.video_mode_handles().map(|mode| mode.mode))
     }
 }
 
@@ -162,126 +252,29 @@ pub fn available_monitors() -> VecDeque<MonitorHandle> {
 
     let mut monitors = VecDeque::with_capacity(displays.len());
     for display in displays {
-        monitors.push_back(MonitorHandle(display));
+        // Display ID just fetched from `CGGetActiveDisplayList`, should be fine to unwrap.
+        monitors.push_back(MonitorHandle::new(display).expect("invalid display ID"));
     }
     monitors
 }
 
 pub fn primary_monitor() -> MonitorHandle {
-    MonitorHandle(unsafe { CGMainDisplayID() })
+    // Display ID just fetched from `CGMainDisplayID`, should be fine to unwrap.
+    MonitorHandle::new(unsafe { CGMainDisplayID() }).expect("invalid display ID")
 }
 
 impl fmt::Debug for MonitorHandle {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("MonitorHandle")
             .field("name", &self.name())
-            .field("native_identifier", &self.native_identifier())
+            .field("uuid", &self.uuid())
+            .field("display_id", &self.display_id())
             .field("position", &self.position())
             .field("scale_factor", &self.scale_factor())
             .finish_non_exhaustive()
     }
 }
 
-impl MonitorHandle {
-    pub fn new(id: CGDirectDisplayID) -> Self {
-        MonitorHandle(id)
-    }
-
-    // TODO: Be smarter about this:
-    // <https://github.com/glfw/glfw/blob/57cbded0760a50b9039ee0cb3f3c14f60145567c/src/cocoa_monitor.m#L44-L126>
-    pub fn name(&self) -> Option<String> {
-        let screen_num = unsafe { CGDisplayModelNumber(self.0) };
-        Some(format!("Monitor #{screen_num}"))
-    }
-
-    #[inline]
-    pub fn native_identifier(&self) -> u32 {
-        self.0
-    }
-
-    #[inline]
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        // This is already in screen coordinates. If we were using `NSScreen`,
-        // then a conversion would've been needed:
-        // flip_window_screen_coordinates(self.ns_screen(mtm)?.frame())
-        let bounds = unsafe { CGDisplayBounds(self.0) };
-        let position = LogicalPosition::new(bounds.origin.x, bounds.origin.y);
-        Some(position.to_physical(self.scale_factor()))
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        run_on_main(|mtm| {
-            match self.ns_screen(mtm) {
-                Some(screen) => screen.backingScaleFactor() as f64,
-                None => 1.0, // default to 1.0 when we can't find the screen
-            }
-        })
-    }
-
-    fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
-        let current_display_mode =
-            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.0) }.unwrap());
-        refresh_rate_millihertz(self.0, &current_display_mode)
-    }
-
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        let mode = NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.0) }.unwrap());
-        let refresh_rate_millihertz = refresh_rate_millihertz(self.0, &mode);
-        Some(VideoModeHandle::new(self.clone(), mode, refresh_rate_millihertz).mode)
-    }
-
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        self.video_modes_handles().map(|handle| handle.mode)
-    }
-
-    pub(crate) fn video_modes_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
-        let refresh_rate_millihertz = self.refresh_rate_millihertz();
-        let monitor = self.clone();
-
-        unsafe {
-            let modes = {
-                let array = CGDisplayCopyAllDisplayModes(self.0, None)
-                    .expect("failed to get list of display modes");
-                let array_count = CFArrayGetCount(&array);
-                let modes: Vec<_> = (0..array_count)
-                    .map(move |i| {
-                        let mode = CFArrayGetValueAtIndex(&array, i) as *mut CGDisplayMode;
-                        CFRetained::retain(NonNull::new(mode).unwrap())
-                    })
-                    .collect();
-                modes
-            };
-
-            modes.into_iter().map(move |mode| {
-                let cg_refresh_rate_hertz = CGDisplayModeGetRefreshRate(Some(&mode)).round() as i64;
-
-                // CGDisplayModeGetRefreshRate returns 0.0 for any display that
-                // isn't a CRT
-                let refresh_rate_millihertz = if cg_refresh_rate_hertz > 0 {
-                    NonZeroU32::new((cg_refresh_rate_hertz * 1000) as u32)
-                } else {
-                    refresh_rate_millihertz
-                };
-
-                VideoModeHandle::new(
-                    monitor.clone(),
-                    NativeDisplayMode(mode),
-                    refresh_rate_millihertz,
-                )
-            })
-        }
-    }
-
-    pub(crate) fn ns_screen(&self, mtm: MainThreadMarker) -> Option<Retained<NSScreen>> {
-        let uuid = self.uuid();
-        NSScreen::screens(mtm).into_iter().find(|screen| {
-            let other_native_id = get_display_id(screen);
-            let other = MonitorHandle::new(other_native_id);
-            uuid == other.uuid()
-        })
-    }
-}
-
 pub(crate) fn get_display_id(screen: &NSScreen) -> u32 {
     let key = ns_string!("NSScreenNumber");
 
@@ -326,21 +319,21 @@ pub(crate) fn flip_window_screen_coordinates(frame: NSRect) -> NSPoint {
 
 fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> Option<NonZeroU32> {
     unsafe {
-        let refresh_rate = CGDisplayModeGetRefreshRate(Some(&mode.0));
+        let refresh_rate = CGDisplayMode::refresh_rate(Some(&mode.0));
         if refresh_rate > 0.0 {
             return NonZeroU32::new((refresh_rate * 1000.0).round() as u32);
         }
 
         let mut display_link = std::ptr::null_mut();
         #[allow(deprecated)]
-        if CVDisplayLinkCreateWithCGDisplay(id, NonNull::from(&mut display_link))
+        if CVDisplayLink::create_with_cg_display(id, NonNull::from(&mut display_link))
             != kCVReturnSuccess
         {
             return None;
         }
         let display_link = CFRetained::from_raw(NonNull::new(display_link).unwrap());
         #[allow(deprecated)]
-        let time = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(&display_link);
+        let time = display_link.nominal_output_video_refresh_period();
 
         // This value is indefinite if an invalid display link was specified
         if time.flags & CVTimeFlags::IsIndefinite.0 != 0 {
@@ -353,3 +346,54 @@ fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> O
             .and_then(NonZeroU32::new)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn uuid_stable() {
+        let handle_a = MonitorHandle::new(1).unwrap();
+        let handle_b = MonitorHandle::new(1).unwrap();
+        assert_eq!(handle_a, handle_b);
+        assert_eq!(handle_a.display_id(), handle_b.display_id());
+        assert_eq!(handle_a.uuid(), handle_b.uuid());
+
+        let handle_a = primary_monitor();
+        let handle_b = primary_monitor();
+        assert_eq!(handle_a, handle_b);
+        assert_eq!(handle_a.display_id(), handle_b.display_id());
+        assert_eq!(handle_a.uuid(), handle_b.uuid());
+    }
+
+    /// Test the MonitorHandle::new fallback.
+    #[test]
+    fn monitorhandle_from_zero() {
+        let handle0 = MonitorHandle::new(0).unwrap();
+        let handle1 = MonitorHandle::new(1).unwrap();
+        assert_eq!(handle0, handle1);
+        assert_eq!(handle0.display_id(), handle1.display_id());
+        assert_eq!(handle0.uuid(), handle1.uuid());
+    }
+
+    #[test]
+    fn from_invalid_id() {
+        // Assume there are never this many monitors connected.
+        assert!(MonitorHandle::new(10000).is_none());
+    }
+
+    /// Test that calling `CGDisplayGetDisplayIDFromUUID` on an invalid UUID returns an invalid
+    /// display ID.
+    #[test]
+    fn invalid_monitor_handle() {
+        // `CGMainDisplayID` must be called to avoid:
+        // ```
+        // Assertion failed: (did_initialize), function CGS_REQUIRE_INIT, file CGInitialization.c, line 44.
+        // ```
+        // See https://github.com/JXA-Cookbook/JXA-Cookbook/issues/27#issuecomment-277517668
+        let _ = unsafe { CGMainDisplayID() };
+
+        let handle = MonitorHandle(CFUUID::new(None).unwrap());
+        assert_eq!(handle.display_id(), 0);
+    }
+}

src/platform_impl/apple/appkit/observer.rs

@@ -12,10 +12,8 @@ use std::time::Instant;
 use objc2::MainThreadMarker;
 use objc2_core_foundation::{
     kCFRunLoopCommonModes, kCFRunLoopDefaultMode, CFAbsoluteTimeGetCurrent, CFIndex, CFRetained,
-    CFRunLoop, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddTimer, CFRunLoopGetMain,
-    CFRunLoopObserver, CFRunLoopObserverCallBack, CFRunLoopObserverContext,
-    CFRunLoopObserverCreate, CFRunLoopPerformBlock, CFRunLoopTimer, CFRunLoopTimerCreate,
-    CFRunLoopTimerInvalidate, CFRunLoopTimerSetNextFireDate, CFRunLoopWakeUp,
+    CFRunLoop, CFRunLoopActivity, CFRunLoopObserver, CFRunLoopObserverCallBack,
+    CFRunLoopObserverContext, CFRunLoopTimer,
 };
 use tracing::error;
 
@@ -95,11 +93,11 @@ impl RunLoop {
         // SAFETY: We have a MainThreadMarker here, which means we know we're on the main thread, so
         // scheduling (and scheduling a non-`Send` block) to that thread is allowed.
         let _ = mtm;
-        RunLoop(unsafe { CFRunLoopGetMain() }.unwrap())
+        RunLoop(CFRunLoop::main().unwrap())
     }
 
     pub fn wakeup(&self) {
-        unsafe { CFRunLoopWakeUp(&self.0) }
+        self.0.wake_up();
     }
 
     unsafe fn add_observer(
@@ -111,9 +109,9 @@ impl RunLoop {
         context: *mut CFRunLoopObserverContext,
     ) {
         let observer =
-            unsafe { CFRunLoopObserverCreate(None, flags.0, true, priority, handler, context) }
+            unsafe { CFRunLoopObserver::new(None, flags.0, true, priority, handler, context) }
                 .unwrap();
-        unsafe { CFRunLoopAddObserver(&self.0, Some(&observer), kCFRunLoopCommonModes) };
+        self.0.add_observer(Some(&observer), unsafe { kCFRunLoopCommonModes });
     }
 
     /// Submit a closure to run on the main thread as the next step in the run loop, before other
@@ -178,7 +176,7 @@ impl RunLoop {
         let mode = unsafe { kCFRunLoopDefaultMode.unwrap() };
 
         // SAFETY: The runloop is valid, the mode is a `CFStringRef`, and the block is `'static`.
-        unsafe { CFRunLoopPerformBlock(&self.0, Some(mode), Some(&block)) }
+        unsafe { self.0.perform_block(Some(mode), Some(&block)) }
     }
 }
 
@@ -224,7 +222,7 @@ pub struct EventLoopWaker {
 
 impl Drop for EventLoopWaker {
     fn drop(&mut self) {
-        unsafe { CFRunLoopTimerInvalidate(&self.timer) };
+        self.timer.invalidate();
     }
 }
 
@@ -235,7 +233,7 @@ impl EventLoopWaker {
             // Create a timer with a 0.1µs interval (1ns does not work) to mimic polling.
             // It is initially setup with a first fire time really far into the
             // future, but that gets changed to fire immediately in did_finish_launching
-            let timer = CFRunLoopTimerCreate(
+            let timer = CFRunLoopTimer::new(
                 None,
                 f64::MAX,
                 0.000_000_1,
@@ -245,7 +243,7 @@ impl EventLoopWaker {
                 ptr::null_mut(),
             )
             .unwrap();
-            CFRunLoopAddTimer(&CFRunLoopGetMain().unwrap(), Some(&timer), kCFRunLoopCommonModes);
+            CFRunLoop::main().unwrap().add_timer(Some(&timer), kCFRunLoopCommonModes);
             Self { timer, start_instant: Instant::now(), next_fire_date: None }
         }
     }
@@ -253,14 +251,14 @@ impl EventLoopWaker {
     pub fn stop(&mut self) {
         if self.next_fire_date.is_some() {
             self.next_fire_date = None;
-            unsafe { CFRunLoopTimerSetNextFireDate(&self.timer, f64::MAX) };
+            self.timer.set_next_fire_date(f64::MAX);
         }
     }
 
     pub fn start(&mut self) {
         if self.next_fire_date != Some(self.start_instant) {
             self.next_fire_date = Some(self.start_instant);
-            unsafe { CFRunLoopTimerSetNextFireDate(&self.timer, f64::MIN) };
+            self.timer.set_next_fire_date(f64::MIN);
         }
     }
 
@@ -273,13 +271,11 @@ impl EventLoopWaker {
             Some(instant) => {
                 if self.next_fire_date != Some(instant) {
                     self.next_fire_date = Some(instant);
-                    unsafe {
-                        let current = CFAbsoluteTimeGetCurrent();
-                        let duration = instant - now;
-                        let fsecs = duration.subsec_nanos() as f64 / 1_000_000_000.0
-                            + duration.as_secs() as f64;
-                        CFRunLoopTimerSetNextFireDate(&self.timer, current + fsecs);
-                    }
+                    let current = CFAbsoluteTimeGetCurrent();
+                    let duration = instant - now;
+                    let fsecs = duration.subsec_nanos() as f64 / 1_000_000_000.0
+                        + duration.as_secs() as f64;
+                    self.timer.set_next_fire_date(current + fsecs);
                 }
             },
             None => {

src/platform_impl/apple/appkit/view.rs

@@ -81,7 +81,7 @@ fn key_to_modifier(key: &Key) -> Option<ModifiersState> {
     match key {
         Key::Named(NamedKey::Alt) => Some(ModifiersState::ALT),
         Key::Named(NamedKey::Control) => Some(ModifiersState::CONTROL),
-        Key::Named(NamedKey::Super) => Some(ModifiersState::SUPER),
+        Key::Named(NamedKey::Meta) => Some(ModifiersState::META),
         Key::Named(NamedKey::Shift) => Some(ModifiersState::SHIFT),
         _ => None,
     }
@@ -92,7 +92,7 @@ fn get_right_modifier_code(key: &Key) -> KeyCode {
         Key::Named(NamedKey::Alt) => KeyCode::AltRight,
         Key::Named(NamedKey::Control) => KeyCode::ControlRight,
         Key::Named(NamedKey::Shift) => KeyCode::ShiftRight,
-        Key::Named(NamedKey::Super) => KeyCode::SuperRight,
+        Key::Named(NamedKey::Meta) => KeyCode::MetaRight,
         _ => unreachable!(),
     }
 }
@@ -102,7 +102,7 @@ fn get_left_modifier_code(key: &Key) -> KeyCode {
         Key::Named(NamedKey::Alt) => KeyCode::AltLeft,
         Key::Named(NamedKey::Control) => KeyCode::ControlLeft,
         Key::Named(NamedKey::Shift) => KeyCode::ShiftLeft,
-        Key::Named(NamedKey::Super) => KeyCode::SuperLeft,
+        Key::Named(NamedKey::Meta) => KeyCode::MetaLeft,
         _ => unreachable!(),
     }
 }
@@ -1103,7 +1103,7 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEven
         OptionAsAlt::Both if ev_mods.alt_key() => true,
         _ => false,
     } && !ev_mods.control_key()
-        && !ev_mods.super_key();
+        && !ev_mods.meta_key();
 
     if ignore_alt_characters {
         let ns_chars = unsafe {

src/platform_impl/apple/appkit/window.rs

@@ -1,5 +1,7 @@
 #![allow(clippy::unnecessary_cast)]
 
+use std::sync::Arc;
+
 use dispatch2::MainThreadBound;
 use dpi::{Position, Size};
 use objc2::rc::{autoreleasepool, Retained};
@@ -10,12 +12,13 @@ use objc2_foundation::NSObject;
 use super::event_loop::ActiveEventLoop;
 use super::window_delegate::WindowDelegate;
 use crate::error::RequestError;
-use crate::monitor::MonitorHandle as CoreMonitorHandle;
+use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
 use crate::window::{
-    Cursor, Fullscreen, Icon, ImePurpose, Theme, UserAttentionType, Window as CoreWindow,
-    WindowAttributes, WindowButtons, WindowId, WindowLevel,
+    Cursor, Icon, ImePurpose, Theme, UserAttentionType, Window as CoreWindow, WindowAttributes,
+    WindowButtons, WindowId, WindowLevel,
 };
 
+#[derive(Debug)]
 pub(crate) struct Window {
     window: MainThreadBound<Retained<NSWindow>>,
     /// The window only keeps a weak reference to this, so we must keep it around here.
@@ -205,11 +208,11 @@ impl CoreWindow for Window {
     }
 
     fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
-        self.maybe_wait_on_main(|delegate| delegate.set_fullscreen(fullscreen.map(Into::into)))
+        self.maybe_wait_on_main(|delegate| delegate.set_fullscreen(fullscreen))
     }
 
     fn fullscreen(&self) -> Option<Fullscreen> {
-        self.maybe_wait_on_main(|delegate| delegate.fullscreen().map(Into::into))
+        self.maybe_wait_on_main(|delegate| delegate.fullscreen())
     }
 
     fn set_decorations(&self, decorations: bool) {
@@ -306,21 +309,24 @@ impl CoreWindow for Window {
 
     fn current_monitor(&self) -> Option<CoreMonitorHandle> {
         self.maybe_wait_on_main(|delegate| {
-            delegate.current_monitor().map(|inner| CoreMonitorHandle { inner })
+            delegate.current_monitor().map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
         })
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         self.maybe_wait_on_main(|delegate| {
             Box::new(
-                delegate.available_monitors().into_iter().map(|inner| CoreMonitorHandle { inner }),
+                delegate
+                    .available_monitors()
+                    .into_iter()
+                    .map(|monitor| CoreMonitorHandle(Arc::new(monitor))),
             )
         })
     }
 
     fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
         self.maybe_wait_on_main(|delegate| {
-            delegate.primary_monitor().map(|inner| CoreMonitorHandle { inner })
+            delegate.primary_monitor().map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
         })
     }
 

src/platform_impl/apple/appkit/window_delegate.rs

@@ -23,8 +23,10 @@ use objc2_app_kit::{
 };
 use objc2_core_foundation::{CGFloat, CGPoint};
 use objc2_core_graphics::{
-    CGAcquireDisplayFadeReservation, CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture,
-    CGDisplayFade, CGDisplayRelease, CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
+    kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, kCGDisplayFadeReservationInvalidToken,
+    kCGFloatingWindowLevel, kCGNormalWindowLevel, CGAcquireDisplayFadeReservation,
+    CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture, CGDisplayFade, CGDisplayRelease,
+    CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
     CGRestorePermanentDisplayConfiguration, CGShieldingWindowLevel, CGWarpMouseCursorPosition,
 };
 use objc2_foundation::{
@@ -36,19 +38,20 @@ use objc2_foundation::{
 use tracing::{trace, warn};
 
 use super::app_state::AppState;
-use super::cursor::cursor_from_icon;
+use super::cursor::{cursor_from_icon, CustomCursor};
 use super::monitor::{self, flip_window_screen_coordinates, get_display_id};
 use super::observer::RunLoop;
 use super::util::cgerr;
 use super::view::WinitView;
 use super::window::{window_id, WinitPanel, WinitWindow};
-use super::{ffi, Fullscreen, MonitorHandle};
+use super::{ffi, MonitorHandle};
 use crate::dpi::{
     LogicalInsets, LogicalPosition, LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize,
     Position, Size,
 };
 use crate::error::{NotSupportedError, RequestError};
 use crate::event::{SurfaceSizeWriter, WindowEvent};
+use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle, MonitorHandleProvider};
 use crate::platform::macos::{OptionAsAlt, WindowExtMacOS};
 use crate::window::{
     Cursor, CursorGrabMode, Icon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
@@ -257,7 +260,9 @@ define_class!(
                 // Otherwise, we must've reached fullscreen by the user clicking
                 // on the green fullscreen button. Update state!
                 None => {
-                    let current_monitor = self.current_monitor_inner();
+                    let current_monitor = self
+                        .current_monitor_inner()
+                        .map(|monitor| CoreMonitorHandle(Arc::new(monitor)));
                     *fullscreen = Some(Fullscreen::Borderless(current_monitor));
                 },
             }
@@ -550,9 +555,10 @@ fn new_window(
     mtm: MainThreadMarker,
 ) -> Option<Retained<NSWindow>> {
     autoreleasepool(|_| {
-        let screen = match attrs.fullscreen.clone().map(Into::into) {
+        let screen = match attrs.fullscreen.clone() {
             Some(Fullscreen::Borderless(Some(monitor)))
             | Some(Fullscreen::Exclusive(monitor, _)) => {
+                let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
                 monitor.ns_screen(mtm).or_else(|| NSScreen::mainScreen(mtm))
             },
             Some(Fullscreen::Borderless(None)) => NSScreen::mainScreen(mtm),
@@ -871,7 +877,7 @@ impl WindowDelegate {
         delegate.set_cursor(attrs.cursor);
 
         // Set fullscreen mode after we setup everything
-        delegate.set_fullscreen(attrs.fullscreen.map(Into::into));
+        delegate.set_fullscreen(attrs.fullscreen);
 
         // Setting the window as key has to happen *after* we set the fullscreen
         // state, since otherwise we'll briefly see the window at normal size
@@ -1245,7 +1251,13 @@ impl WindowDelegate {
 
         let cursor = match cursor {
             Cursor::Icon(icon) => cursor_from_icon(icon),
-            Cursor::Custom(cursor) => cursor.inner.0,
+            Cursor::Custom(cursor) => match cursor.cast_ref::<CustomCursor>() {
+                Some(cursor) => cursor.0.clone(),
+                None => {
+                    tracing::error!("unrecognized cursor passed to macOS backend");
+                    return;
+                },
+            },
         };
 
         if view.cursor_icon() == cursor {
@@ -1455,17 +1467,18 @@ impl WindowDelegate {
         // does not take a screen parameter, but uses the current screen)
         if let Some(ref fullscreen) = fullscreen {
             let new_screen = match fullscreen {
-                Fullscreen::Borderless(Some(monitor)) => monitor.clone(),
+                Fullscreen::Borderless(Some(monitor)) | Fullscreen::Exclusive(monitor, _) => {
+                    let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
+                    monitor.ns_screen(mtm)
+                },
                 Fullscreen::Borderless(None) => {
                     if let Some(monitor) = self.current_monitor_inner() {
-                        monitor
+                        monitor.ns_screen(mtm)
                     } else {
                         return;
                     }
                 },
-                Fullscreen::Exclusive(monitor, _) => monitor.clone(),
             }
-            .ns_screen(mtm)
             .unwrap();
 
             let old_screen = self.window().screen().unwrap();
@@ -1487,9 +1500,9 @@ impl WindowDelegate {
             // parameter, which is not consistent with the docs saying that it
             // takes a `NSDictionary`..
 
-            let display_id = monitor.native_identifier();
+            let display_id = monitor.native_id() as _;
 
-            let mut fade_token = ffi::kCGDisplayFadeReservationInvalidToken;
+            let mut fade_token = kCGDisplayFadeReservationInvalidToken;
 
             if matches!(old_fullscreen, Some(Fullscreen::Borderless(_))) {
                 self.ivars().save_presentation_opts.replace(Some(app.presentationOptions()));
@@ -1502,8 +1515,8 @@ impl WindowDelegate {
                     CGDisplayFade(
                         fade_token,
                         0.3,
-                        ffi::kCGDisplayBlendNormal,
-                        ffi::kCGDisplayBlendSolidColor,
+                        kCGDisplayBlendNormal,
+                        kCGDisplayBlendSolidColor,
                         0.0,
                         0.0,
                         0.0,
@@ -1514,8 +1527,9 @@ impl WindowDelegate {
                 cgerr(CGDisplayCapture(display_id)).unwrap();
             }
 
+            let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
             let video_mode =
-                match monitor.video_modes_handles().find(|mode| &mode.mode == video_mode) {
+                match monitor.video_mode_handles().find(|mode| &mode.mode == video_mode) {
                     Some(video_mode) => video_mode,
                     None => return,
                 };
@@ -1526,12 +1540,12 @@ impl WindowDelegate {
 
                 // After the display has been configured, fade back in
                 // asynchronously
-                if fade_token != ffi::kCGDisplayFadeReservationInvalidToken {
+                if fade_token != kCGDisplayFadeReservationInvalidToken {
                     CGDisplayFade(
                         fade_token,
                         0.6,
-                        ffi::kCGDisplayBlendSolidColor,
-                        ffi::kCGDisplayBlendNormal,
+                        kCGDisplayBlendSolidColor,
+                        kCGDisplayBlendNormal,
                         0.0,
                         0.0,
                         0.0,
@@ -1548,7 +1562,7 @@ impl WindowDelegate {
             // Window level must be restored from `CGShieldingWindowLevel()
             // + 1` back to normal in order for `toggleFullScreen` to do
             // anything
-            window.setLevel(ffi::kCGNormalWindowLevel as NSWindowLevel);
+            window.setLevel(kCGNormalWindowLevel as NSWindowLevel);
             window.toggleFullScreen(None);
         }
 
@@ -1580,7 +1594,8 @@ impl WindowDelegate {
                 // State is restored by `window_did_exit_fullscreen`
                 toggle_fullscreen(self.window());
             },
-            (Some(Fullscreen::Exclusive(ref monitor, _)), None) => {
+            (Some(Fullscreen::Exclusive(monitor, _)), None) => {
+                let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
                 restore_and_release_display(monitor);
                 toggle_fullscreen(self.window());
             },
@@ -1603,7 +1618,7 @@ impl WindowDelegate {
                 let window_level = unsafe { CGShieldingWindowLevel() } as NSWindowLevel + 1;
                 self.window().setLevel(window_level);
             },
-            (Some(Fullscreen::Exclusive(ref monitor, _)), Some(Fullscreen::Borderless(_))) => {
+            (Some(Fullscreen::Exclusive(monitor, _)), Some(Fullscreen::Borderless(_))) => {
                 let presentation_options = self.ivars().save_presentation_opts.get().unwrap_or(
                     NSApplicationPresentationOptions::FullScreen
                         | NSApplicationPresentationOptions::AutoHideDock
@@ -1611,11 +1626,12 @@ impl WindowDelegate {
                 );
                 app.setPresentationOptions(presentation_options);
 
+                let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
                 restore_and_release_display(monitor);
 
                 // Restore the normal window level following the Borderless fullscreen
                 // `CGShieldingWindowLevel() + 1` hack.
-                self.window().setLevel(ffi::kCGNormalWindowLevel as NSWindowLevel);
+                self.window().setLevel(kCGNormalWindowLevel as NSWindowLevel);
             },
             _ => {},
         };
@@ -1662,10 +1678,19 @@ impl WindowDelegate {
 
     #[inline]
     pub fn set_window_level(&self, level: WindowLevel) {
+        // Note: There are two different things at play here:
+        // `CGWindowLevel` and `CGWindowLevelKey`.
+        //
+        // It seems like there was a push towards using "key" values instead of the
+        // raw window level values, and then you were supposed to use
+        // `CGWindowLevelForKey` to get the actual level.
+        //
+        // But the values that `NSWindowLevel` has are compiled in, and as such has
+        // to remain ABI compatible, so they're safe for us to hardcode as well.
         let level = match level {
-            WindowLevel::AlwaysOnTop => ffi::kCGFloatingWindowLevel as NSWindowLevel,
-            WindowLevel::AlwaysOnBottom => (ffi::kCGNormalWindowLevel - 1) as NSWindowLevel,
-            WindowLevel::Normal => ffi::kCGNormalWindowLevel as NSWindowLevel,
+            WindowLevel::AlwaysOnTop => kCGFloatingWindowLevel as NSWindowLevel,
+            WindowLevel::AlwaysOnBottom => (kCGNormalWindowLevel - 1) as NSWindowLevel,
+            WindowLevel::Normal => kCGNormalWindowLevel as NSWindowLevel,
         };
         self.window().setLevel(level);
     }
@@ -1731,7 +1756,14 @@ impl WindowDelegate {
     // Allow directly accessing the current monitor internally without unwrapping.
     pub(crate) fn current_monitor_inner(&self) -> Option<MonitorHandle> {
         let display_id = get_display_id(&*self.window().screen()?);
-        Some(MonitorHandle::new(display_id))
+        if let Some(monitor) = MonitorHandle::new(display_id) {
+            Some(monitor)
+        } else {
+            // NOTE: Display ID was just fetched from live NSScreen, but can still result in `None`
+            // with certain Thunderbolt docked monitors.
+            warn!(display_id, "got screen with invalid display ID");
+            None
+        }
     }
 
     #[inline]
@@ -1815,11 +1847,11 @@ fn restore_and_release_display(monitor: &MonitorHandle) {
     if available_monitors.contains(monitor) {
         unsafe {
             CGRestorePermanentDisplayConfiguration();
-            cgerr(CGDisplayRelease(monitor.native_identifier())).unwrap();
+            cgerr(CGDisplayRelease(monitor.native_id() as _)).unwrap();
         };
     } else {
         warn!(
-            monitor = monitor.name(),
+            monitor = monitor.name().map(|name| name.to_string()),
             "Tried to restore exclusive fullscreen on a monitor that is no longer available"
         );
     }
@@ -1860,8 +1892,13 @@ impl WindowExtMacOS for WindowDelegate {
             self.ivars().is_simple_fullscreen.set(true);
 
             // Simulate pre-Lion fullscreen by hiding the dock and menu bar
-            let presentation_options = NSApplicationPresentationOptions::AutoHideDock
-                | NSApplicationPresentationOptions::AutoHideMenuBar;
+            let presentation_options = if self.is_borderless_game() {
+                NSApplicationPresentationOptions::HideDock
+                    | NSApplicationPresentationOptions::HideMenuBar
+            } else {
+                NSApplicationPresentationOptions::AutoHideDock
+                    | NSApplicationPresentationOptions::AutoHideMenuBar
+            };
             app.setPresentationOptions(presentation_options);
 
             // Hide the titlebar
@@ -1882,7 +1919,6 @@ impl WindowExtMacOS for WindowDelegate {
             self.window().setMovable(false);
         } else {
             let new_mask = self.saved_style();
-            self.set_style_mask(new_mask);
             self.ivars().is_simple_fullscreen.set(false);
 
             let save_presentation_opts = self.ivars().save_presentation_opts.get();
@@ -1905,6 +1941,7 @@ impl WindowExtMacOS for WindowDelegate {
 
             self.window().setFrame_display(frame, true);
             self.window().setMovable(true);
+            self.set_style_mask(new_mask);
         }
 
         true

src/platform_impl/apple/event_handler.rs

@@ -8,10 +8,10 @@ use crate::application::ApplicationHandler;
 #[derive(Default)]
 pub(crate) struct EventHandler {
     /// This can be in the following states:
-    /// - Not registered by the event loop (None).
+    /// - Not registered by the event loop, or terminated (None).
     /// - Present (Some(handler)).
     /// - Currently executing the handler / in use (RefCell borrowed).
-    inner: RefCell<Option<&'static mut dyn ApplicationHandler>>,
+    inner: RefCell<Option<Box<dyn ApplicationHandler + 'static>>>,
 }
 
 impl fmt::Debug for EventHandler {
@@ -37,7 +37,7 @@ impl EventHandler {
     /// from within the closure.
     pub(crate) fn set<'handler, R>(
         &self,
-        app: &'handler mut dyn ApplicationHandler,
+        app: Box<dyn ApplicationHandler + 'handler>,
         closure: impl FnOnce() -> R,
     ) -> R {
         // SAFETY: We extend the lifetime of the handler here so that we can
@@ -48,8 +48,8 @@ impl EventHandler {
         // extended beyond `'handler`.
         let handler = unsafe {
             mem::transmute::<
-                &'handler mut dyn ApplicationHandler,
-                &'static mut dyn ApplicationHandler,
+                Box<dyn ApplicationHandler + 'handler>,
+                Box<dyn ApplicationHandler + 'static>,
             >(app)
         };
 
@@ -71,10 +71,13 @@ impl EventHandler {
             fn drop(&mut self) {
                 match self.0.inner.try_borrow_mut().as_deref_mut() {
                     Ok(data @ Some(_)) => {
-                        *data = None;
+                        let handler = data.take();
+                        // Explicitly `Drop` the application handler.
+                        drop(handler);
                     },
                     Ok(None) => {
-                        tracing::error!("tried to clear handler, but no handler was set");
+                        // Allowed, happens if the handler was cleared manually
+                        // elsewhere (such as in `applicationWillTerminate:`).
                     },
                     Err(_) => {
                         // Note: This is not expected to ever happen, this
@@ -110,16 +113,16 @@ impl EventHandler {
         matches!(self.inner.try_borrow().as_deref(), Ok(Some(_)))
     }
 
-    pub(crate) fn handle(&self, callback: impl FnOnce(&mut dyn ApplicationHandler)) {
+    pub(crate) fn handle(&self, callback: impl FnOnce(&mut (dyn ApplicationHandler + '_))) {
         match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(user_app)) => {
+            Ok(Some(ref mut user_app)) => {
                 // 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);
+                callback(&mut **user_app);
             },
             Ok(None) => {
                 // `NSApplication`, our app state and this handler are all
@@ -133,4 +136,21 @@ impl EventHandler {
             },
         }
     }
+
+    pub(crate) fn terminate(&self) {
+        match self.inner.try_borrow_mut().as_deref_mut() {
+            Ok(data @ Some(_)) => {
+                let handler = data.take();
+                // Explicitly `Drop` the application handler.
+                drop(handler);
+            },
+            Ok(None) => {
+                // When terminating, we expect the application handler to still be registered.
+                tracing::error!("tried to clear handler, but no handler was set");
+            },
+            Err(_) => {
+                panic!("tried to clear handler while an event is currently being handled");
+            },
+        }
+    }
 }

src/platform_impl/apple/event_loop_proxy.rs

@@ -3,9 +3,7 @@ use std::sync::Arc;
 
 use objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    kCFRunLoopCommonModes, CFIndex, CFRetained, CFRunLoop, CFRunLoopAddSource, CFRunLoopGetMain,
-    CFRunLoopSource, CFRunLoopSourceContext, CFRunLoopSourceCreate, CFRunLoopSourceInvalidate,
-    CFRunLoopSourceSignal, CFRunLoopWakeUp,
+    kCFRunLoopCommonModes, CFIndex, CFRetained, CFRunLoop, CFRunLoopSource, CFRunLoopSourceContext,
 };
 
 use crate::event_loop::EventLoopProxyProvider;
@@ -90,12 +88,12 @@ impl EventLoopProxy {
         // Keeping the closure alive beyond this scope is fine, because `F: 'static`.
         let source = unsafe {
             let _ = mtm;
-            CFRunLoopSourceCreate(None, order, &mut context).unwrap()
+            CFRunLoopSource::new(None, order, &mut context).unwrap()
         };
 
         // Register the source to be performed on the main thread.
-        let main_loop = unsafe { CFRunLoopGetMain() }.unwrap();
-        unsafe { CFRunLoopAddSource(&main_loop, Some(&source), kCFRunLoopCommonModes) };
+        let main_loop = CFRunLoop::main().unwrap();
+        unsafe { main_loop.add_source(Some(&source), kCFRunLoopCommonModes) };
 
         Self { source, main_loop }
     }
@@ -106,7 +104,7 @@ impl EventLoopProxy {
     pub(crate) fn invalidate(&self) {
         // NOTE: We do NOT fire this on `Drop`, since we want the proxy to be cloneable, such that
         // we only need to register a single source even if there's multiple proxies in use.
-        unsafe { CFRunLoopSourceInvalidate(&self.source) };
+        self.source.invalidate();
     }
 }
 
@@ -115,12 +113,12 @@ impl EventLoopProxyProvider for EventLoopProxy {
         // Signal the source, which ends up later invoking `perform` on the main thread.
         //
         // Multiple signals in quick succession are automatically coalesced into a single signal.
-        unsafe { CFRunLoopSourceSignal(&self.source) };
+        self.source.signal();
 
         // Let the main thread know there's a new event.
         //
         // This is required since we may be (probably are) running on a different thread, and the
         // main loop may be sleeping (and `CFRunLoopSourceSignal` won't wake it).
-        unsafe { CFRunLoopWakeUp(&self.main_loop) };
+        self.main_loop.wake_up();
     }
 }

src/platform_impl/apple/uikit/app_state.rs

@@ -11,9 +11,8 @@ use dispatch2::MainThreadBound;
 use objc2::rc::Retained;
 use objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    kCFRunLoopCommonModes, CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopAddTimer,
-    CFRunLoopGetMain, CFRunLoopTimer, CFRunLoopTimerCreate, CFRunLoopTimerInvalidate,
-    CFRunLoopTimerSetNextFireDate, CGRect, CGSize,
+    kCFRunLoopCommonModes, CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, CGRect,
+    CGSize,
 };
 use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView};
 
@@ -115,7 +114,7 @@ impl AppState {
             #[inline(never)]
             #[cold]
             fn init_guard(guard: &mut RefMut<'static, Option<AppState>>, mtm: MainThreadMarker) {
-                let waker = EventLoopWaker::new(unsafe { CFRunLoopGetMain().unwrap() });
+                let waker = EventLoopWaker::new(CFRunLoop::main().unwrap());
                 let event_loop_proxy = Arc::new(EventLoopProxy::new(mtm, move || {
                     get_handler(mtm).handle(|app| app.proxy_wake_up(&ActiveEventLoop { mtm }));
                 }));
@@ -298,15 +297,19 @@ pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Retained<W
         },
         s @ &mut AppStateImpl::ProcessingRedraws { .. }
         | s @ &mut AppStateImpl::Waiting { .. }
-        | s @ &mut AppStateImpl::PollFinished { .. } => bug!("unexpected state {:?}", s),
+        | s @ &mut AppStateImpl::PollFinished => bug!("unexpected state {:?}", s),
         &mut AppStateImpl::Terminated => {
             panic!("Attempt to create a `Window` after the app has terminated")
         },
     }
 }
 
-pub(crate) fn launch(mtm: MainThreadMarker, app: &mut dyn ApplicationHandler, run: impl FnOnce()) {
-    get_handler(mtm).set(app, run)
+pub(crate) fn launch<R>(
+    mtm: MainThreadMarker,
+    app: impl ApplicationHandler,
+    run: impl FnOnce() -> R,
+) -> R {
+    get_handler(mtm).set(Box::new(app), run)
 }
 
 pub fn did_finish_launching(mtm: MainThreadMarker) {
@@ -495,13 +498,11 @@ pub(crate) fn terminated(application: &UIApplication) {
 
     let mut this = AppState::get_mut(mtm);
     this.terminated_transition();
-    drop(this);
-
-    get_handler(mtm).handle(|app| app.exiting(&ActiveEventLoop { mtm }));
-
-    let this = AppState::get_mut(mtm);
     // Prevent EventLoopProxy from firing again.
     this.event_loop_proxy.invalidate();
+    drop(this);
+
+    get_handler(mtm).terminate();
 }
 
 fn handle_wrapped_event(mtm: MainThreadMarker, event: EventWrapper) {
@@ -546,9 +547,7 @@ struct EventLoopWaker {
 
 impl Drop for EventLoopWaker {
     fn drop(&mut self) {
-        unsafe {
-            CFRunLoopTimerInvalidate(&self.timer);
-        }
+        self.timer.invalidate();
     }
 }
 
@@ -559,7 +558,7 @@ impl EventLoopWaker {
             // Create a timer with a 0.1µs interval (1ns does not work) to mimic polling.
             // It is initially setup with a first fire time really far into the
             // future, but that gets changed to fire immediately in did_finish_launching
-            let timer = CFRunLoopTimerCreate(
+            let timer = CFRunLoopTimer::new(
                 None,
                 f64::MAX,
                 0.000_000_1,
@@ -569,18 +568,18 @@ impl EventLoopWaker {
                 ptr::null_mut(),
             )
             .unwrap();
-            CFRunLoopAddTimer(&rl, Some(&timer), kCFRunLoopCommonModes);
+            rl.add_timer(Some(&timer), kCFRunLoopCommonModes);
 
             EventLoopWaker { timer }
         }
     }
 
     fn stop(&mut self) {
-        unsafe { CFRunLoopTimerSetNextFireDate(&self.timer, f64::MAX) }
+        self.timer.set_next_fire_date(f64::MAX);
     }
 
     fn start(&mut self) {
-        unsafe { CFRunLoopTimerSetNextFireDate(&self.timer, f64::MIN) }
+        self.timer.set_next_fire_date(f64::MIN);
     }
 
     fn start_at(&mut self, instant: Instant) {
@@ -588,13 +587,11 @@ impl EventLoopWaker {
         if now >= instant {
             self.start();
         } else {
-            unsafe {
-                let current = CFAbsoluteTimeGetCurrent();
-                let duration = instant - now;
-                let fsecs =
-                    duration.subsec_nanos() as f64 / 1_000_000_000.0 + duration.as_secs() as f64;
-                CFRunLoopTimerSetNextFireDate(&self.timer, current + fsecs);
-            }
+            let current = CFAbsoluteTimeGetCurrent();
+            let duration = instant - now;
+            let fsecs =
+                duration.subsec_nanos() as f64 / 1_000_000_000.0 + duration.as_secs() as f64;
+            self.timer.set_next_fire_date(current + fsecs);
         }
     }
 }

src/platform_impl/apple/uikit/event_loop.rs

@@ -1,21 +1,19 @@
-use std::ffi::{c_char, c_int, c_void};
-use std::ptr::{self, NonNull};
+use std::ffi::c_void;
+use std::ptr;
 use std::sync::Arc;
 
 use objc2::rc::Retained;
 use objc2::runtime::ProtocolObject;
 use objc2::{msg_send, ClassType, MainThreadMarker};
 use objc2_core_foundation::{
-    kCFRunLoopDefaultMode, CFIndex, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopGetMain,
-    CFRunLoopObserver, CFRunLoopObserverCreate,
+    kCFRunLoopDefaultMode, CFIndex, CFRunLoop, CFRunLoopActivity, CFRunLoopObserver,
 };
 use objc2_foundation::{NSNotificationCenter, NSObjectProtocol};
 use objc2_ui_kit::{
     UIApplication, UIApplicationDidBecomeActiveNotification,
     UIApplicationDidEnterBackgroundNotification, UIApplicationDidFinishLaunchingNotification,
-    UIApplicationDidReceiveMemoryWarningNotification, UIApplicationMain,
-    UIApplicationWillEnterForegroundNotification, UIApplicationWillResignActiveNotification,
-    UIApplicationWillTerminateNotification, UIScreen,
+    UIApplicationDidReceiveMemoryWarningNotification, UIApplicationWillEnterForegroundNotification,
+    UIApplicationWillResignActiveNotification, UIApplicationWillTerminateNotification, UIScreen,
 };
 use rwh_06::HasDisplayHandle;
 
@@ -28,7 +26,7 @@ use crate::event_loop::{
     ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
     EventLoopProxy as CoreEventLoopProxy, OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
-use crate::monitor::MonitorHandle as RootMonitorHandle;
+use crate::monitor::MonitorHandle as CoreMonitorHandle;
 use crate::platform_impl::Window;
 use crate::window::{CustomCursor, CustomCursorSource, Theme, Window as CoreWindow};
 
@@ -56,14 +54,18 @@ impl RootActiveEventLoop for ActiveEventLoop {
         Err(NotSupportedError::new("create_custom_cursor is not supported").into())
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
-        Box::new(monitor::uiscreens(self.mtm).into_iter().map(|inner| RootMonitorHandle { inner }))
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
+        Box::new(
+            monitor::uiscreens(self.mtm)
+                .into_iter()
+                .map(|monitor| CoreMonitorHandle(Arc::new(monitor))),
+        )
     }
 
     fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
         #[allow(deprecated)]
         let monitor = MonitorHandle::new(UIScreen::mainScreen(self.mtm));
-        Some(RootMonitorHandle { inner: monitor })
+        Some(CoreMonitorHandle(Arc::new(monitor)))
     }
 
     fn listen_device_events(&self, _allowed: DeviceEvents) {}
@@ -116,6 +118,7 @@ impl HasDisplayHandle for OwnedDisplayHandle {
     }
 }
 
+#[derive(Debug)]
 pub struct EventLoop {
     mtm: MainThreadMarker,
     window_target: ActiveEventLoop,
@@ -238,7 +241,7 @@ impl EventLoop {
         })
     }
 
-    pub fn run_app<A: ApplicationHandler>(self, mut app: A) -> ! {
+    pub fn run_app<A: ApplicationHandler>(self, app: A) -> ! {
         let application: Option<Retained<UIApplication>> =
             unsafe { msg_send![UIApplication::class(), sharedApplication] };
         assert!(
@@ -248,24 +251,9 @@ impl EventLoop {
              `EventLoop::run_app` calls `UIApplicationMain` on iOS",
         );
 
-        extern "C" {
-            // These functions are in crt_externs.h.
-            fn _NSGetArgc() -> *mut c_int;
-            fn _NSGetArgv() -> *mut *mut *mut c_char;
-        }
-
-        app_state::launch(self.mtm, &mut app, || unsafe {
-            UIApplicationMain(
-                *_NSGetArgc(),
-                NonNull::new(*_NSGetArgv()).unwrap(),
-                // We intentionally override neither the application nor the delegate, to allow
-                // the user to do so themselves!
-                None,
-                None,
-            );
-        });
-
-        unreachable!()
+        // We intentionally override neither the application nor the delegate,
+        // to allow the user to do so themselves!
+        app_state::launch(self.mtm, app, || UIApplication::main(None, None, self.mtm))
     }
 
     pub fn window_target(&self) -> &dyn RootActiveEventLoop {
@@ -330,9 +318,9 @@ fn setup_control_flow_observers() {
             }
         }
 
-        let main_loop = CFRunLoopGetMain().unwrap();
+        let main_loop = CFRunLoop::main().unwrap();
 
-        let begin_observer = CFRunLoopObserverCreate(
+        let begin_observer = CFRunLoopObserver::new(
             None,
             CFRunLoopActivity::AfterWaiting.0,
             true,
@@ -341,9 +329,9 @@ fn setup_control_flow_observers() {
             ptr::null_mut(),
         )
         .unwrap();
-        CFRunLoopAddObserver(&main_loop, Some(&begin_observer), kCFRunLoopDefaultMode);
+        main_loop.add_observer(Some(&begin_observer), kCFRunLoopDefaultMode);
 
-        let main_end_observer = CFRunLoopObserverCreate(
+        let main_end_observer = CFRunLoopObserver::new(
             None,
             (CFRunLoopActivity::Exit | CFRunLoopActivity::BeforeWaiting).0,
             true,
@@ -352,9 +340,9 @@ fn setup_control_flow_observers() {
             ptr::null_mut(),
         )
         .unwrap();
-        CFRunLoopAddObserver(&main_loop, Some(&main_end_observer), kCFRunLoopDefaultMode);
+        main_loop.add_observer(Some(&main_end_observer), kCFRunLoopDefaultMode);
 
-        let end_observer = CFRunLoopObserverCreate(
+        let end_observer = CFRunLoopObserver::new(
             None,
             (CFRunLoopActivity::Exit | CFRunLoopActivity::BeforeWaiting).0,
             true,
@@ -363,6 +351,6 @@ fn setup_control_flow_observers() {
             ptr::null_mut(),
         )
         .unwrap();
-        CFRunLoopAddObserver(&main_loop, Some(&end_observer), kCFRunLoopDefaultMode);
+        main_loop.add_observer(Some(&end_observer), kCFRunLoopDefaultMode);
     }
 }

src/platform_impl/apple/uikit/mod.rs

@@ -14,11 +14,6 @@ pub(crate) use self::event_loop::{
 };
 pub(crate) use self::monitor::MonitorHandle;
 pub(crate) use self::window::{PlatformSpecificWindowAttributes, Window};
-pub(crate) use crate::cursor::{
-    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
-};
-pub(crate) use crate::icon::NoIcon as PlatformIcon;
-pub(crate) use crate::platform_impl::Fullscreen;
 
 #[derive(Debug)]
 pub enum OsError {}

src/platform_impl/apple/uikit/monitor.rs

@@ -11,7 +11,7 @@ use objc2_foundation::NSInteger;
 use objc2_ui_kit::{UIScreen, UIScreenMode};
 
 use crate::dpi::PhysicalPosition;
-use crate::monitor::VideoMode;
+use crate::monitor::{MonitorHandleProvider, VideoMode};
 
 // Workaround for `MainThreadBound` implementing almost no traits
 #[derive(Debug)]
@@ -76,6 +76,60 @@ pub struct MonitorHandle {
     ui_screen: MainThreadBound<Retained<UIScreen>>,
 }
 
+impl MonitorHandleProvider for MonitorHandle {
+    fn id(&self) -> u128 {
+        self.native_id() as _
+    }
+
+    fn native_id(&self) -> u64 {
+        // SAFETY: Only getting the pointer.
+        let mtm = unsafe { MainThreadMarker::new_unchecked() };
+        Retained::as_ptr(self.ui_screen.get(mtm)) as u64
+    }
+
+    fn name(&self) -> Option<std::borrow::Cow<'_, str>> {
+        run_on_main(|mtm| {
+            #[allow(deprecated)]
+            let main = UIScreen::mainScreen(mtm);
+            if *self.ui_screen(mtm) == main {
+                Some("Primary".into())
+            } else if Some(self.ui_screen(mtm)) == main.mirroredScreen().as_ref() {
+                Some("Mirrored".into())
+            } else {
+                #[allow(deprecated)]
+                UIScreen::screens(mtm)
+                    .iter()
+                    .position(|rhs| rhs == *self.ui_screen(mtm))
+                    .map(|idx| idx.to_string().into())
+            }
+        })
+    }
+
+    fn position(&self) -> Option<PhysicalPosition<i32>> {
+        let bounds = self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeBounds());
+        Some((bounds.origin.x as f64, bounds.origin.y as f64).into())
+    }
+
+    fn scale_factor(&self) -> f64 {
+        self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeScale()) as f64
+    }
+
+    fn current_video_mode(&self) -> Option<VideoMode> {
+        Some(run_on_main(|mtm| {
+            VideoModeHandle::new(
+                self.ui_screen(mtm).clone(),
+                self.ui_screen(mtm).currentMode().unwrap(),
+                mtm,
+            )
+            .mode
+        }))
+    }
+
+    fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
+        Box::new(self.video_modes())
+    }
+}
+
 impl Clone for MonitorHandle {
     fn clone(&self) -> Self {
         run_on_main(|mtm| Self {
@@ -137,44 +191,6 @@ impl MonitorHandle {
         Self { ui_screen: MainThreadBound::new(ui_screen, mtm) }
     }
 
-    pub fn name(&self) -> Option<String> {
-        run_on_main(|mtm| {
-            #[allow(deprecated)]
-            let main = UIScreen::mainScreen(mtm);
-            if *self.ui_screen(mtm) == main {
-                Some("Primary".to_string())
-            } else if Some(self.ui_screen(mtm)) == main.mirroredScreen().as_ref() {
-                Some("Mirrored".to_string())
-            } else {
-                #[allow(deprecated)]
-                UIScreen::screens(mtm)
-                    .iter()
-                    .position(|rhs| rhs == *self.ui_screen(mtm))
-                    .map(|idx| idx.to_string())
-            }
-        })
-    }
-
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        let bounds = self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeBounds());
-        Some((bounds.origin.x as f64, bounds.origin.y as f64).into())
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeScale()) as f64
-    }
-
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        Some(run_on_main(|mtm| {
-            VideoModeHandle::new(
-                self.ui_screen(mtm).clone(),
-                self.ui_screen(mtm).currentMode().unwrap(),
-                mtm,
-            )
-            .mode
-        }))
-    }
-
     pub fn video_modes_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
         run_on_main(|mtm| {
             let ui_screen = self.ui_screen(mtm);

src/platform_impl/apple/uikit/window.rs

@@ -1,6 +1,7 @@
 #![allow(clippy::unnecessary_cast)]
 
 use std::collections::VecDeque;
+use std::sync::Arc;
 
 use dispatch2::MainThreadBound;
 use objc2::rc::Retained;
@@ -16,7 +17,7 @@ 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 super::{app_state, monitor, ActiveEventLoop, MonitorHandle};
 use crate::cursor::Cursor;
 use crate::dpi::{
     LogicalInsets, LogicalPosition, LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize,
@@ -25,7 +26,7 @@ use crate::dpi::{
 use crate::error::{NotSupportedError, RequestError};
 use crate::event::WindowEvent;
 use crate::icon::Icon;
-use crate::monitor::MonitorHandle as CoreMonitorHandle;
+use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
 use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
 use crate::window::{
     CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, Window as CoreWindow,
@@ -78,8 +79,9 @@ impl WinitUIWindow {
 
         this.setRootViewController(Some(view_controller));
 
-        match window_attributes.fullscreen.clone().map(Into::into) {
-            Some(Fullscreen::Exclusive(ref monitor, ref video_mode)) => {
+        match window_attributes.fullscreen.clone() {
+            Some(Fullscreen::Exclusive(monitor, ref video_mode)) => {
+                let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
                 let screen = monitor.ui_screen(mtm);
                 if let Some(video_mode) =
                     monitor.video_modes_handles().find(|mode| &mode.mode == video_mode)
@@ -89,6 +91,7 @@ impl WinitUIWindow {
                 this.setScreen(screen);
             },
             Some(Fullscreen::Borderless(Some(ref monitor))) => {
+                let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
                 let screen = monitor.ui_screen(mtm);
                 this.setScreen(screen);
             },
@@ -303,6 +306,7 @@ impl Inner {
         let mtm = MainThreadMarker::new().unwrap();
         let uiscreen = match &monitor {
             Some(Fullscreen::Exclusive(monitor, video_mode)) => {
+                let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
                 let uiscreen = monitor.ui_screen(mtm);
                 if let Some(video_mode) =
                     monitor.video_modes_handles().find(|mode| &mode.mode == video_mode)
@@ -311,7 +315,9 @@ impl Inner {
                 }
                 uiscreen.clone()
             },
-            Some(Fullscreen::Borderless(Some(monitor))) => monitor.ui_screen(mtm).clone(),
+            Some(Fullscreen::Borderless(Some(monitor))) => {
+                monitor.cast_ref::<MonitorHandle>().unwrap().ui_screen(mtm).clone()
+            },
             Some(Fullscreen::Borderless(None)) => {
                 self.current_monitor_inner().ui_screen(mtm).clone()
             },
@@ -349,7 +355,7 @@ impl Inner {
             && screen_space_bounds.size.width == screen_bounds.size.width
             && screen_space_bounds.size.height == screen_bounds.size.height
         {
-            Some(Fullscreen::Borderless(Some(monitor)))
+            Some(Fullscreen::Borderless(Some(CoreMonitorHandle(Arc::new(monitor)))))
         } else {
             None
         }
@@ -459,6 +465,7 @@ impl Inner {
     }
 }
 
+#[derive(Debug)]
 pub struct Window {
     inner: MainThreadBound<Inner>,
 }
@@ -481,10 +488,13 @@ impl Window {
 
         #[allow(deprecated)]
         let main_screen = UIScreen::mainScreen(mtm);
-        let fullscreen = window_attributes.fullscreen.clone().map(Into::into);
+        let fullscreen = window_attributes.fullscreen.clone();
         let screen = match fullscreen {
-            Some(Fullscreen::Exclusive(ref monitor, _)) => monitor.ui_screen(mtm),
-            Some(Fullscreen::Borderless(Some(ref monitor))) => monitor.ui_screen(mtm),
+            Some(Fullscreen::Exclusive(ref monitor, _))
+            | Some(Fullscreen::Borderless(Some(ref monitor))) => {
+                let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
+                monitor.ui_screen(mtm)
+            },
             Some(Fullscreen::Borderless(None)) | None => &main_screen,
         };
 
@@ -669,12 +679,12 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.is_maximized())
     }
 
-    fn set_fullscreen(&self, fullscreen: Option<crate::window::Fullscreen>) {
-        self.maybe_wait_on_main(|delegate| delegate.set_fullscreen(fullscreen.map(Into::into)))
+    fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_fullscreen(fullscreen))
     }
 
-    fn fullscreen(&self) -> Option<crate::window::Fullscreen> {
-        self.maybe_wait_on_main(|delegate| delegate.fullscreen().map(Into::into))
+    fn fullscreen(&self) -> Option<Fullscreen> {
+        self.maybe_wait_on_main(|delegate| delegate.fullscreen())
     }
 
     fn set_decorations(&self, decorations: bool) {
@@ -770,21 +780,24 @@ impl CoreWindow for Window {
 
     fn current_monitor(&self) -> Option<CoreMonitorHandle> {
         self.maybe_wait_on_main(|delegate| {
-            delegate.current_monitor().map(|inner| CoreMonitorHandle { inner })
+            delegate.current_monitor().map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
         })
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         self.maybe_wait_on_main(|delegate| {
             Box::new(
-                delegate.available_monitors().into_iter().map(|inner| CoreMonitorHandle { inner }),
+                delegate
+                    .available_monitors()
+                    .into_iter()
+                    .map(|monitor| CoreMonitorHandle(Arc::new(monitor))),
             )
         })
     }
 
     fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
         self.maybe_wait_on_main(|delegate| {
-            delegate.primary_monitor().map(|inner| CoreMonitorHandle { inner })
+            delegate.primary_monitor().map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
         })
     }
 

src/platform_impl/linux/common/xkb/keymap.rs

@@ -166,8 +166,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         122 => KeyCode::Lang1,
         123 => KeyCode::Lang2,
         124 => KeyCode::IntlYen,
-        125 => KeyCode::SuperLeft,
-        126 => KeyCode::SuperRight,
+        125 => KeyCode::MetaLeft,
+        126 => KeyCode::MetaRight,
         127 => KeyCode::ContextMenu,
         128 => KeyCode::BrowserStop,
         129 => KeyCode::Again,
@@ -419,8 +419,8 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
         KeyCode::Lang1 => Some(122),
         KeyCode::Lang2 => Some(123),
         KeyCode::IntlYen => Some(124),
-        KeyCode::SuperLeft => Some(125),
-        KeyCode::SuperRight => Some(126),
+        KeyCode::MetaLeft => Some(125),
+        KeyCode::MetaRight => Some(126),
         KeyCode::ContextMenu => Some(127),
         KeyCode::BrowserStop => Some(128),
         KeyCode::Again => Some(129),
@@ -622,16 +622,20 @@ pub fn keysym_to_key(keysym: u32) -> Key {
         keysyms::Control_R => NamedKey::Control,
         keysyms::Caps_Lock => NamedKey::CapsLock,
         // keysyms::Shift_Lock => NamedKey::ShiftLock,
-
-        // keysyms::Meta_L => NamedKey::Meta,
-        // keysyms::Meta_R => NamedKey::Meta,
         keysyms::Alt_L => NamedKey::Alt,
         keysyms::Alt_R => NamedKey::Alt,
-        keysyms::Super_L => NamedKey::Super,
-        keysyms::Super_R => NamedKey::Super,
+        #[allow(deprecated)]
         keysyms::Hyper_L => NamedKey::Hyper,
+        #[allow(deprecated)]
         keysyms::Hyper_R => NamedKey::Hyper,
 
+        // Browsers map X11's Super keys to Meta, so we do that as well.
+        keysyms::Super_L => NamedKey::Meta,
+        keysyms::Super_R => NamedKey::Meta,
+        // The actual Meta keys do not seem to be used by browsers, so we don't do that either.
+        // keysyms::Meta_L => NamedKey::Super,
+        // keysyms::Meta_R => NamedKey::Super,
+
         // XKB function and modifier keys
         // keysyms::ISO_Lock => NamedKey::IsoLock,
         // keysyms::ISO_Level2_Latch => NamedKey::IsoLevel2Latch,
@@ -724,7 +728,7 @@ pub fn keysym_to_key(keysym: u32) -> Key {
         keysyms::_3270_PrintScreen => NamedKey::PrintScreen,
         keysyms::_3270_Enter => NamedKey::Enter,
 
-        keysyms::space => NamedKey::Space,
+        keysyms::space => return Key::Character(" ".into()),
         // exclam..Sinh_kunddaliya
 
         // XFree86

src/platform_impl/linux/common/xkb/state.rs

@@ -183,7 +183,7 @@ impl From<ModifiersState> for crate::keyboard::ModifiersState {
         to_mods.set(crate::keyboard::ModifiersState::SHIFT, mods.shift);
         to_mods.set(crate::keyboard::ModifiersState::CONTROL, mods.ctrl);
         to_mods.set(crate::keyboard::ModifiersState::ALT, mods.alt);
-        to_mods.set(crate::keyboard::ModifiersState::SUPER, mods.logo);
+        to_mods.set(crate::keyboard::ModifiersState::META, mods.logo);
         to_mods
     }
 }

src/platform_impl/linux/mod.rs

@@ -6,26 +6,16 @@ compile_error!("Please select a feature to build for unix: `x11`, `wayland`");
 use std::env;
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::time::Duration;
-#[cfg(x11_platform)]
-use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Arc, sync::Mutex};
 
 pub(crate) use self::common::xkb::{physicalkey_to_scancode, scancode_to_physicalkey};
-#[cfg(x11_platform)]
-use self::x11::{XConnection, XError, XNotSupported};
 use crate::application::ApplicationHandler;
-pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
-use crate::dpi::PhysicalPosition;
 #[cfg(x11_platform)]
 use crate::dpi::Size;
 use crate::error::{EventLoopError, NotSupportedError};
 use crate::event_loop::ActiveEventLoop;
-pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
-use crate::monitor::VideoMode;
 use crate::platform::pump_events::PumpStatus;
 #[cfg(x11_platform)]
-use crate::platform::x11::{WindowType as XWindowType, XlibErrorHook};
-#[cfg(x11_platform)]
-use crate::utils::Lazy;
+use crate::platform::x11::WindowType as XWindowType;
 use crate::window::ActivationToken;
 
 pub(crate) mod common;
@@ -100,18 +90,6 @@ impl Default for PlatformSpecificWindowAttributes {
     }
 }
 
-#[cfg(x11_platform)]
-pub(crate) static X11_BACKEND: Lazy<Mutex<Result<Arc<XConnection>, XNotSupported>>> =
-    Lazy::new(|| Mutex::new(XConnection::new(Some(x_error_callback)).map(Arc::new)));
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum MonitorHandle {
-    #[cfg(x11_platform)]
-    X(x11::MonitorHandle),
-    #[cfg(wayland_platform)]
-    Wayland(wayland::MonitorHandle),
-}
-
 /// `x11_or_wayland!(match expr; Enum(foo) => foo.something())`
 /// expands to the equivalent of
 /// ```ignore
@@ -140,97 +118,7 @@ macro_rules! x11_or_wayland {
     };
 }
 
-impl MonitorHandle {
-    #[inline]
-    pub fn name(&self) -> Option<String> {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.name())
-    }
-
-    #[inline]
-    pub fn native_identifier(&self) -> u32 {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.native_identifier())
-    }
-
-    #[inline]
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.position())
-    }
-
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.scale_factor() as _)
-    }
-
-    #[inline]
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.current_video_mode())
-    }
-
-    #[inline]
-    pub fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
-        x11_or_wayland!(match self; MonitorHandle(m) => Box::new(m.video_modes()))
-    }
-}
-
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub(crate) enum PlatformCustomCursor {
-    #[cfg(wayland_platform)]
-    Wayland(wayland::CustomCursor),
-    #[cfg(x11_platform)]
-    X(x11::CustomCursor),
-}
-
-/// Hooks for X11 errors.
-#[cfg(x11_platform)]
-pub(crate) static XLIB_ERROR_HOOKS: Mutex<Vec<XlibErrorHook>> = Mutex::new(Vec::new());
-
-#[cfg(x11_platform)]
-unsafe extern "C" fn x_error_callback(
-    display: *mut x11::ffi::Display,
-    event: *mut x11::ffi::XErrorEvent,
-) -> c_int {
-    let xconn_lock = X11_BACKEND.lock().unwrap_or_else(|e| e.into_inner());
-    if let Ok(ref xconn) = *xconn_lock {
-        // Call all the hooks.
-        let mut error_handled = false;
-        for hook in XLIB_ERROR_HOOKS.lock().unwrap().iter() {
-            error_handled |= hook(display as *mut _, event as *mut _);
-        }
-
-        // `assume_init` is safe here because the array consists of `MaybeUninit` values,
-        // which do not require initialization.
-        let mut buf: [MaybeUninit<c_char>; 1024] = unsafe { MaybeUninit::uninit().assume_init() };
-        unsafe {
-            (xconn.xlib.XGetErrorText)(
-                display,
-                (*event).error_code as c_int,
-                buf.as_mut_ptr() as *mut c_char,
-                buf.len() as c_int,
-            )
-        };
-        let description =
-            unsafe { CStr::from_ptr(buf.as_ptr() as *const c_char) }.to_string_lossy();
-
-        let error = unsafe {
-            XError {
-                description: description.into_owned(),
-                error_code: (*event).error_code,
-                request_code: (*event).request_code,
-                minor_code: (*event).minor_code,
-            }
-        };
-
-        // Don't log error.
-        if !error_handled {
-            tracing::error!("X11 error: {:#?}", error);
-            // XXX only update the error, if it wasn't handled by any of the hooks.
-            *xconn.latest_error.lock().unwrap() = Some(error);
-        }
-    }
-    // Fun fact: this return value is completely ignored.
-    0
-}
-
+#[derive(Debug)]
 pub enum EventLoop {
     #[cfg(wayland_platform)]
     Wayland(Box<wayland::EventLoop>),
@@ -303,12 +191,7 @@ impl EventLoop {
 
     #[cfg(x11_platform)]
     fn new_x11_any_thread() -> Result<EventLoop, EventLoopError> {
-        let xconn = match X11_BACKEND.lock().unwrap_or_else(|e| e.into_inner()).as_ref() {
-            Ok(xconn) => xconn.clone(),
-            Err(err) => return Err(os_error!(err.clone()).into()),
-        };
-
-        Ok(EventLoop::X(x11::EventLoop::new(xconn)))
+        x11::EventLoop::new().map(EventLoop::X)
     }
 
     #[inline]

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

@@ -3,27 +3,33 @@
 use std::cell::{Cell, RefCell};
 use std::io::Result as IOResult;
 use std::mem;
+use std::os::fd::OwnedFd;
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::atomic::Ordering;
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 
+use calloop::ping::Ping;
+use rustix::event::{PollFd, PollFlags};
+use rustix::pipe::{self, PipeFlags};
 use sctk::reexports::calloop_wayland_source::WaylandSource;
 use sctk::reexports::client::{globals, Connection, QueueHandle};
+use tracing::warn;
 
 use crate::application::ApplicationHandler;
-use crate::cursor::OnlyCursorImage;
 use crate::dpi::LogicalSize;
-use crate::error::{EventLoopError, OsError, RequestError};
+use crate::error::{EventLoopError, NotSupportedError, OsError, RequestError};
 use crate::event::{DeviceEvent, StartCause, SurfaceSizeWriter, WindowEvent};
 use crate::event_loop::{
     ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
     OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
+use crate::monitor::MonitorHandle as CoreMonitorHandle;
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::platform::min_timeout;
-use crate::platform_impl::PlatformCustomCursor;
-use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme};
+use crate::platform_impl::wayland::types::cursor::WaylandCustomCursor;
+use crate::window::{CustomCursor as CoreCustomCursor, CustomCursorSource, Theme};
 
 mod proxy;
 pub mod sink;
@@ -31,6 +37,7 @@ pub mod sink;
 use proxy::EventLoopProxy;
 use sink::EventSink;
 
+use super::output::MonitorHandle;
 use super::state::{WindowCompositorUpdate, WinitState};
 use super::window::state::FrameCallbackState;
 use super::{logical_to_physical_rounded, WindowId};
@@ -45,6 +52,7 @@ pub(crate) enum Event {
 }
 
 /// The Wayland event loop.
+#[derive(Debug)]
 pub struct EventLoop {
     /// Has `run` or `run_on_demand` been called or a call to `pump_events` that starts the loop
     loop_running: bool,
@@ -66,6 +74,8 @@ pub struct EventLoop {
     // XXX drop after everything else, just to be safe.
     /// Calloop's event loop.
     event_loop: calloop::EventLoop<'static, WinitState>,
+
+    pump_event_notifier: Option<PumpEventNotifier>,
 }
 
 impl EventLoop {
@@ -147,6 +157,7 @@ impl EventLoop {
             wayland_dispatcher,
             event_loop,
             active_event_loop,
+            pump_event_notifier: None,
         };
 
         Ok(event_loop)
@@ -201,13 +212,27 @@ impl EventLoop {
         if !self.exiting() {
             self.poll_events_with_timeout(timeout, &mut app);
         }
+
         if let Some(code) = self.exit_code() {
             self.loop_running = false;
 
-            app.exiting(&self.active_event_loop);
-
             PumpStatus::Exit(code)
         } else {
+            // NOTE: spawn a wake-up thread, thus if we have code reading the wayland connection
+            // in parallel to winit, we ensure that the loop itself is marked as having events.
+            if timeout.is_some() && self.pump_event_notifier.is_none() {
+                self.pump_event_notifier = Some(PumpEventNotifier::spawn(
+                    self.active_event_loop.handle.connection.clone(),
+                    self.active_event_loop.event_loop_awakener.clone(),
+                ));
+            }
+
+            if let Some(pump_event_notifier) = self.pump_event_notifier.as_ref() {
+                // Notify that we don't have to wait, since we're out of winit.
+                *pump_event_notifier.control.0.lock().unwrap() = PumpEventNotifierAction::Monitor;
+                pump_event_notifier.control.1.notify_one();
+            }
+
             PumpStatus::Continue
         }
     }
@@ -271,7 +296,10 @@ impl EventLoop {
 
             // Reduce spurious wake-ups.
             let dispatched_events = self.with_state(|state| state.dispatched_events);
-            if matches!(cause, StartCause::WaitCancelled { .. }) && !dispatched_events {
+            if matches!(cause, StartCause::WaitCancelled { .. })
+                && !dispatched_events
+                && timeout.is_none()
+            {
                 continue;
             }
 
@@ -546,12 +574,13 @@ impl AsRawFd for EventLoop {
     }
 }
 
+#[derive(Debug)]
 pub struct ActiveEventLoop {
     /// Event loop proxy
     event_loop_proxy: CoreEventLoopProxy,
 
     /// The event loop wakeup source.
-    pub event_loop_awakener: calloop::ping::Ping,
+    pub event_loop_awakener: Ping,
 
     /// The main queue used by the event loop.
     pub queue_handle: QueueHandle<WinitState>,
@@ -600,10 +629,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_custom_cursor(
         &self,
         cursor: CustomCursorSource,
-    ) -> Result<RootCustomCursor, RequestError> {
-        Ok(RootCustomCursor {
-            inner: PlatformCustomCursor::Wayland(OnlyCursorImage(Arc::from(cursor.inner.0))),
-        })
+    ) -> Result<CoreCustomCursor, RequestError> {
+        let cursor_image = match cursor {
+            CustomCursorSource::Image(cursor_image) => cursor_image,
+            CustomCursorSource::Animation { .. } | CustomCursorSource::Url { .. } => {
+                return Err(NotSupportedError::new("unsupported cursor kind").into())
+            },
+        };
+
+        Ok(CoreCustomCursor(Arc::new(WaylandCustomCursor(cursor_image))))
     }
 
     #[inline]
@@ -619,19 +653,18 @@ impl RootActiveEventLoop for ActiveEventLoop {
         Ok(Box::new(window))
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = crate::monitor::MonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         Box::new(
             self.state
                 .borrow()
                 .output_state
                 .outputs()
-                .map(crate::platform_impl::wayland::output::MonitorHandle::new)
-                .map(crate::platform_impl::MonitorHandle::Wayland)
-                .map(|inner| crate::monitor::MonitorHandle { inner }),
+                .map(MonitorHandle::new)
+                .map(|inner| CoreMonitorHandle(Arc::new(inner))),
         )
     }
 
-    fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
         // There's no primary monitor on Wayland.
         None
     }
@@ -665,6 +698,7 @@ impl rwh_06::HasDisplayHandle for ActiveEventLoop {
     }
 }
 
+#[derive(Debug)]
 pub struct OwnedDisplayHandle {
     pub(crate) connection: Connection,
 }
@@ -687,3 +721,84 @@ impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
         Ok(unsafe { rwh_06::DisplayHandle::borrow_raw(raw.into()) })
     }
 }
+
+#[derive(Debug)]
+struct PumpEventNotifier {
+    /// Whether we're in winit or not.
+    control: Arc<(Mutex<PumpEventNotifierAction>, Condvar)>,
+    /// Waker handle for the working thread.
+    worker_waker: Option<OwnedFd>,
+    /// Thread handle.
+    handle: Option<JoinHandle<()>>,
+}
+
+impl Drop for PumpEventNotifier {
+    fn drop(&mut self) {
+        // Wake-up the thread.
+        if let Some(worker_waker) = self.worker_waker.as_ref() {
+            let _ = rustix::io::write(worker_waker.as_fd(), &[0u8]);
+        }
+        *self.control.0.lock().unwrap() = PumpEventNotifierAction::Monitor;
+        self.control.1.notify_one();
+
+        if let Some(handle) = self.handle.take() {
+            let _ = handle.join();
+        }
+    }
+}
+
+impl PumpEventNotifier {
+    fn spawn(connection: Connection, awakener: Ping) -> Self {
+        // Start from the waiting state.
+        let control = Arc::new((Mutex::new(PumpEventNotifierAction::Pause), Condvar::new()));
+        let control_thread = Arc::clone(&control);
+
+        let (read, write) = match pipe::pipe_with(PipeFlags::CLOEXEC | PipeFlags::NONBLOCK) {
+            Ok((read, write)) => (read, write),
+            Err(_) => return Self { control, handle: None, worker_waker: None },
+        };
+
+        let handle =
+            std::thread::Builder::new().name(String::from("pump_events mon")).spawn(move || {
+                let (lock, cvar) = &*control_thread;
+                'outer: loop {
+                    let mut wait = lock.lock().unwrap();
+                    while *wait == PumpEventNotifierAction::Pause {
+                        wait = cvar.wait(wait).unwrap();
+                    }
+                    // Wake-up the main loop and put this one back to sleep.
+                    *wait = PumpEventNotifierAction::Pause;
+                    drop(wait);
+
+                    while let Some(read_guard) = connection.prepare_read() {
+                        let _ = connection.flush();
+                        let poll_fd = PollFd::from_borrowed_fd(connection.as_fd(), PollFlags::IN);
+                        let pipe_poll_fd = PollFd::from_borrowed_fd(read.as_fd(), PollFlags::IN);
+                        // Read from the `fd` before going back to poll.
+                        if Ok(1) == rustix::io::read(read.as_fd(), &mut [0u8; 1]) {
+                            break 'outer;
+                        }
+                        let _ = rustix::event::poll(&mut [poll_fd, pipe_poll_fd], -1);
+                        // Non-blocking read the connection.
+                        let _ = read_guard.read_without_dispatch();
+                    }
+
+                    awakener.ping();
+                }
+            });
+
+        if let Some(err) = handle.as_ref().err() {
+            warn!("failed to spawn pump_events wake-up thread: {err}");
+        }
+
+        PumpEventNotifier { control, handle: handle.ok(), worker_waker: Some(write) }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum PumpEventNotifierAction {
+    /// Monitor the wayland queue.
+    Monitor,
+    /// Pause monitoring.
+    Pause,
+}

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

@@ -7,6 +7,7 @@ use sctk::reexports::calloop::ping::Ping;
 use crate::event_loop::{EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider};
 
 /// A handle that can be sent across the threads and used to wake up the `EventLoop`.
+#[derive(Debug)]
 pub struct EventLoopProxy {
     ping: Ping,
 }

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

@@ -8,7 +8,7 @@ use crate::window::WindowId;
 
 /// An event loop's sink to deliver events from the Wayland event callbacks
 /// to the winit's user.
-#[derive(Default)]
+#[derive(Default, Debug)]
 pub struct EventSink {
     pub(crate) window_events: Vec<Event>,
 }

src/platform_impl/linux/wayland/mod.rs

@@ -1,12 +1,8 @@
 //! Winit's Wayland backend.
 
-pub use event_loop::{ActiveEventLoop, EventLoop};
-pub use output::MonitorHandle;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::Proxy;
-pub use window::Window;
 
-pub(super) use crate::cursor::OnlyCursorImage as CustomCursor;
 use crate::dpi::{LogicalSize, PhysicalSize};
 use crate::window::WindowId;
 
@@ -17,6 +13,9 @@ mod state;
 mod types;
 mod window;
 
+pub use event_loop::{ActiveEventLoop, EventLoop};
+pub use window::Window;
+
 /// Get the WindowId out of the surface.
 #[inline]
 fn make_wid(surface: &WlSurface) -> WindowId {

src/platform_impl/linux/wayland/output.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::num::NonZeroU32;
 
 use sctk::output::{Mode, OutputData};
@@ -5,7 +6,7 @@ use sctk::reexports::client::protocol::wl_output::WlOutput;
 use sctk::reexports::client::Proxy;
 
 use crate::dpi::{LogicalPosition, PhysicalPosition};
-use crate::monitor::VideoMode;
+use crate::monitor::{MonitorHandleProvider as CoreMonitorHandle, VideoMode};
 
 #[derive(Clone, Debug)]
 pub struct MonitorHandle {
@@ -17,21 +18,24 @@ impl MonitorHandle {
     pub(crate) fn new(proxy: WlOutput) -> Self {
         Self { proxy }
     }
+}
 
-    #[inline]
-    pub fn name(&self) -> Option<String> {
-        let output_data = self.proxy.data::<OutputData>().unwrap();
-        output_data.with_output_info(|info| info.name.clone())
+impl CoreMonitorHandle for MonitorHandle {
+    fn id(&self) -> u128 {
+        self.native_id() as _
     }
 
-    #[inline]
-    pub fn native_identifier(&self) -> u32 {
+    fn native_id(&self) -> u64 {
         let output_data = self.proxy.data::<OutputData>().unwrap();
-        output_data.with_output_info(|info| info.id)
+        output_data.with_output_info(|info| info.id as u64)
     }
 
-    #[inline]
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
+    fn name(&self) -> Option<Cow<'_, str>> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.with_output_info(|info| info.name.clone().map(Cow::Owned))
+    }
+
+    fn position(&self) -> Option<PhysicalPosition<i32>> {
         let output_data = self.proxy.data::<OutputData>().unwrap();
         Some(output_data.with_output_info(|info| {
             info.logical_position.map_or_else(
@@ -47,56 +51,37 @@ impl MonitorHandle {
         }))
     }
 
-    #[inline]
-    pub fn scale_factor(&self) -> i32 {
+    fn scale_factor(&self) -> f64 {
         let output_data = self.proxy.data::<OutputData>().unwrap();
-        output_data.scale_factor()
+        output_data.scale_factor() as f64
     }
 
-    #[inline]
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
+    fn current_video_mode(&self) -> Option<crate::monitor::VideoMode> {
         let output_data = self.proxy.data::<OutputData>().unwrap();
         output_data.with_output_info(|info| {
             let mode = info.modes.iter().find(|mode| mode.current).cloned();
+
             mode.map(wayland_mode_to_core_mode)
         })
     }
 
-    #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
+    fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
         let output_data = self.proxy.data::<OutputData>().unwrap();
         let modes = output_data.with_output_info(|info| info.modes.clone());
-        modes.into_iter().map(wayland_mode_to_core_mode)
+
+        Box::new(modes.into_iter().map(wayland_mode_to_core_mode))
     }
 }
 
 impl PartialEq for MonitorHandle {
     fn eq(&self, other: &Self) -> bool {
-        self.native_identifier() == other.native_identifier()
+        self.native_id() == other.native_id()
     }
 }
 
 impl Eq for MonitorHandle {}
 
-impl PartialOrd for MonitorHandle {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for MonitorHandle {
-    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
-        self.native_identifier().cmp(&other.native_identifier())
-    }
-}
-
-impl std::hash::Hash for MonitorHandle {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.native_identifier().hash(state);
-    }
-}
-
-/// Convert Wayland's [`Mode`] to winit's [`VideoMode`].
+/// Convert the wayland's [`Mode`] to winit's [`VideoMode`].
 fn wayland_mode_to_core_mode(mode: Mode) -> VideoMode {
     VideoMode {
         size: (mode.dimensions.0, mode.dimensions.1).into(),

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

@@ -96,8 +96,12 @@ impl SeatHandler for WinitState {
             },
             SeatCapability::Pointer if seat_state.pointer.is_none() => {
                 let surface = self.compositor_state.create_surface(queue_handle);
+                let viewport = self
+                    .viewporter_state
+                    .as_ref()
+                    .map(|state| state.get_viewport(&surface, queue_handle));
                 let surface_id = surface.id();
-                let pointer_data = WinitPointerData::new(seat.clone());
+                let pointer_data = WinitPointerData::new(seat.clone(), viewport);
                 let themed_pointer = self
                     .seat_state
                     .get_pointer_with_theme_and_data(

src/platform_impl/linux/wayland/seat/pointer/mod.rs

@@ -18,6 +18,7 @@ use sctk::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_ma
 use sctk::reexports::protocols::wp::pointer_constraints::zv1::client::zwp_pointer_constraints_v1::{Lifetime, ZwpPointerConstraintsV1};
 use sctk::reexports::client::globals::{BindError, GlobalList};
 use sctk::reexports::csd_frame::FrameClick;
+use sctk::reexports::protocols::wp::viewporter::client::wp_viewport::WpViewport;
 
 use sctk::compositor::SurfaceData;
 use sctk::globals::GlobalData;
@@ -246,13 +247,17 @@ pub struct WinitPointerData {
 
     /// The data required by the sctk.
     sctk_data: PointerData,
+
+    /// Viewport for fractional cursor.
+    viewport: Option<WpViewport>,
 }
 
 impl WinitPointerData {
-    pub fn new(seat: WlSeat) -> Self {
+    pub fn new(seat: WlSeat, viewport: Option<WpViewport>) -> Self {
         Self {
             inner: Mutex::new(WinitPointerDataInner::default()),
             sctk_data: PointerData::new(seat),
+            viewport,
         }
     }
 
@@ -333,6 +338,18 @@ impl WinitPointerData {
             locked_pointer.set_cursor_position_hint(surface_x, surface_y);
         }
     }
+
+    pub fn viewport(&self) -> Option<&WpViewport> {
+        self.viewport.as_ref()
+    }
+}
+
+impl Drop for WinitPointerData {
+    fn drop(&mut self) {
+        if let Some(viewport) = self.viewport.take() {
+            viewport.destroy();
+        }
+    }
 }
 
 impl PointerDataExt for WinitPointerData {
@@ -414,6 +431,7 @@ impl WinitPointerDataExt for WlPointer {
     }
 }
 
+#[derive(Debug)]
 pub struct PointerConstraintsState {
     pointer_constraints: ZwpPointerConstraintsV1,
 }

src/platform_impl/linux/wayland/seat/pointer/relative_pointer.rs

@@ -16,6 +16,7 @@ use crate::event::DeviceEvent;
 use crate::platform_impl::wayland::state::WinitState;
 
 /// Wrapper around the relative pointer.
+#[derive(Debug)]
 pub struct RelativePointerState {
     manager: ZwpRelativePointerManagerV1,
 }

src/platform_impl/linux/wayland/seat/text_input/mod.rs

@@ -14,6 +14,7 @@ use crate::platform_impl::wayland;
 use crate::platform_impl::wayland::state::WinitState;
 use crate::window::ImePurpose;
 
+#[derive(Debug)]
 pub struct TextInputState {
     text_input_manager: ZwpTextInputManagerV3,
 }

src/platform_impl/linux/wayland/state.rs

@@ -36,6 +36,7 @@ use crate::platform_impl::wayland::window::{WindowRequests, WindowState};
 use crate::platform_impl::wayland::WindowId;
 
 /// Winit's Wayland state.
+#[derive(Debug)]
 pub struct WinitState {
     /// The WlRegistry.
     pub registry_state: RegistryState,

src/platform_impl/linux/wayland/types/cursor.rs

@@ -2,7 +2,16 @@ use cursor_icon::CursorIcon;
 use sctk::reexports::client::protocol::wl_shm::Format;
 use sctk::shm::slot::{Buffer, SlotPool};
 
-use crate::cursor::CursorImage;
+use crate::cursor::{CursorImage, CustomCursorProvider};
+
+// Wrap in our own type to not impl trait on global type.
+#[derive(Debug)]
+pub struct WaylandCustomCursor(pub(crate) CursorImage);
+impl CustomCursorProvider for WaylandCustomCursor {
+    fn is_animated(&self) -> bool {
+        false
+    }
+}
 
 #[derive(Debug)]
 pub enum SelectedCursor {
@@ -26,7 +35,8 @@ pub struct CustomCursor {
 }
 
 impl CustomCursor {
-    pub(crate) fn new(pool: &mut SlotPool, image: &CursorImage) -> Self {
+    pub(crate) fn new(pool: &mut SlotPool, image: &WaylandCustomCursor) -> Self {
+        let image = &image.0;
         let (buffer, canvas) = pool
             .create_buffer(
                 image.width as i32,

src/platform_impl/linux/wayland/types/xdg_activation.rs

@@ -16,6 +16,7 @@ use crate::event_loop::AsyncRequestSerial;
 use crate::platform_impl::wayland::state::WinitState;
 use crate::window::{ActivationToken, WindowId};
 
+#[derive(Debug)]
 pub struct XdgActivationState {
     xdg_activation: XdgActivationV1,
 }

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

@@ -1,5 +1,7 @@
 //! The Wayland window.
 
+use std::ffi::c_void;
+use std::ptr::NonNull;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 
@@ -21,12 +23,11 @@ use crate::dpi::{LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize, Po
 use crate::error::{NotSupportedError, RequestError};
 use crate::event::{Ime, WindowEvent};
 use crate::event_loop::AsyncRequestSerial;
-use crate::monitor::MonitorHandle as CoreMonitorHandle;
-use crate::platform_impl::{Fullscreen, MonitorHandle as PlatformMonitorHandle};
+use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
+use crate::platform_impl::wayland::output;
 use crate::window::{
-    Cursor, CursorGrabMode, Fullscreen as CoreFullscreen, ImePurpose, ResizeDirection, Theme,
-    UserAttentionType, Window as CoreWindow, WindowAttributes, WindowButtons, WindowId,
-    WindowLevel,
+    Cursor, CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType,
+    Window as CoreWindow, WindowAttributes, WindowButtons, WindowId, WindowLevel,
 };
 
 pub(crate) mod state;
@@ -34,6 +35,7 @@ pub(crate) mod state;
 pub use state::WindowState;
 
 /// The Wayland window.
+#[derive(Debug)]
 pub struct Window {
     /// Reference to the underlying SCTK window.
     window: SctkWindow,
@@ -138,19 +140,17 @@ impl Window {
         window_state.set_resizable(attributes.resizable);
 
         // Set startup mode.
-        match attributes.fullscreen.map(Into::into) {
+        match attributes.fullscreen {
             Some(Fullscreen::Exclusive(..)) => {
                 warn!("`Fullscreen::Exclusive` is ignored on Wayland");
             },
             #[cfg_attr(not(x11_platform), allow(clippy::bind_instead_of_map))]
             Some(Fullscreen::Borderless(monitor)) => {
-                let output = monitor.and_then(|monitor| match monitor {
-                    PlatformMonitorHandle::Wayland(monitor) => Some(monitor.proxy),
-                    #[cfg(x11_platform)]
-                    PlatformMonitorHandle::X(_) => None,
+                let output = monitor.as_ref().and_then(|monitor| {
+                    monitor.cast_ref::<output::MonitorHandle>().map(|handle| &handle.proxy)
                 });
 
-                window.set_fullscreen(output.as_ref())
+                window.set_fullscreen(output)
             },
             _ if attributes.maximized => window.set_maximized(),
             _ => (),
@@ -216,6 +216,10 @@ impl Window {
             window_events_sink,
         })
     }
+
+    pub(crate) fn xdg_toplevel(&self) -> Option<NonNull<c_void>> {
+        NonNull::new(self.window.xdg_toplevel().id().as_ptr().cast())
+    }
 }
 
 impl Window {
@@ -436,26 +440,24 @@ impl CoreWindow for Window {
             .unwrap_or_default()
     }
 
-    fn set_fullscreen(&self, fullscreen: Option<CoreFullscreen>) {
+    fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
         match fullscreen {
-            Some(CoreFullscreen::Exclusive(..)) => {
+            Some(Fullscreen::Exclusive(..)) => {
                 warn!("`Fullscreen::Exclusive` is ignored on Wayland");
             },
             #[cfg_attr(not(x11_platform), allow(clippy::bind_instead_of_map))]
-            Some(CoreFullscreen::Borderless(monitor)) => {
-                let output = monitor.and_then(|monitor| match monitor.inner {
-                    PlatformMonitorHandle::Wayland(monitor) => Some(monitor.proxy),
-                    #[cfg(x11_platform)]
-                    PlatformMonitorHandle::X(_) => None,
+            Some(Fullscreen::Borderless(monitor)) => {
+                let output = monitor.as_ref().and_then(|monitor| {
+                    monitor.cast_ref::<output::MonitorHandle>().map(|handle| &handle.proxy)
                 });
 
-                self.window.set_fullscreen(output.as_ref())
+                self.window.set_fullscreen(output)
             },
             None => self.window.unset_fullscreen(),
         }
     }
 
-    fn fullscreen(&self) -> Option<CoreFullscreen> {
+    fn fullscreen(&self) -> Option<Fullscreen> {
         let is_fullscreen = self
             .window_state
             .lock()
@@ -467,7 +469,7 @@ impl CoreWindow for Window {
 
         if is_fullscreen {
             let current_monitor = self.current_monitor();
-            Some(CoreFullscreen::Borderless(current_monitor))
+            Some(Fullscreen::Borderless(current_monitor))
         } else {
             None
         }
@@ -627,8 +629,7 @@ impl CoreWindow for Window {
         data.outputs()
             .next()
             .map(MonitorHandle::new)
-            .map(crate::platform_impl::MonitorHandle::Wayland)
-            .map(|inner| CoreMonitorHandle { inner })
+            .map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
@@ -638,8 +639,7 @@ impl CoreWindow for Window {
                 .unwrap()
                 .clone()
                 .into_iter()
-                .map(crate::platform_impl::MonitorHandle::Wayland)
-                .map(|inner| CoreMonitorHandle { inner }),
+                .map(|inner| CoreMonitorHandle(Arc::new(inner))),
         )
     }
 

src/platform_impl/linux/wayland/window/state.rs

@@ -28,8 +28,8 @@ use sctk::subcompositor::SubcompositorState;
 use tracing::{info, warn};
 use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 
-use crate::cursor::CustomCursor as RootCustomCursor;
-use crate::dpi::{LogicalPosition, LogicalSize, PhysicalSize, Size};
+use crate::cursor::CustomCursor as CoreCustomCursor;
+use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Size};
 use crate::error::{NotSupportedError, RequestError};
 use crate::platform_impl::wayland::event_loop::OwnedDisplayHandle;
 use crate::platform_impl::wayland::logical_to_physical_rounded;
@@ -37,9 +37,10 @@ use crate::platform_impl::wayland::seat::{
     PointerConstraintsState, WinitPointerData, WinitPointerDataExt, ZwpTextInputV3Ext,
 };
 use crate::platform_impl::wayland::state::{WindowCompositorUpdate, WinitState};
-use crate::platform_impl::wayland::types::cursor::{CustomCursor, SelectedCursor};
+use crate::platform_impl::wayland::types::cursor::{
+    CustomCursor, SelectedCursor, WaylandCustomCursor,
+};
 use crate::platform_impl::wayland::types::kwin_blur::KWinBlurManager;
-use crate::platform_impl::PlatformCustomCursor;
 use crate::window::{CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, WindowId};
 
 #[cfg(feature = "sctk-adwaita")]
@@ -51,6 +52,7 @@ pub type WinitFrame = sctk::shell::xdg::fallback_frame::FallbackFrame<WinitState
 const MIN_WINDOW_SIZE: LogicalSize<u32> = LogicalSize::new(2, 1);
 
 /// The state of the window which is being updated from the [`WinitState`].
+#[derive(Debug)]
 pub struct WindowState {
     /// The connection to Wayland server.
     pub handle: Arc<OwnedDisplayHandle>,
@@ -220,9 +222,9 @@ impl WindowState {
     }
 
     /// Apply closure on the given pointer.
-    fn apply_on_pointer<F: Fn(&ThemedPointer<WinitPointerData>, &WinitPointerData)>(
+    fn apply_on_pointer<F: FnMut(&ThemedPointer<WinitPointerData>, &WinitPointerData)>(
         &self,
-        callback: F,
+        mut callback: F,
     ) {
         self.pointers.iter().filter_map(Weak::upgrade).for_each(|pointer| {
             let data = pointer.pointer().winit_data();
@@ -701,19 +703,18 @@ impl WindowState {
     }
 
     /// Set the custom cursor icon.
-    pub(crate) fn set_custom_cursor(&mut self, cursor: RootCustomCursor) {
-        let cursor = match cursor {
-            RootCustomCursor { inner: PlatformCustomCursor::Wayland(cursor) } => cursor.0,
-            #[cfg(x11_platform)]
-            RootCustomCursor { inner: PlatformCustomCursor::X(_) } => {
-                tracing::error!("passed a X11 cursor to Wayland backend");
+    pub(crate) fn set_custom_cursor(&mut self, cursor: CoreCustomCursor) {
+        let cursor = match cursor.cast_ref::<WaylandCustomCursor>() {
+            Some(cursor) => cursor,
+            None => {
+                tracing::error!("unrecognized cursor passed to Wayland backend");
                 return;
             },
         };
 
         let cursor = {
             let mut pool = self.custom_cursor_pool.lock().unwrap();
-            CustomCursor::new(&mut pool, &cursor)
+            CustomCursor::new(&mut pool, cursor)
         };
 
         if self.cursor_visible {
@@ -724,17 +725,26 @@ impl WindowState {
     }
 
     fn apply_custom_cursor(&self, cursor: &CustomCursor) {
-        self.apply_on_pointer(|pointer, _| {
+        self.apply_on_pointer(|pointer, data| {
             let surface = pointer.surface();
 
-            let scale = surface.data::<SurfaceData>().unwrap().surface_data().scale_factor();
+            let scale = if let Some(viewport) = data.viewport() {
+                let scale = self.scale_factor();
+                let size = PhysicalSize::new(cursor.w, cursor.h).to_logical(scale);
+                viewport.set_destination(size.width, size.height);
+                scale
+            } else {
+                let scale = surface.data::<SurfaceData>().unwrap().surface_data().scale_factor();
+                surface.set_buffer_scale(scale);
+                scale as f64
+            };
 
-            surface.set_buffer_scale(scale);
             surface.attach(Some(cursor.buffer.wl_buffer()), 0, 0);
             if surface.version() >= 4 {
                 surface.damage_buffer(0, 0, cursor.w, cursor.h);
             } else {
-                surface.damage(0, 0, cursor.w / scale, cursor.h / scale);
+                let size = PhysicalSize::new(cursor.w, cursor.h).to_logical(scale);
+                surface.damage(0, 0, size.width, size.height);
             }
             surface.commit();
 
@@ -744,12 +754,9 @@ impl WindowState {
                 .and_then(|data| data.pointer_data().latest_enter_serial())
                 .unwrap();
 
-            pointer.pointer().set_cursor(
-                serial,
-                Some(surface),
-                cursor.hotspot_x / scale,
-                cursor.hotspot_y / scale,
-            );
+            let hotspot =
+                PhysicalPosition::new(cursor.hotspot_x, cursor.hotspot_y).to_logical(scale);
+            pointer.pointer().set_cursor(serial, Some(surface), hotspot.x, hotspot.y);
         });
     }
 
@@ -829,34 +836,51 @@ impl WindowState {
             },
         };
 
-        // Replace the current mode.
-        let old_mode = std::mem::replace(&mut self.cursor_grab_mode.current_grab_mode, mode);
-
-        match old_mode {
-            CursorGrabMode::None => (),
+        let mut unset_old = false;
+        match self.cursor_grab_mode.current_grab_mode {
+            CursorGrabMode::None => unset_old = true,
             CursorGrabMode::Confined => self.apply_on_pointer(|_, data| {
                 data.unconfine_pointer();
+                unset_old = true;
             }),
             CursorGrabMode::Locked => {
-                self.apply_on_pointer(|_, data| data.unlock_pointer());
+                self.apply_on_pointer(|_, data| {
+                    data.unlock_pointer();
+                    unset_old = true;
+                });
             },
         }
 
+        // In case we haven't unset the old mode, it means that we don't have a cursor above
+        // the window, thus just wait for it to re-appear.
+        if !unset_old {
+            return Ok(());
+        }
+
+        let mut set_mode = false;
         let surface = self.window.wl_surface();
         match mode {
             CursorGrabMode::Locked => self.apply_on_pointer(|pointer, data| {
                 let pointer = pointer.pointer();
-                data.lock_pointer(pointer_constraints, surface, pointer, &self.queue_handle)
+                data.lock_pointer(pointer_constraints, surface, pointer, &self.queue_handle);
+                set_mode = true;
             }),
             CursorGrabMode::Confined => self.apply_on_pointer(|pointer, data| {
                 let pointer = pointer.pointer();
-                data.confine_pointer(pointer_constraints, surface, pointer, &self.queue_handle)
+                data.confine_pointer(pointer_constraints, surface, pointer, &self.queue_handle);
+                set_mode = true;
             }),
             CursorGrabMode::None => {
                 // Current lock/confine was already removed.
+                set_mode = true;
             },
         }
 
+        // Replace the current grab mode after we've ensure that it got updated.
+        if set_mode {
+            self.cursor_grab_mode.current_grab_mode = mode;
+        }
+
         Ok(())
     }
 
@@ -1097,7 +1121,7 @@ impl Drop for WindowState {
 }
 
 /// The state of the cursor grabs.
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 struct GrabState {
     /// The grab mode requested by the user.
     user_grab_mode: CursorGrabMode,

src/platform_impl/linux/x11/dnd.rs

@@ -39,6 +39,7 @@ impl From<io::Error> for DndDataParseError {
     }
 }
 
+#[derive(Debug)]
 pub struct Dnd {
     xconn: Arc<XConnection>,
     // Populated by XdndEnter event handler

src/platform_impl/linux/x11/event_processor.rs

@@ -45,6 +45,7 @@ pub const MAX_MOD_REPLAY_LEN: usize = 32;
 /// The X11 documentation states: "Keycodes lie in the inclusive range `[8, 255]`".
 const KEYCODE_OFFSET: u8 = 8;
 
+#[derive(Debug)]
 pub struct EventProcessor {
     pub dnd: Dnd,
     pub ime_receiver: ImeReceiver,
@@ -88,8 +89,8 @@ impl EventProcessor {
 
             let ime = ime.get_mut();
             match request {
-                ImeRequest::Position(window_id, x, y) => {
-                    ime.send_xim_spot(window_id, x, y);
+                ImeRequest::Area(window_id, x, y, w, h) => {
+                    ime.send_xim_area(window_id, x, y, w, h);
                 },
                 ImeRequest::Allow(window_id, allowed) => {
                     ime.set_ime_allowed(window_id, allowed);

src/platform_impl/linux/x11/ime/callbacks.rs

@@ -116,7 +116,7 @@ unsafe fn replace_im(inner: *mut ImeInner) -> Result<(), ReplaceImError> {
 
     let mut new_contexts = HashMap::new();
     for (window, old_context) in unsafe { (*inner).contexts.iter() } {
-        let spot = old_context.as_ref().map(|old_context| old_context.ic_spot);
+        let area = old_context.as_ref().map(|old_context| old_context.ic_area);
 
         // Check if the IME was allowed on that context.
         let is_allowed =
@@ -128,7 +128,7 @@ unsafe fn replace_im(inner: *mut ImeInner) -> Result<(), ReplaceImError> {
                     xconn,
                     &new_im,
                     *window,
-                    spot,
+                    area,
                     (*inner).event_sender.clone(),
                     is_allowed,
                 )

src/platform_impl/linux/x11/ime/context.rs

@@ -1,6 +1,5 @@
 use std::error::Error;
 use std::ffi::CStr;
-use std::os::raw::c_short;
 use std::sync::Arc;
 use std::{fmt, mem, ptr};
 
@@ -196,7 +195,7 @@ struct ImeContextClientData {
 // through `ImeInner`.
 pub struct ImeContext {
     pub(crate) ic: ffi::XIC,
-    pub(crate) ic_spot: ffi::XPoint,
+    pub(crate) ic_area: ffi::XRectangle,
     pub(crate) allowed: bool,
     // Since the data is passed shared between X11 XIM callbacks, but couldn't be directly free
     // from there we keep the pointer to automatically deallocate it.
@@ -208,7 +207,7 @@ impl ImeContext {
         xconn: &Arc<XConnection>,
         im: &InputMethod,
         window: ffi::Window,
-        ic_spot: Option<ffi::XPoint>,
+        ic_area: Option<ffi::XRectangle>,
         event_sender: ImeEventSender,
         allowed: bool,
     ) -> Result<Self, ImeContextCreationError> {
@@ -244,14 +243,14 @@ impl ImeContext {
 
         let mut context = ImeContext {
             ic,
-            ic_spot: ffi::XPoint { x: 0, y: 0 },
+            ic_area: ffi::XRectangle { x: 0, y: 0, width: 0, height: 0 },
             allowed,
             _client_data: unsafe { Box::from_raw(client_data) },
         };
 
-        // Set the spot location, if it's present.
-        if let Some(ic_spot) = ic_spot {
-            context.set_spot(xconn, ic_spot.x, ic_spot.y)
+        // Set the preedit cursor area, if it's present.
+        if let Some(ic_area) = ic_area {
+            context.set_area(xconn, ic_area.x, ic_area.y, ic_area.width, ic_area.height);
         }
 
         Ok(context)
@@ -355,17 +354,31 @@ impl ImeContext {
         self.allowed
     }
 
-    // Set the spot for preedit text. Setting spot isn't working with libX11 when preedit callbacks
-    // are being used. Certain IMEs do show selection window, but it's placed in bottom left of the
-    // window and couldn't be changed.
-    //
-    // For me see: https://bugs.freedesktop.org/show_bug.cgi?id=1580.
-    pub(crate) fn set_spot(&mut self, xconn: &Arc<XConnection>, x: c_short, y: c_short) {
-        if !self.is_allowed() || self.ic_spot.x == x && self.ic_spot.y == y {
+    /// Set the spot and area for preedit text.
+    ///
+    /// This functionality depends on the libx11 version.
+    ///  - Until libx11 1.8.2, XNSpotLocation was blocked by libx11 in On-The-Spot mode.
+    ///  - Until libx11 1.8.11, XNArea was blocked by libx11 in On-The-Spot mode.
+    ///
+    /// Use of this information is discretionary by input method servers,
+    /// and some may not use it by default, even if they have support.
+    pub(crate) fn set_area(
+        &mut self,
+        xconn: &Arc<XConnection>,
+        x: i16,
+        y: i16,
+        width: u16,
+        height: u16,
+    ) {
+        let ic_area = ffi::XRectangle { x, y, width, height };
+
+        if !self.is_allowed() || self.ic_area == ic_area {
             return;
         }
 
-        self.ic_spot = ffi::XPoint { x, y };
+        self.ic_area = ic_area;
+        let ic_spot =
+            ffi::XPoint { x: x.saturating_add(width as i16), y: y.saturating_add(height as i16) };
 
         unsafe {
             let preedit_attr = util::memory::XSmartPointer::new(
@@ -373,7 +386,9 @@ impl ImeContext {
                 (xconn.xlib.XVaCreateNestedList)(
                     0,
                     ffi::XNSpotLocation_0.as_ptr(),
-                    &self.ic_spot,
+                    &ic_spot,
+                    ffi::XNArea_0.as_ptr(),
+                    &self.ic_area,
                     ptr::null_mut::<()>(),
                 ),
             )

src/platform_impl/linux/x11/ime/mod.rs

@@ -5,6 +5,7 @@ mod context;
 mod inner;
 mod input_method;
 
+use std::fmt;
 use std::sync::mpsc::{Receiver, Sender};
 use std::sync::Arc;
 
@@ -35,8 +36,8 @@ pub type ImeEventSender = Sender<(ffi::Window, ImeEvent)>;
 
 /// Request to control XIM handler from the window.
 pub enum ImeRequest {
-    /// Set IME spot position for given `window_id`.
-    Position(ffi::Window, i16, i16),
+    /// Set IME preedit area for given `window_id`.
+    Area(ffi::Window, i16, i16, u16, u16),
 
     /// Allow IME input for the given `window_id`.
     Allow(ffi::Window, bool),
@@ -56,6 +57,12 @@ pub(crate) struct Ime {
     inner: Box<ImeInner>,
 }
 
+impl fmt::Debug for Ime {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Ime").finish_non_exhaustive()
+    }
+}
+
 impl Ime {
     pub fn new(
         xconn: Arc<XConnection>,
@@ -185,12 +192,12 @@ impl Ime {
         }
     }
 
-    pub fn send_xim_spot(&mut self, window: ffi::Window, x: i16, y: i16) {
+    pub fn send_xim_area(&mut self, window: ffi::Window, x: i16, y: i16, w: u16, h: u16) {
         if self.is_destroyed() {
             return;
         }
         if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
-            context.set_spot(&self.xconn, x as _, y as _);
+            context.set_area(&self.xconn, x as _, y as _, w as _, h as _);
         }
     }
 

src/platform_impl/linux/x11/mod.rs

@@ -6,7 +6,7 @@ use std::ops::Deref;
 use std::os::raw::*;
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::mpsc::{self, Receiver, Sender, TryRecvError};
-use std::sync::{Arc, Weak};
+use std::sync::{Arc, Mutex, Weak};
 use std::time::{Duration, Instant};
 use std::{fmt, mem, ptr, slice, str};
 
@@ -30,13 +30,15 @@ use crate::event_loop::{
     EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
     OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
+use crate::monitor::MonitorHandle as CoreMonitorHandle;
 use crate::platform::pump_events::PumpStatus;
+use crate::platform::x11::XlibErrorHook;
 use crate::platform_impl::common::xkb::Context;
 use crate::platform_impl::platform::min_timeout;
 use crate::platform_impl::x11::window::Window;
-use crate::platform_impl::PlatformCustomCursor;
+use crate::utils::Lazy;
 use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as CoreWindow,
+    CustomCursor as CoreCustomCursor, CustomCursorSource, Theme, Window as CoreWindow,
     WindowAttributes, WindowId,
 };
 
@@ -71,6 +73,62 @@ type X11rbConnection = x11rb::xcb_ffi::XCBConnection;
 
 type X11Source = Generic<BorrowedFd<'static>>;
 
+#[cfg(x11_platform)]
+pub(crate) static X11_BACKEND: Lazy<Mutex<Result<Arc<XConnection>, XNotSupported>>> =
+    Lazy::new(|| Mutex::new(XConnection::new(Some(x_error_callback)).map(Arc::new)));
+
+/// Hooks for X11 errors.
+#[cfg(x11_platform)]
+pub(crate) static XLIB_ERROR_HOOKS: Mutex<Vec<XlibErrorHook>> = Mutex::new(Vec::new());
+
+#[cfg(x11_platform)]
+unsafe extern "C" fn x_error_callback(
+    display: *mut ffi::Display,
+    event: *mut ffi::XErrorEvent,
+) -> c_int {
+    let xconn_lock = X11_BACKEND.lock().unwrap_or_else(|e| e.into_inner());
+    if let Ok(ref xconn) = *xconn_lock {
+        // Call all the hooks.
+        let mut error_handled = false;
+        for hook in XLIB_ERROR_HOOKS.lock().unwrap().iter() {
+            error_handled |= hook(display as *mut _, event as *mut _);
+        }
+
+        // `assume_init` is safe here because the array consists of `MaybeUninit` values,
+        // which do not require initialization.
+        let mut buf: [MaybeUninit<c_char>; 1024] = unsafe { MaybeUninit::uninit().assume_init() };
+        unsafe {
+            (xconn.xlib.XGetErrorText)(
+                display,
+                (*event).error_code as c_int,
+                buf.as_mut_ptr() as *mut c_char,
+                buf.len() as c_int,
+            )
+        };
+        let description =
+            unsafe { CStr::from_ptr(buf.as_ptr() as *const c_char) }.to_string_lossy();
+
+        let error = unsafe {
+            XError {
+                description: description.into_owned(),
+                error_code: (*event).error_code,
+                request_code: (*event).request_code,
+                minor_code: (*event).minor_code,
+            }
+        };
+
+        // Don't log error.
+        if !error_handled {
+            tracing::error!("X11 error: {:#?}", error);
+            // XXX only update the error, if it wasn't handled by any of the hooks.
+            *xconn.latest_error.lock().unwrap() = Some(error);
+        }
+    }
+    // Fun fact: this return value is completely ignored.
+    0
+}
+
+#[derive(Debug)]
 struct WakeSender<T> {
     sender: Sender<T>,
     waker: Ping,
@@ -91,6 +149,7 @@ impl<T> WakeSender<T> {
     }
 }
 
+#[derive(Debug)]
 struct PeekableReceiver<T> {
     recv: Receiver<T>,
     first: Option<T>,
@@ -127,6 +186,7 @@ impl<T> PeekableReceiver<T> {
     }
 }
 
+#[derive(Debug)]
 pub struct ActiveEventLoop {
     xconn: Arc<XConnection>,
     wm_delete_window: xproto::Atom,
@@ -144,6 +204,7 @@ pub struct ActiveEventLoop {
     device_events: Cell<DeviceEvents>,
 }
 
+#[derive(Debug)]
 pub struct EventLoop {
     loop_running: bool,
     event_loop: Loop<'static, EventLoopState>,
@@ -157,6 +218,7 @@ pub struct EventLoop {
 
 type ActivationToken = (WindowId, crate::event_loop::AsyncRequestSerial);
 
+#[derive(Debug)]
 struct EventLoopState {
     /// The latest readiness state for the x11 file descriptor
     x11_readiness: Readiness,
@@ -166,7 +228,12 @@ struct EventLoopState {
 }
 
 impl EventLoop {
-    pub(crate) fn new(xconn: Arc<XConnection>) -> EventLoop {
+    pub(crate) fn new() -> Result<EventLoop, EventLoopError> {
+        let xconn = match X11_BACKEND.lock().unwrap_or_else(|e| e.into_inner()).as_ref() {
+            Ok(xconn) => xconn.clone(),
+            Err(err) => return Err(os_error!(err.clone()).into()),
+        };
+
         let root = xconn.default_root().root;
         let atoms = xconn.atoms();
 
@@ -359,14 +426,16 @@ impl EventLoop {
 
         event_processor.init_device(ALL_DEVICES);
 
-        EventLoop {
+        let event_loop = EventLoop {
             loop_running: false,
             event_loop,
             event_processor,
             redraw_receiver: PeekableReceiver::from_recv(redraw_channel),
             activation_receiver: PeekableReceiver::from_recv(activation_token_channel),
             state: EventLoopState { x11_readiness: Readiness::EMPTY, proxy_wake_up: false },
-        }
+        };
+
+        Ok(event_loop)
     }
 
     pub(crate) fn window_target(&self) -> &dyn RootActiveEventLoop {
@@ -429,8 +498,6 @@ impl EventLoop {
         if let Some(code) = self.exit_code() {
             self.loop_running = false;
 
-            app.exiting(self.window_target());
-
             PumpStatus::Exit(code)
         } else {
             PumpStatus::Continue
@@ -501,6 +568,7 @@ impl EventLoop {
         // If we don't have any pending `_receiver`
         if !self.has_pending()
             && !matches!(&cause, StartCause::ResumeTimeReached { .. } | StartCause::Poll)
+            && timeout.is_none()
         {
             return;
         }
@@ -661,29 +729,22 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_custom_cursor(
         &self,
         custom_cursor: CustomCursorSource,
-    ) -> Result<RootCustomCursor, RequestError> {
-        Ok(RootCustomCursor {
-            inner: PlatformCustomCursor::X(CustomCursor::new(self, custom_cursor.inner)?),
-        })
+    ) -> Result<CoreCustomCursor, RequestError> {
+        Ok(CoreCustomCursor(Arc::new(CustomCursor::new(self, custom_cursor)?)))
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = crate::monitor::MonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         Box::new(
             self.xconn
                 .available_monitors()
                 .into_iter()
                 .flatten()
-                .map(crate::platform_impl::MonitorHandle::X)
-                .map(|inner| crate::monitor::MonitorHandle { inner }),
+                .map(|monitor| CoreMonitorHandle(Arc::new(monitor))),
         )
     }
 
-    fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
-        self.xconn
-            .primary_monitor()
-            .ok()
-            .map(crate::platform_impl::MonitorHandle::X)
-            .map(|inner| crate::monitor::MonitorHandle { inner })
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
+        self.xconn.primary_monitor().ok().map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
     }
 
     fn system_theme(&self) -> Option<Theme> {
@@ -762,7 +823,7 @@ impl Deref for DeviceInfo<'_> {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct EventLoopProxy {
     ping: Ping,
 }

src/platform_impl/linux/x11/monitor.rs

@@ -6,7 +6,7 @@ use x11rb::protocol::xproto;
 
 use super::{util, X11Error, XConnection};
 use crate::dpi::PhysicalPosition;
-use crate::monitor::VideoMode;
+use crate::monitor::{MonitorHandleProvider, VideoMode};
 
 // Used for testing. This should always be committed as false.
 const DISABLE_MONITOR_LIST_CACHING: bool = false;
@@ -23,7 +23,6 @@ pub struct VideoModeHandle {
     pub(crate) current: bool,
     pub(crate) mode: VideoMode,
     pub(crate) native_mode: randr::Mode,
-    pub(crate) monitor: Option<MonitorHandle>,
 }
 
 impl From<VideoModeHandle> for VideoMode {
@@ -50,6 +49,36 @@ pub struct MonitorHandle {
     pub(crate) video_modes: Vec<VideoModeHandle>,
 }
 
+impl MonitorHandleProvider for MonitorHandle {
+    fn id(&self) -> u128 {
+        self.native_id() as _
+    }
+
+    fn native_id(&self) -> u64 {
+        self.id as _
+    }
+
+    fn name(&self) -> Option<std::borrow::Cow<'_, str>> {
+        Some(self.name.as_str().into())
+    }
+
+    fn position(&self) -> Option<PhysicalPosition<i32>> {
+        Some(self.position.into())
+    }
+
+    fn scale_factor(&self) -> f64 {
+        self.scale_factor
+    }
+
+    fn current_video_mode(&self) -> Option<VideoMode> {
+        self.video_modes.iter().find_map(|mode| mode.current.then(|| mode.clone().into()))
+    }
+
+    fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
+        Box::new(self.video_modes.clone().into_iter().map(|mode| mode.into()))
+    }
+}
+
 impl PartialEq for MonitorHandle {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
@@ -121,34 +150,6 @@ impl MonitorHandle {
         // Zero is an invalid XID value; no real monitor will have it
         self.id == 0
     }
-
-    pub fn name(&self) -> Option<String> {
-        Some(self.name.clone())
-    }
-
-    #[inline]
-    pub fn native_identifier(&self) -> u32 {
-        self.id as _
-    }
-
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        Some(self.position.into())
-    }
-
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        self.scale_factor
-    }
-
-    #[inline]
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        self.video_modes.iter().find(|mode| mode.current).cloned().map(Into::into)
-    }
-
-    #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        self.video_modes.clone().into_iter().map(Into::into)
-    }
 }
 
 impl XConnection {

src/platform_impl/linux/x11/util/cursor.rs

@@ -9,8 +9,8 @@ use x11rb::protocol::xproto;
 
 use super::super::ActiveEventLoop;
 use super::*;
-use crate::error::RequestError;
-use crate::platform_impl::PlatformCustomCursorSource;
+use crate::cursor::{CustomCursorProvider, CustomCursorSource};
+use crate::error::{NotSupportedError, RequestError};
 use crate::window::CursorIcon;
 
 impl XConnection {
@@ -36,7 +36,7 @@ impl XConnection {
         window: xproto::Window,
         cursor: &CustomCursor,
     ) -> Result<(), X11Error> {
-        self.update_cursor(window, cursor.inner.cursor)
+        self.update_cursor(window, cursor.cursor)
     }
 
     /// Create a cursor from an image.
@@ -170,32 +170,45 @@ pub enum SelectedCursor {
     Named(CursorIcon),
 }
 
+impl Default for SelectedCursor {
+    fn default() -> Self {
+        SelectedCursor::Named(Default::default())
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct CustomCursor {
-    inner: Arc<CustomCursorInner>,
+    xconn: Arc<XConnection>,
+    cursor: xproto::Cursor,
 }
 
 impl Hash for CustomCursor {
     fn hash<H: Hasher>(&self, state: &mut H) {
-        Arc::as_ptr(&self.inner).hash(state);
+        self.cursor.hash(state);
     }
 }
 
 impl PartialEq for CustomCursor {
     fn eq(&self, other: &Self) -> bool {
-        Arc::ptr_eq(&self.inner, &other.inner)
+        self.cursor == other.cursor
     }
 }
-
 impl Eq for CustomCursor {}
 
 impl CustomCursor {
     pub(crate) fn new(
         event_loop: &ActiveEventLoop,
-        mut cursor: PlatformCustomCursorSource,
+        cursor: CustomCursorSource,
     ) -> Result<CustomCursor, RequestError> {
+        let mut cursor = match cursor {
+            CustomCursorSource::Image(cursor_image) => cursor_image,
+            CustomCursorSource::Animation { .. } | CustomCursorSource::Url { .. } => {
+                return Err(NotSupportedError::new("unsupported cursor kind").into())
+            },
+        };
+
         // Reverse RGBA order to BGRA.
-        cursor.0.rgba.chunks_mut(4).for_each(|chunk| {
+        cursor.rgba.chunks_mut(4).for_each(|chunk| {
             let chunk: &mut [u8; 4] = chunk.try_into().unwrap();
             chunk[0..3].reverse();
 
@@ -209,32 +222,26 @@ impl CustomCursor {
         let cursor = event_loop
             .xconn
             .create_cursor_from_image(
-                cursor.0.width,
-                cursor.0.height,
-                cursor.0.hotspot_x,
-                cursor.0.hotspot_y,
-                &cursor.0.rgba,
+                cursor.width,
+                cursor.height,
+                cursor.hotspot_x,
+                cursor.hotspot_y,
+                &cursor.rgba,
             )
             .map_err(|err| os_error!(err))?;
 
-        Ok(Self { inner: Arc::new(CustomCursorInner { xconn: event_loop.xconn.clone(), cursor }) })
+        Ok(Self { xconn: event_loop.xconn.clone(), cursor })
     }
 }
 
-#[derive(Debug)]
-struct CustomCursorInner {
-    xconn: Arc<XConnection>,
-    cursor: xproto::Cursor,
-}
-
-impl Drop for CustomCursorInner {
+impl Drop for CustomCursor {
     fn drop(&mut self) {
         self.xconn.xcb_connection().free_cursor(self.cursor).map(|r| r.ignore_error()).ok();
     }
 }
 
-impl Default for SelectedCursor {
-    fn default() -> Self {
-        SelectedCursor::Named(Default::default())
+impl CustomCursorProvider for CustomCursor {
+    fn is_animated(&self) -> bool {
+        false
     }
 }

src/platform_impl/linux/x11/util/randr.rs

@@ -83,19 +83,14 @@ impl XConnection {
             // XRROutputInfo contains an array of mode ids that correspond to
             // modes in the array in XRRScreenResources
             .filter(|x| output_modes.iter().any(|id| x.id == *id))
-            .map(|mode| {
-                VideoModeHandle {
-                    current: mode.id == current_mode,
-                    mode: VideoMode {
-                        size: (mode.width as u32, mode.height as u32).into(),
-                        refresh_rate_millihertz: monitor::mode_refresh_rate_millihertz(mode),
-                        bit_depth: NonZeroU16::new(bit_depth as u16),
-                    },
-                    native_mode: mode.id,
-                    // This is populated in `MonitorHandle::video_modes` as the
-                    // video mode is returned to the user
-                    monitor: None,
-                }
+            .map(|mode| VideoModeHandle {
+                current: mode.id == current_mode,
+                mode: VideoMode {
+                    size: (mode.width as u32, mode.height as u32).into(),
+                    refresh_rate_millihertz: monitor::mode_refresh_rate_millihertz(mode),
+                    bit_depth: NonZeroU16::new(bit_depth as u16),
+                },
+                native_mode: mode.id,
             })
             .collect();
 

src/platform_impl/linux/x11/window.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::ffi::CString;
 use std::mem::replace;
 use std::num::NonZeroU32;
@@ -18,27 +19,31 @@ use x11rb::protocol::{randr, xinput};
 
 use super::util::{self, SelectedCursor};
 use super::{
-    ffi, ActiveEventLoop, CookieResultExt, ImeRequest, ImeSender, VoidCookie, XConnection,
+    ffi, ActiveEventLoop, CookieResultExt, CustomCursor, ImeRequest, ImeSender, VoidCookie,
+    XConnection,
 };
 use crate::application::ApplicationHandler;
-use crate::cursor::{Cursor, CustomCursor as RootCustomCursor};
+use crate::cursor::Cursor;
 use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{NotSupportedError, RequestError};
 use crate::event::{SurfaceSizeWriter, WindowEvent};
 use crate::event_loop::AsyncRequestSerial;
+use crate::icon::RgbaIcon;
+use crate::monitor::{
+    Fullscreen, MonitorHandle as CoreMonitorHandle, MonitorHandleProvider, VideoMode,
+};
 use crate::platform::x11::WindowType;
+use crate::platform_impl::common;
 use crate::platform_impl::x11::atoms::*;
 use crate::platform_impl::x11::{
     xinput_fp1616_to_float, MonitorHandle as X11MonitorHandle, WakeSender, X11Error,
 };
-use crate::platform_impl::{
-    common, Fullscreen, MonitorHandle as PlatformMonitorHandle, PlatformCustomCursor, PlatformIcon,
-};
 use crate::window::{
     CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, Window as CoreWindow,
     WindowAttributes, WindowButtons, WindowId, WindowLevel,
 };
 
+#[derive(Debug)]
 pub(crate) struct Window(Arc<UnownedWindow>);
 
 impl Deref for Window {
@@ -178,12 +183,12 @@ impl CoreWindow for Window {
         self.0.is_maximized()
     }
 
-    fn set_fullscreen(&self, fullscreen: Option<crate::window::Fullscreen>) {
-        self.0.set_fullscreen(fullscreen.map(Into::into))
+    fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
+        self.0.set_fullscreen(fullscreen)
     }
 
-    fn fullscreen(&self) -> Option<crate::window::Fullscreen> {
-        self.0.fullscreen().map(Into::into)
+    fn fullscreen(&self) -> Option<Fullscreen> {
+        self.0.fullscreen()
     }
 
     fn set_decorations(&self, decorations: bool) {
@@ -199,7 +204,11 @@ impl CoreWindow for Window {
     }
 
     fn set_window_icon(&self, window_icon: Option<crate::window::Icon>) {
-        self.0.set_window_icon(window_icon.map(|inner| inner.inner))
+        let icon = match window_icon.as_ref() {
+            Some(icon) => icon.0.cast_ref::<RgbaIcon>(),
+            None => None,
+        };
+        self.0.set_window_icon(icon)
     }
 
     fn set_ime_cursor_area(&self, position: Position, size: Size) {
@@ -274,28 +283,21 @@ impl CoreWindow for Window {
         self.0.set_cursor_hittest(hittest)
     }
 
-    fn current_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
-        self.0
-            .current_monitor()
-            .map(crate::platform_impl::MonitorHandle::X)
-            .map(|inner| crate::monitor::MonitorHandle { inner })
+    fn current_monitor(&self) -> Option<CoreMonitorHandle> {
+        self.0.current_monitor().map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = crate::monitor::MonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         Box::new(
             self.0
                 .available_monitors()
                 .into_iter()
-                .map(crate::platform_impl::MonitorHandle::X)
-                .map(|inner| crate::monitor::MonitorHandle { inner }),
+                .map(|monitor| CoreMonitorHandle(Arc::new(monitor))),
         )
     }
 
-    fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
-        self.0
-            .primary_monitor()
-            .map(crate::platform_impl::MonitorHandle::X)
-            .map(|inner| crate::monitor::MonitorHandle { inner })
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
+        self.0.primary_monitor().map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
     }
 
     fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
@@ -411,6 +413,7 @@ impl SharedState {
 unsafe impl Send for UnownedWindow {}
 unsafe impl Sync for UnownedWindow {}
 
+#[derive(Debug)]
 pub struct UnownedWindow {
     pub(crate) xconn: Arc<XConnection>, // never changes
     xwindow: xproto::Window,            // never changes
@@ -767,8 +770,10 @@ impl UnownedWindow {
             .check());
 
             // Set window icons
-            if let Some(icon) = window_attrs.window_icon {
-                leap!(window.set_icon_inner(icon.inner)).ignore_error();
+            if let Some(icon) =
+                window_attrs.window_icon.as_ref().and_then(|icon| icon.0.cast_ref::<RgbaIcon>())
+            {
+                leap!(window.set_icon_inner(icon)).ignore_error();
             }
 
             // Opt into handling window close and resize synchronization
@@ -860,8 +865,7 @@ impl UnownedWindow {
 
             if window_attrs.fullscreen.is_some() {
                 if let Some(flusher) =
-                    leap!(window
-                        .set_fullscreen_inner(window_attrs.fullscreen.clone().map(Into::into)))
+                    leap!(window.set_fullscreen_inner(window_attrs.fullscreen.clone()))
                 {
                     flusher.ignore_error()
                 }
@@ -1037,7 +1041,7 @@ impl UnownedWindow {
             // to the desktop video mode as macOS and Windows do
             (&None, &Some(Fullscreen::Exclusive(ref monitor, _)))
             | (&Some(Fullscreen::Borderless(_)), &Some(Fullscreen::Exclusive(ref monitor, _))) => {
-                let id = monitor.native_identifier();
+                let id = monitor.native_id() as _;
                 shared_state_lock.desktop_video_mode = Some((
                     id,
                     self.xconn.get_crtc_mode(id).expect("Failed to get desktop video mode"),
@@ -1068,19 +1072,20 @@ impl UnownedWindow {
                 flusher.map(Some)
             },
             Some(fullscreen) => {
-                let (video_mode, monitor) = match fullscreen {
-                    Fullscreen::Exclusive(PlatformMonitorHandle::X(monitor), video_mode) => {
-                        (Some(video_mode), monitor.clone())
-                    },
-                    Fullscreen::Borderless(Some(PlatformMonitorHandle::X(monitor))) => {
-                        (None, monitor)
-                    },
-                    Fullscreen::Borderless(None) => {
-                        (None, self.shared_state_lock().last_monitor.clone())
-                    },
-                    #[cfg(wayland_platform)]
-                    _ => unreachable!(),
-                };
+                let (monitor, video_mode): (Cow<'_, X11MonitorHandle>, Option<&VideoMode>) =
+                    match &fullscreen {
+                        Fullscreen::Exclusive(monitor, video_mode) => {
+                            let monitor = monitor.cast_ref::<X11MonitorHandle>().unwrap();
+                            (Cow::Borrowed(monitor), Some(video_mode))
+                        },
+                        Fullscreen::Borderless(Some(monitor)) => {
+                            let monitor = monitor.cast_ref::<X11MonitorHandle>().unwrap();
+                            (Cow::Borrowed(monitor), None)
+                        },
+                        Fullscreen::Borderless(None) => {
+                            (Cow::Owned(self.shared_state_lock().last_monitor.clone()), None)
+                        },
+                    };
 
                 // Don't set fullscreen on an invalid dummy monitor handle
                 if monitor.is_dummy() {
@@ -1089,7 +1094,7 @@ impl UnownedWindow {
 
                 if let Some(native_mode) = video_mode.and_then(|requested| {
                     monitor.video_modes.iter().find_map(|mode| {
-                        if mode.mode == requested {
+                        if &mode.mode == requested {
                             Some(mode.native_mode)
                         } else {
                             None
@@ -1122,7 +1127,7 @@ impl UnownedWindow {
                     // this will make someone unhappy, but it's very unusual for
                     // games to want to do this anyway).
                     self.xconn
-                        .set_crtc_config(monitor.id, native_mode)
+                        .set_crtc_config(monitor.native_id() as _, native_mode)
                         .expect("failed to set video mode");
                 }
 
@@ -1406,7 +1411,7 @@ impl UnownedWindow {
         self.xconn.flush_requests().expect("Failed to set window-level state");
     }
 
-    fn set_icon_inner(&self, icon: PlatformIcon) -> Result<VoidCookie<'_>, X11Error> {
+    fn set_icon_inner(&self, icon: &RgbaIcon) -> Result<VoidCookie<'_>, X11Error> {
         let atoms = self.xconn.atoms();
         let icon_atom = atoms[_NET_WM_ICON];
         let data = icon.to_cardinals();
@@ -1433,7 +1438,7 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub(crate) fn set_window_icon(&self, icon: Option<PlatformIcon>) {
+    pub(crate) fn set_window_icon(&self, icon: Option<&RgbaIcon>) {
         match icon {
             Some(icon) => self.set_icon_inner(icon),
             None => self.unset_icon_inner(),
@@ -1811,19 +1816,23 @@ impl UnownedWindow {
                     }
                 }
             },
-            Cursor::Custom(RootCustomCursor { inner: PlatformCustomCursor::X(cursor) }) => {
+            Cursor::Custom(cursor) => {
+                let cursor = match cursor.cast_ref::<CustomCursor>() {
+                    Some(cursor) => cursor,
+                    None => {
+                        tracing::error!("unrecognized cursor passed to X11 backend");
+                        return;
+                    },
+                };
+
                 #[allow(clippy::mutex_atomic)]
                 if *self.cursor_visible.lock().unwrap() {
-                    if let Err(err) = self.xconn.set_custom_cursor(self.xwindow, &cursor) {
+                    if let Err(err) = self.xconn.set_custom_cursor(self.xwindow, cursor) {
                         tracing::error!("failed to set window icon: {err}");
                     }
                 }
 
-                *self.selected_cursor.lock().unwrap() = SelectedCursor::Custom(cursor);
-            },
-            #[cfg(wayland_platform)]
-            Cursor::Custom(RootCustomCursor { inner: PlatformCustomCursor::Wayland(_) }) => {
-                tracing::error!("passed a Wayland cursor to X11 backend")
+                *self.selected_cursor.lock().unwrap() = SelectedCursor::Custom(cursor.clone());
             },
         }
     }
@@ -2051,17 +2060,13 @@ impl UnownedWindow {
     #[inline]
     pub fn set_ime_cursor_area(&self, spot: Position, size: Size) {
         let PhysicalPosition { x, y } = spot.to_physical::<i16>(self.scale_factor());
-        let PhysicalSize { width, height } = size.to_physical::<i16>(self.scale_factor());
-        // We only currently support reporting a caret position via XIM.
-        // No IM servers currently process preedit area information from XIM clients
-        // and it is unclear this is even part of the standard protocol.
-        // Fcitx and iBus both assume that the position reported is at the insertion
-        // caret, and by default will place the candidate window under and to the
-        // right of the reported point.
-        let _ = self.ime_sender.lock().unwrap().send(ImeRequest::Position(
+        let PhysicalSize { width, height } = size.to_physical::<u16>(self.scale_factor());
+        let _ = self.ime_sender.lock().unwrap().send(ImeRequest::Area(
             self.xwindow as ffi::Window,
-            x.saturating_add(width),
-            y.saturating_add(height),
+            x,
+            y,
+            width,
+            height,
         ));
     }
 

src/platform_impl/mod.rs

@@ -1,6 +1,3 @@
-use crate::monitor::{MonitorHandle as RootMonitorHandle, VideoMode};
-use crate::window::Fullscreen as RootFullscreen;
-
 #[cfg(android_platform)]
 mod android;
 #[cfg(target_vendor = "apple")]
@@ -29,40 +26,6 @@ use self::web as platform;
 #[cfg(windows_platform)]
 use self::windows as platform;
 
-/// Helper for converting between platform-specific and generic
-/// [`VideoMode`]/[`MonitorHandle`]
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum Fullscreen {
-    Exclusive(MonitorHandle, VideoMode),
-    Borderless(Option<MonitorHandle>),
-}
-
-impl From<RootFullscreen> for Fullscreen {
-    fn from(f: RootFullscreen) -> Self {
-        match f {
-            RootFullscreen::Exclusive(handle, video_mode) => {
-                Self::Exclusive(handle.inner, video_mode)
-            },
-            RootFullscreen::Borderless(Some(handle)) => Self::Borderless(Some(handle.inner)),
-            RootFullscreen::Borderless(None) => Self::Borderless(None),
-        }
-    }
-}
-
-impl From<Fullscreen> for RootFullscreen {
-    fn from(f: Fullscreen) -> Self {
-        match f {
-            Fullscreen::Exclusive(inner, video_mode) => {
-                Self::Exclusive(RootMonitorHandle { inner }, video_mode)
-            },
-            Fullscreen::Borderless(Some(inner)) => {
-                Self::Borderless(Some(RootMonitorHandle { inner }))
-            },
-            Fullscreen::Borderless(None) => Self::Borderless(None),
-        }
-    }
-}
-
 #[cfg(all(
     not(ios_platform),
     not(windows_platform),

src/platform_impl/orbital/event_loop.rs

@@ -2,7 +2,7 @@ use std::cell::Cell;
 use std::collections::VecDeque;
 use std::sync::{mpsc, Arc, Mutex};
 use std::time::Instant;
-use std::{mem, slice};
+use std::{iter, mem, slice};
 
 use bitflags::bitflags;
 use orbclient::{
@@ -11,9 +11,7 @@ use orbclient::{
 };
 use smol_str::SmolStr;
 
-use super::{
-    MonitorHandle, PlatformSpecificEventLoopAttributes, RedoxSocket, TimeSocket, WindowProperties,
-};
+use super::{PlatformSpecificEventLoopAttributes, RedoxSocket, TimeSocket, WindowProperties};
 use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, NotSupportedError, RequestError};
 use crate::event::{self, Ime, Modifiers, StartCause};
@@ -120,8 +118,8 @@ fn convert_scancode(scancode: u8) -> (PhysicalKey, Option<NamedKey>) {
         orbclient::K_RIGHT_SHIFT => (KeyCode::ShiftRight, Some(NamedKey::Shift)),
         orbclient::K_SEMICOLON => (KeyCode::Semicolon, None),
         orbclient::K_SLASH => (KeyCode::Slash, None),
-        orbclient::K_SPACE => (KeyCode::Space, Some(NamedKey::Space)),
-        orbclient::K_SUPER => (KeyCode::SuperLeft, Some(NamedKey::Super)),
+        orbclient::K_SPACE => (KeyCode::Space, None),
+        orbclient::K_SUPER => (KeyCode::MetaLeft, Some(NamedKey::Meta)),
         orbclient::K_TAB => (KeyCode::Tab, Some(NamedKey::Tab)),
         orbclient::K_TICK => (KeyCode::Backquote, None),
         orbclient::K_UP => (KeyCode::ArrowUp, Some(NamedKey::ArrowUp)),
@@ -151,8 +149,8 @@ bitflags! {
         const RCTRL = 1 << 3;
         const LALT = 1 << 4;
         const RALT = 1 << 5;
-        const LSUPER = 1 << 6;
-        const RSUPER = 1 << 7;
+        const LMETA = 1 << 6;
+        const RMETA = 1 << 7;
     }
 }
 
@@ -165,7 +163,7 @@ bitflags! {
     }
 }
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 struct EventState {
     keyboard: KeyboardModifierState,
     mouse: MouseButtonState,
@@ -202,8 +200,8 @@ impl EventState {
             KeyCode::ControlRight => self.keyboard.set(KeyboardModifierState::RCTRL, pressed),
             KeyCode::AltLeft => self.keyboard.set(KeyboardModifierState::LALT, pressed),
             KeyCode::AltRight => self.keyboard.set(KeyboardModifierState::RALT, pressed),
-            KeyCode::SuperLeft => self.keyboard.set(KeyboardModifierState::LSUPER, pressed),
-            KeyCode::SuperRight => self.keyboard.set(KeyboardModifierState::RSUPER, pressed),
+            KeyCode::MetaLeft => self.keyboard.set(KeyboardModifierState::LMETA, pressed),
+            KeyCode::MetaRight => self.keyboard.set(KeyboardModifierState::RMETA, pressed),
             _ => (),
         }
     }
@@ -261,19 +259,20 @@ impl EventState {
         pressed_mods.set(ModifiersKeys::LALT, self.keyboard.contains(KeyboardModifierState::LALT));
         pressed_mods.set(ModifiersKeys::RALT, self.keyboard.contains(KeyboardModifierState::RALT));
 
-        if self.keyboard.intersects(KeyboardModifierState::LSUPER | KeyboardModifierState::RSUPER) {
-            state |= ModifiersState::SUPER
+        if self.keyboard.intersects(KeyboardModifierState::LMETA | KeyboardModifierState::RMETA) {
+            state |= ModifiersState::META
         }
 
         pressed_mods
-            .set(ModifiersKeys::LSUPER, self.keyboard.contains(KeyboardModifierState::LSUPER));
+            .set(ModifiersKeys::LMETA, self.keyboard.contains(KeyboardModifierState::LMETA));
         pressed_mods
-            .set(ModifiersKeys::RSUPER, self.keyboard.contains(KeyboardModifierState::RSUPER));
+            .set(ModifiersKeys::RMETA, self.keyboard.contains(KeyboardModifierState::RMETA));
 
         Modifiers { state, pressed_mods }
     }
 }
 
+#[derive(Debug)]
 pub struct EventLoop {
     windows: Vec<(Arc<RedoxSocket>, EventState)>,
     window_target: ActiveEventLoop,
@@ -651,8 +650,6 @@ impl EventLoop {
             }
         }
 
-        app.exiting(&self.window_target);
-
         Ok(())
     }
 
@@ -661,6 +658,7 @@ impl EventLoop {
     }
 }
 
+#[derive(Debug)]
 pub struct EventLoopProxy {
     user_events_sender: mpsc::SyncSender<()>,
     pub(super) wake_socket: TimeSocket,
@@ -678,6 +676,7 @@ impl EventLoopProxyProvider for EventLoopProxy {
 
 impl Unpin for EventLoopProxy {}
 
+#[derive(Debug)]
 pub struct ActiveEventLoop {
     control_flow: Cell<ControlFlow>,
     exit: Cell<bool>,
@@ -708,9 +707,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = crate::monitor::MonitorHandle>> {
-        let mut v = VecDeque::with_capacity(1);
-        v.push_back(crate::monitor::MonitorHandle { inner: MonitorHandle });
-        Box::new(v.into_iter())
+        Box::new(iter::empty())
     }
 
     fn system_theme(&self) -> Option<Theme> {
@@ -718,7 +715,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
     }
 
     fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
-        Some(crate::monitor::MonitorHandle { inner: MonitorHandle })
+        None
     }
 
     fn listen_device_events(&self, _allowed: DeviceEvents) {}

src/platform_impl/orbital/mod.rs

@@ -4,17 +4,11 @@ use std::{fmt, str};
 
 pub(crate) use self::event_loop::{ActiveEventLoop, EventLoop};
 pub use self::window::Window;
-use crate::dpi::PhysicalPosition;
-use crate::monitor::VideoMode;
 
 mod event_loop;
 mod window;
 
-pub(crate) use crate::cursor::{
-    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
-};
-pub(crate) use crate::icon::NoIcon as PlatformIcon;
-
+#[derive(Debug)]
 struct RedoxSocket {
     fd: usize,
 }
@@ -67,6 +61,7 @@ impl Drop for RedoxSocket {
     }
 }
 
+#[derive(Debug)]
 pub struct TimeSocket(RedoxSocket);
 
 impl TimeSocket {
@@ -131,29 +126,3 @@ impl fmt::Display for WindowProperties<'_> {
         )
     }
 }
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct MonitorHandle;
-
-impl MonitorHandle {
-    pub fn name(&self) -> Option<String> {
-        None
-    }
-
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        None
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        1.0 // TODO
-    }
-
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        // (it is guaranteed to support 32 bit color though)
-        None
-    }
-
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        std::iter::empty()
-    }
-}

src/platform_impl/orbital/window.rs

@@ -1,13 +1,14 @@
 use std::collections::VecDeque;
+use std::iter;
 use std::sync::{Arc, Mutex};
 
 use super::event_loop::EventLoopProxy;
-use super::{ActiveEventLoop, MonitorHandle, RedoxSocket, WindowProperties};
+use super::{ActiveEventLoop, RedoxSocket, WindowProperties};
 use crate::cursor::Cursor;
 use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{NotSupportedError, RequestError};
-use crate::monitor::MonitorHandle as CoreMonitorHandle;
-use crate::window::{self, Fullscreen, ImePurpose, Window as CoreWindow, WindowId};
+use crate::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
+use crate::window::{self, ImePurpose, Window as CoreWindow, WindowId};
 
 // These values match the values uses in the `window_new` function in orbital:
 // https://gitlab.redox-os.org/redox-os/orbital/-/blob/master/src/scheme.rs
@@ -20,6 +21,7 @@ const ORBITAL_FLAG_MAXIMIZED: char = 'm';
 const ORBITAL_FLAG_RESIZABLE: char = 'r';
 const ORBITAL_FLAG_TRANSPARENT: char = 't';
 
+#[derive(Debug)]
 pub struct Window {
     window_socket: Arc<RedoxSocket>,
     redraws: Arc<Mutex<VecDeque<WindowId>>>,
@@ -32,7 +34,7 @@ impl Window {
         el: &ActiveEventLoop,
         attrs: window::WindowAttributes,
     ) -> Result<Self, RequestError> {
-        let scale = MonitorHandle.scale_factor();
+        let scale = 1.;
 
         let (x, y) = if let Some(pos) = attrs.position {
             pos.to_physical::<i32>(scale).into()
@@ -160,22 +162,22 @@ impl CoreWindow for Window {
 
     #[inline]
     fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
-        Some(CoreMonitorHandle { inner: MonitorHandle })
+        None
     }
 
     #[inline]
     fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
-        Box::new(vec![CoreMonitorHandle { inner: MonitorHandle }].into_iter())
+        Box::new(iter::empty())
     }
 
     #[inline]
     fn current_monitor(&self) -> Option<CoreMonitorHandle> {
-        Some(CoreMonitorHandle { inner: MonitorHandle })
+        None
     }
 
     #[inline]
     fn scale_factor(&self) -> f64 {
-        MonitorHandle.scale_factor()
+        1.
     }
 
     #[inline]

src/platform_impl/web/async/wrapper.rs

@@ -9,6 +9,7 @@ use super::super::main_thread::MainThreadMarker;
 
 // Unsafe wrapper type that allows us to use `T` when it's not `Send` from other threads.
 // `value` **must** only be accessed on the main thread.
+#[derive(Debug)]
 pub struct Wrapper<V: 'static, S: Clone + Send, E> {
     value: Value<V>,
     handler: fn(&RefCell<Option<V>>, E),
@@ -16,6 +17,7 @@ pub struct Wrapper<V: 'static, S: Clone + Send, E> {
     sender_handler: fn(&S, E),
 }
 
+#[derive(Debug)]
 struct Value<V> {
     // SAFETY:
     // This value must not be accessed if not on the main thread.

src/platform_impl/web/cursor.rs

@@ -24,50 +24,17 @@ use super::backend::Style;
 use super::main_thread::{MainThreadMarker, MainThreadSafe};
 use super::r#async::{AbortHandle, Abortable, DropAbortHandle, Notified, Notifier};
 use super::ActiveEventLoop;
-use crate::cursor::{BadImage, Cursor, CursorImage, CustomCursor as RootCustomCursor};
+use crate::cursor::{
+    Cursor, CursorAnimation, CursorImage, CustomCursorProvider, CustomCursorSource,
+};
 use crate::platform::web::CustomCursorError;
 
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub(crate) enum CustomCursorSource {
-    Image(CursorImage),
-    Url { url: String, hotspot_x: u16, hotspot_y: u16 },
-    Animation { duration: Duration, cursors: Vec<RootCustomCursor> },
-}
-
-impl CustomCursorSource {
-    pub fn from_rgba(
-        rgba: Vec<u8>,
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    ) -> Result<CustomCursorSource, BadImage> {
-        Ok(CustomCursorSource::Image(CursorImage::from_rgba(
-            rgba, width, height, hotspot_x, hotspot_y,
-        )?))
-    }
-}
-
 #[derive(Clone, Debug)]
 pub struct CustomCursor {
     pub(crate) animation: bool,
     state: Arc<MainThreadSafe<RefCell<ImageState>>>,
 }
 
-impl Hash for CustomCursor {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        Arc::as_ptr(&self.state).hash(state);
-    }
-}
-
-impl PartialEq for CustomCursor {
-    fn eq(&self, other: &Self) -> bool {
-        Arc::ptr_eq(&self.state, &other.state)
-    }
-}
-
-impl Eq for CustomCursor {}
-
 impl CustomCursor {
     pub(crate) fn new(event_loop: &ActiveEventLoop, source: CustomCursorSource) -> Self {
         match source {
@@ -81,15 +48,13 @@ impl CustomCursor {
                 from_url(UrlType::Plain(url), hotspot_x, hotspot_y),
                 false,
             ),
-            CustomCursorSource::Animation { duration, cursors } => Self::build_spawn(
-                event_loop,
-                from_animation(
-                    event_loop.runner.main_thread(),
-                    duration,
-                    cursors.into_iter().map(|cursor| cursor.inner),
-                ),
-                true,
-            ),
+            CustomCursorSource::Animation(CursorAnimation { duration, cursors }) => {
+                Self::build_spawn(
+                    event_loop,
+                    from_animation(event_loop.runner.main_thread(), duration, cursors.into_iter()),
+                    true,
+                )
+            },
         }
     }
 
@@ -163,6 +128,26 @@ impl CustomCursor {
     }
 }
 
+impl CustomCursorProvider for CustomCursor {
+    fn is_animated(&self) -> bool {
+        self.animation
+    }
+}
+
+impl Hash for CustomCursor {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        Arc::as_ptr(&self.state).hash(state);
+    }
+}
+
+impl PartialEq for CustomCursor {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.state, &other.state)
+    }
+}
+
+impl Eq for CustomCursor {}
+
 #[derive(Debug)]
 pub struct CustomCursorFuture {
     notified: Notified<Result<(), CustomCursorError>>,
@@ -230,13 +215,16 @@ impl CursorHandler {
                 this.set_style();
             },
             Cursor::Custom(cursor) => {
-                let cursor = cursor.inner;
+                let cursor = match cursor.cast_ref::<CustomCursor>() {
+                    Some(cursor) => cursor,
+                    None => todo!(),
+                };
 
                 if let SelectedCursor::Loading { cursor: old_cursor, .. }
                 | SelectedCursor::Image(old_cursor)
                 | SelectedCursor::Animation { cursor: old_cursor, .. } = &this.cursor
                 {
-                    if *old_cursor == cursor {
+                    if old_cursor == cursor {
                         return;
                     }
                 }
@@ -263,7 +251,7 @@ impl CursorHandler {
 
                         drop(state);
                         this.cursor = SelectedCursor::Loading {
-                            cursor,
+                            cursor: cursor.clone(),
                             previous: mem::take(&mut this.cursor).into(),
                             _handle: handle,
                         };
@@ -275,7 +263,7 @@ impl CursorHandler {
                     },
                     ImageState::Image(_) => {
                         drop(state);
-                        this.cursor = SelectedCursor::Image(cursor);
+                        this.cursor = SelectedCursor::Image(cursor.clone());
                         this.set_style();
                     },
                     ImageState::Animation(animation) => {
@@ -292,7 +280,7 @@ impl CursorHandler {
 
                         this.cursor = SelectedCursor::Animation {
                             animation: AnimationDropper(animation),
-                            cursor,
+                            cursor: cursor.clone(),
                         };
                         this.set_style();
                     },
@@ -650,12 +638,13 @@ async fn from_url(
 async fn from_animation(
     main_thread: MainThreadMarker,
     duration: Duration,
-    cursors: impl ExactSizeIterator<Item = CustomCursor>,
+    cursors: impl ExactSizeIterator<Item = crate::cursor::CustomCursor>,
 ) -> Result<Animation, CustomCursorError> {
     let keyframes = Array::new();
     let mut images = Vec::with_capacity(cursors.len());
 
     for cursor in cursors {
+        let cursor = cursor.cast_ref::<CustomCursor>().unwrap();
         let state = cursor.state.get(main_thread).borrow();
 
         match state.deref() {
@@ -680,7 +669,7 @@ async fn from_animation(
         keyframes.push(&keyframe);
         drop(state);
 
-        images.push(cursor);
+        images.push(cursor.clone());
     }
 
     keyframes.push(&keyframes.get(0));

src/platform_impl/web/event_loop/mod.rs

@@ -11,6 +11,7 @@ mod window_target;
 
 pub(crate) use window_target::ActiveEventLoop;
 
+#[derive(Debug)]
 pub struct EventLoop {
     elw: ActiveEventLoop,
 }

src/platform_impl/web/event_loop/proxy.rs

@@ -8,8 +8,10 @@ use crate::event_loop::EventLoopProxyProvider;
 use crate::platform_impl::web::event_loop::runner::WeakShared;
 use crate::platform_impl::web::r#async::{AtomicWaker, Wrapper};
 
+#[derive(Debug)]
 pub struct EventLoopProxy(Wrapper<WeakShared, Arc<State>, ()>);
 
+#[derive(Debug)]
 struct State {
     awoken: AtomicBool,
     waker: AtomicWaker,

src/platform_impl/web/event_loop/runner.rs

@@ -1,9 +1,9 @@
 use std::cell::{Cell, RefCell};
 use std::collections::{HashSet, VecDeque};
-use std::iter;
 use std::ops::Deref;
 use std::rc::{Rc, Weak};
 use std::sync::Arc;
+use std::{fmt, iter};
 
 use wasm_bindgen::prelude::Closure;
 use wasm_bindgen::JsCast;
@@ -26,6 +26,7 @@ use crate::platform_impl::platform::r#async::DispatchRunner;
 use crate::platform_impl::platform::window::Inner;
 use crate::window::WindowId;
 
+#[derive(Debug)]
 pub struct Shared(Rc<Execution>);
 
 impl Clone for Shared {
@@ -68,6 +69,12 @@ struct Execution {
     on_visibility_change: OnEventHandle<web_sys::Event>,
 }
 
+impl fmt::Debug for Execution {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Execution").finish_non_exhaustive()
+    }
+}
+
 enum RunnerEnum {
     /// The `EventLoop` is created but not being run.
     Pending,
@@ -96,6 +103,16 @@ struct Runner {
     event_loop: ActiveEventLoop,
 }
 
+impl fmt::Debug for Runner {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Runner")
+            .field("state", &self.state)
+            .field("app", &"<ApplicationHandler>")
+            .field("event_loop", &self.event_loop)
+            .finish()
+    }
+}
+
 impl Runner {
     pub fn new(app: Box<dyn ApplicationHandler>, event_loop: ActiveEventLoop) -> Self {
         Runner { state: State::Init, app, event_loop }
@@ -141,7 +158,6 @@ impl Runner {
             Event::Resumed => self.app.resumed(&self.event_loop),
             Event::CreateSurfaces => self.app.can_create_surfaces(&self.event_loop),
             Event::AboutToWait => self.app.about_to_wait(&self.event_loop),
-            Event::LoopExiting => self.app.exiting(&self.event_loop),
         }
     }
 }
@@ -622,7 +638,9 @@ impl Shared {
         self.apply_control_flow();
         // We don't call `handle_loop_destroyed` here because we don't need to
         // perform cleanup when the Web browser is going to destroy the page.
-        self.handle_event(Event::LoopExiting);
+        //
+        // We do want to run the application handler's `Drop` impl.
+        *self.0.runner.borrow_mut() = RunnerEnum::Destroyed;
     }
 
     // handle_event takes in events and either queues them or applies a callback
@@ -720,7 +738,6 @@ impl Shared {
     }
 
     fn handle_loop_destroyed(&self) {
-        self.handle_event(Event::LoopExiting);
         let all_canvases = std::mem::take(&mut *self.0.all_canvases.borrow_mut());
         *self.0.page_transition_event_handle.borrow_mut() = None;
         *self.0.on_mouse_move.borrow_mut() = None;
@@ -862,6 +879,5 @@ pub(crate) enum Event {
     CreateSurfaces,
     Resumed,
     AboutToWait,
-    LoopExiting,
     UserWakeUp,
 }

src/platform_impl/web/event_loop/window_target.rs

@@ -18,14 +18,14 @@ use crate::event_loop::{
     EventLoopProxy as RootEventLoopProxy, OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
 use crate::keyboard::ModifiersState;
-use crate::monitor::MonitorHandle as RootMonitorHandle;
+use crate::monitor::MonitorHandle as CoremMonitorHandle;
 use crate::platform::web::{CustomCursorFuture, PollStrategy, WaitUntilStrategy};
 use crate::platform_impl::platform::cursor::CustomCursor;
 use crate::platform_impl::web::event_loop::proxy::EventLoopProxy;
 use crate::platform_impl::Window;
-use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme, WindowId};
+use crate::window::{CustomCursor as CoreCustomCursor, CustomCursorSource, Theme, WindowId};
 
-#[derive(Default)]
+#[derive(Default, Debug)]
 struct ModifiersShared(Rc<Cell<ModifiersState>>);
 
 impl ModifiersShared {
@@ -44,7 +44,7 @@ impl Clone for ModifiersShared {
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct ActiveEventLoop {
     pub(crate) runner: runner::Shared,
     modifiers: ModifiersShared,
@@ -65,7 +65,7 @@ impl ActiveEventLoop {
     }
 
     pub fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture {
-        CustomCursorFuture(CustomCursor::new_async(self, source.inner))
+        CustomCursorFuture(CustomCursor::new_async(self, source))
     }
 
     pub fn register(&self, canvas: &Rc<backend::Canvas>, window_id: WindowId) {
@@ -498,22 +498,22 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_custom_cursor(
         &self,
         source: CustomCursorSource,
-    ) -> Result<RootCustomCursor, RequestError> {
-        Ok(RootCustomCursor { inner: CustomCursor::new(self, source.inner) })
+    ) -> Result<CoreCustomCursor, RequestError> {
+        Ok(CoreCustomCursor(Arc::new(CustomCursor::new(self, source))))
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoremMonitorHandle>> {
         Box::new(
             self.runner
                 .monitor()
                 .available_monitors()
                 .into_iter()
-                .map(|inner| RootMonitorHandle { inner }),
+                .map(|monitor| CoremMonitorHandle(Arc::new(monitor))),
         )
     }
 
-    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
-        self.runner.monitor().primary_monitor().map(|inner| RootMonitorHandle { inner })
+    fn primary_monitor(&self) -> Option<CoremMonitorHandle> {
+        self.runner.monitor().primary_monitor().map(|monitor| CoremMonitorHandle(Arc::new(monitor)))
     }
 
     fn listen_device_events(&self, allowed: DeviceEvents) {

src/platform_impl/web/keyboard.rs

@@ -18,11 +18,13 @@ impl Key {
             "Shift" => NamedKey::Shift,
             "Symbol" => NamedKey::Symbol,
             "SymbolLock" => NamedKey::SymbolLock,
+            #[allow(deprecated)]
+            "Super" => NamedKey::Super,
+            #[allow(deprecated)]
             "Hyper" => NamedKey::Hyper,
-            "Meta" => NamedKey::Super,
+            "Meta" => NamedKey::Meta,
             "Enter" => NamedKey::Enter,
             "Tab" => NamedKey::Tab,
-            " " => NamedKey::Space,
             "ArrowDown" => NamedKey::ArrowDown,
             "ArrowLeft" => NamedKey::ArrowLeft,
             "ArrowRight" => NamedKey::ArrowRight,
@@ -378,8 +380,8 @@ impl PhysicalKey {
             "ControlLeft" => KeyCode::ControlLeft,
             "ControlRight" => KeyCode::ControlRight,
             "Enter" => KeyCode::Enter,
-            "MetaLeft" => KeyCode::SuperLeft,
-            "MetaRight" => KeyCode::SuperRight,
+            "MetaLeft" => KeyCode::MetaLeft,
+            "MetaRight" => KeyCode::MetaRight,
             "ShiftLeft" => KeyCode::ShiftLeft,
             "ShiftRight" => KeyCode::ShiftRight,
             "Space" => KeyCode::Space,
@@ -462,7 +464,11 @@ impl PhysicalKey {
             "AudioVolumeMute" => KeyCode::AudioVolumeMute,
             "AudioVolumeUp" => KeyCode::AudioVolumeUp,
             "WakeUp" => KeyCode::WakeUp,
+            #[allow(deprecated)]
+            "Super" => KeyCode::Super,
+            #[allow(deprecated)]
             "Hyper" => KeyCode::Hyper,
+            #[allow(deprecated)]
             "Turbo" => KeyCode::Turbo,
             "Abort" => KeyCode::Abort,
             "Resume" => KeyCode::Resume,

src/platform_impl/web/mod.rs

@@ -32,10 +32,7 @@ mod monitor;
 mod web_sys;
 mod window;
 
-pub(crate) use cursor::{
-    CustomCursor as PlatformCustomCursor, CustomCursorFuture,
-    CustomCursorSource as PlatformCustomCursorSource,
-};
+pub(crate) use cursor::CustomCursorFuture;
 
 pub(crate) use self::event_loop::{
     ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
@@ -45,4 +42,3 @@ pub(crate) use self::monitor::{
 };
 use self::web_sys as backend;
 pub use self::window::{PlatformSpecificWindowAttributes, Window};
-pub(crate) use crate::icon::NoIcon as PlatformIcon;

src/platform_impl/web/monitor.rs

@@ -8,7 +8,7 @@ use std::num::NonZeroU16;
 use std::ops::{Deref, DerefMut};
 use std::pin::Pin;
 use std::rc::{Rc, Weak};
-use std::sync::OnceLock;
+use std::sync::{Arc, OnceLock};
 use std::task::{ready, Context, Poll};
 
 use dpi::LogicalSize;
@@ -28,7 +28,7 @@ use super::main_thread::MainThreadMarker;
 use super::r#async::{Dispatcher, Notified, Notifier};
 use super::web_sys::{Engine, EventListenerHandle};
 use crate::dpi::{PhysicalPosition, PhysicalSize};
-use crate::monitor::{MonitorHandle as RootMonitorHandle, VideoMode};
+use crate::monitor::{MonitorHandle as CoreMonitorHandle, MonitorHandleProvider, VideoMode};
 use crate::platform::web::{
     MonitorPermissionError, Orientation, OrientationData, OrientationLock, OrientationLockError,
 };
@@ -46,30 +46,6 @@ impl MonitorHandle {
         Self { id, inner: Dispatcher::new(main_thread, inner).0 }
     }
 
-    pub fn scale_factor(&self) -> f64 {
-        self.inner.queue(|inner| inner.scale_factor())
-    }
-
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        self.inner.queue(|inner| inner.position())
-    }
-
-    pub fn name(&self) -> Option<String> {
-        self.inner.queue(|inner| inner.name())
-    }
-
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        Some(VideoMode {
-            size: self.inner.queue(|inner| inner.size()),
-            bit_depth: self.inner.queue(|inner| inner.bit_depth()),
-            refresh_rate_millihertz: None,
-        })
-    }
-
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        self.current_video_mode().into_iter()
-    }
-
     pub fn orientation(&self) -> OrientationData {
         self.inner.queue(|inner| inner.orientation())
     }
@@ -143,6 +119,40 @@ impl MonitorHandle {
     }
 }
 
+impl MonitorHandleProvider for MonitorHandle {
+    fn id(&self) -> u128 {
+        self.native_id() as _
+    }
+
+    fn native_id(&self) -> u64 {
+        self.id.unwrap_or_default()
+    }
+
+    fn scale_factor(&self) -> f64 {
+        self.inner.queue(|inner| inner.scale_factor())
+    }
+
+    fn position(&self) -> Option<PhysicalPosition<i32>> {
+        self.inner.queue(|inner| inner.position())
+    }
+
+    fn name(&self) -> Option<std::borrow::Cow<'_, str>> {
+        self.inner.queue(|inner| inner.name().map(Into::into))
+    }
+
+    fn current_video_mode(&self) -> Option<VideoMode> {
+        Some(VideoMode {
+            size: self.inner.queue(|inner| inner.size()),
+            bit_depth: self.inner.queue(|inner| inner.bit_depth()),
+            refresh_rate_millihertz: None,
+        })
+    }
+
+    fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
+        Box::new(self.current_video_mode().into_iter())
+    }
+}
+
 impl Debug for MonitorHandle {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let (name, position, scale_factor, orientation, is_internal, is_detailed) =
@@ -192,9 +202,9 @@ impl PartialOrd for MonitorHandle {
     }
 }
 
-impl From<MonitorHandle> for RootMonitorHandle {
-    fn from(inner: MonitorHandle) -> Self {
-        RootMonitorHandle { inner }
+impl From<MonitorHandle> for CoreMonitorHandle {
+    fn from(monitor: MonitorHandle) -> Self {
+        CoreMonitorHandle(Arc::new(monitor))
     }
 }