Fix docs link

Make error infrastructure more backend agnostic and let backends
just forward the os errors opaquely.

.github/workflows/ci.yml

@@ -68,7 +68,8 @@ jobs:
           - { name: 'Wayland',            target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: '--no-default-features --features=wayland,wayland-dlopen' }
           - { name: 'Android',            target: aarch64-linux-android,    os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
           - { name: 'Redox OS',           target: x86_64-unknown-redox,     os: ubuntu-latest,   }
-          - { name: 'macOS',              target: x86_64-apple-darwin,      os: macos-latest,    }
+          - { name: 'macOS x86_64',       target: x86_64-apple-darwin,      os: macos-latest,    }
+          - { name: 'macOS Aarch64',      target: aarch64-apple-darwin,     os: macos-latest,    }
           - { name: 'iOS x86_64',         target: x86_64-apple-ios,         os: macos-latest,    }
           - { name: 'iOS Aarch64',        target: aarch64-apple-ios,        os: macos-latest,    }
           - { name: 'Web',                target: wasm32-unknown-unknown,   os: ubuntu-latest,   }
@@ -243,10 +244,11 @@ jobs:
           - { name: 'Android', target: aarch64-linux-android }
           - { name: 'iOS', target: aarch64-apple-ios }
           - { name: 'Linux', target: x86_64-unknown-linux-gnu }
-          - { name: 'macOS', target: x86_64-apple-darwin }
+          - { name: 'macOS', target: aarch64-apple-darwin }
           - { name: 'Redox OS', target: x86_64-unknown-redox }
           - { name: 'Web', target: wasm32-unknown-unknown }
-          - { name: 'Windows', target: x86_64-pc-windows-gnu }
+          - { name: 'Windows GNU', target: x86_64-pc-windows-gnu }
+          - { name: 'Windows MSVC', target: x86_64-pc-windows-msvc }
 
     steps:
     - uses: taiki-e/checkout-action@v1

Cargo.toml

@@ -21,7 +21,7 @@ name = "winit"
 readme = "README.md"
 repository.workspace = true
 rust-version.workspace = true
-version = "0.30.4"
+version = "0.30.5"
 
 [package.metadata.docs.rs]
 features = [
@@ -38,12 +38,13 @@ targets = [
     "i686-pc-windows-msvc",
     "x86_64-pc-windows-msvc",
     # macOS
+    "aarch64-apple-darwin",
     "x86_64-apple-darwin",
     # Unix (X11 & Wayland)
     "i686-unknown-linux-gnu",
     "x86_64-unknown-linux-gnu",
     # iOS
-    "x86_64-apple-ios",
+    "aarch64-apple-ios",
     # Android
     "aarch64-linux-android",
     # Web
@@ -105,12 +106,12 @@ ndk = { version = "0.9.0", default-features = false }
 
 # AppKit or UIKit
 [target.'cfg(target_vendor = "apple")'.dependencies]
+block2 = "0.5.1"
 core-foundation = "0.9.3"
 objc2 = "0.5.2"
 
 # AppKit
 [target.'cfg(target_os = "macos")'.dependencies]
-block2 = "0.5.1"
 core-graphics = "0.23.1"
 objc2-app-kit = { version = "0.2.2", features = [
     "NSAppearance",
@@ -152,6 +153,7 @@ objc2-foundation = { version = "0.2.2", features = [
     "NSKeyValueObserving",
     "NSNotification",
     "NSObjCRuntime",
+    "NSOperation",
     "NSPathUtilities",
     "NSProcessInfo",
     "NSRunLoop",
@@ -163,11 +165,13 @@ objc2-foundation = { version = "0.2.2", features = [
 # UIKit
 [target.'cfg(all(target_vendor = "apple", not(target_os = "macos")))'.dependencies]
 objc2-foundation = { version = "0.2.2", features = [
+    "block2",
     "dispatch",
     "NSArray",
     "NSEnumerator",
     "NSGeometry",
     "NSObjCRuntime",
+    "NSOperation",
     "NSString",
     "NSProcessInfo",
     "NSThread",
@@ -179,6 +183,8 @@ objc2-ui-kit = { version = "0.2.2", features = [
     "UIEvent",
     "UIGeometry",
     "UIGestureRecognizer",
+    "UITextInput",
+    "UITextInputTraits",
     "UIOrientation",
     "UIPanGestureRecognizer",
     "UIPinchGestureRecognizer",
@@ -251,6 +257,7 @@ wayland-protocols-plasma = { version = "0.3.2", features = ["client"], optional
 x11-dl = { version = "2.19.1", optional = true }
 x11rb = { version = "0.13.0", default-features = false, features = [
     "allow-unsafe-code",
+    "cursor",
     "dl-libxcb",
     "randr",
     "resource_manager",
@@ -267,12 +274,12 @@ redox_syscall = "0.4.1"
 
 # Web
 [target.'cfg(target_family = "wasm")'.dependencies]
-js-sys = "0.3.64"
+js-sys = "0.3.70"
 pin-project = "1"
-wasm-bindgen = "0.2"
-wasm-bindgen-futures = "0.4"
+wasm-bindgen = "0.2.93"
+wasm-bindgen-futures = "0.4.43"
 web-time = "1"
-web_sys = { package = "web-sys", version = "0.3.64", features = [
+web_sys = { package = "web-sys", version = "0.3.70", features = [
     "AbortController",
     "AbortSignal",
     "Blob",

README.md

@@ -8,7 +8,7 @@
 
 ```toml
 [dependencies]
-winit = "0.30.4"
+winit = "0.30.5"
 ```
 
 ## [Documentation](https://docs.rs/winit)

deny.toml

@@ -7,6 +7,7 @@
 all-features = true
 exclude-dev = true
 targets = [
+    { triple = "aarch64-apple-darwin" },
     { triple = "aarch64-apple-ios" },
     { triple = "aarch64-linux-android" },
     { triple = "i686-pc-windows-gnu" },
@@ -54,19 +55,6 @@ crate = "android-activity"
 allow-globs = ["freetype2/*"]
 crate = "freetype-sys"
 
-[[bans.build.bypass]]
-allow = [
-    { path = "releases/friends.sh", checksum = "f896ccdcb8445d29ed6dd0d9a360f94d4f33af2f1cc9965e7bb38b156c45949d" },
-]
-crate = "wasm-bindgen"
-
-[[bans.build.bypass]]
-allow = [
-    { path = "ui-tests/update-all-references.sh", checksum = "8b8dbf31e7ada1314956db7a20ab14b13af3ae246a6295afdc7dc96af8ec3773" },
-    { path = "ui-tests/update-references.sh", checksum = "65375c25981646e08e8589449a06be4505b1a2c9e10d35f650be4b1b495dff22" },
-]
-crate = "wasm-bindgen-macro"
-
 [[bans.build.bypass]]
 allow-globs = ["lib/*.a"]
 crate = "windows_i686_gnu"

dpi/Cargo.toml

@@ -26,12 +26,13 @@ targets = [
     "i686-pc-windows-msvc",
     "x86_64-pc-windows-msvc",
     # macOS
+    "aarch64-apple-darwin",
     "x86_64-apple-darwin",
     # Unix (X11 & Wayland)
     "i686-unknown-linux-gnu",
     "x86_64-unknown-linux-gnu",
     # iOS
-    "x86_64-apple-ios",
+    "aarch64-apple-ios",
     # Android
     "aarch64-linux-android",
     # Web

examples/child_window.rs

@@ -8,7 +8,7 @@ fn main() -> Result<(), impl std::error::Error> {
     use winit::event::{ElementState, KeyEvent, WindowEvent};
     use winit::event_loop::{ActiveEventLoop, EventLoop};
     use winit::raw_window_handle::HasRawWindowHandle;
-    use winit::window::{Window, WindowId};
+    use winit::window::{Window, WindowAttributes, WindowId};
 
     #[path = "util/fill.rs"]
     mod fill;
@@ -16,15 +16,15 @@ fn main() -> Result<(), impl std::error::Error> {
     #[derive(Default)]
     struct Application {
         parent_window_id: Option<WindowId>,
-        windows: HashMap<WindowId, Window>,
+        windows: HashMap<WindowId, Box<dyn Window>>,
     }
 
     impl ApplicationHandler for Application {
         fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-            let attributes = Window::default_attributes()
+            let attributes = WindowAttributes::default()
                 .with_title("parent window")
                 .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
-                .with_inner_size(LogicalSize::new(640.0f32, 480.0f32));
+                .with_surface_size(LogicalSize::new(640.0f32, 480.0f32));
             let window = event_loop.create_window(attributes).unwrap();
 
             println!("Parent window id: {:?})", window.id());
@@ -57,14 +57,14 @@ fn main() -> Result<(), impl std::error::Error> {
                     ..
                 } => {
                     let parent_window = self.windows.get(&self.parent_window_id.unwrap()).unwrap();
-                    let child_window = spawn_child_window(parent_window, event_loop);
+                    let child_window = spawn_child_window(parent_window.as_ref(), event_loop);
                     let child_id = child_window.id();
                     println!("Child window created with id: {child_id:?}");
                     self.windows.insert(child_id, child_window);
                 },
                 WindowEvent::RedrawRequested => {
                     if let Some(window) = self.windows.get(&window_id) {
-                        fill::fill_window(window);
+                        fill::fill_window(window.as_ref());
                     }
                 },
                 _ => (),
@@ -72,11 +72,14 @@ fn main() -> Result<(), impl std::error::Error> {
         }
     }
 
-    fn spawn_child_window(parent: &Window, event_loop: &dyn ActiveEventLoop) -> Window {
+    fn spawn_child_window(
+        parent: &dyn Window,
+        event_loop: &dyn ActiveEventLoop,
+    ) -> Box<dyn Window> {
         let parent = parent.raw_window_handle().unwrap();
-        let mut window_attributes = Window::default_attributes()
+        let mut window_attributes = WindowAttributes::default()
             .with_title("child window")
-            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
+            .with_surface_size(LogicalSize::new(200.0f32, 200.0f32))
             .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
             .with_visible(true);
         // `with_parent_window` is unsafe. Parent window must be a valid window.

examples/control_flow.rs

@@ -11,7 +11,7 @@ use winit::application::ApplicationHandler;
 use winit::event::{ElementState, KeyEvent, StartCause, WindowEvent};
 use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
-use winit::window::{Window, WindowId};
+use winit::window::{Window, WindowAttributes, WindowId};
 
 #[path = "util/fill.rs"]
 mod fill;
@@ -52,7 +52,7 @@ struct ControlFlowDemo {
     request_redraw: bool,
     wait_cancelled: bool,
     close_requested: bool,
-    window: Option<Window>,
+    window: Option<Box<dyn Window>>,
 }
 
 impl ApplicationHandler for ControlFlowDemo {
@@ -66,7 +66,7 @@ impl ApplicationHandler for ControlFlowDemo {
     }
 
     fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-        let window_attributes = Window::default_attributes().with_title(
+        let window_attributes = WindowAttributes::default().with_title(
             "Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.",
         );
         self.window = Some(event_loop.create_window(window_attributes).unwrap());
@@ -114,7 +114,7 @@ impl ApplicationHandler for ControlFlowDemo {
             WindowEvent::RedrawRequested => {
                 let window = self.window.as_ref().unwrap();
                 window.pre_present_notify();
-                fill::fill_window(window);
+                fill::fill_window(window.as_ref());
             },
             _ => (),
         }

examples/pump_events.rs

@@ -11,19 +11,19 @@ fn main() -> std::process::ExitCode {
     use winit::event::WindowEvent;
     use winit::event_loop::{ActiveEventLoop, EventLoop};
     use winit::platform::pump_events::{EventLoopExtPumpEvents, PumpStatus};
-    use winit::window::{Window, WindowId};
+    use winit::window::{Window, WindowAttributes, WindowId};
 
     #[path = "util/fill.rs"]
     mod fill;
 
     #[derive(Default)]
     struct PumpDemo {
-        window: Option<Window>,
+        window: Option<Box<dyn Window>>,
     }
 
     impl ApplicationHandler for PumpDemo {
         fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-            let window_attributes = Window::default_attributes().with_title("A fantastic window!");
+            let window_attributes = WindowAttributes::default().with_title("A fantastic window!");
             self.window = Some(event_loop.create_window(window_attributes).unwrap());
         }
 
@@ -43,7 +43,7 @@ fn main() -> std::process::ExitCode {
             match event {
                 WindowEvent::CloseRequested => event_loop.exit(),
                 WindowEvent::RedrawRequested => {
-                    fill::fill_window(window);
+                    fill::fill_window(window.as_ref());
                     window.request_redraw();
                 },
                 _ => (),

examples/run_on_demand.rs

@@ -9,7 +9,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     use winit::event::WindowEvent;
     use winit::event_loop::{ActiveEventLoop, EventLoop};
     use winit::platform::run_on_demand::EventLoopExtRunOnDemand;
-    use winit::window::{Window, WindowId};
+    use winit::window::{Window, WindowAttributes, WindowId};
 
     #[path = "util/fill.rs"]
     mod fill;
@@ -18,7 +18,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     struct App {
         idx: usize,
         window_id: Option<WindowId>,
-        window: Option<Window>,
+        window: Option<Box<dyn Window>>,
     }
 
     impl ApplicationHandler for App {
@@ -29,9 +29,9 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
 
         fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-            let window_attributes = Window::default_attributes()
+            let window_attributes = WindowAttributes::default()
                 .with_title("Fantastic window number one!")
-                .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0));
+                .with_surface_size(winit::dpi::LogicalSize::new(128.0, 128.0));
             let window = event_loop.create_window(window_attributes).unwrap();
             self.window_id = Some(window.id());
             self.window = Some(window);
@@ -65,11 +65,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                          CloseRequested",
                         self.idx
                     );
-                    fill::cleanup_window(window);
+                    fill::cleanup_window(window.as_ref());
                     self.window = None;
                 },
                 WindowEvent::RedrawRequested => {
-                    fill::fill_window(window);
+                    fill::fill_window(window.as_ref());
                 },
                 _ => (),
             }

examples/util/fill.rs

@@ -34,18 +34,20 @@ mod platform {
     /// The graphics context used to draw to a window.
     struct GraphicsContext {
         /// The global softbuffer context.
-        context: RefCell<Context<&'static Window>>,
+        context: RefCell<Context<&'static dyn Window>>,
 
         /// The hash map of window IDs to surfaces.
-        surfaces: HashMap<WindowId, Surface<&'static Window, &'static Window>>,
+        surfaces: HashMap<WindowId, Surface<&'static dyn Window, &'static dyn Window>>,
     }
 
     impl GraphicsContext {
-        fn new(w: &Window) -> Self {
+        fn new(w: &dyn Window) -> Self {
             Self {
                 context: RefCell::new(
-                    Context::new(unsafe { mem::transmute::<&'_ Window, &'static Window>(w) })
-                        .expect("Failed to create a softbuffer context"),
+                    Context::new(unsafe {
+                        mem::transmute::<&'_ dyn Window, &'static dyn Window>(w)
+                    })
+                    .expect("Failed to create a softbuffer context"),
                 ),
                 surfaces: HashMap::new(),
             }
@@ -53,24 +55,24 @@ mod platform {
 
         fn create_surface(
             &mut self,
-            window: &Window,
-        ) -> &mut Surface<&'static Window, &'static Window> {
+            window: &dyn Window,
+        ) -> &mut Surface<&'static dyn Window, &'static dyn Window> {
             self.surfaces.entry(window.id()).or_insert_with(|| {
                 Surface::new(&self.context.borrow(), unsafe {
-                    mem::transmute::<&'_ Window, &'static Window>(window)
+                    mem::transmute::<&'_ dyn Window, &'static dyn Window>(window)
                 })
                 .expect("Failed to create a softbuffer surface")
             })
         }
 
-        fn destroy_surface(&mut self, window: &Window) {
+        fn destroy_surface(&mut self, window: &dyn Window) {
             self.surfaces.remove(&window.id());
         }
     }
 
-    pub fn fill_window(window: &Window) {
+    pub fn fill_window(window: &dyn Window) {
         GC.with(|gc| {
-            let size = window.inner_size();
+            let size = window.surface_size();
             let (Some(width), Some(height)) =
                 (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
             else {
@@ -94,7 +96,7 @@ mod platform {
     }
 
     #[allow(dead_code)]
-    pub fn cleanup_window(window: &Window) {
+    pub fn cleanup_window(window: &dyn Window) {
         GC.with(|gc| {
             let mut gc = gc.borrow_mut();
             if let Some(context) = gc.as_mut() {
@@ -106,12 +108,12 @@ mod platform {
 
 #[cfg(not(all(feature = "rwh_06", not(any(target_os = "android", target_os = "ios")))))]
 mod platform {
-    pub fn fill_window(_window: &winit::window::Window) {
+    pub fn fill_window(_window: &dyn winit::window::Window) {
         // No-op on mobile platforms.
     }
 
     #[allow(dead_code)]
-    pub fn cleanup_window(_window: &winit::window::Window) {
+    pub fn cleanup_window(_window: &dyn winit::window::Window) {
         // No-op on mobile platforms.
     }
 }

examples/window.rs

@@ -17,7 +17,7 @@ use rwh_06::{DisplayHandle, HasDisplayHandle};
 use softbuffer::{Context, Surface};
 use winit::application::ApplicationHandler;
 use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
-use winit::error::ExternalError;
+use winit::error::RequestError;
 use winit::event::{DeviceEvent, DeviceId, Ime, MouseButton, MouseScrollDelta, WindowEvent};
 use winit::event_loop::{ActiveEventLoop, EventLoop};
 use winit::keyboard::{Key, ModifiersState};
@@ -27,12 +27,11 @@ use winit::platform::macos::{OptionAsAlt, WindowAttributesExtMacOS, WindowExtMac
 use winit::platform::startup_notify::{
     self, EventLoopExtStartupNotify, WindowAttributesExtStartupNotify, WindowExtStartupNotify,
 };
-use winit::platform::wayland::{EventLoopExtWayland, WaylandApplicationHandler};
 #[cfg(web_platform)]
 use winit::platform::web::{ActiveEventLoopExtWeb, CustomCursorExtWeb, WindowAttributesExtWeb};
 use winit::window::{
     Cursor, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, Icon, ResizeDirection,
-    Theme, Window, WindowId,
+    Theme, Window, WindowAttributes, WindowId,
 };
 
 #[path = "util/tracing.rs"]
@@ -47,7 +46,7 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     tracing::init();
 
-    let mut event_loop = EventLoop::new()?;
+    let event_loop = EventLoop::new()?;
     let (sender, receiver) = mpsc::channel();
 
     // Wire the user event from another thread.
@@ -68,7 +67,6 @@ fn main() -> Result<(), Box<dyn Error>> {
     }
 
     let app = Application::new(&event_loop, receiver, sender);
-    event_loop.register_wayland_callback::<Application>();
     Ok(event_loop.run_app(app)?)
 }
 
@@ -78,7 +76,7 @@ struct Application {
     receiver: Receiver<Action>,
     sender: Sender<Action>,
     /// Custom cursors assets.
-    custom_cursors: Result<Vec<CustomCursor>, ExternalError>,
+    custom_cursors: Result<Vec<CustomCursor>, RequestError>,
     /// Application icon.
     icon: Icon,
     windows: HashMap<WindowId, WindowState>,
@@ -137,7 +135,7 @@ impl Application {
         // TODO read-out activation token.
 
         #[allow(unused_mut)]
-        let mut window_attributes = Window::default_attributes()
+        let mut window_attributes = WindowAttributes::default()
             .with_title("Winit window")
             .with_transparent(true)
             .with_window_icon(Some(self.icon.clone()));
@@ -373,11 +371,6 @@ impl Application {
 }
 
 impl ApplicationHandler for Application {
-    fn as_any(&mut self) -> Option<&mut dyn std::any::Any> {
-        println!("Called");
-        Some(self)
-    }
-
     fn proxy_wake_up(&mut self, event_loop: &dyn ActiveEventLoop) {
         while let Ok(action) = self.receiver.try_recv() {
             self.handle_action_from_proxy(event_loop, action)
@@ -396,7 +389,7 @@ impl ApplicationHandler for Application {
         };
 
         match event {
-            WindowEvent::Resized(size) => {
+            WindowEvent::SurfaceResized(size) => {
                 window.resize(size);
             },
             WindowEvent::Focused(focused) => {
@@ -559,12 +552,6 @@ impl ApplicationHandler for Application {
     }
 }
 
-impl WaylandApplicationHandler for Application {
-    fn wayland_callback(&mut self) {
-        println!("Wayland callback!");
-    }
-}
-
 /// State of the window.
 struct WindowState {
     /// IME input.
@@ -573,9 +560,9 @@ struct WindowState {
     ///
     /// NOTE: This surface must be dropped before the `Window`.
     #[cfg(not(any(android_platform, ios_platform)))]
-    surface: Surface<DisplayHandle<'static>, Arc<Window>>,
+    surface: Surface<DisplayHandle<'static>, Arc<dyn Window>>,
     /// The actual winit Window.
-    window: Arc<Window>,
+    window: Arc<dyn Window>,
     /// The window theme we're drawing with.
     theme: Theme,
     /// Cursor position over the window.
@@ -603,8 +590,8 @@ struct WindowState {
 }
 
 impl WindowState {
-    fn new(app: &Application, window: Window) -> Result<Self, Box<dyn Error>> {
-        let window = Arc::new(window);
+    fn new(app: &Application, window: Box<dyn Window>) -> Result<Self, Box<dyn Error>> {
+        let window: Arc<dyn Window> = Arc::from(window);
 
         // SAFETY: the surface is dropped before the `window` which provided it with handle, thus
         // it doesn't outlive it.
@@ -614,13 +601,13 @@ impl WindowState {
         let theme = window.theme().unwrap_or(Theme::Dark);
         info!("Theme: {theme:?}");
         let named_idx = 0;
-        window.set_cursor(CURSORS[named_idx]);
+        window.set_cursor(CURSORS[named_idx].into());
 
         // Allow IME out of the box.
         let ime = true;
         window.set_ime_allowed(ime);
 
-        let size = window.inner_size();
+        let size = window.surface_size();
         let mut state = Self {
             #[cfg(macos_platform)]
             option_as_alt: window.option_as_alt(),
@@ -649,7 +636,7 @@ impl WindowState {
         self.ime = !self.ime;
         self.window.set_ime_allowed(self.ime);
         if let Some(position) = self.ime.then_some(self.cursor_position).flatten() {
-            self.window.set_ime_cursor_area(position, PhysicalSize::new(20, 20));
+            self.window.set_ime_cursor_area(position.into(), PhysicalSize::new(20, 20).into());
         }
     }
 
@@ -660,7 +647,7 @@ impl WindowState {
     pub fn cursor_moved(&mut self, position: PhysicalPosition<f64>) {
         self.cursor_position = Some(position);
         if self.ime {
-            self.window.set_ime_cursor_area(position, PhysicalSize::new(20, 20));
+            self.window.set_ime_cursor_area(position.into(), PhysicalSize::new(20, 20).into());
         }
     }
 
@@ -694,12 +681,12 @@ impl WindowState {
 
     /// Toggle resize increments on a window.
     fn toggle_resize_increments(&mut self) {
-        let new_increments = match self.window.resize_increments() {
+        let new_increments = match self.window.surface_resize_increments() {
             Some(_) => None,
-            None => Some(LogicalSize::new(25.0, 25.0)),
+            None => Some(LogicalSize::new(25.0, 25.0).into()),
         };
         info!("Had increments: {}", new_increments.is_none());
-        self.window.set_resize_increments(new_increments);
+        self.window.set_surface_resize_increments(new_increments);
     }
 
     /// Toggle fullscreen.
@@ -738,22 +725,22 @@ impl WindowState {
         self.window.set_option_as_alt(self.option_as_alt);
     }
 
-    /// Swap the window dimensions with `request_inner_size`.
+    /// Swap the window dimensions with `request_surface_size`.
     fn swap_dimensions(&mut self) {
-        let old_inner_size = self.window.inner_size();
-        let mut inner_size = old_inner_size;
+        let old_surface_size = self.window.surface_size();
+        let mut surface_size = old_surface_size;
 
-        mem::swap(&mut inner_size.width, &mut inner_size.height);
-        info!("Requesting resize from {old_inner_size:?} to {inner_size:?}");
+        mem::swap(&mut surface_size.width, &mut surface_size.height);
+        info!("Requesting resize from {old_surface_size:?} to {surface_size:?}");
 
-        if let Some(new_inner_size) = self.window.request_inner_size(inner_size) {
-            if old_inner_size == new_inner_size {
+        if let Some(new_surface_size) = self.window.request_surface_size(surface_size.into()) {
+            if old_surface_size == new_surface_size {
                 info!("Inner size change got ignored");
             } else {
-                self.resize(new_inner_size);
+                self.resize(new_surface_size);
             }
         } else {
-            info!("Request inner size is asynchronous");
+            info!("Requesting surface size is asynchronous");
         }
     }
 
@@ -779,7 +766,7 @@ impl WindowState {
     ) -> Result<(), Box<dyn Error>> {
         let cursor = event_loop.create_custom_cursor(url_custom_cursor())?;
 
-        self.window.set_cursor(cursor);
+        self.window.set_cursor(cursor.into());
 
         Ok(())
     }
@@ -801,14 +788,14 @@ impl WindowState {
         let cursor = CustomCursor::from_animation(Duration::from_secs(3), cursors).unwrap();
         let cursor = event_loop.create_custom_cursor(cursor)?;
 
-        self.window.set_cursor(cursor);
+        self.window.set_cursor(cursor.into());
 
         Ok(())
     }
 
-    /// Resize the window to the new size.
+    /// Resize the surface to the new size.
     fn resize(&mut self, size: PhysicalSize<u32>) {
-        info!("Resized to {size:?}");
+        info!("Surface resized to {size:?}");
         #[cfg(not(any(android_platform, ios_platform)))]
         {
             let (width, height) = match (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
@@ -830,7 +817,7 @@ impl WindowState {
     /// Show window menu.
     fn show_menu(&self) {
         if let Some(position) = self.cursor_position {
-            self.window.show_window_menu(position);
+            self.window.show_window_menu(position.into());
         }
     }
 
@@ -853,7 +840,7 @@ impl WindowState {
             },
         };
 
-        let win_size = self.window.inner_size();
+        let win_size = self.window.surface_size();
         let border_size = BORDER_SIZE * self.window.scale_factor();
 
         let x_direction = if position.x < border_size {

examples/x11_embed.rs

@@ -7,21 +7,21 @@ fn main() -> Result<(), Box<dyn Error>> {
     use winit::event::WindowEvent;
     use winit::event_loop::{ActiveEventLoop, EventLoop};
     use winit::platform::x11::WindowAttributesExtX11;
-    use winit::window::{Window, WindowId};
+    use winit::window::{Window, WindowAttributes, WindowId};
 
     #[path = "util/fill.rs"]
     mod fill;
 
     pub struct XEmbedDemo {
         parent_window_id: u32,
-        window: Option<Window>,
+        window: Option<Box<dyn Window>>,
     }
 
     impl ApplicationHandler for XEmbedDemo {
         fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-            let window_attributes = Window::default_attributes()
+            let window_attributes = WindowAttributes::default()
                 .with_title("An embedded window!")
-                .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
+                .with_surface_size(winit::dpi::LogicalSize::new(128.0, 128.0))
                 .with_embed_parent_window(self.parent_window_id);
 
             self.window = Some(event_loop.create_window(window_attributes).unwrap());
@@ -38,7 +38,7 @@ fn main() -> Result<(), Box<dyn Error>> {
                 WindowEvent::CloseRequested => event_loop.exit(),
                 WindowEvent::RedrawRequested => {
                     window.pre_present_notify();
-                    fill::fill_window(window);
+                    fill::fill_window(window.as_ref());
                 },
                 _ => (),
             }

src/application.rs

@@ -1,7 +1,5 @@
 //! End user application handling.
 
-use std::any::Any;
-
 use crate::event::{DeviceEvent, DeviceId, StartCause, WindowEvent};
 use crate::event_loop::ActiveEventLoop;
 use crate::window::WindowId;
@@ -327,23 +325,10 @@ pub trait ApplicationHandler {
     fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
         let _ = event_loop;
     }
-
-    /// Get the [`ApplicationHandler`] as [`Any`].
-    ///
-    /// This is useful for downcasting to a concrete application type.
-    #[inline(always)]
-    fn as_any(&mut self) -> Option<&mut dyn Any> {
-        None
-    }
 }
 
 #[deny(clippy::missing_trait_methods)]
 impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
-    #[inline(always)]
-    fn as_any(&mut self) -> Option<&mut dyn Any> {
-        (**self).as_any()
-    }
-
     #[inline]
     fn new_events(&mut self, event_loop: &dyn ActiveEventLoop, cause: StartCause) {
         (**self).new_events(event_loop, cause);
@@ -412,11 +397,6 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
 
 #[deny(clippy::missing_trait_methods)]
 impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
-    #[inline(always)]
-    fn as_any(&mut self) -> Option<&mut dyn Any> {
-        (**self).as_any()
-    }
-
     #[inline]
     fn new_events(&mut self, event_loop: &dyn ActiveEventLoop, cause: StartCause) {
         (**self).new_events(event_loop, cause);

src/changelog/unreleased.md

@@ -43,29 +43,34 @@ changelog entry.
 ### Added
 
 - Add `ActiveEventLoop::create_proxy()`.
-- On Web, implement `Error` for `platform::web::CustomCursorError`.
 - On Web, add `ActiveEventLoopExtWeb::is_cursor_lock_raw()` to determine if
   `DeviceEvent::MouseMotion` is returning raw data, not OS accelerated, when using
   `CursorGrabMode::Locked`.
 - On Web, implement `MonitorHandle` and `VideoModeHandle`.
-  
+
   Without prompting the user for permission, only the current monitor is returned. But when
   prompting and being granted permission through
   `ActiveEventLoop::request_detailed_monitor_permission()`, access to all monitors and their
-  information is available. This "detailed monitors" can be used in `Window::set_fullscreen()` as
-  well.
-- On Android, add `{Active,}EventLoopExtAndroid::android_app()` to access the app used to create the loop.
-- Add `ActiveEventLoop::system_theme()`, returning the current system theme.
+  details is available. Handles created with "detailed monitor permissions" can be used in
+  `Window::set_fullscreen()` as well.
+
+  Keep in mind that handles do not auto-upgrade after permissions are granted and have to be
+  re-created to make full use of this feature.
 - Add `Touch::finger_id` with a new type `FingerId`.
 - On Web and Windows, add `FingerIdExt*::is_primary()`, exposing a way to determine
   the primary finger in a multi-touch interaction.
 - Implement `Clone`, `Copy`, `Debug`, `Deserialize`, `Eq`, `Hash`, `Ord`, `PartialEq`, `PartialOrd`
   and `Serialize` on many types.
 - Add `MonitorHandle::current_video_mode()`.
+- Add basic iOS IME support. The soft keyboard can now be shown using `Window::set_ime_allowed`.
+- On macOS, add `WindowExtMacOS::set_borderless_game` and `WindowAttributesExtMacOS::with_borderless_game`
+  to fully disable the menu bar and dock in Borderless Fullscreen as commonly done in games.
 
 ### Changed
 
 - Change `ActiveEventLoop` to be a trait.
+- Change `Window` to be a trait.
+- `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`.
 - Bump MSRV from `1.70` to `1.73`.
@@ -97,6 +102,28 @@ 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
+  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`.
+  - `InnerSizeWriter` to `SurfaceSizeWriter`.
+  - `WindowAttributes.inner_size` to `surface_size`.
+  - `WindowAttributes.min_inner_size` to `min_surface_size`.
+  - `WindowAttributes.max_inner_size` to `max_surface_size`.
+  - `WindowAttributes.resize_increments` to `surface_resize_increments`.
+  - `WindowAttributes::with_inner_size` to `with_surface_size`.
+  - `WindowAttributes::with_min_inner_size` to `with_min_surface_size`.
+  - `WindowAttributes::with_max_inner_size` to `with_max_surface_size`.
+  - `WindowAttributes::with_resize_increments` to `with_surface_resize_increments`.
+  - `Window::inner_size` to `surface_size`.
+  - `Window::request_inner_size` to `request_surface_size`.
+  - `Window::set_min_inner_size` to `set_min_surface_size`.
+  - `Window::set_max_inner_size` to `set_max_surface_size`.
+
+  To migrate, you can probably just replace all instances of `inner_size` with `surface_size` in your codebase.
 
 ### Removed
 
@@ -126,7 +153,4 @@ changelog entry.
 
 ### Fixed
 
-- On Web, pen events are now routed through to `WindowEvent::Cursor*`.
-- On macOS, fix panic when releasing not available monitor.
-- On MacOS, return the system theme in `Window::theme()` if no theme override is set.
 - On Orbital, `MonitorHandle::name()` now returns `None` instead of a dummy name.

src/changelog/v0.30.md

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

src/cursor.rs

@@ -50,7 +50,7 @@ impl From<CustomCursor> for Cursor {
 /// ```no_run
 /// # use winit::event_loop::ActiveEventLoop;
 /// # use winit::window::Window;
-/// # fn scope(event_loop: &dyn ActiveEventLoop, window: &Window) {
+/// # fn scope(event_loop: &dyn ActiveEventLoop, window: &dyn Window) {
 /// use winit::window::CustomCursor;
 ///
 /// let w = 10;
@@ -67,7 +67,7 @@ impl From<CustomCursor> for Cursor {
 /// };
 ///
 /// if let Ok(custom_cursor) = event_loop.create_custom_cursor(source) {
-///     window.set_cursor(custom_cursor.clone());
+///     window.set_cursor(custom_cursor.clone().into());
 /// }
 /// # }
 /// ```

src/error.rs

@@ -1,45 +1,40 @@
-use std::{error, fmt};
+use std::error::Error;
+use std::fmt::{self, Display};
 
-use crate::platform_impl;
-
-// TODO: Rename
-/// An error that may be generated when requesting Winit state
-#[derive(Debug)]
-pub enum ExternalError {
-    /// The operation is not supported by the backend.
-    NotSupported(NotSupportedError),
-    /// The operation was ignored.
-    Ignored,
-    /// The OS cannot perform the operation.
-    Os(OsError),
-}
-
-/// The error type for when the requested operation is not supported by the backend.
-#[derive(Clone, Copy, Default, Eq, Hash, PartialEq)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-pub struct NotSupportedError {
-    _marker: (),
-}
-
-/// The error type for when the OS cannot perform the requested operation.
-#[derive(Debug)]
-pub struct OsError {
-    line: u32,
-    file: &'static str,
-    error: platform_impl::OsError,
-}
-
-/// A general error that may occur while running the Winit event loop
+/// A general error that may occur while running or creating
+/// the event loop.
 #[derive(Debug)]
+#[non_exhaustive]
 pub enum EventLoopError {
-    /// The operation is not supported by the backend.
-    NotSupported(NotSupportedError),
-    /// The OS cannot perform the operation.
-    Os(OsError),
     /// The event loop can't be re-created.
     RecreationAttempt,
     /// Application has exit with an error status.
     ExitFailure(i32),
+    /// Got unspecified OS-specific error during the request.
+    Os(OsError),
+    /// Creating the event loop with the requested configuration is not supported.
+    NotSupported(NotSupportedError),
+}
+
+impl fmt::Display for EventLoopError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::RecreationAttempt => write!(f, "EventLoop can't be recreated"),
+            Self::Os(err) => err.fmt(f),
+            Self::ExitFailure(status) => write!(f, "Exit Failure: {status}"),
+            Self::NotSupported(err) => err.fmt(f),
+        }
+    }
+}
+
+impl Error for EventLoopError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        if let Self::Os(err) = self {
+            err.source()
+        } else {
+            None
+        }
+    }
 }
 
 impl From<OsError> for EventLoopError {
@@ -48,18 +43,102 @@ impl From<OsError> for EventLoopError {
     }
 }
 
-impl NotSupportedError {
-    #[inline]
-    #[allow(dead_code)]
-    pub(crate) fn new() -> NotSupportedError {
-        NotSupportedError { _marker: () }
+impl From<NotSupportedError> for EventLoopError {
+    fn from(value: NotSupportedError) -> Self {
+        Self::NotSupported(value)
     }
 }
 
+/// A general error that may occur during a request to the windowing system.
+#[derive(Debug)]
+#[non_exhaustive]
+pub enum RequestError {
+    /// The request is not supported.
+    NotSupported(NotSupportedError),
+    /// The request was ignored by the operating system.
+    Ignored,
+    /// Got unspecified OS specific error during the request.
+    Os(OsError),
+}
+
+impl Display for RequestError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::NotSupported(err) => err.fmt(f),
+            Self::Ignored => write!(f, "The request was ignored"),
+            Self::Os(err) => err.fmt(f),
+        }
+    }
+}
+impl Error for RequestError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        if let Self::Os(err) = self {
+            err.source()
+        } else {
+            None
+        }
+    }
+}
+
+impl From<NotSupportedError> for RequestError {
+    fn from(value: NotSupportedError) -> Self {
+        Self::NotSupported(value)
+    }
+}
+
+impl From<OsError> for RequestError {
+    fn from(value: OsError) -> Self {
+        Self::Os(value)
+    }
+}
+
+/// The requested operation is not supported.
+#[derive(Debug)]
+pub struct NotSupportedError {
+    /// The reason why a certain operation is not supported.
+    reason: &'static str,
+}
+
+impl NotSupportedError {
+    pub(crate) fn new(reason: &'static str) -> Self {
+        Self { reason }
+    }
+}
+
+impl fmt::Display for NotSupportedError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "Operation is not supported: {}", self.reason)
+    }
+}
+impl Error for NotSupportedError {}
+
+/// Unclassified error from the OS.
+#[derive(Debug)]
+pub struct OsError {
+    line: u32,
+    file: &'static str,
+    error: Box<dyn Error + Send + Sync + 'static>,
+}
+
 impl OsError {
     #[allow(dead_code)]
-    pub(crate) fn new(line: u32, file: &'static str, error: platform_impl::OsError) -> OsError {
-        OsError { line, file, error }
+    pub(crate) fn new(
+        line: u32,
+        file: &'static str,
+        error: impl Into<Box<dyn Error + Send + Sync + 'static>>,
+    ) -> Self {
+        Self { line, file, error: error.into() }
+    }
+}
+
+impl Display for OsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad(&format!("os error at {}:{}: {}", self.file, self.line, self.error))
+    }
+}
+impl Error for OsError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        Some(self.error.as_ref())
     }
 }
 
@@ -69,64 +148,3 @@ macro_rules! os_error {
         crate::error::OsError::new(line!(), file!(), $error)
     }};
 }
-
-impl fmt::Display for OsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        f.pad(&format!("os error at {}:{}: {}", self.file, self.line, self.error))
-    }
-}
-
-impl fmt::Display for ExternalError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        match self {
-            ExternalError::NotSupported(e) => e.fmt(f),
-            ExternalError::Ignored => write!(f, "Operation was ignored"),
-            ExternalError::Os(e) => e.fmt(f),
-        }
-    }
-}
-
-impl fmt::Debug for NotSupportedError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        f.debug_struct("NotSupportedError").finish()
-    }
-}
-
-impl fmt::Display for NotSupportedError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        f.pad("the requested operation is not supported by Winit")
-    }
-}
-
-impl fmt::Display for EventLoopError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        match self {
-            EventLoopError::RecreationAttempt => write!(f, "EventLoop can't be recreated"),
-            EventLoopError::NotSupported(e) => e.fmt(f),
-            EventLoopError::Os(e) => e.fmt(f),
-            EventLoopError::ExitFailure(status) => write!(f, "Exit Failure: {status}"),
-        }
-    }
-}
-
-impl error::Error for OsError {}
-impl error::Error for ExternalError {}
-impl error::Error for NotSupportedError {}
-impl error::Error for EventLoopError {}
-
-#[cfg(test)]
-#[allow(clippy::redundant_clone)]
-mod tests {
-    use super::*;
-
-    // Eat attributes for testing
-    #[test]
-    fn ensure_fmt_does_not_panic() {
-        let _ = format!("{:?}, {}", NotSupportedError::new(), NotSupportedError::new().clone());
-        let _ = format!(
-            "{:?}, {}",
-            ExternalError::NotSupported(NotSupportedError::new()),
-            ExternalError::NotSupported(NotSupportedError::new())
-        );
-    }
-}

src/event.rs

@@ -46,7 +46,7 @@ use smol_str::SmolStr;
 use web_time::Instant;
 
 use crate::dpi::{PhysicalPosition, PhysicalSize};
-use crate::error::ExternalError;
+use crate::error::RequestError;
 use crate::event_loop::AsyncRequestSerial;
 use crate::keyboard::{self, ModifiersKeyState, ModifiersKeys, ModifiersState};
 use crate::platform_impl;
@@ -148,8 +148,13 @@ pub enum WindowEvent {
     /// [`request_activation_token`]: crate::platform::startup_notify::WindowExtStartupNotify::request_activation_token
     ActivationTokenDone { serial: AsyncRequestSerial, token: ActivationToken },
 
-    /// The size of the window has changed. Contains the client area's new dimensions.
-    Resized(PhysicalSize<u32>),
+    /// The size of the window's surface has changed.
+    ///
+    /// Contains the new dimensions of the surface (can also be retrieved with
+    /// [`Window::surface_size`]).
+    ///
+    /// [`Window::surface_size`]: crate::window::Window::surface_size
+    SurfaceResized(PhysicalSize<u32>),
 
     /// The position of the window has changed. Contains the window's new position.
     ///
@@ -360,16 +365,16 @@ pub enum WindowEvent {
     /// * Changing the display's scale factor (e.g. in Control Panel on Windows).
     /// * Moving the window to a display with a different scale factor.
     ///
-    /// To update the window size, use the provided [`InnerSizeWriter`] handle. By default, the
+    /// To update the window size, use the provided [`SurfaceSizeWriter`] handle. By default, the
     /// window is resized to the value suggested by the OS, but it can be changed to any value.
     ///
     /// For more information about DPI in general, see the [`dpi`] crate.
     ScaleFactorChanged {
         scale_factor: f64,
-        /// Handle to update inner size during scale changes.
+        /// Handle to update surface size during scale changes.
         ///
-        /// See [`InnerSizeWriter`] docs for more details.
-        inner_size_writer: InnerSizeWriter,
+        /// See [`SurfaceSizeWriter`] docs for more details.
+        surface_size_writer: SurfaceSizeWriter,
     },
 
     /// The system window theme has changed.
@@ -995,40 +1000,39 @@ pub enum MouseScrollDelta {
     PixelDelta(PhysicalPosition<f64>),
 }
 
-/// Handle to synchronously change the size of the window from the
-/// [`WindowEvent`].
+/// Handle to synchronously change the size of the window from the [`WindowEvent`].
 #[derive(Debug, Clone)]
-pub struct InnerSizeWriter {
-    pub(crate) new_inner_size: Weak<Mutex<PhysicalSize<u32>>>,
+pub struct SurfaceSizeWriter {
+    pub(crate) new_surface_size: Weak<Mutex<PhysicalSize<u32>>>,
 }
 
-impl InnerSizeWriter {
+impl SurfaceSizeWriter {
     #[cfg(not(orbital_platform))]
-    pub(crate) fn new(new_inner_size: Weak<Mutex<PhysicalSize<u32>>>) -> Self {
-        Self { new_inner_size }
+    pub(crate) fn new(new_surface_size: Weak<Mutex<PhysicalSize<u32>>>) -> Self {
+        Self { new_surface_size }
     }
 
-    /// Try to request inner size which will be set synchronously on the window.
-    pub fn request_inner_size(
+    /// Try to request surface size which will be set synchronously on the window.
+    pub fn request_surface_size(
         &mut self,
-        new_inner_size: PhysicalSize<u32>,
-    ) -> Result<(), ExternalError> {
-        if let Some(inner) = self.new_inner_size.upgrade() {
-            *inner.lock().unwrap() = new_inner_size;
+        new_surface_size: PhysicalSize<u32>,
+    ) -> Result<(), RequestError> {
+        if let Some(inner) = self.new_surface_size.upgrade() {
+            *inner.lock().unwrap() = new_surface_size;
             Ok(())
         } else {
-            Err(ExternalError::Ignored)
+            Err(RequestError::Ignored)
         }
     }
 }
 
-impl PartialEq for InnerSizeWriter {
+impl PartialEq for SurfaceSizeWriter {
     fn eq(&self, other: &Self) -> bool {
-        self.new_inner_size.as_ptr() == other.new_inner_size.as_ptr()
+        self.new_surface_size.as_ptr() == other.new_surface_size.as_ptr()
     }
 }
 
-impl Eq for InnerSizeWriter {}
+impl Eq for SurfaceSizeWriter {}
 
 #[cfg(test)]
 mod tests {
@@ -1066,7 +1070,7 @@ mod tests {
                 with_window_event(Destroyed);
                 with_window_event(Focused(true));
                 with_window_event(Moved((0, 0).into()));
-                with_window_event(Resized((0, 0).into()));
+                with_window_event(SurfaceResized((0, 0).into()));
                 with_window_event(DroppedFile("x.txt".into()));
                 with_window_event(HoveredFile("x.txt".into()));
                 with_window_event(HoveredFileCancelled);

src/event_loop.rs

@@ -8,7 +8,6 @@
 //!
 //! See the root-level documentation for information on how to create and use an event loop to
 //! handle events.
-use std::any::Any;
 use std::fmt;
 use std::marker::PhantomData;
 #[cfg(any(x11_platform, wayland_platform))]
@@ -21,9 +20,10 @@ use std::time::{Duration, Instant};
 use web_time::{Duration, Instant};
 
 use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, ExternalError, OsError};
+use crate::error::{EventLoopError, RequestError};
 use crate::monitor::MonitorHandle;
 use crate::platform_impl;
+use crate::utils::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
@@ -148,11 +148,12 @@ pub enum ControlFlow {
     /// When the current loop iteration finishes, suspend the thread until either another event
     /// arrives or the given time is reached.
     ///
-    /// Useful for implementing efficient timers. Applications which want to render at the
-    /// display's native refresh rate should instead use [`Poll`] and the VSync functionality
-    /// of a graphics API to reduce odds of missed frames.
+    /// Useful for implementing efficient timers, but should not be relied on for real-time needs
+    /// like rendering (VSync) or audio. Applications which want to render at the display's native
+    /// refresh rate should instead issue a [`Window::request_redraw`] at the end of
+    /// [`WindowEvent::RedrawRequested`].
     ///
-    /// [`Poll`]: Self::Poll
+    /// [`WindowEvent::RedrawRequested`]: crate::event::WindowEvent::RedrawRequested
     WaitUntil(Instant),
 }
 
@@ -268,7 +269,7 @@ impl EventLoop {
     pub fn create_custom_cursor(
         &self,
         custom_cursor: CustomCursorSource,
-    ) -> Result<CustomCursor, ExternalError> {
+    ) -> Result<CustomCursor, RequestError> {
         self.event_loop.window_target().create_custom_cursor(custom_cursor)
     }
 }
@@ -308,7 +309,7 @@ impl AsRawFd for EventLoop {
     }
 }
 
-pub trait ActiveEventLoop {
+pub trait ActiveEventLoop: AsAny {
     /// 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;
@@ -321,7 +322,10 @@ pub trait ActiveEventLoop {
     ///
     /// - **Web:** The window is created but not inserted into the Web page automatically. Please
     ///   see the Web platform module for more information.
-    fn create_window(&self, window_attributes: WindowAttributes) -> Result<Window, OsError>;
+    fn create_window(
+        &self,
+        window_attributes: WindowAttributes,
+    ) -> Result<Box<dyn Window>, RequestError>;
 
     /// Create custom cursor.
     ///
@@ -331,7 +335,7 @@ pub trait ActiveEventLoop {
     fn create_custom_cursor(
         &self,
         custom_cursor: CustomCursorSource,
-    ) -> Result<CustomCursor, ExternalError>;
+    ) -> Result<CustomCursor, RequestError>;
 
     /// Returns the list of all the monitors available on the system.
     ///
@@ -403,16 +407,18 @@ pub trait ActiveEventLoop {
     /// See the [`OwnedDisplayHandle`] type for more information.
     fn owned_display_handle(&self) -> OwnedDisplayHandle;
 
-    /// Get the [`ActiveEventLoop`] as [`Any`].
-    ///
-    /// This is useful for downcasting to a concrete event loop type.
-    fn as_any(&self) -> &dyn Any;
-
     /// Get the raw-window-handle handle.
     #[cfg(feature = "rwh_06")]
     fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle;
 }
 
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for dyn ActiveEventLoop + '_ {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        self.rwh_06_handle().display_handle()
+    }
+}
+
 /// A proxy for the underlying display handle.
 ///
 /// The purpose of this type is to provide a cheaply clonable handle to the underlying

src/lib.rs

@@ -44,16 +44,16 @@
 //! use winit::application::ApplicationHandler;
 //! use winit::event::WindowEvent;
 //! use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
-//! use winit::window::{Window, WindowId};
+//! use winit::window::{Window, WindowId, WindowAttributes};
 //!
 //! #[derive(Default)]
 //! struct App {
-//!     window: Option<Window>,
+//!     window: Option<Box<dyn Window>>,
 //! }
 //!
 //! impl ApplicationHandler for App {
 //!     fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
-//!         self.window = Some(event_loop.create_window(Window::default_attributes()).unwrap());
+//!         self.window = Some(event_loop.create_window(WindowAttributes::default()).unwrap());
 //!     }
 //!
 //!     fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, id: WindowId, event: WindowEvent) {

src/monitor.rs

@@ -47,9 +47,9 @@ impl Ord for VideoModeHandle {
 
 impl VideoModeHandle {
     /// Returns the resolution of this video mode. This **must not** be used to create your
-    /// rendering surface. Use [`Window::inner_size()`] instead.
+    /// rendering surface. Use [`Window::surface_size()`] instead.
     ///
-    /// [`Window::inner_size()`]: crate::window::Window::inner_size
+    /// [`Window::surface_size()`]: crate::window::Window::surface_size
     #[inline]
     pub fn size(&self) -> PhysicalSize<u32> {
         self.video_mode.size()

src/platform/android.rs

@@ -62,7 +62,7 @@
 //! If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building
 //! with `cargo apk`, then the minimal changes would be:
 //! 1. Remove `ndk-glue` from your `Cargo.toml`
-//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.4",
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.5",
 //!    features = [ "android-native-activity" ] }`
 //! 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc
 //!    macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize
@@ -99,17 +99,19 @@ pub trait WindowExtAndroid {
     fn config(&self) -> ConfigurationRef;
 }
 
-impl WindowExtAndroid for Window {
+impl WindowExtAndroid for dyn Window + '_ {
     fn content_rect(&self) -> Rect {
-        self.window.content_rect()
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.content_rect()
     }
 
     fn config(&self) -> ConfigurationRef {
-        self.window.config()
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.config()
     }
 }
 
-impl ActiveEventLoopExtAndroid for &dyn ActiveEventLoop {
+impl ActiveEventLoopExtAndroid for dyn ActiveEventLoop + '_ {
     fn android_app(&self) -> &AndroidApp {
         let event_loop =
             self.as_any().downcast_ref::<crate::platform_impl::ActiveEventLoop>().unwrap();

src/platform/ios.rs

@@ -1,51 +1,79 @@
 //! # iOS / UIKit
 //!
-//! Winit has an OS requirement of iOS 8 or higher, and is regularly tested on
-//! iOS 9.3.
+//! Winit has [the same iOS version requirements as `rustc`][rustc-ios-version], although it's
+//! frequently only tested on newer iOS versions.
 //!
-//! iOS's main `UIApplicationMain` does some init work that's required by all
-//! UI-related code (see issue [#1705]). It is best to create your windows
-//! inside `Event::Resumed`.
+//! [rustc-ios-version]: https://doc.rust-lang.org/rustc/platform-support/apple-ios.html#os-version
 //!
-//! [#1705]: https://github.com/rust-windowing/winit/issues/1705
+//! ## Running on Mac Catalyst
 //!
-//! ## Building app
+//! Mac Catalyst allows running applications using UIKit on macOS, which can be very useful for
+//! testing. See [`rustc`'s documentation on Mac Catalyst][rustc-mac-catalyst] for details on how to
+//! use these targets. To use these with Winit, you'll need to bundle your application before
+//! running it, otherwise UIKit will exit with an error.
 //!
-//! To build ios app you will need rustc built for this targets:
+//! To run e.g. the `window` example in the Winit repository, you can use [`cargo-bundle`] as
+//! follows:
 //!
-//!  - armv7-apple-ios
-//!  - armv7s-apple-ios
-//!  - i386-apple-ios
-//!  - aarch64-apple-ios
-//!  - x86_64-apple-ios
-//!
-//! Then
-//!
-//! ```
-//! cargo build --target=...
-//! ```
-//! The simplest way to integrate your app into xcode environment is to build it
-//! as a static library. Wrap your main function and export it.
-//!
-//! ```rust, ignore
-//! #[no_mangle]
-//! pub extern fn start_winit_app() {
-//!     start_inner()
-//! }
-//!
-//! fn start_inner() {
-//!    ...
-//! }
+//! ```console
+//! $ cargo +nightly bundle --format=ios --target=aarch64-apple-ios-macabi --example=window
+//! $ ./target/aarch64-apple-ios-macabi/debug/examples/bundle/ios/winit.app/window
 //! ```
 //!
-//! Compile project and then drag resulting .a into Xcode project. Add winit.h to xcode.
+//! [rustc-mac-catalyst]: https://doc.rust-lang.org/rustc/platform-support/apple-ios-macabi.html
+//! [`cargo-bundle`]: https://github.com/burtonageo/cargo-bundle
 //!
-//! ```ignore
-//! void start_winit_app();
+//! ## Introduction to building an app
+//!
+//! Building and running your application in the iOS simulator, or on a real device, is a bit more
+//! complicated than Mac Catalyst - fundamentally, you must use Xcode, since the binary needs to be
+//! bundled, signed, notarized and uploaded to the device (there is [an open source work-in-progress
+//! on re-implementing parts of this][apple-platform-rs], but the user-story around it is not yet
+//! clear).
+//!
+//! This means that you're left with effectively two options: Use a tool that manages the Xcode
+//! configuration for you, or use Xcode directly. [`cargo-dinghy`] and [`cargo-mobile2`] are notable
+//! projects in the ecosystem that attempt the former, and [`cargo-xcode`] is an excellent project
+//! that attempts the latter. We will also attempt to describe here how you would go about using
+//! Xcode directly:
+//!
+//! First off, you'll need the correct Rust targets, see [`rustc`'s documentation on iOS][rustc-ios]
+//! for details. Nowadays, the correct targets are usually `aarch64-apple-ios-sim` for the
+//! simulator, and `aarch64-apple-ios` for the actual device.
+//!
+//! Next, create a new Xcode project using the "App" template. The exact configuration does not
+//! really matter, as we're going to delete most of it, since it's tailored for Objective-C and/or
+//! Swift, and Rust/Winit is neither. Specifically, we need to delete:
+//! - Everything relating to storyboards (unless you want to use e.g. a launch screen). This
+//!   includes the relevant keys in `Info.plist`.
+//! - All the generated C header, Objective-C and/or Swift files.
+//!
+//! Now that we have a fairly clean slate that we can build upon, you can add a "run script" build
+//! phase to your Xcode target, which will get invoked instead of the "compile sources" and "link
+//! binary" steps. The basic script should look something like:
+//!
+//! ```sh
+//! # Build desired targets based on `ARCHS` environment variable
+//! cargo build --target=aarch64-apple-ios --target=armv7s-apple-ios
+//! # Merge these with `lipo`, and place the result in "$TARGET_BUILD_DIR/$EXECUTABLE_PATH", which
+//! # is understood by Xcode
+//! lipo "$TARGET_BUILD_DIR/$EXECUTABLE_PATH" target/aarch64-apple-ios/debug/my_app target/armv7s-apple-ios/debug/my_app
 //! ```
 //!
-//! Use start_winit_app inside your xcode's main function.
+//! Note that this is very much the overall idea; the script needs to be much more involved to
+//! properly deal with different target architectures, invoking `lipo` when needed, incremental
+//! rebuild change detection, and so on. `cargo-xcode` has a script [here][cargo-xcode-script] that
+//! handles most of this complexity, you might be able to build upon that.
 //!
+//! Apologies that we're not able to provide you with more than this; work is in-progress on
+//! improving the situation, but it's slow-going.
+//!
+//! [apple-platform-rs]: https://github.com/indygreg/apple-platform-rs
+//! [`cargo-dinghy`]: https://github.com/sonos/dinghy
+//! [`cargo-mobile2`]: https://github.com/tauri-apps/cargo-mobile2
+//! [`cargo-xcode`]: https://crates.io/crates/cargo-xcode
+//! [rustc-ios]: https://doc.rust-lang.org/rustc/platform-support/apple-ios.html
+//! [cargo-xcode-script]: https://gitlab.com/kornelski/cargo-xcode/-/blob/main/src/xcodebuild.sh
 //!
 //! ## App lifecycle and events
 //!
@@ -63,6 +91,16 @@
 //! opengl will result in segfault.
 //!
 //! Also note that app may not receive the LoopExiting event if suspended; it might be SIGKILL'ed.
+//!
+//! ## Custom `UIApplicationDelegate`
+//!
+//! Winit usually handles everything related to the lifecycle events of the application. Sometimes,
+//! though, you might want to access some of the more niche stuff that [the application
+//! delegate][app-delegate] provides. This functionality is not exposed directly in Winit, since it
+//! would increase the API surface by quite a lot. Instead, Winit guarantees that it will not
+//! register an application delegate, so you can set up a custom one in a nib file instead.
+//!
+//! [app-delegate]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate?language=objc
 
 use std::os::raw::c_void;
 
@@ -171,42 +209,49 @@ pub trait WindowExtIOS {
     fn recognize_rotation_gesture(&self, should_recognize: bool);
 }
 
-impl WindowExtIOS for Window {
+impl WindowExtIOS for dyn Window + '_ {
     #[inline]
     fn set_scale_factor(&self, scale_factor: f64) {
-        self.window.maybe_queue_on_main(move |w| w.set_scale_factor(scale_factor))
+        let window = self.as_any().downcast_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) {
-        self.window.maybe_queue_on_main(move |w| w.set_valid_orientations(valid_orientations))
+        let window = self.as_any().downcast_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) {
-        self.window.maybe_queue_on_main(move |w| w.set_prefers_home_indicator_hidden(hidden))
+        let window = self.as_any().downcast_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) {
-        self.window.maybe_queue_on_main(move |w| {
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(move |w| {
             w.set_preferred_screen_edges_deferring_system_gestures(edges)
-        })
+        });
     }
 
     #[inline]
     fn set_prefers_status_bar_hidden(&self, hidden: bool) {
-        self.window.maybe_queue_on_main(move |w| w.set_prefers_status_bar_hidden(hidden))
+        let window = self.as_any().downcast_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) {
-        self.window.maybe_queue_on_main(move |w| w.set_preferred_status_bar_style(status_bar_style))
+        let window = self.as_any().downcast_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) {
-        self.window.maybe_queue_on_main(move |w| w.recognize_pinch_gesture(should_recognize));
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(move |w| w.recognize_pinch_gesture(should_recognize));
     }
 
     #[inline]
@@ -216,7 +261,8 @@ impl WindowExtIOS for Window {
         minimum_number_of_touches: u8,
         maximum_number_of_touches: u8,
     ) {
-        self.window.maybe_queue_on_main(move |w| {
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(move |w| {
             w.recognize_pan_gesture(
                 should_recognize,
                 minimum_number_of_touches,
@@ -227,12 +273,14 @@ impl WindowExtIOS for Window {
 
     #[inline]
     fn recognize_doubletap_gesture(&self, should_recognize: bool) {
-        self.window.maybe_queue_on_main(move |w| w.recognize_doubletap_gesture(should_recognize));
+        let window = self.as_any().downcast_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) {
-        self.window.maybe_queue_on_main(move |w| w.recognize_rotation_gesture(should_recognize));
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(move |w| w.recognize_rotation_gesture(should_recognize));
     }
 }
 

src/platform/macos.rs

@@ -1,18 +1,74 @@
 //! # macOS / AppKit
 //!
-//! Winit has an OS requirement of macOS 10.11 or higher (same as Rust
-//! itself), and is regularly tested on macOS 10.14.
+//! Winit has [the same macOS version requirements as `rustc`][rustc-macos-version], and is tested
+//! once in a while on as low as macOS 10.14.
 //!
-//! A lot of functionality expects the application to be ready before you
-//! start doing anything; this includes creating windows, fetching monitors,
-//! drawing, and so on, see issues [#2238], [#2051] and [#2087].
+//! [rustc-macos-version]: https://doc.rust-lang.org/rustc/platform-support/apple-darwin.html#os-version
 //!
-//! If you encounter problems, you should try doing your initialization inside
-//! `Event::Resumed`.
+//! ## Custom `NSApplicationDelegate`
 //!
-//! [#2238]: https://github.com/rust-windowing/winit/issues/2238
-//! [#2051]: https://github.com/rust-windowing/winit/issues/2051
-//! [#2087]: https://github.com/rust-windowing/winit/issues/2087
+//! Winit usually handles everything related to the lifecycle events of the application. Sometimes,
+//! though, you might want to do more niche stuff, such as [handle when the user re-activates the
+//! application][reopen]. Such functionality is not exposed directly in Winit, since it would
+//! increase the API surface by quite a lot.
+//!
+//! [reopen]: https://developer.apple.com/documentation/appkit/nsapplicationdelegate/1428638-applicationshouldhandlereopen?language=objc
+//!
+//! Instead, Winit guarantees that it will not register an application delegate, so the solution is
+//! to register your own application delegate, as outlined in the following example (see
+//! `objc2-app-kit` for more detailed information).
+#![cfg_attr(target_os = "macos", doc = "```")]
+#![cfg_attr(not(target_os = "macos"), doc = "```ignore")]
+//! use objc2::rc::Retained;
+//! use objc2::runtime::ProtocolObject;
+//! use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
+//! use objc2_app_kit::{NSApplication, NSApplicationDelegate};
+//! use objc2_foundation::{NSArray, NSURL, MainThreadMarker, NSObject, NSObjectProtocol};
+//! use winit::event_loop::EventLoop;
+//!
+//! declare_class!(
+//!     struct AppDelegate;
+//!
+//!     unsafe impl ClassType for AppDelegate {
+//!         type Super = NSObject;
+//!         type Mutability = mutability::MainThreadOnly;
+//!         const NAME: &'static str = "MyAppDelegate";
+//!     }
+//!
+//!     impl DeclaredClass for AppDelegate {}
+//!
+//!     unsafe impl NSObjectProtocol for AppDelegate {}
+//!
+//!     unsafe impl NSApplicationDelegate for AppDelegate {
+//!         #[method(application:openURLs:)]
+//!         fn application_openURLs(&self, application: &NSApplication, urls: &NSArray<NSURL>) {
+//!             // Note: To specifically get `application:openURLs:` to work, you _might_
+//!             // have to bundle your application. This is not done in this example.
+//!             println!("open urls: {application:?}, {urls:?}");
+//!         }
+//!     }
+//! );
+//!
+//! impl AppDelegate {
+//!     fn new(mtm: MainThreadMarker) -> Retained<Self> {
+//!         unsafe { msg_send_id![super(mtm.alloc().set_ivars(())), init] }
+//!     }
+//! }
+//!
+//! fn main() -> Result<(), Box<dyn std::error::Error>> {
+//!     let event_loop = EventLoop::new()?;
+//!
+//!     let mtm = MainThreadMarker::new().unwrap();
+//!     let delegate = AppDelegate::new(mtm);
+//!     // Important: Call `sharedApplication` after `EventLoop::new`,
+//!     // doing it before is not yet supported.
+//!     let app = NSApplication::sharedApplication(mtm);
+//!     app.setDelegate(Some(ProtocolObject::from_ref(&*delegate)));
+//!
+//!     // event_loop.run_app(&mut my_app);
+//!     Ok(())
+//! }
+//! ```
 
 use std::os::raw::c_void;
 
@@ -94,77 +150,109 @@ 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.
+    fn set_borderless_game(&self, borderless_game: bool);
+
+    /// Getter for the [`WindowExtMacOS::set_borderless_game`].
+    fn is_borderless_game(&self) -> bool;
 }
 
-impl WindowExtMacOS for Window {
+impl WindowExtMacOS for dyn Window + '_ {
     #[inline]
     fn simple_fullscreen(&self) -> bool {
-        self.window.maybe_wait_on_main(|w| w.simple_fullscreen())
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(|w| w.simple_fullscreen())
     }
 
     #[inline]
     fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
-        self.window.maybe_wait_on_main(move |w| w.set_simple_fullscreen(fullscreen))
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(move |w| w.set_simple_fullscreen(fullscreen))
     }
 
     #[inline]
     fn has_shadow(&self) -> bool {
-        self.window.maybe_wait_on_main(|w| w.has_shadow())
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(|w| w.has_shadow())
     }
 
     #[inline]
     fn set_has_shadow(&self, has_shadow: bool) {
-        self.window.maybe_queue_on_main(move |w| w.set_has_shadow(has_shadow))
+        let window = self.as_any().downcast_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) {
-        self.window.maybe_wait_on_main(|w| w.set_tabbing_identifier(identifier))
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(|w| w.set_tabbing_identifier(identifier))
     }
 
     #[inline]
     fn tabbing_identifier(&self) -> String {
-        self.window.maybe_wait_on_main(|w| w.tabbing_identifier())
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(|w| w.tabbing_identifier())
     }
 
     #[inline]
     fn select_next_tab(&self) {
-        self.window.maybe_queue_on_main(|w| w.select_next_tab())
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(|w| w.select_next_tab());
     }
 
     #[inline]
     fn select_previous_tab(&self) {
-        self.window.maybe_queue_on_main(|w| w.select_previous_tab())
+        let window = self.as_any().downcast_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) {
-        self.window.maybe_queue_on_main(move |w| w.select_tab_at_index(index))
+        let window = self.as_any().downcast_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 {
-        self.window.maybe_wait_on_main(|w| w.num_tabs())
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(|w| w.num_tabs())
     }
 
     #[inline]
     fn is_document_edited(&self) -> bool {
-        self.window.maybe_wait_on_main(|w| w.is_document_edited())
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.maybe_wait_on_main(|w| w.is_document_edited())
     }
 
     #[inline]
     fn set_document_edited(&self, edited: bool) {
-        self.window.maybe_queue_on_main(move |w| w.set_document_edited(edited))
+        let window = self.as_any().downcast_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) {
-        self.window.maybe_queue_on_main(move |w| w.set_option_as_alt(option_as_alt))
+        let window = self.as_any().downcast_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 {
-        self.window.maybe_wait_on_main(|w| w.option_as_alt())
+        let window = self.as_any().downcast_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();
+        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();
+        window.maybe_wait_on_main(|w| w.is_borderless_game())
     }
 }
 
@@ -217,6 +305,8 @@ pub trait WindowAttributesExtMacOS {
     ///
     /// See [`WindowExtMacOS::set_option_as_alt`] for details on what this means if set.
     fn with_option_as_alt(self, option_as_alt: OptionAsAlt) -> Self;
+    /// See [`WindowExtMacOS::set_borderless_game`] for details on what this means if set.
+    fn with_borderless_game(self, borderless_game: bool) -> Self;
 }
 
 impl WindowAttributesExtMacOS for WindowAttributes {
@@ -285,6 +375,12 @@ impl WindowAttributesExtMacOS for WindowAttributes {
         self.platform_specific.option_as_alt = option_as_alt;
         self
     }
+
+    #[inline]
+    fn with_borderless_game(mut self, borderless_game: bool) -> Self {
+        self.platform_specific.borderless_game = borderless_game;
+        self
+    }
 }
 
 pub trait EventLoopBuilderExtMacOS {
@@ -297,11 +393,11 @@ pub trait EventLoopBuilderExtMacOS {
     /// Set the activation policy to "accessory".
     ///
     /// ```
-    /// use winit::event_loop::EventLoopBuilder;
+    /// use winit::event_loop::EventLoop;
     /// #[cfg(target_os = "macos")]
     /// use winit::platform::macos::{ActivationPolicy, EventLoopBuilderExtMacOS};
     ///
-    /// let mut builder = EventLoopBuilder::new();
+    /// let mut builder = EventLoop::builder();
     /// #[cfg(target_os = "macos")]
     /// builder.with_activation_policy(ActivationPolicy::Accessory);
     /// # if false { // We can't test this part
@@ -319,11 +415,11 @@ pub trait EventLoopBuilderExtMacOS {
     /// Disable creating a default menubar.
     ///
     /// ```
-    /// use winit::event_loop::EventLoopBuilder;
+    /// use winit::event_loop::EventLoop;
     /// #[cfg(target_os = "macos")]
     /// use winit::platform::macos::EventLoopBuilderExtMacOS;
     ///
-    /// let mut builder = EventLoopBuilder::new();
+    /// let mut builder = EventLoop::builder();
     /// #[cfg(target_os = "macos")]
     /// builder.with_default_menu(false);
     /// # if false { // We can't test this part
@@ -396,7 +492,7 @@ pub trait ActiveEventLoopExtMacOS {
     fn allows_automatic_window_tabbing(&self) -> bool;
 }
 
-impl ActiveEventLoopExtMacOS for &dyn ActiveEventLoop {
+impl ActiveEventLoopExtMacOS for dyn ActiveEventLoop + '_ {
     fn hide_application(&self) {
         let event_loop = self
             .as_any()

src/platform/startup_notify.rs

@@ -23,7 +23,7 @@
 
 use std::env;
 
-use crate::error::NotSupportedError;
+use crate::error::{NotSupportedError, RequestError};
 use crate::event_loop::{ActiveEventLoop, AsyncRequestSerial};
 #[cfg(wayland_platform)]
 use crate::platform::wayland::ActiveEventLoopExtWayland;
@@ -46,7 +46,7 @@ pub trait WindowExtStartupNotify {
     /// Request a new activation token.
     ///
     /// The token will be delivered inside
-    fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError>;
+    fn request_activation_token(&self) -> Result<AsyncRequestSerial, RequestError>;
 }
 
 pub trait WindowAttributesExtStartupNotify {
@@ -57,7 +57,7 @@ pub trait WindowAttributesExtStartupNotify {
     fn with_activation_token(self, token: ActivationToken) -> Self;
 }
 
-impl EventLoopExtStartupNotify for &dyn ActiveEventLoop {
+impl EventLoopExtStartupNotify for dyn ActiveEventLoop + '_ {
     fn read_token_from_env(&self) -> Option<ActivationToken> {
         #[cfg(x11_platform)]
         let _is_wayland = false;
@@ -72,9 +72,22 @@ impl EventLoopExtStartupNotify for &dyn ActiveEventLoop {
     }
 }
 
-impl WindowExtStartupNotify for Window {
-    fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError> {
-        self.window.request_activation_token()
+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>()
+        {
+            return window.request_activation_token();
+        }
+
+        #[cfg(x11_platform)]
+        if let Some(window) =
+            self.as_any().downcast_ref::<crate::platform_impl::x11::window::Window>()
+        {
+            return window.request_activation_token();
+        }
+
+        Err(NotSupportedError::new("startup notify is not supported").into())
     }
 }
 

src/platform/wayland.rs

@@ -13,11 +13,10 @@
 //! * `wayland-csd-adwaita` (default).
 //! * `wayland-csd-adwaita-crossfont`.
 //! * `wayland-csd-adwaita-notitle`.
-use crate::application::ApplicationHandler;
 use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
 use crate::monitor::MonitorHandle;
 pub use crate::window::Theme;
-use crate::window::{Window, WindowAttributes};
+use crate::window::{Window as CoreWindow, WindowAttributes};
 
 /// Additional methods on [`ActiveEventLoop`] that are specific to Wayland.
 pub trait ActiveEventLoopExtWayland {
@@ -25,11 +24,7 @@ pub trait ActiveEventLoopExtWayland {
     fn is_wayland(&self) -> bool;
 }
 
-pub trait WaylandApplicationHandler: ApplicationHandler + 'static {
-    fn wayland_callback(&mut self);
-}
-
-impl ActiveEventLoopExtWayland for &dyn ActiveEventLoop {
+impl ActiveEventLoopExtWayland for dyn ActiveEventLoop + '_ {
     #[inline]
     fn is_wayland(&self) -> bool {
         self.as_any().downcast_ref::<crate::platform_impl::wayland::ActiveEventLoop>().is_some()
@@ -40,8 +35,6 @@ impl ActiveEventLoopExtWayland for &dyn ActiveEventLoop {
 pub trait EventLoopExtWayland {
     /// True if the [`EventLoop`] uses Wayland.
     fn is_wayland(&self) -> bool;
-
-    fn register_wayland_callback<T: WaylandApplicationHandler>(&mut self);
 }
 
 impl EventLoopExtWayland for EventLoop {
@@ -49,22 +42,6 @@ impl EventLoopExtWayland for EventLoop {
     fn is_wayland(&self) -> bool {
         self.event_loop.is_wayland()
     }
-
-    fn register_wayland_callback<T: WaylandApplicationHandler>(&mut self) {
-        let event_loop = match &self.event_loop {
-            crate::platform_impl::EventLoop::Wayland(event_loop) => &event_loop.active_event_loop,
-            #[cfg(x11_platform)]
-            crate::platform_impl::EventLoop::X(_) => return,
-        };
-
-        event_loop.wayland_callback.set(Some(|app: &mut dyn ApplicationHandler| {
-            app.as_any()
-                .expect("as_any_mut is not implemented")
-                .downcast_mut::<T>()
-                .unwrap()
-                .wayland_callback()
-        }));
-    }
 }
 
 /// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
@@ -94,9 +71,11 @@ impl EventLoopBuilderExtWayland for EventLoopBuilder {
 }
 
 /// Additional methods on [`Window`] that are specific to Wayland.
+///
+/// [`Window`]: crate::window::Window
 pub trait WindowExtWayland {}
 
-impl WindowExtWayland for Window {}
+impl WindowExtWayland for dyn CoreWindow + '_ {}
 
 /// Additional methods on [`WindowAttributes`] that are specific to Wayland.
 pub trait WindowAttributesExtWayland {

src/platform/web.rs

@@ -27,14 +27,14 @@
 //! - [`padding`](https://developer.mozilla.org/en-US/docs/Web/CSS/padding)
 //!
 //! The following APIs can't take them into account and will therefore provide inaccurate results:
-//! - [`WindowEvent::Resized`] and [`Window::(set_)inner_size()`]
+//! - [`WindowEvent::SurfaceResized`] and [`Window::(set_)surface_size()`]
 //! - [`WindowEvent::Occluded`]
 //! - [`WindowEvent::CursorMoved`], [`WindowEvent::CursorEntered`], [`WindowEvent::CursorLeft`], and
 //!   [`WindowEvent::Touch`].
 //! - [`Window::set_outer_position()`]
 //!
-//! [`WindowEvent::Resized`]: crate::event::WindowEvent::Resized
-//! [`Window::(set_)inner_size()`]: crate::window::Window::inner_size
+//! [`WindowEvent::SurfaceResized`]: crate::event::WindowEvent::SurfaceResized
+//! [`Window::(set_)surface_size()`]: crate::window::Window::surface_size
 //! [`WindowEvent::Occluded`]: crate::event::WindowEvent::Occluded
 //! [`WindowEvent::CursorMoved`]: crate::event::WindowEvent::CursorMoved
 //! [`WindowEvent::CursorEntered`]: crate::event::WindowEvent::CursorEntered
@@ -82,7 +82,7 @@ pub trait WindowExtWeb {
 
     /// Returns [`true`] if calling `event.preventDefault()` is enabled.
     ///
-    /// See [`Window::set_prevent_default()`] for more details.
+    /// See [`WindowExtWeb::set_prevent_default()`] for more details.
     fn prevent_default(&self) -> bool;
 
     /// Sets whether `event.preventDefault()` should be called on events on the
@@ -104,22 +104,34 @@ pub trait WindowExtWeb {
     fn is_cursor_lock_raw(&self) -> bool;
 }
 
-impl WindowExtWeb for Window {
+impl WindowExtWeb for dyn Window + '_ {
     #[inline]
     fn canvas(&self) -> Option<Ref<'_, HtmlCanvasElement>> {
-        self.window.canvas()
+        self.as_any()
+            .downcast_ref::<crate::platform_impl::Window>()
+            .expect("non Web window on Web")
+            .canvas()
     }
 
     fn prevent_default(&self) -> bool {
-        self.window.prevent_default()
+        self.as_any()
+            .downcast_ref::<crate::platform_impl::Window>()
+            .expect("non Web window on Web")
+            .prevent_default()
     }
 
     fn set_prevent_default(&self, prevent_default: bool) {
-        self.window.set_prevent_default(prevent_default)
+        self.as_any()
+            .downcast_ref::<crate::platform_impl::Window>()
+            .expect("non Web window on Web")
+            .set_prevent_default(prevent_default)
     }
 
     fn is_cursor_lock_raw(&self) -> bool {
-        self.window.is_cursor_lock_raw()
+        self.as_any()
+            .downcast_ref::<crate::platform_impl::Window>()
+            .expect("non Web window on Web")
+            .is_cursor_lock_raw()
     }
 }
 
@@ -136,7 +148,7 @@ pub trait WindowAttributesExtWeb {
     /// Sets whether `event.preventDefault()` should be called on events on the
     /// canvas that have side effects.
     ///
-    /// See [`Window::set_prevent_default()`] for more details.
+    /// See [`WindowExtWeb::set_prevent_default()`] for more details.
     ///
     /// Enabled by default.
     fn with_prevent_default(self, prevent_default: bool) -> Self;
@@ -347,7 +359,7 @@ pub trait ActiveEventLoopExtWeb {
     fn has_detailed_monitor_permission(&self) -> bool;
 }
 
-impl ActiveEventLoopExtWeb for &dyn ActiveEventLoop {
+impl ActiveEventLoopExtWeb for dyn ActiveEventLoop + '_ {
     #[inline]
     fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture {
         let event_loop = self
@@ -699,10 +711,9 @@ pub struct OrientationData {
     pub orientation: Orientation,
     /// [`true`] if the [`orientation`](Self::orientation) is flipped upside down.
     pub flipped: bool,
-    /// [`true`] if the [`Orientation`] is the most natural one for the screen regardless of being
-    /// flipped. Computer monitors are commonly naturally landscape mode, while mobile phones
-    /// are commonly naturally portrait mode.
-    pub natural: bool,
+    /// The most natural orientation for the screen. Computer monitors are commonly naturally
+    /// landscape mode, while mobile phones are commonly naturally portrait mode.
+    pub natural: Orientation,
 }
 
 /// Screen orientation.
@@ -726,14 +737,14 @@ pub enum OrientationLock {
     /// User is locked to landscape mode.
     Landscape {
         /// - [`None`]: User is locked to both upright or upside down landscape mode.
-        /// - [`false`]: User is locked to upright landscape mode.
+        /// - [`true`]: User is locked to upright landscape mode.
         /// - [`false`]: User is locked to upside down landscape mode.
         flipped: Option<bool>,
     },
     /// User is locked to portrait mode.
     Portrait {
         /// - [`None`]: User is locked to both upright or upside down portrait mode.
-        /// - [`false`]: User is locked to upright portrait mode.
+        /// - [`true`]: User is locked to upright portrait mode.
         /// - [`false`]: User is locked to upside down portrait mode.
         flipped: Option<bool>,
     },

src/platform/windows.rs

@@ -4,6 +4,7 @@
 //! tested regularly.
 use std::borrow::Borrow;
 use std::ffi::c_void;
+use std::ops::Deref;
 use std::path::Path;
 
 #[cfg(feature = "serde")]
@@ -115,50 +116,25 @@ pub enum CornerPreference {
 ///
 /// See [`WindowBorrowExtWindows::any_thread`] for more information.
 #[derive(Clone, Debug)]
-pub struct AnyThread<W>(W);
+pub struct AnyThread<W: Window>(W);
 
-impl<W: Borrow<Window>> AnyThread<W> {
+impl<W: Window> AnyThread<W> {
     /// Get a reference to the inner window.
     #[inline]
-    pub fn get_ref(&self) -> &Window {
-        self.0.borrow()
-    }
-
-    /// Get a reference to the inner object.
-    #[inline]
-    pub fn inner(&self) -> &W {
+    pub fn get_ref(&self) -> &dyn Window {
         &self.0
     }
-
-    /// Unwrap and get the inner window.
-    #[inline]
-    pub fn into_inner(self) -> W {
-        self.0
-    }
 }
 
-impl<W: Borrow<Window>> AsRef<Window> for AnyThread<W> {
-    fn as_ref(&self) -> &Window {
-        self.get_ref()
-    }
-}
-
-impl<W: Borrow<Window>> Borrow<Window> for AnyThread<W> {
-    fn borrow(&self) -> &Window {
-        self.get_ref()
-    }
-}
-
-impl<W: Borrow<Window>> std::ops::Deref for AnyThread<W> {
-    type Target = Window;
-
+impl<W: Window> Deref for AnyThread<W> {
+    type Target = W;
     fn deref(&self) -> &Self::Target {
-        self.get_ref()
+        &self.0
     }
 }
 
 #[cfg(feature = "rwh_06")]
-impl<W: Borrow<Window>> rwh_06::HasWindowHandle for AnyThread<W> {
+impl<W: Window> rwh_06::HasWindowHandle for AnyThread<W> {
     fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
         // SAFETY: The top level user has asserted this is only used safely.
         unsafe { self.get_ref().window_handle_any_thread() }
@@ -341,7 +317,7 @@ pub trait WindowExtWindows {
     ///
     /// ```no_run
     /// # use winit::window::Window;
-    /// # fn scope(window: Window) {
+    /// # fn scope(window: Box<dyn Window>) {
     /// use std::thread;
     ///
     /// use winit::platform::windows::WindowExtWindows;
@@ -365,35 +341,41 @@ pub trait WindowExtWindows {
     ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError>;
 }
 
-impl WindowExtWindows for Window {
+impl WindowExtWindows for dyn Window + '_ {
     #[inline]
     fn set_enable(&self, enabled: bool) {
-        self.window.set_enable(enabled)
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.set_enable(enabled)
     }
 
     #[inline]
     fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
-        self.window.set_taskbar_icon(taskbar_icon)
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.set_taskbar_icon(taskbar_icon)
     }
 
     #[inline]
     fn set_skip_taskbar(&self, skip: bool) {
-        self.window.set_skip_taskbar(skip)
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.set_skip_taskbar(skip)
     }
 
     #[inline]
     fn set_undecorated_shadow(&self, shadow: bool) {
-        self.window.set_undecorated_shadow(shadow)
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.set_undecorated_shadow(shadow)
     }
 
     #[inline]
     fn set_system_backdrop(&self, backdrop_type: BackdropType) {
-        self.window.set_system_backdrop(backdrop_type)
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.set_system_backdrop(backdrop_type)
     }
 
     #[inline]
     fn set_border_color(&self, color: Option<Color>) {
-        self.window.set_border_color(color.unwrap_or(Color::NONE))
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.set_border_color(color.unwrap_or(Color::NONE))
     }
 
     #[inline]
@@ -401,25 +383,29 @@ impl WindowExtWindows for 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"
-        self.window.set_title_background_color(color.unwrap_or(Color::NONE))
+        let window = self.as_any().downcast_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) {
-        self.window.set_title_text_color(color)
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.set_title_text_color(color)
     }
 
     #[inline]
     fn set_corner_preference(&self, preference: CornerPreference) {
-        self.window.set_corner_preference(preference)
+        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        window.set_corner_preference(preference)
     }
 
     #[cfg(feature = "rwh_06")]
     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();
         unsafe {
-            let handle = self.window.rwh_06_no_thread_check()?;
+            let handle = window.rwh_06_no_thread_check()?;
 
             // SAFETY: The handle is valid in this context.
             Ok(rwh_06::WindowHandle::borrow_raw(handle))
@@ -430,7 +416,7 @@ impl WindowExtWindows for Window {
 /// Additional methods for anything that dereference to [`Window`].
 ///
 /// [`Window`]: crate::window::Window
-pub trait WindowBorrowExtWindows: Borrow<Window> + Sized {
+pub trait WindowBorrowExtWindows: Borrow<dyn Window> + Sized {
     /// Create an object that allows accessing the inner window handle in a thread-unsafe way.
     ///
     /// It is possible to call [`window_handle_any_thread`] to get around Windows's thread
@@ -457,12 +443,15 @@ pub trait WindowBorrowExtWindows: Borrow<Window> + Sized {
         doc = "[`HasWindowHandle`]: #only-available-with-rwh_06",
         doc = "[`window_handle_any_thread`]: #only-available-with-rwh_06"
     )]
-    unsafe fn any_thread(self) -> AnyThread<Self> {
+    unsafe fn any_thread(self) -> AnyThread<Self>
+    where
+        Self: Window,
+    {
         AnyThread(self)
     }
 }
 
-impl<W: Borrow<Window> + Sized> WindowBorrowExtWindows for W {}
+impl<W: Borrow<dyn Window> + Sized> WindowBorrowExtWindows for W {}
 
 /// Additional methods on `WindowAttributes` that are specific to Windows.
 #[allow(rustdoc::broken_intra_doc_links)]

src/platform/x11.rs

@@ -5,7 +5,7 @@ use serde::{Deserialize, Serialize};
 use crate::dpi::Size;
 use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
 use crate::monitor::MonitorHandle;
-use crate::window::{Window, WindowAttributes};
+use crate::window::{Window as CoreWindow, WindowAttributes};
 
 /// X window type. Maps directly to
 /// [`_NET_WM_WINDOW_TYPE`](https://specifications.freedesktop.org/wm-spec/wm-spec-1.5.html).
@@ -91,7 +91,7 @@ pub trait ActiveEventLoopExtX11 {
     fn is_x11(&self) -> bool;
 }
 
-impl ActiveEventLoopExtX11 for &dyn ActiveEventLoop {
+impl ActiveEventLoopExtX11 for dyn ActiveEventLoop + '_ {
     #[inline]
     fn is_x11(&self) -> bool {
         self.as_any().downcast_ref::<crate::platform_impl::x11::ActiveEventLoop>().is_some()
@@ -138,9 +138,11 @@ impl EventLoopBuilderExtX11 for EventLoopBuilder {
 }
 
 /// Additional methods on [`Window`] that are specific to X11.
+///
+/// [`Window`]: crate::window::Window
 pub trait WindowExtX11 {}
 
-impl WindowExtX11 for Window {}
+impl WindowExtX11 for dyn CoreWindow {}
 
 /// Additional methods on [`WindowAttributes`] that are specific to X11.
 pub trait WindowAttributesExtX11 {
@@ -169,13 +171,13 @@ pub trait WindowAttributesExtX11 {
     ///
     /// ```
     /// # use winit::dpi::{LogicalSize, PhysicalSize};
-    /// # use winit::window::Window;
+    /// # use winit::window::{Window, WindowAttributes};
     /// # use winit::platform::x11::WindowAttributesExtX11;
     /// // Specify the size in logical dimensions like this:
-    /// Window::default_attributes().with_base_size(LogicalSize::new(400.0, 200.0));
+    /// WindowAttributes::default().with_base_size(LogicalSize::new(400.0, 200.0));
     ///
     /// // Or specify the size in physical dimensions like this:
-    /// Window::default_attributes().with_base_size(PhysicalSize::new(400, 200));
+    /// WindowAttributes::default().with_base_size(PhysicalSize::new(400, 200));
     /// ```
     fn with_base_size<S: Into<Size>>(self, base_size: S) -> Self;
 
@@ -184,12 +186,12 @@ pub trait WindowAttributesExtX11 {
     /// # Example
     ///
     /// ```no_run
-    /// use winit::window::Window;
+    /// use winit::window::{Window, WindowAttributes};
     /// use winit::event_loop::ActiveEventLoop;
     /// use winit::platform::x11::{XWindow, WindowAttributesExtX11};
     /// # fn create_window(event_loop: &dyn ActiveEventLoop) -> Result<(), Box<dyn std::error::Error>> {
     /// let parent_window_id = std::env::args().nth(1).unwrap().parse::<XWindow>()?;
-    /// let window_attributes = Window::default_attributes().with_embed_parent_window(parent_window_id);
+    /// let window_attributes = WindowAttributes::default().with_embed_parent_window(parent_window_id);
     /// let window = event_loop.create_window(window_attributes)?;
     /// # Ok(()) }
     /// ```

src/platform_impl/android/mod.rs

@@ -1,4 +1,3 @@
-use std::any::Any;
 use std::cell::Cell;
 use std::hash::Hash;
 use std::num::{NonZeroU16, NonZeroU32};
@@ -15,18 +14,17 @@ use tracing::{debug, trace, warn};
 use crate::application::ApplicationHandler;
 use crate::cursor::Cursor;
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{self, EventLoopError, ExternalError, NotSupportedError};
-use crate::event::{self, Force, InnerSizeWriter, StartCause};
+use crate::error::{EventLoopError, NotSupportedError, RequestError};
+use crate::event::{self, Force, StartCause, SurfaceSizeWriter};
 use crate::event_loop::{
     ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
     EventLoopProxy as RootEventLoopProxy, OwnedDisplayHandle as RootOwnedDisplayHandle,
 };
 use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::platform::pump_events::PumpStatus;
-use crate::platform_impl::Fullscreen;
 use crate::window::{
-    self, CursorGrabMode, CustomCursor, CustomCursorSource, ImePurpose, ResizeDirection, Theme,
-    Window as RootWindow, WindowAttributes, WindowButtons, WindowLevel,
+    self, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, ImePurpose,
+    ResizeDirection, Theme, Window as CoreWindow, WindowAttributes, WindowButtons, WindowLevel,
 };
 
 mod keycodes;
@@ -203,11 +201,11 @@ impl EventLoop {
                     let old_scale_factor = scale_factor(&self.android_app);
                     let scale_factor = scale_factor(&self.android_app);
                     if (scale_factor - old_scale_factor).abs() < f64::EPSILON {
-                        let new_inner_size = Arc::new(Mutex::new(screen_size(&self.android_app)));
+                        let new_surface_size = Arc::new(Mutex::new(screen_size(&self.android_app)));
                         let window_id = window::WindowId(WindowId);
                         let event = event::WindowEvent::ScaleFactorChanged {
-                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                                &new_inner_size,
+                            surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(
+                                &new_surface_size,
                             )),
                             scale_factor,
                         };
@@ -289,7 +287,7 @@ impl EventLoop {
                     PhysicalSize::new(0, 0)
                 };
                 let window_id = window::WindowId(WindowId);
-                let event = event::WindowEvent::Resized(size);
+                let event = event::WindowEvent::SurfaceResized(size);
                 app.window_event(&self.window_target, window_id, event);
             }
 
@@ -594,16 +592,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_window(
         &self,
         window_attributes: WindowAttributes,
-    ) -> Result<RootWindow, error::OsError> {
-        let window = Window::new(self, window_attributes)?;
-        Ok(RootWindow { window })
+    ) -> Result<Box<dyn CoreWindow>, RequestError> {
+        Ok(Box::new(Window::new(self, window_attributes)?))
     }
 
     fn create_custom_cursor(
         &self,
         _source: CustomCursorSource,
-    ) -> Result<CustomCursor, ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    ) -> Result<CustomCursor, RequestError> {
+        Err(NotSupportedError::new("create_custom_cursor is not supported").into())
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
@@ -640,10 +637,6 @@ impl RootActiveEventLoop for ActiveEventLoop {
         RootOwnedDisplayHandle { platform: OwnedDisplayHandle }
     }
 
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     #[cfg(feature = "rwh_06")]
     fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
         self
@@ -722,178 +715,24 @@ impl Window {
     pub(crate) fn new(
         el: &ActiveEventLoop,
         _window_attrs: window::WindowAttributes,
-    ) -> Result<Self, error::OsError> {
+    ) -> Result<Self, RequestError> {
         // FIXME this ignores requested window attributes
 
         Ok(Self { app: el.app.clone(), redraw_requester: el.redraw_requester.clone() })
     }
 
-    pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Self) + Send + 'static) {
-        f(self)
+    pub fn config(&self) -> ConfigurationRef {
+        self.app.config()
     }
 
-    pub(crate) fn maybe_wait_on_main<R: Send>(&self, f: impl FnOnce(&Self) -> R + Send) -> R {
-        f(self)
-    }
-
-    pub fn id(&self) -> WindowId {
-        WindowId
-    }
-
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        None
-    }
-
-    pub fn available_monitors(&self) -> Option<MonitorHandle> {
-        None
-    }
-
-    pub fn current_monitor(&self) -> Option<MonitorHandle> {
-        None
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        scale_factor(&self.app)
-    }
-
-    pub fn request_redraw(&self) {
-        self.redraw_requester.request_redraw()
-    }
-
-    pub fn pre_present_notify(&self) {}
-
-    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, error::NotSupportedError> {
-        Err(error::NotSupportedError::new())
-    }
-
-    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, error::NotSupportedError> {
-        Err(error::NotSupportedError::new())
-    }
-
-    pub fn set_outer_position(&self, _position: Position) {
-        // no effect
-    }
-
-    pub fn inner_size(&self) -> PhysicalSize<u32> {
-        self.outer_size()
-    }
-
-    pub fn request_inner_size(&self, _size: Size) -> Option<PhysicalSize<u32>> {
-        Some(self.inner_size())
-    }
-
-    pub fn outer_size(&self) -> PhysicalSize<u32> {
-        screen_size(&self.app)
-    }
-
-    pub fn set_min_inner_size(&self, _: Option<Size>) {}
-
-    pub fn set_max_inner_size(&self, _: Option<Size>) {}
-
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
-        None
-    }
-
-    pub fn set_resize_increments(&self, _increments: Option<Size>) {}
-
-    pub fn set_title(&self, _title: &str) {}
-
-    pub fn set_transparent(&self, _transparent: bool) {}
-
-    pub fn set_blur(&self, _blur: bool) {}
-
-    pub fn set_visible(&self, _visibility: bool) {}
-
-    pub fn is_visible(&self) -> Option<bool> {
-        None
-    }
-
-    pub fn set_resizable(&self, _resizeable: bool) {}
-
-    pub fn is_resizable(&self) -> bool {
-        false
-    }
-
-    pub fn set_enabled_buttons(&self, _buttons: WindowButtons) {}
-
-    pub fn enabled_buttons(&self) -> WindowButtons {
-        WindowButtons::all()
-    }
-
-    pub fn set_minimized(&self, _minimized: bool) {}
-
-    pub fn is_minimized(&self) -> Option<bool> {
-        None
-    }
-
-    pub fn set_maximized(&self, _maximized: bool) {}
-
-    pub fn is_maximized(&self) -> bool {
-        false
-    }
-
-    pub fn set_fullscreen(&self, _monitor: Option<Fullscreen>) {
-        warn!("Cannot set fullscreen on Android");
-    }
-
-    pub fn fullscreen(&self) -> Option<Fullscreen> {
-        None
-    }
-
-    pub fn set_decorations(&self, _decorations: bool) {}
-
-    pub fn is_decorated(&self) -> bool {
-        true
-    }
-
-    pub fn set_window_level(&self, _level: WindowLevel) {}
-
-    pub fn set_window_icon(&self, _window_icon: Option<crate::icon::Icon>) {}
-
-    pub fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}
-
-    pub fn set_ime_allowed(&self, _allowed: bool) {}
-
-    pub fn set_ime_purpose(&self, _purpose: ImePurpose) {}
-
-    pub fn focus_window(&self) {}
-
-    pub fn request_user_attention(&self, _request_type: Option<window::UserAttentionType>) {}
-
-    pub fn set_cursor(&self, _: Cursor) {}
-
-    pub fn set_cursor_position(&self, _: Position) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
-    }
-
-    pub fn set_cursor_grab(&self, _: CursorGrabMode) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
-    }
-
-    pub fn set_cursor_visible(&self, _: bool) {}
-
-    pub fn drag_window(&self) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
-    }
-
-    pub fn drag_resize_window(
-        &self,
-        _direction: ResizeDirection,
-    ) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
-    }
-
-    #[inline]
-    pub fn show_window_menu(&self, _position: Position) {}
-
-    pub fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
+    pub fn content_rect(&self) -> Rect {
+        self.app.content_rect()
     }
 
     #[cfg(feature = "rwh_06")]
     // Allow the usage of HasRawWindowHandle inside this function
     #[allow(deprecated)]
-    pub fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
+    fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
         use rwh_06::HasRawWindowHandle;
 
         if let Some(native_window) = self.app.native_window().as_ref() {
@@ -909,37 +748,206 @@ impl Window {
     }
 
     #[cfg(feature = "rwh_06")]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
+    fn raw_display_handle_rwh_06(&self) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
         Ok(rwh_06::RawDisplayHandle::Android(rwh_06::AndroidDisplayHandle::new()))
     }
+}
 
-    pub fn config(&self) -> ConfigurationRef {
-        self.app.config()
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for Window {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = self.raw_display_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasWindowHandle for Window {
+    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        let raw = self.raw_window_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::WindowHandle::borrow_raw(raw)) }
+    }
+}
+
+impl CoreWindow for Window {
+    fn id(&self) -> window::WindowId {
+        window::WindowId(WindowId)
     }
 
-    pub fn content_rect(&self) -> Rect {
-        self.app.content_rect()
-    }
-
-    pub fn set_theme(&self, _theme: Option<Theme>) {}
-
-    pub fn theme(&self) -> Option<Theme> {
+    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
         None
     }
 
-    pub fn set_content_protected(&self, _protected: bool) {}
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
+        Box::new(std::iter::empty())
+    }
 
-    pub fn has_focus(&self) -> bool {
+    fn current_monitor(&self) -> Option<RootMonitorHandle> {
+        None
+    }
+
+    fn scale_factor(&self) -> f64 {
+        scale_factor(&self.app)
+    }
+
+    fn request_redraw(&self) {
+        self.redraw_requester.request_redraw()
+    }
+
+    fn pre_present_notify(&self) {}
+
+    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        Err(NotSupportedError::new("inner_position is not supported").into())
+    }
+
+    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        Err(NotSupportedError::new("outer_position is not supported").into())
+    }
+
+    fn set_outer_position(&self, _position: Position) {
+        // no effect
+    }
+
+    fn surface_size(&self) -> PhysicalSize<u32> {
+        self.outer_size()
+    }
+
+    fn request_surface_size(&self, _size: Size) -> Option<PhysicalSize<u32>> {
+        Some(self.surface_size())
+    }
+
+    fn outer_size(&self) -> PhysicalSize<u32> {
+        screen_size(&self.app)
+    }
+
+    fn set_min_surface_size(&self, _: Option<Size>) {}
+
+    fn set_max_surface_size(&self, _: Option<Size>) {}
+
+    fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        None
+    }
+
+    fn set_surface_resize_increments(&self, _increments: Option<Size>) {}
+
+    fn set_title(&self, _title: &str) {}
+
+    fn set_transparent(&self, _transparent: bool) {}
+
+    fn set_blur(&self, _blur: bool) {}
+
+    fn set_visible(&self, _visibility: bool) {}
+
+    fn is_visible(&self) -> Option<bool> {
+        None
+    }
+
+    fn set_resizable(&self, _resizeable: bool) {}
+
+    fn is_resizable(&self) -> bool {
+        false
+    }
+
+    fn set_enabled_buttons(&self, _buttons: WindowButtons) {}
+
+    fn enabled_buttons(&self) -> WindowButtons {
+        WindowButtons::all()
+    }
+
+    fn set_minimized(&self, _minimized: bool) {}
+
+    fn is_minimized(&self) -> Option<bool> {
+        None
+    }
+
+    fn set_maximized(&self, _maximized: bool) {}
+
+    fn is_maximized(&self) -> bool {
+        false
+    }
+
+    fn set_fullscreen(&self, _monitor: Option<Fullscreen>) {
+        warn!("Cannot set fullscreen on Android");
+    }
+
+    fn fullscreen(&self) -> Option<Fullscreen> {
+        None
+    }
+
+    fn set_decorations(&self, _decorations: bool) {}
+
+    fn is_decorated(&self) -> bool {
+        true
+    }
+
+    fn set_window_level(&self, _level: WindowLevel) {}
+
+    fn set_window_icon(&self, _window_icon: Option<crate::icon::Icon>) {}
+
+    fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}
+
+    fn set_ime_allowed(&self, _allowed: bool) {}
+
+    fn set_ime_purpose(&self, _purpose: ImePurpose) {}
+
+    fn focus_window(&self) {}
+
+    fn request_user_attention(&self, _request_type: Option<window::UserAttentionType>) {}
+
+    fn set_cursor(&self, _: Cursor) {}
+
+    fn set_cursor_position(&self, _: Position) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("set_cursor_position is not supported").into())
+    }
+
+    fn set_cursor_grab(&self, _: CursorGrabMode) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("set_cursor_grab is not supported").into())
+    }
+
+    fn set_cursor_visible(&self, _: bool) {}
+
+    fn drag_window(&self) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("drag_window is not supported").into())
+    }
+
+    fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("drag_resize_window").into())
+    }
+
+    #[inline]
+    fn show_window_menu(&self, _position: Position) {}
+
+    fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("set_cursor_hittest is not supported").into())
+    }
+
+    fn set_theme(&self, _theme: Option<Theme>) {}
+
+    fn theme(&self) -> Option<Theme> {
+        None
+    }
+
+    fn set_content_protected(&self, _protected: bool) {}
+
+    fn has_focus(&self) -> bool {
         HAS_FOCUS.load(Ordering::Relaxed)
     }
 
-    pub fn title(&self) -> String {
+    fn title(&self) -> String {
         String::new()
     }
 
-    pub fn reset_dead_keys(&self) {}
+    fn reset_dead_keys(&self) {}
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
+        self
+    }
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
+        self
+    }
 }
 
 #[derive(Default, Clone, Debug)]

src/platform_impl/apple/appkit/app.rs

@@ -1,10 +1,12 @@
 #![allow(clippy::unnecessary_cast)]
 
+use std::rc::Rc;
+
 use objc2::{declare_class, msg_send, mutability, ClassType, DeclaredClass};
 use objc2_app_kit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType, NSResponder};
 use objc2_foundation::{MainThreadMarker, NSObject};
 
-use super::app_state::ApplicationDelegate;
+use super::app_state::AppState;
 use super::DEVICE_ID;
 use crate::event::{DeviceEvent, ElementState};
 
@@ -38,15 +40,15 @@ declare_class!(
                     key_window.sendEvent(event);
                 }
             } else {
-                let delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-                maybe_dispatch_device_event(&delegate, event);
+                let app_state = AppState::get(MainThreadMarker::from(self));
+                maybe_dispatch_device_event(&app_state, event);
                 unsafe { msg_send![super(self), sendEvent: event] }
             }
         }
     }
 );
 
-fn maybe_dispatch_device_event(delegate: &ApplicationDelegate, event: &NSEvent) {
+fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
     let event_type = unsafe { event.r#type() };
     #[allow(non_upper_case_globals)]
     match event_type {
@@ -58,7 +60,7 @@ fn maybe_dispatch_device_event(delegate: &ApplicationDelegate, event: &NSEvent)
             let delta_y = unsafe { event.deltaY() } as f64;
 
             if delta_x != 0.0 || delta_y != 0.0 {
-                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                app_state.maybe_queue_with_handler(move |app, event_loop| {
                     app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseMotion {
                         delta: (delta_x, delta_y),
                     });
@@ -67,7 +69,7 @@ fn maybe_dispatch_device_event(delegate: &ApplicationDelegate, event: &NSEvent)
         },
         NSEventType::LeftMouseDown | NSEventType::RightMouseDown | NSEventType::OtherMouseDown => {
             let button = unsafe { event.buttonNumber() } as u32;
-            delegate.maybe_queue_with_handler(move |app, event_loop| {
+            app_state.maybe_queue_with_handler(move |app, event_loop| {
                 app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
                     button,
                     state: ElementState::Pressed,
@@ -76,7 +78,7 @@ fn maybe_dispatch_device_event(delegate: &ApplicationDelegate, event: &NSEvent)
         },
         NSEventType::LeftMouseUp | NSEventType::RightMouseUp | NSEventType::OtherMouseUp => {
             let button = unsafe { event.buttonNumber() } as u32;
-            delegate.maybe_queue_with_handler(move |app, event_loop| {
+            app_state.maybe_queue_with_handler(move |app, event_loop| {
                 app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
                     button,
                     state: ElementState::Released,

src/platform_impl/apple/appkit/app_state.rs

@@ -1,16 +1,14 @@
-use std::cell::{Cell, RefCell};
+use std::cell::{Cell, OnceCell, RefCell};
 use std::mem;
-use std::rc::Weak;
+use std::rc::{Rc, Weak};
 use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
 use std::sync::Arc;
 use std::time::Instant;
 
-use objc2::rc::Retained;
-use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
-use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSApplicationDelegate};
-use objc2_foundation::{MainThreadMarker, NSNotification, NSObject, NSObjectProtocol};
+use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy};
+use objc2_foundation::{MainThreadMarker, NSNotification};
 
-use super::event_handler::EventHandler;
+use super::super::event_handler::EventHandler;
 use super::event_loop::{stop_app_immediately, ActiveEventLoop, PanicInfo};
 use super::observer::{EventLoopWaker, RunLoop};
 use super::{menu, WindowId};
@@ -21,6 +19,7 @@ use crate::window::WindowId as RootWindowId;
 
 #[derive(Debug)]
 pub(super) struct AppState {
+    mtm: MainThreadMarker,
     activation_policy: NSApplicationActivationPolicy,
     default_menu: bool,
     activate_ignoring_other_apps: bool,
@@ -46,43 +45,32 @@ pub(super) struct AppState {
     // as such should be careful to not add fields that, in turn, strongly reference those.
 }
 
-declare_class!(
-    #[derive(Debug)]
-    pub(super) struct ApplicationDelegate;
+// TODO(madsmtm): Use `MainThreadBound` once that is possible in `static`s.
+struct StaticMainThreadBound<T>(T);
 
-    unsafe impl ClassType for ApplicationDelegate {
-        type Super = NSObject;
-        type Mutability = mutability::MainThreadOnly;
-        const NAME: &'static str = "WinitApplicationDelegate";
+impl<T> StaticMainThreadBound<T> {
+    const fn get(&self, _mtm: MainThreadMarker) -> &T {
+        &self.0
     }
+}
 
-    impl DeclaredClass for ApplicationDelegate {
-        type Ivars = AppState;
-    }
+unsafe impl<T> Send for StaticMainThreadBound<T> {}
+unsafe impl<T> Sync for StaticMainThreadBound<T> {}
 
-    unsafe impl NSObjectProtocol for ApplicationDelegate {}
+// SAFETY: Creating `StaticMainThreadBound` in a `const` context, where there is no concept of the
+// main thread.
+static GLOBAL: StaticMainThreadBound<OnceCell<Rc<AppState>>> =
+    StaticMainThreadBound(OnceCell::new());
 
-    unsafe impl NSApplicationDelegate for ApplicationDelegate {
-        #[method(applicationDidFinishLaunching:)]
-        fn app_did_finish_launching(&self, notification: &NSNotification) {
-            self.did_finish_launching(notification)
-        }
-
-        #[method(applicationWillTerminate:)]
-        fn app_will_terminate(&self, notification: &NSNotification) {
-            self.will_terminate(notification)
-        }
-    }
-);
-
-impl ApplicationDelegate {
-    pub(super) fn new(
+impl AppState {
+    pub(super) fn setup_global(
         mtm: MainThreadMarker,
         activation_policy: NSApplicationActivationPolicy,
         default_menu: bool,
         activate_ignoring_other_apps: bool,
-    ) -> Retained<Self> {
-        let this = mtm.alloc().set_ivars(AppState {
+    ) -> Rc<Self> {
+        let this = Rc::new(AppState {
+            mtm,
             activation_policy,
             proxy_wake_up: Arc::new(AtomicBool::new(false)),
             default_menu,
@@ -102,33 +90,41 @@ impl ApplicationDelegate {
             wait_timeout: Cell::new(None),
             pending_redraw: RefCell::new(vec![]),
         });
-        unsafe { msg_send_id![super(this), init] }
+
+        GLOBAL.get(mtm).set(this.clone()).expect("application state can only be set once");
+        this
     }
 
-    // NOTE: This will, globally, only be run once, no matter how many
-    // `EventLoop`s the user creates.
-    fn did_finish_launching(&self, _notification: &NSNotification) {
-        trace_scope!("applicationDidFinishLaunching:");
-        self.ivars().is_launched.set(true);
+    pub fn get(mtm: MainThreadMarker) -> Rc<Self> {
+        GLOBAL
+            .get(mtm)
+            .get()
+            .expect("tried to get application state before it was registered")
+            .clone()
+    }
 
-        let mtm = MainThreadMarker::from(self);
-        let app = NSApplication::sharedApplication(mtm);
+    // NOTE: This notification will, globally, only be emitted once,
+    // no matter how many `EventLoop`s the user creates.
+    pub fn did_finish_launching(self: &Rc<Self>, _notification: &NSNotification) {
+        trace_scope!("NSApplicationDidFinishLaunchingNotification");
+        self.is_launched.set(true);
+
+        let app = NSApplication::sharedApplication(self.mtm);
         // We need to delay setting the activation policy and activating the app
         // until `applicationDidFinishLaunching` has been called. Otherwise the
         // menu bar is initially unresponsive on macOS 10.15.
-        app.setActivationPolicy(self.ivars().activation_policy);
+        app.setActivationPolicy(self.activation_policy);
 
-        window_activation_hack(&app);
         #[allow(deprecated)]
-        app.activateIgnoringOtherApps(self.ivars().activate_ignoring_other_apps);
+        app.activateIgnoringOtherApps(self.activate_ignoring_other_apps);
 
-        if self.ivars().default_menu {
+        if self.default_menu {
             // The menubar initialization should be before the `NewEvents` event, to allow
             // overriding of the default menu even if it's created
             menu::initialize(&app);
         }
 
-        self.ivars().waker.borrow_mut().start();
+        self.waker.borrow_mut().start();
 
         self.set_is_running(true);
         self.dispatch_init_events();
@@ -138,77 +134,65 @@ impl ApplicationDelegate {
         //
         // In this case we still want to consider Winit's `EventLoop` to be "running",
         // so we call `start_running()` above.
-        if self.ivars().stop_on_launch.get() {
+        if self.stop_on_launch.get() {
             // NOTE: the original idea had been to only stop the underlying `RunLoop`
             // for the app but that didn't work as expected (`-[NSApplication run]`
             // effectively ignored the attempt to stop the RunLoop and re-started it).
             //
             // So we return from `pump_events` by stopping the application.
-            let app = NSApplication::sharedApplication(mtm);
+            let app = NSApplication::sharedApplication(self.mtm);
             stop_app_immediately(&app);
         }
     }
 
-    fn will_terminate(&self, _notification: &NSNotification) {
-        trace_scope!("applicationWillTerminate:");
+    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?
         self.internal_exit();
     }
 
-    pub fn get(mtm: MainThreadMarker) -> Retained<Self> {
-        let app = NSApplication::sharedApplication(mtm);
-        let delegate =
-            unsafe { app.delegate() }.expect("a delegate was not configured on the application");
-        if delegate.is_kind_of::<Self>() {
-            // SAFETY: Just checked that the delegate is an instance of `ApplicationDelegate`
-            unsafe { Retained::cast(delegate) }
-        } else {
-            panic!("tried to get a delegate that was not the one Winit has registered")
-        }
-    }
-
-    /// Place the event handler in the application delegate for the duration
+    /// Place the event handler in the application state for the duration
     /// of the given closure.
     pub fn set_event_handler<R>(
         &self,
         handler: &mut dyn ApplicationHandler,
         closure: impl FnOnce() -> R,
     ) -> R {
-        self.ivars().event_handler.set(handler, closure)
+        self.event_handler.set(handler, closure)
     }
 
     pub fn proxy_wake_up(&self) -> Arc<AtomicBool> {
-        self.ivars().proxy_wake_up.clone()
+        self.proxy_wake_up.clone()
     }
 
     /// If `pump_events` is called to progress the event loop then we
     /// bootstrap the event loop via `-[NSApplication run]` but will use
     /// `CFRunLoopRunInMode` for subsequent calls to `pump_events`.
     pub fn set_stop_on_launch(&self) {
-        self.ivars().stop_on_launch.set(true);
+        self.stop_on_launch.set(true);
     }
 
     pub fn set_stop_before_wait(&self, value: bool) {
-        self.ivars().stop_before_wait.set(value)
+        self.stop_before_wait.set(value)
     }
 
     pub fn set_stop_after_wait(&self, value: bool) {
-        self.ivars().stop_after_wait.set(value)
+        self.stop_after_wait.set(value)
     }
 
     pub fn set_stop_on_redraw(&self, value: bool) {
-        self.ivars().stop_on_redraw.set(value)
+        self.stop_on_redraw.set(value)
     }
 
     pub fn set_wait_timeout(&self, value: Option<Instant>) {
-        self.ivars().wait_timeout.set(value)
+        self.wait_timeout.set(value)
     }
 
     /// Clears the `running` state and resets the `control_flow` state when an `EventLoop` exits.
     ///
     /// 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) {
+    pub fn internal_exit(self: &Rc<Self>) {
         self.with_handler(|app, event_loop| {
             app.exiting(event_loop);
         });
@@ -221,42 +205,41 @@ impl ApplicationDelegate {
     }
 
     pub fn is_launched(&self) -> bool {
-        self.ivars().is_launched.get()
+        self.is_launched.get()
     }
 
     pub fn set_is_running(&self, value: bool) {
-        self.ivars().is_running.set(value)
+        self.is_running.set(value)
     }
 
     pub fn is_running(&self) -> bool {
-        self.ivars().is_running.get()
+        self.is_running.get()
     }
 
     pub fn exit(&self) {
-        self.ivars().exit.set(true)
+        self.exit.set(true)
     }
 
     pub fn clear_exit(&self) {
-        self.ivars().exit.set(false)
+        self.exit.set(false)
     }
 
     pub fn exiting(&self) -> bool {
-        self.ivars().exit.get()
+        self.exit.get()
     }
 
     pub fn set_control_flow(&self, value: ControlFlow) {
-        self.ivars().control_flow.set(value)
+        self.control_flow.set(value)
     }
 
     pub fn control_flow(&self) -> ControlFlow {
-        self.ivars().control_flow.get()
+        self.control_flow.get()
     }
 
-    pub fn handle_redraw(&self, window_id: WindowId) {
-        let mtm = MainThreadMarker::from(self);
+    pub fn handle_redraw(self: &Rc<Self>, window_id: WindowId) {
         // Redraw request might come out of order from the OS.
         // -> Don't go back into the event handler when our callstack originates from there
-        if !self.ivars().event_handler.in_use() {
+        if !self.event_handler.in_use() {
             self.with_handler(|app, event_loop| {
                 app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
             });
@@ -264,24 +247,24 @@ impl ApplicationDelegate {
             // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested
             // events as a way to ensure that `pump_events` can't block an external loop
             // indefinitely
-            if self.ivars().stop_on_redraw.get() {
-                let app = NSApplication::sharedApplication(mtm);
+            if self.stop_on_redraw.get() {
+                let app = NSApplication::sharedApplication(self.mtm);
                 stop_app_immediately(&app);
             }
         }
     }
 
     pub fn queue_redraw(&self, window_id: WindowId) {
-        let mut pending_redraw = self.ivars().pending_redraw.borrow_mut();
+        let mut pending_redraw = self.pending_redraw.borrow_mut();
         if !pending_redraw.contains(&window_id) {
             pending_redraw.push(window_id);
         }
-        self.ivars().run_loop.wakeup();
+        self.run_loop.wakeup();
     }
 
     #[track_caller]
     pub fn maybe_queue_with_handler(
-        &self,
+        self: &Rc<Self>,
         callback: impl FnOnce(&mut dyn ApplicationHandler, &ActiveEventLoop) + 'static,
     ) {
         // Most programmer actions in AppKit (e.g. change window fullscreen, set focused, etc.)
@@ -290,26 +273,28 @@ impl ApplicationDelegate {
         // However, it is not documented which actions do this, and which ones are done immediately,
         // so to make sure that we don't encounter re-entrancy issues, we first check if we're
         // currently handling another event, and if we are, we queue the event instead.
-        if !self.ivars().event_handler.in_use() {
+        if !self.event_handler.in_use() {
             self.with_handler(callback);
         } else {
             tracing::debug!("had to queue event since another is currently being handled");
-            let this = self.retain();
-            self.ivars().run_loop.queue_closure(move || {
+            let this = Rc::clone(self);
+            self.run_loop.queue_closure(move || {
                 this.with_handler(callback);
             });
         }
     }
 
     #[track_caller]
-    fn with_handler(&self, callback: impl FnOnce(&mut dyn ApplicationHandler, &ActiveEventLoop)) {
-        let event_loop =
-            ActiveEventLoop { delegate: self.retain(), mtm: MainThreadMarker::from(self) };
-        self.ivars().event_handler.handle(callback, &event_loop);
+    fn with_handler(
+        self: &Rc<Self>,
+        callback: impl FnOnce(&mut dyn ApplicationHandler, &ActiveEventLoop),
+    ) {
+        let event_loop = ActiveEventLoop { app_state: Rc::clone(self), mtm: self.mtm };
+        self.event_handler.handle(|app| callback(app, &event_loop));
     }
 
     /// dispatch `NewEvents(Init)` + `Resumed`
-    pub fn dispatch_init_events(&self) {
+    pub fn dispatch_init_events(self: &Rc<Self>) {
         self.with_handler(|app, event_loop| app.new_events(event_loop, StartCause::Init));
         // NB: For consistency all platforms must call `can_create_surfaces` even though macOS
         // applications don't themselves have a formal surface destroy/create lifecycle.
@@ -317,23 +302,22 @@ impl ApplicationDelegate {
     }
 
     // Called by RunLoopObserver after finishing waiting for new events
-    pub fn wakeup(&self, panic_info: Weak<PanicInfo>) {
-        let mtm = MainThreadMarker::from(self);
+    pub fn wakeup(self: &Rc<Self>, panic_info: Weak<PanicInfo>) {
         let panic_info = panic_info
             .upgrade()
             .expect("The panic info must exist here. This failure indicates a developer error.");
 
         // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        if panic_info.is_panicking() || !self.ivars().event_handler.ready() || !self.is_running() {
+        if panic_info.is_panicking() || !self.event_handler.ready() || !self.is_running() {
             return;
         }
 
-        if self.ivars().stop_after_wait.get() {
-            let app = NSApplication::sharedApplication(mtm);
+        if self.stop_after_wait.get() {
+            let app = NSApplication::sharedApplication(self.mtm);
             stop_app_immediately(&app);
         }
 
-        let start = self.ivars().start_time.get().unwrap();
+        let start = self.start_time.get().unwrap();
         let cause = match self.control_flow() {
             ControlFlow::Poll => StartCause::Poll,
             ControlFlow::Wait => StartCause::WaitCancelled { start, requested_resume: None },
@@ -350,8 +334,7 @@ impl ApplicationDelegate {
     }
 
     // Called by RunLoopObserver before waiting for new events
-    pub fn cleared(&self, panic_info: Weak<PanicInfo>) {
-        let mtm = MainThreadMarker::from(self);
+    pub fn cleared(self: &Rc<Self>, panic_info: Weak<PanicInfo>) {
         let panic_info = panic_info
             .upgrade()
             .expect("The panic info must exist here. This failure indicates a developer error.");
@@ -359,15 +342,15 @@ impl ApplicationDelegate {
         // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
         // XXX: how does it make sense that `event_handler.ready()` can ever return `false` here if
         // we're about to return to the `CFRunLoop` to poll for new events?
-        if panic_info.is_panicking() || !self.ivars().event_handler.ready() || !self.is_running() {
+        if panic_info.is_panicking() || !self.event_handler.ready() || !self.is_running() {
             return;
         }
 
-        if self.ivars().proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
+        if self.proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
             self.with_handler(|app, event_loop| app.proxy_wake_up(event_loop));
         }
 
-        let redraw = mem::take(&mut *self.ivars().pending_redraw.borrow_mut());
+        let redraw = mem::take(&mut *self.pending_redraw.borrow_mut());
         for window_id in redraw {
             self.with_handler(|app, event_loop| {
                 app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
@@ -378,22 +361,22 @@ impl ApplicationDelegate {
         });
 
         if self.exiting() {
-            let app = NSApplication::sharedApplication(mtm);
+            let app = NSApplication::sharedApplication(self.mtm);
             stop_app_immediately(&app);
         }
 
-        if self.ivars().stop_before_wait.get() {
-            let app = NSApplication::sharedApplication(mtm);
+        if self.stop_before_wait.get() {
+            let app = NSApplication::sharedApplication(self.mtm);
             stop_app_immediately(&app);
         }
-        self.ivars().start_time.set(Some(Instant::now()));
-        let wait_timeout = self.ivars().wait_timeout.get(); // configured by pump_events
+        self.start_time.set(Some(Instant::now()));
+        let wait_timeout = self.wait_timeout.get(); // configured by pump_events
         let app_timeout = match self.control_flow() {
             ControlFlow::Wait => None,
             ControlFlow::Poll => Some(Instant::now()),
             ControlFlow::WaitUntil(instant) => Some(instant),
         };
-        self.ivars().waker.borrow_mut().start_at(min_timeout(wait_timeout, app_timeout));
+        self.waker.borrow_mut().start_at(min_timeout(wait_timeout, app_timeout));
     }
 }
 
@@ -403,26 +386,3 @@ impl ApplicationDelegate {
 fn min_timeout(a: Option<Instant>, b: Option<Instant>) -> Option<Instant> {
     a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
 }
-
-/// A hack to make activation of multiple windows work when creating them before
-/// `applicationDidFinishLaunching:` / `Event::Event::NewEvents(StartCause::Init)`.
-///
-/// Alternative to this would be the user calling `window.set_visible(true)` in
-/// `StartCause::Init`.
-///
-/// If this becomes too bothersome to maintain, it can probably be removed
-/// without too much damage.
-fn window_activation_hack(app: &NSApplication) {
-    // TODO: Proper ordering of the windows
-    app.windows().into_iter().for_each(|window| {
-        // Call `makeKeyAndOrderFront` if it was called on the window in `WinitWindow::new`
-        // This way we preserve the user's desired initial visibility status
-        // TODO: Also filter on the type/"level" of the window, and maybe other things?
-        if window.isVisible() {
-            tracing::trace!("Activating visible window");
-            window.makeKeyAndOrderFront(None);
-        } else {
-            tracing::trace!("Skipping activating invisible window");
-        }
-    })
-}

src/platform_impl/apple/appkit/cursor.rs

@@ -11,9 +11,8 @@ use objc2_foundation::{
     NSString,
 };
 
-use super::OsError;
 use crate::cursor::{CursorImage, OnlyCursorImageSource};
-use crate::error::ExternalError;
+use crate::error::RequestError;
 use crate::window::CursorIcon;
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -25,12 +24,12 @@ unsafe impl Send for CustomCursor {}
 unsafe impl Sync for CustomCursor {}
 
 impl CustomCursor {
-    pub(crate) fn new(cursor: OnlyCursorImageSource) -> Result<CustomCursor, ExternalError> {
+    pub(crate) fn new(cursor: OnlyCursorImageSource) -> Result<CustomCursor, RequestError> {
         cursor_from_image(&cursor.0).map(Self)
     }
 }
 
-pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Result<Retained<NSCursor>, ExternalError> {
+pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Result<Retained<NSCursor>, RequestError> {
     let width = cursor.width;
     let height = cursor.height;
 
@@ -48,7 +47,7 @@ pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Result<Retained<NSCurso
             width as isize * 4,
             32,
         )
-    }.ok_or_else(|| ExternalError::Os(os_error!(OsError::CreationError("parent view should be installed in a window"))))?;
+    }.ok_or_else(|| os_error!("parent view should be installed in a window"))?;
     let bitmap_data = unsafe { slice::from_raw_parts_mut(bitmap.bitmapData(), cursor.rgba.len()) };
     bitmap_data.copy_from_slice(&cursor.rgba);
 

src/platform_impl/apple/appkit/event_loop.rs

@@ -14,19 +14,22 @@ use core_foundation::runloop::{
     CFRunLoopSourceCreate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
 };
 use objc2::rc::{autoreleasepool, Retained};
-use objc2::runtime::ProtocolObject;
 use objc2::{msg_send_id, sel, ClassType};
-use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSWindow};
-use objc2_foundation::{MainThreadMarker, NSObjectProtocol};
+use objc2_app_kit::{
+    NSApplication, NSApplicationActivationPolicy, NSApplicationDidFinishLaunchingNotification,
+    NSApplicationWillTerminateNotification, NSWindow,
+};
+use objc2_foundation::{MainThreadMarker, NSNotificationCenter, NSObject, NSObjectProtocol};
 
+use super::super::notification_center::create_observer;
 use super::app::WinitApplication;
-use super::app_state::ApplicationDelegate;
+use super::app_state::AppState;
 use super::cursor::CustomCursor;
 use super::event::dummy_event;
 use super::monitor;
 use super::observer::setup_control_flow_observers;
 use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, ExternalError};
+use crate::error::{EventLoopError, RequestError};
 use crate::event_loop::{
     ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
     EventLoopProxy as RootEventLoopProxy, OwnedDisplayHandle as RootOwnedDisplayHandle,
@@ -35,9 +38,7 @@ use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::platform::macos::ActivationPolicy;
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::Window;
-use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as RootWindow,
-};
+use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme};
 
 #[derive(Default)]
 pub struct PanicInfo {
@@ -71,15 +72,11 @@ impl PanicInfo {
 
 #[derive(Debug)]
 pub struct ActiveEventLoop {
-    pub(super) delegate: Retained<ApplicationDelegate>,
+    pub(super) app_state: Rc<AppState>,
     pub(super) mtm: MainThreadMarker,
 }
 
 impl ActiveEventLoop {
-    pub(super) fn app_delegate(&self) -> &ApplicationDelegate {
-        &self.delegate
-    }
-
     pub(crate) fn hide_application(&self) {
         NSApplication::sharedApplication(self.mtm).hide(None)
     }
@@ -99,22 +96,21 @@ impl ActiveEventLoop {
 
 impl RootActiveEventLoop for ActiveEventLoop {
     fn create_proxy(&self) -> RootEventLoopProxy {
-        let event_loop_proxy = EventLoopProxy::new(self.delegate.proxy_wake_up());
+        let event_loop_proxy = EventLoopProxy::new(self.app_state.proxy_wake_up());
         RootEventLoopProxy { event_loop_proxy }
     }
 
     fn create_window(
         &self,
         window_attributes: crate::window::WindowAttributes,
-    ) -> Result<crate::window::Window, crate::error::OsError> {
-        let window = Window::new(self, window_attributes)?;
-        Ok(RootWindow { window })
+    ) -> Result<Box<dyn crate::window::Window>, RequestError> {
+        Ok(Box::new(Window::new(self, window_attributes)?))
     }
 
     fn create_custom_cursor(
         &self,
         source: CustomCursorSource,
-    ) -> Result<RootCustomCursor, ExternalError> {
+    ) -> Result<RootCustomCursor, RequestError> {
         Ok(RootCustomCursor { inner: CustomCursor::new(source.inner)? })
     }
 
@@ -140,29 +136,25 @@ impl RootActiveEventLoop for ActiveEventLoop {
     }
 
     fn set_control_flow(&self, control_flow: ControlFlow) {
-        self.delegate.set_control_flow(control_flow)
+        self.app_state.set_control_flow(control_flow)
     }
 
     fn control_flow(&self) -> ControlFlow {
-        self.delegate.control_flow()
+        self.app_state.control_flow()
     }
 
     fn exit(&self) {
-        self.delegate.exit()
+        self.app_state.exit()
     }
 
     fn exiting(&self) -> bool {
-        self.delegate.exiting()
+        self.app_state.exiting()
     }
 
     fn owned_display_handle(&self) -> RootOwnedDisplayHandle {
         RootOwnedDisplayHandle { platform: OwnedDisplayHandle }
     }
 
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     #[cfg(feature = "rwh_06")]
     fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
         self
@@ -183,14 +175,17 @@ pub struct EventLoop {
     /// We intentionally don't store `WinitApplication` since we want to have
     /// the possibility of swapping that out at some point.
     app: Retained<NSApplication>,
-    /// The application delegate that we've registered.
-    ///
-    /// The delegate is only weakly referenced by NSApplication, so we must
-    /// keep it around here as well.
-    delegate: Retained<ApplicationDelegate>,
+    app_state: Rc<AppState>,
 
     window_target: ActiveEventLoop,
     panic_info: Rc<PanicInfo>,
+
+    // Since macOS 10.11, we no longer need to remove the observers before they are deallocated;
+    // the system instead cleans it up next time it would have posted a notification to it.
+    //
+    // Though we do still need to keep the observers around to prevent them from being deallocated.
+    _did_finish_launching_observer: Retained<NSObject>,
+    _will_terminate_observer: Retained<NSObject>,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -233,25 +228,49 @@ impl EventLoop {
             ActivationPolicy::Prohibited => NSApplicationActivationPolicy::Prohibited,
         };
 
-        let delegate = ApplicationDelegate::new(
+        let app_state = AppState::setup_global(
             mtm,
             activation_policy,
             attributes.default_menu,
             attributes.activate_ignoring_other_apps,
         );
 
-        autoreleasepool(|_| {
-            app.setDelegate(Some(ProtocolObject::from_ref(&*delegate)));
-        });
+        let center = unsafe { NSNotificationCenter::defaultCenter() };
+
+        let weak_app_state = Rc::downgrade(&app_state);
+        let _did_finish_launching_observer = create_observer(
+            &center,
+            // `applicationDidFinishLaunching:`
+            unsafe { NSApplicationDidFinishLaunchingNotification },
+            move |notification| {
+                if let Some(app_state) = weak_app_state.upgrade() {
+                    app_state.did_finish_launching(notification);
+                }
+            },
+        );
+
+        let weak_app_state = Rc::downgrade(&app_state);
+        let _will_terminate_observer = create_observer(
+            &center,
+            // `applicationWillTerminate:`
+            unsafe { NSApplicationWillTerminateNotification },
+            move |notification| {
+                if let Some(app_state) = weak_app_state.upgrade() {
+                    app_state.will_terminate(notification);
+                }
+            },
+        );
 
         let panic_info: Rc<PanicInfo> = Default::default();
         setup_control_flow_observers(mtm, Rc::downgrade(&panic_info));
 
         Ok(EventLoop {
             app,
-            delegate: delegate.clone(),
-            window_target: ActiveEventLoop { delegate, mtm },
+            app_state: app_state.clone(),
+            window_target: ActiveEventLoop { app_state, mtm },
             panic_info,
+            _did_finish_launching_observer,
+            _will_terminate_observer,
         })
     }
 
@@ -271,19 +290,19 @@ impl EventLoop {
         &mut self,
         mut app: A,
     ) -> Result<(), EventLoopError> {
-        self.delegate.clear_exit();
-        self.delegate.set_event_handler(&mut app, || {
+        self.app_state.clear_exit();
+        self.app_state.set_event_handler(&mut app, || {
             autoreleasepool(|_| {
                 // clear / normalize pump_events state
-                self.delegate.set_wait_timeout(None);
-                self.delegate.set_stop_before_wait(false);
-                self.delegate.set_stop_after_wait(false);
-                self.delegate.set_stop_on_redraw(false);
+                self.app_state.set_wait_timeout(None);
+                self.app_state.set_stop_before_wait(false);
+                self.app_state.set_stop_after_wait(false);
+                self.app_state.set_stop_on_redraw(false);
 
-                if self.delegate.is_launched() {
-                    debug_assert!(!self.delegate.is_running());
-                    self.delegate.set_is_running(true);
-                    self.delegate.dispatch_init_events();
+                if self.app_state.is_launched() {
+                    debug_assert!(!self.app_state.is_running());
+                    self.app_state.set_is_running(true);
+                    self.app_state.dispatch_init_events();
                 }
 
                 // SAFETY: We do not run the application re-entrantly
@@ -298,7 +317,7 @@ impl EventLoop {
                     resume_unwind(panic);
                 }
 
-                self.delegate.internal_exit()
+                self.app_state.internal_exit()
             })
         });
 
@@ -310,47 +329,47 @@ impl EventLoop {
         timeout: Option<Duration>,
         mut app: A,
     ) -> PumpStatus {
-        self.delegate.set_event_handler(&mut app, || {
+        self.app_state.set_event_handler(&mut 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.
-                if !self.delegate.is_launched() {
-                    debug_assert!(!self.delegate.is_running());
+                if !self.app_state.is_launched() {
+                    debug_assert!(!self.app_state.is_running());
 
-                    self.delegate.set_stop_on_launch();
+                    self.app_state.set_stop_on_launch();
                     // SAFETY: We do not run the application re-entrantly
                     unsafe { self.app.run() };
 
                     // Note: we dispatch `NewEvents(Init)` + `Resumed` events after the application
                     // has launched
-                } else if !self.delegate.is_running() {
+                } else if !self.app_state.is_running() {
                     // Even though the application may have been launched, it's possible we aren't
                     // running if the `EventLoop` was run before and has since
                     // exited. This indicates that we just starting to re-run
                     // the same `EventLoop` again.
-                    self.delegate.set_is_running(true);
-                    self.delegate.dispatch_init_events();
+                    self.app_state.set_is_running(true);
+                    self.app_state.dispatch_init_events();
                 } else {
                     // Only run for as long as the given `Duration` allows so we don't block the
                     // external loop.
                     match timeout {
                         Some(Duration::ZERO) => {
-                            self.delegate.set_wait_timeout(None);
-                            self.delegate.set_stop_before_wait(true);
+                            self.app_state.set_wait_timeout(None);
+                            self.app_state.set_stop_before_wait(true);
                         },
                         Some(duration) => {
-                            self.delegate.set_stop_before_wait(false);
+                            self.app_state.set_stop_before_wait(false);
                             let timeout = Instant::now() + duration;
-                            self.delegate.set_wait_timeout(Some(timeout));
-                            self.delegate.set_stop_after_wait(true);
+                            self.app_state.set_wait_timeout(Some(timeout));
+                            self.app_state.set_stop_after_wait(true);
                         },
                         None => {
-                            self.delegate.set_wait_timeout(None);
-                            self.delegate.set_stop_before_wait(false);
-                            self.delegate.set_stop_after_wait(true);
+                            self.app_state.set_wait_timeout(None);
+                            self.app_state.set_stop_before_wait(false);
+                            self.app_state.set_stop_after_wait(true);
                         },
                     }
-                    self.delegate.set_stop_on_redraw(true);
+                    self.app_state.set_stop_on_redraw(true);
                     // SAFETY: We do not run the application re-entrantly
                     unsafe { self.app.run() };
                 }
@@ -364,8 +383,8 @@ impl EventLoop {
                     resume_unwind(panic);
                 }
 
-                if self.delegate.exiting() {
-                    self.delegate.internal_exit();
+                if self.app_state.exiting() {
+                    self.app_state.internal_exit();
                     PumpStatus::Exit(0)
                 } else {
                     PumpStatus::Continue

src/platform_impl/apple/appkit/mod.rs

@@ -5,7 +5,6 @@ mod app;
 mod app_state;
 mod cursor;
 mod event;
-mod event_handler;
 mod event_loop;
 mod ffi;
 mod menu;
@@ -15,8 +14,6 @@ mod view;
 mod window;
 mod window_delegate;
 
-use std::fmt;
-
 pub(crate) use self::cursor::CustomCursor as PlatformCustomCursor;
 pub(crate) use self::event::{physicalkey_to_scancode, scancode_to_physicalkey, KeyEventExtra};
 pub(crate) use self::event_loop::{
@@ -51,18 +48,3 @@ impl FingerId {
         FingerId
     }
 }
-
-#[derive(Debug)]
-pub enum OsError {
-    CGError(core_graphics::base::CGError),
-    CreationError(&'static str),
-}
-
-impl fmt::Display for OsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            OsError::CGError(e) => f.pad(&format!("CGError {e}")),
-            OsError::CreationError(e) => f.pad(e),
-        }
-    }
-}

src/platform_impl/apple/appkit/observer.rs

@@ -22,7 +22,7 @@ use core_foundation::runloop::{
 use objc2_foundation::MainThreadMarker;
 use tracing::error;
 
-use super::app_state::ApplicationDelegate;
+use super::app_state::AppState;
 use super::event_loop::{stop_app_on_panic, PanicInfo};
 use super::ffi;
 
@@ -59,7 +59,7 @@ extern "C" fn control_flow_begin_handler(
             match activity {
                 kCFRunLoopAfterWaiting => {
                     // trace!("Triggered `CFRunLoopAfterWaiting`");
-                    ApplicationDelegate::get(MainThreadMarker::new().unwrap()).wakeup(panic_info);
+                    AppState::get(MainThreadMarker::new().unwrap()).wakeup(panic_info);
                     // trace!("Completed `CFRunLoopAfterWaiting`");
                 },
                 _ => unreachable!(),
@@ -81,7 +81,7 @@ extern "C" fn control_flow_end_handler(
             match activity {
                 kCFRunLoopBeforeWaiting => {
                     // trace!("Triggered `CFRunLoopBeforeWaiting`");
-                    ApplicationDelegate::get(MainThreadMarker::new().unwrap()).cleared(panic_info);
+                    AppState::get(MainThreadMarker::new().unwrap()).cleared(panic_info);
                     // trace!("Completed `CFRunLoopBeforeWaiting`");
                 },
                 kCFRunLoopExit => (), // unimplemented!(), // not expected to ever happen

src/platform_impl/apple/appkit/view.rs

@@ -2,6 +2,7 @@
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, VecDeque};
 use std::ptr;
+use std::rc::Rc;
 
 use objc2::rc::{Retained, WeakId};
 use objc2::runtime::{AnyObject, Sel};
@@ -16,7 +17,7 @@ use objc2_foundation::{
     NSPoint, NSRange, NSRect, NSSize, NSString, NSUInteger,
 };
 
-use super::app_state::ApplicationDelegate;
+use super::app_state::AppState;
 use super::cursor::{default_cursor, invisible_cursor};
 use super::event::{
     code_to_key, code_to_location, create_key_event, event_mods, lalt_pressed, ralt_pressed,
@@ -112,7 +113,7 @@ fn get_left_modifier_code(key: &Key) -> KeyCode {
 #[derive(Debug)]
 pub struct ViewState {
     /// Strong reference to the global application state.
-    app_delegate: Retained<ApplicationDelegate>,
+    app_state: Rc<AppState>,
 
     cursor_state: RefCell<CursorState>,
     ime_position: Cell<NSPoint>,
@@ -197,7 +198,7 @@ declare_class!(
             // 2. Even when a window resize does occur on a new tabbed window, it contains the wrong size (includes tab height).
             let logical_size = LogicalSize::new(rect.size.width as f64, rect.size.height as f64);
             let size = logical_size.to_physical::<u32>(self.scale_factor());
-            self.queue_event(WindowEvent::Resized(size));
+            self.queue_event(WindowEvent::SurfaceResized(size));
         }
 
         #[method(drawRect:)]
@@ -206,7 +207,7 @@ declare_class!(
 
             // It's a workaround for https://github.com/rust-windowing/winit/issues/2640, don't replace with `self.window_id()`.
             if let Some(window) = self.ivars()._ns_window.load() {
-                self.ivars().app_delegate.handle_redraw(window.id());
+                self.ivars().app_state.handle_redraw(window.id());
             }
 
             // This is a direct subclass of NSView, no need to call superclass' drawRect:
@@ -687,7 +688,7 @@ declare_class!(
 
             self.update_modifiers(event, false);
 
-            self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop|
+            self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop|
                 app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseWheel { delta })
             );
             self.queue_event(WindowEvent::MouseWheel {
@@ -782,14 +783,14 @@ declare_class!(
 
 impl WinitView {
     pub(super) fn new(
-        app_delegate: &ApplicationDelegate,
+        app_state: &Rc<AppState>,
         window: &WinitWindow,
         accepts_first_mouse: bool,
         option_as_alt: OptionAsAlt,
     ) -> Retained<Self> {
         let mtm = MainThreadMarker::from(window);
         let this = mtm.alloc().set_ivars(ViewState {
-            app_delegate: app_delegate.retain(),
+            app_state: Rc::clone(app_state),
             cursor_state: Default::default(),
             ime_position: Default::default(),
             ime_size: Default::default(),
@@ -834,7 +835,7 @@ impl WinitView {
 
     fn queue_event(&self, event: WindowEvent) {
         let window_id = RootWindowId(self.window().id());
-        self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop| {
+        self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop| {
             app.window_event(event_loop, window_id, event);
         });
     }

src/platform_impl/apple/appkit/window.rs

@@ -1,5 +1,6 @@
 #![allow(clippy::unnecessary_cast)]
 
+use dpi::{Position, Size};
 use objc2::rc::{autoreleasepool, Retained};
 use objc2::{declare_class, mutability, ClassType, DeclaredClass};
 use objc2_app_kit::{NSResponder, NSWindow};
@@ -7,8 +8,12 @@ use objc2_foundation::{MainThreadBound, MainThreadMarker, NSObject};
 
 use super::event_loop::ActiveEventLoop;
 use super::window_delegate::WindowDelegate;
-use crate::error::OsError as RootOsError;
-use crate::window::WindowAttributes;
+use crate::error::RequestError;
+use crate::monitor::MonitorHandle as CoreMonitorHandle;
+use crate::window::{
+    Cursor, Fullscreen, Icon, ImePurpose, Theme, UserAttentionType, Window as CoreWindow,
+    WindowAttributes, WindowButtons, WindowLevel,
+};
 
 pub(crate) struct Window {
     window: MainThreadBound<Retained<WinitWindow>>,
@@ -16,32 +21,20 @@ pub(crate) struct Window {
     delegate: MainThreadBound<Retained<WindowDelegate>>,
 }
 
-impl Drop for Window {
-    fn drop(&mut self) {
-        self.window.get_on_main(|window| autoreleasepool(|_| window.close()))
-    }
-}
-
 impl Window {
     pub(crate) fn new(
         window_target: &ActiveEventLoop,
         attributes: WindowAttributes,
-    ) -> Result<Self, RootOsError> {
+    ) -> Result<Self, RequestError> {
         let mtm = window_target.mtm;
-        let delegate = autoreleasepool(|_| {
-            WindowDelegate::new(window_target.app_delegate(), attributes, mtm)
-        })?;
+        let delegate =
+            autoreleasepool(|_| WindowDelegate::new(&window_target.app_state, attributes, mtm))?;
         Ok(Window {
             window: MainThreadBound::new(delegate.window().retain(), mtm),
             delegate: MainThreadBound::new(delegate, mtm),
         })
     }
 
-    pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&WindowDelegate) + Send + 'static) {
-        // For now, don't actually do queuing, since it may be less predictable
-        self.maybe_wait_on_main(f)
-    }
-
     pub(crate) fn maybe_wait_on_main<R: Send>(
         &self,
         f: impl FnOnce(&WindowDelegate) -> R + Send,
@@ -70,6 +63,278 @@ impl Window {
     }
 }
 
+impl Drop for Window {
+    fn drop(&mut self) {
+        // Restore the video mode.
+        if matches!(self.fullscreen(), Some(Fullscreen::Exclusive(_))) {
+            self.set_fullscreen(None);
+        }
+
+        self.window.get_on_main(|window| autoreleasepool(|_| window.close()))
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for Window {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = self.raw_display_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasWindowHandle for Window {
+    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        let raw = self.raw_window_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::WindowHandle::borrow_raw(raw)) }
+    }
+}
+
+impl CoreWindow for Window {
+    fn id(&self) -> crate::window::WindowId {
+        self.maybe_wait_on_main(|delegate| crate::window::WindowId(delegate.id()))
+    }
+
+    fn scale_factor(&self) -> f64 {
+        self.maybe_wait_on_main(|delegate| delegate.scale_factor())
+    }
+
+    fn request_redraw(&self) {
+        self.maybe_wait_on_main(|delegate| delegate.request_redraw());
+    }
+
+    fn pre_present_notify(&self) {
+        self.maybe_wait_on_main(|delegate| delegate.pre_present_notify());
+    }
+
+    fn reset_dead_keys(&self) {
+        self.maybe_wait_on_main(|delegate| delegate.reset_dead_keys());
+    }
+
+    fn inner_position(&self) -> Result<dpi::PhysicalPosition<i32>, RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.inner_position()))
+    }
+
+    fn outer_position(&self) -> Result<dpi::PhysicalPosition<i32>, RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.outer_position()))
+    }
+
+    fn set_outer_position(&self, position: Position) {
+        self.maybe_wait_on_main(|delegate| delegate.set_outer_position(position));
+    }
+
+    fn surface_size(&self) -> dpi::PhysicalSize<u32> {
+        self.maybe_wait_on_main(|delegate| delegate.surface_size())
+    }
+
+    fn request_surface_size(&self, size: Size) -> Option<dpi::PhysicalSize<u32>> {
+        self.maybe_wait_on_main(|delegate| delegate.request_surface_size(size))
+    }
+
+    fn outer_size(&self) -> dpi::PhysicalSize<u32> {
+        self.maybe_wait_on_main(|delegate| delegate.outer_size())
+    }
+
+    fn set_min_surface_size(&self, min_size: Option<Size>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_min_surface_size(min_size))
+    }
+
+    fn set_max_surface_size(&self, max_size: Option<Size>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_max_surface_size(max_size));
+    }
+
+    fn surface_resize_increments(&self) -> Option<dpi::PhysicalSize<u32>> {
+        self.maybe_wait_on_main(|delegate| delegate.surface_resize_increments())
+    }
+
+    fn set_surface_resize_increments(&self, increments: Option<Size>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_surface_resize_increments(increments));
+    }
+
+    fn set_title(&self, title: &str) {
+        self.maybe_wait_on_main(|delegate| delegate.set_title(title));
+    }
+
+    fn set_transparent(&self, transparent: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_transparent(transparent));
+    }
+
+    fn set_blur(&self, blur: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_blur(blur));
+    }
+
+    fn set_visible(&self, visible: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_visible(visible));
+    }
+
+    fn is_visible(&self) -> Option<bool> {
+        self.maybe_wait_on_main(|delegate| delegate.is_visible())
+    }
+
+    fn set_resizable(&self, resizable: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_resizable(resizable))
+    }
+
+    fn is_resizable(&self) -> bool {
+        self.maybe_wait_on_main(|delegate| delegate.is_resizable())
+    }
+
+    fn set_enabled_buttons(&self, buttons: WindowButtons) {
+        self.maybe_wait_on_main(|delegate| delegate.set_enabled_buttons(buttons))
+    }
+
+    fn enabled_buttons(&self) -> WindowButtons {
+        self.maybe_wait_on_main(|delegate| delegate.enabled_buttons())
+    }
+
+    fn set_minimized(&self, minimized: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_minimized(minimized));
+    }
+
+    fn is_minimized(&self) -> Option<bool> {
+        self.maybe_wait_on_main(|delegate| delegate.is_minimized())
+    }
+
+    fn set_maximized(&self, maximized: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_maximized(maximized));
+    }
+
+    fn is_maximized(&self) -> bool {
+        self.maybe_wait_on_main(|delegate| delegate.is_maximized())
+    }
+
+    fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_fullscreen(fullscreen.map(Into::into)))
+    }
+
+    fn fullscreen(&self) -> Option<Fullscreen> {
+        self.maybe_wait_on_main(|delegate| delegate.fullscreen().map(Into::into))
+    }
+
+    fn set_decorations(&self, decorations: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_decorations(decorations));
+    }
+
+    fn is_decorated(&self) -> bool {
+        self.maybe_wait_on_main(|delegate| delegate.is_decorated())
+    }
+
+    fn set_window_level(&self, level: WindowLevel) {
+        self.maybe_wait_on_main(|delegate| delegate.set_window_level(level));
+    }
+
+    fn set_window_icon(&self, window_icon: Option<Icon>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_window_icon(window_icon));
+    }
+
+    fn set_ime_cursor_area(&self, position: Position, size: Size) {
+        self.maybe_wait_on_main(|delegate| delegate.set_ime_cursor_area(position, size));
+    }
+
+    fn set_ime_allowed(&self, allowed: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_ime_allowed(allowed));
+    }
+
+    fn set_ime_purpose(&self, purpose: ImePurpose) {
+        self.maybe_wait_on_main(|delegate| delegate.set_ime_purpose(purpose));
+    }
+
+    fn focus_window(&self) {
+        self.maybe_wait_on_main(|delegate| delegate.focus_window());
+    }
+
+    fn has_focus(&self) -> bool {
+        self.maybe_wait_on_main(|delegate| delegate.has_focus())
+    }
+
+    fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        self.maybe_wait_on_main(|delegate| delegate.request_user_attention(request_type));
+    }
+
+    fn set_theme(&self, theme: Option<Theme>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_theme(theme));
+    }
+
+    fn theme(&self) -> Option<Theme> {
+        self.maybe_wait_on_main(|delegate| delegate.theme())
+    }
+
+    fn set_content_protected(&self, protected: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_content_protected(protected));
+    }
+
+    fn title(&self) -> String {
+        self.maybe_wait_on_main(|delegate| delegate.title())
+    }
+
+    fn set_cursor(&self, cursor: Cursor) {
+        self.maybe_wait_on_main(|delegate| delegate.set_cursor(cursor));
+    }
+
+    fn set_cursor_position(&self, position: Position) -> Result<(), RequestError> {
+        self.maybe_wait_on_main(|delegate| delegate.set_cursor_position(position))
+    }
+
+    fn set_cursor_grab(&self, mode: crate::window::CursorGrabMode) -> Result<(), RequestError> {
+        self.maybe_wait_on_main(|delegate| delegate.set_cursor_grab(mode))
+    }
+
+    fn set_cursor_visible(&self, visible: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_cursor_visible(visible))
+    }
+
+    fn drag_window(&self) -> Result<(), RequestError> {
+        self.maybe_wait_on_main(|delegate| delegate.drag_window());
+        Ok(())
+    }
+
+    fn drag_resize_window(
+        &self,
+        direction: crate::window::ResizeDirection,
+    ) -> Result<(), RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.drag_resize_window(direction))?)
+    }
+
+    fn show_window_menu(&self, position: Position) {
+        self.maybe_wait_on_main(|delegate| delegate.show_window_menu(position))
+    }
+
+    fn set_cursor_hittest(&self, hittest: bool) -> Result<(), RequestError> {
+        self.maybe_wait_on_main(|delegate| delegate.set_cursor_hittest(hittest));
+        Ok(())
+    }
+
+    fn current_monitor(&self) -> Option<CoreMonitorHandle> {
+        self.maybe_wait_on_main(|delegate| {
+            delegate.current_monitor().map(|inner| CoreMonitorHandle { inner })
+        })
+    }
+
+    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 }),
+            )
+        })
+    }
+
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
+        self.maybe_wait_on_main(|delegate| {
+            delegate.primary_monitor().map(|inner| CoreMonitorHandle { inner })
+        })
+    }
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
+        self
+    }
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
+        self
+    }
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WindowId(pub usize);
 

src/platform_impl/apple/appkit/window_delegate.rs

@@ -3,6 +3,7 @@ use std::cell::{Cell, RefCell};
 use std::collections::VecDeque;
 use std::ffi::c_void;
 use std::ptr;
+use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 
 use core_graphics::display::{CGDisplay, CGPoint};
@@ -26,16 +27,16 @@ use objc2_foundation::{
 };
 use tracing::{trace, warn};
 
-use super::app_state::ApplicationDelegate;
+use super::app_state::AppState;
 use super::cursor::cursor_from_icon;
 use super::monitor::{self, flip_window_screen_coordinates, get_display_id};
 use super::observer::RunLoop;
 use super::view::WinitView;
 use super::window::WinitWindow;
-use super::{ffi, Fullscreen, MonitorHandle, OsError, WindowId};
+use super::{ffi, Fullscreen, MonitorHandle, WindowId};
 use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
-use crate::event::{InnerSizeWriter, WindowEvent};
+use crate::error::{NotSupportedError, RequestError};
+use crate::event::{SurfaceSizeWriter, WindowEvent};
 use crate::platform::macos::{OptionAsAlt, WindowExtMacOS};
 use crate::window::{
     Cursor, CursorGrabMode, Icon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
@@ -55,6 +56,7 @@ pub struct PlatformSpecificWindowAttributes {
     pub accepts_first_mouse: bool,
     pub tabbing_identifier: Option<String>,
     pub option_as_alt: OptionAsAlt,
+    pub borderless_game: bool,
 }
 
 impl Default for PlatformSpecificWindowAttributes {
@@ -72,6 +74,7 @@ impl Default for PlatformSpecificWindowAttributes {
             accepts_first_mouse: true,
             tabbing_identifier: None,
             option_as_alt: Default::default(),
+            borderless_game: false,
         }
     }
 }
@@ -79,7 +82,7 @@ impl Default for PlatformSpecificWindowAttributes {
 #[derive(Debug)]
 pub(crate) struct State {
     /// Strong reference to the global application state.
-    app_delegate: Retained<ApplicationDelegate>,
+    app_state: Rc<AppState>,
 
     window: Retained<WinitWindow>,
 
@@ -92,7 +95,7 @@ pub(crate) struct State {
     previous_scale_factor: Cell<f64>,
 
     /// The current resize increments for the window content.
-    resize_increments: Cell<NSSize>,
+    surface_resize_increments: Cell<NSSize>,
     /// Whether the window is showing decorations.
     decorations: Cell<bool>,
     resizable: Cell<bool>,
@@ -120,6 +123,7 @@ pub(crate) struct State {
     standard_frame: Cell<Option<NSRect>>,
     is_simple_fullscreen: Cell<bool>,
     saved_style: Cell<Option<NSWindowStyleMask>>,
+    is_borderless_game: Cell<bool>,
 }
 
 declare_class!(
@@ -160,7 +164,7 @@ declare_class!(
         #[method(windowDidResize:)]
         fn window_did_resize(&self, _: Option<&AnyObject>) {
             trace_scope!("windowDidResize:");
-            // NOTE: WindowEvent::Resized is reported in frameDidChange.
+            // NOTE: WindowEvent::SurfaceResized is reported in frameDidChange.
             self.emit_move_event();
         }
 
@@ -168,7 +172,7 @@ declare_class!(
         fn window_will_start_live_resize(&self, _: Option<&AnyObject>) {
             trace_scope!("windowWillStartLiveResize:");
 
-            let increments = self.ivars().resize_increments.get();
+            let increments = self.ivars().surface_resize_increments.get();
             self.set_resize_increments_inner(increments);
         }
 
@@ -482,7 +486,7 @@ impl Drop for WindowDelegate {
 }
 
 fn new_window(
-    app_delegate: &ApplicationDelegate,
+    app_state: &Rc<AppState>,
     attrs: &WindowAttributes,
     mtm: MainThreadMarker,
 ) -> Option<Retained<WinitWindow>> {
@@ -501,7 +505,7 @@ fn new_window(
                 let scale_factor = NSScreen::mainScreen(mtm)
                     .map(|screen| screen.backingScaleFactor() as f64)
                     .unwrap_or(1.0);
-                let size = match attrs.inner_size {
+                let size = match attrs.surface_size {
                     Some(size) => {
                         let size = size.to_logical(scale_factor);
                         NSSize::new(size.width, size.height)
@@ -557,6 +561,11 @@ fn new_window(
             masks |= NSWindowStyleMask::FullSizeContentView;
         }
 
+        // NOTE: This should only be created after the application has started launching,
+        // (`applicationWillFinishLaunching:` at the earliest), otherwise you'll run into very
+        // confusing issues with the window not being properly activated.
+        //
+        // Winit ensures this by not allowing access to `ActiveEventLoop` before handling events.
         let window: Option<Retained<WinitWindow>> = unsafe {
             msg_send_id![
                 super(mtm.alloc().set_ivars(())),
@@ -622,7 +631,7 @@ fn new_window(
         }
 
         let view = WinitView::new(
-            app_delegate,
+            app_state,
             &window,
             attrs.platform_specific.accepts_first_mouse,
             attrs.platform_specific.option_as_alt,
@@ -665,12 +674,12 @@ fn new_window(
 
 impl WindowDelegate {
     pub(super) fn new(
-        app_delegate: &ApplicationDelegate,
+        app_state: &Rc<AppState>,
         attrs: WindowAttributes,
         mtm: MainThreadMarker,
-    ) -> Result<Retained<Self>, RootOsError> {
-        let window = new_window(app_delegate, &attrs, mtm)
-            .ok_or_else(|| os_error!(OsError::CreationError("couldn't create `NSWindow`")))?;
+    ) -> Result<Retained<Self>, RequestError> {
+        let window = new_window(app_state, &attrs, mtm)
+            .ok_or_else(|| os_error!("couldn't create `NSWindow`"))?;
 
         #[cfg(feature = "rwh_06")]
         match attrs.parent_window.map(|handle| handle.0) {
@@ -679,9 +688,9 @@ impl WindowDelegate {
                 // Unwrap is fine, since the pointer comes from `NonNull`.
                 let parent_view: Retained<NSView> =
                     unsafe { Retained::retain(handle.ns_view.as_ptr().cast()) }.unwrap();
-                let parent = parent_view.window().ok_or_else(|| {
-                    os_error!(OsError::CreationError("parent view should be installed in a window"))
-                })?;
+                let parent = parent_view
+                    .window()
+                    .ok_or_else(|| os_error!("parent view should be installed in a window"))?;
 
                 // SAFETY: We know that there are no parent -> child -> parent cycles since the only
                 // place in `winit` where we allow making a window a child window is
@@ -694,13 +703,15 @@ impl WindowDelegate {
             None => (),
         }
 
-        let resize_increments =
-            match attrs.resize_increments.map(|i| i.to_logical(window.backingScaleFactor() as _)) {
-                Some(LogicalSize { width, height }) if width >= 1. && height >= 1. => {
-                    NSSize::new(width, height)
-                },
-                _ => NSSize::new(1., 1.),
-            };
+        let surface_resize_increments = match attrs
+            .surface_resize_increments
+            .map(|i| i.to_logical(window.backingScaleFactor() as _))
+        {
+            Some(LogicalSize { width, height }) if width >= 1. && height >= 1. => {
+                NSSize::new(width, height)
+            },
+            _ => NSSize::new(1., 1.),
+        };
 
         let scale_factor = window.backingScaleFactor() as _;
 
@@ -709,11 +720,11 @@ impl WindowDelegate {
         }
 
         let delegate = mtm.alloc().set_ivars(State {
-            app_delegate: app_delegate.retain(),
+            app_state: Rc::clone(app_state),
             window: window.retain(),
             previous_position: Cell::new(None),
             previous_scale_factor: Cell::new(scale_factor),
-            resize_increments: Cell::new(resize_increments),
+            surface_resize_increments: Cell::new(surface_resize_increments),
             decorations: Cell::new(attrs.decorations),
             resizable: Cell::new(attrs.resizable),
             maximized: Cell::new(attrs.maximized),
@@ -725,6 +736,7 @@ impl WindowDelegate {
             standard_frame: Cell::new(None),
             is_simple_fullscreen: Cell::new(false),
             saved_style: Cell::new(None),
+            is_borderless_game: Cell::new(attrs.platform_specific.borderless_game),
         });
         let delegate: Retained<WindowDelegate> = unsafe { msg_send_id![super(delegate), init] };
 
@@ -753,11 +765,11 @@ impl WindowDelegate {
             delegate.set_blur(attrs.blur);
         }
 
-        if let Some(dim) = attrs.min_inner_size {
-            delegate.set_min_inner_size(Some(dim));
+        if let Some(dim) = attrs.min_surface_size {
+            delegate.set_min_surface_size(Some(dim));
         }
-        if let Some(dim) = attrs.max_inner_size {
-            delegate.set_max_inner_size(Some(dim));
+        if let Some(dim) = attrs.max_surface_size {
+            delegate.set_max_surface_size(Some(dim));
         }
 
         delegate.set_window_level(attrs.window_level);
@@ -808,7 +820,7 @@ impl WindowDelegate {
 
     pub(crate) fn queue_event(&self, event: WindowEvent) {
         let window_id = RootWindowId(self.window().id());
-        self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop| {
+        self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop| {
             app.window_event(event_loop, window_id, event);
         });
     }
@@ -820,20 +832,20 @@ impl WindowDelegate {
         let content_size = LogicalSize::new(content_size.width, content_size.height);
 
         let suggested_size = content_size.to_physical(scale_factor);
-        let new_inner_size = Arc::new(Mutex::new(suggested_size));
+        let new_surface_size = Arc::new(Mutex::new(suggested_size));
         self.queue_event(WindowEvent::ScaleFactorChanged {
             scale_factor,
-            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
+            surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_surface_size)),
         });
-        let physical_size = *new_inner_size.lock().unwrap();
-        drop(new_inner_size);
+        let physical_size = *new_surface_size.lock().unwrap();
+        drop(new_surface_size);
 
         if physical_size != suggested_size {
             let logical_size = physical_size.to_logical(scale_factor);
             let size = NSSize::new(logical_size.width, logical_size.height);
             window.setContentSize(size);
         }
-        self.queue_event(WindowEvent::Resized(physical_size));
+        self.queue_event(WindowEvent::SurfaceResized(physical_size));
     }
 
     fn emit_move_event(&self) {
@@ -907,21 +919,21 @@ impl WindowDelegate {
     }
 
     pub fn request_redraw(&self) {
-        self.ivars().app_delegate.queue_redraw(self.window().id());
+        self.ivars().app_state.queue_redraw(self.window().id());
     }
 
     #[inline]
     pub fn pre_present_notify(&self) {}
 
-    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+    pub fn outer_position(&self) -> PhysicalPosition<i32> {
         let position = flip_window_screen_coordinates(self.window().frame());
-        Ok(LogicalPosition::new(position.x, position.y).to_physical(self.scale_factor()))
+        LogicalPosition::new(position.x, position.y).to_physical(self.scale_factor())
     }
 
-    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+    pub fn inner_position(&self) -> PhysicalPosition<i32> {
         let content_rect = self.window().contentRectForFrameRect(self.window().frame());
         let position = flip_window_screen_coordinates(content_rect);
-        Ok(LogicalPosition::new(position.x, position.y).to_physical(self.scale_factor()))
+        LogicalPosition::new(position.x, position.y).to_physical(self.scale_factor())
     }
 
     pub fn set_outer_position(&self, position: Position) {
@@ -934,7 +946,7 @@ impl WindowDelegate {
     }
 
     #[inline]
-    pub fn inner_size(&self) -> PhysicalSize<u32> {
+    pub fn surface_size(&self) -> PhysicalSize<u32> {
         let content_rect = self.window().contentRectForFrameRect(self.window().frame());
         let logical = LogicalSize::new(content_rect.size.width, content_rect.size.height);
         logical.to_physical(self.scale_factor())
@@ -948,14 +960,14 @@ impl WindowDelegate {
     }
 
     #[inline]
-    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
+    pub fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let scale_factor = self.scale_factor();
         let size = size.to_logical(scale_factor);
         self.window().setContentSize(NSSize::new(size.width, size.height));
         None
     }
 
-    pub fn set_min_inner_size(&self, dimensions: Option<Size>) {
+    pub fn set_min_surface_size(&self, dimensions: Option<Size>) {
         let dimensions =
             dimensions.unwrap_or(Size::Logical(LogicalSize { width: 0.0, height: 0.0 }));
         let min_size = dimensions.to_logical::<CGFloat>(self.scale_factor());
@@ -974,7 +986,7 @@ impl WindowDelegate {
         self.window().setContentSize(current_size);
     }
 
-    pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
+    pub fn set_max_surface_size(&self, dimensions: Option<Size>) {
         let dimensions = dimensions.unwrap_or(Size::Logical(LogicalSize {
             width: f32::MAX as f64,
             height: f32::MAX as f64,
@@ -996,8 +1008,8 @@ impl WindowDelegate {
         self.window().setContentSize(current_size);
     }
 
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
-        let increments = self.ivars().resize_increments.get();
+    pub fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        let increments = self.ivars().surface_resize_increments.get();
         let (w, h) = (increments.width, increments.height);
         if w > 1.0 || h > 1.0 {
             Some(LogicalSize::new(w, h).to_physical(self.scale_factor()))
@@ -1006,9 +1018,9 @@ impl WindowDelegate {
         }
     }
 
-    pub fn set_resize_increments(&self, increments: Option<Size>) {
+    pub fn set_surface_resize_increments(&self, increments: Option<Size>) {
         // XXX the resize increments are only used during live resizes.
-        self.ivars().resize_increments.set(
+        self.ivars().surface_resize_increments.set(
             increments
                 .map(|increments| {
                     let logical = increments.to_logical::<f64>(self.scale_factor());
@@ -1113,18 +1125,18 @@ impl WindowDelegate {
     }
 
     #[inline]
-    pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
+    pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError> {
         let associate_mouse_cursor = match mode {
             CursorGrabMode::Locked => false,
             CursorGrabMode::None => true,
             CursorGrabMode::Confined => {
-                return Err(ExternalError::NotSupported(NotSupportedError::new()))
+                return Err(NotSupportedError::new("confined cursor is not supported").into())
             },
         };
 
         // TODO: Do this for real https://stackoverflow.com/a/40922095/5435443
         CGDisplay::associate_mouse_and_mouse_cursor_position(associate_mouse_cursor)
-            .map_err(|status| ExternalError::Os(os_error!(OsError::CGError(status))))
+            .map_err(|status| os_error!(format!("CGError {status}")).into())
     }
 
     #[inline]
@@ -1142,8 +1154,8 @@ impl WindowDelegate {
     }
 
     #[inline]
-    pub fn set_cursor_position(&self, cursor_position: Position) -> Result<(), ExternalError> {
-        let physical_window_position = self.inner_position().unwrap();
+    pub fn set_cursor_position(&self, cursor_position: Position) -> Result<(), RequestError> {
+        let physical_window_position = self.inner_position();
         let scale_factor = self.scale_factor();
         let window_position = physical_window_position.to_logical::<CGFloat>(scale_factor);
         let logical_cursor_position = cursor_position.to_logical::<CGFloat>(scale_factor);
@@ -1152,33 +1164,31 @@ impl WindowDelegate {
             y: logical_cursor_position.y + window_position.y,
         };
         CGDisplay::warp_mouse_cursor_position(point)
-            .map_err(|e| ExternalError::Os(os_error!(OsError::CGError(e))))?;
+            .map_err(|status| os_error!(format!("CGError {status}")))?;
         CGDisplay::associate_mouse_and_mouse_cursor_position(true)
-            .map_err(|e| ExternalError::Os(os_error!(OsError::CGError(e))))?;
+            .map_err(|status| os_error!(format!("CGError {status}")))?;
 
         Ok(())
     }
 
     #[inline]
-    pub fn drag_window(&self) -> Result<(), ExternalError> {
+    pub fn drag_window(&self) {
         let mtm = MainThreadMarker::from(self);
         let event = NSApplication::sharedApplication(mtm).currentEvent().unwrap();
         self.window().performWindowDragWithEvent(&event);
-        Ok(())
     }
 
     #[inline]
-    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), NotSupportedError> {
+        Err(NotSupportedError::new("drag_resize_window is not supported"))
     }
 
     #[inline]
     pub fn show_window_menu(&self, _position: Position) {}
 
     #[inline]
-    pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
+    pub fn set_cursor_hittest(&self, hittest: bool) {
         self.window().setIgnoresMouseEvents(!hittest);
-        Ok(())
     }
 
     pub(crate) fn is_zoomed(&self) -> bool {
@@ -1411,7 +1421,7 @@ impl WindowDelegate {
         }
 
         match (old_fullscreen, fullscreen) {
-            (None, Some(_)) => {
+            (None, Some(fullscreen)) => {
                 // `toggleFullScreen` doesn't work if the `StyleMask` is none, so we
                 // set a normal style temporarily. The previous state will be
                 // restored in `WindowDelegate::window_did_exit_fullscreen`.
@@ -1421,6 +1431,17 @@ impl WindowDelegate {
                     self.set_style_mask(required);
                     self.ivars().saved_style.set(Some(curr_mask));
                 }
+
+                // In borderless games, we want to disable the dock and menu bar
+                // by setting the presentation options. We do this here rather than in
+                // `window:willUseFullScreenPresentationOptions` because for some reason
+                // the menu bar remains interactable despite being hidden.
+                if self.is_borderless_game() && matches!(fullscreen, Fullscreen::Borderless(_)) {
+                    let presentation_options = NSApplicationPresentationOptions::NSApplicationPresentationHideDock
+                            | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar;
+                    app.setPresentationOptions(presentation_options);
+                }
+
                 toggle_fullscreen(self.window());
             },
             (Some(Fullscreen::Borderless(_)), None) => {
@@ -1807,6 +1828,14 @@ impl WindowExtMacOS for WindowDelegate {
     fn option_as_alt(&self) -> OptionAsAlt {
         self.view().option_as_alt()
     }
+
+    fn set_borderless_game(&self, borderless_game: bool) {
+        self.ivars().is_borderless_game.set(borderless_game);
+    }
+
+    fn is_borderless_game(&self) -> bool {
+        self.ivars().is_borderless_game.get()
+    }
 }
 
 const DEFAULT_STANDARD_FRAME: NSRect =

src/platform_impl/apple/event_handler.rs

@@ -2,8 +2,9 @@ use std::cell::RefCell;
 use std::{fmt, mem};
 
 use crate::application::ApplicationHandler;
-use crate::platform_impl::ActiveEventLoop;
 
+/// A helper type for storing a reference to `ApplicationHandler`, allowing interior mutable access
+/// to it within the execution of a closure.
 #[derive(Default)]
 pub(crate) struct EventHandler {
     /// This can be in the following states:
@@ -100,19 +101,17 @@ impl EventHandler {
         // soundness.
     }
 
+    #[cfg(target_os = "macos")]
     pub(crate) fn in_use(&self) -> bool {
         self.inner.try_borrow().is_err()
     }
 
+    #[cfg(target_os = "macos")]
     pub(crate) fn ready(&self) -> bool {
         matches!(self.inner.try_borrow().as_deref(), Ok(Some(_)))
     }
 
-    pub(crate) fn handle(
-        &self,
-        callback: impl FnOnce(&mut dyn ApplicationHandler, &ActiveEventLoop),
-        event_loop: &ActiveEventLoop,
-    ) {
+    pub(crate) fn handle(&self, callback: impl FnOnce(&mut dyn ApplicationHandler)) {
         match self.inner.try_borrow_mut().as_deref_mut() {
             Ok(Some(user_app)) => {
                 // It is important that we keep the reference borrowed here,
@@ -121,10 +120,10 @@ impl EventHandler {
                 //
                 // If the handler unwinds, the `RefMut` will ensure that the
                 // handler is no longer borrowed.
-                callback(*user_app, event_loop);
+                callback(*user_app);
             },
             Ok(None) => {
-                // `NSApplication`, our app delegate and this handler are all
+                // `NSApplication`, our app state and this handler are all
                 // global state and so it's not impossible that we could get
                 // an event after the application has exited the `EventLoop`.
                 tracing::error!("tried to run event handler, but no handler was set");

src/platform_impl/apple/mod.rs

@@ -2,6 +2,8 @@
 
 #[cfg(target_os = "macos")]
 mod appkit;
+mod event_handler;
+mod notification_center;
 #[cfg(not(target_os = "macos"))]
 mod uikit;
 

src/platform_impl/apple/notification_center.rs

@@ -0,0 +1,27 @@
+use std::ptr::NonNull;
+
+use block2::RcBlock;
+use objc2::rc::Retained;
+use objc2_foundation::{NSNotification, NSNotificationCenter, NSNotificationName, NSObject};
+
+/// Observe the given notification.
+///
+/// This is used in Winit as an alternative to declaring an application delegate, as we want to
+/// give the user full control over those.
+pub fn create_observer(
+    center: &NSNotificationCenter,
+    name: &NSNotificationName,
+    handler: impl Fn(&NSNotification) + 'static,
+) -> Retained<NSObject> {
+    let block = RcBlock::new(move |notification: NonNull<NSNotification>| {
+        handler(unsafe { notification.as_ref() });
+    });
+    unsafe {
+        center.addObserverForName_object_queue_usingBlock(
+            Some(name),
+            None, // No sender filter
+            None, // No queue, run on posting thread (i.e. main thread)
+            &block,
+        )
+    }
+}

src/platform_impl/apple/uikit/app_delegate.rs

@@ -1,60 +0,0 @@
-use objc2::{declare_class, mutability, ClassType, DeclaredClass};
-use objc2_foundation::{MainThreadMarker, NSObject};
-use objc2_ui_kit::UIApplication;
-
-use super::app_state::{self, send_occluded_event_for_all_windows, EventWrapper};
-use crate::event::Event;
-
-declare_class!(
-    pub struct AppDelegate;
-
-    unsafe impl ClassType for AppDelegate {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-        const NAME: &'static str = "WinitApplicationDelegate";
-    }
-
-    impl DeclaredClass for AppDelegate {}
-
-    // UIApplicationDelegate protocol
-    unsafe impl AppDelegate {
-        #[method(application:didFinishLaunchingWithOptions:)]
-        fn did_finish_launching(&self, _application: &UIApplication, _: *mut NSObject) -> bool {
-            app_state::did_finish_launching(MainThreadMarker::new().unwrap());
-            true
-        }
-
-        #[method(applicationDidBecomeActive:)]
-        fn did_become_active(&self, _application: &UIApplication) {
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Resumed))
-        }
-
-        #[method(applicationWillResignActive:)]
-        fn will_resign_active(&self, _application: &UIApplication) {
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Suspended))
-        }
-
-        #[method(applicationWillEnterForeground:)]
-        fn will_enter_foreground(&self, application: &UIApplication) {
-            send_occluded_event_for_all_windows(application, false);
-        }
-
-        #[method(applicationDidEnterBackground:)]
-        fn did_enter_background(&self, application: &UIApplication) {
-            send_occluded_event_for_all_windows(application, true);
-        }
-
-        #[method(applicationWillTerminate:)]
-        fn will_terminate(&self, application: &UIApplication) {
-            app_state::terminated(application);
-        }
-
-        #[method(applicationDidReceiveMemoryWarning:)]
-        fn did_receive_memory_warning(&self, _application: &UIApplication) {
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::MemoryWarning))
-        }
-    }
-);

src/platform_impl/apple/uikit/app_state.rs

@@ -1,12 +1,12 @@
 #![deny(unused_results)]
 
-use std::cell::{RefCell, RefMut};
+use std::cell::{OnceCell, RefCell, RefMut};
 use std::collections::HashSet;
 use std::os::raw::c_void;
-use std::sync::atomic::AtomicBool;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, OnceLock};
 use std::time::Instant;
-use std::{fmt, mem, ptr};
+use std::{mem, ptr};
 
 use core_foundation::base::CFRelease;
 use core_foundation::date::CFAbsoluteTimeGetCurrent;
@@ -15,19 +15,20 @@ use core_foundation::runloop::{
     CFRunLoopTimerInvalidate, CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate,
 };
 use objc2::rc::Retained;
-use objc2::runtime::AnyObject;
-use objc2::{msg_send, sel};
+use objc2::sel;
 use objc2_foundation::{
     CGRect, CGSize, MainThreadMarker, NSInteger, NSObjectProtocol, NSOperatingSystemVersion,
     NSProcessInfo,
 };
 use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView, UIWindow};
 
+use super::super::event_handler::EventHandler;
 use super::window::WinitUIWindow;
 use super::ActiveEventLoop;
+use crate::application::ApplicationHandler;
 use crate::dpi::PhysicalSize;
-use crate::event::{Event, InnerSizeWriter, StartCause, WindowEvent};
-use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
+use crate::event::{Event, StartCause, SurfaceSizeWriter, WindowEvent};
+use crate::event_loop::ControlFlow;
 use crate::window::WindowId as RootWindowId;
 
 macro_rules! bug {
@@ -42,25 +43,45 @@ macro_rules! bug_assert {
     };
 }
 
-pub(crate) struct EventLoopHandler {
-    #[allow(clippy::type_complexity)]
-    pub(crate) handler: Box<dyn FnMut(Event, &dyn RootActiveEventLoop)>,
-    pub(crate) event_loop: ActiveEventLoop,
+/// Get the global event handler for the application.
+///
+/// This is stored separately from AppState, since AppState needs to be accessible while the handler
+/// is executing.
+fn get_handler(mtm: MainThreadMarker) -> &'static EventHandler {
+    // TODO(madsmtm): Use `MainThreadBound` once that is possible in `static`s.
+    struct StaticMainThreadBound<T>(T);
+
+    impl<T> StaticMainThreadBound<T> {
+        const fn get(&self, _mtm: MainThreadMarker) -> &T {
+            &self.0
+        }
+    }
+
+    unsafe impl<T> Send for StaticMainThreadBound<T> {}
+    unsafe impl<T> Sync for StaticMainThreadBound<T> {}
+
+    // SAFETY: Creating `StaticMainThreadBound` in a `const` context, where there is no concept
+    // of the main thread.
+    static GLOBAL: StaticMainThreadBound<OnceCell<EventHandler>> =
+        StaticMainThreadBound(OnceCell::new());
+
+    GLOBAL.get(mtm).get_or_init(EventHandler::new)
 }
 
-impl fmt::Debug for EventLoopHandler {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventLoopHandler")
-            .field("handler", &"...")
-            .field("event_loop", &self.event_loop)
-            .finish()
-    }
-}
-
-impl EventLoopHandler {
-    fn handle_event(&mut self, event: Event) {
-        (self.handler)(event, &self.event_loop)
-    }
+fn handle_event(mtm: MainThreadMarker, event: Event) {
+    let event_loop = &ActiveEventLoop { mtm };
+    get_handler(mtm).handle(|app| match event {
+        Event::NewEvents(cause) => app.new_events(event_loop, cause),
+        Event::WindowEvent { window_id, event } => app.window_event(event_loop, window_id, event),
+        Event::DeviceEvent { device_id, event } => app.device_event(event_loop, device_id, event),
+        Event::UserWakeUp => app.proxy_wake_up(event_loop),
+        Event::Suspended => app.suspended(event_loop),
+        Event::Resumed => app.resumed(event_loop),
+        Event::CreateSurfaces => app.can_create_surfaces(event_loop),
+        Event::AboutToWait => app.about_to_wait(event_loop),
+        Event::LoopExiting => app.exiting(event_loop),
+        Event::MemoryWarning => app.memory_warning(event_loop),
+    })
 }
 
 #[derive(Debug)]
@@ -77,14 +98,8 @@ pub struct ScaleFactorChanged {
 }
 
 enum UserCallbackTransitionResult<'a> {
-    Success {
-        handler: EventLoopHandler,
-        active_control_flow: ControlFlow,
-        processing_redraws: bool,
-    },
-    ReentrancyPrevented {
-        queued_events: &'a mut Vec<EventWrapper>,
-    },
+    Success { active_control_flow: ControlFlow, processing_redraws: bool },
+    ReentrancyPrevented { queued_events: &'a mut Vec<EventWrapper> },
 }
 
 impl Event {
@@ -97,19 +112,11 @@ impl Event {
 #[derive(Debug)]
 #[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"]
 enum AppStateImpl {
-    NotLaunched {
-        queued_windows: Vec<Retained<WinitUIWindow>>,
+    Initial {
         queued_events: Vec<EventWrapper>,
         queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
     },
-    Launching {
-        queued_windows: Vec<Retained<WinitUIWindow>>,
-        queued_events: Vec<EventWrapper>,
-        queued_handler: EventLoopHandler,
-        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
-    },
     ProcessingEvents {
-        handler: EventLoopHandler,
         queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
         active_control_flow: ControlFlow,
     },
@@ -119,16 +126,12 @@ enum AppStateImpl {
         queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
     },
     ProcessingRedraws {
-        handler: EventLoopHandler,
         active_control_flow: ControlFlow,
     },
     Waiting {
-        waiting_handler: EventLoopHandler,
         start: Instant,
     },
-    PollFinished {
-        waiting_handler: EventLoopHandler,
-    },
+    PollFinished,
     Terminated,
 }
 
@@ -154,8 +157,7 @@ impl AppState {
             fn init_guard(guard: &mut RefMut<'static, Option<AppState>>) {
                 let waker = EventLoopWaker::new(unsafe { CFRunLoopGetMain() });
                 **guard = Some(AppState {
-                    app_state: Some(AppStateImpl::NotLaunched {
-                        queued_windows: Vec::new(),
+                    app_state: Some(AppStateImpl::Initial {
                         queued_events: Vec::new(),
                         queued_gpu_redraws: HashSet::new(),
                     }),
@@ -207,46 +209,25 @@ impl AppState {
     }
 
     fn has_launched(&self) -> bool {
-        !matches!(self.state(), AppStateImpl::NotLaunched { .. } | AppStateImpl::Launching { .. })
+        !matches!(self.state(), AppStateImpl::Initial { .. })
     }
 
     fn has_terminated(&self) -> bool {
         matches!(self.state(), AppStateImpl::Terminated)
     }
 
-    fn will_launch_transition(&mut self, queued_handler: EventLoopHandler) {
-        let (queued_windows, queued_events, queued_gpu_redraws) = match self.take_state() {
-            AppStateImpl::NotLaunched { queued_windows, queued_events, queued_gpu_redraws } => {
-                (queued_windows, queued_events, queued_gpu_redraws)
+    fn did_finish_launching_transition(&mut self) -> Vec<EventWrapper> {
+        let (events, queued_gpu_redraws) = match self.take_state() {
+            AppStateImpl::Initial { queued_events, queued_gpu_redraws } => {
+                (queued_events, queued_gpu_redraws)
             },
             s => bug!("unexpected state {:?}", s),
         };
-        self.set_state(AppStateImpl::Launching {
-            queued_windows,
-            queued_events,
-            queued_handler,
-            queued_gpu_redraws,
-        });
-    }
-
-    fn did_finish_launching_transition(
-        &mut self,
-    ) -> (Vec<Retained<WinitUIWindow>>, Vec<EventWrapper>) {
-        let (windows, events, handler, queued_gpu_redraws) = match self.take_state() {
-            AppStateImpl::Launching {
-                queued_windows,
-                queued_events,
-                queued_handler,
-                queued_gpu_redraws,
-            } => (queued_windows, queued_events, queued_handler, queued_gpu_redraws),
-            s => bug!("unexpected state {:?}", s),
-        };
         self.set_state(AppStateImpl::ProcessingEvents {
-            handler,
             active_control_flow: self.control_flow,
             queued_gpu_redraws,
         });
-        (windows, events)
+        events
     }
 
     fn wakeup_transition(&mut self) -> Option<EventWrapper> {
@@ -256,22 +237,18 @@ impl AppState {
             return None;
         }
 
-        let (handler, event) = match (self.control_flow, self.take_state()) {
-            (ControlFlow::Poll, AppStateImpl::PollFinished { waiting_handler }) => {
-                (waiting_handler, EventWrapper::StaticEvent(Event::NewEvents(StartCause::Poll)))
+        let event = match (self.control_flow, self.take_state()) {
+            (ControlFlow::Poll, AppStateImpl::PollFinished) => {
+                EventWrapper::StaticEvent(Event::NewEvents(StartCause::Poll))
             },
-            (ControlFlow::Wait, AppStateImpl::Waiting { waiting_handler, start }) => (
-                waiting_handler,
+            (ControlFlow::Wait, AppStateImpl::Waiting { start }) => {
                 EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled {
                     start,
                     requested_resume: None,
-                })),
-            ),
-            (
-                ControlFlow::WaitUntil(requested_resume),
-                AppStateImpl::Waiting { waiting_handler, start },
-            ) => {
-                let event = if Instant::now() >= requested_resume {
+                }))
+            },
+            (ControlFlow::WaitUntil(requested_resume), AppStateImpl::Waiting { start }) => {
+                if Instant::now() >= requested_resume {
                     EventWrapper::StaticEvent(Event::NewEvents(StartCause::ResumeTimeReached {
                         start,
                         requested_resume,
@@ -281,14 +258,12 @@ impl AppState {
                         start,
                         requested_resume: Some(requested_resume),
                     }))
-                };
-                (waiting_handler, event)
+                }
             },
             s => bug!("`EventHandler` unexpectedly woke up {:?}", s),
         };
 
         self.set_state(AppStateImpl::ProcessingEvents {
-            handler,
             queued_gpu_redraws: Default::default(),
             active_control_flow: self.control_flow,
         });
@@ -299,8 +274,7 @@ impl AppState {
         // If we're not able to process an event due to recursion or `Init` not having been sent out
         // yet, then queue the events up.
         match self.state_mut() {
-            &mut AppStateImpl::Launching { ref mut queued_events, .. }
-            | &mut AppStateImpl::NotLaunched { ref mut queued_events, .. }
+            &mut AppStateImpl::Initial { ref mut queued_events, .. }
             | &mut AppStateImpl::InUserCallback { ref mut queued_events, .. } => {
                 // A lifetime cast: early returns are not currently handled well with NLL, but
                 // polonius handles them well. This transmute is a safe workaround.
@@ -324,17 +298,14 @@ impl AppState {
             },
         }
 
-        let (handler, queued_gpu_redraws, active_control_flow, processing_redraws) = match self
-            .take_state()
+        let (queued_gpu_redraws, active_control_flow, processing_redraws) = match self.take_state()
         {
-            AppStateImpl::Launching { .. }
-            | AppStateImpl::NotLaunched { .. }
-            | AppStateImpl::InUserCallback { .. } => unreachable!(),
-            AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow } => {
-                (handler, queued_gpu_redraws, active_control_flow, false)
+            AppStateImpl::Initial { .. } | AppStateImpl::InUserCallback { .. } => unreachable!(),
+            AppStateImpl::ProcessingEvents { queued_gpu_redraws, active_control_flow } => {
+                (queued_gpu_redraws, active_control_flow, false)
             },
-            AppStateImpl::ProcessingRedraws { handler, active_control_flow } => {
-                (handler, Default::default(), active_control_flow, true)
+            AppStateImpl::ProcessingRedraws { active_control_flow } => {
+                (Default::default(), active_control_flow, true)
             },
             AppStateImpl::PollFinished { .. }
             | AppStateImpl::Waiting { .. }
@@ -344,17 +315,17 @@ impl AppState {
             queued_events: Vec::new(),
             queued_gpu_redraws,
         });
-        UserCallbackTransitionResult::Success { handler, active_control_flow, processing_redraws }
+        UserCallbackTransitionResult::Success { active_control_flow, processing_redraws }
     }
 
     fn main_events_cleared_transition(&mut self) -> HashSet<Retained<WinitUIWindow>> {
-        let (handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
-            AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow } => {
-                (handler, queued_gpu_redraws, active_control_flow)
+        let (queued_gpu_redraws, active_control_flow) = match self.take_state() {
+            AppStateImpl::ProcessingEvents { queued_gpu_redraws, active_control_flow } => {
+                (queued_gpu_redraws, active_control_flow)
             },
             s => bug!("unexpected state {:?}", s),
         };
-        self.set_state(AppStateImpl::ProcessingRedraws { handler, active_control_flow });
+        self.set_state(AppStateImpl::ProcessingRedraws { active_control_flow });
         queued_gpu_redraws
     }
 
@@ -362,10 +333,8 @@ impl AppState {
         if !self.has_launched() || self.has_terminated() {
             return;
         }
-        let (waiting_handler, old) = match self.take_state() {
-            AppStateImpl::ProcessingRedraws { handler, active_control_flow } => {
-                (handler, active_control_flow)
-            },
+        let old = match self.take_state() {
+            AppStateImpl::ProcessingRedraws { active_control_flow } => active_control_flow,
             s => bug!("unexpected state {:?}", s),
         };
 
@@ -373,35 +342,35 @@ impl AppState {
         match (old, new) {
             (ControlFlow::Wait, ControlFlow::Wait) => {
                 let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+                self.set_state(AppStateImpl::Waiting { start });
             },
             (ControlFlow::WaitUntil(old_instant), ControlFlow::WaitUntil(new_instant))
                 if old_instant == new_instant =>
             {
                 let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+                self.set_state(AppStateImpl::Waiting { start });
             },
             (_, ControlFlow::Wait) => {
                 let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+                self.set_state(AppStateImpl::Waiting { start });
                 self.waker.stop()
             },
             (_, ControlFlow::WaitUntil(new_instant)) => {
                 let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+                self.set_state(AppStateImpl::Waiting { start });
                 self.waker.start_at(new_instant)
             },
             // Unlike on macOS, handle Poll to Poll transition here to call the waker
             (_, ControlFlow::Poll) => {
-                self.set_state(AppStateImpl::PollFinished { waiting_handler });
+                self.set_state(AppStateImpl::PollFinished);
                 self.waker.start()
             },
         }
     }
 
-    fn terminated_transition(&mut self) -> EventLoopHandler {
+    fn terminated_transition(&mut self) {
         match self.replace_state(AppStateImpl::Terminated) {
-            AppStateImpl::ProcessingEvents { handler, .. } => handler,
+            AppStateImpl::ProcessingEvents { .. } => {},
             s => bug!("`LoopExiting` happened while not processing events {:?}", s),
         }
     }
@@ -419,31 +388,10 @@ impl AppState {
     }
 }
 
-pub(crate) fn set_key_window(mtm: MainThreadMarker, window: &Retained<WinitUIWindow>) {
-    let mut this = AppState::get_mut(mtm);
-    match this.state_mut() {
-        &mut AppStateImpl::NotLaunched { ref mut queued_windows, .. } => {
-            return queued_windows.push(window.clone())
-        },
-        &mut AppStateImpl::ProcessingEvents { .. }
-        | &mut AppStateImpl::InUserCallback { .. }
-        | &mut AppStateImpl::ProcessingRedraws { .. } => {},
-        s @ &mut AppStateImpl::Launching { .. }
-        | s @ &mut AppStateImpl::Waiting { .. }
-        | s @ &mut AppStateImpl::PollFinished { .. } => bug!("unexpected state {:?}", s),
-        &mut AppStateImpl::Terminated => {
-            panic!("Attempt to create a `Window` after the app has terminated")
-        },
-    }
-    drop(this);
-    window.makeKeyAndVisible();
-}
-
 pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Retained<WinitUIWindow>) {
     let mut this = AppState::get_mut(mtm);
     match this.state_mut() {
-        &mut AppStateImpl::NotLaunched { ref mut queued_gpu_redraws, .. }
-        | &mut AppStateImpl::Launching { ref mut queued_gpu_redraws, .. }
+        &mut AppStateImpl::Initial { ref mut queued_gpu_redraws, .. }
         | &mut AppStateImpl::ProcessingEvents { ref mut queued_gpu_redraws, .. }
         | &mut AppStateImpl::InUserCallback { ref mut queued_gpu_redraws, .. } => {
             let _ = queued_gpu_redraws.insert(window);
@@ -457,45 +405,19 @@ pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Retained<W
     }
 }
 
-pub(crate) fn will_launch(mtm: MainThreadMarker, queued_handler: EventLoopHandler) {
-    AppState::get_mut(mtm).will_launch_transition(queued_handler)
+pub(crate) fn launch(mtm: MainThreadMarker, app: &mut dyn ApplicationHandler, run: impl FnOnce()) {
+    get_handler(mtm).set(app, run)
 }
 
 pub fn did_finish_launching(mtm: MainThreadMarker) {
     let mut this = AppState::get_mut(mtm);
-    let windows = match this.state_mut() {
-        AppStateImpl::Launching { queued_windows, .. } => mem::take(queued_windows),
-        s => bug!("unexpected state {:?}", s),
-    };
 
     this.waker.start();
 
     // have to drop RefMut because the window setup code below can trigger new events
     drop(this);
 
-    for window in windows {
-        // Do a little screen dance here to account for windows being created before
-        // `UIApplicationMain` is called. This fixes visual issues such as being
-        // offcenter and sized incorrectly. Additionally, to fix orientation issues, we
-        // gotta reset the `rootViewController`.
-        //
-        // relevant iOS log:
-        // ```
-        // [ApplicationLifecycle] Windows were created before application initialization
-        // completed. This may result in incorrect visual appearance.
-        // ```
-        let screen = window.screen();
-        let _: () = unsafe { msg_send![&window, setScreen: ptr::null::<AnyObject>()] };
-        window.setScreen(&screen);
-
-        let controller = window.rootViewController();
-        window.setRootViewController(None);
-        window.setRootViewController(controller.as_deref());
-
-        window.makeKeyAndVisible();
-    }
-
-    let (windows, events) = AppState::get_mut(mtm).did_finish_launching_transition();
+    let events = AppState::get_mut(mtm).did_finish_launching_transition();
 
     let events = [
         EventWrapper::StaticEvent(Event::NewEvents(StartCause::Init)),
@@ -504,12 +426,6 @@ pub fn did_finish_launching(mtm: MainThreadMarker) {
     .into_iter()
     .chain(events);
     handle_nonuser_events(mtm, events);
-
-    // the above window dance hack, could possibly trigger new windows to be created.
-    // we can just set those windows up normally, as they were created after didFinishLaunching
-    for window in windows {
-        window.makeKeyAndVisible();
-    }
 }
 
 // AppState::did_finish_launching handles the special transition `Init`
@@ -537,18 +453,15 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
         return;
     }
 
-    let (mut handler, active_control_flow, processing_redraws) =
-        match this.try_user_callback_transition() {
-            UserCallbackTransitionResult::ReentrancyPrevented { queued_events } => {
-                queued_events.extend(events);
-                return;
-            },
-            UserCallbackTransitionResult::Success {
-                handler,
-                active_control_flow,
-                processing_redraws,
-            } => (handler, active_control_flow, processing_redraws),
-        };
+    let (active_control_flow, processing_redraws) = match this.try_user_callback_transition() {
+        UserCallbackTransitionResult::ReentrancyPrevented { queued_events } => {
+            queued_events.extend(events);
+            return;
+        },
+        UserCallbackTransitionResult::Success { active_control_flow, processing_redraws } => {
+            (active_control_flow, processing_redraws)
+        },
+    };
     drop(this);
 
     for wrapper in events {
@@ -562,9 +475,9 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
                         event
                     );
                 }
-                handler.handle_event(event)
+                handle_event(mtm, event)
             },
-            EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
+            EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(mtm, event),
         }
     }
 
@@ -588,9 +501,9 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
                     queued_gpu_redraws.is_empty(),
                     "redraw queued while processing redraws"
                 );
-                AppStateImpl::ProcessingRedraws { handler, active_control_flow }
+                AppStateImpl::ProcessingRedraws { active_control_flow }
             } else {
-                AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow }
+                AppStateImpl::ProcessingEvents { queued_gpu_redraws, active_control_flow }
             });
             break;
         }
@@ -608,9 +521,9 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
                             event
                         );
                     }
-                    handler.handle_event(event)
+                    handle_event(mtm, event)
                 },
-                EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
+                EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(mtm, event),
             }
         }
     }
@@ -618,23 +531,23 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
 
 fn handle_user_events(mtm: MainThreadMarker) {
     let mut this = AppState::get_mut(mtm);
-    let (mut handler, active_control_flow, processing_redraws) =
-        match this.try_user_callback_transition() {
-            UserCallbackTransitionResult::ReentrancyPrevented { .. } => {
-                bug!("unexpected attempted to process an event")
-            },
-            UserCallbackTransitionResult::Success {
-                handler,
-                active_control_flow,
-                processing_redraws,
-            } => (handler, active_control_flow, processing_redraws),
-        };
+    let (active_control_flow, processing_redraws) = match this.try_user_callback_transition() {
+        UserCallbackTransitionResult::ReentrancyPrevented { .. } => {
+            bug!("unexpected attempted to process an event")
+        },
+        UserCallbackTransitionResult::Success { active_control_flow, processing_redraws } => {
+            (active_control_flow, processing_redraws)
+        },
+    };
     if processing_redraws {
         bug!("user events attempted to be sent out while `ProcessingRedraws`");
     }
+    let proxy_wake_up = this.proxy_wake_up.clone();
     drop(this);
 
-    handler.handle_event(Event::UserWakeUp);
+    if proxy_wake_up.swap(false, Ordering::Relaxed) {
+        handle_event(mtm, Event::UserWakeUp);
+    }
 
     loop {
         let mut this = AppState::get_mut(mtm);
@@ -651,23 +564,22 @@ fn handle_user_events(mtm: MainThreadMarker) {
                 },
                 _ => unreachable!(),
             };
-            this.app_state = Some(AppStateImpl::ProcessingEvents {
-                handler,
-                queued_gpu_redraws,
-                active_control_flow,
-            });
+            this.app_state =
+                Some(AppStateImpl::ProcessingEvents { queued_gpu_redraws, active_control_flow });
             break;
         }
         drop(this);
 
         for wrapper in queued_events {
             match wrapper {
-                EventWrapper::StaticEvent(event) => handler.handle_event(event),
-                EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
+                EventWrapper::StaticEvent(event) => handle_event(mtm, event),
+                EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(mtm, event),
             }
         }
 
-        handler.handle_event(Event::UserWakeUp);
+        if proxy_wake_up.swap(false, Ordering::Relaxed) {
+            handle_event(mtm, Event::UserWakeUp);
+        }
     }
 }
 
@@ -749,26 +661,26 @@ pub(crate) fn terminated(application: &UIApplication) {
     handle_nonuser_events(mtm, events);
 
     let mut this = AppState::get_mut(mtm);
-    let mut handler = this.terminated_transition();
+    this.terminated_transition();
     drop(this);
 
-    handler.handle_event(Event::LoopExiting)
+    handle_event(mtm, Event::LoopExiting)
 }
 
-fn handle_hidpi_proxy(handler: &mut EventLoopHandler, event: ScaleFactorChanged) {
+fn handle_hidpi_proxy(mtm: MainThreadMarker, event: ScaleFactorChanged) {
     let ScaleFactorChanged { suggested_size, scale_factor, window } = event;
-    let new_inner_size = Arc::new(Mutex::new(suggested_size));
+    let new_surface_size = Arc::new(Mutex::new(suggested_size));
     let event = Event::WindowEvent {
         window_id: RootWindowId(window.id()),
         event: WindowEvent::ScaleFactorChanged {
             scale_factor,
-            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
+            surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_surface_size)),
         },
     };
-    handler.handle_event(event);
+    handle_event(mtm, event);
     let (view, screen_frame) = get_view_and_screen_frame(&window);
-    let physical_size = *new_inner_size.lock().unwrap();
-    drop(new_inner_size);
+    let physical_size = *new_surface_size.lock().unwrap();
+    drop(new_surface_size);
     let logical_size = physical_size.to_logical(scale_factor);
     let size = CGSize::new(logical_size.width, logical_size.height);
     let new_frame: CGRect = CGRect::new(screen_frame.origin, size);

src/platform_impl/apple/uikit/event_loop.rs

@@ -1,4 +1,3 @@
-use std::any::Any;
 use std::ffi::{c_char, c_int, c_void};
 use std::ptr::{self, NonNull};
 use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
@@ -13,14 +12,20 @@ use core_foundation::runloop::{
 };
 use objc2::rc::Retained;
 use objc2::{msg_send_id, ClassType};
-use objc2_foundation::{MainThreadMarker, NSString};
-use objc2_ui_kit::{UIApplication, UIApplicationMain, UIScreen};
+use objc2_foundation::{MainThreadMarker, NSNotificationCenter, NSObject};
+use objc2_ui_kit::{
+    UIApplication, UIApplicationDidBecomeActiveNotification,
+    UIApplicationDidEnterBackgroundNotification, UIApplicationDidFinishLaunchingNotification,
+    UIApplicationDidReceiveMemoryWarningNotification, UIApplicationMain,
+    UIApplicationWillEnterForegroundNotification, UIApplicationWillResignActiveNotification,
+    UIApplicationWillTerminateNotification, UIScreen,
+};
 
-use super::app_delegate::AppDelegate;
-use super::app_state::{AppState, EventLoopHandler};
+use super::super::notification_center::create_observer;
+use super::app_state::{send_occluded_event_for_all_windows, AppState, EventWrapper};
 use super::{app_state, monitor, MonitorHandle};
 use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, ExternalError, NotSupportedError, OsError};
+use crate::error::{EventLoopError, NotSupportedError, RequestError};
 use crate::event::Event;
 use crate::event_loop::{
     ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
@@ -28,7 +33,7 @@ use crate::event_loop::{
 };
 use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::platform_impl::Window;
-use crate::window::{CustomCursor, CustomCursorSource, Theme, Window as RootWindow};
+use crate::window::{CustomCursor, CustomCursorSource, Theme, Window as CoreWindow};
 
 #[derive(Debug)]
 pub(crate) struct ActiveEventLoop {
@@ -44,16 +49,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_window(
         &self,
         window_attributes: crate::window::WindowAttributes,
-    ) -> Result<RootWindow, OsError> {
-        let window = Window::new(self, window_attributes)?;
-        Ok(RootWindow { window })
+    ) -> Result<Box<dyn CoreWindow>, RequestError> {
+        Ok(Box::new(Window::new(self, window_attributes)?))
     }
 
     fn create_custom_cursor(
         &self,
         _source: CustomCursorSource,
-    ) -> Result<CustomCursor, ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    ) -> Result<CustomCursor, RequestError> {
+        Err(NotSupportedError::new("create_custom_cursor is not supported").into())
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
@@ -94,10 +98,6 @@ impl RootActiveEventLoop for ActiveEventLoop {
         RootOwnedDisplayHandle { platform: OwnedDisplayHandle }
     }
 
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     #[cfg(feature = "rwh_06")]
     fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
         self
@@ -125,35 +125,21 @@ impl OwnedDisplayHandle {
     }
 }
 
-fn map_user_event<'a, A: ApplicationHandler + 'a>(
-    mut app: A,
-    proxy_wake_up: Arc<AtomicBool>,
-) -> impl FnMut(Event, &dyn RootActiveEventLoop) + 'a {
-    move |event, window_target| match event {
-        Event::NewEvents(cause) => app.new_events(window_target, cause),
-        Event::WindowEvent { window_id, event } => {
-            app.window_event(window_target, window_id, event)
-        },
-        Event::DeviceEvent { device_id, event } => {
-            app.device_event(window_target, device_id, event)
-        },
-        Event::UserWakeUp => {
-            if proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
-                app.proxy_wake_up(window_target);
-            }
-        },
-        Event::Suspended => app.suspended(window_target),
-        Event::Resumed => app.resumed(window_target),
-        Event::CreateSurfaces => app.can_create_surfaces(window_target),
-        Event::AboutToWait => app.about_to_wait(window_target),
-        Event::LoopExiting => app.exiting(window_target),
-        Event::MemoryWarning => app.memory_warning(window_target),
-    }
-}
-
 pub struct EventLoop {
     mtm: MainThreadMarker,
     window_target: ActiveEventLoop,
+
+    // Since iOS 9.0, we no longer need to remove the observers before they are deallocated; the
+    // system instead cleans it up next time it would have posted a notification to it.
+    //
+    // Though we do still need to keep the observers around to prevent them from being deallocated.
+    _did_finish_launching_observer: Retained<NSObject>,
+    _did_become_active_observer: Retained<NSObject>,
+    _will_resign_active_observer: Retained<NSObject>,
+    _will_enter_foreground_observer: Retained<NSObject>,
+    _did_enter_background_observer: Retained<NSObject>,
+    _will_terminate_observer: Retained<NSObject>,
+    _did_receive_memory_warning_observer: Retained<NSObject>,
 }
 
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -178,10 +164,99 @@ impl EventLoop {
         // this line sets up the main run loop before `UIApplicationMain`
         setup_control_flow_observers();
 
-        Ok(EventLoop { mtm, window_target: ActiveEventLoop { mtm } })
+        let center = unsafe { NSNotificationCenter::defaultCenter() };
+
+        let _did_finish_launching_observer = create_observer(
+            &center,
+            // `application:didFinishLaunchingWithOptions:`
+            unsafe { UIApplicationDidFinishLaunchingNotification },
+            move |_| {
+                app_state::did_finish_launching(mtm);
+            },
+        );
+        let _did_become_active_observer = create_observer(
+            &center,
+            // `applicationDidBecomeActive:`
+            unsafe { UIApplicationDidBecomeActiveNotification },
+            move |_| {
+                app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Resumed));
+            },
+        );
+        let _will_resign_active_observer = create_observer(
+            &center,
+            // `applicationWillResignActive:`
+            unsafe { UIApplicationWillResignActiveNotification },
+            move |_| {
+                app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Suspended));
+            },
+        );
+        let _will_enter_foreground_observer = create_observer(
+            &center,
+            // `applicationWillEnterForeground:`
+            unsafe { UIApplicationWillEnterForegroundNotification },
+            move |notification| {
+                let app = unsafe { notification.object() }.expect(
+                    "UIApplicationWillEnterForegroundNotification to have application object",
+                );
+                // SAFETY: The `object` in `UIApplicationWillEnterForegroundNotification` is
+                // documented to be `UIApplication`.
+                let app: Retained<UIApplication> = unsafe { Retained::cast(app) };
+                send_occluded_event_for_all_windows(&app, false);
+            },
+        );
+        let _did_enter_background_observer = create_observer(
+            &center,
+            // `applicationDidEnterBackground:`
+            unsafe { UIApplicationDidEnterBackgroundNotification },
+            move |notification| {
+                let app = unsafe { notification.object() }.expect(
+                    "UIApplicationDidEnterBackgroundNotification to have application object",
+                );
+                // SAFETY: The `object` in `UIApplicationDidEnterBackgroundNotification` is
+                // documented to be `UIApplication`.
+                let app: Retained<UIApplication> = unsafe { Retained::cast(app) };
+                send_occluded_event_for_all_windows(&app, true);
+            },
+        );
+        let _will_terminate_observer = create_observer(
+            &center,
+            // `applicationWillTerminate:`
+            unsafe { UIApplicationWillTerminateNotification },
+            move |notification| {
+                let app = unsafe { notification.object() }
+                    .expect("UIApplicationWillTerminateNotification to have application object");
+                // SAFETY: The `object` in `UIApplicationWillTerminateNotification` is
+                // (somewhat) documented to be `UIApplication`.
+                let app: Retained<UIApplication> = unsafe { Retained::cast(app) };
+                app_state::terminated(&app);
+            },
+        );
+        let _did_receive_memory_warning_observer = create_observer(
+            &center,
+            // `applicationDidReceiveMemoryWarning:`
+            unsafe { UIApplicationDidReceiveMemoryWarningNotification },
+            move |_| {
+                app_state::handle_nonuser_event(
+                    mtm,
+                    EventWrapper::StaticEvent(Event::MemoryWarning),
+                );
+            },
+        );
+
+        Ok(EventLoop {
+            mtm,
+            window_target: ActiveEventLoop { mtm },
+            _did_finish_launching_observer,
+            _did_become_active_observer,
+            _will_resign_active_observer,
+            _will_enter_foreground_observer,
+            _did_enter_background_observer,
+            _will_terminate_observer,
+            _did_receive_memory_warning_observer,
+        })
     }
 
-    pub fn run_app<A: ApplicationHandler>(self, app: A) -> ! {
+    pub fn run_app<A: ApplicationHandler>(self, mut app: A) -> ! {
         let application: Option<Retained<UIApplication>> =
             unsafe { msg_send_id![UIApplication::class(), sharedApplication] };
         assert!(
@@ -191,36 +266,23 @@ impl EventLoop {
              `EventLoop::run_app` calls `UIApplicationMain` on iOS",
         );
 
-        let handler = map_user_event(app, AppState::get_mut(self.mtm).proxy_wake_up());
-
-        let handler = unsafe {
-            std::mem::transmute::<
-                Box<dyn FnMut(Event, &dyn RootActiveEventLoop)>,
-                Box<dyn FnMut(Event, &dyn RootActiveEventLoop)>,
-            >(Box::new(handler))
-        };
-
-        let handler = EventLoopHandler { handler, event_loop: self.window_target };
-
-        app_state::will_launch(self.mtm, handler);
-
-        // Ensure application delegate is initialized
-        let _ = AppDelegate::class();
-
         extern "C" {
             // These functions are in crt_externs.h.
             fn _NSGetArgc() -> *mut c_int;
             fn _NSGetArgv() -> *mut *mut *mut c_char;
         }
 
-        unsafe {
+        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,
-                Some(&NSString::from_str(AppDelegate::NAME)),
-            )
-        };
+                None,
+            );
+        });
+
         unreachable!()
     }
 

src/platform_impl/apple/uikit/mod.rs

@@ -1,6 +1,5 @@
 #![allow(clippy::let_unit_value)]
 
-mod app_delegate;
 mod app_state;
 mod event_loop;
 mod monitor;

src/platform_impl/apple/uikit/view.rs

@@ -4,19 +4,23 @@ use std::cell::{Cell, RefCell};
 use objc2::rc::Retained;
 use objc2::runtime::{NSObjectProtocol, ProtocolObject};
 use objc2::{declare_class, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass};
-use objc2_foundation::{CGFloat, CGPoint, CGRect, MainThreadMarker, NSObject, NSSet};
+use objc2_foundation::{CGFloat, CGPoint, CGRect, MainThreadMarker, NSObject, NSSet, NSString};
 use objc2_ui_kit::{
     UICoordinateSpace, UIEvent, UIForceTouchCapability, UIGestureRecognizer,
-    UIGestureRecognizerDelegate, UIGestureRecognizerState, UIPanGestureRecognizer,
+    UIGestureRecognizerDelegate, UIGestureRecognizerState, UIKeyInput, UIPanGestureRecognizer,
     UIPinchGestureRecognizer, UIResponder, UIRotationGestureRecognizer, UITapGestureRecognizer,
-    UITouch, UITouchPhase, UITouchType, UITraitEnvironment, UIView,
+    UITextInputTraits, UITouch, UITouchPhase, UITouchType, UITraitEnvironment, UIView,
 };
 
 use super::app_state::{self, EventWrapper};
 use super::window::WinitUIWindow;
 use super::{FingerId, DEVICE_ID};
 use crate::dpi::PhysicalPosition;
-use crate::event::{Event, FingerId as RootFingerId, Force, Touch, TouchPhase, WindowEvent};
+use crate::event::{
+    ElementState, Event, FingerId as RootFingerId, Force, KeyEvent, Touch, TouchPhase, WindowEvent,
+};
+use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKeyCode, PhysicalKey};
+use crate::platform_impl::KeyEventExtra;
 use crate::window::{WindowAttributes, WindowId as RootWindowId};
 
 pub struct WinitViewState {
@@ -89,7 +93,7 @@ declare_class!(
                 mtm,
                 EventWrapper::StaticEvent(Event::WindowEvent {
                     window_id: RootWindowId(window.id()),
-                    event: WindowEvent::Resized(size),
+                    event: WindowEvent::SurfaceResized(size),
                 }),
             );
         }
@@ -140,7 +144,7 @@ declare_class!(
                 .chain(std::iter::once(EventWrapper::StaticEvent(
                     Event::WindowEvent {
                         window_id,
-                        event: WindowEvent::Resized(size.to_physical(scale_factor)),
+                        event: WindowEvent::SurfaceResized(size.to_physical(scale_factor)),
                     },
                 ))),
             );
@@ -314,6 +318,11 @@ declare_class!(
             let mtm = MainThreadMarker::new().unwrap();
             app_state::handle_nonuser_event(mtm, gesture_event);
         }
+
+        #[method(canBecomeFirstResponder)]
+        fn can_become_first_responder(&self) -> bool {
+            true
+        }
     }
 
     unsafe impl NSObjectProtocol for WinitView {}
@@ -324,6 +333,26 @@ declare_class!(
             true
         }
     }
+
+    unsafe impl UITextInputTraits for WinitView {
+    }
+
+    unsafe impl UIKeyInput for WinitView {
+        #[method(hasText)]
+        fn has_text(&self) -> bool {
+            true
+        }
+
+        #[method(insertText:)]
+        fn insert_text(&self, text: &NSString) {
+            self.handle_insert_text(text)
+        }
+
+        #[method(deleteBackward)]
+        fn delete_backward(&self) {
+            self.handle_delete_backward()
+        }
+    }
 );
 
 impl WinitView {
@@ -512,4 +541,69 @@ impl WinitView {
         let mtm = MainThreadMarker::new().unwrap();
         app_state::handle_nonuser_events(mtm, touch_events);
     }
+
+    fn handle_insert_text(&self, text: &NSString) {
+        let window = self.window().unwrap();
+        let window_id = RootWindowId(window.id());
+        let mtm = MainThreadMarker::new().unwrap();
+        // send individual events for each character
+        app_state::handle_nonuser_events(
+            mtm,
+            text.to_string().chars().flat_map(|c| {
+                let text = smol_str::SmolStr::from_iter([c]);
+                // Emit both press and release events
+                [ElementState::Pressed, ElementState::Released].map(|state| {
+                    EventWrapper::StaticEvent(Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::KeyboardInput {
+                            event: KeyEvent {
+                                text: if state == ElementState::Pressed {
+                                    Some(text.clone())
+                                } else {
+                                    None
+                                },
+                                state,
+                                location: KeyLocation::Standard,
+                                repeat: false,
+                                logical_key: Key::Character(text.clone()),
+                                physical_key: PhysicalKey::Unidentified(
+                                    NativeKeyCode::Unidentified,
+                                ),
+                                platform_specific: KeyEventExtra {},
+                            },
+                            is_synthetic: false,
+                            device_id: DEVICE_ID,
+                        },
+                    })
+                })
+            }),
+        );
+    }
+
+    fn handle_delete_backward(&self) {
+        let window = self.window().unwrap();
+        let window_id = RootWindowId(window.id());
+        let mtm = MainThreadMarker::new().unwrap();
+        app_state::handle_nonuser_events(
+            mtm,
+            [ElementState::Pressed, ElementState::Released].map(|state| {
+                EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id,
+                    event: WindowEvent::KeyboardInput {
+                        device_id: DEVICE_ID,
+                        event: KeyEvent {
+                            state,
+                            logical_key: Key::Named(NamedKey::Backspace),
+                            physical_key: PhysicalKey::Code(KeyCode::Backspace),
+                            platform_specific: KeyEventExtra {},
+                            repeat: false,
+                            location: KeyLocation::Standard,
+                            text: None,
+                        },
+                        is_synthetic: false,
+                    },
+                })
+            }),
+        );
+    }
 }

src/platform_impl/apple/uikit/window.rs

@@ -20,13 +20,14 @@ use super::view_controller::WinitViewController;
 use super::{app_state, monitor, ActiveEventLoop, Fullscreen, MonitorHandle};
 use crate::cursor::Cursor;
 use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
+use crate::error::{NotSupportedError, RequestError};
 use crate::event::{Event, WindowEvent};
 use crate::icon::Icon;
+use crate::monitor::MonitorHandle as CoreMonitorHandle;
 use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
 use crate::window::{
-    CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, WindowAttributes,
-    WindowButtons, WindowId as RootWindowId, WindowLevel,
+    CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, Window as CoreWindow,
+    WindowAttributes, WindowButtons, WindowId as CoreWindowId, WindowLevel,
 };
 
 declare_class!(
@@ -49,7 +50,7 @@ declare_class!(
             app_state::handle_nonuser_event(
                 mtm,
                 EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: RootWindowId(self.id()),
+                    window_id: CoreWindowId(self.id()),
                     event: WindowEvent::Focused(true),
                 }),
             );
@@ -62,7 +63,7 @@ declare_class!(
             app_state::handle_nonuser_event(
                 mtm,
                 EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: RootWindowId(self.id()),
+                    window_id: CoreWindowId(self.id()),
                     event: WindowEvent::Focused(false),
                 }),
             );
@@ -78,6 +79,11 @@ impl WinitUIWindow {
         frame: CGRect,
         view_controller: &UIViewController,
     ) -> Retained<Self> {
+        // NOTE: This should only be created after the application has started launching,
+        // (`application:willFinishLaunchingWithOptions:` at the earliest), otherwise you'll run
+        // into very confusing issues with the window not being properly activated.
+        //
+        // Winit ensures this by not allowing access to `ActiveEventLoop` before handling events.
         let this: Retained<Self> = unsafe { msg_send_id![mtm.alloc(), initWithFrame: frame] };
 
         this.setRootViewController(Some(view_controller));
@@ -153,20 +159,20 @@ impl Inner {
 
     pub fn pre_present_notify(&self) {}
 
-    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+    pub fn inner_position(&self) -> PhysicalPosition<i32> {
         let safe_area = self.safe_area_screen_space();
         let position =
             LogicalPosition { x: safe_area.origin.x as f64, y: safe_area.origin.y as f64 };
         let scale_factor = self.scale_factor();
-        Ok(position.to_physical(scale_factor))
+        position.to_physical(scale_factor)
     }
 
-    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+    pub fn outer_position(&self) -> PhysicalPosition<i32> {
         let screen_frame = self.screen_frame();
         let position =
             LogicalPosition { x: screen_frame.origin.x as f64, y: screen_frame.origin.y as f64 };
         let scale_factor = self.scale_factor();
-        Ok(position.to_physical(scale_factor))
+        position.to_physical(scale_factor)
     }
 
     pub fn set_outer_position(&self, physical_position: Position) {
@@ -181,7 +187,7 @@ impl Inner {
         self.window.setBounds(bounds);
     }
 
-    pub fn inner_size(&self) -> PhysicalSize<u32> {
+    pub fn surface_size(&self) -> PhysicalSize<u32> {
         let scale_factor = self.scale_factor();
         let safe_area = self.safe_area_screen_space();
         let size = LogicalSize {
@@ -201,25 +207,25 @@ impl Inner {
         size.to_physical(scale_factor)
     }
 
-    pub fn request_inner_size(&self, _size: Size) -> Option<PhysicalSize<u32>> {
-        Some(self.inner_size())
+    pub fn request_surface_size(&self, _size: Size) -> Option<PhysicalSize<u32>> {
+        Some(self.surface_size())
     }
 
-    pub fn set_min_inner_size(&self, _dimensions: Option<Size>) {
-        warn!("`Window::set_min_inner_size` is ignored on iOS")
+    pub fn set_min_surface_size(&self, _dimensions: Option<Size>) {
+        warn!("`Window::set_min_surface_size` is ignored on iOS")
     }
 
-    pub fn set_max_inner_size(&self, _dimensions: Option<Size>) {
-        warn!("`Window::set_max_inner_size` is ignored on iOS")
+    pub fn set_max_surface_size(&self, _dimensions: Option<Size>) {
+        warn!("`Window::set_max_surface_size` is ignored on iOS")
     }
 
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
+    pub fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
         None
     }
 
     #[inline]
-    pub fn set_resize_increments(&self, _increments: Option<Size>) {
-        warn!("`Window::set_resize_increments` is ignored on iOS")
+    pub fn set_surface_resize_increments(&self, _increments: Option<Size>) {
+        warn!("`Window::set_surface_resize_increments` is ignored on iOS")
     }
 
     pub fn set_resizable(&self, _resizable: bool) {
@@ -250,31 +256,31 @@ impl Inner {
         debug!("`Window::set_cursor` ignored on iOS")
     }
 
-    pub fn set_cursor_position(&self, _position: Position) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    pub fn set_cursor_position(&self, _position: Position) -> Result<(), NotSupportedError> {
+        Err(NotSupportedError::new("set_cursor_position is not supported"))
     }
 
-    pub fn set_cursor_grab(&self, _: CursorGrabMode) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    pub fn set_cursor_grab(&self, _: CursorGrabMode) -> Result<(), NotSupportedError> {
+        Err(NotSupportedError::new("set_cursor_grab is not supported"))
     }
 
     pub fn set_cursor_visible(&self, _visible: bool) {
         debug!("`Window::set_cursor_visible` is ignored on iOS")
     }
 
-    pub fn drag_window(&self) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    pub fn drag_window(&self) -> Result<(), NotSupportedError> {
+        Err(NotSupportedError::new("drag_window is not supported"))
     }
 
-    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), NotSupportedError> {
+        Err(NotSupportedError::new("drag_resize_window is not supported"))
     }
 
     #[inline]
     pub fn show_window_menu(&self, _position: Position) {}
 
-    pub fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    pub fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), NotSupportedError> {
+        Err(NotSupportedError::new("set_cursor_hittest is not supported"))
     }
 
     pub fn set_minimized(&self, _minimized: bool) {
@@ -365,12 +371,24 @@ impl Inner {
         warn!("`Window::set_ime_cursor_area` is ignored on iOS")
     }
 
-    pub fn set_ime_allowed(&self, _allowed: bool) {
-        warn!("`Window::set_ime_allowed` is ignored on iOS")
+    /// Show / hide the keyboard. To show the keyboard, we call `becomeFirstResponder`,
+    /// requesting focus for the [WinitView]. Since [WinitView] implements
+    /// [objc2_ui_kit::UIKeyInput], the keyboard will be shown.
+    /// <https://developer.apple.com/documentation/uikit/uiresponder/1621113-becomefirstresponder>
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        if allowed {
+            unsafe {
+                self.view.becomeFirstResponder();
+            }
+        } else {
+            unsafe {
+                self.view.resignFirstResponder();
+            }
+        }
     }
 
     pub fn set_ime_purpose(&self, _purpose: ImePurpose) {
-        warn!("`Window::set_ime_allowed` is ignored on iOS")
+        warn!("`Window::set_ime_purpose` is ignored on iOS")
     }
 
     pub fn focus_window(&self) {
@@ -448,14 +466,14 @@ impl Window {
     pub(crate) fn new(
         event_loop: &ActiveEventLoop,
         window_attributes: WindowAttributes,
-    ) -> Result<Window, RootOsError> {
+    ) -> Result<Window, RequestError> {
         let mtm = event_loop.mtm;
 
-        if window_attributes.min_inner_size.is_some() {
-            warn!("`WindowAttributes::min_inner_size` is ignored on iOS");
+        if window_attributes.min_surface_size.is_some() {
+            warn!("`WindowAttributes::min_surface_size` is ignored on iOS");
         }
-        if window_attributes.max_inner_size.is_some() {
-            warn!("`WindowAttributes::max_inner_size` is ignored on iOS");
+        if window_attributes.max_surface_size.is_some() {
+            warn!("`WindowAttributes::max_surface_size` is ignored on iOS");
         }
 
         // TODO: transparency, visible
@@ -471,7 +489,7 @@ impl Window {
 
         let screen_bounds = screen.bounds();
 
-        let frame = match window_attributes.inner_size {
+        let frame = match window_attributes.surface_size {
             Some(dim) => {
                 let scale_factor = screen.scale();
                 let size = dim.to_logical::<f64>(scale_factor as f64);
@@ -490,10 +508,9 @@ impl Window {
 
         let view_controller = WinitViewController::new(mtm, &window_attributes, &view);
         let window = WinitUIWindow::new(mtm, &window_attributes, frame, &view_controller);
+        window.makeKeyAndVisible();
 
-        app_state::set_key_window(mtm, &window);
-
-        // Like the Windows and macOS backends, we send a `ScaleFactorChanged` and `Resized`
+        // Like the Windows and macOS backends, we send a `ScaleFactorChanged` and `SurfaceResized`
         // event on window creation if the DPI factor != 1.0
         let scale_factor = view.contentScaleFactor();
         let scale_factor = scale_factor as f64;
@@ -506,7 +523,7 @@ impl Window {
                 width: screen_frame.size.width as f64,
                 height: screen_frame.size.height as f64,
             };
-            let window_id = RootWindowId(window.id());
+            let window_id = CoreWindowId(window.id());
             app_state::handle_nonuser_events(
                 mtm,
                 std::iter::once(EventWrapper::ScaleFactorChanged(app_state::ScaleFactorChanged {
@@ -517,7 +534,7 @@ impl Window {
                 .chain(std::iter::once(EventWrapper::StaticEvent(
                     Event::WindowEvent {
                         window_id,
-                        event: WindowEvent::Resized(size.to_physical(scale_factor)),
+                        event: WindowEvent::SurfaceResized(size.to_physical(scale_factor)),
                     },
                 ))),
             );
@@ -527,11 +544,6 @@ impl Window {
         Ok(Window { inner: MainThreadBound::new(inner, mtm) })
     }
 
-    pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Inner) + Send + 'static) {
-        // For now, don't actually do queuing, since it may be less predictable
-        self.maybe_wait_on_main(f)
-    }
-
     pub(crate) fn maybe_wait_on_main<R: Send>(&self, f: impl FnOnce(&Inner) -> R + Send) -> R {
         self.inner.get_on_main(|inner| f(inner))
     }
@@ -557,6 +569,265 @@ impl Window {
     }
 }
 
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for Window {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = self.raw_display_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasWindowHandle for Window {
+    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        let raw = self.raw_window_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::WindowHandle::borrow_raw(raw)) }
+    }
+}
+
+impl CoreWindow for Window {
+    fn id(&self) -> crate::window::WindowId {
+        self.maybe_wait_on_main(|delegate| crate::window::WindowId(delegate.id()))
+    }
+
+    fn scale_factor(&self) -> f64 {
+        self.maybe_wait_on_main(|delegate| delegate.scale_factor())
+    }
+
+    fn request_redraw(&self) {
+        self.maybe_wait_on_main(|delegate| delegate.request_redraw());
+    }
+
+    fn pre_present_notify(&self) {
+        self.maybe_wait_on_main(|delegate| delegate.pre_present_notify());
+    }
+
+    fn reset_dead_keys(&self) {
+        self.maybe_wait_on_main(|delegate| delegate.reset_dead_keys());
+    }
+
+    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.inner_position()))
+    }
+
+    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.outer_position()))
+    }
+
+    fn set_outer_position(&self, position: Position) {
+        self.maybe_wait_on_main(|delegate| delegate.set_outer_position(position));
+    }
+
+    fn surface_size(&self) -> PhysicalSize<u32> {
+        self.maybe_wait_on_main(|delegate| delegate.surface_size())
+    }
+
+    fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
+        self.maybe_wait_on_main(|delegate| delegate.request_surface_size(size))
+    }
+
+    fn outer_size(&self) -> PhysicalSize<u32> {
+        self.maybe_wait_on_main(|delegate| delegate.outer_size())
+    }
+
+    fn set_min_surface_size(&self, min_size: Option<Size>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_min_surface_size(min_size))
+    }
+
+    fn set_max_surface_size(&self, max_size: Option<Size>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_max_surface_size(max_size));
+    }
+
+    fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        self.maybe_wait_on_main(|delegate| delegate.surface_resize_increments())
+    }
+
+    fn set_surface_resize_increments(&self, increments: Option<Size>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_surface_resize_increments(increments));
+    }
+
+    fn set_title(&self, title: &str) {
+        self.maybe_wait_on_main(|delegate| delegate.set_title(title));
+    }
+
+    fn set_transparent(&self, transparent: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_transparent(transparent));
+    }
+
+    fn set_blur(&self, blur: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_blur(blur));
+    }
+
+    fn set_visible(&self, visible: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_visible(visible));
+    }
+
+    fn is_visible(&self) -> Option<bool> {
+        self.maybe_wait_on_main(|delegate| delegate.is_visible())
+    }
+
+    fn set_resizable(&self, resizable: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_resizable(resizable))
+    }
+
+    fn is_resizable(&self) -> bool {
+        self.maybe_wait_on_main(|delegate| delegate.is_resizable())
+    }
+
+    fn set_enabled_buttons(&self, buttons: WindowButtons) {
+        self.maybe_wait_on_main(|delegate| delegate.set_enabled_buttons(buttons))
+    }
+
+    fn enabled_buttons(&self) -> WindowButtons {
+        self.maybe_wait_on_main(|delegate| delegate.enabled_buttons())
+    }
+
+    fn set_minimized(&self, minimized: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_minimized(minimized));
+    }
+
+    fn is_minimized(&self) -> Option<bool> {
+        self.maybe_wait_on_main(|delegate| delegate.is_minimized())
+    }
+
+    fn set_maximized(&self, maximized: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_maximized(maximized));
+    }
+
+    fn is_maximized(&self) -> bool {
+        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 fullscreen(&self) -> Option<crate::window::Fullscreen> {
+        self.maybe_wait_on_main(|delegate| delegate.fullscreen().map(Into::into))
+    }
+
+    fn set_decorations(&self, decorations: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_decorations(decorations));
+    }
+
+    fn is_decorated(&self) -> bool {
+        self.maybe_wait_on_main(|delegate| delegate.is_decorated())
+    }
+
+    fn set_window_level(&self, level: WindowLevel) {
+        self.maybe_wait_on_main(|delegate| delegate.set_window_level(level));
+    }
+
+    fn set_window_icon(&self, window_icon: Option<Icon>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_window_icon(window_icon));
+    }
+
+    fn set_ime_cursor_area(&self, position: Position, size: Size) {
+        self.maybe_wait_on_main(|delegate| delegate.set_ime_cursor_area(position, size));
+    }
+
+    fn set_ime_allowed(&self, allowed: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_ime_allowed(allowed));
+    }
+
+    fn set_ime_purpose(&self, purpose: ImePurpose) {
+        self.maybe_wait_on_main(|delegate| delegate.set_ime_purpose(purpose));
+    }
+
+    fn focus_window(&self) {
+        self.maybe_wait_on_main(|delegate| delegate.focus_window());
+    }
+
+    fn has_focus(&self) -> bool {
+        self.maybe_wait_on_main(|delegate| delegate.has_focus())
+    }
+
+    fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        self.maybe_wait_on_main(|delegate| delegate.request_user_attention(request_type));
+    }
+
+    fn set_theme(&self, theme: Option<Theme>) {
+        self.maybe_wait_on_main(|delegate| delegate.set_theme(theme));
+    }
+
+    fn theme(&self) -> Option<Theme> {
+        self.maybe_wait_on_main(|delegate| delegate.theme())
+    }
+
+    fn set_content_protected(&self, protected: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_content_protected(protected));
+    }
+
+    fn title(&self) -> String {
+        self.maybe_wait_on_main(|delegate| delegate.title())
+    }
+
+    fn set_cursor(&self, cursor: Cursor) {
+        self.maybe_wait_on_main(|delegate| delegate.set_cursor(cursor));
+    }
+
+    fn set_cursor_position(&self, position: Position) -> Result<(), RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.set_cursor_position(position))?)
+    }
+
+    fn set_cursor_grab(&self, mode: crate::window::CursorGrabMode) -> Result<(), RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.set_cursor_grab(mode))?)
+    }
+
+    fn set_cursor_visible(&self, visible: bool) {
+        self.maybe_wait_on_main(|delegate| delegate.set_cursor_visible(visible))
+    }
+
+    fn drag_window(&self) -> Result<(), RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.drag_window())?)
+    }
+
+    fn drag_resize_window(
+        &self,
+        direction: crate::window::ResizeDirection,
+    ) -> Result<(), RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.drag_resize_window(direction))?)
+    }
+
+    fn show_window_menu(&self, position: Position) {
+        self.maybe_wait_on_main(|delegate| delegate.show_window_menu(position))
+    }
+
+    fn set_cursor_hittest(&self, hittest: bool) -> Result<(), RequestError> {
+        Ok(self.maybe_wait_on_main(|delegate| delegate.set_cursor_hittest(hittest))?)
+    }
+
+    fn current_monitor(&self) -> Option<CoreMonitorHandle> {
+        self.maybe_wait_on_main(|delegate| {
+            delegate.current_monitor().map(|inner| CoreMonitorHandle { inner })
+        })
+    }
+
+    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 }),
+            )
+        })
+    }
+
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
+        self.maybe_wait_on_main(|delegate| {
+            delegate.primary_monitor().map(|inner| CoreMonitorHandle { inner })
+        })
+    }
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
+        self
+    }
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
+        self
+    }
+}
+
 // WindowExtIOS
 impl Inner {
     pub fn set_scale_factor(&self, scale_factor: f64) {

src/platform_impl/linux/mod.rs

@@ -3,38 +3,33 @@
 #[cfg(all(not(x11_platform), not(wayland_platform)))]
 compile_error!("Please select a feature to build for unix: `x11`, `wayland`");
 
-use std::collections::VecDeque;
+use std::env;
 use std::num::{NonZeroU16, NonZeroU32};
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
-use std::sync::Arc;
 use std::time::Duration;
-use std::{env, fmt};
 #[cfg(x11_platform)]
-use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Mutex};
+use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Arc, sync::Mutex};
 
 use smol_str::SmolStr;
 
 pub(crate) use self::common::xkb::{physicalkey_to_scancode, scancode_to_physicalkey};
 #[cfg(x11_platform)]
-use self::x11::{X11Error, XConnection, XError, XNotSupported};
+use self::x11::{XConnection, XError, XNotSupported};
 use crate::application::ApplicationHandler;
 pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
-use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{EventLoopError, ExternalError, NotSupportedError};
-use crate::event_loop::{ActiveEventLoop, AsyncRequestSerial};
-use crate::icon::Icon;
+#[cfg(x11_platform)]
+use crate::dpi::Size;
+use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::error::{EventLoopError, NotSupportedError};
+use crate::event_loop::ActiveEventLoop;
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
 use crate::keyboard::Key;
 use crate::platform::pump_events::PumpStatus;
 #[cfg(x11_platform)]
 use crate::platform::x11::{WindowType as XWindowType, XlibErrorHook};
-pub(crate) use crate::platform_impl::Fullscreen;
 #[cfg(x11_platform)]
 use crate::utils::Lazy;
-use crate::window::{
-    ActivationToken, Cursor, CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-    WindowButtons, WindowLevel,
-};
+use crate::window::ActivationToken;
 
 pub(crate) mod common;
 #[cfg(wayland_platform)]
@@ -112,34 +107,6 @@ impl Default for PlatformSpecificWindowAttributes {
 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)]
-pub enum OsError {
-    Misc(&'static str),
-    #[cfg(x11_platform)]
-    XError(Arc<X11Error>),
-    #[cfg(wayland_platform)]
-    WaylandError(Arc<wayland::WaylandError>),
-}
-
-impl fmt::Display for OsError {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        match *self {
-            OsError::Misc(e) => _f.pad(e),
-            #[cfg(x11_platform)]
-            OsError::XError(ref e) => fmt::Display::fmt(e, _f),
-            #[cfg(wayland_platform)]
-            OsError::WaylandError(ref e) => fmt::Display::fmt(e, _f),
-        }
-    }
-}
-
-pub(crate) enum Window {
-    #[cfg(x11_platform)]
-    X(x11::Window),
-    #[cfg(wayland_platform)]
-    Wayland(wayland::Window),
-}
-
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WindowId(u64);
 
@@ -293,316 +260,6 @@ impl VideoModeHandle {
     }
 }
 
-impl Window {
-    pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Self) + Send + 'static) {
-        f(self)
-    }
-
-    pub(crate) fn maybe_wait_on_main<R: Send>(&self, f: impl FnOnce(&Self) -> R + Send) -> R {
-        f(self)
-    }
-
-    #[inline]
-    pub fn id(&self) -> WindowId {
-        x11_or_wayland!(match self; Window(w) => w.id())
-    }
-
-    #[inline]
-    pub fn set_title(&self, title: &str) {
-        x11_or_wayland!(match self; Window(w) => w.set_title(title));
-    }
-
-    #[inline]
-    pub fn set_transparent(&self, transparent: bool) {
-        x11_or_wayland!(match self; Window(w) => w.set_transparent(transparent));
-    }
-
-    #[inline]
-    pub fn set_blur(&self, blur: bool) {
-        x11_or_wayland!(match self; Window(w) => w.set_blur(blur));
-    }
-
-    #[inline]
-    pub fn set_visible(&self, visible: bool) {
-        x11_or_wayland!(match self; Window(w) => w.set_visible(visible))
-    }
-
-    #[inline]
-    pub fn is_visible(&self) -> Option<bool> {
-        x11_or_wayland!(match self; Window(w) => w.is_visible())
-    }
-
-    #[inline]
-    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        x11_or_wayland!(match self; Window(w) => w.outer_position())
-    }
-
-    #[inline]
-    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        x11_or_wayland!(match self; Window(w) => w.inner_position())
-    }
-
-    #[inline]
-    pub fn set_outer_position(&self, position: Position) {
-        x11_or_wayland!(match self; Window(w) => w.set_outer_position(position))
-    }
-
-    #[inline]
-    pub fn inner_size(&self) -> PhysicalSize<u32> {
-        x11_or_wayland!(match self; Window(w) => w.inner_size())
-    }
-
-    #[inline]
-    pub fn outer_size(&self) -> PhysicalSize<u32> {
-        x11_or_wayland!(match self; Window(w) => w.outer_size())
-    }
-
-    #[inline]
-    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
-        x11_or_wayland!(match self; Window(w) => w.request_inner_size(size))
-    }
-
-    #[inline]
-    pub(crate) fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError> {
-        x11_or_wayland!(match self; Window(w) => w.request_activation_token())
-    }
-
-    #[inline]
-    pub fn set_min_inner_size(&self, dimensions: Option<Size>) {
-        x11_or_wayland!(match self; Window(w) => w.set_min_inner_size(dimensions))
-    }
-
-    #[inline]
-    pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
-        x11_or_wayland!(match self; Window(w) => w.set_max_inner_size(dimensions))
-    }
-
-    #[inline]
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
-        x11_or_wayland!(match self; Window(w) => w.resize_increments())
-    }
-
-    #[inline]
-    pub fn set_resize_increments(&self, increments: Option<Size>) {
-        x11_or_wayland!(match self; Window(w) => w.set_resize_increments(increments))
-    }
-
-    #[inline]
-    pub fn set_resizable(&self, resizable: bool) {
-        x11_or_wayland!(match self; Window(w) => w.set_resizable(resizable))
-    }
-
-    #[inline]
-    pub fn is_resizable(&self) -> bool {
-        x11_or_wayland!(match self; Window(w) => w.is_resizable())
-    }
-
-    #[inline]
-    pub fn set_enabled_buttons(&self, buttons: WindowButtons) {
-        x11_or_wayland!(match self; Window(w) => w.set_enabled_buttons(buttons))
-    }
-
-    #[inline]
-    pub fn enabled_buttons(&self) -> WindowButtons {
-        x11_or_wayland!(match self; Window(w) => w.enabled_buttons())
-    }
-
-    #[inline]
-    pub fn set_cursor(&self, cursor: Cursor) {
-        x11_or_wayland!(match self; Window(w) => w.set_cursor(cursor))
-    }
-
-    #[inline]
-    pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
-        x11_or_wayland!(match self; Window(window) => window.set_cursor_grab(mode))
-    }
-
-    #[inline]
-    pub fn set_cursor_visible(&self, visible: bool) {
-        x11_or_wayland!(match self; Window(window) => window.set_cursor_visible(visible))
-    }
-
-    #[inline]
-    pub fn drag_window(&self) -> Result<(), ExternalError> {
-        x11_or_wayland!(match self; Window(window) => window.drag_window())
-    }
-
-    #[inline]
-    pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), ExternalError> {
-        x11_or_wayland!(match self; Window(window) => window.drag_resize_window(direction))
-    }
-
-    #[inline]
-    pub fn show_window_menu(&self, position: Position) {
-        x11_or_wayland!(match self; Window(w) => w.show_window_menu(position))
-    }
-
-    #[inline]
-    pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
-        x11_or_wayland!(match self; Window(w) => w.set_cursor_hittest(hittest))
-    }
-
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        x11_or_wayland!(match self; Window(w) => w.scale_factor())
-    }
-
-    #[inline]
-    pub fn set_cursor_position(&self, position: Position) -> Result<(), ExternalError> {
-        x11_or_wayland!(match self; Window(w) => w.set_cursor_position(position))
-    }
-
-    #[inline]
-    pub fn set_maximized(&self, maximized: bool) {
-        x11_or_wayland!(match self; Window(w) => w.set_maximized(maximized))
-    }
-
-    #[inline]
-    pub fn is_maximized(&self) -> bool {
-        x11_or_wayland!(match self; Window(w) => w.is_maximized())
-    }
-
-    #[inline]
-    pub fn set_minimized(&self, minimized: bool) {
-        x11_or_wayland!(match self; Window(w) => w.set_minimized(minimized))
-    }
-
-    #[inline]
-    pub fn is_minimized(&self) -> Option<bool> {
-        x11_or_wayland!(match self; Window(w) => w.is_minimized())
-    }
-
-    #[inline]
-    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
-        x11_or_wayland!(match self; Window(w) => w.fullscreen())
-    }
-
-    #[inline]
-    pub(crate) fn set_fullscreen(&self, monitor: Option<Fullscreen>) {
-        x11_or_wayland!(match self; Window(w) => w.set_fullscreen(monitor))
-    }
-
-    #[inline]
-    pub fn set_decorations(&self, decorations: bool) {
-        x11_or_wayland!(match self; Window(w) => w.set_decorations(decorations))
-    }
-
-    #[inline]
-    pub fn is_decorated(&self) -> bool {
-        x11_or_wayland!(match self; Window(w) => w.is_decorated())
-    }
-
-    #[inline]
-    pub fn set_window_level(&self, level: WindowLevel) {
-        x11_or_wayland!(match self; Window(w) => w.set_window_level(level))
-    }
-
-    #[inline]
-    pub fn set_window_icon(&self, window_icon: Option<Icon>) {
-        x11_or_wayland!(match self; Window(w) => w.set_window_icon(window_icon.map(|icon| icon.inner)))
-    }
-
-    #[inline]
-    pub fn set_ime_cursor_area(&self, position: Position, size: Size) {
-        x11_or_wayland!(match self; Window(w) => w.set_ime_cursor_area(position, size))
-    }
-
-    #[inline]
-    pub fn reset_dead_keys(&self) {
-        common::xkb::reset_dead_keys()
-    }
-
-    #[inline]
-    pub fn set_ime_allowed(&self, allowed: bool) {
-        x11_or_wayland!(match self; Window(w) => w.set_ime_allowed(allowed))
-    }
-
-    #[inline]
-    pub fn set_ime_purpose(&self, purpose: ImePurpose) {
-        x11_or_wayland!(match self; Window(w) => w.set_ime_purpose(purpose))
-    }
-
-    #[inline]
-    pub fn focus_window(&self) {
-        x11_or_wayland!(match self; Window(w) => w.focus_window())
-    }
-
-    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
-        x11_or_wayland!(match self; Window(w) => w.request_user_attention(request_type))
-    }
-
-    #[inline]
-    pub fn request_redraw(&self) {
-        x11_or_wayland!(match self; Window(w) => w.request_redraw())
-    }
-
-    #[inline]
-    pub fn pre_present_notify(&self) {
-        x11_or_wayland!(match self; Window(w) => w.pre_present_notify())
-    }
-
-    #[inline]
-    pub fn current_monitor(&self) -> Option<MonitorHandle> {
-        Some(x11_or_wayland!(match self; Window(w) => w.current_monitor()?; as MonitorHandle))
-    }
-
-    #[inline]
-    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        match self {
-            #[cfg(x11_platform)]
-            Window::X(ref window) => {
-                window.available_monitors().into_iter().map(MonitorHandle::X).collect()
-            },
-            #[cfg(wayland_platform)]
-            Window::Wayland(ref window) => {
-                window.available_monitors().into_iter().map(MonitorHandle::Wayland).collect()
-            },
-        }
-    }
-
-    #[inline]
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(x11_or_wayland!(match self; Window(w) => w.primary_monitor()?; as MonitorHandle))
-    }
-
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
-        x11_or_wayland!(match self; Window(window) => window.raw_window_handle_rwh_06())
-    }
-
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        x11_or_wayland!(match self; Window(window) => window.raw_display_handle_rwh_06())
-    }
-
-    #[inline]
-    pub fn set_theme(&self, theme: Option<Theme>) {
-        x11_or_wayland!(match self; Window(window) => window.set_theme(theme))
-    }
-
-    #[inline]
-    pub fn theme(&self) -> Option<Theme> {
-        x11_or_wayland!(match self; Window(window) => window.theme())
-    }
-
-    pub fn set_content_protected(&self, protected: bool) {
-        x11_or_wayland!(match self; Window(window) => window.set_content_protected(protected))
-    }
-
-    #[inline]
-    pub fn has_focus(&self) -> bool {
-        x11_or_wayland!(match self; Window(window) => window.has_focus())
-    }
-
-    pub fn title(&self) -> String {
-        x11_or_wayland!(match self; Window(window) => window.title())
-    }
-}
-
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct KeyEventExtra {
     pub text_with_all_modifiers: Option<SmolStr>,
@@ -626,7 +283,7 @@ 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();
+    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;
@@ -728,7 +385,7 @@ impl EventLoop {
                 } else {
                     "neither WAYLAND_DISPLAY nor WAYLAND_SOCKET nor DISPLAY is set."
                 };
-                return Err(EventLoopError::Os(os_error!(OsError::Misc(msg))));
+                return Err(NotSupportedError::new(msg).into());
             },
         };
 
@@ -748,9 +405,9 @@ impl EventLoop {
 
     #[cfg(x11_platform)]
     fn new_x11_any_thread() -> Result<EventLoop, EventLoopError> {
-        let xconn = match X11_BACKEND.lock().unwrap().as_ref() {
+        let xconn = match X11_BACKEND.lock().unwrap_or_else(|e| e.into_inner()).as_ref() {
             Ok(xconn) => xconn.clone(),
-            Err(_) => return Err(EventLoopError::NotSupported(NotSupportedError::new())),
+            Err(err) => return Err(os_error!(err.clone()).into()),
         };
 
         Ok(EventLoop::X(x11::EventLoop::new(xconn)))

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

@@ -1,6 +1,5 @@
 //! The event-loop routines.
 
-use std::any::Any;
 use std::cell::{Cell, RefCell};
 use std::io::Result as IOResult;
 use std::mem;
@@ -9,19 +8,18 @@ use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
-use sctk::reexports::calloop::Error as CalloopError;
 use sctk::reexports::calloop_wayland_source::WaylandSource;
 use sctk::reexports::client::{globals, Connection, QueueHandle};
 
 use crate::application::ApplicationHandler;
 use crate::cursor::OnlyCursorImage;
 use crate::dpi::LogicalSize;
-use crate::error::{EventLoopError, ExternalError, OsError as RootOsError};
-use crate::event::{Event, InnerSizeWriter, StartCause, WindowEvent};
+use crate::error::{EventLoopError, OsError, RequestError};
+use crate::event::{Event, StartCause, SurfaceSizeWriter, WindowEvent};
 use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents};
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::platform::min_timeout;
-use crate::platform_impl::{OsError, PlatformCustomCursor};
+use crate::platform_impl::PlatformCustomCursor;
 use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme};
 
 mod proxy;
@@ -32,7 +30,7 @@ use sink::EventSink;
 
 use super::state::{WindowCompositorUpdate, WinitState};
 use super::window::state::FrameCallbackState;
-use super::{logical_to_physical_rounded, DeviceId, WaylandError, WindowId};
+use super::{logical_to_physical_rounded, DeviceId, WindowId};
 
 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;
 
@@ -53,7 +51,7 @@ pub struct EventLoop {
     connection: Connection,
 
     /// Event loop window target.
-    pub(crate) active_event_loop: ActiveEventLoop,
+    active_event_loop: ActiveEventLoop,
 
     // XXX drop after everything else, just to be safe.
     /// Calloop's event loop.
@@ -62,27 +60,20 @@ pub struct EventLoop {
 
 impl EventLoop {
     pub fn new() -> Result<EventLoop, EventLoopError> {
-        macro_rules! map_err {
-            ($e:expr, $err:expr) => {
-                $e.map_err(|error| os_error!($err(error).into()))
-            };
-        }
-
-        let connection = map_err!(Connection::connect_to_env(), WaylandError::Connection)?;
+        let connection = Connection::connect_to_env().map_err(|err| os_error!(err))?;
 
         let (globals, mut event_queue) =
-            map_err!(globals::registry_queue_init(&connection), WaylandError::Global)?;
+            globals::registry_queue_init(&connection).map_err(|err| os_error!(err))?;
         let queue_handle = event_queue.handle();
 
         let event_loop =
-            map_err!(calloop::EventLoop::<WinitState>::try_new(), WaylandError::Calloop)?;
+            calloop::EventLoop::<WinitState>::try_new().map_err(|err| os_error!(err))?;
 
-        let mut winit_state = WinitState::new(&globals, &queue_handle, event_loop.handle())
-            .map_err(|error| os_error!(error))?;
+        let mut winit_state = WinitState::new(&globals, &queue_handle, event_loop.handle())?;
 
         // NOTE: do a roundtrip after binding the globals to prevent potential
         // races with the server.
-        map_err!(event_queue.roundtrip(&mut winit_state), WaylandError::Dispatch)?;
+        event_queue.roundtrip(&mut winit_state).map_err(|err| os_error!(err))?;
 
         // Register Wayland source.
         let wayland_source = WaylandSource::new(connection.clone(), event_queue);
@@ -98,37 +89,32 @@ impl EventLoop {
                 result
             });
 
-        map_err!(
-            event_loop.handle().register_dispatcher(wayland_dispatcher.clone()),
-            WaylandError::Calloop
-        )?;
+        event_loop
+            .handle()
+            .register_dispatcher(wayland_dispatcher.clone())
+            .map_err(|err| os_error!(err))?;
 
         // Setup the user proxy.
         let (ping, ping_source) = calloop::ping::make_ping().unwrap();
-        let result = event_loop
+        event_loop
             .handle()
             .insert_source(ping_source, move |_, _, winit_state: &mut WinitState| {
                 winit_state.dispatched_events = true;
                 winit_state.proxy_wake_up = true;
             })
-            .map_err(|error| error.error);
-        map_err!(result, WaylandError::Calloop)?;
+            .map_err(|err| os_error!(err))?;
 
         // An event's loop awakener to wake up for window events from winit's windows.
-        let (event_loop_awakener, event_loop_awakener_source) = map_err!(
-            calloop::ping::make_ping()
-                .map_err(|error| CalloopError::OtherError(Box::new(error).into())),
-            WaylandError::Calloop
-        )?;
+        let (event_loop_awakener, event_loop_awakener_source) =
+            calloop::ping::make_ping().map_err(|err| os_error!(err))?;
 
-        let result = event_loop
+        event_loop
             .handle()
             .insert_source(event_loop_awakener_source, move |_, _, winit_state: &mut WinitState| {
                 // Mark that we have something to dispatch.
                 winit_state.dispatched_events = true;
             })
-            .map_err(|error| error.error);
-        map_err!(result, WaylandError::Calloop)?;
+            .map_err(|err| os_error!(err))?;
 
         let active_event_loop = ActiveEventLoop {
             connection: connection.clone(),
@@ -139,7 +125,6 @@ impl EventLoop {
             control_flow: Cell::new(ControlFlow::default()),
             exit: Cell::new(None),
             state: RefCell::new(winit_state),
-            wayland_callback: Default::default(),
         };
 
         let event_loop = Self {
@@ -298,10 +283,6 @@ impl EventLoop {
 
         app.new_events(&self.active_event_loop, cause);
 
-        if let Some(callback) = self.active_event_loop.wayland_callback.get() {
-            callback(app);
-        }
-
         // NB: For consistency all platforms must call `can_create_surfaces` even though Wayland
         // applications don't themselves have a formal surface destroy/create lifecycle.
         if cause == StartCause::Init {
@@ -323,24 +304,24 @@ impl EventLoop {
                     let windows = state.windows.get_mut();
                     let window = windows.get(&window_id).unwrap().lock().unwrap();
                     let scale_factor = window.scale_factor();
-                    let size = logical_to_physical_rounded(window.inner_size(), scale_factor);
+                    let size = logical_to_physical_rounded(window.surface_size(), scale_factor);
                     (size, scale_factor)
                 });
 
                 // Stash the old window size.
                 let old_physical_size = physical_size;
 
-                let new_inner_size = Arc::new(Mutex::new(physical_size));
+                let new_surface_size = Arc::new(Mutex::new(physical_size));
                 let root_window_id = crate::window::WindowId(window_id);
                 let event = WindowEvent::ScaleFactorChanged {
                     scale_factor,
-                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
+                    surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_surface_size)),
                 };
 
                 app.window_event(&self.active_event_loop, root_window_id, event);
 
-                let physical_size = *new_inner_size.lock().unwrap();
-                drop(new_inner_size);
+                let physical_size = *new_surface_size.lock().unwrap();
+                drop(new_surface_size);
 
                 // Resize the window when user altered the size.
                 if old_physical_size != physical_size {
@@ -350,7 +331,7 @@ impl EventLoop {
 
                         let new_logical_size: LogicalSize<f64> =
                             physical_size.to_logical(scale_factor);
-                        window.request_inner_size(new_logical_size.into());
+                        window.request_surface_size(new_logical_size.into());
                     });
 
                     // Make it queue resize.
@@ -366,7 +347,7 @@ impl EventLoop {
                     let window = windows.get(&window_id).unwrap().lock().unwrap();
 
                     let scale_factor = window.scale_factor();
-                    let size = logical_to_physical_rounded(window.inner_size(), scale_factor);
+                    let size = logical_to_physical_rounded(window.surface_size(), scale_factor);
 
                     // Mark the window as needed a redraw.
                     state
@@ -381,7 +362,7 @@ impl EventLoop {
                 });
 
                 let window_id = crate::window::WindowId(window_id);
-                let event = WindowEvent::Resized(physical_size);
+                let event = WindowEvent::SurfaceResized(physical_size);
                 app.window_event(&self.active_event_loop, window_id, event);
             }
 
@@ -523,14 +504,12 @@ impl EventLoop {
         })
     }
 
-    fn roundtrip(&mut self) -> Result<usize, RootOsError> {
+    fn roundtrip(&mut self) -> Result<usize, OsError> {
         let state = &mut self.active_event_loop.state.get_mut();
 
         let mut wayland_source = self.wayland_dispatcher.as_source_mut();
         let event_queue = wayland_source.queue();
-        event_queue.roundtrip(state).map_err(|error| {
-            os_error!(OsError::WaylandError(Arc::new(WaylandError::Dispatch(error))))
-        })
+        event_queue.roundtrip(state).map_err(|err| os_error!(err))
     }
 
     fn control_flow(&self) -> ControlFlow {
@@ -587,8 +566,6 @@ pub struct ActiveEventLoop {
 
     /// Connection to the wayland server.
     pub connection: Connection,
-
-    pub wayland_callback: Cell<Option<fn(&mut dyn ApplicationHandler)>>,
 }
 
 impl RootActiveEventLoop for ActiveEventLoop {
@@ -622,7 +599,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_custom_cursor(
         &self,
         cursor: CustomCursorSource,
-    ) -> Result<RootCustomCursor, ExternalError> {
+    ) -> Result<RootCustomCursor, RequestError> {
         Ok(RootCustomCursor {
             inner: PlatformCustomCursor::Wayland(OnlyCursorImage(Arc::from(cursor.inner.0))),
         })
@@ -636,10 +613,9 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_window(
         &self,
         window_attributes: crate::window::WindowAttributes,
-    ) -> Result<crate::window::Window, RootOsError> {
+    ) -> Result<Box<dyn crate::window::Window>, RequestError> {
         let window = crate::platform_impl::wayland::Window::new(self, window_attributes)?;
-        let window = crate::platform_impl::Window::Wayland(window);
-        Ok(crate::window::Window { window })
+        Ok(Box::new(window))
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = crate::monitor::MonitorHandle>> {
@@ -665,11 +641,6 @@ impl RootActiveEventLoop for ActiveEventLoop {
         }
     }
 
-    #[inline(always)]
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     #[cfg(feature = "rwh_06")]
     fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
         self

src/platform_impl/linux/wayland/mod.rs

@@ -1,18 +1,14 @@
 //! Winit's Wayland backend.
 
-use std::fmt::Display;
-use std::sync::Arc;
-
 pub use event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy};
 pub use output::{MonitorHandle, VideoModeHandle};
-use sctk::reexports::client::globals::{BindError, GlobalError};
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{self, ConnectError, DispatchError, Proxy};
+use sctk::reexports::client::Proxy;
 pub use window::Window;
 
 pub(super) use crate::cursor::OnlyCursorImage as CustomCursor;
 use crate::dpi::{LogicalSize, PhysicalSize};
-pub use crate::platform_impl::platform::{OsError, WindowId};
+pub use crate::platform_impl::platform::WindowId;
 
 mod event_loop;
 mod output;
@@ -21,46 +17,6 @@ mod state;
 mod types;
 mod window;
 
-#[derive(Debug)]
-pub enum WaylandError {
-    /// Error connecting to the socket.
-    Connection(ConnectError),
-
-    /// Error binding the global.
-    Global(GlobalError),
-
-    // Bind error.
-    Bind(BindError),
-
-    /// Error during the dispatching the event queue.
-    Dispatch(DispatchError),
-
-    /// Calloop error.
-    Calloop(calloop::Error),
-
-    /// Wayland
-    Wire(client::backend::WaylandError),
-}
-
-impl Display for WaylandError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            WaylandError::Connection(error) => error.fmt(f),
-            WaylandError::Global(error) => error.fmt(f),
-            WaylandError::Bind(error) => error.fmt(f),
-            WaylandError::Dispatch(error) => error.fmt(f),
-            WaylandError::Calloop(error) => error.fmt(f),
-            WaylandError::Wire(error) => error.fmt(f),
-        }
-    }
-}
-
-impl From<WaylandError> for OsError {
-    fn from(value: WaylandError) -> Self {
-        Self::WaylandError(Arc::new(value))
-    }
-}
-
 /// Dummy device id, since Wayland doesn't have device events.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId;

src/platform_impl/linux/wayland/state.rs

@@ -21,6 +21,7 @@ use sctk::shm::slot::SlotPool;
 use sctk::shm::{Shm, ShmHandler};
 use sctk::subcompositor::SubcompositorState;
 
+use crate::error::OsError;
 use crate::platform_impl::wayland::event_loop::sink::EventSink;
 use crate::platform_impl::wayland::output::MonitorHandle;
 use crate::platform_impl::wayland::seat::{
@@ -32,8 +33,7 @@ use crate::platform_impl::wayland::types::wp_fractional_scaling::FractionalScali
 use crate::platform_impl::wayland::types::wp_viewporter::ViewporterState;
 use crate::platform_impl::wayland::types::xdg_activation::XdgActivationState;
 use crate::platform_impl::wayland::window::{WindowRequests, WindowState};
-use crate::platform_impl::wayland::{WaylandError, WindowId};
-use crate::platform_impl::OsError;
+use crate::platform_impl::wayland::WindowId;
 
 /// Winit's Wayland state.
 pub struct WinitState {
@@ -126,7 +126,7 @@ impl WinitState {
     ) -> Result<Self, OsError> {
         let registry_state = RegistryState::new(globals);
         let compositor_state =
-            CompositorState::bind(globals, queue_handle).map_err(WaylandError::Bind)?;
+            CompositorState::bind(globals, queue_handle).map_err(|err| os_error!(err))?;
         let subcompositor_state = match SubcompositorState::bind(
             compositor_state.wl_compositor().clone(),
             globals,
@@ -156,7 +156,7 @@ impl WinitState {
                 (None, None)
             };
 
-        let shm = Shm::bind(globals, queue_handle).map_err(WaylandError::Bind)?;
+        let shm = Shm::bind(globals, queue_handle).map_err(|err| os_error!(err))?;
         let custom_cursor_pool = Arc::new(Mutex::new(SlotPool::new(2, &shm).unwrap()));
 
         Ok(Self {
@@ -168,7 +168,7 @@ impl WinitState {
             shm,
             custom_cursor_pool,
 
-            xdg_shell: XdgShell::bind(globals, queue_handle).map_err(WaylandError::Bind)?,
+            xdg_shell: XdgShell::bind(globals, queue_handle).map_err(|err| os_error!(err))?,
             xdg_activation: XdgActivationState::bind(globals, queue_handle).ok(),
 
             windows: Default::default(),

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

@@ -16,17 +16,17 @@ use super::event_loop::sink::EventSink;
 use super::output::MonitorHandle;
 use super::state::WinitState;
 use super::types::xdg_activation::XdgActivationTokenData;
-use super::{ActiveEventLoop, WaylandError, WindowId};
+use super::{ActiveEventLoop, WindowId};
 use crate::dpi::{LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
+use crate::error::{NotSupportedError, RequestError};
 use crate::event::{Ime, WindowEvent};
 use crate::event_loop::AsyncRequestSerial;
-use crate::platform_impl::{
-    Fullscreen, MonitorHandle as PlatformMonitorHandle, OsError, PlatformIcon,
-};
+use crate::monitor::MonitorHandle as CoreMonitorHandle;
+use crate::platform_impl::{Fullscreen, MonitorHandle as PlatformMonitorHandle};
 use crate::window::{
-    Cursor, CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-    WindowAttributes, WindowButtons, WindowLevel,
+    Cursor, CursorGrabMode, Fullscreen as CoreFullscreen, ImePurpose, ResizeDirection, Theme,
+    UserAttentionType, Window as CoreWindow, WindowAttributes, WindowButtons,
+    WindowId as CoreWindowId, WindowLevel,
 };
 
 pub(crate) mod state;
@@ -77,7 +77,7 @@ impl Window {
     pub(crate) fn new(
         event_loop_window_target: &ActiveEventLoop,
         attributes: WindowAttributes,
-    ) -> Result<Self, RootOsError> {
+    ) -> Result<Self, RequestError> {
         let queue_handle = event_loop_window_target.queue_handle.clone();
         let mut state = event_loop_window_target.state.borrow_mut();
 
@@ -89,7 +89,7 @@ impl Window {
             state.xdg_activation.as_ref().map(|activation_state| activation_state.global().clone());
         let display = event_loop_window_target.connection.display();
 
-        let size: Size = attributes.inner_size.unwrap_or(LogicalSize::new(800., 600.).into());
+        let size: Size = attributes.surface_size.unwrap_or(LogicalSize::new(800., 600.).into());
 
         // We prefer server side decorations, however to not have decorations we ask for client
         // side decorations instead.
@@ -129,10 +129,10 @@ impl Window {
 
         // Set the min and max sizes. We must set the hints upon creating a window, so
         // we use the default `1.` scaling...
-        let min_size = attributes.min_inner_size.map(|size| size.to_logical(1.));
-        let max_size = attributes.max_inner_size.map(|size| size.to_logical(1.));
-        window_state.set_min_inner_size(min_size);
-        window_state.set_max_inner_size(max_size);
+        let min_size = attributes.min_surface_size.map(|size| size.to_logical(1.));
+        let max_size = attributes.max_surface_size.map(|size| size.to_logical(1.));
+        window_state.set_min_surface_size(min_size);
+        window_state.set_max_surface_size(max_size);
 
         // Non-resizable implies that the min and max sizes are set to the same value.
         window_state.set_resizable(attributes.resizable);
@@ -190,15 +190,11 @@ impl Window {
         let event_queue = wayland_source.queue();
 
         // Do a roundtrip.
-        event_queue.roundtrip(&mut state).map_err(|error| {
-            os_error!(OsError::WaylandError(Arc::new(WaylandError::Dispatch(error))))
-        })?;
+        event_queue.roundtrip(&mut state).map_err(|err| os_error!(err))?;
 
         // XXX Wait for the initial configure to arrive.
         while !window_state.lock().unwrap().is_configured() {
-            event_queue.blocking_dispatch(&mut state).map_err(|error| {
-                os_error!(OsError::WaylandError(Arc::new(WaylandError::Dispatch(error))))
-            })?;
+            event_queue.blocking_dispatch(&mut state).map_err(|err| os_error!(err))?;
         }
 
         // Wake-up event loop, so it'll send initial redraw requested.
@@ -223,51 +219,65 @@ impl Window {
 }
 
 impl Window {
-    #[inline]
-    pub fn id(&self) -> WindowId {
-        self.window_id
+    pub fn request_activation_token(&self) -> Result<AsyncRequestSerial, RequestError> {
+        let xdg_activation = match self.xdg_activation.as_ref() {
+            Some(xdg_activation) => xdg_activation,
+            None => return Err(NotSupportedError::new("xdg_activation_v1 is not available").into()),
+        };
+
+        let serial = AsyncRequestSerial::get();
+
+        let data = XdgActivationTokenData::Obtain((self.window_id, serial));
+        let xdg_activation_token = xdg_activation.get_activation_token(&self.queue_handle, data);
+        xdg_activation_token.set_surface(self.surface());
+        xdg_activation_token.commit();
+
+        Ok(serial)
     }
 
     #[inline]
-    pub fn set_title(&self, title: impl ToString) {
-        let new_title = title.to_string();
-        self.window_state.lock().unwrap().set_title(new_title);
+    pub fn surface(&self) -> &WlSurface {
+        self.window.wl_surface()
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        self.window_requests.closed.store(true, Ordering::Relaxed);
+        self.event_loop_awakener.ping();
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasWindowHandle for Window {
+    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        let raw = rwh_06::WaylandWindowHandle::new({
+            let ptr = self.window.wl_surface().id().as_ptr();
+            std::ptr::NonNull::new(ptr as *mut _).expect("wl_surface will never be null")
+        });
+
+        unsafe { Ok(rwh_06::WindowHandle::borrow_raw(raw.into())) }
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for Window {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = rwh_06::WaylandDisplayHandle::new({
+            let ptr = self.display.id().as_ptr();
+            std::ptr::NonNull::new(ptr as *mut _).expect("wl_proxy should never be null")
+        });
+
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw.into())) }
+    }
+}
+
+impl CoreWindow for Window {
+    fn id(&self) -> CoreWindowId {
+        CoreWindowId(self.window_id)
     }
 
-    #[inline]
-    pub fn set_visible(&self, _visible: bool) {
-        // Not possible on Wayland.
-    }
-
-    #[inline]
-    pub fn is_visible(&self) -> Option<bool> {
-        None
-    }
-
-    #[inline]
-    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        Err(NotSupportedError::new())
-    }
-
-    #[inline]
-    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        Err(NotSupportedError::new())
-    }
-
-    #[inline]
-    pub fn set_outer_position(&self, _: Position) {
-        // Not possible on Wayland.
-    }
-
-    #[inline]
-    pub fn inner_size(&self) -> PhysicalSize<u32> {
-        let window_state = self.window_state.lock().unwrap();
-        let scale_factor = window_state.scale_factor();
-        super::logical_to_physical_rounded(window_state.inner_size(), scale_factor)
-    }
-
-    #[inline]
-    pub fn request_redraw(&self) {
+    fn request_redraw(&self) {
         // NOTE: try to not wake up the loop when the event was already scheduled and not yet
         // processed by the loop, because if at this point the value was `true` it could only
         // mean that the loop still haven't dispatched the value to the client and will do
@@ -283,135 +293,116 @@ impl Window {
     }
 
     #[inline]
-    pub fn pre_present_notify(&self) {
+    fn title(&self) -> String {
+        self.window_state.lock().unwrap().title().to_owned()
+    }
+
+    fn pre_present_notify(&self) {
         self.window_state.lock().unwrap().request_frame_callback();
     }
 
-    #[inline]
-    pub fn outer_size(&self) -> PhysicalSize<u32> {
+    fn reset_dead_keys(&self) {
+        crate::platform_impl::common::xkb::reset_dead_keys()
+    }
+
+    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        Err(NotSupportedError::new("window position information is not available on Wayland")
+            .into())
+    }
+
+    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        Err(NotSupportedError::new("window position information is not available on Wayland")
+            .into())
+    }
+
+    fn set_outer_position(&self, _position: Position) {
+        // Not possible.
+    }
+
+    fn surface_size(&self) -> PhysicalSize<u32> {
+        let window_state = self.window_state.lock().unwrap();
+        let scale_factor = window_state.scale_factor();
+        super::logical_to_physical_rounded(window_state.surface_size(), scale_factor)
+    }
+
+    fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
+        let mut window_state = self.window_state.lock().unwrap();
+        let new_size = window_state.request_surface_size(size);
+        self.request_redraw();
+        Some(new_size)
+    }
+
+    fn outer_size(&self) -> PhysicalSize<u32> {
         let window_state = self.window_state.lock().unwrap();
         let scale_factor = window_state.scale_factor();
         super::logical_to_physical_rounded(window_state.outer_size(), scale_factor)
     }
 
-    #[inline]
-    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
-        let mut window_state = self.window_state.lock().unwrap();
-        let new_size = window_state.request_inner_size(size);
-        self.request_redraw();
-        Some(new_size)
-    }
-
-    /// Set the minimum inner size for the window.
-    #[inline]
-    pub fn set_min_inner_size(&self, min_size: Option<Size>) {
+    fn set_min_surface_size(&self, min_size: Option<Size>) {
         let scale_factor = self.scale_factor();
         let min_size = min_size.map(|size| size.to_logical(scale_factor));
-        self.window_state.lock().unwrap().set_min_inner_size(min_size);
+        self.window_state.lock().unwrap().set_min_surface_size(min_size);
         // NOTE: Requires commit to be applied.
         self.request_redraw();
     }
 
-    /// Set the maximum inner size for the window.
+    /// Set the maximum surface size for the window.
     #[inline]
-    pub fn set_max_inner_size(&self, max_size: Option<Size>) {
+    fn set_max_surface_size(&self, max_size: Option<Size>) {
         let scale_factor = self.scale_factor();
         let max_size = max_size.map(|size| size.to_logical(scale_factor));
-        self.window_state.lock().unwrap().set_max_inner_size(max_size);
+        self.window_state.lock().unwrap().set_max_surface_size(max_size);
         // NOTE: Requires commit to be applied.
         self.request_redraw();
     }
 
-    #[inline]
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
+    fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
         None
     }
 
-    #[inline]
-    pub fn set_resize_increments(&self, _increments: Option<Size>) {
-        warn!("`set_resize_increments` is not implemented for Wayland");
+    fn set_surface_resize_increments(&self, _increments: Option<Size>) {
+        warn!("`set_surface_resize_increments` is not implemented for Wayland");
+    }
+
+    fn set_title(&self, title: &str) {
+        let new_title = title.to_string();
+        self.window_state.lock().unwrap().set_title(new_title);
     }
 
     #[inline]
-    pub fn set_transparent(&self, transparent: bool) {
+    fn set_transparent(&self, transparent: bool) {
         self.window_state.lock().unwrap().set_transparent(transparent);
     }
 
-    #[inline]
-    pub fn has_focus(&self) -> bool {
-        self.window_state.lock().unwrap().has_focus()
+    fn set_visible(&self, _visible: bool) {
+        // Not possible on Wayland.
     }
 
-    #[inline]
-    pub fn is_minimized(&self) -> Option<bool> {
-        // XXX clients don't know whether they are minimized or not.
+    fn is_visible(&self) -> Option<bool> {
         None
     }
 
-    #[inline]
-    pub fn show_window_menu(&self, position: Position) {
-        let scale_factor = self.scale_factor();
-        let position = position.to_logical(scale_factor);
-        self.window_state.lock().unwrap().show_window_menu(position);
-    }
-
-    #[inline]
-    pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), ExternalError> {
-        self.window_state.lock().unwrap().drag_resize_window(direction)
-    }
-
-    #[inline]
-    pub fn set_resizable(&self, resizable: bool) {
+    fn set_resizable(&self, resizable: bool) {
         if self.window_state.lock().unwrap().set_resizable(resizable) {
             // NOTE: Requires commit to be applied.
             self.request_redraw();
         }
     }
 
-    #[inline]
-    pub fn is_resizable(&self) -> bool {
+    fn is_resizable(&self) -> bool {
         self.window_state.lock().unwrap().resizable()
     }
 
-    #[inline]
-    pub fn set_enabled_buttons(&self, _buttons: WindowButtons) {
+    fn set_enabled_buttons(&self, _buttons: WindowButtons) {
         // TODO(kchibisov) v5 of the xdg_shell allows that.
     }
 
-    #[inline]
-    pub fn enabled_buttons(&self) -> WindowButtons {
+    fn enabled_buttons(&self) -> WindowButtons {
         // TODO(kchibisov) v5 of the xdg_shell allows that.
         WindowButtons::all()
     }
 
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        self.window_state.lock().unwrap().scale_factor()
-    }
-
-    #[inline]
-    pub fn set_blur(&self, blur: bool) {
-        self.window_state.lock().unwrap().set_blur(blur);
-    }
-
-    #[inline]
-    pub fn set_decorations(&self, decorate: bool) {
-        self.window_state.lock().unwrap().set_decorate(decorate)
-    }
-
-    #[inline]
-    pub fn is_decorated(&self) -> bool {
-        self.window_state.lock().unwrap().is_decorated()
-    }
-
-    #[inline]
-    pub fn set_window_level(&self, _level: WindowLevel) {}
-
-    #[inline]
-    pub(crate) fn set_window_icon(&self, _window_icon: Option<PlatformIcon>) {}
-
-    #[inline]
-    pub fn set_minimized(&self, minimized: bool) {
+    fn set_minimized(&self, minimized: bool) {
         // You can't unminimize the window on Wayland.
         if !minimized {
             warn!("Unminimizing is ignored on Wayland.");
@@ -421,8 +412,20 @@ impl Window {
         self.window.set_minimized();
     }
 
-    #[inline]
-    pub fn is_maximized(&self) -> bool {
+    fn is_minimized(&self) -> Option<bool> {
+        // XXX clients don't know whether they are minimized or not.
+        None
+    }
+
+    fn set_maximized(&self, maximized: bool) {
+        if maximized {
+            self.window.set_maximized()
+        } else {
+            self.window.unset_maximized()
+        }
+    }
+
+    fn is_maximized(&self) -> bool {
         self.window_state
             .lock()
             .unwrap()
@@ -432,43 +435,14 @@ impl Window {
             .unwrap_or_default()
     }
 
-    #[inline]
-    pub fn set_maximized(&self, maximized: bool) {
-        if maximized {
-            self.window.set_maximized()
-        } else {
-            self.window.unset_maximized()
-        }
-    }
-
-    #[inline]
-    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
-        let is_fullscreen = self
-            .window_state
-            .lock()
-            .unwrap()
-            .last_configure
-            .as_ref()
-            .map(|last_configure| last_configure.is_fullscreen())
-            .unwrap_or_default();
-
-        if is_fullscreen {
-            let current_monitor = self.current_monitor().map(PlatformMonitorHandle::Wayland);
-            Some(Fullscreen::Borderless(current_monitor))
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    pub(crate) fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
+    fn set_fullscreen(&self, fullscreen: Option<CoreFullscreen>) {
         match fullscreen {
-            Some(Fullscreen::Exclusive(_)) => {
+            Some(CoreFullscreen::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 {
+            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,
@@ -480,22 +454,82 @@ impl Window {
         }
     }
 
-    #[inline]
-    pub fn set_cursor(&self, cursor: Cursor) {
-        let window_state = &mut self.window_state.lock().unwrap();
+    fn fullscreen(&self) -> Option<CoreFullscreen> {
+        let is_fullscreen = self
+            .window_state
+            .lock()
+            .unwrap()
+            .last_configure
+            .as_ref()
+            .map(|last_configure| last_configure.is_fullscreen())
+            .unwrap_or_default();
 
-        match cursor {
-            Cursor::Icon(icon) => window_state.set_cursor(icon),
-            Cursor::Custom(cursor) => window_state.set_custom_cursor(cursor),
+        if is_fullscreen {
+            let current_monitor = self.current_monitor();
+            Some(CoreFullscreen::Borderless(current_monitor))
+        } else {
+            None
         }
     }
 
     #[inline]
-    pub fn set_cursor_visible(&self, visible: bool) {
-        self.window_state.lock().unwrap().set_cursor_visible(visible);
+    fn scale_factor(&self) -> f64 {
+        self.window_state.lock().unwrap().scale_factor()
     }
 
-    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+    #[inline]
+    fn set_blur(&self, blur: bool) {
+        self.window_state.lock().unwrap().set_blur(blur);
+    }
+
+    #[inline]
+    fn set_decorations(&self, decorate: bool) {
+        self.window_state.lock().unwrap().set_decorate(decorate)
+    }
+
+    #[inline]
+    fn is_decorated(&self) -> bool {
+        self.window_state.lock().unwrap().is_decorated()
+    }
+
+    fn set_window_level(&self, _level: WindowLevel) {}
+
+    fn set_window_icon(&self, _window_icon: Option<crate::window::Icon>) {}
+
+    #[inline]
+    fn set_ime_cursor_area(&self, position: Position, size: Size) {
+        let window_state = self.window_state.lock().unwrap();
+        if window_state.ime_allowed() {
+            let scale_factor = window_state.scale_factor();
+            let position = position.to_logical(scale_factor);
+            let size = size.to_logical(scale_factor);
+            window_state.set_ime_cursor_area(position, size);
+        }
+    }
+
+    #[inline]
+    fn set_ime_allowed(&self, allowed: bool) {
+        let mut window_state = self.window_state.lock().unwrap();
+
+        if window_state.ime_allowed() != allowed && window_state.set_ime_allowed(allowed) {
+            let event = WindowEvent::Ime(if allowed { Ime::Enabled } else { Ime::Disabled });
+            self.window_events_sink.lock().unwrap().push_window_event(event, self.window_id);
+            self.event_loop_awakener.ping();
+        }
+    }
+
+    #[inline]
+    fn set_ime_purpose(&self, purpose: ImePurpose) {
+        self.window_state.lock().unwrap().set_ime_purpose(purpose);
+    }
+
+    fn focus_window(&self) {}
+
+    fn has_focus(&self) -> bool {
+        self.window_state.lock().unwrap().has_focus()
+    }
+
+    fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
         let xdg_activation = match self.xdg_activation.as_ref() {
             Some(xdg_activation) => xdg_activation,
             None => {
@@ -521,29 +555,26 @@ impl Window {
         xdg_activation_token.commit();
     }
 
-    pub fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError> {
-        let xdg_activation = match self.xdg_activation.as_ref() {
-            Some(xdg_activation) => xdg_activation,
-            None => return Err(NotSupportedError::new()),
-        };
-
-        let serial = AsyncRequestSerial::get();
-
-        let data = XdgActivationTokenData::Obtain((self.window_id, serial));
-        let xdg_activation_token = xdg_activation.get_activation_token(&self.queue_handle, data);
-        xdg_activation_token.set_surface(self.surface());
-        xdg_activation_token.commit();
-
-        Ok(serial)
+    fn set_theme(&self, theme: Option<Theme>) {
+        self.window_state.lock().unwrap().set_theme(theme)
     }
 
-    #[inline]
-    pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
-        self.window_state.lock().unwrap().set_cursor_grab(mode)
+    fn theme(&self) -> Option<Theme> {
+        self.window_state.lock().unwrap().theme()
     }
 
-    #[inline]
-    pub fn set_cursor_position(&self, position: Position) -> Result<(), ExternalError> {
+    fn set_content_protected(&self, _protected: bool) {}
+
+    fn set_cursor(&self, cursor: Cursor) {
+        let window_state = &mut self.window_state.lock().unwrap();
+
+        match cursor {
+            Cursor::Icon(icon) => window_state.set_cursor(icon),
+            Cursor::Custom(cursor) => window_state.set_custom_cursor(cursor),
+        }
+    }
+
+    fn set_cursor_position(&self, position: Position) -> Result<(), RequestError> {
         let scale_factor = self.scale_factor();
         let position = position.to_logical(scale_factor);
         self.window_state
@@ -554,124 +585,78 @@ impl Window {
             .map(|_| self.request_redraw())
     }
 
-    #[inline]
-    pub fn drag_window(&self) -> Result<(), ExternalError> {
+    fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError> {
+        self.window_state.lock().unwrap().set_cursor_grab(mode)
+    }
+
+    fn set_cursor_visible(&self, visible: bool) {
+        self.window_state.lock().unwrap().set_cursor_visible(visible);
+    }
+
+    fn drag_window(&self) -> Result<(), RequestError> {
         self.window_state.lock().unwrap().drag_window()
     }
 
-    #[inline]
-    pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
+    fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), RequestError> {
+        self.window_state.lock().unwrap().drag_resize_window(direction)
+    }
+
+    fn show_window_menu(&self, position: Position) {
+        let scale_factor = self.scale_factor();
+        let position = position.to_logical(scale_factor);
+        self.window_state.lock().unwrap().show_window_menu(position);
+    }
+
+    fn set_cursor_hittest(&self, hittest: bool) -> Result<(), RequestError> {
         let surface = self.window.wl_surface();
 
         if hittest {
             surface.set_input_region(None);
             Ok(())
         } else {
-            let region = Region::new(&*self.compositor).map_err(|_| {
-                ExternalError::Os(os_error!(OsError::Misc("failed to set input region.")))
-            })?;
+            let region = Region::new(&*self.compositor).map_err(|err| os_error!(err))?;
             region.add(0, 0, 0, 0);
             surface.set_input_region(Some(region.wl_region()));
             Ok(())
         }
     }
 
-    #[inline]
-    pub fn set_ime_cursor_area(&self, position: Position, size: Size) {
-        let window_state = self.window_state.lock().unwrap();
-        if window_state.ime_allowed() {
-            let scale_factor = window_state.scale_factor();
-            let position = position.to_logical(scale_factor);
-            let size = size.to_logical(scale_factor);
-            window_state.set_ime_cursor_area(position, size);
-        }
-    }
-
-    #[inline]
-    pub fn set_ime_allowed(&self, allowed: bool) {
-        let mut window_state = self.window_state.lock().unwrap();
-
-        if window_state.ime_allowed() != allowed && window_state.set_ime_allowed(allowed) {
-            let event = WindowEvent::Ime(if allowed { Ime::Enabled } else { Ime::Disabled });
-            self.window_events_sink.lock().unwrap().push_window_event(event, self.window_id);
-            self.event_loop_awakener.ping();
-        }
-    }
-
-    #[inline]
-    pub fn set_ime_purpose(&self, purpose: ImePurpose) {
-        self.window_state.lock().unwrap().set_ime_purpose(purpose);
-    }
-
-    #[inline]
-    pub fn focus_window(&self) {}
-
-    #[inline]
-    pub fn surface(&self) -> &WlSurface {
-        self.window.wl_surface()
-    }
-
-    #[inline]
-    pub fn current_monitor(&self) -> Option<MonitorHandle> {
+    fn current_monitor(&self) -> Option<CoreMonitorHandle> {
         let data = self.window.wl_surface().data::<SurfaceData>()?;
-        data.outputs().next().map(MonitorHandle::new)
+        data.outputs()
+            .next()
+            .map(MonitorHandle::new)
+            .map(crate::platform_impl::MonitorHandle::Wayland)
+            .map(|inner| CoreMonitorHandle { inner })
     }
 
-    #[inline]
-    pub fn available_monitors(&self) -> Vec<MonitorHandle> {
-        self.monitors.lock().unwrap().clone()
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
+        Box::new(
+            self.monitors
+                .lock()
+                .unwrap()
+                .clone()
+                .into_iter()
+                .map(crate::platform_impl::MonitorHandle::Wayland)
+                .map(|inner| CoreMonitorHandle { inner }),
+        )
     }
 
-    #[inline]
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        // XXX there's no such concept on Wayland.
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
+        // NOTE: There's no such concept on Wayland.
         None
     }
 
+    /// Get the raw-window-handle v0.6 display handle.
     #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
-        Ok(rwh_06::WaylandWindowHandle::new({
-            let ptr = self.window.wl_surface().id().as_ptr();
-            std::ptr::NonNull::new(ptr as *mut _).expect("wl_surface will never be null")
-        })
-        .into())
+    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
+        self
     }
 
+    /// Get the raw-window-handle v0.6 window handle.
     #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::WaylandDisplayHandle::new({
-            let ptr = self.display.id().as_ptr();
-            std::ptr::NonNull::new(ptr as *mut _).expect("wl_proxy should never be null")
-        })
-        .into())
-    }
-
-    #[inline]
-    pub fn set_theme(&self, theme: Option<Theme>) {
-        self.window_state.lock().unwrap().set_theme(theme)
-    }
-
-    #[inline]
-    pub fn theme(&self) -> Option<Theme> {
-        self.window_state.lock().unwrap().theme()
-    }
-
-    pub fn set_content_protected(&self, _protected: bool) {}
-
-    #[inline]
-    pub fn title(&self) -> String {
-        self.window_state.lock().unwrap().title().to_owned()
-    }
-}
-
-impl Drop for Window {
-    fn drop(&mut self) {
-        self.window_requests.closed.store(true, Ordering::Relaxed);
-        self.event_loop_awakener.ping();
+    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
+        self
     }
 }
 

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

@@ -30,7 +30,7 @@ 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::error::{ExternalError, NotSupportedError};
+use crate::error::{NotSupportedError, RequestError};
 use crate::platform_impl::wayland::logical_to_physical_rounded;
 use crate::platform_impl::wayland::seat::{
     PointerConstraintsState, WinitPointerData, WinitPointerDataExt, ZwpTextInputV3Ext,
@@ -46,7 +46,7 @@ pub type WinitFrame = sctk_adwaita::AdwaitaFrame<WinitState>;
 #[cfg(not(feature = "sctk-adwaita"))]
 pub type WinitFrame = sctk::shell::xdg::fallback_frame::FallbackFrame<WinitState>;
 
-// Minimum window inner size.
+// Minimum window surface size.
 const MIN_WINDOW_SIZE: LogicalSize<u32> = LogicalSize::new(2, 1);
 
 /// The state of the window which is being updated from the [`WinitState`].
@@ -112,7 +112,7 @@ pub struct WindowState {
     /// The text inputs observed on the window.
     text_inputs: Vec<ZwpTextInputV3>,
 
-    /// The inner size of the window, as in without client side decorations.
+    /// The surface size of the window, as in without client side decorations.
     size: LogicalSize<u32>,
 
     /// Whether the CSD fail to create, so we don't try to create them on each iteration.
@@ -122,8 +122,8 @@ pub struct WindowState {
     decorate: bool,
 
     /// Min size.
-    min_inner_size: LogicalSize<u32>,
-    max_inner_size: Option<LogicalSize<u32>>,
+    min_surface_size: LogicalSize<u32>,
+    max_surface_size: Option<LogicalSize<u32>>,
 
     /// The size of the window when no states were applied to it. The primary use for it
     /// is to fallback to original window size, before it was maximized, if the compositor
@@ -197,8 +197,8 @@ impl WindowState {
             ime_allowed: false,
             ime_purpose: ImePurpose::Normal,
             last_configure: None,
-            max_inner_size: None,
-            min_inner_size: MIN_WINDOW_SIZE,
+            max_surface_size: None,
+            min_surface_size: MIN_WINDOW_SIZE,
             pointer_constraints,
             pointers: Default::default(),
             queue_handle: queue_handle.clone(),
@@ -328,7 +328,7 @@ impl WindowState {
 
         // Apply configure bounds only when compositor let the user decide what size to pick.
         if constrain {
-            let bounds = self.inner_size_bounds(&configure);
+            let bounds = self.surface_size_bounds(&configure);
             new_size.width =
                 bounds.0.map(|bound_w| new_size.width.min(bound_w.get())).unwrap_or(new_size.width);
             new_size.height = bounds
@@ -353,7 +353,7 @@ impl WindowState {
         // NOTE: Set the configure before doing a resize, since we query it during it.
         self.last_configure = Some(configure);
 
-        if state_change_requires_resize || new_size != self.inner_size() {
+        if state_change_requires_resize || new_size != self.surface_size() {
             self.resize(new_size);
             true
         } else {
@@ -361,8 +361,8 @@ impl WindowState {
         }
     }
 
-    /// Compute the bounds for the inner size of the surface.
-    fn inner_size_bounds(
+    /// Compute the bounds for the surface size of the surface.
+    fn surface_size_bounds(
         &self,
         configure: &WindowConfigure,
     ) -> (Option<NonZeroU32>, Option<NonZeroU32>) {
@@ -388,7 +388,7 @@ impl WindowState {
     }
 
     /// Start interacting drag resize.
-    pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), ExternalError> {
+    pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), RequestError> {
         let xdg_toplevel = self.window.xdg_toplevel();
 
         // TODO(kchibisov) handle touch serials.
@@ -402,7 +402,7 @@ impl WindowState {
     }
 
     /// Start the window drag.
-    pub fn drag_window(&self) -> Result<(), ExternalError> {
+    pub fn drag_window(&self) -> Result<(), RequestError> {
         let xdg_toplevel = self.window.xdg_toplevel();
         // TODO(kchibisov) handle touch serials.
         self.apply_on_pointer(|_, data| {
@@ -507,8 +507,8 @@ impl WindowState {
             // Restore min/max sizes of the window.
             self.reload_min_max_hints();
         } else {
-            self.set_min_inner_size(Some(self.size));
-            self.set_max_inner_size(Some(self.size));
+            self.set_min_surface_size(Some(self.size));
+            self.set_max_surface_size(Some(self.size));
         }
 
         // Reload the state on the frame as well.
@@ -533,7 +533,7 @@ impl WindowState {
 
     /// Get the size of the window.
     #[inline]
-    pub fn inner_size(&self) -> LogicalSize<u32> {
+    pub fn surface_size(&self) -> LogicalSize<u32> {
         self.size
     }
 
@@ -628,21 +628,21 @@ impl WindowState {
     }
 
     /// Try to resize the window when the user can do so.
-    pub fn request_inner_size(&mut self, inner_size: Size) -> PhysicalSize<u32> {
+    pub fn request_surface_size(&mut self, surface_size: Size) -> PhysicalSize<u32> {
         if self.last_configure.as_ref().map(Self::is_stateless).unwrap_or(true) {
-            self.resize(inner_size.to_logical(self.scale_factor()))
+            self.resize(surface_size.to_logical(self.scale_factor()))
         }
 
-        logical_to_physical_rounded(self.inner_size(), self.scale_factor())
+        logical_to_physical_rounded(self.surface_size(), self.scale_factor())
     }
 
-    /// Resize the window to the new inner size.
-    fn resize(&mut self, inner_size: LogicalSize<u32>) {
-        self.size = inner_size;
+    /// Resize the window to the new surface size.
+    fn resize(&mut self, surface_size: LogicalSize<u32>) {
+        self.size = surface_size;
 
         // Update the stateless size.
         if Some(true) == self.last_configure.as_ref().map(Self::is_stateless) {
-            self.stateless_size = inner_size;
+            self.stateless_size = surface_size;
         }
 
         // Update the inner frame.
@@ -673,7 +673,7 @@ impl WindowState {
 
         // Update the target viewport, this is used if and only if fractional scaling is in use.
         if let Some(viewport) = self.viewport.as_ref() {
-            // Set inner size without the borders.
+            // Set surface size without the borders.
             viewport.set_destination(self.size.width as _, self.size.height as _);
         }
     }
@@ -753,7 +753,7 @@ impl WindowState {
     }
 
     /// Set maximum inner window size.
-    pub fn set_min_inner_size(&mut self, size: Option<LogicalSize<u32>>) {
+    pub fn set_min_surface_size(&mut self, size: Option<LogicalSize<u32>>) {
         // Ensure that the window has the right minimum size.
         let mut size = size.unwrap_or(MIN_WINDOW_SIZE);
         size.width = size.width.max(MIN_WINDOW_SIZE.width);
@@ -766,12 +766,12 @@ impl WindowState {
             .map(|frame| frame.add_borders(size.width, size.height).into())
             .unwrap_or(size);
 
-        self.min_inner_size = size;
+        self.min_surface_size = size;
         self.window.set_min_size(Some(size.into()));
     }
 
     /// Set maximum inner window size.
-    pub fn set_max_inner_size(&mut self, size: Option<LogicalSize<u32>>) {
+    pub fn set_max_surface_size(&mut self, size: Option<LogicalSize<u32>>) {
         let size = size.map(|size| {
             self.frame
                 .as_ref()
@@ -779,7 +779,7 @@ impl WindowState {
                 .unwrap_or(size)
         });
 
-        self.max_inner_size = size;
+        self.max_surface_size = size;
         self.window.set_max_size(size.map(Into::into));
     }
 
@@ -799,7 +799,7 @@ impl WindowState {
     }
 
     /// Set the cursor grabbing state on the top-level.
-    pub fn set_cursor_grab(&mut self, mode: CursorGrabMode) -> Result<(), ExternalError> {
+    pub fn set_cursor_grab(&mut self, mode: CursorGrabMode) -> Result<(), RequestError> {
         if self.cursor_grab_mode.user_grab_mode == mode {
             return Ok(());
         }
@@ -812,16 +812,20 @@ impl WindowState {
 
     /// Reload the hints for minimum and maximum sizes.
     pub fn reload_min_max_hints(&mut self) {
-        self.set_min_inner_size(Some(self.min_inner_size));
-        self.set_max_inner_size(self.max_inner_size);
+        self.set_min_surface_size(Some(self.min_surface_size));
+        self.set_max_surface_size(self.max_surface_size);
     }
 
     /// Set the grabbing state on the surface.
-    fn set_cursor_grab_inner(&mut self, mode: CursorGrabMode) -> Result<(), ExternalError> {
+    fn set_cursor_grab_inner(&mut self, mode: CursorGrabMode) -> Result<(), RequestError> {
         let pointer_constraints = match self.pointer_constraints.as_ref() {
             Some(pointer_constraints) => pointer_constraints,
             None if mode == CursorGrabMode::None => return Ok(()),
-            None => return Err(ExternalError::NotSupported(NotSupportedError::new())),
+            None => {
+                return Err(
+                    NotSupportedError::new("zwp_pointer_constraints is not available").into()
+                )
+            },
         };
 
         // Replace the current mode.
@@ -865,16 +869,17 @@ impl WindowState {
     }
 
     /// Set the position of the cursor.
-    pub fn set_cursor_position(&self, position: LogicalPosition<f64>) -> Result<(), ExternalError> {
+    pub fn set_cursor_position(&self, position: LogicalPosition<f64>) -> Result<(), RequestError> {
         if self.pointer_constraints.is_none() {
-            return Err(ExternalError::NotSupported(NotSupportedError::new()));
+            return Err(NotSupportedError::new("zwp_pointer_constraints is not available").into());
         }
 
         // Position can be set only for locked cursor.
         if self.cursor_grab_mode.current_grab_mode != CursorGrabMode::Locked {
-            return Err(ExternalError::Os(os_error!(crate::platform_impl::OsError::Misc(
-                "cursor position can be set only for locked cursor."
-            ))));
+            return Err(NotSupportedError::new(
+                "cursor position could only be changed for locked pointer",
+            )
+            .into());
         }
 
         self.apply_on_pointer(|_, data| {

src/platform_impl/linux/x11/event_processor.rs

@@ -22,8 +22,8 @@ use xkbcommon_dl::xkb_mod_mask_t;
 
 use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::event::{
-    DeviceEvent, ElementState, Event, Ime, InnerSizeWriter, MouseButton, MouseScrollDelta,
-    RawKeyEvent, Touch, TouchPhase, WindowEvent,
+    DeviceEvent, ElementState, Event, Ime, MouseButton, MouseScrollDelta, RawKeyEvent,
+    SurfaceSizeWriter, Touch, TouchPhase, WindowEvent,
 };
 use crate::keyboard::ModifiersState;
 use crate::platform_impl::common::xkb::{self, XkbState};
@@ -598,19 +598,19 @@ impl EventProcessor {
         // `XSendEvent` (synthetic `ConfigureNotify`) -> position relative to root
         // `XConfigureNotify` (real `ConfigureNotify`) -> position relative to parent
         // https://tronche.com/gui/x/icccm/sec-4.html#s-4.1.5
-        // We don't want to send `Moved` when this is false, since then every `Resized`
+        // We don't want to send `Moved` when this is false, since then every `SurfaceResized`
         // (whether the window moved or not) is accompanied by an extraneous `Moved` event
         // that has a position relative to the parent window.
         let is_synthetic = xev.send_event == xlib::True;
 
         // These are both in physical space.
-        let new_inner_size = (xev.width as u32, xev.height as u32);
+        let new_surface_size = (xev.width as u32, xev.height as u32);
         let new_inner_position = (xev.x, xev.y);
 
         let (mut resized, moved) = {
             let mut shared_state_lock = window.shared_state_lock();
 
-            let resized = util::maybe_change(&mut shared_state_lock.size, new_inner_size);
+            let resized = util::maybe_change(&mut shared_state_lock.size, new_surface_size);
             let moved = if is_synthetic {
                 util::maybe_change(&mut shared_state_lock.inner_position, new_inner_position)
             } else {
@@ -671,7 +671,7 @@ impl EventProcessor {
 
             let last_scale_factor = shared_state_lock.last_monitor.scale_factor;
             let new_scale_factor = {
-                let window_rect = util::AaRect::new(new_outer_position, new_inner_size);
+                let window_rect = util::AaRect::new(new_outer_position, new_surface_size);
                 let monitor = self
                     .target
                     .xconn
@@ -695,27 +695,30 @@ impl EventProcessor {
                     &shared_state_lock,
                 );
 
-                let old_inner_size = PhysicalSize::new(width, height);
-                let new_inner_size = PhysicalSize::new(new_width, new_height);
+                let old_surface_size = PhysicalSize::new(width, height);
+                let new_surface_size = PhysicalSize::new(new_width, new_height);
 
                 // Unlock shared state to prevent deadlock in callback below
                 drop(shared_state_lock);
 
-                let inner_size = Arc::new(Mutex::new(new_inner_size));
+                let surface_size = Arc::new(Mutex::new(new_surface_size));
                 callback(&self.target, Event::WindowEvent {
                     window_id,
                     event: WindowEvent::ScaleFactorChanged {
                         scale_factor: new_scale_factor,
-                        inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&inner_size)),
+                        surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&surface_size)),
                     },
                 });
 
-                let new_inner_size = *inner_size.lock().unwrap();
-                drop(inner_size);
+                let new_surface_size = *surface_size.lock().unwrap();
+                drop(surface_size);
 
-                if new_inner_size != old_inner_size {
-                    window.request_inner_size_physical(new_inner_size.width, new_inner_size.height);
-                    window.shared_state_lock().dpi_adjusted = Some(new_inner_size.into());
+                if new_surface_size != old_surface_size {
+                    window.request_surface_size_physical(
+                        new_surface_size.width,
+                        new_surface_size.height,
+                    );
+                    window.shared_state_lock().dpi_adjusted = Some(new_surface_size.into());
                     // if the DPI factor changed, force a resize event to ensure the logical
                     // size is computed with the right DPI factor
                     resized = true;
@@ -736,13 +739,13 @@ impl EventProcessor {
             // XResizeWindow requests, making Xorg, the winit client, and the WM
             // consume 100% of CPU.
             if let Some(adjusted_size) = shared_state_lock.dpi_adjusted {
-                if new_inner_size == adjusted_size || !util::wm_name_is_one_of(&["Xfwm4"]) {
+                if new_surface_size == adjusted_size || !util::wm_name_is_one_of(&["Xfwm4"]) {
                     // When this finally happens, the event will not be synthetic.
                     shared_state_lock.dpi_adjusted = None;
                 } else {
                     // Unlock shared state to prevent deadlock in callback below
                     drop(shared_state_lock);
-                    window.request_inner_size_physical(adjusted_size.0, adjusted_size.1);
+                    window.request_surface_size_physical(adjusted_size.0, adjusted_size.1);
                 }
             }
 
@@ -757,7 +760,7 @@ impl EventProcessor {
         if resized {
             callback(&self.target, Event::WindowEvent {
                 window_id,
-                event: WindowEvent::Resized(new_inner_size.into()),
+                event: WindowEvent::SurfaceResized(new_surface_size.into()),
             });
         }
     }

src/platform_impl/linux/x11/ffi.rs

@@ -1,5 +1,4 @@
 pub use x11_dl::error::OpenError;
-pub use x11_dl::xcursor::*;
 pub use x11_dl::xinput2::*;
 pub use x11_dl::xlib::*;
 pub use x11_dl::xlib_xcb::*;

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

@@ -1,7 +1,8 @@
+use std::error::Error;
 use std::ffi::CStr;
 use std::os::raw::c_short;
 use std::sync::Arc;
-use std::{mem, ptr};
+use std::{fmt, mem, ptr};
 
 use x11_dl::xlib::{XIMCallback, XIMPreeditCaretCallbackStruct, XIMPreeditDrawCallbackStruct};
 
@@ -19,6 +20,19 @@ pub enum ImeContextCreationError {
     Null,
 }
 
+impl fmt::Display for ImeContextCreationError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ImeContextCreationError::XError(err) => err.fmt(f),
+            ImeContextCreationError::Null => {
+                write!(f, "got null pointer from Xlib without exact reason")
+            },
+        }
+    }
+}
+
+impl Error for ImeContextCreationError {}
+
 /// The callback used by XIM preedit functions.
 type XIMProcNonnull = unsafe extern "C" fn(ffi::XIM, ffi::XPointer, ffi::XPointer);
 

src/platform_impl/linux/x11/mod.rs

@@ -1,4 +1,3 @@
-use std::any::Any;
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::ffi::CStr;
@@ -19,13 +18,12 @@ use tracing::warn;
 use x11rb::connection::RequestConnection;
 use x11rb::errors::{ConnectError, ConnectionError, IdsExhausted, ReplyError};
 use x11rb::protocol::xinput::{self, ConnectionExt as _};
-use x11rb::protocol::xkb;
-use x11rb::protocol::xproto::{self, ConnectionExt as _};
+use x11rb::protocol::{xkb, xproto};
 use x11rb::x11_utils::X11Error as LogicalError;
 use x11rb::xcb_ffi::ReplyOrIdError;
 
 use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, ExternalError, OsError as RootOsError};
+use crate::error::{EventLoopError, RequestError};
 use crate::event::{Event, StartCause, WindowEvent};
 use crate::event_loop::{
     ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
@@ -34,9 +32,11 @@ use crate::event_loop::{
 use crate::platform::pump_events::PumpStatus;
 use crate::platform_impl::common::xkb::Context;
 use crate::platform_impl::platform::{min_timeout, WindowId};
-use crate::platform_impl::{OsError, OwnedDisplayHandle, PlatformCustomCursor};
+use crate::platform_impl::x11::window::Window;
+use crate::platform_impl::{OwnedDisplayHandle, PlatformCustomCursor};
 use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, WindowAttributes,
+    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as CoreWindow,
+    WindowAttributes,
 };
 
 mod activation;
@@ -47,7 +47,7 @@ pub mod ffi;
 mod ime;
 mod monitor;
 mod util;
-mod window;
+pub(crate) mod window;
 mod xdisplay;
 mod xsettings;
 
@@ -399,9 +399,11 @@ impl EventLoop {
         // `run_on_demand` calls but if they have only just dropped their
         // windows we need to make sure those last requests are sent to the
         // X Server.
-        self.event_processor.target.x_connection().sync_with_server().map_err(|x_err| {
-            EventLoopError::Os(os_error!(OsError::XError(Arc::new(X11Error::Xlib(x_err)))))
-        })?;
+        self.event_processor
+            .target
+            .x_connection()
+            .sync_with_server()
+            .map_err(|x_err| EventLoopError::Os(os_error!(X11Error::Xlib(x_err))))?;
 
         exit
     }
@@ -688,16 +690,14 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_window(
         &self,
         window_attributes: WindowAttributes,
-    ) -> Result<crate::window::Window, RootOsError> {
-        let window = crate::platform_impl::x11::Window::new(self, window_attributes)?;
-        let window = crate::platform_impl::Window::X(window);
-        Ok(crate::window::Window { window })
+    ) -> Result<Box<dyn CoreWindow>, RequestError> {
+        Ok(Box::new(Window::new(self, window_attributes)?))
     }
 
     fn create_custom_cursor(
         &self,
         custom_cursor: CustomCursorSource,
-    ) -> Result<RootCustomCursor, ExternalError> {
+    ) -> Result<RootCustomCursor, RequestError> {
         Ok(RootCustomCursor {
             inner: PlatformCustomCursor::X(CustomCursor::new(self, custom_cursor.inner)?),
         })
@@ -751,10 +751,6 @@ impl RootActiveEventLoop for ActiveEventLoop {
         RootOwnedDisplayHandle { platform: handle }
     }
 
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     #[cfg(feature = "rwh_06")]
     fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
         self
@@ -832,39 +828,6 @@ impl FingerId {
     }
 }
 
-pub(crate) struct Window(Arc<UnownedWindow>);
-
-impl Deref for Window {
-    type Target = UnownedWindow;
-
-    #[inline]
-    fn deref(&self) -> &UnownedWindow {
-        &self.0
-    }
-}
-
-impl Window {
-    pub(crate) fn new(
-        event_loop: &ActiveEventLoop,
-        attribs: WindowAttributes,
-    ) -> Result<Self, RootOsError> {
-        let window = Arc::new(UnownedWindow::new(event_loop, attribs)?);
-        event_loop.windows.borrow_mut().insert(window.id(), Arc::downgrade(&window));
-        Ok(Window(window))
-    }
-}
-
-impl Drop for Window {
-    fn drop(&mut self) {
-        let window = self.deref();
-        let xconn = &window.xconn;
-
-        if let Ok(c) = xconn.xcb_connection().destroy_window(window.id().0 as xproto::Window) {
-            c.ignore_error();
-        }
-    }
-}
-
 #[derive(Clone)]
 pub struct EventLoopProxy {
     ping: Ping,
@@ -911,6 +874,9 @@ pub enum X11Error {
 
     /// Failed to get property.
     GetProperty(util::GetPropertyError),
+
+    /// Could not find an ARGB32 pict format.
+    NoArgb32Format,
 }
 
 impl fmt::Display for X11Error {
@@ -935,6 +901,9 @@ impl fmt::Display for X11Error {
             X11Error::XsettingsParse(err) => {
                 write!(f, "Failed to parse xsettings: {:?}", err)
             },
+            X11Error::NoArgb32Format => {
+                f.write_str("winit only supports X11 displays with ARGB32 picture formats")
+            },
         }
     }
 }

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

@@ -1,92 +1,161 @@
-use std::ffi::CString;
+use std::collections::hash_map::Entry;
 use std::hash::{Hash, Hasher};
+use std::iter;
 use std::sync::Arc;
-use std::{iter, slice};
 
 use x11rb::connection::Connection;
+use x11rb::protocol::render::{self, ConnectionExt as _};
+use x11rb::protocol::xproto;
 
 use super::super::ActiveEventLoop;
 use super::*;
-use crate::error::ExternalError;
-use crate::platform_impl::{OsError, PlatformCustomCursorSource};
+use crate::error::RequestError;
+use crate::platform_impl::PlatformCustomCursorSource;
 use crate::window::CursorIcon;
 
 impl XConnection {
-    pub fn set_cursor_icon(&self, window: xproto::Window, cursor: Option<CursorIcon>) {
-        let cursor = *self
-            .cursor_cache
-            .lock()
-            .unwrap()
-            .entry(cursor)
-            .or_insert_with(|| self.get_cursor(cursor));
+    pub fn set_cursor_icon(
+        &self,
+        window: xproto::Window,
+        cursor: Option<CursorIcon>,
+    ) -> Result<(), X11Error> {
+        let cursor = {
+            let mut cache = self.cursor_cache.lock().unwrap_or_else(|e| e.into_inner());
 
-        self.update_cursor(window, cursor).expect("Failed to set cursor");
-    }
-
-    pub(crate) fn set_custom_cursor(&self, window: xproto::Window, cursor: &CustomCursor) {
-        self.update_cursor(window, cursor.inner.cursor).expect("Failed to set cursor");
-    }
-
-    fn create_empty_cursor(&self) -> ffi::Cursor {
-        let data = 0;
-        let pixmap = unsafe {
-            let screen = (self.xlib.XDefaultScreen)(self.display);
-            let window = (self.xlib.XRootWindow)(self.display, screen);
-            (self.xlib.XCreateBitmapFromData)(self.display, window, &data, 1, 1)
+            match cache.entry(cursor) {
+                Entry::Occupied(o) => *o.get(),
+                Entry::Vacant(v) => *v.insert(self.get_cursor(cursor)?),
+            }
         };
 
-        if pixmap == 0 {
-            panic!("failed to allocate pixmap for cursor");
-        }
-
-        unsafe {
-            // We don't care about this color, since it only fills bytes
-            // in the pixmap which are not 0 in the mask.
-            let mut dummy_color = MaybeUninit::uninit();
-            let cursor = (self.xlib.XCreatePixmapCursor)(
-                self.display,
-                pixmap,
-                pixmap,
-                dummy_color.as_mut_ptr(),
-                dummy_color.as_mut_ptr(),
-                0,
-                0,
-            );
-            (self.xlib.XFreePixmap)(self.display, pixmap);
-
-            cursor
-        }
+        self.update_cursor(window, cursor)
     }
 
-    fn get_cursor(&self, cursor: Option<CursorIcon>) -> ffi::Cursor {
+    pub(crate) fn set_custom_cursor(
+        &self,
+        window: xproto::Window,
+        cursor: &CustomCursor,
+    ) -> Result<(), X11Error> {
+        self.update_cursor(window, cursor.inner.cursor)
+    }
+
+    /// Create a cursor from an image.
+    fn create_cursor_from_image(
+        &self,
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+        image: &[u8],
+    ) -> Result<xproto::Cursor, X11Error> {
+        // Create a pixmap for the default root window.
+        let root = self.default_root().root;
+        let pixmap =
+            xproto::PixmapWrapper::create_pixmap(self.xcb_connection(), 32, root, width, height)?;
+
+        // Create a GC to draw with.
+        let gc = xproto::GcontextWrapper::create_gc(
+            self.xcb_connection(),
+            pixmap.pixmap(),
+            &Default::default(),
+        )?;
+
+        // Draw the data into it.
+        self.xcb_connection()
+            .put_image(
+                xproto::ImageFormat::Z_PIXMAP,
+                pixmap.pixmap(),
+                gc.gcontext(),
+                width,
+                height,
+                0,
+                0,
+                0,
+                32,
+                image,
+            )?
+            .ignore_error();
+        drop(gc);
+
+        // Create the XRender picture.
+        let picture = render::PictureWrapper::create_picture(
+            self.xcb_connection(),
+            pixmap.pixmap(),
+            self.find_argb32_format()?,
+            &Default::default(),
+        )?;
+        drop(pixmap);
+
+        // Create the cursor.
+        let cursor = self.xcb_connection().generate_id()?;
+        self.xcb_connection()
+            .render_create_cursor(cursor, picture.picture(), hotspot_x, hotspot_y)?
+            .check()?;
+
+        Ok(cursor)
+    }
+
+    /// Find the render format that corresponds to ARGB32.
+    fn find_argb32_format(&self) -> Result<render::Pictformat, X11Error> {
+        macro_rules! direct {
+            ($format:expr, $shift_name:ident, $mask_name:ident, $shift:expr) => {{
+                ($format).direct.$shift_name == $shift && ($format).direct.$mask_name == 0xff
+            }};
+        }
+
+        self.render_formats()
+            .formats
+            .iter()
+            .find(|format| {
+                format.type_ == render::PictType::DIRECT
+                    && format.depth == 32
+                    && direct!(format, red_shift, red_mask, 16)
+                    && direct!(format, green_shift, green_mask, 8)
+                    && direct!(format, blue_shift, blue_mask, 0)
+                    && direct!(format, alpha_shift, alpha_mask, 24)
+            })
+            .ok_or(X11Error::NoArgb32Format)
+            .map(|format| format.id)
+    }
+
+    fn create_empty_cursor(&self) -> Result<xproto::Cursor, X11Error> {
+        self.create_cursor_from_image(1, 1, 0, 0, &[0, 0, 0, 0])
+    }
+
+    fn get_cursor(&self, cursor: Option<CursorIcon>) -> Result<xproto::Cursor, X11Error> {
         let cursor = match cursor {
             Some(cursor) => cursor,
             None => return self.create_empty_cursor(),
         };
 
-        let mut xcursor = 0;
-        for &name in iter::once(&cursor.name()).chain(cursor.alt_names().iter()) {
-            let name = CString::new(name).unwrap();
-            xcursor = unsafe {
-                (self.xcursor.XcursorLibraryLoadCursor)(
-                    self.display,
-                    name.as_ptr() as *const c_char,
-                )
-            };
+        let database = self.database();
+        let handle = x11rb::cursor::Handle::new(
+            self.xcb_connection(),
+            self.default_screen_index(),
+            &database,
+        )?
+        .reply()?;
 
-            if xcursor != 0 {
-                break;
+        let mut last_error = None;
+        for &name in iter::once(&cursor.name()).chain(cursor.alt_names().iter()) {
+            match handle.load_cursor(self.xcb_connection(), name) {
+                Ok(cursor) => return Ok(cursor),
+                Err(err) => last_error = Some(err.into()),
             }
         }
 
-        xcursor
+        Err(last_error.unwrap())
     }
 
-    fn update_cursor(&self, window: xproto::Window, cursor: ffi::Cursor) -> Result<(), X11Error> {
+    fn update_cursor(
+        &self,
+        window: xproto::Window,
+        cursor: xproto::Cursor,
+    ) -> Result<(), X11Error> {
         self.xcb_connection()
             .change_window_attributes(
                 window,
-                &xproto::ChangeWindowAttributesAux::new().cursor(cursor as xproto::Cursor),
+                &xproto::ChangeWindowAttributesAux::new().cursor(cursor),
             )?
             .ignore_error();
 
@@ -123,51 +192,44 @@ impl Eq for CustomCursor {}
 impl CustomCursor {
     pub(crate) fn new(
         event_loop: &ActiveEventLoop,
-        cursor: PlatformCustomCursorSource,
-    ) -> Result<CustomCursor, ExternalError> {
-        unsafe {
-            let ximage = (event_loop.xconn.xcursor.XcursorImageCreate)(
-                cursor.0.width as i32,
-                cursor.0.height as i32,
-            );
-            if ximage.is_null() {
-                return Err(ExternalError::Os(os_error!(OsError::Misc(
-                    "`XcursorImageCreate` failed"
-                ))));
-            }
-            (*ximage).xhot = cursor.0.hotspot_x as u32;
-            (*ximage).yhot = cursor.0.hotspot_y as u32;
-            (*ximage).delay = 0;
+        mut cursor: PlatformCustomCursorSource,
+    ) -> Result<CustomCursor, RequestError> {
+        // Reverse RGBA order to BGRA.
+        cursor.0.rgba.chunks_mut(4).for_each(|chunk| {
+            let chunk: &mut [u8; 4] = chunk.try_into().unwrap();
+            chunk[0..3].reverse();
 
-            let dst = slice::from_raw_parts_mut((*ximage).pixels, cursor.0.rgba.len() / 4);
-            for (dst, chunk) in dst.iter_mut().zip(cursor.0.rgba.chunks_exact(4)) {
-                *dst = (chunk[0] as u32) << 16
-                    | (chunk[1] as u32) << 8
-                    | (chunk[2] as u32)
-                    | (chunk[3] as u32) << 24;
+            // Byteswap if we need to.
+            if event_loop.xconn.needs_endian_swap() {
+                let value = u32::from_ne_bytes(*chunk).swap_bytes();
+                *chunk = value.to_ne_bytes();
             }
+        });
 
-            let cursor =
-                (event_loop.xconn.xcursor.XcursorImageLoadCursor)(event_loop.xconn.display, ximage);
-            (event_loop.xconn.xcursor.XcursorImageDestroy)(ximage);
-            Ok(Self {
-                inner: Arc::new(CustomCursorInner { xconn: event_loop.xconn.clone(), cursor }),
-            })
-        }
+        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,
+            )
+            .map_err(|err| os_error!(err))?;
+
+        Ok(Self { inner: Arc::new(CustomCursorInner { xconn: event_loop.xconn.clone(), cursor }) })
     }
 }
 
 #[derive(Debug)]
 struct CustomCursorInner {
     xconn: Arc<XConnection>,
-    cursor: ffi::Cursor,
+    cursor: xproto::Cursor,
 }
 
 impl Drop for CustomCursorInner {
     fn drop(&mut self) {
-        unsafe {
-            (self.xconn.xlib.XFreeCursor)(self.xconn.display, self.cursor);
-        }
+        self.xconn.xcb_connection().free_cursor(self.cursor).map(|r| r.ignore_error()).ok();
     }
 }
 

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

@@ -76,7 +76,7 @@ impl FrameExtentsHeuristic {
         }
     }
 
-    pub fn inner_size_to_outer(&self, width: u32, height: u32) -> (u32, u32) {
+    pub fn surface_size_to_outer(&self, width: u32, height: u32) -> (u32, u32) {
         (
             width.saturating_add(
                 self.frame_extents.left.saturating_add(self.frame_extents.right) as _
@@ -98,7 +98,7 @@ impl XConnection {
         self.xcb_connection().translate_coordinates(window, root, 0, 0)?.reply().map_err(Into::into)
     }
 
-    // This is adequate for inner_size
+    // This is adequate for surface_size
     pub fn get_geometry(
         &self,
         window: xproto::Window,

src/platform_impl/linux/x11/window.rs

@@ -1,6 +1,7 @@
 use std::ffi::CString;
 use std::mem::replace;
 use std::num::NonZeroU32;
+use std::ops::Deref;
 use std::os::raw::*;
 use std::path::Path;
 use std::sync::{Arc, Mutex, MutexGuard};
@@ -21,8 +22,8 @@ use super::{
 };
 use crate::cursor::{Cursor, CustomCursor as RootCustomCursor};
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
-use crate::event::{Event, InnerSizeWriter, WindowEvent};
+use crate::error::{NotSupportedError, RequestError};
+use crate::event::{Event, SurfaceSizeWriter, WindowEvent};
 use crate::event_loop::AsyncRequestSerial;
 use crate::platform::x11::WindowType;
 use crate::platform_impl::x11::atoms::*;
@@ -30,14 +31,312 @@ use crate::platform_impl::x11::{
     xinput_fp1616_to_float, MonitorHandle as X11MonitorHandle, WakeSender, X11Error,
 };
 use crate::platform_impl::{
-    Fullscreen, MonitorHandle as PlatformMonitorHandle, OsError, PlatformCustomCursor,
-    PlatformIcon, VideoModeHandle as PlatformVideoModeHandle,
+    common, Fullscreen, MonitorHandle as PlatformMonitorHandle, PlatformCustomCursor, PlatformIcon,
+    VideoModeHandle as PlatformVideoModeHandle,
 };
 use crate::window::{
-    CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, WindowAttributes,
-    WindowButtons, WindowLevel,
+    CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, Window as CoreWindow,
+    WindowAttributes, WindowButtons, WindowLevel,
 };
 
+pub(crate) struct Window(Arc<UnownedWindow>);
+
+impl Deref for Window {
+    type Target = UnownedWindow;
+
+    #[inline]
+    fn deref(&self) -> &UnownedWindow {
+        &self.0
+    }
+}
+
+impl Window {
+    pub(crate) fn new(
+        event_loop: &ActiveEventLoop,
+        attribs: WindowAttributes,
+    ) -> Result<Self, RequestError> {
+        let window = Arc::new(UnownedWindow::new(event_loop, attribs)?);
+        event_loop.windows.borrow_mut().insert(window.id(), Arc::downgrade(&window));
+        Ok(Window(window))
+    }
+}
+
+impl CoreWindow for Window {
+    fn id(&self) -> crate::window::WindowId {
+        crate::window::WindowId(self.0.id())
+    }
+
+    fn scale_factor(&self) -> f64 {
+        self.0.scale_factor()
+    }
+
+    fn request_redraw(&self) {
+        self.0.request_redraw()
+    }
+
+    fn pre_present_notify(&self) {
+        self.0.pre_present_notify()
+    }
+
+    fn reset_dead_keys(&self) {
+        common::xkb::reset_dead_keys();
+    }
+
+    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        self.0.inner_position()
+    }
+
+    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        self.0.outer_position()
+    }
+
+    fn set_outer_position(&self, position: Position) {
+        self.0.set_outer_position(position)
+    }
+
+    fn surface_size(&self) -> PhysicalSize<u32> {
+        self.0.surface_size()
+    }
+
+    fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
+        self.0.request_surface_size(size)
+    }
+
+    fn outer_size(&self) -> PhysicalSize<u32> {
+        self.0.outer_size()
+    }
+
+    fn set_min_surface_size(&self, min_size: Option<Size>) {
+        self.0.set_min_surface_size(min_size)
+    }
+
+    fn set_max_surface_size(&self, max_size: Option<Size>) {
+        self.0.set_max_surface_size(max_size)
+    }
+
+    fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        self.0.surface_resize_increments()
+    }
+
+    fn set_surface_resize_increments(&self, increments: Option<Size>) {
+        self.0.set_surface_resize_increments(increments)
+    }
+
+    fn set_title(&self, title: &str) {
+        self.0.set_title(title);
+    }
+
+    fn set_transparent(&self, transparent: bool) {
+        self.0.set_transparent(transparent);
+    }
+
+    fn set_blur(&self, blur: bool) {
+        self.0.set_blur(blur);
+    }
+
+    fn set_visible(&self, visible: bool) {
+        self.0.set_visible(visible);
+    }
+
+    fn is_visible(&self) -> Option<bool> {
+        self.0.is_visible()
+    }
+
+    fn set_resizable(&self, resizable: bool) {
+        self.0.set_resizable(resizable);
+    }
+
+    fn is_resizable(&self) -> bool {
+        self.0.is_resizable()
+    }
+
+    fn set_enabled_buttons(&self, buttons: WindowButtons) {
+        self.0.set_enabled_buttons(buttons)
+    }
+
+    fn enabled_buttons(&self) -> WindowButtons {
+        self.0.enabled_buttons()
+    }
+
+    fn set_minimized(&self, minimized: bool) {
+        self.0.set_minimized(minimized)
+    }
+
+    fn is_minimized(&self) -> Option<bool> {
+        self.0.is_minimized()
+    }
+
+    fn set_maximized(&self, maximized: bool) {
+        self.0.set_maximized(maximized)
+    }
+
+    fn is_maximized(&self) -> bool {
+        self.0.is_maximized()
+    }
+
+    fn set_fullscreen(&self, fullscreen: Option<crate::window::Fullscreen>) {
+        self.0.set_fullscreen(fullscreen.map(Into::into))
+    }
+
+    fn fullscreen(&self) -> Option<crate::window::Fullscreen> {
+        self.0.fullscreen().map(Into::into)
+    }
+
+    fn set_decorations(&self, decorations: bool) {
+        self.0.set_decorations(decorations);
+    }
+
+    fn is_decorated(&self) -> bool {
+        self.0.is_decorated()
+    }
+
+    fn set_window_level(&self, level: WindowLevel) {
+        self.0.set_window_level(level);
+    }
+
+    fn set_window_icon(&self, window_icon: Option<crate::window::Icon>) {
+        self.0.set_window_icon(window_icon.map(|inner| inner.inner))
+    }
+
+    fn set_ime_cursor_area(&self, position: Position, size: Size) {
+        self.0.set_ime_cursor_area(position, size);
+    }
+
+    fn set_ime_allowed(&self, allowed: bool) {
+        self.0.set_ime_allowed(allowed);
+    }
+
+    fn set_ime_purpose(&self, purpose: ImePurpose) {
+        self.0.set_ime_purpose(purpose);
+    }
+
+    fn focus_window(&self) {
+        self.0.focus_window();
+    }
+
+    fn has_focus(&self) -> bool {
+        self.0.has_focus()
+    }
+
+    fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        self.0.request_user_attention(request_type);
+    }
+
+    fn set_theme(&self, theme: Option<Theme>) {
+        self.0.set_theme(theme);
+    }
+
+    fn theme(&self) -> Option<Theme> {
+        self.0.theme()
+    }
+
+    fn set_content_protected(&self, protected: bool) {
+        self.0.set_content_protected(protected);
+    }
+
+    fn title(&self) -> String {
+        self.0.title()
+    }
+
+    fn set_cursor(&self, cursor: Cursor) {
+        self.0.set_cursor(cursor);
+    }
+
+    fn set_cursor_position(&self, position: Position) -> Result<(), RequestError> {
+        self.0.set_cursor_position(position)
+    }
+
+    fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError> {
+        self.0.set_cursor_grab(mode)
+    }
+
+    fn set_cursor_visible(&self, visible: bool) {
+        self.0.set_cursor_visible(visible);
+    }
+
+    fn drag_window(&self) -> Result<(), RequestError> {
+        self.0.drag_window()
+    }
+
+    fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), RequestError> {
+        self.0.drag_resize_window(direction)
+    }
+
+    fn show_window_menu(&self, position: Position) {
+        self.0.show_window_menu(position);
+    }
+
+    fn set_cursor_hittest(&self, hittest: bool) -> Result<(), RequestError> {
+        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 available_monitors(&self) -> Box<dyn Iterator<Item = crate::monitor::MonitorHandle>> {
+        Box::new(
+            self.0
+                .available_monitors()
+                .into_iter()
+                .map(crate::platform_impl::MonitorHandle::X)
+                .map(|inner| crate::monitor::MonitorHandle { inner }),
+        )
+    }
+
+    fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
+        self.0
+            .primary_monitor()
+            .map(crate::platform_impl::MonitorHandle::X)
+            .map(|inner| crate::monitor::MonitorHandle { inner })
+    }
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
+        self
+    }
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
+        self
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for Window {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = self.0.raw_display_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasWindowHandle for Window {
+    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        let raw = self.0.raw_window_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::WindowHandle::borrow_raw(raw)) }
+    }
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        let window = &self.0;
+        let xconn = &window.xconn;
+
+        // Restore the video mode on drop.
+        if let Some(Fullscreen::Exclusive(_)) = window.fullscreen() {
+            window.set_fullscreen(None);
+        }
+
+        if let Ok(c) = xconn.xcb_connection().destroy_window(window.id().0 as xproto::Window) {
+            c.ignore_error();
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct SharedState {
     pub cursor_pos: Option<(f64, f64)>,
@@ -57,9 +356,9 @@ pub struct SharedState {
     // Used to restore video mode after exiting fullscreen
     pub desktop_video_mode: Option<(randr::Crtc, randr::Mode)>,
     pub frame_extents: Option<util::FrameExtentsHeuristic>,
-    pub min_inner_size: Option<Size>,
-    pub max_inner_size: Option<Size>,
-    pub resize_increments: Option<Size>,
+    pub min_surface_size: Option<Size>,
+    pub max_surface_size: Option<Size>,
+    pub surface_resize_increments: Option<Size>,
     pub base_size: Option<Size>,
     pub visibility: Visibility,
     pub has_focus: bool,
@@ -97,9 +396,9 @@ impl SharedState {
             restore_position: None,
             desktop_video_mode: None,
             frame_extents: None,
-            min_inner_size: None,
-            max_inner_size: None,
-            resize_increments: None,
+            min_surface_size: None,
+            max_surface_size: None,
+            surface_resize_increments: None,
             base_size: None,
             has_focus: false,
             cursor_hittest: None,
@@ -128,13 +427,9 @@ pub struct UnownedWindow {
     redraw_sender: WakeSender<WindowId>,
     activation_sender: WakeSender<super::ActivationToken>,
 }
-
 macro_rules! leap {
     ($e:expr) => {
-        match $e {
-            Ok(x) => x,
-            Err(err) => return Err(os_error!(OsError::XError(X11Error::from(err).into()))),
-        }
+        $e.map_err(|err| os_error!(err))?
     };
 }
 
@@ -143,7 +438,7 @@ impl UnownedWindow {
     pub(crate) fn new(
         event_loop: &ActiveEventLoop,
         window_attrs: WindowAttributes,
-    ) -> Result<UnownedWindow, RootOsError> {
+    ) -> Result<UnownedWindow, RequestError> {
         let xconn = &event_loop.xconn;
         let atoms = xconn.atoms();
         #[cfg(feature = "rwh_06")]
@@ -180,10 +475,10 @@ impl UnownedWindow {
 
         info!("Guessed window scale factor: {}", scale_factor);
 
-        let max_inner_size: Option<(u32, u32)> =
-            window_attrs.max_inner_size.map(|size| size.to_physical::<u32>(scale_factor).into());
-        let min_inner_size: Option<(u32, u32)> =
-            window_attrs.min_inner_size.map(|size| size.to_physical::<u32>(scale_factor).into());
+        let max_surface_size: Option<(u32, u32)> =
+            window_attrs.max_surface_size.map(|size| size.to_physical::<u32>(scale_factor).into());
+        let min_surface_size: Option<(u32, u32)> =
+            window_attrs.min_surface_size.map(|size| size.to_physical::<u32>(scale_factor).into());
 
         let position =
             window_attrs.position.map(|position| position.to_physical::<i32>(scale_factor));
@@ -192,16 +487,16 @@ impl UnownedWindow {
             // x11 only applies constraints when the window is actively resized
             // by the user, so we have to manually apply the initial constraints
             let mut dimensions: (u32, u32) = window_attrs
-                .inner_size
+                .surface_size
                 .map(|size| size.to_physical::<u32>(scale_factor))
                 .or_else(|| Some((800, 600).into()))
                 .map(Into::into)
                 .unwrap();
-            if let Some(max) = max_inner_size {
+            if let Some(max) = max_surface_size {
                 dimensions.0 = cmp::min(dimensions.0, max.0);
                 dimensions.1 = cmp::min(dimensions.1, max.1);
             }
-            if let Some(min) = min_inner_size {
+            if let Some(min) = min_surface_size {
                 dimensions.0 = cmp::max(dimensions.0, min.0);
                 dimensions.1 = cmp::max(dimensions.1, min.1);
             }
@@ -228,10 +523,9 @@ impl UnownedWindow {
             match window_attrs.platform_specific.x11.visual_id {
                 Some(vi) => {
                     // Find this specific visual.
-                    let (visualtype, depth) =
-                        all_visuals.find(|(visual, _)| visual.visual_id == vi).ok_or_else(
-                            || os_error!(OsError::XError(X11Error::NoSuchVisual(vi).into())),
-                        )?;
+                    let (visualtype, depth) = all_visuals
+                        .find(|(visual, _)| visual.visual_id == vi)
+                        .ok_or_else(|| os_error!(X11Error::NoSuchVisual(vi)))?;
 
                     (Some(visualtype), depth, true)
                 },
@@ -418,24 +712,24 @@ impl UnownedWindow {
                 .ignore_error();
 
             // Set size hints.
-            let mut min_inner_size =
-                window_attrs.min_inner_size.map(|size| size.to_physical::<u32>(scale_factor));
-            let mut max_inner_size =
-                window_attrs.max_inner_size.map(|size| size.to_physical::<u32>(scale_factor));
+            let mut min_surface_size =
+                window_attrs.min_surface_size.map(|size| size.to_physical::<u32>(scale_factor));
+            let mut max_surface_size =
+                window_attrs.max_surface_size.map(|size| size.to_physical::<u32>(scale_factor));
 
             if !window_attrs.resizable {
                 if util::wm_name_is_one_of(&["Xfwm4"]) {
                     warn!("To avoid a WM bug, disabling resizing has no effect on Xfwm4");
                 } else {
-                    max_inner_size = Some(dimensions.into());
-                    min_inner_size = Some(dimensions.into());
+                    max_surface_size = Some(dimensions.into());
+                    min_surface_size = Some(dimensions.into());
                 }
             }
 
             let shared_state = window.shared_state.get_mut().unwrap();
-            shared_state.min_inner_size = min_inner_size.map(Into::into);
-            shared_state.max_inner_size = max_inner_size.map(Into::into);
-            shared_state.resize_increments = window_attrs.resize_increments;
+            shared_state.min_surface_size = min_surface_size.map(Into::into);
+            shared_state.max_surface_size = max_surface_size.map(Into::into);
+            shared_state.surface_resize_increments = window_attrs.surface_resize_increments;
             shared_state.base_size = window_attrs.platform_specific.x11.base_size;
 
             let normal_hints = WmSizeHints {
@@ -447,10 +741,10 @@ impl UnownedWindow {
                     cast_dimension_to_hint(dimensions.0),
                     cast_dimension_to_hint(dimensions.1),
                 )),
-                max_size: max_inner_size.map(cast_physical_size_to_hint),
-                min_size: min_inner_size.map(cast_physical_size_to_hint),
+                max_size: max_surface_size.map(cast_physical_size_to_hint),
+                min_size: min_surface_size.map(cast_physical_size_to_hint),
                 size_increment: window_attrs
-                    .resize_increments
+                    .surface_resize_increments
                     .map(|size| cast_size_to_hint(size, scale_factor)),
                 base_size: window_attrs
                     .platform_specific
@@ -529,7 +823,7 @@ impl UnownedWindow {
                     &mut supported_ptr,
                 );
                 if supported_ptr == ffi::False {
-                    return Err(os_error!(OsError::Misc("`XkbSetDetectableAutoRepeat` failed")));
+                    return Err(os_error!("`XkbSetDetectableAutoRepeat` failed").into());
                 }
             }
 
@@ -549,14 +843,16 @@ impl UnownedWindow {
 
             // Try to create input context for the window.
             if let Some(ime) = event_loop.ime.as_ref() {
-                let result = ime.borrow_mut().create_context(window.xwindow as ffi::Window, false);
-                leap!(result);
+                ime.borrow_mut()
+                    .create_context(window.xwindow as ffi::Window, false)
+                    .map_err(|err| os_error!(err))?;
             }
 
             // These properties must be set after mapping
             if window_attrs.maximized {
                 leap!(window.set_maximized_inner(window_attrs.maximized)).ignore_error();
             }
+
             if window_attrs.fullscreen.is_some() {
                 if let Some(flusher) =
                     leap!(window
@@ -589,7 +885,7 @@ impl UnownedWindow {
     }
 
     /// Embed this window into a parent window.
-    pub(super) fn embed_window(&self) -> Result<(), RootOsError> {
+    pub(super) fn embed_window(&self) -> Result<(), RequestError> {
         let atoms = self.xconn.atoms();
         leap!(leap!(self.xconn.change_property(
             self.xwindow,
@@ -911,7 +1207,7 @@ impl UnownedWindow {
         // Check if the self is on this monitor
         let monitor = self.shared_state_lock().last_monitor.clone();
         if monitor.name == new_monitor.name {
-            let (width, height) = self.inner_size_physical();
+            let (width, height) = self.surface_size_physical();
             let (new_width, new_height) = self.adjust_for_dpi(
                 // If we couldn't determine the previous scale
                 // factor (e.g., because all monitors were closed
@@ -925,22 +1221,22 @@ impl UnownedWindow {
             );
 
             let window_id = crate::window::WindowId(self.id());
-            let old_inner_size = PhysicalSize::new(width, height);
-            let inner_size = Arc::new(Mutex::new(PhysicalSize::new(new_width, new_height)));
+            let old_surface_size = PhysicalSize::new(width, height);
+            let surface_size = Arc::new(Mutex::new(PhysicalSize::new(new_width, new_height)));
             callback(Event::WindowEvent {
                 window_id,
                 event: WindowEvent::ScaleFactorChanged {
                     scale_factor: new_monitor.scale_factor,
-                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&inner_size)),
+                    surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&surface_size)),
                 },
             });
 
-            let new_inner_size = *inner_size.lock().unwrap();
-            drop(inner_size);
+            let new_surface_size = *surface_size.lock().unwrap();
+            drop(surface_size);
 
-            if new_inner_size != old_inner_size {
-                let (new_width, new_height) = new_inner_size.into();
-                self.request_inner_size_physical(new_width, new_height);
+            if new_surface_size != old_surface_size {
+                let (new_width, new_height) = new_surface_size.into();
+                self.request_surface_size_physical(new_width, new_height);
             }
         }
     }
@@ -1201,7 +1497,7 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
         let extents = self.shared_state_lock().frame_extents.clone();
         if let Some(extents) = extents {
             let (x, y) = self.inner_position_physical();
@@ -1222,7 +1518,7 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
+    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
         Ok(self.inner_position_physical().into())
     }
 
@@ -1260,7 +1556,7 @@ impl UnownedWindow {
         self.set_position_physical(x, y);
     }
 
-    pub(crate) fn inner_size_physical(&self) -> (u32, u32) {
+    pub(crate) fn surface_size_physical(&self) -> (u32, u32) {
         // This should be okay to unwrap since the only error XGetGeometry can return
         // is BadWindow, and if the window handle is bad we have bigger problems.
         self.xconn
@@ -1270,23 +1566,23 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn inner_size(&self) -> PhysicalSize<u32> {
-        self.inner_size_physical().into()
+    pub fn surface_size(&self) -> PhysicalSize<u32> {
+        self.surface_size_physical().into()
     }
 
     #[inline]
     pub fn outer_size(&self) -> PhysicalSize<u32> {
         let extents = self.shared_state_lock().frame_extents.clone();
         if let Some(extents) = extents {
-            let (width, height) = self.inner_size_physical();
-            extents.inner_size_to_outer(width, height).into()
+            let (width, height) = self.surface_size_physical();
+            extents.surface_size_to_outer(width, height).into()
         } else {
             self.update_cached_frame_extents();
             self.outer_size()
         }
     }
 
-    pub(crate) fn request_inner_size_physical(&self, width: u32, height: u32) {
+    pub(crate) fn request_surface_size_physical(&self, width: u32, height: u32) {
         self.xconn
             .xcb_connection()
             .configure_window(
@@ -1302,7 +1598,7 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
+    pub fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let scale_factor = self.scale_factor();
         let size = size.to_physical::<u32>(scale_factor).into();
         if !self.shared_state_lock().is_resizable {
@@ -1312,7 +1608,7 @@ impl UnownedWindow {
             })
             .expect("Failed to call `XSetWMNormalHints`");
         }
-        self.request_inner_size_physical(size.0 as u32, size.1 as u32);
+        self.request_surface_size_physical(size.0 as u32, size.1 as u32);
 
         None
     }
@@ -1339,7 +1635,7 @@ impl UnownedWindow {
         Ok(())
     }
 
-    pub(crate) fn set_min_inner_size_physical(&self, dimensions: Option<(u32, u32)>) {
+    pub(crate) fn set_min_surface_size_physical(&self, dimensions: Option<(u32, u32)>) {
         self.update_normal_hints(|normal_hints| {
             normal_hints.min_size =
                 dimensions.map(|(w, h)| (cast_dimension_to_hint(w), cast_dimension_to_hint(h)))
@@ -1348,14 +1644,14 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn set_min_inner_size(&self, dimensions: Option<Size>) {
-        self.shared_state_lock().min_inner_size = dimensions;
+    pub fn set_min_surface_size(&self, dimensions: Option<Size>) {
+        self.shared_state_lock().min_surface_size = dimensions;
         let physical_dimensions =
             dimensions.map(|dimensions| dimensions.to_physical::<u32>(self.scale_factor()).into());
-        self.set_min_inner_size_physical(physical_dimensions);
+        self.set_min_surface_size_physical(physical_dimensions);
     }
 
-    pub(crate) fn set_max_inner_size_physical(&self, dimensions: Option<(u32, u32)>) {
+    pub(crate) fn set_max_surface_size_physical(&self, dimensions: Option<(u32, u32)>) {
         self.update_normal_hints(|normal_hints| {
             normal_hints.max_size =
                 dimensions.map(|(w, h)| (cast_dimension_to_hint(w), cast_dimension_to_hint(h)))
@@ -1364,15 +1660,15 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
-        self.shared_state_lock().max_inner_size = dimensions;
+    pub fn set_max_surface_size(&self, dimensions: Option<Size>) {
+        self.shared_state_lock().max_surface_size = dimensions;
         let physical_dimensions =
             dimensions.map(|dimensions| dimensions.to_physical::<u32>(self.scale_factor()).into());
-        self.set_max_inner_size_physical(physical_dimensions);
+        self.set_max_surface_size_physical(physical_dimensions);
     }
 
     #[inline]
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
+    pub fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
         WmSizeHints::get(
             self.xconn.xcb_connection(),
             self.xwindow as xproto::Window,
@@ -1386,8 +1682,8 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn set_resize_increments(&self, increments: Option<Size>) {
-        self.shared_state_lock().resize_increments = increments;
+    pub fn set_surface_resize_increments(&self, increments: Option<Size>) {
+        self.shared_state_lock().surface_resize_increments = increments;
         let physical_increments =
             increments.map(|increments| cast_size_to_hint(increments, self.scale_factor()));
         self.update_normal_hints(|hints| hints.size_increment = physical_increments)
@@ -1405,14 +1701,15 @@ impl UnownedWindow {
         let scale_factor = new_scale_factor / old_scale_factor;
         self.update_normal_hints(|normal_hints| {
             let dpi_adjuster = |size: Size| -> (i32, i32) { cast_size_to_hint(size, scale_factor) };
-            let max_size = shared_state.max_inner_size.map(dpi_adjuster);
-            let min_size = shared_state.min_inner_size.map(dpi_adjuster);
-            let resize_increments = shared_state.resize_increments.map(dpi_adjuster);
+            let max_size = shared_state.max_surface_size.map(dpi_adjuster);
+            let min_size = shared_state.min_surface_size.map(dpi_adjuster);
+            let surface_resize_increments =
+                shared_state.surface_resize_increments.map(dpi_adjuster);
             let base_size = shared_state.base_size.map(dpi_adjuster);
 
             normal_hints.max_size = max_size;
             normal_hints.min_size = min_size;
-            normal_hints.size_increment = resize_increments;
+            normal_hints.size_increment = surface_resize_increments;
             normal_hints.base_size = base_size;
         })
         .expect("Failed to update normal hints");
@@ -1435,9 +1732,9 @@ impl UnownedWindow {
 
         let (min_size, max_size) = if resizable {
             let shared_state_lock = self.shared_state_lock();
-            (shared_state_lock.min_inner_size, shared_state_lock.max_inner_size)
+            (shared_state_lock.min_surface_size, shared_state_lock.max_surface_size)
         } else {
-            let window_size = Some(Size::from(self.inner_size()));
+            let window_size = Some(Size::from(self.surface_size()));
             (window_size, window_size)
         };
         self.shared_state_lock().is_resizable = resizable;
@@ -1446,11 +1743,11 @@ impl UnownedWindow {
             .expect_then_ignore_error("Failed to call `XSetWMNormalHints`");
 
         let scale_factor = self.scale_factor();
-        let min_inner_size = min_size.map(|size| cast_size_to_hint(size, scale_factor));
-        let max_inner_size = max_size.map(|size| cast_size_to_hint(size, scale_factor));
+        let min_surface_size = min_size.map(|size| cast_size_to_hint(size, scale_factor));
+        let max_surface_size = max_size.map(|size| cast_size_to_hint(size, scale_factor));
         self.update_normal_hints(|normal_hints| {
-            normal_hints.min_size = min_inner_size;
-            normal_hints.max_size = max_inner_size;
+            normal_hints.min_size = min_surface_size;
+            normal_hints.max_size = max_surface_size;
         })
         .expect("Failed to call `XSetWMNormalHints`");
     }
@@ -1492,13 +1789,17 @@ impl UnownedWindow {
                 #[allow(clippy::mutex_atomic)]
                 if SelectedCursor::Named(icon) != old_cursor && *self.cursor_visible.lock().unwrap()
                 {
-                    self.xconn.set_cursor_icon(self.xwindow, Some(icon));
+                    if let Err(err) = self.xconn.set_cursor_icon(self.xwindow, Some(icon)) {
+                        tracing::error!("failed to set cursor icon: {err}");
+                    }
                 }
             },
             Cursor::Custom(RootCustomCursor { inner: PlatformCustomCursor::X(cursor) }) => {
                 #[allow(clippy::mutex_atomic)]
                 if *self.cursor_visible.lock().unwrap() {
-                    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);
@@ -1511,7 +1812,7 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
+    pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError> {
         let mut grabbed_lock = self.cursor_grabbed_mode.lock().unwrap();
         if mode == *grabbed_lock {
             return Ok(());
@@ -1525,9 +1826,10 @@ impl UnownedWindow {
             .expect_then_ignore_error("Failed to call `xcb_ungrab_pointer`");
 
         let result = match mode {
-            CursorGrabMode::None => self.xconn.flush_requests().map_err(|err| {
-                ExternalError::Os(os_error!(OsError::XError(X11Error::Xlib(err).into())))
-            }),
+            CursorGrabMode::None => self
+                .xconn
+                .flush_requests()
+                .map_err(|err| RequestError::Os(os_error!(X11Error::Xlib(err)))),
             CursorGrabMode::Confined => {
                 let result = {
                     self.xconn
@@ -1574,10 +1876,12 @@ impl UnownedWindow {
                     },
                     _ => unreachable!(),
                 }
-                .map_err(|err| ExternalError::Os(os_error!(OsError::Misc(err))))
+                .map_err(|err| RequestError::Os(os_error!(err)))
             },
             CursorGrabMode::Locked => {
-                return Err(ExternalError::NotSupported(NotSupportedError::new()));
+                return Err(
+                    NotSupportedError::new("locked cursor is not implemented on X11").into()
+                );
             },
         };
 
@@ -1599,16 +1903,18 @@ impl UnownedWindow {
             if visible { Some((*self.selected_cursor.lock().unwrap()).clone()) } else { None };
         *visible_lock = visible;
         drop(visible_lock);
-        match cursor {
+        let result = match cursor {
             Some(SelectedCursor::Custom(cursor)) => {
-                self.xconn.set_custom_cursor(self.xwindow, &cursor);
+                self.xconn.set_custom_cursor(self.xwindow, &cursor)
             },
             Some(SelectedCursor::Named(cursor)) => {
-                self.xconn.set_cursor_icon(self.xwindow, Some(cursor));
-            },
-            None => {
-                self.xconn.set_cursor_icon(self.xwindow, None);
+                self.xconn.set_cursor_icon(self.xwindow, Some(cursor))
             },
+            None => self.xconn.set_cursor_icon(self.xwindow, None),
+        };
+
+        if let Err(err) = result {
+            tracing::error!("failed to set cursor icon: {err}");
         }
     }
 
@@ -1617,31 +1923,26 @@ impl UnownedWindow {
         self.shared_state_lock().last_monitor.scale_factor
     }
 
-    pub fn set_cursor_position_physical(&self, x: i32, y: i32) -> Result<(), ExternalError> {
-        {
-            self.xconn
-                .xcb_connection()
-                .warp_pointer(x11rb::NONE, self.xwindow, 0, 0, 0, 0, x as _, y as _)
-                .map_err(|e| {
-                    ExternalError::Os(os_error!(OsError::XError(X11Error::from(e).into())))
-                })?;
-            self.xconn.flush_requests().map_err(|e| {
-                ExternalError::Os(os_error!(OsError::XError(X11Error::Xlib(e).into())))
-            })
-        }
+    pub fn set_cursor_position_physical(&self, x: i32, y: i32) -> Result<(), RequestError> {
+        self.xconn
+            .xcb_connection()
+            .warp_pointer(x11rb::NONE, self.xwindow, 0, 0, 0, 0, x as _, y as _)
+            .map_err(|err| os_error!(X11Error::from(err)))?;
+        self.xconn.flush_requests().map_err(|err| os_error!(X11Error::Xlib(err)))?;
+        Ok(())
     }
 
     #[inline]
-    pub fn set_cursor_position(&self, position: Position) -> Result<(), ExternalError> {
+    pub fn set_cursor_position(&self, position: Position) -> Result<(), RequestError> {
         let (x, y) = position.to_physical::<i32>(self.scale_factor()).into();
         self.set_cursor_position_physical(x, y)
     }
 
     #[inline]
-    pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
+    pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), RequestError> {
         let mut rectangles: Vec<Rectangle> = Vec::new();
         if hittest {
-            let size = self.inner_size();
+            let size = self.surface_size();
             rectangles.push(Rectangle {
                 x: 0,
                 y: 0,
@@ -1650,17 +1951,17 @@ impl UnownedWindow {
             })
         }
         let region = RegionWrapper::create_region(self.xconn.xcb_connection(), &rectangles)
-            .map_err(|_e| ExternalError::Ignored)?;
+            .map_err(|_e| RequestError::Ignored)?;
         self.xconn
             .xcb_connection()
             .xfixes_set_window_shape_region(self.xwindow, SK::INPUT, 0, 0, region.region())
-            .map_err(|_e| ExternalError::Ignored)?;
+            .map_err(|_e| RequestError::Ignored)?;
         self.shared_state_lock().cursor_hittest = Some(hittest);
         Ok(())
     }
 
     /// Moves the window while it is being dragged.
-    pub fn drag_window(&self) -> Result<(), ExternalError> {
+    pub fn drag_window(&self) -> Result<(), RequestError> {
         self.drag_initiate(util::MOVERESIZE_MOVE)
     }
 
@@ -1668,7 +1969,7 @@ impl UnownedWindow {
     pub fn show_window_menu(&self, _position: Position) {}
 
     /// Resizes the window while it is being dragged.
-    pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), ExternalError> {
+    pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), RequestError> {
         self.drag_initiate(match direction {
             ResizeDirection::East => util::MOVERESIZE_RIGHT,
             ResizeDirection::North => util::MOVERESIZE_TOP,
@@ -1682,13 +1983,13 @@ impl UnownedWindow {
     }
 
     /// Initiates a drag operation while the left mouse button is pressed.
-    fn drag_initiate(&self, action: isize) -> Result<(), ExternalError> {
+    fn drag_initiate(&self, action: isize) -> Result<(), RequestError> {
         let pointer = self
             .xconn
             .query_pointer(self.xwindow, util::VIRTUAL_CORE_POINTER)
-            .map_err(|err| ExternalError::Os(os_error!(OsError::XError(err.into()))))?;
+            .map_err(|err| os_error!(err))?;
 
-        let window = self.inner_position().map_err(ExternalError::NotSupported)?;
+        let window_position = self.inner_position()?;
 
         let atoms = self.xconn.atoms();
         let message = atoms[_NET_WM_MOVERESIZE];
@@ -1699,13 +2000,9 @@ impl UnownedWindow {
         self.xconn
             .xcb_connection()
             .ungrab_pointer(x11rb::CURRENT_TIME)
-            .map_err(|err| {
-                ExternalError::Os(os_error!(OsError::XError(X11Error::from(err).into())))
-            })?
+            .map_err(|err| os_error!(X11Error::from(err)))?
             .ignore_error();
-        self.xconn.flush_requests().map_err(|err| {
-            ExternalError::Os(os_error!(OsError::XError(X11Error::Xlib(err).into())))
-        })?;
+        self.xconn.flush_requests().map_err(|err| os_error!(X11Error::Xlib(err)))?;
         *grabbed_lock = CursorGrabMode::None;
 
         // we keep the lock until we are done
@@ -1719,18 +2016,18 @@ impl UnownedWindow {
                         | xproto::EventMask::SUBSTRUCTURE_NOTIFY,
                 ),
                 [
-                    (window.x + xinput_fp1616_to_float(pointer.win_x) as i32) as u32,
-                    (window.y + xinput_fp1616_to_float(pointer.win_y) as i32) as u32,
+                    (window_position.x + xinput_fp1616_to_float(pointer.win_x) as i32) as u32,
+                    (window_position.y + xinput_fp1616_to_float(pointer.win_y) as i32) as u32,
                     action.try_into().unwrap(),
                     1, // Button 1
                     1,
                 ],
             )
-            .map_err(|err| ExternalError::Os(os_error!(OsError::XError(err.into()))))?;
+            .map_err(|err| os_error!(err))?;
 
-        self.xconn.flush_requests().map_err(|err| {
-            ExternalError::Os(os_error!(OsError::XError(X11Error::Xlib(err).into())))
-        })
+        self.xconn.flush_requests().map_err(|err| os_error!(X11Error::Xlib(err)))?;
+
+        Ok(())
     }
 
     #[inline]
@@ -1829,7 +2126,7 @@ impl UnownedWindow {
     }
 
     #[inline]
-    pub fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError> {
+    pub fn request_activation_token(&self) -> Result<AsyncRequestSerial, RequestError> {
         let serial = AsyncRequestSerial::get();
         self.activation_sender.send((self.id(), serial));
         Ok(serial)

src/platform_impl/linux/x11/xdisplay.rs

@@ -6,6 +6,7 @@ use std::{fmt, ptr};
 
 use x11rb::connection::Connection;
 use x11rb::protocol::randr::ConnectionExt as _;
+use x11rb::protocol::render;
 use x11rb::protocol::xproto::{self, ConnectionExt};
 use x11rb::resource_manager;
 use x11rb::xcb_ffi::XCBConnection;
@@ -18,7 +19,6 @@ use crate::window::CursorIcon;
 /// A connection to an X server.
 pub struct XConnection {
     pub xlib: ffi::Xlib,
-    pub xcursor: ffi::Xcursor,
 
     // TODO(notgull): I'd like to remove this, but apparently Xlib and Xinput2 are tied together
     // for some reason.
@@ -55,8 +55,11 @@ pub struct XConnection {
     /// Atom for the XSettings screen.
     xsettings_screen: Option<xproto::Atom>,
 
+    /// XRender format information.
+    render_formats: render::QueryPictFormatsReply,
+
     pub latest_error: Mutex<Option<XError>>,
-    pub cursor_cache: Mutex<HashMap<Option<CursorIcon>, ffi::Cursor>>,
+    pub cursor_cache: Mutex<HashMap<Option<CursorIcon>, xproto::Cursor>>,
 }
 
 unsafe impl Send for XConnection {}
@@ -69,7 +72,6 @@ impl XConnection {
     pub fn new(error_handler: XErrorHandler) -> Result<XConnection, XNotSupported> {
         // opening the libraries
         let xlib = ffi::Xlib::open()?;
-        let xcursor = ffi::Xcursor::open()?;
         let xlib_xcb = ffi::Xlib_xcb::open()?;
         let xinput2 = ffi::XInput2::open()?;
 
@@ -118,15 +120,22 @@ impl XConnection {
             tracing::warn!("error setting XSETTINGS; Xft options won't reload automatically")
         }
 
+        // Start getting the XRender formats.
+        let formats_cookie = render::query_pict_formats(&xcb)
+            .map_err(|e| XNotSupported::XcbConversionError(Arc::new(e)))?;
+
         // Fetch atoms.
         let atoms = Atoms::new(&xcb)
             .map_err(|e| XNotSupported::XcbConversionError(Arc::new(e)))?
             .reply()
             .map_err(|e| XNotSupported::XcbConversionError(Arc::new(e)))?;
 
+        // Finish getting everything else.
+        let formats =
+            formats_cookie.reply().map_err(|e| XNotSupported::XcbConversionError(Arc::new(e)))?;
+
         Ok(XConnection {
             xlib,
-            xcursor,
             xinput2,
             display,
             xcb: Some(xcb),
@@ -138,6 +147,7 @@ impl XConnection {
             database: RwLock::new(database),
             cursor_cache: Default::default(),
             randr_version: (randr_version.major_version, randr_version.minor_version),
+            render_formats: formats,
             xsettings_screen,
         })
     }
@@ -257,6 +267,23 @@ impl XConnection {
     pub fn xsettings_screen(&self) -> Option<xproto::Atom> {
         self.xsettings_screen
     }
+
+    /// Get the data containing our rendering formats.
+    #[inline]
+    pub fn render_formats(&self) -> &render::QueryPictFormatsReply {
+        &self.render_formats
+    }
+
+    /// Do we need to do an endian swap?
+    #[inline]
+    pub fn needs_endian_swap(&self) -> bool {
+        #[cfg(target_endian = "big")]
+        let endian = xproto::ImageOrder::MSB_FIRST;
+        #[cfg(not(target_endian = "big"))]
+        let endian = xproto::ImageOrder::LSB_FIRST;
+
+        self.xcb_connection().setup().image_byte_order != endian
+    }
 }
 
 impl fmt::Debug for XConnection {

src/platform_impl/orbital/event_loop.rs

@@ -1,4 +1,3 @@
-use std::any::Any;
 use std::cell::Cell;
 use std::collections::VecDeque;
 use std::sync::{mpsc, Arc, Mutex};
@@ -13,19 +12,21 @@ use orbclient::{
 use smol_str::SmolStr;
 
 use super::{
-    DeviceId, KeyEventExtra, MonitorHandle, OsError, PlatformSpecificEventLoopAttributes,
-    RedoxSocket, TimeSocket, WindowId, WindowProperties,
+    DeviceId, KeyEventExtra, MonitorHandle, PlatformSpecificEventLoopAttributes, RedoxSocket,
+    TimeSocket, WindowId, WindowProperties,
 };
 use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, ExternalError, NotSupportedError};
+use crate::error::{EventLoopError, NotSupportedError, RequestError};
 use crate::event::{self, Ime, Modifiers, StartCause};
 use crate::event_loop::{self, ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents};
 use crate::keyboard::{
     Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey, NativeKeyCode,
     PhysicalKey,
 };
+use crate::platform_impl::Window;
 use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, WindowId as RootWindowId,
+    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as CoreWindow,
+    WindowId as RootWindowId,
 };
 
 fn convert_scancode(scancode: u8) -> (PhysicalKey, Option<NamedKey>) {
@@ -283,17 +284,11 @@ impl EventLoop {
         // events.
         let (user_events_sender, user_events_receiver) = mpsc::sync_channel(1);
 
-        let event_socket = Arc::new(
-            RedoxSocket::event()
-                .map_err(OsError::new)
-                .map_err(|error| EventLoopError::Os(os_error!(error)))?,
-        );
+        let event_socket =
+            Arc::new(RedoxSocket::event().map_err(|error| os_error!(format!("{error}")))?);
 
-        let wake_socket = Arc::new(
-            TimeSocket::open()
-                .map_err(OsError::new)
-                .map_err(|error| EventLoopError::Os(os_error!(error)))?,
-        );
+        let wake_socket =
+            Arc::new(TimeSocket::open().map_err(|error| os_error!(format!("{error}")))?);
 
         event_socket
             .write(&syscall::Event {
@@ -301,8 +296,7 @@ impl EventLoop {
                 flags: syscall::EventFlags::EVENT_READ,
                 data: wake_socket.0.fd,
             })
-            .map_err(OsError::new)
-            .map_err(|error| EventLoopError::Os(os_error!(error)))?;
+            .map_err(|error| os_error!(format!("{error}")))?;
 
         Ok(Self {
             windows: Vec::new(),
@@ -475,7 +469,7 @@ impl EventLoop {
                 app.window_event(
                     window_target,
                     RootWindowId(window_id),
-                    event::WindowEvent::Resized((width, height).into()),
+                    event::WindowEvent::SurfaceResized((width, height).into()),
                 );
 
                 // Acknowledge resize after event loop.
@@ -522,7 +516,7 @@ impl EventLoop {
                 let window_id = RootWindowId(window_id);
 
                 // Send resize event on create to indicate first size.
-                let event = event::WindowEvent::Resized((properties.w, properties.h).into());
+                let event = event::WindowEvent::SurfaceResized((properties.w, properties.h).into());
                 app.window_event(&self.window_target, window_id, event);
 
                 // Send moved event on create to indicate first position.
@@ -730,16 +724,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_window(
         &self,
         window_attributes: crate::window::WindowAttributes,
-    ) -> Result<crate::window::Window, crate::error::OsError> {
-        let window = crate::platform_impl::Window::new(self, window_attributes)?;
-        Ok(crate::window::Window { window })
+    ) -> Result<Box<dyn CoreWindow>, RequestError> {
+        Ok(Box::new(Window::new(self, window_attributes)?))
     }
 
     fn create_custom_cursor(
         &self,
         _: CustomCursorSource,
-    ) -> Result<RootCustomCursor, ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    ) -> Result<RootCustomCursor, RequestError> {
+        Err(NotSupportedError::new("create_custom_cursor is not supported").into())
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = crate::monitor::MonitorHandle>> {
@@ -778,10 +771,6 @@ impl RootActiveEventLoop for ActiveEventLoop {
         event_loop::OwnedDisplayHandle { platform: OwnedDisplayHandle }
     }
 
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     #[cfg(feature = "rwh_06")]
     fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
         self

src/platform_impl/orbital/mod.rs

@@ -1,9 +1,7 @@
 #![cfg(target_os = "redox")]
 
-use std::fmt::{self, Display, Formatter};
 use std::num::{NonZeroU16, NonZeroU32};
-use std::str;
-use std::sync::Arc;
+use std::{fmt, str};
 
 use smol_str::SmolStr;
 
@@ -15,6 +13,11 @@ mod event_loop;
 pub use self::window::Window;
 mod window;
 
+pub(crate) use crate::cursor::{
+    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
+};
+pub(crate) use crate::icon::NoIcon as PlatformIcon;
+
 struct RedoxSocket {
     fd: usize,
 }
@@ -173,26 +176,6 @@ impl<'a> fmt::Display for WindowProperties<'a> {
     }
 }
 
-#[derive(Clone, Debug)]
-pub struct OsError(Arc<syscall::Error>);
-
-impl OsError {
-    fn new(error: syscall::Error) -> Self {
-        Self(Arc::new(error))
-    }
-}
-
-impl Display for OsError {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
-        self.0.fmt(fmt)
-    }
-}
-
-pub(crate) use crate::cursor::{
-    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
-};
-pub(crate) use crate::icon::NoIcon as PlatformIcon;
-
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
 pub struct MonitorHandle;
 

src/platform_impl/orbital/window.rs

@@ -1,14 +1,12 @@
 use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};
 
-use super::{
-    ActiveEventLoop, MonitorHandle, OsError, RedoxSocket, TimeSocket, WindowId, WindowProperties,
-};
+use super::{ActiveEventLoop, MonitorHandle, RedoxSocket, TimeSocket, WindowId, WindowProperties};
 use crate::cursor::Cursor;
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
-use crate::platform_impl::Fullscreen;
-use crate::window::ImePurpose;
-use crate::{error, window};
+use crate::error::{NotSupportedError, RequestError};
+use crate::monitor::MonitorHandle as CoreMonitorHandle;
+use crate::window::{self, Fullscreen, ImePurpose, Window as CoreWindow, WindowId as CoreWindowId};
 
 // 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
@@ -32,7 +30,7 @@ impl Window {
     pub(crate) fn new(
         el: &ActiveEventLoop,
         attrs: window::WindowAttributes,
-    ) -> Result<Self, error::OsError> {
+    ) -> Result<Self, RequestError> {
         let scale = MonitorHandle.scale_factor();
 
         let (x, y) = if let Some(pos) = attrs.position {
@@ -42,13 +40,13 @@ impl Window {
             (-1, -1)
         };
 
-        let (w, h): (u32, u32) = if let Some(size) = attrs.inner_size {
+        let (w, h): (u32, u32) = if let Some(size) = attrs.surface_size {
             size.to_physical::<u32>(scale).into()
         } else {
             (1024, 768)
         };
 
-        // TODO: min/max inner_size
+        // TODO: min/max surface_size
 
         // Async by default.
         let mut flag_str = ORBITAL_FLAG_ASYNC.to_string();
@@ -125,61 +123,65 @@ impl Window {
         })
     }
 
-    pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Self) + Send + 'static) {
-        f(self)
-    }
-
-    pub(crate) fn maybe_wait_on_main<R: Send>(&self, f: impl FnOnce(&Self) -> R + Send) -> R {
-        f(self)
-    }
-
-    fn get_flag(&self, flag: char) -> Result<bool, error::ExternalError> {
+    fn get_flag(&self, flag: char) -> Result<bool, RequestError> {
         let mut buf: [u8; 4096] = [0; 4096];
-        let path = self
-            .window_socket
-            .fpath(&mut buf)
-            .map_err(|err| error::ExternalError::Os(os_error!(OsError::new(err))))?;
+        let path = self.window_socket.fpath(&mut buf).map_err(|err| os_error!(format!("{err}")))?;
         let properties = WindowProperties::new(path);
         Ok(properties.flags.contains(flag))
     }
 
-    fn set_flag(&self, flag: char, value: bool) -> Result<(), error::ExternalError> {
+    fn set_flag(&self, flag: char, value: bool) -> Result<(), RequestError> {
         self.window_socket
             .write(format!("F,{flag},{}", if value { 1 } else { 0 }).as_bytes())
-            .map_err(|err| error::ExternalError::Os(os_error!(OsError::new(err))))?;
+            .map_err(|err| os_error!(format!("{err}")))?;
         Ok(())
     }
 
+    #[cfg(feature = "rwh_06")]
     #[inline]
-    pub fn id(&self) -> WindowId {
-        WindowId { fd: self.window_socket.fd as u64 }
+    fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
+        let handle = rwh_06::OrbitalWindowHandle::new({
+            let window = self.window_socket.fd as *mut _;
+            std::ptr::NonNull::new(window).expect("orbital fd should never be null")
+        });
+        Ok(rwh_06::RawWindowHandle::Orbital(handle))
+    }
+
+    #[cfg(feature = "rwh_06")]
+    #[inline]
+    fn raw_display_handle_rwh_06(&self) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
+        Ok(rwh_06::RawDisplayHandle::Orbital(rwh_06::OrbitalDisplayHandle::new()))
+    }
+}
+
+impl CoreWindow for Window {
+    fn id(&self) -> CoreWindowId {
+        CoreWindowId(WindowId { fd: self.window_socket.fd as u64 })
     }
 
     #[inline]
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle)
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
+        Some(CoreMonitorHandle { inner: MonitorHandle })
     }
 
     #[inline]
-    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        let mut v = VecDeque::with_capacity(1);
-        v.push_back(MonitorHandle);
-        v
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
+        Box::new(vec![CoreMonitorHandle { inner: MonitorHandle }].into_iter())
     }
 
     #[inline]
-    pub fn current_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle)
+    fn current_monitor(&self) -> Option<CoreMonitorHandle> {
+        Some(CoreMonitorHandle { inner: MonitorHandle })
     }
 
     #[inline]
-    pub fn scale_factor(&self) -> f64 {
+    fn scale_factor(&self) -> f64 {
         MonitorHandle.scale_factor()
     }
 
     #[inline]
-    pub fn request_redraw(&self) {
-        let window_id = self.id();
+    fn request_redraw(&self) {
+        let window_id = self.id().0;
         let mut redraws = self.redraws.lock().unwrap();
         if !redraws.contains(&window_id) {
             redraws.push_back(window_id);
@@ -189,15 +191,15 @@ impl Window {
     }
 
     #[inline]
-    pub fn pre_present_notify(&self) {}
+    fn pre_present_notify(&self) {}
 
     #[inline]
-    pub fn reset_dead_keys(&self) {
+    fn reset_dead_keys(&self) {
         // TODO?
     }
 
     #[inline]
-    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, error::NotSupportedError> {
+    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
         let mut buf: [u8; 4096] = [0; 4096];
         let path = self.window_socket.fpath(&mut buf).expect("failed to read properties");
         let properties = WindowProperties::new(path);
@@ -205,20 +207,20 @@ impl Window {
     }
 
     #[inline]
-    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, error::NotSupportedError> {
+    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
         // TODO: adjust for window decorations
         self.inner_position()
     }
 
     #[inline]
-    pub fn set_outer_position(&self, position: Position) {
+    fn set_outer_position(&self, position: Position) {
         // TODO: adjust for window decorations
         let (x, y): (i32, i32) = position.to_physical::<i32>(self.scale_factor()).into();
         self.window_socket.write(format!("P,{x},{y}").as_bytes()).expect("failed to set position");
     }
 
     #[inline]
-    pub fn inner_size(&self) -> PhysicalSize<u32> {
+    fn surface_size(&self) -> PhysicalSize<u32> {
         let mut buf: [u8; 4096] = [0; 4096];
         let path = self.window_socket.fpath(&mut buf).expect("failed to read properties");
         let properties = WindowProperties::new(path);
@@ -226,26 +228,26 @@ impl Window {
     }
 
     #[inline]
-    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
+    fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let (w, h): (u32, u32) = size.to_physical::<u32>(self.scale_factor()).into();
         self.window_socket.write(format!("S,{w},{h}").as_bytes()).expect("failed to set size");
         None
     }
 
     #[inline]
-    pub fn outer_size(&self) -> PhysicalSize<u32> {
+    fn outer_size(&self) -> PhysicalSize<u32> {
         // TODO: adjust for window decorations
-        self.inner_size()
+        self.surface_size()
     }
 
     #[inline]
-    pub fn set_min_inner_size(&self, _: Option<Size>) {}
+    fn set_min_surface_size(&self, _: Option<Size>) {}
 
     #[inline]
-    pub fn set_max_inner_size(&self, _: Option<Size>) {}
+    fn set_max_surface_size(&self, _: Option<Size>) {}
 
     #[inline]
-    pub fn title(&self) -> String {
+    fn title(&self) -> String {
         let mut buf: [u8; 4096] = [0; 4096];
         let path = self.window_socket.fpath(&mut buf).expect("failed to read properties");
         let properties = WindowProperties::new(path);
@@ -253,84 +255,82 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_title(&self, title: &str) {
+    fn set_title(&self, title: &str) {
         self.window_socket.write(format!("T,{title}").as_bytes()).expect("failed to set title");
     }
 
     #[inline]
-    pub fn set_transparent(&self, transparent: bool) {
+    fn set_transparent(&self, transparent: bool) {
         let _ = self.set_flag(ORBITAL_FLAG_TRANSPARENT, transparent);
     }
 
     #[inline]
-    pub fn set_blur(&self, _blur: bool) {}
+    fn set_blur(&self, _blur: bool) {}
 
     #[inline]
-    pub fn set_visible(&self, visible: bool) {
+    fn set_visible(&self, visible: bool) {
         let _ = self.set_flag(ORBITAL_FLAG_HIDDEN, !visible);
     }
 
     #[inline]
-    pub fn is_visible(&self) -> Option<bool> {
+    fn is_visible(&self) -> Option<bool> {
         Some(!self.get_flag(ORBITAL_FLAG_HIDDEN).unwrap_or(false))
     }
 
     #[inline]
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
+    fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
         None
     }
 
     #[inline]
-    pub fn set_resize_increments(&self, _increments: Option<Size>) {}
+    fn set_surface_resize_increments(&self, _increments: Option<Size>) {}
 
     #[inline]
-    pub fn set_resizable(&self, resizeable: bool) {
+    fn set_resizable(&self, resizeable: bool) {
         let _ = self.set_flag(ORBITAL_FLAG_RESIZABLE, resizeable);
     }
 
     #[inline]
-    pub fn is_resizable(&self) -> bool {
+    fn is_resizable(&self) -> bool {
         self.get_flag(ORBITAL_FLAG_RESIZABLE).unwrap_or(false)
     }
 
     #[inline]
-    pub fn set_minimized(&self, _minimized: bool) {}
+    fn set_minimized(&self, _minimized: bool) {}
 
     #[inline]
-    pub fn is_minimized(&self) -> Option<bool> {
+    fn is_minimized(&self) -> Option<bool> {
         None
     }
 
     #[inline]
-    pub fn set_maximized(&self, maximized: bool) {
+    fn set_maximized(&self, maximized: bool) {
         let _ = self.set_flag(ORBITAL_FLAG_MAXIMIZED, maximized);
     }
 
     #[inline]
-    pub fn is_maximized(&self) -> bool {
+    fn is_maximized(&self) -> bool {
         self.get_flag(ORBITAL_FLAG_MAXIMIZED).unwrap_or(false)
     }
 
-    #[inline]
-    pub(crate) fn set_fullscreen(&self, _monitor: Option<Fullscreen>) {}
+    fn set_fullscreen(&self, _monitor: Option<Fullscreen>) {}
 
-    #[inline]
-    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
+    fn fullscreen(&self) -> Option<Fullscreen> {
         None
     }
 
     #[inline]
-    pub fn set_decorations(&self, decorations: bool) {
+    fn set_decorations(&self, decorations: bool) {
         let _ = self.set_flag(ORBITAL_FLAG_BORDERLESS, !decorations);
     }
 
     #[inline]
-    pub fn is_decorated(&self) -> bool {
+    fn is_decorated(&self) -> bool {
         !self.get_flag(ORBITAL_FLAG_BORDERLESS).unwrap_or(false)
     }
 
     #[inline]
-    pub fn set_window_level(&self, level: window::WindowLevel) {
+    fn set_window_level(&self, level: window::WindowLevel) {
         match level {
             window::WindowLevel::AlwaysOnBottom => {
                 let _ = self.set_flag(ORBITAL_FLAG_BACK, true);
@@ -346,36 +346,33 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_window_icon(&self, _window_icon: Option<crate::icon::Icon>) {}
+    fn set_window_icon(&self, _window_icon: Option<crate::icon::Icon>) {}
 
     #[inline]
-    pub fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}
+    fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}
 
     #[inline]
-    pub fn set_ime_allowed(&self, _allowed: bool) {}
+    fn set_ime_allowed(&self, _allowed: bool) {}
 
     #[inline]
-    pub fn set_ime_purpose(&self, _purpose: ImePurpose) {}
+    fn set_ime_purpose(&self, _purpose: ImePurpose) {}
 
     #[inline]
-    pub fn focus_window(&self) {}
+    fn focus_window(&self) {}
 
     #[inline]
-    pub fn request_user_attention(&self, _request_type: Option<window::UserAttentionType>) {}
+    fn request_user_attention(&self, _request_type: Option<window::UserAttentionType>) {}
 
     #[inline]
-    pub fn set_cursor(&self, _: Cursor) {}
+    fn set_cursor(&self, _: Cursor) {}
 
     #[inline]
-    pub fn set_cursor_position(&self, _: Position) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
+    fn set_cursor_position(&self, _: Position) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("set_cursor_position is not supported").into())
     }
 
     #[inline]
-    pub fn set_cursor_grab(
-        &self,
-        mode: window::CursorGrabMode,
-    ) -> Result<(), error::ExternalError> {
+    fn set_cursor_grab(&self, mode: window::CursorGrabMode) -> Result<(), RequestError> {
         let (grab, relative) = match mode {
             window::CursorGrabMode::None => (false, false),
             window::CursorGrabMode::Confined => (true, false),
@@ -383,31 +380,26 @@ impl Window {
         };
         self.window_socket
             .write(format!("M,G,{}", if grab { 1 } else { 0 }).as_bytes())
-            .map_err(|err| error::ExternalError::Os(os_error!(OsError::new(err))))?;
+            .map_err(|err| os_error!(format!("{err}")))?;
         self.window_socket
             .write(format!("M,R,{}", if relative { 1 } else { 0 }).as_bytes())
-            .map_err(|err| error::ExternalError::Os(os_error!(OsError::new(err))))?;
+            .map_err(|err| os_error!(format!("{err}")))?;
         Ok(())
     }
 
     #[inline]
-    pub fn set_cursor_visible(&self, visible: bool) {
+    fn set_cursor_visible(&self, visible: bool) {
         let _ = self.window_socket.write(format!("M,C,{}", if visible { 1 } else { 0 }).as_bytes());
     }
 
     #[inline]
-    pub fn drag_window(&self) -> Result<(), error::ExternalError> {
-        self.window_socket
-            .write(b"D")
-            .map_err(|err| error::ExternalError::Os(os_error!(OsError::new(err))))?;
+    fn drag_window(&self) -> Result<(), RequestError> {
+        self.window_socket.write(b"D").map_err(|err| os_error!(format!("{err}")))?;
         Ok(())
     }
 
     #[inline]
-    pub fn drag_resize_window(
-        &self,
-        direction: window::ResizeDirection,
-    ) -> Result<(), error::ExternalError> {
+    fn drag_resize_window(&self, direction: window::ResizeDirection) -> Result<(), RequestError> {
         let arg = match direction {
             window::ResizeDirection::East => "R",
             window::ResizeDirection::North => "T",
@@ -420,65 +412,73 @@ impl Window {
         };
         self.window_socket
             .write(format!("D,{}", arg).as_bytes())
-            .map_err(|err| error::ExternalError::Os(os_error!(OsError::new(err))))?;
+            .map_err(|err| os_error!(format!("{err}")))?;
         Ok(())
     }
 
     #[inline]
-    pub fn show_window_menu(&self, _position: Position) {}
+    fn show_window_menu(&self, _position: Position) {}
 
     #[inline]
-    pub fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
-    }
-
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
-        let handle = rwh_06::OrbitalWindowHandle::new({
-            let window = self.window_socket.fd as *mut _;
-            std::ptr::NonNull::new(window).expect("orbital fd should never be null")
-        });
-        Ok(rwh_06::RawWindowHandle::Orbital(handle))
-    }
-
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::RawDisplayHandle::Orbital(rwh_06::OrbitalDisplayHandle::new()))
+    fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("set_cursor_hittest is not supported").into())
     }
 
     #[inline]
-    pub fn set_enabled_buttons(&self, _buttons: window::WindowButtons) {}
+    fn set_enabled_buttons(&self, _buttons: window::WindowButtons) {}
 
     #[inline]
-    pub fn enabled_buttons(&self) -> window::WindowButtons {
+    fn enabled_buttons(&self) -> window::WindowButtons {
         window::WindowButtons::all()
     }
 
     #[inline]
-    pub fn theme(&self) -> Option<window::Theme> {
+    fn theme(&self) -> Option<window::Theme> {
         None
     }
 
     #[inline]
-    pub fn has_focus(&self) -> bool {
+    fn has_focus(&self) -> bool {
         false
     }
 
     #[inline]
-    pub fn set_theme(&self, _theme: Option<window::Theme>) {}
+    fn set_theme(&self, _theme: Option<window::Theme>) {}
 
-    pub fn set_content_protected(&self, _protected: bool) {}
+    fn set_content_protected(&self, _protected: bool) {}
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
+        self
+    }
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
+        self
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasWindowHandle for Window {
+    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        let raw = self.raw_window_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::WindowHandle::borrow_raw(raw)) }
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for Window {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = self.raw_display_handle_rwh_06()?;
+        unsafe { Ok(rwh_06::DisplayHandle::borrow_raw(raw)) }
+    }
 }
 
 impl Drop for Window {
     fn drop(&mut self) {
         {
             let mut destroys = self.destroys.lock().unwrap();
-            destroys.push_back(self.id());
+            destroys.push_back(self.id().0);
         }
 
         self.wake_socket.wake().unwrap();

src/platform_impl/web/cursor.rs

@@ -542,8 +542,8 @@ fn from_rgba(
     //
     // We call `createImageBitmap()` before spawning the future,
     // to not have to clone the image buffer.
-    let mut options = ImageBitmapOptions::new();
-    options.premultiply_alpha(PremultiplyAlpha::None);
+    let options = ImageBitmapOptions::new();
+    options.set_premultiply_alpha(PremultiplyAlpha::None);
     let bitmap = JsFuture::from(
         window
             .create_image_bitmap_with_image_data_and_image_bitmap_options(&image_data, &options)

src/platform_impl/web/event_loop/runner.rs

@@ -4,8 +4,7 @@ use std::iter;
 use std::ops::Deref;
 use std::rc::{Rc, Weak};
 
-use js_sys::Function;
-use wasm_bindgen::prelude::{wasm_bindgen, Closure};
+use wasm_bindgen::prelude::Closure;
 use wasm_bindgen::JsCast;
 use web_sys::{Document, KeyboardEvent, Navigator, PageTransitionEvent, PointerEvent, WheelEvent};
 use web_time::{Duration, Instant};
@@ -495,14 +494,8 @@ impl Shared {
             if let Ok(RunnerEnum::Running(_)) =
                 self.0.runner.try_borrow().as_ref().map(Deref::deref)
             {
-                #[wasm_bindgen]
-                extern "C" {
-                    #[wasm_bindgen(js_name = queueMicrotask)]
-                    fn queue_microtask(task: Function);
-                }
-
-                queue_microtask(
-                    Closure::once_into_js({
+                self.window().queue_microtask(
+                    &Closure::once_into_js({
                         let this = Rc::downgrade(&self.0);
                         move || {
                             if let Some(shared) = this.upgrade() {

src/platform_impl/web/event_loop/window_target.rs

@@ -1,4 +1,3 @@
-use std::any::Any;
 use std::cell::Cell;
 use std::clone::Clone;
 use std::iter;
@@ -12,7 +11,7 @@ use super::event::DeviceId;
 use super::runner::{EventWrapper, WeakShared};
 use super::window::WindowId;
 use super::{backend, runner, EventLoopProxy};
-use crate::error::{ExternalError, NotSupportedError};
+use crate::error::{NotSupportedError, RequestError};
 use crate::event::{
     DeviceId as RootDeviceId, ElementState, Event, FingerId as RootFingerId, KeyEvent, Touch,
     TouchPhase, WindowEvent,
@@ -28,8 +27,7 @@ use crate::platform_impl::platform::cursor::CustomCursor;
 use crate::platform_impl::platform::r#async::Waker;
 use crate::platform_impl::Window;
 use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as RootWindow,
-    WindowId as RootWindowId,
+    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, WindowId as RootWindowId,
 };
 
 #[derive(Default)]
@@ -558,7 +556,7 @@ impl ActiveEventLoop {
                         canvas.set_old_size(new_size);
                         runner.send_event(Event::WindowEvent {
                             window_id: RootWindowId(id),
-                            event: WindowEvent::Resized(new_size),
+                            event: WindowEvent::SurfaceResized(new_size),
                         });
                         canvas.request_animation_frame();
                     }
@@ -608,7 +606,10 @@ impl ActiveEventLoop {
     }
 
     pub(crate) fn has_multiple_screens(&self) -> Result<bool, NotSupportedError> {
-        self.runner.monitor().is_extended().ok_or(NotSupportedError::new())
+        self.runner
+            .monitor()
+            .is_extended()
+            .ok_or(NotSupportedError::new("has_multiple_screens is not supported"))
     }
 
     pub(crate) fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture {
@@ -633,15 +634,15 @@ impl RootActiveEventLoop for ActiveEventLoop {
     fn create_window(
         &self,
         window_attributes: crate::window::WindowAttributes,
-    ) -> Result<crate::window::Window, crate::error::OsError> {
+    ) -> Result<Box<dyn crate::window::Window>, RequestError> {
         let window = Window::new(self, window_attributes)?;
-        Ok(RootWindow { window })
+        Ok(Box::new(window))
     }
 
     fn create_custom_cursor(
         &self,
         source: CustomCursorSource,
-    ) -> Result<RootCustomCursor, ExternalError> {
+    ) -> Result<RootCustomCursor, RequestError> {
         Ok(RootCustomCursor { inner: CustomCursor::new(self, source.inner) })
     }
 
@@ -693,10 +694,6 @@ impl RootActiveEventLoop for ActiveEventLoop {
         RootOwnedDisplayHandle { platform: OwnedDisplayHandle }
     }
 
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
     #[cfg(feature = "rwh_06")]
     fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
         self

src/platform_impl/web/mod.rs

@@ -37,7 +37,6 @@ pub(crate) use cursor::{
     CustomCursorSource as PlatformCustomCursorSource,
 };
 
-pub use self::error::OsError;
 pub use self::event::{DeviceId, FingerId};
 pub(crate) use self::event_loop::{
     ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
@@ -51,4 +50,3 @@ pub(crate) use self::monitor::{
 use self::web_sys as backend;
 pub use self::window::{PlatformSpecificWindowAttributes, Window, WindowId};
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
-pub(crate) use crate::platform_impl::Fullscreen;

src/platform_impl/web/monitor.rs

@@ -29,6 +29,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;
 use crate::platform::web::{
     MonitorPermissionError, Orientation, OrientationData, OrientationLock, OrientationLockError,
 };
@@ -188,6 +189,12 @@ impl PartialOrd for MonitorHandle {
     }
 }
 
+impl From<MonitorHandle> for RootMonitorHandle {
+    fn from(inner: MonitorHandle) -> Self {
+        RootMonitorHandle { inner }
+    }
+}
+
 #[derive(Debug)]
 pub enum OrientationLockFuture {
     Future(Notified<Result<(), OrientationLockError>>),
@@ -322,22 +329,22 @@ impl Inner {
             OrientationType::LandscapePrimary => OrientationData {
                 orientation: Orientation::Landscape,
                 flipped: false,
-                natural: angle == 0,
+                natural: if angle == 0 { Orientation::Landscape } else { Orientation::Portrait },
             },
             OrientationType::LandscapeSecondary => OrientationData {
                 orientation: Orientation::Landscape,
                 flipped: true,
-                natural: angle == 180,
+                natural: if angle == 180 { Orientation::Landscape } else { Orientation::Portrait },
             },
             OrientationType::PortraitPrimary => OrientationData {
                 orientation: Orientation::Portrait,
                 flipped: false,
-                natural: angle == 0,
+                natural: if angle == 0 { Orientation::Portrait } else { Orientation::Landscape },
             },
             OrientationType::PortraitSecondary => OrientationData {
                 orientation: Orientation::Portrait,
                 flipped: true,
-                natural: angle == 180,
+                natural: if angle == 180 { Orientation::Portrait } else { Orientation::Landscape },
             },
             _ => {
                 unreachable!("found unrecognized orientation: {}", orientation.type_string())

src/platform_impl/web/web_sys/canvas.rs

@@ -22,10 +22,10 @@ use super::media_query_handle::MediaQueryListHandle;
 use super::pointer::PointerHandler;
 use super::{event, fullscreen, ButtonsState, ResizeScaleHandle};
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use crate::error::OsError as RootOE;
-use crate::event::{Force, InnerSizeWriter, MouseButton, MouseScrollDelta};
+use crate::error::RequestError;
+use crate::event::{Force, MouseButton, MouseScrollDelta, SurfaceSizeWriter};
 use crate::keyboard::{Key, KeyLocation, ModifiersState, PhysicalKey};
-use crate::platform_impl::{Fullscreen, OsError};
+use crate::platform_impl::Fullscreen;
 use crate::window::{WindowAttributes, WindowId as RootWindowId};
 
 #[allow(dead_code)]
@@ -83,13 +83,13 @@ impl Canvas {
         navigator: Navigator,
         document: Document,
         attr: WindowAttributes,
-    ) -> Result<Self, RootOE> {
+    ) -> Result<Self, RequestError> {
         let canvas = match attr.platform_specific.canvas.map(Arc::try_unwrap) {
             Some(Ok(canvas)) => canvas.into_inner(main_thread),
             Some(Err(canvas)) => canvas.get(main_thread).clone(),
             None => document
                 .create_element("canvas")
-                .map_err(|_| os_error!(OsError("Failed to create canvas element".to_owned())))?
+                .map_err(|_| os_error!("Failed to create canvas element"))?
                 .unchecked_into(),
         };
 
@@ -109,7 +109,7 @@ impl Canvas {
         if attr.platform_specific.focusable {
             canvas
                 .set_attribute("tabindex", "0")
-                .map_err(|_| os_error!(OsError("Failed to set a tabindex".to_owned())))?;
+                .map_err(|_| os_error!("Failed to set a tabindex"))?;
         }
 
         let style = Style::new(&window, &canvas);
@@ -126,17 +126,17 @@ impl Canvas {
             current_size: Rc::default(),
         };
 
-        if let Some(size) = attr.inner_size {
+        if let Some(size) = attr.surface_size {
             let size = size.to_logical(super::scale_factor(&common.window));
             super::set_canvas_size(&common.document, &common.raw, &common.style, size);
         }
 
-        if let Some(size) = attr.min_inner_size {
+        if let Some(size) = attr.min_surface_size {
             let size = size.to_logical(super::scale_factor(&common.window));
             super::set_canvas_min_size(&common.document, &common.raw, &common.style, Some(size));
         }
 
-        if let Some(size) = attr.max_inner_size {
+        if let Some(size) = attr.max_surface_size {
             let size = size.to_logical(super::scale_factor(&common.window));
             super::set_canvas_max_size(&common.document, &common.raw, &common.style, Some(size));
         }
@@ -213,7 +213,7 @@ impl Canvas {
     }
 
     #[inline]
-    pub fn inner_size(&self) -> PhysicalSize<u32> {
+    pub fn surface_size(&self) -> PhysicalSize<u32> {
         self.common.current_size.get()
     }
 
@@ -504,7 +504,7 @@ impl Canvas {
                 window_id: RootWindowId(self.id),
                 event: crate::event::WindowEvent::ScaleFactorChanged {
                     scale_factor: scale,
-                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_size)),
+                    surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_size)),
                 },
             });
 
@@ -513,8 +513,8 @@ impl Canvas {
         };
 
         if current_size != new_size {
-            // Then we resize the canvas to the new size, a new
-            // `Resized` event will be sent by the `ResizeObserver`:
+            // Then we resize the canvas to the new size, a new `SurfaceResized` event will be sent
+            // by the `ResizeObserver`:
             let new_size = new_size.to_logical(scale);
             super::set_canvas_size(self.document(), self.raw(), self.style(), new_size);
 
@@ -530,7 +530,7 @@ impl Canvas {
             self.set_old_size(new_size);
             runner.send_event(crate::event::Event::WindowEvent {
                 window_id: RootWindowId(self.id),
-                event: crate::event::WindowEvent::Resized(new_size),
+                event: crate::event::WindowEvent::SurfaceResized(new_size),
             })
         }
     }

src/platform_impl/web/web_sys/resize_scaling.rs

@@ -138,10 +138,9 @@ impl ResizeScaleInternal {
 
         // Safari doesn't support `devicePixelContentBoxSize`
         if has_device_pixel_support() {
-            observer.observe_with_options(
-                canvas,
-                ResizeObserverOptions::new().box_(ResizeObserverBoxOptions::DevicePixelContentBox),
-            );
+            let options = ResizeObserverOptions::new();
+            options.set_box(ResizeObserverBoxOptions::DevicePixelContentBox);
+            observer.observe_with_options(canvas, &options);
         } else {
             observer.observe(canvas);
         }

src/platform_impl/web/web_sys/schedule.rs

@@ -275,8 +275,8 @@ struct ScriptUrl(String);
 impl ScriptUrl {
     fn new(script: &str) -> Self {
         let sequence = Array::of1(&script.into());
-        let mut property = BlobPropertyBag::new();
-        property.type_("text/javascript");
+        let property = BlobPropertyBag::new();
+        property.set_type("text/javascript");
         let blob = Blob::new_with_str_sequence_and_options(&sequence, &property)
             .expect("`new Blob()` should never throw");
 

src/platform_impl/web/window.rs

@@ -5,15 +5,17 @@ use std::sync::Arc;
 use web_sys::HtmlCanvasElement;
 
 use super::main_thread::{MainThreadMarker, MainThreadSafe};
-use super::monitor::{MonitorHandle, MonitorHandler};
+use super::monitor::MonitorHandler;
 use super::r#async::Dispatcher;
-use super::{backend, lock, ActiveEventLoop, Fullscreen};
+use super::{backend, lock, ActiveEventLoop};
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{ExternalError, NotSupportedError, OsError as RootOE};
+use crate::error::{NotSupportedError, RequestError};
 use crate::icon::Icon;
+use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::window::{
-    Cursor, CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-    WindowAttributes, WindowButtons, WindowId as RootWI, WindowLevel,
+    Cursor, CursorGrabMode, Fullscreen as RootFullscreen, ImePurpose, ResizeDirection, Theme,
+    UserAttentionType, Window as RootWindow, WindowAttributes, WindowButtons, WindowId as RootWI,
+    WindowLevel,
 };
 
 pub struct Window {
@@ -29,7 +31,10 @@ pub struct Inner {
 }
 
 impl Window {
-    pub(crate) fn new(target: &ActiveEventLoop, attr: WindowAttributes) -> Result<Self, RootOE> {
+    pub(crate) fn new(
+        target: &ActiveEventLoop,
+        attr: WindowAttributes,
+    ) -> Result<Self, RequestError> {
         let id = target.generate_id();
 
         let window = target.runner.window();
@@ -65,14 +70,6 @@ impl Window {
         Ok(Window { inner: dispatcher })
     }
 
-    pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Inner) + Send + 'static) {
-        self.inner.dispatch(f)
-    }
-
-    pub(crate) fn maybe_wait_on_main<R: Send>(&self, f: impl FnOnce(&Inner) -> R + Send) -> R {
-        self.inner.queue(f)
-    }
-
     pub fn canvas(&self) -> Option<Ref<'_, HtmlCanvasElement>> {
         MainThreadMarker::new()
             .map(|main_thread| Ref::map(self.inner.value(main_thread), |inner| inner.canvas.raw()))
@@ -91,10 +88,307 @@ impl Window {
             lock::is_cursor_lock_raw(inner.canvas.navigator(), inner.canvas.document())
         })
     }
+}
+
+impl RootWindow for Window {
+    fn id(&self) -> RootWI {
+        RootWI(self.inner.queue(|inner| inner.id))
+    }
+
+    fn scale_factor(&self) -> f64 {
+        self.inner.queue(Inner::scale_factor)
+    }
+
+    fn request_redraw(&self) {
+        self.inner.dispatch(|inner| inner.canvas.request_animation_frame())
+    }
+
+    fn pre_present_notify(&self) {}
+
+    fn reset_dead_keys(&self) {
+        // Not supported
+    }
+
+    fn inner_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        // Note: the canvas element has no window decorations, so this is equal to `outer_position`.
+        self.outer_position()
+    }
+
+    fn outer_position(&self) -> Result<PhysicalPosition<i32>, RequestError> {
+        Ok(self.inner.queue(|inner| inner.canvas.position().to_physical(inner.scale_factor())))
+    }
+
+    fn set_outer_position(&self, position: Position) {
+        self.inner.dispatch(move |inner| {
+            let position = position.to_logical::<f64>(inner.scale_factor());
+            backend::set_canvas_position(
+                inner.canvas.document(),
+                inner.canvas.raw(),
+                inner.canvas.style(),
+                position,
+            )
+        })
+    }
+
+    fn surface_size(&self) -> PhysicalSize<u32> {
+        self.inner.queue(|inner| inner.canvas.surface_size())
+    }
+
+    fn request_surface_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
+        self.inner.queue(|inner| {
+            let size = size.to_logical(self.scale_factor());
+            backend::set_canvas_size(
+                inner.canvas.document(),
+                inner.canvas.raw(),
+                inner.canvas.style(),
+                size,
+            );
+            None
+        })
+    }
+
+    fn outer_size(&self) -> PhysicalSize<u32> {
+        // Note: the canvas element has no window decorations, so this is equal to `surface_size`.
+        self.surface_size()
+    }
+
+    fn set_min_surface_size(&self, min_size: Option<Size>) {
+        self.inner.dispatch(move |inner| {
+            let dimensions = min_size.map(|min_size| min_size.to_logical(inner.scale_factor()));
+            backend::set_canvas_min_size(
+                inner.canvas.document(),
+                inner.canvas.raw(),
+                inner.canvas.style(),
+                dimensions,
+            )
+        })
+    }
+
+    fn set_max_surface_size(&self, max_size: Option<Size>) {
+        self.inner.dispatch(move |inner| {
+            let dimensions = max_size.map(|dimensions| dimensions.to_logical(inner.scale_factor()));
+            backend::set_canvas_max_size(
+                inner.canvas.document(),
+                inner.canvas.raw(),
+                inner.canvas.style(),
+                dimensions,
+            )
+        })
+    }
+
+    fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        None
+    }
+
+    fn set_surface_resize_increments(&self, _: Option<Size>) {
+        // Intentionally a no-op: users can't resize canvas elements
+    }
+
+    fn set_title(&self, title: &str) {
+        self.inner.queue(|inner| inner.canvas.set_attribute("alt", title))
+    }
+
+    fn set_transparent(&self, _: bool) {}
+
+    fn set_blur(&self, _: bool) {}
+
+    fn set_visible(&self, _: bool) {
+        // Intentionally a no-op
+    }
+
+    fn is_visible(&self) -> Option<bool> {
+        None
+    }
+
+    fn set_resizable(&self, _: bool) {
+        // Intentionally a no-op: users can't resize canvas elements
+    }
+
+    fn is_resizable(&self) -> bool {
+        true
+    }
+
+    fn set_enabled_buttons(&self, _: WindowButtons) {}
+
+    fn enabled_buttons(&self) -> WindowButtons {
+        WindowButtons::all()
+    }
+
+    fn set_minimized(&self, _: bool) {
+        // Intentionally a no-op, as canvases cannot be 'minimized'
+    }
+
+    fn is_minimized(&self) -> Option<bool> {
+        // Canvas cannot be 'minimized'
+        Some(false)
+    }
+
+    fn set_maximized(&self, _: bool) {
+        // Intentionally a no-op, as canvases cannot be 'maximized'
+    }
+
+    fn is_maximized(&self) -> bool {
+        // Canvas cannot be 'maximized'
+        false
+    }
+
+    fn set_fullscreen(&self, fullscreen: Option<RootFullscreen>) {
+        self.inner.dispatch(move |inner| {
+            if let Some(fullscreen) = fullscreen {
+                inner.canvas.request_fullscreen(fullscreen.into());
+            } else {
+                inner.canvas.exit_fullscreen()
+            }
+        })
+    }
+
+    fn fullscreen(&self) -> Option<RootFullscreen> {
+        self.inner.queue(|inner| {
+            if inner.canvas.is_fullscreen() {
+                Some(RootFullscreen::Borderless(None))
+            } else {
+                None
+            }
+        })
+    }
+
+    fn set_decorations(&self, _: bool) {
+        // Intentionally a no-op, no canvas decorations
+    }
+
+    fn is_decorated(&self) -> bool {
+        true
+    }
+
+    fn set_window_level(&self, _: WindowLevel) {
+        // Intentionally a no-op, no window ordering
+    }
+
+    fn set_window_icon(&self, _: Option<Icon>) {
+        // Currently an intentional no-op
+    }
+
+    fn set_ime_cursor_area(&self, _: Position, _: Size) {
+        // Currently not implemented
+    }
+
+    fn set_ime_allowed(&self, _: bool) {
+        // Currently not implemented
+    }
+
+    fn set_ime_purpose(&self, _: ImePurpose) {
+        // Currently not implemented
+    }
+
+    fn focus_window(&self) {
+        self.inner.dispatch(|inner| {
+            let _ = inner.canvas.raw().focus();
+        })
+    }
+
+    fn has_focus(&self) -> bool {
+        self.inner.queue(|inner| inner.canvas.has_focus.get())
+    }
+
+    fn request_user_attention(&self, _: Option<UserAttentionType>) {
+        // Currently an intentional no-op
+    }
+
+    fn set_theme(&self, _: Option<Theme>) {}
+
+    fn theme(&self) -> Option<Theme> {
+        self.inner.queue(|inner| {
+            backend::is_dark_mode(&inner.window).map(|is_dark_mode| {
+                if is_dark_mode {
+                    Theme::Dark
+                } else {
+                    Theme::Light
+                }
+            })
+        })
+    }
+
+    fn set_content_protected(&self, _: bool) {}
+
+    fn title(&self) -> String {
+        String::new()
+    }
+
+    fn set_cursor(&self, cursor: Cursor) {
+        self.inner.dispatch(move |inner| inner.canvas.cursor.set_cursor(cursor))
+    }
+
+    fn set_cursor_position(&self, _: Position) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("set_cursor_position is not supported").into())
+    }
+
+    fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), RequestError> {
+        Ok(self.inner.queue(|inner| {
+            match mode {
+                CursorGrabMode::None => inner.canvas.document().exit_pointer_lock(),
+                CursorGrabMode::Locked => lock::request_pointer_lock(
+                    inner.canvas.navigator(),
+                    inner.canvas.document(),
+                    inner.canvas.raw(),
+                ),
+                CursorGrabMode::Confined => {
+                    return Err(NotSupportedError::new("confined cursor mode is not supported"))
+                },
+            }
+
+            Ok(())
+        })?)
+    }
+
+    fn set_cursor_visible(&self, visible: bool) {
+        self.inner.dispatch(move |inner| inner.canvas.cursor.set_cursor_visible(visible))
+    }
+
+    fn drag_window(&self) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("drag_window is not supported").into())
+    }
+
+    fn drag_resize_window(&self, _: ResizeDirection) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("drag_resize_window is not supported").into())
+    }
+
+    fn show_window_menu(&self, _: Position) {}
+
+    fn set_cursor_hittest(&self, _: bool) -> Result<(), RequestError> {
+        Err(NotSupportedError::new("set_cursor_hittest is not supported").into())
+    }
+
+    fn current_monitor(&self) -> Option<RootMonitorHandle> {
+        Some(self.inner.queue(|inner| inner.monitor.current_monitor()).into())
+    }
+
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
+        Box::new(
+            self.inner
+                .queue(|inner| inner.monitor.available_monitors())
+                .into_iter()
+                .map(RootMonitorHandle::from),
+        )
+    }
+
+    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+        self.inner.queue(|inner| inner.monitor.primary_monitor()).map(RootMonitorHandle::from)
+    }
 
     #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
+    fn rwh_06_display_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
+        self
+    }
+
+    #[cfg(feature = "rwh_06")]
+    fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {
+        self
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasWindowHandle for Window {
+    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
         MainThreadMarker::new()
             .map(|main_thread| {
                 let inner = self.inner.value(main_thread);
@@ -102,323 +396,30 @@ impl Window {
                 let canvas: &wasm_bindgen::JsValue = inner.canvas.raw();
                 let window_handle =
                     rwh_06::WebCanvasWindowHandle::new(std::ptr::NonNull::from(canvas).cast());
-                rwh_06::RawWindowHandle::WebCanvas(window_handle)
+                // SAFETY: The pointer won't be invalidated as long as `Window` lives, which the
+                // lifetime is bound to.
+                unsafe {
+                    rwh_06::WindowHandle::borrow_raw(rwh_06::RawWindowHandle::WebCanvas(
+                        window_handle,
+                    ))
+                }
             })
             .ok_or(rwh_06::HandleError::Unavailable)
     }
+}
 
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub(crate) fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::RawDisplayHandle::Web(rwh_06::WebDisplayHandle::new()))
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for Window {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        Ok(rwh_06::DisplayHandle::web())
     }
 }
 
 impl Inner {
-    pub fn set_title(&self, title: &str) {
-        self.canvas.set_attribute("alt", title)
-    }
-
-    pub fn set_transparent(&self, _transparent: bool) {}
-
-    pub fn set_blur(&self, _blur: bool) {}
-
-    pub fn set_visible(&self, _visible: bool) {
-        // Intentionally a no-op
-    }
-
-    #[inline]
-    pub fn is_visible(&self) -> Option<bool> {
-        None
-    }
-
-    pub fn request_redraw(&self) {
-        self.canvas.request_animation_frame();
-    }
-
-    pub fn pre_present_notify(&self) {}
-
-    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        Ok(self.canvas.position().to_physical(self.scale_factor()))
-    }
-
-    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        // Note: the canvas element has no window decorations, so this is equal to `outer_position`.
-        self.outer_position()
-    }
-
-    pub fn set_outer_position(&self, position: Position) {
-        let position = position.to_logical::<f64>(self.scale_factor());
-
-        backend::set_canvas_position(
-            self.canvas.document(),
-            self.canvas.raw(),
-            self.canvas.style(),
-            position,
-        )
-    }
-
-    #[inline]
-    pub fn inner_size(&self) -> PhysicalSize<u32> {
-        self.canvas.inner_size()
-    }
-
-    #[inline]
-    pub fn outer_size(&self) -> PhysicalSize<u32> {
-        // Note: the canvas element has no window decorations, so this is equal to `inner_size`.
-        self.inner_size()
-    }
-
-    #[inline]
-    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
-        let size = size.to_logical(self.scale_factor());
-        backend::set_canvas_size(
-            self.canvas.document(),
-            self.canvas.raw(),
-            self.canvas.style(),
-            size,
-        );
-        None
-    }
-
-    #[inline]
-    pub fn set_min_inner_size(&self, dimensions: Option<Size>) {
-        let dimensions = dimensions.map(|dimensions| dimensions.to_logical(self.scale_factor()));
-        backend::set_canvas_min_size(
-            self.canvas.document(),
-            self.canvas.raw(),
-            self.canvas.style(),
-            dimensions,
-        )
-    }
-
-    #[inline]
-    pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
-        let dimensions = dimensions.map(|dimensions| dimensions.to_logical(self.scale_factor()));
-        backend::set_canvas_max_size(
-            self.canvas.document(),
-            self.canvas.raw(),
-            self.canvas.style(),
-            dimensions,
-        )
-    }
-
-    #[inline]
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
-        None
-    }
-
-    #[inline]
-    pub fn set_resize_increments(&self, _increments: Option<Size>) {
-        // Intentionally a no-op: users can't resize canvas elements
-    }
-
-    #[inline]
-    pub fn set_resizable(&self, _resizable: bool) {
-        // Intentionally a no-op: users can't resize canvas elements
-    }
-
-    pub fn is_resizable(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    pub fn set_enabled_buttons(&self, _buttons: WindowButtons) {}
-
-    #[inline]
-    pub fn enabled_buttons(&self) -> WindowButtons {
-        WindowButtons::all()
-    }
-
     #[inline]
     pub fn scale_factor(&self) -> f64 {
         super::backend::scale_factor(&self.window)
     }
-
-    #[inline]
-    pub fn set_cursor(&self, cursor: Cursor) {
-        self.canvas.cursor.set_cursor(cursor)
-    }
-
-    #[inline]
-    pub fn set_cursor_position(&self, _position: Position) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
-    }
-
-    #[inline]
-    pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
-        match mode {
-            CursorGrabMode::None => self.canvas.document().exit_pointer_lock(),
-            CursorGrabMode::Locked => lock::request_pointer_lock(
-                self.canvas.navigator(),
-                self.canvas.document(),
-                self.canvas.raw(),
-            ),
-            CursorGrabMode::Confined => {
-                return Err(ExternalError::NotSupported(NotSupportedError::new()))
-            },
-        }
-
-        Ok(())
-    }
-
-    #[inline]
-    pub fn set_cursor_visible(&self, visible: bool) {
-        self.canvas.cursor.set_cursor_visible(visible)
-    }
-
-    #[inline]
-    pub fn drag_window(&self) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
-    }
-
-    #[inline]
-    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
-    }
-
-    #[inline]
-    pub fn show_window_menu(&self, _position: Position) {}
-
-    #[inline]
-    pub fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
-    }
-
-    #[inline]
-    pub fn set_minimized(&self, _minimized: bool) {
-        // Intentionally a no-op, as canvases cannot be 'minimized'
-    }
-
-    #[inline]
-    pub fn is_minimized(&self) -> Option<bool> {
-        // Canvas cannot be 'minimized'
-        Some(false)
-    }
-
-    #[inline]
-    pub fn set_maximized(&self, _maximized: bool) {
-        // Intentionally a no-op, as canvases cannot be 'maximized'
-    }
-
-    #[inline]
-    pub fn is_maximized(&self) -> bool {
-        // Canvas cannot be 'maximized'
-        false
-    }
-
-    #[inline]
-    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
-        if self.canvas.is_fullscreen() {
-            Some(Fullscreen::Borderless(None))
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    pub(crate) fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
-        if let Some(fullscreen) = fullscreen {
-            self.canvas.request_fullscreen(fullscreen);
-        } else {
-            self.canvas.exit_fullscreen()
-        }
-    }
-
-    #[inline]
-    pub fn set_decorations(&self, _decorations: bool) {
-        // Intentionally a no-op, no canvas decorations
-    }
-
-    pub fn is_decorated(&self) -> bool {
-        true
-    }
-
-    #[inline]
-    pub fn set_window_level(&self, _level: WindowLevel) {
-        // Intentionally a no-op, no window ordering
-    }
-
-    #[inline]
-    pub fn set_window_icon(&self, _window_icon: Option<Icon>) {
-        // Currently an intentional no-op
-    }
-
-    #[inline]
-    pub fn set_ime_cursor_area(&self, _position: Position, _size: Size) {
-        // Currently not implemented
-    }
-
-    #[inline]
-    pub fn set_ime_allowed(&self, _allowed: bool) {
-        // Currently not implemented
-    }
-
-    #[inline]
-    pub fn set_ime_purpose(&self, _purpose: ImePurpose) {
-        // Currently not implemented
-    }
-
-    #[inline]
-    pub fn focus_window(&self) {
-        let _ = self.canvas.raw().focus();
-    }
-
-    #[inline]
-    pub fn request_user_attention(&self, _request_type: Option<UserAttentionType>) {
-        // Currently an intentional no-op
-    }
-
-    #[inline]
-    pub fn current_monitor(&self) -> Option<MonitorHandle> {
-        Some(self.monitor.current_monitor())
-    }
-
-    #[inline]
-    pub fn available_monitors(&self) -> Vec<MonitorHandle> {
-        self.monitor.available_monitors()
-    }
-
-    #[inline]
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        self.monitor.primary_monitor()
-    }
-
-    #[inline]
-    pub fn id(&self) -> WindowId {
-        self.id
-    }
-
-    #[inline]
-    pub fn set_theme(&self, _theme: Option<Theme>) {}
-
-    #[inline]
-    pub fn theme(&self) -> Option<Theme> {
-        backend::is_dark_mode(&self.window).map(|is_dark_mode| {
-            if is_dark_mode {
-                Theme::Dark
-            } else {
-                Theme::Light
-            }
-        })
-    }
-
-    pub fn set_content_protected(&self, _protected: bool) {}
-
-    #[inline]
-    pub fn has_focus(&self) -> bool {
-        self.canvas.has_focus.get()
-    }
-
-    pub fn title(&self) -> String {
-        String::new()
-    }
-
-    pub fn reset_dead_keys(&self) {
-        // Not supported
-    }
 }
 
 impl Drop for Inner {

src/platform_impl/windows/event_loop.rs

@@ -56,9 +56,9 @@ use super::window::set_skip_taskbar;
 use super::SelectedCursor;
 use crate::application::ApplicationHandler;
 use crate::dpi::{PhysicalPosition, PhysicalSize};
-use crate::error::{EventLoopError, ExternalError, OsError};
+use crate::error::{EventLoopError, RequestError};
 use crate::event::{
-    Event, FingerId as RootFingerId, Force, Ime, InnerSizeWriter, RawKeyEvent, Touch, TouchPhase,
+    Event, FingerId as RootFingerId, Force, Ime, RawKeyEvent, SurfaceSizeWriter, Touch, TouchPhase,
     WindowEvent,
 };
 use crate::event_loop::{
@@ -86,8 +86,8 @@ use crate::platform_impl::platform::{
 use crate::platform_impl::Window;
 use crate::utils::Lazy;
 use crate::window::{
-    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as RootWindow,
-    WindowAttributes, WindowId as RootWindowId,
+    CustomCursor as RootCustomCursor, CustomCursorSource, Theme, Window as CoreWindow,
+    WindowAttributes, WindowId as CoreWindowId,
 };
 
 pub(crate) struct WindowData {
@@ -518,15 +518,17 @@ impl RootActiveEventLoop for ActiveEventLoop {
         RootEventLoopProxy { event_loop_proxy }
     }
 
-    fn create_window(&self, window_attributes: WindowAttributes) -> Result<RootWindow, OsError> {
-        let window = Window::new(self, window_attributes)?;
-        Ok(RootWindow { window })
+    fn create_window(
+        &self,
+        window_attributes: WindowAttributes,
+    ) -> Result<Box<dyn CoreWindow>, RequestError> {
+        Ok(Box::new(Window::new(self, window_attributes)?))
     }
 
     fn create_custom_cursor(
         &self,
         source: CustomCursorSource,
-    ) -> Result<RootCustomCursor, ExternalError> {
+    ) -> Result<RootCustomCursor, RequestError> {
         Ok(RootCustomCursor { inner: WinCursor::new(&source.inner.0)? })
     }
 
@@ -570,10 +572,6 @@ impl RootActiveEventLoop for ActiveEventLoop {
         RootOwnedDisplayHandle { platform: OwnedDisplayHandle }
     }
 
-    fn as_any(&self) -> &dyn std::any::Any {
-        self
-    }
-
     fn rwh_06_handle(&self) -> &dyn rwh_06::HasDisplayHandle {
         self
     }
@@ -922,7 +920,7 @@ fn update_modifiers(window: HWND, userdata: &WindowData) {
         drop(window_state);
 
         userdata.send_event(Event::WindowEvent {
-            window_id: RootWindowId(WindowId(window)),
+            window_id: CoreWindowId(WindowId(window)),
             event: ModifiersChanged(modifiers.into()),
         });
     }
@@ -934,7 +932,7 @@ unsafe fn gain_active_focus(window: HWND, userdata: &WindowData) {
     update_modifiers(window, userdata);
 
     userdata.send_event(Event::WindowEvent {
-        window_id: RootWindowId(WindowId(window)),
+        window_id: CoreWindowId(WindowId(window)),
         event: Focused(true),
     });
 }
@@ -944,12 +942,12 @@ unsafe fn lose_active_focus(window: HWND, userdata: &WindowData) {
 
     userdata.window_state_lock().modifiers_state = ModifiersState::empty();
     userdata.send_event(Event::WindowEvent {
-        window_id: RootWindowId(WindowId(window)),
+        window_id: CoreWindowId(WindowId(window)),
         event: ModifiersChanged(ModifiersState::empty().into()),
     });
 
     userdata.send_event(Event::WindowEvent {
-        window_id: RootWindowId(WindowId(window)),
+        window_id: CoreWindowId(WindowId(window)),
         event: Focused(false),
     });
 }
@@ -1047,7 +1045,7 @@ unsafe fn public_window_callback_inner(
             userdata.key_event_builder.process_message(window, msg, wparam, lparam, &mut result);
         for event in events {
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: KeyboardInput {
                     device_id: DEVICE_ID,
                     event: event.event,
@@ -1132,7 +1130,7 @@ unsafe fn public_window_callback_inner(
         WM_CLOSE => {
             use crate::event::WindowEvent::CloseRequested;
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: CloseRequested,
             });
             result = ProcResult::Value(0);
@@ -1142,7 +1140,7 @@ unsafe fn public_window_callback_inner(
             use crate::event::WindowEvent::Destroyed;
             unsafe { RevokeDragDrop(window) };
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: Destroyed,
             });
             result = ProcResult::Value(0);
@@ -1163,7 +1161,7 @@ unsafe fn public_window_callback_inner(
             // and request a normal redraw with `RedrawWindow`.
             if !userdata.event_loop_runner.should_buffer() {
                 userdata.send_event(Event::WindowEvent {
-                    window_id: RootWindowId(WindowId(window)),
+                    window_id: CoreWindowId(WindowId(window)),
                     event: WindowEvent::RedrawRequested,
                 });
             }
@@ -1266,7 +1264,7 @@ unsafe fn public_window_callback_inner(
                 let physical_position =
                     unsafe { PhysicalPosition::new((*windowpos).x, (*windowpos).y) };
                 userdata.send_event(Event::WindowEvent {
-                    window_id: RootWindowId(WindowId(window)),
+                    window_id: CoreWindowId(WindowId(window)),
                     event: Moved(physical_position),
                 });
             }
@@ -1276,14 +1274,14 @@ unsafe fn public_window_callback_inner(
         },
 
         WM_SIZE => {
-            use crate::event::WindowEvent::Resized;
+            use crate::event::WindowEvent::SurfaceResized;
             let w = super::loword(lparam as u32) as u32;
             let h = super::hiword(lparam as u32) as u32;
 
             let physical_size = PhysicalSize::new(w, h);
             let event = Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
-                event: Resized(physical_size),
+                window_id: CoreWindowId(WindowId(window)),
+                event: SurfaceResized(physical_size),
             };
 
             {
@@ -1310,7 +1308,7 @@ unsafe fn public_window_callback_inner(
             let scale_factor = userdata.window_state_lock().scale_factor;
             let Some(inc) = userdata
                 .window_state_lock()
-                .resize_increments
+                .surface_resize_increments
                 .map(|inc| inc.to_physical(scale_factor))
                 .filter(|inc| inc.width > 0 && inc.height > 0)
             else {
@@ -1397,7 +1395,7 @@ unsafe fn public_window_callback_inner(
                 userdata.window_state_lock().ime_state = ImeState::Enabled;
 
                 userdata.send_event(Event::WindowEvent {
-                    window_id: RootWindowId(WindowId(window)),
+                    window_id: CoreWindowId(WindowId(window)),
                     event: WindowEvent::Ime(Ime::Enabled),
                 });
             }
@@ -1417,7 +1415,7 @@ unsafe fn public_window_callback_inner(
 
                 if lparam == 0 {
                     userdata.send_event(Event::WindowEvent {
-                        window_id: RootWindowId(WindowId(window)),
+                        window_id: CoreWindowId(WindowId(window)),
                         event: WindowEvent::Ime(Ime::Preedit(String::new(), None)),
                     });
                 }
@@ -1429,11 +1427,11 @@ unsafe fn public_window_callback_inner(
                         userdata.window_state_lock().ime_state = ImeState::Enabled;
 
                         userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
+                            window_id: CoreWindowId(WindowId(window)),
                             event: WindowEvent::Ime(Ime::Preedit(String::new(), None)),
                         });
                         userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
+                            window_id: CoreWindowId(WindowId(window)),
                             event: WindowEvent::Ime(Ime::Commit(text)),
                         });
                     }
@@ -1448,7 +1446,7 @@ unsafe fn public_window_callback_inner(
                         let cursor_range = first.map(|f| (f, last.unwrap_or(f)));
 
                         userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
+                            window_id: CoreWindowId(WindowId(window)),
                             event: WindowEvent::Ime(Ime::Preedit(text, cursor_range)),
                         });
                     }
@@ -1471,11 +1469,11 @@ unsafe fn public_window_callback_inner(
                     let ime_context = unsafe { ImeContext::current(window) };
                     if let Some(text) = unsafe { ime_context.get_composed_text() } {
                         userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
+                            window_id: CoreWindowId(WindowId(window)),
                             event: WindowEvent::Ime(Ime::Preedit(String::new(), None)),
                         });
                         userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
+                            window_id: CoreWindowId(WindowId(window)),
                             event: WindowEvent::Ime(Ime::Commit(text)),
                         });
                     }
@@ -1484,7 +1482,7 @@ unsafe fn public_window_callback_inner(
                 userdata.window_state_lock().ime_state = ImeState::Disabled;
 
                 userdata.send_event(Event::WindowEvent {
-                    window_id: RootWindowId(WindowId(window)),
+                    window_id: CoreWindowId(WindowId(window)),
                     event: WindowEvent::Ime(Ime::Disabled),
                 });
             }
@@ -1542,7 +1540,7 @@ unsafe fn public_window_callback_inner(
 
                         drop(w);
                         userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
+                            window_id: CoreWindowId(WindowId(window)),
                             event: CursorEntered { device_id: DEVICE_ID },
                         });
 
@@ -1563,7 +1561,7 @@ unsafe fn public_window_callback_inner(
 
                         drop(w);
                         userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
+                            window_id: CoreWindowId(WindowId(window)),
                             event: CursorLeft { device_id: DEVICE_ID },
                         });
                     },
@@ -1582,7 +1580,7 @@ unsafe fn public_window_callback_inner(
                 update_modifiers(window, userdata);
 
                 userdata.send_event(Event::WindowEvent {
-                    window_id: RootWindowId(WindowId(window)),
+                    window_id: CoreWindowId(WindowId(window)),
                     event: CursorMoved { device_id: DEVICE_ID, position },
                 });
             }
@@ -1598,7 +1596,7 @@ unsafe fn public_window_callback_inner(
             }
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: CursorLeft { device_id: DEVICE_ID },
             });
 
@@ -1614,7 +1612,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: WindowEvent::MouseWheel {
                     device_id: DEVICE_ID,
                     delta: LineDelta(0.0, value),
@@ -1634,7 +1632,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: WindowEvent::MouseWheel {
                     device_id: DEVICE_ID,
                     delta: LineDelta(value, 0.0),
@@ -1669,7 +1667,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: MouseInput { device_id: DEVICE_ID, state: Pressed, button: Left },
             });
             result = ProcResult::Value(0);
@@ -1685,7 +1683,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: MouseInput { device_id: DEVICE_ID, state: Released, button: Left },
             });
             result = ProcResult::Value(0);
@@ -1701,7 +1699,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: MouseInput { device_id: DEVICE_ID, state: Pressed, button: Right },
             });
             result = ProcResult::Value(0);
@@ -1717,7 +1715,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: MouseInput { device_id: DEVICE_ID, state: Released, button: Right },
             });
             result = ProcResult::Value(0);
@@ -1733,7 +1731,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: MouseInput { device_id: DEVICE_ID, state: Pressed, button: Middle },
             });
             result = ProcResult::Value(0);
@@ -1749,7 +1747,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: MouseInput { device_id: DEVICE_ID, state: Released, button: Middle },
             });
             result = ProcResult::Value(0);
@@ -1766,7 +1764,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: MouseInput {
                     device_id: DEVICE_ID,
                     state: Pressed,
@@ -1791,7 +1789,7 @@ unsafe fn public_window_callback_inner(
             update_modifiers(window, userdata);
 
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: MouseInput {
                     device_id: DEVICE_ID,
                     state: Released,
@@ -1840,7 +1838,7 @@ unsafe fn public_window_callback_inner(
                     let y = location.y as f64 + (input.y % 100) as f64 / 100f64;
                     let location = PhysicalPosition::new(x, y);
                     userdata.send_event(Event::WindowEvent {
-                        window_id: RootWindowId(WindowId(window)),
+                        window_id: CoreWindowId(WindowId(window)),
                         event: WindowEvent::Touch(Touch {
                             phase: if util::has_flag(input.dwFlags, TOUCHEVENTF_DOWN) {
                                 TouchPhase::Started
@@ -1988,7 +1986,7 @@ unsafe fn public_window_callback_inner(
                     let y = location.y as f64 + y.fract();
                     let location = PhysicalPosition::new(x, y);
                     userdata.send_event(Event::WindowEvent {
-                        window_id: RootWindowId(WindowId(window)),
+                        window_id: CoreWindowId(WindowId(window)),
                         event: WindowEvent::Touch(Touch {
                             phase: if util::has_flag(pointer_info.pointerFlags, POINTER_FLAG_DOWN) {
                                 TouchPhase::Started
@@ -2133,7 +2131,7 @@ unsafe fn public_window_callback_inner(
             // New size as suggested by Windows.
             let suggested_rect = unsafe { *(lparam as *const RECT) };
 
-            // The window rect provided is the window's outer size, not it's inner size. However,
+            // The window rect provided is the window's outer size, not it's surface size. However,
             // win32 doesn't provide an `UnadjustWindowRectEx` function to get the client rect from
             // the outer rect, so we instead adjust the window rect to get the decoration margins
             // and remove them from the outer size.
@@ -2153,33 +2151,33 @@ unsafe fn public_window_callback_inner(
             let old_physical_inner_rect = util::WindowArea::Inner
                 .get_rect(window)
                 .expect("failed to query (old) inner window area");
-            let old_physical_inner_size = PhysicalSize::new(
+            let old_physical_surface_size = PhysicalSize::new(
                 (old_physical_inner_rect.right - old_physical_inner_rect.left) as u32,
                 (old_physical_inner_rect.bottom - old_physical_inner_rect.top) as u32,
             );
 
             // `allow_resize` prevents us from re-applying DPI adjustment to the restored size after
             // exiting fullscreen (the restored size is already DPI adjusted).
-            let new_physical_inner_size = match allow_resize {
+            let new_physical_surface_size = match allow_resize {
                 // We calculate our own size because the default suggested rect doesn't do a great
                 // job of preserving the window's logical size.
-                true => old_physical_inner_size
+                true => old_physical_surface_size
                     .to_logical::<f64>(old_scale_factor)
                     .to_physical::<u32>(new_scale_factor),
-                false => old_physical_inner_size,
+                false => old_physical_surface_size,
             };
 
-            let new_inner_size = Arc::new(Mutex::new(new_physical_inner_size));
+            let new_surface_size = Arc::new(Mutex::new(new_physical_surface_size));
             userdata.send_event(Event::WindowEvent {
-                window_id: RootWindowId(WindowId(window)),
+                window_id: CoreWindowId(WindowId(window)),
                 event: ScaleFactorChanged {
                     scale_factor: new_scale_factor,
-                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
+                    surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(&new_surface_size)),
                 },
             });
 
-            let new_physical_inner_size = *new_inner_size.lock().unwrap();
-            drop(new_inner_size);
+            let new_physical_surface_size = *new_surface_size.lock().unwrap();
+            drop(new_surface_size);
 
             let dragging_window: bool;
 
@@ -2188,7 +2186,7 @@ unsafe fn public_window_callback_inner(
                 dragging_window =
                     window_state.window_flags().contains(WindowFlags::MARKER_IN_SIZE_MOVE);
                 // Unset maximized if we're changing the window's size.
-                if new_physical_inner_size != old_physical_inner_size {
+                if new_physical_surface_size != old_physical_surface_size {
                     WindowState::set_window_flags(window_state, window, |f| {
                         f.set(WindowFlags::MAXIMIZED, false)
                     });
@@ -2203,8 +2201,8 @@ unsafe fn public_window_callback_inner(
                 let mut conservative_rect = RECT {
                     left: suggested_ul.0,
                     top: suggested_ul.1,
-                    right: suggested_ul.0 + new_physical_inner_size.width as i32,
-                    bottom: suggested_ul.1 + new_physical_inner_size.height as i32,
+                    right: suggested_ul.0 + new_physical_surface_size.width as i32,
+                    bottom: suggested_ul.1 + new_physical_surface_size.height as i32,
                 };
 
                 conservative_rect = window_flags
@@ -2323,7 +2321,7 @@ unsafe fn public_window_callback_inner(
                     window_state.current_theme = new_theme;
                     drop(window_state);
                     userdata.send_event(Event::WindowEvent {
-                        window_id: RootWindowId(WindowId(window)),
+                        window_id: CoreWindowId(WindowId(window)),
                         event: ThemeChanged(new_theme),
                     });
                 }

src/platform_impl/windows/event_loop/runner.rs

@@ -9,7 +9,7 @@ use windows_sys::Win32::Foundation::HWND;
 
 use super::ControlFlow;
 use crate::dpi::PhysicalSize;
-use crate::event::{Event, InnerSizeWriter, StartCause, WindowEvent};
+use crate::event::{Event, StartCause, SurfaceSizeWriter, WindowEvent};
 use crate::platform_impl::platform::event_loop::{WindowData, GWL_USERDATA};
 use crate::platform_impl::platform::get_window_long;
 use crate::window::WindowId;
@@ -357,12 +357,12 @@ impl BufferedEvent {
     pub fn from_event(event: Event) -> BufferedEvent {
         match event {
             Event::WindowEvent {
-                event: WindowEvent::ScaleFactorChanged { scale_factor, inner_size_writer },
+                event: WindowEvent::ScaleFactorChanged { scale_factor, surface_size_writer },
                 window_id,
             } => BufferedEvent::ScaleFactorChanged(
                 window_id,
                 scale_factor,
-                *inner_size_writer.new_inner_size.upgrade().unwrap().lock().unwrap(),
+                *surface_size_writer.new_surface_size.upgrade().unwrap().lock().unwrap(),
             ),
             event => BufferedEvent::Event(event),
         }
@@ -371,29 +371,29 @@ impl BufferedEvent {
     pub fn dispatch_event(self, dispatch: impl FnOnce(Event)) {
         match self {
             Self::Event(event) => dispatch(event),
-            Self::ScaleFactorChanged(window_id, scale_factor, new_inner_size) => {
-                let user_new_innner_size = Arc::new(Mutex::new(new_inner_size));
+            Self::ScaleFactorChanged(window_id, scale_factor, new_surface_size) => {
+                let user_new_surface_size = Arc::new(Mutex::new(new_surface_size));
                 dispatch(Event::WindowEvent {
                     window_id,
                     event: WindowEvent::ScaleFactorChanged {
                         scale_factor,
-                        inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                            &user_new_innner_size,
+                        surface_size_writer: SurfaceSizeWriter::new(Arc::downgrade(
+                            &user_new_surface_size,
                         )),
                     },
                 });
-                let inner_size = *user_new_innner_size.lock().unwrap();
+                let surface_size = *user_new_surface_size.lock().unwrap();
 
-                drop(user_new_innner_size);
+                drop(user_new_surface_size);
 
-                if inner_size != new_inner_size {
+                if surface_size != new_surface_size {
                     let window_flags = unsafe {
                         let userdata =
                             get_window_long(window_id.0.into(), GWL_USERDATA) as *mut WindowData;
                         (*userdata).window_state_lock().window_flags
                     };
 
-                    window_flags.set_size((window_id.0).0, inner_size);
+                    window_flags.set_size((window_id.0).0, surface_size);
                 }
             },
         }

src/platform_impl/windows/icon.rs

@@ -17,7 +17,7 @@ use windows_sys::Win32::UI::WindowsAndMessaging::{
 use super::util;
 use crate::cursor::CursorImage;
 use crate::dpi::PhysicalSize;
-use crate::error::ExternalError;
+use crate::error::RequestError;
 use crate::icon::*;
 
 impl Pixel {
@@ -179,7 +179,7 @@ impl Default for SelectedCursor {
 pub struct WinCursor(pub(super) Arc<RaiiCursor>);
 
 impl WinCursor {
-    pub(crate) fn new(image: &CursorImage) -> Result<Self, ExternalError> {
+    pub(crate) fn new(image: &CursorImage) -> Result<Self, RequestError> {
         let mut bgra = image.rgba.clone();
         bgra.chunks_exact_mut(4).for_each(|chunk| chunk.swap(0, 2));
 
@@ -189,16 +189,16 @@ impl WinCursor {
         unsafe {
             let hdc_screen = GetDC(0);
             if hdc_screen == 0 {
-                return Err(ExternalError::Os(os_error!(io::Error::last_os_error())));
+                return Err(os_error!(io::Error::last_os_error()).into());
             }
             let hbm_color = CreateCompatibleBitmap(hdc_screen, w, h);
             ReleaseDC(0, hdc_screen);
             if hbm_color == 0 {
-                return Err(ExternalError::Os(os_error!(io::Error::last_os_error())));
+                return Err(os_error!(io::Error::last_os_error()).into());
             }
             if SetBitmapBits(hbm_color, bgra.len() as u32, bgra.as_ptr() as *const c_void) == 0 {
                 DeleteObject(hbm_color);
-                return Err(ExternalError::Os(os_error!(io::Error::last_os_error())));
+                return Err(os_error!(io::Error::last_os_error()).into());
             };
 
             // Mask created according to https://learn.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-createbitmap#parameters
@@ -206,7 +206,7 @@ impl WinCursor {
             let hbm_mask = CreateBitmap(w, h, 1, 1, mask_bits.as_ptr() as *const _);
             if hbm_mask == 0 {
                 DeleteObject(hbm_color);
-                return Err(ExternalError::Os(os_error!(io::Error::last_os_error())));
+                return Err(os_error!(io::Error::last_os_error()).into());
             }
 
             let icon_info = ICONINFO {
@@ -221,7 +221,7 @@ impl WinCursor {
             DeleteObject(hbm_color);
             DeleteObject(hbm_mask);
             if handle == 0 {
-                return Err(ExternalError::Os(os_error!(io::Error::last_os_error())));
+                return Err(os_error!(io::Error::last_os_error()).into());
             }
 
             Ok(Self(Arc::new(RaiiCursor { handle })))

src/platform_impl/windows/mod.rs

@@ -103,8 +103,6 @@ fn wrap_device_id(id: u32) -> RootDeviceId {
     RootDeviceId(DeviceId(id))
 }
 
-pub type OsError = std::io::Error;
-
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct KeyEventExtra {
     pub text_with_all_modifiers: Option<SmolStr>,

src/platform_impl/windows/monitor.rs

@@ -16,7 +16,6 @@ use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::monitor::VideoModeHandle as RootVideoModeHandle;
 use crate::platform_impl::platform::dpi::{dpi_to_scale_factor, get_monitor_dpi};
 use crate::platform_impl::platform::util::has_flag;
-use crate::platform_impl::platform::window::Window;
 
 #[derive(Clone)]
 pub struct VideoModeHandle {
@@ -136,17 +135,6 @@ pub fn current_monitor(hwnd: HWND) -> MonitorHandle {
     MonitorHandle::new(hmonitor)
 }
 
-impl Window {
-    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        available_monitors()
-    }
-
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        let monitor = primary_monitor();
-        Some(monitor)
-    }
-}
-
 pub(crate) fn get_monitor_info(hmonitor: HMONITOR) -> Result<MONITORINFOEXW, io::Error> {
     let mut monitor_info: MONITORINFOEXW = unsafe { mem::zeroed() };
     monitor_info.monitorInfo.cbSize = mem::size_of::<MONITORINFOEXW>() as u32;

src/platform_impl/windows/window_state.rs

@@ -30,7 +30,7 @@ pub(crate) struct WindowState {
     pub min_size: Option<Size>,
     pub max_size: Option<Size>,
 
-    pub resize_increments: Option<Size>,
+    pub surface_resize_increments: Option<Size>,
 
     pub window_icon: Option<Icon>,
     pub taskbar_icon: Option<Icon>,
@@ -151,10 +151,10 @@ impl WindowState {
                 last_position: None,
             },
 
-            min_size: attributes.min_inner_size,
-            max_size: attributes.max_inner_size,
+            min_size: attributes.min_surface_size,
+            max_size: attributes.max_surface_size,
 
-            resize_increments: attributes.resize_increments,
+            surface_resize_increments: attributes.surface_resize_increments,
 
             window_icon: attributes.window_icon.clone(),
             taskbar_icon: None,

src/utils.rs

@@ -4,6 +4,7 @@
 // This isn't used on every platform, which can come up as dead code warnings.
 #![allow(dead_code)]
 
+use std::any::Any;
 use std::ops::Deref;
 use std::sync::OnceLock;
 
@@ -26,3 +27,20 @@ impl<T> Deref for Lazy<T> {
         self.cell.get_or_init(self.init)
     }
 }
+
+pub trait AsAny {
+    fn as_any(&self) -> &dyn Any;
+    fn as_any_mut(&mut self) -> &mut dyn Any;
+}
+
+impl<T: Any> AsAny for T {
+    #[inline(always)]
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    #[inline(always)]
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+}

tests/send_objects.rs

@@ -1,5 +1,5 @@
 #[allow(dead_code)]
-fn needs_send<T: Send>() {}
+fn needs_send<T: Send + ?Sized>() {}
 
 #[test]
 fn event_loop_proxy_send() {
@@ -8,7 +8,7 @@ fn event_loop_proxy_send() {
 
 #[test]
 fn window_send() {
-    needs_send::<winit::window::Window>();
+    needs_send::<dyn winit::window::Window>();
 }
 
 #[test]

tests/sync_object.rs

@@ -1,5 +1,5 @@
 #[allow(dead_code)]
-fn needs_sync<T: Sync>() {}
+fn needs_sync<T: Sync + ?Sized>() {}
 
 #[test]
 fn event_loop_proxy_send() {
@@ -8,7 +8,7 @@ fn event_loop_proxy_send() {
 
 #[test]
 fn window_sync() {
-    needs_sync::<winit::window::Window>();
+    needs_sync::<dyn winit::window::Window>();
 }
 
 #[test]