Review comments

Signed-off-by: John Nunley <dev@notgull.net>

.github/CODEOWNERS

@@ -1,6 +1,12 @@
+# Core maintainers:
+# - @msiglreith
+# - @kchibisov
+# - @madsmtm
+# - @maroider
+
 # Android
-/src/platform/android.rs            @msiglreith @MarijnS95
-/src/platform_impl/android          @msiglreith @MarijnS95
+/src/platform/android.rs            @msiglreith
+/src/platform_impl/android          @msiglreith
 
 # iOS
 /src/platform/ios.rs                @madsmtm
@@ -14,14 +20,14 @@
 /src/platform_impl/linux/wayland    @kchibisov
 
 # X11
-/src/platform/x11.rs                @kchibisov @notgull
-/src/platform_impl/linux/x11        @kchibisov @notgull
+/src/platform/x11.rs                @kchibisov
+/src/platform_impl/linux/x11        @kchibisov
 
 # macOS
 /src/platform/macos.rs              @madsmtm
 /src/platform_impl/macos            @madsmtm
 
-# Web
+# Web (no maintainer)
 /src/platform/web.rs                @daxpedda
 /src/platform_impl/web              @daxpedda
 

.github/workflows/ci.yml

@@ -24,7 +24,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        toolchain: [stable, nightly, '1.70.0']
+        toolchain: [stable, nightly, '1.65.0']
         platform:
           # Note: Make sure that we test all the `docs.rs` targets defined in Cargo.toml!
           - { name: 'Windows 64bit MSVC', target: x86_64-pc-windows-msvc,   os: windows-latest,  }
@@ -35,28 +35,20 @@ jobs:
           - { name: 'Linux 64bit',        target: x86_64-unknown-linux-gnu, os: ubuntu-latest,   }
           - { name: 'X11',                target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: '--no-default-features --features=x11' }
           - { 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: '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,   }
-        exclude:
-          # Android is tested on stable-3
-          - toolchain: '1.70.0'
-            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
         include:
-          - toolchain: '1.70.0'
-            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
+          # Android is tested on stable-3
+          - toolchain: '1.69.0'
+            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity' }
+          - toolchain: 'stable'
+            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity' }
           - toolchain: 'nightly'
-            platform: {
-              name:       'web Atomic',
-              target:     wasm32-unknown-unknown,
-              os:         ubuntu-latest,
-              options:    '-Zbuild-std=panic_abort,std',
-              rustflags:  '-Ctarget-feature=+atomics,+bulk-memory',
-              components: rust-src,
-            }
+            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity' }
+
 
     env:
       # Set more verbose terminal output
@@ -64,10 +56,10 @@ jobs:
       RUST_BACKTRACE: 1
 
       # Faster compilation and error on warnings
-      RUSTFLAGS: '--codegen=debuginfo=0 --deny=warnings ${{ matrix.platform.rustflags }}'
+      RUSTFLAGS: '--codegen=debuginfo=0 --deny=warnings'
+      RUSTDOCFLAGS: '--deny=warnings'
 
       OPTIONS: --target=${{ matrix.platform.target }} ${{ matrix.platform.options }}
-      CMD: ${{ matrix.platform.cmd }}
 
     steps:
     - uses: actions/checkout@v3
@@ -89,49 +81,48 @@ jobs:
 
     - name: Generate lockfile
       # Also updates the crates.io index
-      run: cargo generate-lockfile && cargo update -p ahash --precise 0.8.7
+      run: cargo generate-lockfile
 
     - name: Install GCC Multilib
       if: (matrix.platform.os == 'ubuntu-latest') && contains(matrix.platform.target, 'i686')
       run: sudo apt-get update && sudo apt-get install gcc-multilib
 
-    - name: Cache cargo-apk
-      if: contains(matrix.platform.target, 'android')
-      id: cargo-apk-cache
-      uses: actions/cache@v3
+    - name: Install xbuild
+      uses: taiki-e/install-action@v2
+      if: contains(matrix.platform.target, 'android') || contains(matrix.platform.target, 'ios')
       with:
-        path: ~/.cargo/bin/cargo-apk
-        # Change this key if we update the required cargo-apk version
-        key: cargo-apk-v0-9-7
-
-    - uses: dtolnay/rust-toolchain@master
-      if: contains(matrix.platform.target, 'android') && (steps.cargo-apk-cache.outputs.cache-hit != 'true')
-      with:
-        toolchain: stable
-
-    - name: Install cargo-apk
-      if: contains(matrix.platform.target, 'android') && (steps.cargo-apk-cache.outputs.cache-hit != 'true')
-      run: cargo install cargo-apk --version=^0.9.7 --locked
+        tool: xbuild@0.2.0
 
     - uses: dtolnay/rust-toolchain@master
       with:
         toolchain: ${{ matrix.toolchain }}${{ matrix.platform.host }}
         targets: ${{ matrix.platform.target }}
-        components: clippy, ${{ matrix.platform.components }}
+        components: clippy
+
+    - name: Install LLVM tools for Android
+      if: contains(matrix.platform.target, 'android')
+      run: sudo apt-get update && sudo apt-get install lld llvm
 
     - name: Check documentation
       run: cargo doc --no-deps $OPTIONS --document-private-items
-      env:
-        RUSTDOCFLAGS: '--deny=warnings ${{ matrix.platform.rustflags }}'
 
-    - name: Build crate
-      run: cargo $CMD build $OPTIONS
+    - name: Build crate 
+      run: cargo build $OPTIONS
+
+    - name: Build and package crate for Android
+      if: contains(matrix.platform.target, 'android')
+      run: x build -p android-xbuild-target --platform android --arch arm64
+
+    - name: Build and package crate for iOS
+      if: contains(matrix.platform.target, 'ios')
+      run: x build -p ios-xbuild-target --platform ios --arch arm64
 
     - name: Build tests
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
-      run: cargo $CMD test --no-run $OPTIONS
+        !contains(matrix.platform.target, 'android') &&
+        matrix.toolchain != '1.65.0'
+      run: cargo test --no-run $OPTIONS
 
     - name: Run tests
       if: >
@@ -139,8 +130,8 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
-      run: cargo $CMD test $OPTIONS
+        matrix.toolchain != '1.65.0'
+      run: cargo test $OPTIONS
 
     - name: Lint with clippy
       if: (matrix.toolchain == 'stable') && !contains(matrix.platform.options, '--no-default-features')
@@ -149,8 +140,9 @@ jobs:
     - name: Build tests with serde enabled
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
-      run: cargo $CMD test --no-run $OPTIONS --features serde
+        !contains(matrix.platform.target, 'android') &&
+        matrix.toolchain != '1.65.0'
+      run: cargo test --no-run $OPTIONS --features serde
 
     - name: Run tests with serde enabled
       if: >
@@ -158,14 +150,8 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
-      run: cargo $CMD test $OPTIONS --features serde
-
-    - name: Check docs.rs documentation
-      if: matrix.toolchain == 'nightly'
-      run: cargo doc --no-deps $OPTIONS --features=rwh_04,rwh_05,rwh_06,serde,mint,android-native-activity
-      env:
-        RUSTDOCFLAGS: '--deny=warnings ${{ matrix.platform.rustflags }} --cfg=docsrs'
+        matrix.toolchain != '1.65.0'
+      run: cargo test $OPTIONS --features serde
 
     # See restore step above
     - name: Save cache of cargo folder

.github/workflows/docs.yml

@@ -1,50 +0,0 @@
-name: Docs
-
-on:
-  push:
-    branches: [master]
-
-jobs:
-  docs:
-    name: Documentation
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}winit
-
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: read
-      pages: write
-      id-token: write
-    
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: nightly
-
-      - name: Run Rustdoc
-        env:
-          RUSTDOCFLAGS: --crate-version master --cfg=docsrs
-        run: |
-          cargo doc --no-deps -Z rustdoc-map -Z rustdoc-scrape-examples --features=rwh_04,rwh_05,rwh_06,serde,mint,android-native-activity
-
-      - name: Setup Pages
-        uses: actions/configure-pages@v4
-
-      - name: Fix permissions
-        run: |
-          chmod -c -R +rX "target/doc" | while read line; do
-            echo "::warning title=Invalid file permissions automatically fixed::$line"
-          done
-
-      - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
-        with:
-          path: target/doc
-
-      - name: Deploy to GitHub Pages
-        id: deployment
-        uses: actions/deploy-pages@v4

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "deps/apk-builder"]
+	path = deps/apk-builder
+	url = https://github.com/rust-windowing/android-rs-glue

CHANGELOG.md

@@ -2,210 +2,49 @@
 
 All notable changes to this project will be documented in this file.
 
-Please keep one empty line before and after all headers. (This is required for
-`git` to produce a conflict when a release is made while a PR is open and the
-PR's changelog entry would go into the wrong section).
+Please keep one empty line before and after all headers. (This is required for `git` to produce a conflict when a release is made while a PR is open and the PR's changelog entry would go into the wrong section).
 
-And please only add new entries to the top of this list, right below the `#
-Unreleased` header.
+And please only add new entries to the top of this list, right below the `# Unreleased` header.
 
 # Unreleased
 
-- On X11, don't require XIM to run.
-- Fix compatibility with 32-bit platforms without 64-bit atomics.
-- On X11, fix swapped instance and general class names.
-- **Breaking:** Removed unnecessary generic parameter `T` from `EventLoopWindowTarget`.
-- On Windows, macOS, X11, Wayland and Web, implement setting images as cursors. See the `custom_cursors.rs` example.
-  - **Breaking:** Remove `Window::set_cursor_icon`
-  - Add `WindowBuilder::with_cursor` and `Window::set_cursor` which takes a `CursorIcon` or `CustomCursor`
-  - Add `CustomCursor`
-  - Add `CustomCursor::from_rgba` to allow creating cursor images from RGBA data.
-  - Add `CustomCursorExtWebSys::from_url` to allow loading cursor images from URLs.
-  - Add `CustomCursorExtWebSys::from_animation` to allow creating animated cursors from other `CustomCursor`s.
-- On macOS, add services menu.
-- **Breaking:** On Web, remove queuing fullscreen request in absence of transient activation.
-- On Web, fix setting cursor icon overriding cursor visibility.
-- **Breaking:** On Web, return `RawWindowHandle::WebCanvas` instead of `RawWindowHandle::Web`.
-- **Breaking:** On Web, macOS and iOS, return `HandleError::Unavailable` when a window handle is not available.
-- **Breaking:** Bump MSRV from `1.65` to `1.70`.
-- On Web, add the ability to toggle calling `Event.preventDefault()` on `Window`.
-- **Breaking:** Remove `WindowAttributes::fullscreen()` and expose as field directly.
-- **Breaking:** Rename `VideoMode` to `VideoModeHandle` to represent that it doesn't hold static data.
-- **Breaking:** No longer export `platform::x11::XNotSupported`.
-- **Breaking:** Renamed `platform::x11::XWindowType` to `platform::x11::WindowType`.
-- Add the `OwnedDisplayHandle` type for allowing safe display handle usage outside of trivial cases.
-- **Breaking:** Rename `TouchpadMagnify` to `PinchGesture`, `SmartMagnify` to `DoubleTapGesture` and `TouchpadRotate` to `RotationGesture` to represent the action rather than the intent.
-- on iOS, add detection support for `PinchGesture`, `DoubleTapGesture` and `RotationGesture`.
-- on Windows: add `with_system_backdrop`, `with_border_color`, `with_title_background_color`, `with_title_text_color` and `with_corner_preference`
-- On Windows, Remove `WS_CAPTION`, `WS_BORDER` and `WS_EX_WINDOWEDGE` styles for child windows without decorations.
-- On Windows, fixed a race condition when sending an event through the loop proxy.
-- **Breaking:** Removed `EventLoopError::AlreadyRunning`, which can't happen as it is already prevented by the type system.
-- On Wayland, disable `Occluded` event handling.
-- Added `EventLoop::builder`, which is intended to replace the (now deprecated) `EventLoopBuilder::new`.
-- **Breaking:** Changed the signature of `EventLoop::with_user_event` to return a builder.
-- **Breaking:** Removed `EventLoopBuilder::with_user_event`, the functionality is now available in `EventLoop::with_user_event`.
-- Add `Window::builder`, which is intended to replace the (now deprecated) `WindowBuilder::new`.
-- On X11, reload dpi on `_XSETTINGS_SETTINGS` update.
-- On X11, fix deadlock when adjusting DPI and resizing at the same time.
-- On Wayland, fix `Focused(false)` being send when other seats still have window focused.
-- On Wayland, fix `Window::set_{min,max}_inner_size` not always applied.
-- On Windows, fix inconsistent resizing behavior with multi-monitor setups when repositioning outside the event loop.
-- On Wayland, fix `WAYLAND_SOCKET` not used when detecting platform.
-- On Orbital, fix `logical_key` and `text` not reported in `KeyEvent`.
-- On Orbital, implement `KeyEventExtModifierSupplement`.
-- On Orbital, map keys to `NamedKey` when possible.
-- On Orbital, implement `set_cursor_grab`.
-- On Orbital, implement `set_cursor_visible`.
-- On Orbital, implement `drag_window`.
-- On Orbital, implement `drag_resize_window`.
-- On Orbital, implement `set_transparent`.
-- On Orbital, implement `set_visible`.
-- On Orbital, implement `is_visible`.
-- On Orbital, implement `set_resizable`.
-- On Orbital, implement `is_resizable`.
-- On Orbital, implement `set_maximized`.
-- On Orbital, implement `is_maximized`.
-- On Orbital, implement `set_decorations`.
-- On Orbital, implement `is_decorated`.
-- On Orbital, implement `set_window_level`.
-- On Orbital, emit `DeviceEvent::MouseMotion`.
-- On Wayland, fix title in CSD not updated from `AboutToWait`.
-
-# 0.29.10
-
-- On Web, account for canvas being focused already before event loop starts.
-- On Web, increase cursor position accuracy.
-
-# 0.29.9
-
-- On X11, fix `NotSupported` error not propagated when creating event loop.
-- On Wayland, fix resize not issued when scale changes
-- On X11 and Wayland, fix arrow up on keypad reported as `ArrowLeft`.
-- On macOS, report correct logical key when Ctrl or Cmd is pressed.
-
-# 0.29.8
-
-- On X11, fix IME input lagging behind.
-- On X11, fix `ModifiersChanged` not sent from xdotool-like input
-- On X11, fix keymap not updated from xmodmap.
-- On X11, reduce the amount of time spent fetching screen resources.
-- On Wayland, fix `Window::request_inner_size` being overwritten by resize.
-- On Wayland, fix `Window::inner_size` not using the correct rounding.
-
-# 0.29.7
-
-- On X11, fix `Xft.dpi` reload during runtime.
-- On X11, fix window minimize.
-
-# 0.29.6
-
-- On Web, fix context menu not being disabled by `with_prevent_default(true)`.
-- On Wayland, fix `WindowEvent::Destroyed` not being delivered after destroying window.
-- Fix `EventLoopExtRunOnDemand::run_on_demand` not working for consequent invocation
-
-# 0.29.5
-
-- On macOS, remove spurious error logging when handling `Fn`.
-- On X11, fix an issue where floating point data from the server is
-  misinterpreted during a drag and drop operation.
-- On X11, fix a bug where focusing the window would panic.
-- On macOS, fix `refresh_rate_millihertz`.
-- On Wayland, disable Client Side Decorations when `wl_subcompositor` is not supported.
-- On X11, fix `Xft.dpi` detection from Xresources.
-- On Windows, fix consecutive calls to `window.set_fullscreen(Some(Fullscreen::Borderless(None)))` resulting in losing previous window state when eventually exiting fullscreen using `window.set_fullscreen(None)`.
-- On Wayland, fix resize being sent on focus change.
-- On Windows, fix `set_ime_cursor_area`.
-
-# 0.29.4
-
-- Fix crash when running iOS app on macOS.
-- On X11, check common alternative cursor names when loading cursor.
-- On X11, reload the DPI after a property change event.
-- On Windows, fix so `drag_window` and `drag_resize_window` can be called from another thread.
-- On Windows, fix `set_control_flow` in `AboutToWait` not being taken in account.
-- On macOS, send a `Resized` event after each `ScaleFactorChanged` event.
-- On Wayland, fix `wl_surface` being destroyed before associated objects.
-- On macOS, fix assertion when pressing `Fn` key.
-- On Windows, add `WindowBuilderExtWindows::with_clip_children` to control `WS_CLIPCHILDREN` style.
-
-# 0.29.3
-
-- On Wayland, apply correct scale to `PhysicalSize` passed in `WindowBuilder::with_inner_size` when possible.
-- On Wayland, fix `RedrawRequsted` being always sent without decorations and `sctk-adwaita` feature.
-- On Wayland, ignore resize requests when the window is fully tiled.
-- On Wayland, use `configure_bounds` to constrain `with_inner_size` when compositor wants users to pick size.
-- On Windows, fix deadlock when accessing the state during `Cursor{Enter,Leave}`.
-- On Windows, add support for `Window::set_transparent`.
-- On macOS, fix deadlock when entering a nested event loop from an event handler.
-- On macOS, add support for `Window::set_blur`.
-
-# 0.29.2
-
-- **Breaking:** Bump MSRV from `1.60` to `1.65`.
-- **Breaking:** Add `Event::MemoryWarning`; implemented on iOS/Android.
-- **Breaking:** Bump `ndk` version to `0.8.0`, ndk-sys to `0.5.0`, `android-activity` to `0.5.0`.
-- **Breaking:** Change default `ControlFlow` from `Poll` to `Wait`.
+- Renamed `EventLoopExtRunOnDemand` / `run_ondemand` to `EventLoopExtRunOnDemand` / `run_on_demand`.
+- Make iOS `MonitorHandle` and `VideoMode` usable from other threads.
+- On Web, `ControlFlow::WaitUntil` now uses the Prioritized Task Scheduling API. `setTimeout()`, with a trick to circumvent throttling to 4ms, is used as a fallback.
+- On Web, never return a `MonitorHandle`.
 - **Breaking:** Move `Event::RedrawRequested` to `WindowEvent::RedrawRequested`.
-- **Breaking:** Moved `ControlFlow::Exit` to `EventLoopWindowTarget::exit()` and `EventLoopWindowTarget::exiting()` and removed `ControlFlow::ExitWithCode(_)` entirely.
+- On macOS, fix crash in `window.set_minimized(false)`.
+- On Web, enable event propagation and let `DeviceEvent`s appear after `WindowEvent`s.
+- On Web, take all transient activations on the canvas and window into account to queue a fullscreen request.
+- On Web, remove any fullscreen requests from the queue when an external fullscreen activation was detected.
+- On Wayland, fix `TouchPhase::Canceled` being sent for moved events.
+- Mark `startup_notify` unsafe functions as safe.
+- Fix a bug where Wayland would be chosen on Linux even if the user specified `with_x11`. (#3058)
 - **Breaking:** Moved `ControlFlow` to `EventLoopWindowTarget::set_control_flow()` and `EventLoopWindowTarget::control_flow()`.
-- **Breaking:** `EventLoop::new` and `EventLoopBuilder::build` now return `Result<Self, EventLoopError>`
-- **Breaking:** `WINIT_UNIX_BACKEND` was removed in favor of standard `WAYLAND_DISPLAY` and `DISPLAY` variables.
-- **Breaking:** on Wayland, dispatching user created Wayland queue won't wake up the loop unless winit has event to send back.
+- **Breaking:** Moved `ControlFlow::Exit` to `EventLoopWindowTarget::exit()` and `EventLoopWindowTarget::exiting()` and removed `ControlFlow::ExitWithCode(_)` entirely.
+- On Web, add `EventLoopWindowTargetExtWebSys` and `PollStrategy`, which allows to set different strategies for `ControlFlow::Poll`. By default the Prioritized Task Scheduling API is used, but an option to use `Window.requestIdleCallback` is available as well. Both use `setTimeout()`, with a trick to circumvent throttling to 4ms, as a fallback.
+- Implement `PartialOrd` and `Ord` for `MouseButton`.
+- On X11, fix event loop not waking up on `ControlFlow::Poll` and `ControlFlow::WaitUntil`.
+- **Breaking:** Change default `ControlFlow` from `Poll` to `Wait`.
 - **Breaking:** remove `DeviceEvent::Text`.
-- **Breaking:** Remove lifetime parameter from `Event` and `WindowEvent`.
-- **Breaking:** Rename `Window::set_inner_size` to `Window::request_inner_size` and indicate if the size was applied immediately.
-- **Breaking:** `ActivationTokenDone` event which could be requested with the new `startup_notify` module, see its docs for more.
-- **Breaking:** `ScaleFactorChanged` now contains a writer instead of a reference to update inner size.
-- **Breaking** `run() -> !` has been replaced by `run() -> Result<(), EventLoopError>` for returning errors without calling `std::process::exit()` ([#2767](https://github.com/rust-windowing/winit/pull/2767))
-- **Breaking** Removed `EventLoopExtRunReturn` / `run_return` in favor of `EventLoopExtPumpEvents` / `pump_events` and `EventLoopExtRunOnDemand` / `run_on_demand` ([#2767](https://github.com/rust-windowing/winit/pull/2767))
-- `RedrawRequested` is no longer guaranteed to be emitted after `MainEventsCleared`, it is now platform-specific when the event is emitted after being requested via `redraw_request()`.
-  - On Windows, `RedrawRequested` is now driven by `WM_PAINT` messages which are requested via `redraw_request()`
-- **Breaking** `LoopDestroyed` renamed to `LoopExiting` ([#2900](https://github.com/rust-windowing/winit/issues/2900))
-- **Breaking** `RedrawEventsCleared` removed ([#2900](https://github.com/rust-windowing/winit/issues/2900))
-- **Breaking** `MainEventsCleared` removed ([#2900](https://github.com/rust-windowing/winit/issues/2900))
-- **Breaking:** Remove all deprecated `modifiers` fields.
-- **Breaking:** Rename `DeviceEventFilter` to `DeviceEvents` reversing the behavior of variants.
-- **Breaking** Add `AboutToWait` event which is emitted when the event loop is about to block and wait for new events ([#2900](https://github.com/rust-windowing/winit/issues/2900))
-- **Breaking:** Rename `EventLoopWindowTarget::set_device_event_filter` to `listen_device_events`.
-- **Breaking:** Rename `Window::set_ime_position` to `Window::set_ime_cursor_area` adding a way to set exclusive zone.
-- **Breaking:** `with_x11_visual` now takes the visual ID instead of the bare pointer.
-- **Breaking** `MouseButton` now supports `Back` and `Forward` variants, emitted from mouse events on Wayland, X11, Windows, macOS and Web.
-- **Breaking:** On Web, `instant` is now replaced by `web_time`.
-- **Breaking:** On Web, dropped support for Safari versions below 13.1.
-- **Breaking:** On Web, the canvas output bitmap size is no longer adjusted.
-- **Breaking:** On Web, the canvas size is not controlled by Winit anymore and external changes to the canvas size will be reported through `WindowEvent::Resized`.
-- **Breaking:** Updated `bitflags` crate version to `2`, which changes the API on exposed types.
-- **Breaking:** `CursorIcon::Arrow` was removed.
-- **Breaking:** `CursorIcon::Hand` is now named `CursorIcon::Pointer`.
-- **Breaking:** `CursorIcon` is now used from the `cursor-icon` crate.
-- **Breaking:** `WindowExtWebSys::canvas()` now returns an `Option`.
-- **Breaking:** Overhaul keyboard input handling.
-  - Replace `KeyboardInput` with `KeyEvent` and `RawKeyEvent`.
-    - Change `WindowEvent::KeyboardInput` to contain a `KeyEvent`.
-    - Change `Event::Key` to contain a `RawKeyEvent`.
-  - Remove `Event::ReceivedCharacter`. In its place, you should use
-    `KeyEvent.text` in combination with `WindowEvent::Ime`.
-  - Replace `VirtualKeyCode` with the `Key` enum.
-  - Replace `ScanCode` with the `KeyCode` enum.
-  - Rename `ModifiersState::LOGO` to `SUPER` and `ModifiersState::CTRL` to `CONTROL`.
-  - Add `PhysicalKey` wrapping `KeyCode` and `NativeKeyCode`.
-  - Add `KeyCode` to refer to keys (roughly) by their physical location.
-  - Add `NativeKeyCode` to represent raw `KeyCode`s which Winit doesn't
-    understand.
-  - Add `Key` to represent the keys after they've been interpreted by the
-    active (software) keyboard layout.
-  - Add `NamedKey` to represent the categorized keys.
-  - Add `NativeKey` to represent raw `Key`s which Winit doesn't understand.
-  - Add `KeyLocation` to tell apart `Key`s which usually "mean" the same thing,
-    but can appear simultaneously in different spots on the same keyboard
-    layout.
-  - Add `Window::reset_dead_keys` to enable application-controlled cancellation
-    of dead key sequences.
-  - Add `KeyEventExtModifierSupplement` to expose additional (and less
-    portable) interpretations of a given key-press.
-  - Add `PhysicalKeyExtScancode`, which lets you convert between scancodes and
-    `PhysicalKey`.
-  - `ModifiersChanged` now uses dedicated `Modifiers` struct.
+- On Android, fix `DeviceId` to contain device id's.
+- Add `Window::set_blur` to request a blur behind the window; implemented on Wayland for now.
+- On Web, fix `ControlFlow::WaitUntil` to never wake up **before** the given time.
+- Add `Window::show_window_menu` to request a titlebar/system menu; implemented on Wayland/Windows for now.
+- On iOS, send events `WindowEvent::Occluded(false)`, `WindowEvent::Occluded(true)` when application enters/leaves foreground.
+- **Breaking** add `Event::MemoryWarning`; implemented on iOS/Android.
+- On Wayland, support `Occluded` event with xdg-shell v6
+
+# 0.29.1-beta
+
+- **Breaking:** Bump `ndk` version to `0.8.0-beta.0`, ndk-sys to `v0.5.0-beta.0`, `android-activity` to `0.5.0-beta.1`.
+- **Breaking:** Bump MSRV from `1.64` to `1.65`.
+- Make iOS windows usable from other threads.
+- Reexport `raw-window-handle` in `window` module.
+- **Breaking:** `WINIT_UNIX_BACKEND` was removed in favor of standard `WAYLAND_DISPLAY` and `DISPLAY` variables.
+- **Breaking:** `EventLoop::new` and `EventLoopBuilder::build` now return `Result<Self, EventLoopError>`
+- On X11, set `visual_id` in returned `raw-window-handle`.
+- **Breaking:** on Wayland, dispatching user created wayland queue won't wake up the loop unless winit has event to send back.
 - Removed platform-specific extensions that should be retrieved through `raw-window-handle` trait implementations instead:
   - `platform::windows::HINSTANCE`.
   - `WindowExtWindows::hinstance`.
@@ -222,89 +61,126 @@ Unreleased` header.
   - `WindowExtX11::xlib_display`.
   - `WindowExtX11::xlib_screen_id`.
   - `WindowExtX11::xcb_connection`.
-- Reexport `raw-window-handle` in `window` module.
-- Add `ElementState::is_pressed`.
-- Add `Window::pre_present_notify` to notify winit before presenting to the windowing system.
-- Add `Window::set_blur` to request a blur behind the window; implemented on Wayland for now.
-- Add `Window::show_window_menu` to request a titlebar/system menu; implemented on Wayland/Windows for now.
-- Implement `AsFd`/`AsRawFd` for `EventLoop<T>` on X11 and Wayland.
-- Implement `PartialOrd` and `Ord` for `MouseButton`.
-- Implement `PartialOrd` and `Ord` on types in the `dpi` module.
-- Make `WindowBuilder` `Send + Sync`.
-- Make iOS `MonitorHandle` and `VideoMode` usable from other threads.
-- Make iOS windows usable from other threads.
-- On Android, add force data to touch events.
-- On Android, added `EventLoopBuilderExtAndroid::handle_volume_keys` to indicate that the application will handle the volume keys manually.
-- On Android, fix `DeviceId` to contain device id's.
-- On Orbital, fix `ModifiersChanged` not being sent.
-- On Wayland, `Window::outer_size` now accounts for **client side** decorations.
-- On Wayland, add `Window::drag_resize_window` method.
-- On Wayland, remove `WINIT_WAYLAND_CSD_THEME` variable.
-- On Wayland, fix `TouchPhase::Canceled` being sent for moved events.
-- On Wayland, fix forward compatibility issues.
-- On Wayland, fix initial window size not restored for maximized/fullscreened on startup window.
-- On Wayland, fix maximized startup not taking full size on GNOME.
-- On Wayland, fix maximized window creation and window geometry handling.
-- On Wayland, fix window not checking that it actually got initial configure event.
-- On Wayland, make double clicking and moving the CSD frame more reliable.
-- On Wayland, support `Occluded` event with xdg-shell v6
+- On Web, use `Window.requestAnimationFrame()` to throttle `RedrawRequested` events.
 - On Wayland, use frame callbacks to throttle `RedrawRequested` events so redraws will align with compositor.
-- On Web, `ControlFlow::WaitUntil` now uses the Prioritized Task Scheduling API. `setTimeout()`, with a trick to circumvent throttling to 4ms, is used as a fallback.
-- On Web, `EventLoopProxy` now implements `Send`.
-- On Web, `Window` now implements `Send` and `Sync`.
+- Add `Window::pre_present_notify` to notify winit before presenting to the windowing system.
+- On Windows, added `WindowBuilderExtWindows::with_class_name` to customize the internal class name.
+- **Breaking:** Remove lifetime parameter from `Event` and `WindowEvent`.
+- **Breaking:** `ScaleFactorChanged` now contains a writer instead of a reference to update inner size.
+- On iOS, always wake the event loop when transitioning from `ControlFlow::Poll` to `ControlFlow::Poll`.
+- **Breaking:** `ActivationTokenDone` event which could be requested with the new `startup_notify` module, see its docs for more.
+- On Wayland, make double clicking and moving the CSD frame more reliable.
+- On macOS, add tabbing APIs on `WindowExtMacOS` and `EventLoopWindowTargetExtMacOS`.
+- **Breaking:** Rename `Window::set_inner_size` to `Window::request_inner_size` and indicate if the size was applied immediately.
+- On X11, fix false positive flagging of key repeats when pressing different keys with no release between presses.
+- Implement `PartialOrd` and `Ord` for `Key`, `KeyCode`, `NativeKey`, and `NativeKeyCode`.
+- Add `ElementState::is_pressed`.
+- On Web, implement `WindowEvent::Occluded`.
+- On Web, fix touch location to be as accurate as mouse position.
 - On Web, account for CSS `padding`, `border`, and `margin` when getting or setting the canvas position.
 - On Web, add Fullscreen API compatibility for Safari.
-- On Web, add `DeviceEvent::Motion`, `DeviceEvent::MouseWheel`, `DeviceEvent::Button` and `DeviceEvent::Key` support.
-- On Web, add `EventLoopWindowTargetExtWebSys` and `PollStrategy`, which allows to set different strategies for `ControlFlow::Poll`. By default the Prioritized Task Scheduling API is used, but an option to use `Window.requestIdleCallback` is available as well. Both use `setTimeout()`, with a trick to circumvent throttling to 4ms, as a fallback.
-- On Web, add `WindowBuilderExtWebSys::with_append()` to append the canvas element to the web page on creation.
-- On Web, allow event loops to be recreated with `spawn`.
-- On Web, enable event propagation.
-- On Web, fix `ControlFlow::WaitUntil` to never wake up **before** the given time.
-- On Web, fix `DeviceEvent::MouseMotion` only being emitted for each canvas instead of the whole window.
-- On Web, fix `Window:::set_fullscreen` doing nothing when called outside the event loop but during transient activation.
-- On Web, fix pen treated as mouse input.
-- On Web, fix pointer button events not being processed when a buttons is already pressed.
-- On Web, fix scale factor resize suggestion always overwriting the canvas size.
-- On Web, fix some `WindowBuilder` methods doing nothing.
-- On Web, fix some `Window` methods using incorrect HTML attributes instead of CSS properties.
-- On Web, fix the bfcache by not using the `beforeunload` event and map bfcache loading/unloading to `Suspended`/`Resumed` events.
-- On Web, fix touch input not gaining or loosing focus.
-- On Web, fix touch location to be as accurate as mouse position.
-- On Web, handle coalesced pointer events, which increases the resolution of pointer inputs.
-- On Web, implement `Window::focus_window()`.
 - On Web, implement `Window::set_(min|max)_inner_size()`.
-- On Web, implement `WindowEvent::Occluded`.
-- On Web, never return a `MonitorHandle`.
-- On Web, prevent clicks on the canvas to select text.
-- On Web, remove any fullscreen requests from the queue when an external fullscreen activation was detected.
+- On Web, fix some `Window` methods using incorrect HTML attributes instead of CSS properties.
+- On Web, fix some `WindowBuilder` methods doing nothing.
+- On Web, implement `Window::focus_window()`.
 - On Web, remove unnecessary `Window::is_dark_mode()`, which was replaced with `Window::theme()`.
-- On Web, respect `EventLoopWindowTarget::listen_device_events()` settings.
-- On Web, scale factor and dark mode detection are now more robust.
-- On Web, send mouse position on button release as well.
-- On Web, take all transient activations on the canvas and window into account to queue a fullscreen request.
-- On Web, use `Window.requestAnimationFrame()` to throttle `RedrawRequested` events.
-- On Web, use the correct canvas size when calculating the new size during scale factor change, instead of using the output bitmap size.
+- On Web, add `WindowBuilderExtWebSys::with_append()` to append the canvas element to the web page on creation.
+- On Windows, add `drag_resize_window` method support.
+- **Breaking** `run() ->!` has been replaced by `run() -> Result<(), EventLoopError>` for returning errors without calling `std::process::exit()` ([#2767](https://github.com/rust-windowing/winit/pull/2767))
+- **Breaking** Removed `EventLoopExtRunReturn` / `run_return` in favor of `EventLoopExtPumpEvents` / `pump_events` and `EventLoopExtRunOnDemand` / `run_ondemand` ([#2767](https://github.com/rust-windowing/winit/pull/2767))
+- `RedrawRequested` is no longer guaranteed to be emitted after `MainEventsCleared`, it is now platform-specific when the event is emitted after being requested via `redraw_request()`.
+  - On Windows, `RedrawRequested` is now driven by `WM_PAINT` messages which are requested via `redraw_request()`
+- **Breaking** `LoopDestroyed` renamed to `LoopExiting` ([#2900](https://github.com/rust-windowing/winit/issues/2900))
+- **Breaking** `RedrawEventsCleared` removed ([#2900](https://github.com/rust-windowing/winit/issues/2900))
+- **Breaking** `MainEventsCleared` removed ([#2900](https://github.com/rust-windowing/winit/issues/2900))
+- Added `AboutToWait` event which is emitted when the event loop is about to block and wait for new events ([#2900](https://github.com/rust-windowing/winit/issues/2900))
+- **Breaking:** `with_x11_visual` now takes the visual ID instead of the bare pointer.
+- On X11, add a `with_embedded_parent_window` function to the window builder to allow embedding a window into another window.
+- On iOS, add force data to touch events when using the Apple Pencil.
+- On Android, add force data to touch events.
+
+# 0.29.0-beta.0
+
+- On Web, allow event loops to be recreated with `spawn`.
+- **Breaking:** Rename `Window::set_ime_position` to `Window::set_ime_cursor_area` adding a way to set exclusive zone.
+- On Android, changed default behavior of Android to ignore volume keys letting the operating system handle them.
+- On Android, added `EventLoopBuilderExtAndroid::handle_volume_keys` to indicate that the application will handle the volume keys manually.
+- **Breaking:** Rename `DeviceEventFilter` to `DeviceEvents` reversing the behavior of variants.
+- **Breaking:** Rename `EventLoopWindowTarget::set_device_event_filter` to `listen_device_events`.
+- On X11, fix `EventLoopWindowTarget::listen_device_events` effect being reversed.
+- **Breaking:** Remove all deprecated `modifiers` fields.
+- **Breaking:** Overhaul keyboard input handling.
+  - Replace `KeyboardInput` with `KeyEvent` and `RawKeyEvent`.
+    - Change `WindowEvent::KeyboardInput` to contain a `KeyEvent`.
+    - Change `Event::Key` to contain a `RawKeyEvent`.
+  - Remove `Event::ReceivedCharacter`. In its place, you should use
+    `KeyEvent.text` in combination with `WindowEvent::Ime`.
+  - Replace `VirtualKeyCode` with the `Key` enum.
+  - Replace `ScanCode` with the `KeyCode` enum.
+  - Rename `ModifiersState::LOGO` to `SUPER` and `ModifiersState::CTRL` to `CONTROL`.
+  - Add `KeyCode` to refer to keys (roughly) by their physical location.
+  - Add `NativeKeyCode` to represent raw `KeyCode`s which Winit doesn't
+    understand.
+  - Add `Key` to represent the keys after they've been interpreted by the
+    active (software) keyboard layout.
+  - Add `NativeKey` to represent raw `Key`s which Winit doesn't understand.
+  - Add `KeyLocation` to tell apart `Key`s which usually "mean" the same thing,
+    but can appear simultaneously in different spots on the same keyboard
+    layout.
+  - Add `Window::reset_dead_keys` to enable application-controlled cancellation
+    of dead key sequences.
+  - Add `KeyEventExtModifierSupplement` to expose additional (and less
+    portable) interpretations of a given key-press.
+  - Add `KeyCodeExtScancode`, which lets you convert between raw keycodes and
+    `KeyCode`.
+  - `ModifiersChanged` now uses dedicated `Modifiers` struct.
+- On Orbital, fix `ModifiersChanged` not being sent.
+- **Breaking:** `CursorIcon` is now used from the `cursor-icon` crate.
+- **Breaking:** `CursorIcon::Hand` is now named `CursorIcon::Pointer`.
+- **Breaking:** `CursorIcon::Arrow` was removed.
+- On Wayland, fix maximized startup not taking full size on GNOME.
+- On Wayland, fix initial window size not restored for maximized/fullscreened on startup window.
+- On Wayland, `Window::outer_size` now accounts for **client side** decorations.
+- On Wayland, fix window not checking that it actually got initial configure event.
+- On Wayland, fix maximized window creation and window geometry handling.
+- On Wayland, fix forward compatibility issues.
+- On Wayland, add `Window::drag_resize_window` method.
+- On Wayland, drop `WINIT_WAYLAND_CSD_THEME` variable.
+- Implement `PartialOrd` and `Ord` on types in the `dpi` module.
+- **Breaking:** Bump MSRV from `1.60` to `1.64`.
+- **Breaking:** On Web, the canvas output bitmap size is no longer adjusted.
 - On Web: fix `Window::request_redraw` not waking the event loop when called from outside the loop.
 - On Web: fix position of touch events to be relative to the canvas.
-- On Windows, add `drag_resize_window` method support.
-- On Windows, add horizontal MouseWheel `DeviceEvent`.
-- On Windows, added `WindowBuilderExtWindows::with_class_name` to customize the internal class name.
-- On Windows, fix IME APIs not working when from non event loop thread.
-- On Windows, fix `CursorEnter/Left` not being sent when grabbing the mouse.
-- On Windows, fix `RedrawRequested` not being delivered when calling `Window::request_redraw` from `RedrawRequested`.
+- On Web, fix `Window:::set_fullscreen` doing nothing when called outside the event loop but during
+  a transient activation.
+- On Web, fix pointer button events not being processed when a buttons is already pressed.
+- **Breaking:** Updated `bitflags` crate version to `2`, which changes the API on exposed types.
+- On Web, handle coalesced pointer events, which increases the resolution of pointer inputs.
+- **Breaking:** On Web, `instant` is now replaced by `web_time`.
 - On Windows, port to `windows-sys` version 0.48.0.
-- On X11, add a `with_embedded_parent_window` function to the window builder to allow embedding a window into another window.
-- On X11, fix event loop not waking up on `ControlFlow::Poll` and `ControlFlow::WaitUntil`.
-- On X11, fix false positive flagging of key repeats when pressing different keys with no release between presses.
-- On X11, set `visual_id` in returned `raw-window-handle`.
-- On iOS, add ability to change the status bar style.
-- On iOS, add force data to touch events when using the Apple Pencil.
-- On iOS, always wake the event loop when transitioning from `ControlFlow::Poll` to `ControlFlow::Poll`.
-- On iOS, send events `WindowEvent::Occluded(false)`, `WindowEvent::Occluded(true)` when application enters/leaves foreground.
-- On macOS, add tabbing APIs on `WindowExtMacOS` and `EventLoopWindowTargetExtMacOS`.
-- On macOS, fix assertion when pressing `Globe` key.
-- On macOS, fix crash in `window.set_minimized(false)`.
+- On Web, fix pen treated as mouse input.
+- On Web, send mouse position on button release as well.
+- On Web, fix touch input not gaining or loosing focus.
+- **Breaking:** On Web, dropped support for Safari versions below 13.1.
+- On Web, prevent clicks on the canvas to select text.
+- On Web, `EventLoopProxy` now implements `Send`.
+- On Web, `Window` now implements `Send` and `Sync`.
+- **Breaking:** `WindowExtWebSys::canvas()` now returns an `Option`.
+- On Web, use the correct canvas size when calculating the new size during scale factor change,
+  instead of using the output bitmap size.
+- On Web, scale factor and dark mode detection are now more robust.
+- On Web, fix the bfcache by not using the `beforeunload` event and map bfcache loading/unloading to `Suspended`/`Resumed` events.
+- On Web, fix scale factor resize suggestion always overwriting the canvas size.
 - On macOS, fix crash when dropping `Window`.
+- On Web, use `Window.requestIdleCallback()` for `ControlFlow::Poll` when available.
+- **Breaking:** On Web, the canvas size is not controlled by Winit anymore and external changes to
+  the canvas size will be reported through `WindowEvent::Resized`.
+- On Web, respect `EventLoopWindowTarget::listen_device_events()` settings.
+- On Web, fix `DeviceEvent::MouseMotion` only being emitted for each canvas instead of the whole window.
+- On Web, add `DeviceEvent::Motion`, `DeviceEvent::MouseWheel`, `DeviceEvent::Button` and
+  `DeviceEvent::Key` support.
+- **Breaking** `MouseButton` now supports `Back` and `Forward` variants, emitted from mouse events
+  on Wayland, X11, Windows, macOS and Web.
 
 # 0.28.7
 

CONTRIBUTING.md

@@ -11,7 +11,7 @@ may be worth creating a separate crate that extends Winit's API to add that func
 When reporting an issue, in order to help the maintainers understand what the problem is, please make
 your description of the issue as detailed as possible:
 
-- if it is a bug, please provide a clear explanation of what happens, what should happen, and how to
+- if it is a bug, please provide clear explanation of what happens, what should happen, and how to
   reproduce the issue, ideally by providing a minimal program exhibiting the problem
 - if it is a feature request, please provide a clear argumentation about why you believe this feature
   should be supported by winit
@@ -20,8 +20,8 @@ your description of the issue as detailed as possible:
 
 When making a code contribution to winit, before opening your pull request, please make sure that:
 
-- your patch builds with Winit's minimal supported rust version - Rust 1.70.
-- you tested your modifications on all the platforms impacted, or if not possible, detail which platforms
+- your patch builds with Winit's minimal supported rust version - Rust 1.65.
+- you tested your modifications on all the platforms impacted, or if not possible detail which platforms
   were not tested, and what should be tested, so that a maintainer or another contributor can test them
 - you updated any relevant documentation in winit
 - you left comments in your code explaining any part that is not straightforward, so that the
@@ -34,7 +34,7 @@ When making a code contribution to winit, before opening your pull request, plea
   relevant sections in [`FEATURES.md`](https://github.com/rust-windowing/winit/blob/master/FEATURES.md#features)
   should be updated.
 
-Once your PR is open, you can ask for a review by a maintainer of your platform. Winit's merging policy
+Once your PR is open, you can ask for review by a maintainer of your platform. Winit's merging policy
 is that a PR must be approved by at least two maintainers of winit before being merged, including
 at least a maintainer of the platform (a maintainer making a PR themselves counts as approving it).
 
@@ -46,26 +46,27 @@ Once your PR is deemed ready, the merging maintainer will take care of resolving
 
 The current maintainers are listed in the [CODEOWNERS](.github/CODEOWNERS) file.
 
-If you are interested in being pinged when testing is needed for a specific platform, please add yourself to the [Testers and Contributors](https://github.com/rust-windowing/winit/wiki/Testers-and-Contributors) table!
+If you are interested in being pinged when testing is needed for a certain platform, please add yourself to the [Testers and Contributors](https://github.com/rust-windowing/winit/wiki/Testers-and-Contributors) table!
 
 ## Release process
 
-Given that winit is a widely used library, we should be able to make a patch
+Given that winit is a widely used library we should be able to make a patch
 releases at any time we want without blocking the development of new features.
 
-To achieve these goals, a new branch is created for every new release. Releases and later patch releases are committed and tagged in this branch.
+To achieve these goals, a new branch is created for every new release. Releases
+and later patch releases are committed and tagged in this branch.
 
 The exact steps for an exemplary `0.2.0` release might look like this:
-  1. Initially, the version on the latest master is `0.1.0`
+  1. Initially the version on the latest master is `0.1.0`
   2. A new `v0.2.x` branch is created for the release
   3. In the branch, the version is bumped to `v0.2.0`
   4. The new commit in the branch is tagged `v0.2.0`
   5. The version is pushed to crates.io
   6. A GitHub release is created for the `v0.2.0` tag
-  7. On master, the version is bumped to `0.2.0`, and the CHANGELOG is updated
+  7. On master, the version is bumped to `0.2.0` and the CHANGELOG is updated
   
-When doing a patch release, the process is similar:
-  1. Initially, the version of the latest release is `0.2.0`
+When doing a patch release the process is similar:
+  1. Initially the version of the latest release is `0.2.0`
   2. Checkout the `v0.2.x` branch
   3. Cherry-pick the required non-breaking changes into the `v0.2.x`
   4. Follow steps 3-7 of the regular release example

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.29.10"
+version = "0.29.1-beta"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 edition = "2021"
@@ -10,18 +10,10 @@ readme = "README.md"
 repository = "https://github.com/rust-windowing/winit"
 documentation = "https://docs.rs/winit"
 categories = ["gui"]
-rust-version = "1.70.0"
+rust-version = "1.65.0"
 
 [package.metadata.docs.rs]
-features = [
-    "rwh_04",
-    "rwh_05",
-    "rwh_06",
-    "serde",
-    "mint",
-    # Enabled to get docs to compile
-    "android-native-activity",
-]
+features = ["rwh_04", "rwh_05", "rwh_06", "serde"]
 default-target = "x86_64-unknown-linux-gnu"
 # These are all tested in CI
 targets = [
@@ -37,7 +29,7 @@ targets = [
     "x86_64-apple-ios",
     # Android
     "aarch64-linux-android",
-    # Web
+    # WebAssembly
     "wasm32-unknown-unknown",
 ]
 rustdoc-args = ["--cfg", "docsrs"]
@@ -53,47 +45,44 @@ wayland-csd-adwaita-notitle = ["sctk-adwaita"]
 android-native-activity = ["android-activity/native-activity"]
 android-game-activity = ["android-activity/game-activity"]
 serde = ["dep:serde", "cursor-icon/serde", "smol_str/serde"]
-rwh_04 = ["dep:rwh_04", "ndk/rwh_04"]
-rwh_05 = ["dep:rwh_05", "ndk/rwh_05"]
-rwh_06 = ["dep:rwh_06", "ndk/rwh_06"]
 
 [build-dependencies]
-cfg_aliases = "0.2.0"
+cfg_aliases = "0.1.1"
 
 [dependencies]
 bitflags = "2"
-cursor-icon = "1.1.0"
+cursor-icon = "1.0.0"
 log = "0.4"
 mint = { version = "0.5.6", optional = true }
 once_cell = "1.12"
 rwh_04 = { package = "raw-window-handle", version = "0.4", optional = true }
-rwh_05 = { package = "raw-window-handle", version = "0.5.2", features = ["std"], optional = true }
+rwh_05 = { package = "raw-window-handle", version = "0.5", features = ["std"], optional = true }
 rwh_06 = { package = "raw-window-handle", version = "0.6", features = ["std"], optional = true }
 serde = { version = "1", optional = true, features = ["serde_derive"] }
 smol_str = "0.2.0"
 
 [dev-dependencies]
 image = { version = "0.24.0", default-features = false, features = ["png"] }
-simple_logger = { version = "4.2.0", default_features = false }
-winit = { path = ".", features = ["rwh_05"] }
+simple_logger = { version = "2.1.0", default_features = false }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dev-dependencies]
-softbuffer = { version = "0.3.0", default-features = false, features = ["x11", "x11-dlopen", "wayland", "wayland-dlopen"] }
+softbuffer = "0.3.0"
 
 [target.'cfg(target_os = "android")'.dependencies]
-android-activity = "0.5.0"
-ndk = { version = "0.8.0", default-features = false }
-ndk-sys = "0.5.0"
+# Coordinate the next winit release android-activity 0.5 release
+android-activity = "=0.5.0-beta.1"
+ndk = "=0.8.0-beta.0"
+ndk-sys = "=0.5.0-beta.0"
 
 [target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
 core-foundation = "0.9.3"
-objc2 = "0.5.0"
+objc2 = "0.4.1"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-graphics = "0.23.1"
 
 [target.'cfg(target_os = "macos")'.dependencies.icrate]
-version = "0.1.0"
+version = "0.0.4"
 features = [
     "dispatch",
     "Foundation",
@@ -106,31 +95,10 @@ features = [
     "Foundation_NSProcessInfo",
     "Foundation_NSThread",
     "Foundation_NSNumber",
-    "AppKit",
-    "AppKit_NSAppearance",
-    "AppKit_NSApplication",
-    "AppKit_NSBitmapImageRep",
-    "AppKit_NSButton",
-    "AppKit_NSColor",
-    "AppKit_NSControl",
-    "AppKit_NSCursor",
-    "AppKit_NSEvent",
-    "AppKit_NSGraphicsContext",
-    "AppKit_NSImage",
-    "AppKit_NSImageRep",
-    "AppKit_NSMenu",
-    "AppKit_NSMenuItem",
-    "AppKit_NSPasteboard",
-    "AppKit_NSResponder",
-    "AppKit_NSScreen",
-    "AppKit_NSTextInputContext",
-    "AppKit_NSView",
-    "AppKit_NSWindow",
-    "AppKit_NSWindowTabGroup",
 ]
 
 [target.'cfg(target_os = "ios")'.dependencies.icrate]
-version = "0.1.0"
+version = "0.0.4"
 features = [
     "dispatch",
     "Foundation",
@@ -174,7 +142,7 @@ features = [
 ]
 
 [target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies]
-ahash = { version = "0.8.7", features = ["no-rng"], optional = true }
+ahash = { version = "0.8.3", features = ["no-rng"], optional = true }
 bytemuck = { version = "1.13.1", default-features = false, optional = true }
 calloop = "0.12.3"
 libc = "0.2.64"
@@ -182,18 +150,18 @@ memmap2 = { version = "0.9.0", optional = true }
 percent-encoding = { version = "2.0", optional = true }
 rustix = { version = "0.38.4", default-features = false, features = ["std", "system", "thread", "process"] }
 sctk = { package = "smithay-client-toolkit", version = "0.18.0", default-features = false, features = ["calloop"], optional = true }
-sctk-adwaita = { version = "0.8.0", default_features = false, optional = true }
+sctk-adwaita = { version = "0.7.0", default_features = false, optional = true }
 wayland-backend = { version = "0.3.0", default_features = false, features = ["client_system"], optional = true }
 wayland-client = { version = "0.31.1", optional = true }
 wayland-protocols = { version = "0.31.0", features = [ "staging"], optional = true }
 wayland-protocols-plasma = { version = "0.2.0", features = [ "client" ], optional = true }
 x11-dl = { version = "2.18.5", optional = true }
-x11rb = { version = "0.13.0", default-features = false, features = ["allow-unsafe-code", "dl-libxcb", "randr", "resource_manager", "xinput", "xkb"], optional = true }
+x11rb = { version = "0.12.0", default-features = false, features = ["allow-unsafe-code", "dl-libxcb", "randr", "resource_manager", "xinput", "xkb"], optional = true }
 xkbcommon-dl = "0.4.0"
 
 [target.'cfg(target_os = "redox")'.dependencies]
-orbclient = { version = "0.3.47", default-features = false }
-redox_syscall = "0.4.1"
+orbclient = { version = "0.3.42", default-features = false }
+redox_syscall = "0.3"
 
 [target.'cfg(target_family = "wasm")'.dependencies.web_sys]
 package = "web-sys"
@@ -201,11 +169,9 @@ version = "0.3.64"
 features = [
     'AbortController',
     'AbortSignal',
-    'Blob',
     'console',
     'CssStyleDeclaration',
     'Document',
-    'DomException',
     'DomRect',
     'DomRectReadOnly',
     'Element',
@@ -214,11 +180,6 @@ features = [
     'FocusEvent',
     'HtmlCanvasElement',
     'HtmlElement',
-    'HtmlImageElement',
-    'ImageBitmap',
-    'ImageBitmapOptions',
-    'ImageBitmapRenderingContext',
-    'ImageData',
     'IntersectionObserver',
     'IntersectionObserverEntry',
     'KeyboardEvent',
@@ -228,7 +189,6 @@ features = [
     'Node',
     'PageTransitionEvent',
     'PointerEvent',
-    'PremultiplyAlpha',
     'ResizeObserver',
     'ResizeObserverBoxOptions',
     'ResizeObserverEntry',
@@ -236,20 +196,15 @@ features = [
     'ResizeObserverSize',
     'VisibilityState',
     'Window',
-    'WheelEvent',
-    'Url',
+    'WheelEvent'
 ]
 
 [target.'cfg(target_family = "wasm")'.dependencies]
+atomic-waker = "1"
 js-sys = "0.3.64"
-pin-project = "1"
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
-web-time = "1"
-
-[target.'cfg(all(target_family = "wasm", target_feature = "atomics"))'.dependencies]
-atomic-waker = "1"
-concurrent-queue = { version = "2", default-features = false }
+web-time = "0.2"
 
 [target.'cfg(target_family = "wasm")'.dev-dependencies]
 console_log = "1"
@@ -257,9 +212,7 @@ web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }
 
 [workspace]
 members = [
+    "xbuild/android-target",
+    "xbuild/ios-target",
     "run-wasm",
 ]
-
-[[example]]
-doc-scrape-examples = true
-name = "window"

FEATURES.md

@@ -1,6 +1,6 @@
 # Winit Scope
 
-Winit aims to expose an interface that abstracts over window creation and input handling and can
+Winit aims to expose an interface that abstracts over window creation and input handling, and can
 be used to create both games and applications. It supports the following main graphical platforms:
 - Desktop
   - Windows 7+ (10+ is tested regularly)
@@ -45,10 +45,10 @@ be released and the library will enter maintenance mode. For the most part, new
 be added past this point. New platform features may be accepted and exposed through point releases.
 
 ### Tier upgrades
-Some platform features could, in theory, be exposed across multiple platforms, but have not gone
+Some platform features could in theory be exposed across multiple platforms, but have not gone
 through the implementation work necessary to function on all platforms. When one of these features
 gets implemented across all platforms, a PR can be opened to upgrade the feature to a core feature.
-If that gets accepted, the platform-specific functions get deprecated and become permanently
+If that gets accepted, the platform-specific functions gets deprecated and become permanently
 exposed through the core, cross-platform API.
 
 # Features
@@ -88,7 +88,7 @@ If your PR makes notable changes to Winit's features, please update this section
 - **Fullscreen toggle**: The windows created by winit can be switched to and from fullscreen after
   creation.
 - **Exclusive fullscreen**: Winit allows changing the video mode of the monitor
-  for fullscreen windows and, if applicable, captures the monitor for exclusive
+  for fullscreen windows, and if applicable, captures the monitor for exclusive
   use by this application.
 - **HiDPI support**: Winit assists developers in appropriately scaling HiDPI content.
 - **Popup / modal windows**: Windows can be created relative to the client area of other windows, and parent
@@ -105,8 +105,7 @@ If your PR makes notable changes to Winit's features, please update this section
 - **Mouse set location**: Forcibly changing the location of the pointer.
 - **Cursor locking**: Locking the cursor inside the window so it cannot move.
 - **Cursor confining**: Confining the cursor to the window bounds so it cannot leave them.
-- **Cursor icon**: Changing the cursor icon or hiding the cursor.
-- **Cursor image**: Changing the cursor to your own image.
+- **Cursor icon**: Changing the cursor icon, or hiding the cursor.
 - **Cursor hittest**: Handle or ignore mouse events for a window.
 - **Touch events**: Single-touch events.
 - **Touch pressure**: Touch events contain information about the amount of force being applied.
@@ -126,11 +125,6 @@ If your PR makes notable changes to Winit's features, please update this section
 * Setting a menu bar
 * `WS_EX_NOREDIRECTIONBITMAP` support
 * Theme the title bar according to Windows 10 Dark Mode setting or set a preferred theme
-* Changing a system-drawn backdrop
-* Setting the window border color
-* Setting the title bar background color
-* Setting the title color
-* Setting the corner rounding preference
 
 ### macOS
 * Window activation policy
@@ -156,13 +150,13 @@ If your PR makes notable changes to Winit's features, please update this section
 * Setting the `UIView` hidpi factor
 * Valid orientations
 * Home indicator visibility
-* Status bar visibility and style
-* Deferring system gestures
+* Status bar visibility
+* Deferrring system gestures
 * Getting the device idiom
 * Getting the preferred video mode
 
 ### Web
-* Get if the systems preferred color scheme is "dark"
+* Get if systems preferred color scheme is "dark"
 
 ## Usability
 * `serde`: Enables serialization/deserialization of certain types with Serde. (Maintainer: @Osspial)
@@ -172,7 +166,7 @@ If your PR makes notable changes to Winit's features, please update this section
 Legend:
 
 - ✔️: Works as intended
-- ▢: Mostly works, but some bugs are known
+- ▢: Mostly works but some bugs are known
 - ❌: Missing feature or large bugs making it unusable
 - **N/A**: Not applicable for this platform
 - ❓: Unknown status
@@ -212,7 +206,6 @@ Legend:
 |Cursor locking          |❌       |✔️      |❌       |✔️          |**N/A**|**N/A**|✔️        |❌      |
 |Cursor confining        |✔️       |❌      |✔️       |✔️          |**N/A**|**N/A**|❌       |❌      |
 |Cursor icon             |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|✔️        |**N/A** |
-|Cursor image            |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|✔️        |**N/A** |
 |Cursor hittest          |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|❌        |❌      |
 |Touch events            |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |✔️        |**N/A** |
 |Touch pressure          |✔️       |❌      |❌       |❌          |❌    |✔️     |✔️        |**N/A** |

HALL_OF_CHAMPIONS.md

@@ -2,20 +2,21 @@
 
 The winit maintainers would like to recognize the following former winit
 contributors, without whom winit would not exist in its current form. We thank
-them deeply for their time and efforts and wish them the best of luck in their
+them deeply for their time and efforts, and wish them best of luck in their
 future endeavors:
 
 * [@tomaka]: For creating the winit project and guiding it through its early
   years of existence.
-* [@vberger]: For diligently creating the Wayland backend and being its
+* [@vberger]: For diligently creating the Wayland backend, and being its
   extremely helpful and benevolent maintainer for years.
 * [@francesca64]: For taking over the responsibility of maintaining almost every
-  winit backend and standardizing HiDPI support across all of them.
-* [@Osspial]: For heroically landing EventLoop 2.0 and valiantly ushering in a
+  winit backend, and standardizing HiDPI support across all of them.
+* [@Osspial]: For heroically landing EventLoop 2.0, and valiantly ushering in a
   vastly more sustainable era of winit.
-* [@goddessfreya]: For selflessly taking over maintainership of glutin and her
+* [@goddessfreya]: For selflessly taking over maintainership of glutin, and her
   stellar dedication to improving both winit and glutin.
-* [@ArturKovacs]: For consistently maintaining the macOS backend and for his immense involvement in designing and implementing the new keyboard API.
+* [@ArturKovacs]: For consistently maintaining the macOS backend, and his
+  immense involvement in designing and implementing the new keyboard API.
 
 [@tomaka]: https://github.com/tomaka
 [@vberger]: https://github.com/vberger

README.md

@@ -2,13 +2,11 @@
 
 [![Crates.io](https://img.shields.io/crates/v/winit.svg)](https://crates.io/crates/winit)
 [![Docs.rs](https://docs.rs/winit/badge.svg)](https://docs.rs/winit)
-[![Master Docs](https://img.shields.io/github/actions/workflow/status/rust-windowing/winit/docs.yml?branch=master&label=master%20docs
-)](https://rust-windowing.github.io/winit/winit/index.html)
 [![CI Status](https://github.com/rust-windowing/winit/workflows/CI/badge.svg)](https://github.com/rust-windowing/winit/actions)
 
 ```toml
 [dependencies]
-winit = "0.29.10"
+winit = "0.29.1-beta"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -19,20 +17,47 @@ For features _outside_ the scope of winit, see [Are we GUI Yet?](https://arewegu
 
 ## Contact Us
 
-Join us in our [![Matrix](https://img.shields.io/badge/Matrix-%23rust--windowing%3Amatrix.org-blueviolet.svg)](https://matrix.to/#/#rust-windowing:matrix.org) room. If you don't get an answer there, try [![Libera.Chat](https://img.shields.io/badge/libera.chat-%23winit-red.svg)](https://web.libera.chat/#winit).
+Join us in any of these:
 
-The maintainers have a meeting every friday at UTC 15. The meeting notes can be found [here](https://hackmd.io/@winit-meetings).
+[![Matrix](https://img.shields.io/badge/Matrix-%23rust--windowing%3Amatrix.org-blueviolet.svg)](https://matrix.to/#/#rust-windowing:matrix.org)
+[![Libera.Chat](https://img.shields.io/badge/libera.chat-%23winit-red.svg)](https://web.libera.chat/#winit)
 
 ## Usage
 
 Winit is a window creation and management library. It can create windows and lets you handle
 events (for example: the window being resized, a key being pressed, a mouse movement, etc.)
-produced by the window.
+produced by window.
 
 Winit is designed to be a low-level brick in a hierarchy of libraries. Consequently, in order to
 show something on the window you need to use the platform-specific getters provided by winit, or
 another library.
 
+```rust
+use winit::{
+    event::{Event, WindowEvent},
+    event_loop::EventLoop,
+    window::WindowBuilder,
+};
+
+fn main() {
+    let event_loop = EventLoop::new();
+    event_loop.set_control_flow(ControlFlow::Wait);
+    let window = WindowBuilder::new().build(&event_loop).unwrap();
+
+    event_loop.run(move |event, elwt| {
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                window_id,
+            } if window_id == window.id() => elwt.exit(),
+            _ => (),
+        }
+    });
+}
+```
+
+Winit is only officially supported on the latest stable version of the Rust compiler.
+
 ### Cargo Features
 
 Winit provides the following features, which can be enabled in your `Cargo.toml` file:
@@ -43,7 +68,7 @@ Winit provides the following features, which can be enabled in your `Cargo.toml`
 
 ## MSRV Policy
 
-This crate's Minimum Supported Rust Version (MSRV) is **1.70**. Changes to
+The Minimum Supported Rust Version (MSRV) of this crate is **1.65**. Changes to
 the MSRV will be accompanied by a minor version bump.
 
 As a **tentative** policy, the upper bound of the MSRV is given by the following
@@ -54,11 +79,12 @@ min(sid, stable - 3)
 ```
 
 Where `sid` is the current version of `rustc` provided by [Debian Sid], and
-`stable` is the latest stable version of Rust. This bound may be broken in case of a major ecosystem shift or a security vulnerability.
+`stable` is the latest stable version of Rust. This bound may be broken in the
+event of a major ecosystem shift or a security vulnerability.
 
 [Debian Sid]: https://packages.debian.org/sid/rustc
 
-The exception is for the Android platform, where a higher Rust version
+The exception to this is for the Android platform, where a higher Rust version
 must be used for certain Android features. In this case, the MSRV will be
 capped at the latest stable version of Rust minus three. This inconsistency is
 not reflected in Cargo metadata, as it is not powerful enough to expose this
@@ -75,7 +101,7 @@ same MSRV policy.
 
 Note that windows don't appear on Wayland until you draw/present to them.
 
-#### Web
+#### WebAssembly
 
 To run the web example: `cargo run-wasm --example web`
 
@@ -86,7 +112,7 @@ either [provide Winit with a `<canvas>` element][web with_canvas], or [let Winit
 create a `<canvas>` element which you can then retrieve][web canvas getter] and
 insert it into the DOM yourself.
 
-For the example code using Winit on Web, check out the [web example]. For
+For example code using Winit with WebAssembly, check out the [web example]. For
 information on using Rust on WebAssembly, check out the [Rust and WebAssembly
 book].
 
@@ -109,14 +135,14 @@ glue crate (prior to `0.28` it used
 
 The version of the glue crate that your application depends on _must_ match the
 version that Winit depends on because the glue crate is responsible for your
-application's main entry point. If Cargo resolves multiple versions, they will
+application's main entrypoint. If Cargo resolves multiple versions they will
 clash.
 
 `winit` glue compatibility table:
 
 | winit |       ndk-glue               |
 | :---: | :--------------------------: |
-| 0.29  | `android-activity = "0.5"`   |
+| 0.29.1-beta  | `android-activity = "0.5.0-beta.1"`   |
 | 0.28  | `android-activity = "0.4"`   |
 | 0.27  | `ndk-glue = "0.7"`           |
 | 0.26  | `ndk-glue = "0.5"`           |
@@ -127,7 +153,7 @@ The recommended way to avoid a conflict with the glue version is to avoid explic
 depending on the `android-activity` crate, and instead consume the API that
 is re-exported by Winit under `winit::platform::android::activity::*`
 
-Running on an Android device needs a dynamic system library. Add this to Cargo.toml:
+Running on an Android device needs a dynamic system library, add this to Cargo.toml:
 
 ```toml
 [lib]
@@ -135,14 +161,14 @@ name = "main"
 crate-type = ["cdylib"]
 ```
 
-All Android applications are based on an `Activity` subclass, and the
+All Android applications are based on an `Activity` subclass and the
 `android-activity` crate is designed to support different choices for this base
 class. Your application _must_ specify the base class it needs via a feature flag:
 
 | Base Class       | Feature Flag      |  Notes  |
 | :--------------: | :---------------: | :-----: |
 | `NativeActivity` | `android-native-activity` | Built-in to Android - it is possible to use without compiling any Java or Kotlin code. Java or Kotlin code may be needed to subclass `NativeActivity` to access some platform features. It does not derive from the [`AndroidAppCompat`] base class.|
-| [`GameActivity`] | `android-game-activity`   | Derives from [`AndroidAppCompat`], a defacto standard `Activity` base class that helps support a wider range of Android versions. Requires a build system that can compile Java or Kotlin and fetch Android dependencies from a [Maven repository][agdk_jetpack] (or link with an embedded [release][agdk_releases] of [`GameActivity`]) |
+| [`GameActivity`] | `android-game-activity`   | Derives from [`AndroidAppCompat`] which is a defacto standard `Activity` base class that helps support a wider range of Android versions. Requires a build system that can compile Java or Kotlin and fetch Android dependencies from a [Maven repository][agdk_jetpack] (or link with an embedded [release][agdk_releases] of [`GameActivity`]) |
 
 [`GameActivity`]: https://developer.android.com/games/agdk/game-activity
 [`GameTextInput`]: https://developer.android.com/games/agdk/add-support-for-text-input
@@ -151,13 +177,40 @@ class. Your application _must_ specify the base class it needs via a feature fla
 [agdk_releases]: https://developer.android.com/games/agdk/download#agdk-libraries
 [Gradle]: https://developer.android.com/studio/build
 
-For more details, refer to these `android-activity` [example applications](https://github.com/rust-mobile/android-activity/tree/main/examples).
+For example, add this to Cargo.toml:
+```toml
+winit = { version = "0.29.1-beta", features = [ "android-native-activity" ] }
+
+[target.'cfg(target_os = "android")'.dependencies]
+android_logger = "0.11.0"
+```
+
+And, for example, define an entry point for your library like this:
+```rust
+#[cfg(target_os = "android")]
+use winit::platform::android::activity::AndroidApp;
+
+#[cfg(target_os = "android")]
+#[no_mangle]
+fn android_main(app: AndroidApp) {
+    use winit::platform::android::EventLoopBuilderExtAndroid;
+
+    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Trace));
+
+    let event_loop = EventLoopBuilder::with_user_event()
+        .with_android_app(app)
+        .build();
+    _main(event_loop);
+}
+```
+
+For more details, refer to these `android-activity` [example applications](https://github.com/rib/android-activity/tree/main/examples).
 
 ##### Converting from `ndk-glue` to `android-activity`
 
-If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building with `cargo apk`, then the minimal changes would be:
+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.29.10", features = [ "android-native-activity" ] }`
+2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.1-beta", 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 logging as above).
 4. Pass a clone of the `AndroidApp` that your application receives to Winit when building your event loop (as shown above).
 
@@ -168,13 +221,13 @@ doing anything; this includes creating windows, fetching monitors, drawing,
 and so on, see issues [#2238], [#2051] and [#2087].
 
 If you encounter problems, you should try doing your initialization inside
-`Event::Resumed`.
+`Event::NewEvents(StartCause::Init)`.
 
 #### iOS
 
 Similar to macOS, iOS's main `UIApplicationMain` does some init work that's required
-by all UI-related code (see issue [#1705]). It would be best to consider creating your windows
-inside `Event::Resumed`.
+by all UI related code, see issue [#1705]. You should consider creating your windows
+inside `Event::NewEvents(StartCause::Init)`.
 
 
 [#2238]: https://github.com/rust-windowing/winit/issues/2238
@@ -184,5 +237,5 @@ inside `Event::Resumed`.
 
 #### Redox OS
 
-Redox OS has some functionality not yet present that will be implemented when
+Redox OS has some functionality not present yet, that will be implemented when
 its orbital display server provides it.

build.rs

@@ -8,7 +8,7 @@ fn main() {
     cfg_aliases! {
         // Systems.
         android_platform: { target_os = "android" },
-        web_platform: { all(target_family = "wasm", target_os = "unknown") },
+        wasm_platform: { all(target_family = "wasm", not(target_os = "emscripten")) },
         macos_platform: { target_os = "macos" },
         ios_platform: { target_os = "ios" },
         windows_platform: { target_os = "windows" },
@@ -17,8 +17,8 @@ fn main() {
         redox: { target_os = "redox" },
 
         // Native displays.
-        x11_platform: { all(feature = "x11", free_unix, not(redox)) },
-        wayland_platform: { all(feature = "wayland", free_unix, not(redox)) },
+        x11_platform: { all(feature = "x11", free_unix, not(wasm), not(redox)) },
+        wayland_platform: { all(feature = "wayland", free_unix, not(wasm), not(redox)) },
         orbital_platform: { redox },
     }
 }

clippy.toml

@@ -6,10 +6,8 @@ disallowed-methods = [
     { path = "web_sys::HtmlCanvasElement::set_height", reason = "Winit shouldn't touch the internal canvas size" },
     { path = "web_sys::Window::document", reason = "cache this to reduce calls to JS" },
     { path = "web_sys::Window::get_computed_style", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::HtmlElement::style", reason = "cache this to reduce calls to JS" },
     { path = "web_sys::Element::request_fullscreen", reason = "Doesn't account for compatibility with Safari" },
     { path = "web_sys::Document::exit_fullscreen", reason = "Doesn't account for compatibility with Safari" },
     { path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },
     { path = "icrate::AppKit::NSView::visibleRect", reason = "We expose a render target to the user, and visibility is not really relevant to that (and can break if you don't use the rectangle position as well). Use `frame` instead." },
-    { path = "icrate::AppKit::NSWindow::setFrameTopLeftPoint", reason = "Not sufficient when working with Winit's coordinate system, use `flip_window_screen_coordinates` instead" },
 ]

deny.toml

@@ -34,6 +34,13 @@ skip = [
     { name = "raw-window-handle" },    # we intentionally have multiple versions of this
     { name = "bitflags" },             # the ecosystem is in the process of migrating.
     { name = "libloading" },           # x11rb uses a different version until the next update
+    { name = "syn" },                  # https://github.com/rust-mobile/ndk/issues/392
+    { name = "num_enum"},              # See above ^, waiting for release
+    { name = "num_enum_derive"},       # See above ^, waiting for release
+    { name = "miniz_oxide"},           # https://github.com/rust-lang/flate2-rs/issues/340
+    { name = "redox_syscall" },        # https://gitlab.redox-os.org/redox-os/orbclient/-/issues/46
+    { name = "foreign-types-shared" }, # https://github.com/servo/core-foundation-rs/issues/634
+    { name = "foreign-types" },        # See above ^, waiting for release
 ]
 skip-tree = []
 

docs/res/ATTRIBUTION.md

@@ -5,7 +5,7 @@ These images are used in the documentation of `winit`.
 ## keyboard_*.svg
 
 These files are a modified version of "[ANSI US QWERTY (Windows)](https://commons.wikimedia.org/wiki/File:ANSI_US_QWERTY_(Windows).svg)"
-by [Tomiĉo] (https://commons.wikimedia.org/wiki/User:Tomi%C4%89o). It was
+by [Tomiĉo] (https://commons.wikimedia.org/wiki/User:Tomi%C4%89o). It is
 originally released under the [CC-BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/deed.en)
 License. Minor modifications have been made by [John Nunley](https://github.com/notgull),
 which have been released under the same license as a derivative work.

examples/child_window.rs

@@ -18,16 +18,16 @@ fn main() -> Result<(), impl std::error::Error> {
         event::{ElementState, Event, KeyEvent, WindowEvent},
         event_loop::{EventLoop, EventLoopWindowTarget},
         raw_window_handle::HasRawWindowHandle,
-        window::{Window, WindowId},
+        window::{Window, WindowBuilder, WindowId},
     };
 
     fn spawn_child_window(
         parent: &Window,
-        event_loop: &EventLoopWindowTarget,
+        event_loop: &EventLoopWindowTarget<()>,
         windows: &mut HashMap<WindowId, Window>,
     ) {
         let parent = parent.raw_window_handle().unwrap();
-        let mut builder = Window::builder()
+        let mut builder = WindowBuilder::new()
             .with_title("child window")
             .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
             .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
@@ -44,7 +44,7 @@ fn main() -> Result<(), impl std::error::Error> {
     let mut windows = HashMap::new();
 
     let event_loop: EventLoop<()> = EventLoop::new().unwrap();
-    let parent_window = Window::builder()
+    let parent_window = WindowBuilder::new()
         .with_title("parent window")
         .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
         .with_inner_size(LogicalSize::new(640.0f32, 480.0f32))

examples/control_flow.rs

@@ -1,17 +1,17 @@
 #![allow(clippy::single_match)]
 
 use std::thread;
-#[cfg(not(web_platform))]
+#[cfg(not(wasm_platform))]
 use std::time;
-#[cfg(web_platform)]
+#[cfg(wasm_platform)]
 use web_time as time;
 
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
-    keyboard::{Key, NamedKey},
-    window::Window,
+    keyboard::Key,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -37,7 +37,7 @@ fn main() -> Result<(), impl std::error::Error> {
     println!("Press 'Esc' to close the window.");
 
     let event_loop = EventLoop::new().unwrap();
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.")
         .build(&event_loop)
         .unwrap();
@@ -88,7 +88,7 @@ fn main() -> Result<(), impl std::error::Error> {
                         request_redraw = !request_redraw;
                         println!("\nrequest_redraw: {request_redraw}\n");
                     }
-                    Key::Named(NamedKey::Escape) => {
+                    Key::Escape => {
                         close_requested = true;
                     }
                     _ => (),

examples/cursor.rs

@@ -4,7 +4,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    window::{CursorIcon, Window},
+    window::{CursorIcon, WindowBuilder},
 };
 
 #[path = "util/fill.rs"]
@@ -14,7 +14,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder().build(&event_loop).unwrap();
+    let window = WindowBuilder::new().build(&event_loop).unwrap();
     window.set_title("A fantastic window!");
 
     let mut cursor_idx = 0;
@@ -31,7 +31,7 @@ fn main() -> Result<(), impl std::error::Error> {
                     ..
                 } => {
                     println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]);
-                    window.set_cursor(CURSORS[cursor_idx]);
+                    window.set_cursor_icon(CURSORS[cursor_idx]);
                     if cursor_idx < CURSORS.len() - 1 {
                         cursor_idx += 1;
                     } else {

examples/cursor_grab.rs

@@ -4,8 +4,8 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{DeviceEvent, ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    keyboard::{Key, ModifiersState, NamedKey},
-    window::{CursorGrabMode, Window},
+    keyboard::{Key, ModifiersState},
+    window::{CursorGrabMode, WindowBuilder},
 };
 
 #[path = "util/fill.rs"]
@@ -15,7 +15,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("Super Cursor Grab'n'Hide Simulator 9000")
         .build(&event_loop)
         .unwrap();
@@ -35,7 +35,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 ..
             } => {
                 let result = match key {
-                    Key::Named(NamedKey::Escape) => {
+                    Key::Escape => {
                         elwt.exit();
                         Ok(())
                     }

examples/custom_cursors.rs

@@ -1,143 +0,0 @@
-#![allow(clippy::single_match, clippy::disallowed_methods)]
-
-#[cfg(not(web_platform))]
-use simple_logger::SimpleLogger;
-use winit::{
-    event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{EventLoop, EventLoopWindowTarget},
-    keyboard::Key,
-    window::{CursorIcon, CustomCursor, Window},
-};
-#[cfg(web_platform)]
-use {
-    std::sync::atomic::{AtomicU64, Ordering},
-    std::time::Duration,
-    winit::platform::web::CustomCursorExtWebSys,
-};
-
-#[cfg(web_platform)]
-static COUNTER: AtomicU64 = AtomicU64::new(0);
-
-fn decode_cursor(bytes: &[u8], window_target: &EventLoopWindowTarget) -> CustomCursor {
-    let img = image::load_from_memory(bytes).unwrap().to_rgba8();
-    let samples = img.into_flat_samples();
-    let (_, w, h) = samples.extents();
-    let (w, h) = (w as u16, h as u16);
-    let builder = CustomCursor::from_rgba(samples.samples, w, h, w / 2, h / 2).unwrap();
-
-    builder.build(window_target)
-}
-
-#[cfg(not(web_platform))]
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
-    #[cfg(not(web_platform))]
-    SimpleLogger::new()
-        .with_level(log::LevelFilter::Info)
-        .init()
-        .unwrap();
-    #[cfg(web_platform)]
-    console_log::init_with_level(log::Level::Debug).unwrap();
-
-    let event_loop = EventLoop::new().unwrap();
-    let builder = Window::builder().with_title("A fantastic window!");
-    #[cfg(web_platform)]
-    let builder = {
-        use winit::platform::web::WindowBuilderExtWebSys;
-        builder.with_append(true)
-    };
-    let window = builder.build(&event_loop).unwrap();
-
-    let mut cursor_idx = 0;
-    let mut cursor_visible = true;
-
-    let custom_cursors = [
-        decode_cursor(include_bytes!("data/cross.png"), &event_loop),
-        decode_cursor(include_bytes!("data/cross2.png"), &event_loop),
-        decode_cursor(include_bytes!("data/gradient.png"), &event_loop),
-    ];
-
-    event_loop.run(move |event, _elwt| match event {
-        Event::WindowEvent { event, .. } => match event {
-            WindowEvent::KeyboardInput {
-                event:
-                    KeyEvent {
-                        state: ElementState::Pressed,
-                        logical_key: key,
-                        ..
-                    },
-                ..
-            } => match key.as_ref() {
-                Key::Character("1") => {
-                    log::debug!("Setting cursor to {:?}", cursor_idx);
-                    window.set_cursor(custom_cursors[cursor_idx].clone());
-                    cursor_idx = (cursor_idx + 1) % 3;
-                }
-                Key::Character("2") => {
-                    log::debug!("Setting cursor icon to default");
-                    window.set_cursor(CursorIcon::default());
-                }
-                Key::Character("3") => {
-                    cursor_visible = !cursor_visible;
-                    log::debug!("Setting cursor visibility to {:?}", cursor_visible);
-                    window.set_cursor_visible(cursor_visible);
-                }
-                #[cfg(web_platform)]
-                Key::Character("4") => {
-                    log::debug!("Setting cursor to a random image from an URL");
-                    window.set_cursor(
-                        CustomCursor::from_url(
-                            format!(
-                                "https://picsum.photos/128?random={}",
-                                COUNTER.fetch_add(1, Ordering::Relaxed)
-                            ),
-                            64,
-                            64,
-                        )
-                        .build(_elwt),
-                    );
-                }
-                #[cfg(web_platform)]
-                Key::Character("5") => {
-                    log::debug!("Setting cursor to an animation");
-                    window.set_cursor(
-                        CustomCursor::from_animation(
-                            Duration::from_secs(3),
-                            vec![
-                                custom_cursors[0].clone(),
-                                custom_cursors[1].clone(),
-                                CustomCursor::from_url(
-                                    format!(
-                                        "https://picsum.photos/128?random={}",
-                                        COUNTER.fetch_add(1, Ordering::Relaxed)
-                                    ),
-                                    64,
-                                    64,
-                                )
-                                .build(_elwt),
-                            ],
-                        )
-                        .unwrap()
-                        .build(_elwt),
-                    );
-                }
-                _ => {}
-            },
-            WindowEvent::RedrawRequested => {
-                #[cfg(not(web_platform))]
-                fill::fill_window(&window);
-            }
-            WindowEvent::CloseRequested => {
-                #[cfg(not(web_platform))]
-                _elwt.exit();
-            }
-            _ => (),
-        },
-        Event::AboutToWait => {
-            window.request_redraw();
-        }
-        _ => {}
-    })
-}

examples/custom_events.rs

@@ -1,12 +1,12 @@
 #![allow(clippy::single_match)]
 
-#[cfg(not(web_platform))]
+#[cfg(not(wasm_platform))]
 fn main() -> Result<(), impl std::error::Error> {
     use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
-        event_loop::EventLoop,
-        window::Window,
+        event_loop::EventLoopBuilder,
+        window::WindowBuilder,
     };
 
     #[path = "util/fill.rs"]
@@ -18,9 +18,11 @@ fn main() -> Result<(), impl std::error::Error> {
     }
 
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::<CustomEvent>::with_user_event().build().unwrap();
+    let event_loop = EventLoopBuilder::<CustomEvent>::with_user_event()
+        .build()
+        .unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .build(&event_loop)
         .unwrap();
@@ -54,7 +56,7 @@ fn main() -> Result<(), impl std::error::Error> {
     })
 }
 
-#[cfg(web_platform)]
+#[cfg(wasm_platform)]
 fn main() {
     panic!("This example is not supported on web.");
 }

examples/drag_window.rs

@@ -5,7 +5,7 @@ use winit::{
     event::{ElementState, Event, KeyEvent, MouseButton, StartCause, WindowEvent},
     event_loop::EventLoop,
     keyboard::Key,
-    window::{Window, WindowId},
+    window::{Window, WindowBuilder, WindowId},
 };
 
 #[path = "util/fill.rs"]
@@ -15,8 +15,8 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window_1 = Window::builder().build(&event_loop).unwrap();
-    let window_2 = Window::builder().build(&event_loop).unwrap();
+    let window_1 = WindowBuilder::new().build(&event_loop).unwrap();
+    let window_2 = WindowBuilder::new().build(&event_loop).unwrap();
 
     let mut switched = false;
     let mut entered_id = window_2.id();

examples/focus.rs

@@ -1,56 +0,0 @@
-#![allow(clippy::single_match)]
-
-//! Example for focusing a window.
-
-use simple_logger::SimpleLogger;
-#[cfg(not(web_platform))]
-use std::time;
-#[cfg(web_platform)]
-use web_time as time;
-use winit::{
-    event::{Event, StartCause, WindowEvent},
-    event_loop::EventLoop,
-    window::Window,
-};
-
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
-
-    let window = Window::builder()
-        .with_title("A fantastic window!")
-        .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
-        .build(&event_loop)
-        .unwrap();
-
-    let mut deadline = time::Instant::now() + time::Duration::from_secs(3);
-    event_loop.run(move |event, elwt| {
-        match event {
-            Event::NewEvents(StartCause::ResumeTimeReached { .. }) => {
-                // Timeout reached; focus the window.
-                println!("Re-focusing the window.");
-                deadline += time::Duration::from_secs(3);
-                window.focus_window();
-            }
-            Event::WindowEvent { event, window_id } if window_id == window.id() => match event {
-                WindowEvent::CloseRequested => elwt.exit(),
-                WindowEvent::RedrawRequested => {
-                    // Notify the windowing system that we'll be presenting to the window.
-                    window.pre_present_notify();
-                    fill::fill_window(&window);
-                }
-                _ => (),
-            },
-            Event::AboutToWait => {
-                window.request_redraw();
-            }
-
-            _ => (),
-        }
-
-        elwt.set_control_flow(winit::event_loop::ControlFlow::WaitUntil(deadline));
-    })
-}

examples/fullscreen.rs

@@ -1,11 +1,11 @@
 #![allow(clippy::single_match)]
 
 use simple_logger::SimpleLogger;
-use winit::dpi::LogicalSize;
+use winit::dpi::PhysicalSize;
 use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
 use winit::event_loop::EventLoop;
-use winit::keyboard::{Key, NamedKey};
-use winit::window::{Fullscreen, Window};
+use winit::keyboard::Key;
+use winit::window::{Fullscreen, WindowBuilder};
 
 #[cfg(target_os = "macos")]
 use winit::platform::macos::WindowExtMacOS;
@@ -22,7 +22,7 @@ fn main() -> Result<(), impl std::error::Error> {
     let mut with_min_size = false;
     let mut with_max_size = false;
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("Hello world!")
         .build(&event_loop)
         .unwrap();
@@ -65,7 +65,7 @@ fn main() -> Result<(), impl std::error::Error> {
                         },
                     ..
                 } => match key {
-                    Key::Named(NamedKey::Escape) => elwt.exit(),
+                    Key::Escape => elwt.exit(),
                     // WARNING: Consider using `key_without_modifers()` if available on your platform.
                     // See the `key_binding` example
                     Key::Character(ch) => match ch.to_lowercase().as_str() {
@@ -126,7 +126,7 @@ fn main() -> Result<(), impl std::error::Error> {
                         "i" => {
                             with_min_size = !with_min_size;
                             let min_size = if with_min_size {
-                                Some(LogicalSize::new(100, 100))
+                                Some(PhysicalSize::new(100, 100))
                             } else {
                                 None
                             };
@@ -139,7 +139,7 @@ fn main() -> Result<(), impl std::error::Error> {
                         "a" => {
                             with_max_size = !with_max_size;
                             let max_size = if with_max_size {
-                                Some(LogicalSize::new(200, 200))
+                                Some(PhysicalSize::new(200, 200))
                             } else {
                                 None
                             };

examples/handling_close.rs

@@ -5,7 +5,7 @@ use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
     keyboard::Key,
-    window::Window,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -15,7 +15,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("Your faithful window")
         .build(&event_loop)
         .unwrap();

examples/ime.rs

@@ -6,8 +6,8 @@ use winit::{
     dpi::{PhysicalPosition, PhysicalSize},
     event::{ElementState, Event, Ime, WindowEvent},
     event_loop::EventLoop,
-    keyboard::NamedKey,
-    window::{ImePurpose, Window},
+    keyboard::{Key, KeyCode},
+    window::{ImePurpose, WindowBuilder},
 };
 
 #[path = "util/fill.rs"]
@@ -26,7 +26,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_inner_size(winit::dpi::LogicalSize::new(256f64, 128f64))
         .build(&event_loop)
         .unwrap();
@@ -69,12 +69,12 @@ fn main() -> Result<(), impl std::error::Error> {
                 WindowEvent::KeyboardInput { event, .. } => {
                     println!("key: {event:?}");
 
-                    if event.state == ElementState::Pressed && event.logical_key == NamedKey::F2 {
+                    if event.state == ElementState::Pressed && event.physical_key == KeyCode::F2 {
                         ime_allowed = !ime_allowed;
                         window.set_ime_allowed(ime_allowed);
                         println!("\nIME allowed: {ime_allowed}\n");
                     }
-                    if event.state == ElementState::Pressed && event.logical_key == NamedKey::F3 {
+                    if event.state == ElementState::Pressed && event.logical_key == Key::F3 {
                         ime_purpose = match ime_purpose {
                             ImePurpose::Normal => ImePurpose::Password,
                             ImePurpose::Password => ImePurpose::Terminal,

examples/key_binding.rs

@@ -8,7 +8,7 @@ use winit::{
     keyboard::{Key, ModifiersState},
     // WARNING: This is not available on all platforms (for example on the web).
     platform::modifier_supplement::KeyEventExtModifierSupplement,
-    window::Window,
+    window::WindowBuilder,
 };
 
 #[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
@@ -24,7 +24,7 @@ fn main() -> Result<(), impl std::error::Error> {
     simple_logger::SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_inner_size(LogicalSize::new(400.0, 200.0))
         .build(&event_loop)
         .unwrap();

examples/monitor_list.rs

@@ -3,12 +3,12 @@
 use simple_logger::SimpleLogger;
 use winit::dpi::{PhysicalPosition, PhysicalSize};
 use winit::monitor::MonitorHandle;
-use winit::{event_loop::EventLoop, window::Window};
+use winit::{event_loop::EventLoop, window::WindowBuilder};
 
 fn main() {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
-    let window = Window::builder().build(&event_loop).unwrap();
+    let window = WindowBuilder::new().build(&event_loop).unwrap();
 
     if let Some(mon) = window.primary_monitor() {
         print_info("Primary output", mon);

examples/mouse_wheel.rs

@@ -4,7 +4,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
     event_loop::EventLoop,
-    window::Window,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -14,7 +14,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("Mouse Wheel events")
         .build(&event_loop)
         .unwrap();

examples/multithreaded.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::single_match)]
 
-#[cfg(not(web_platform))]
+#[cfg(not(wasm_platform))]
 fn main() -> Result<(), impl std::error::Error> {
     use std::{collections::HashMap, sync::mpsc, thread, time::Duration};
 
@@ -9,8 +9,8 @@ fn main() -> Result<(), impl std::error::Error> {
         dpi::{PhysicalPosition, PhysicalSize, Position, Size},
         event::{ElementState, Event, KeyEvent, WindowEvent},
         event_loop::EventLoop,
-        keyboard::{Key, ModifiersState, NamedKey},
-        window::{CursorGrabMode, CursorIcon, Fullscreen, Window, WindowLevel},
+        keyboard::{Key, ModifiersState},
+        window::{CursorGrabMode, CursorIcon, Fullscreen, WindowBuilder, WindowLevel},
     };
 
     const WINDOW_COUNT: usize = 3;
@@ -20,7 +20,7 @@ fn main() -> Result<(), impl std::error::Error> {
     let event_loop = EventLoop::new().unwrap();
     let mut window_senders = HashMap::with_capacity(WINDOW_COUNT);
     for _ in 0..WINDOW_COUNT {
-        let window = Window::builder()
+        let window = WindowBuilder::new()
             .with_inner_size(WINDOW_SIZE)
             .build(&event_loop)
             .unwrap();
@@ -65,17 +65,17 @@ fn main() -> Result<(), impl std::error::Error> {
                             },
                         ..
                     } => {
-                        use NamedKey::{ArrowLeft, ArrowRight};
+                        use Key::{ArrowLeft, ArrowRight};
                         window.set_title(&format!("{key:?}"));
                         let state = !modifiers.shift_key();
                         match key {
                             // Cycle through video modes
-                            Key::Named(ArrowRight) | Key::Named(ArrowLeft) => {
-                                if key == ArrowLeft {
-                                    video_mode_id = video_mode_id.saturating_sub(1);
-                                } else if key == ArrowRight {
-                                    video_mode_id = (video_modes.len() - 1).min(video_mode_id + 1);
-                                }
+                            Key::ArrowRight | Key::ArrowLeft => {
+                                video_mode_id = match key {
+                                    ArrowLeft => video_mode_id.saturating_sub(1),
+                                    ArrowRight => (video_modes.len() - 1).min(video_mode_id + 1),
+                                    _ => unreachable!(),
+                                };
                                 println!("Picking video mode: {}", video_modes[video_mode_id]);
                             }
                             // WARNING: Consider using `key_without_modifers()` if available on your platform.
@@ -84,7 +84,7 @@ fn main() -> Result<(), impl std::error::Error> {
                                 "1" => window.set_window_level(WindowLevel::AlwaysOnTop),
                                 "2" => window.set_window_level(WindowLevel::AlwaysOnBottom),
                                 "3" => window.set_window_level(WindowLevel::Normal),
-                                "c" => window.set_cursor(match state {
+                                "c" => window.set_cursor_icon(match state {
                                     true => CursorIcon::Progress,
                                     false => CursorIcon::Default,
                                 }),
@@ -96,13 +96,21 @@ fn main() -> Result<(), impl std::error::Error> {
                                     )),
                                     (false, _) => None,
                                 }),
-                                ch @ ("g" | "l") => {
-                                    let mode = match (ch, state) {
-                                        ("l", true) => CursorGrabMode::Locked,
-                                        ("g", true) => CursorGrabMode::Confined,
-                                        (_, _) => CursorGrabMode::None,
-                                    };
-                                    if let Err(err) = window.set_cursor_grab(mode) {
+                                "l" if state => {
+                                    if let Err(err) = window.set_cursor_grab(CursorGrabMode::Locked)
+                                    {
+                                        println!("error: {err}");
+                                    }
+                                }
+                                "g" if state => {
+                                    if let Err(err) =
+                                        window.set_cursor_grab(CursorGrabMode::Confined)
+                                    {
+                                        println!("error: {err}");
+                                    }
+                                }
+                                "g" | "l" if !state => {
+                                    if let Err(err) = window.set_cursor_grab(CursorGrabMode::None) {
                                         println!("error: {err}");
                                     }
                                 }
@@ -115,6 +123,10 @@ fn main() -> Result<(), impl std::error::Error> {
                                     println!("-> inner_size     : {:?}", window.inner_size());
                                     println!("-> fullscreen     : {:?}", window.fullscreen());
                                 }
+                                "l" => window.set_min_inner_size(match state {
+                                    true => Some(WINDOW_SIZE),
+                                    false => None,
+                                }),
                                 "m" => window.set_maximized(state),
                                 "p" => window.set_outer_position({
                                     let mut position = window.outer_position().unwrap();
@@ -128,26 +140,12 @@ fn main() -> Result<(), impl std::error::Error> {
                                 "s" => {
                                     let _ = window.request_inner_size(match state {
                                         true => PhysicalSize::new(
-                                            WINDOW_SIZE.width + 50,
-                                            WINDOW_SIZE.height + 50,
+                                            WINDOW_SIZE.width + 100,
+                                            WINDOW_SIZE.height + 100,
                                         ),
                                         false => WINDOW_SIZE,
                                     });
                                 }
-                                "k" => window.set_min_inner_size(match state {
-                                    true => Some(PhysicalSize::new(
-                                        WINDOW_SIZE.width - 100,
-                                        WINDOW_SIZE.height - 100,
-                                    )),
-                                    false => None,
-                                }),
-                                "o" => window.set_max_inner_size(match state {
-                                    true => Some(PhysicalSize::new(
-                                        WINDOW_SIZE.width + 100,
-                                        WINDOW_SIZE.height + 100,
-                                    )),
-                                    false => None,
-                                }),
                                 "w" => {
                                     if let Size::Physical(size) = WINDOW_SIZE.into() {
                                         window
@@ -187,7 +185,7 @@ fn main() -> Result<(), impl std::error::Error> {
                     event:
                         KeyEvent {
                             state: ElementState::Released,
-                            logical_key: Key::Named(NamedKey::Escape),
+                            logical_key: Key::Escape,
                             ..
                         },
                     ..
@@ -205,7 +203,7 @@ fn main() -> Result<(), impl std::error::Error> {
     })
 }
 
-#[cfg(web_platform)]
+#[cfg(wasm_platform)]
 fn main() {
-    panic!("Example not supported on Web");
+    panic!("Example not supported on Wasm");
 }

examples/multiwindow.rs

@@ -4,9 +4,9 @@ use std::collections::HashMap;
 
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    keyboard::{Key, NamedKey},
+    keyboard::Key,
     window::Window,
 };
 
@@ -40,18 +40,19 @@ fn main() -> Result<(), impl std::error::Error> {
                     }
                 }
                 WindowEvent::KeyboardInput {
-                    event,
+                    event:
+                        KeyEvent {
+                            state: ElementState::Pressed,
+                            logical_key: Key::Character(c),
+                            ..
+                        },
                     is_synthetic: false,
                     ..
-                } if event.state == ElementState::Pressed => match event.logical_key {
-                    Key::Named(NamedKey::Escape) => elwt.exit(),
-                    Key::Character(c) if c == "n" || c == "N" => {
-                        let window = Window::new(elwt).unwrap();
-                        println!("Opened a new window: {:?}", window.id());
-                        windows.insert(window.id(), window);
-                    }
-                    _ => (),
-                },
+                } if matches!(c.as_ref(), "n" | "N") => {
+                    let window = Window::new(elwt).unwrap();
+                    println!("Opened a new window: {:?}", window.id());
+                    windows.insert(window.id(), window);
+                }
                 WindowEvent::RedrawRequested => {
                     if let Some(window) = windows.get(&window_id) {
                         fill::fill_window(window);

examples/request_redraw.rs

@@ -4,7 +4,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, WindowEvent},
     event_loop::EventLoop,
-    window::Window,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -14,7 +14,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .build(&event_loop)
         .unwrap();

examples/request_redraw_threaded.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::single_match)]
 
-#[cfg(not(web_platform))]
+#[cfg(not(wasm_platform))]
 fn main() -> Result<(), impl std::error::Error> {
     use std::{sync::Arc, thread, time};
 
@@ -8,7 +8,7 @@ fn main() -> Result<(), impl std::error::Error> {
     use winit::{
         event::{Event, WindowEvent},
         event_loop::EventLoop,
-        window::Window,
+        window::WindowBuilder,
     };
 
     #[path = "util/fill.rs"]
@@ -18,7 +18,7 @@ fn main() -> Result<(), impl std::error::Error> {
     let event_loop = EventLoop::new().unwrap();
 
     let window = {
-        let window = Window::builder()
+        let window = WindowBuilder::new()
             .with_title("A fantastic window!")
             .build(&event_loop)
             .unwrap();
@@ -53,7 +53,7 @@ fn main() -> Result<(), impl std::error::Error> {
     })
 }
 
-#[cfg(web_platform)]
+#[cfg(wasm_platform)]
 fn main() {
     unimplemented!() // `Window` can't be sent between threads
 }

examples/resizable.rs

@@ -5,8 +5,8 @@ use winit::{
     dpi::LogicalSize,
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    keyboard::{KeyCode, PhysicalKey},
-    window::Window,
+    keyboard::KeyCode,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -18,7 +18,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let mut resizable = false;
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("Hit space to toggle resizability.")
         .with_inner_size(LogicalSize::new(600.0, 300.0))
         .with_min_inner_size(LogicalSize::new(400.0, 200.0))
@@ -34,7 +34,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 WindowEvent::KeyboardInput {
                     event:
                         KeyEvent {
-                            physical_key: PhysicalKey::Code(KeyCode::Space),
+                            physical_key: KeyCode::Space,
                             state: ElementState::Released,
                             ..
                         },

examples/startup_notification.rs

@@ -11,10 +11,11 @@ mod example {
 
     use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
     use winit::event_loop::EventLoop;
+    use winit::keyboard::Key;
     use winit::platform::startup_notify::{
         EventLoopExtStartupNotify, WindowBuilderExtStartupNotify, WindowExtStartupNotify,
     };
-    use winit::window::{Window, WindowId};
+    use winit::window::{Window, WindowBuilder, WindowId};
 
     pub(super) fn main() -> Result<(), impl std::error::Error> {
         // Create the event loop and get the activation token.
@@ -45,7 +46,7 @@ mod example {
                             },
                         ..
                     } => {
-                        if logical_key == "n" {
+                        if logical_key == Key::Character("n".into()) {
                             if let Some(window) = windows.get(&window_id) {
                                 // Request a new activation token on this window.
                                 // Once we get it we will use it to create a window.
@@ -84,7 +85,8 @@ mod example {
             if current_token.is_some() || create_first_window {
                 // Create the initial window.
                 let window = {
-                    let mut builder = Window::builder().with_title(format!("Window {}", counter));
+                    let mut builder =
+                        WindowBuilder::new().with_title(format!("Window {}", counter));
 
                     if let Some(token) = current_token.take() {
                         println!("Creating a window with token {token:?}");

examples/theme.rs

@@ -5,7 +5,7 @@ use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
     keyboard::Key,
-    window::{Theme, Window},
+    window::{Theme, WindowBuilder},
 };
 
 #[path = "util/fill.rs"]
@@ -15,7 +15,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .with_theme(Some(Theme::Dark))
         .build(&event_loop)

examples/timer.rs

@@ -1,16 +1,16 @@
 #![allow(clippy::single_match)]
 
 use std::time::Duration;
-#[cfg(not(web_platform))]
+#[cfg(not(wasm_platform))]
 use std::time::Instant;
-#[cfg(web_platform)]
+#[cfg(wasm_platform)]
 use web_time::Instant;
 
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, StartCause, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
-    window::Window,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -20,7 +20,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .build(&event_loop)
         .unwrap();

examples/touchpad_gestures.rs

@@ -2,7 +2,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
     event_loop::EventLoop,
-    window::Window,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -12,44 +12,32 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("Touchpad gestures")
         .build(&event_loop)
         .unwrap();
-    #[cfg(target_os = "ios")]
-    {
-        use winit::platform::ios::WindowExtIOS;
-        window.recognize_doubletap_gesture(true);
-        window.recognize_pinch_gesture(true);
-        window.recognize_rotation_gesture(true);
-    }
 
-    println!("Only supported on macOS/iOS at the moment.");
-
-    let mut zoom = 0.0;
-    let mut rotated = 0.0;
+    println!("Only supported on macOS at the moment.");
 
     event_loop.run(move |event, elwt| {
         if let Event::WindowEvent { event, .. } = event {
             match event {
                 WindowEvent::CloseRequested => elwt.exit(),
-                WindowEvent::PinchGesture { delta, .. } => {
-                    zoom += delta;
+                WindowEvent::TouchpadMagnify { delta, .. } => {
                     if delta > 0.0 {
-                        println!("Zoomed in {delta:.5} (now: {zoom:.5})");
+                        println!("Zoomed in {delta}");
                     } else {
-                        println!("Zoomed out {delta:.5} (now: {zoom:.5})");
+                        println!("Zoomed out {delta}");
                     }
                 }
-                WindowEvent::DoubleTapGesture { .. } => {
+                WindowEvent::SmartMagnify { .. } => {
                     println!("Smart zoom");
                 }
-                WindowEvent::RotationGesture { delta, .. } => {
-                    rotated += delta;
+                WindowEvent::TouchpadRotate { delta, .. } => {
                     if delta > 0.0 {
-                        println!("Rotated counterclockwise {delta:.5} (now: {rotated:.5})");
+                        println!("Rotated counterclockwise {delta}");
                     } else {
-                        println!("Rotated clockwise {delta:.5} (now: {rotated:.5})");
+                        println!("Rotated clockwise {delta}");
                     }
                 }
                 WindowEvent::RedrawRequested => {

examples/transparent.rs

@@ -4,7 +4,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
     event_loop::EventLoop,
-    window::Window,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -14,7 +14,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_decorations(false)
         .with_transparent(true)
         .build(&event_loop)

examples/util/fill.rs

@@ -7,30 +7,17 @@
 //! The `softbuffer` crate is used, largely because of its ease of use. `glutin` or `wgpu` could
 //! also be used to fill the window buffer, but they are more complicated to use.
 
-#[allow(unused_imports)]
-pub use platform::cleanup_window;
-pub use platform::fill_window;
+use winit::window::Window;
 
 #[cfg(all(feature = "rwh_05", not(any(target_os = "android", target_os = "ios"))))]
-mod platform {
+pub(super) fn fill_window(window: &Window) {
+    use softbuffer::{Context, Surface};
     use std::cell::RefCell;
     use std::collections::HashMap;
     use std::mem::ManuallyDrop;
     use std::num::NonZeroU32;
-
-    use softbuffer::{Context, Surface};
-    use winit::window::Window;
     use winit::window::WindowId;
 
-    thread_local! {
-        // NOTE: You should never do things like that, create context and drop it before
-        // you drop the event loop. We do this for brevity to not blow up examples. We use
-        // ManuallyDrop to prevent destructors from running.
-        //
-        // A static, thread-local map of graphics contexts to open windows.
-        static GC: ManuallyDrop<RefCell<Option<GraphicsContext>>> = ManuallyDrop::new(RefCell::new(None));
-    }
-
     /// The graphics context used to draw to a window.
     struct GraphicsContext {
         /// The global softbuffer context.
@@ -48,69 +35,52 @@ mod platform {
             }
         }
 
-        fn create_surface(&mut self, window: &Window) -> &mut Surface {
-            self.surfaces.entry(window.id()).or_insert_with(|| {
-                unsafe { Surface::new(&self.context, window) }
+        fn surface(&mut self, w: &Window) -> &mut Surface {
+            self.surfaces.entry(w.id()).or_insert_with(|| {
+                unsafe { Surface::new(&self.context, w) }
                     .expect("Failed to create a softbuffer surface")
             })
         }
-
-        fn destroy_surface(&mut self, window: &Window) {
-            self.surfaces.remove(&window.id());
-        }
     }
 
-    pub fn fill_window(window: &Window) {
-        GC.with(|gc| {
-            let size = window.inner_size();
-            let (Some(width), Some(height)) =
-                (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
-            else {
-                return;
-            };
-
-            // Either get the last context used or create a new one.
-            let mut gc = gc.borrow_mut();
-            let surface = gc
-                .get_or_insert_with(|| GraphicsContext::new(window))
-                .create_surface(window);
-
-            // Fill a buffer with a solid color.
-            const DARK_GRAY: u32 = 0xFF181818;
-
-            surface
-                .resize(width, height)
-                .expect("Failed to resize the softbuffer surface");
-
-            let mut buffer = surface
-                .buffer_mut()
-                .expect("Failed to get the softbuffer buffer");
-            buffer.fill(DARK_GRAY);
-            buffer
-                .present()
-                .expect("Failed to present the softbuffer buffer");
-        })
+    thread_local! {
+        // NOTE: You should never do things like that, create context and drop it before
+        // you drop the event loop. We do this for brevity to not blow up examples. We use
+        // ManuallyDrop to prevent destructors from running.
+        //
+        // A static, thread-local map of graphics contexts to open windows.
+        static GC: ManuallyDrop<RefCell<Option<GraphicsContext>>> = ManuallyDrop::new(RefCell::new(None));
     }
 
-    #[allow(dead_code)]
-    pub fn cleanup_window(window: &Window) {
-        GC.with(|gc| {
-            let mut gc = gc.borrow_mut();
-            if let Some(context) = gc.as_mut() {
-                context.destroy_surface(window);
-            }
-        });
-    }
+    GC.with(|gc| {
+        // Either get the last context used or create a new one.
+        let mut gc = gc.borrow_mut();
+        let surface = gc
+            .get_or_insert_with(|| GraphicsContext::new(window))
+            .surface(window);
+
+        // Fill a buffer with a solid color.
+        const DARK_GRAY: u32 = 0xFF181818;
+        let size = window.inner_size();
+
+        surface
+            .resize(
+                NonZeroU32::new(size.width).expect("Width must be greater than zero"),
+                NonZeroU32::new(size.height).expect("Height must be greater than zero"),
+            )
+            .expect("Failed to resize the softbuffer surface");
+
+        let mut buffer = surface
+            .buffer_mut()
+            .expect("Failed to get the softbuffer buffer");
+        buffer.fill(DARK_GRAY);
+        buffer
+            .present()
+            .expect("Failed to present the softbuffer buffer");
+    })
 }
 
 #[cfg(not(all(feature = "rwh_05", not(any(target_os = "android", target_os = "ios")))))]
-mod platform {
-    pub fn fill_window(_window: &winit::window::Window) {
-        // No-op on mobile platforms.
-    }
-
-    #[allow(dead_code)]
-    pub fn cleanup_window(_window: &winit::window::Window) {
-        // No-op on mobile platforms.
-    }
+pub(super) fn fill_window(_window: &Window) {
+    // No-op on mobile platforms.
 }

examples/web.rs

@@ -3,14 +3,14 @@
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    keyboard::Key,
-    window::{Fullscreen, Window},
+    keyboard::KeyCode,
+    window::{Fullscreen, WindowBuilder},
 };
 
 pub fn main() -> Result<(), impl std::error::Error> {
     let event_loop = EventLoop::new().unwrap();
 
-    let builder = Window::builder().with_title("A fantastic window!");
+    let builder = WindowBuilder::new().with_title("A fantastic window!");
     #[cfg(wasm_platform)]
     let builder = {
         use winit::platform::web::WindowBuilderExtWebSys;
@@ -18,11 +18,11 @@ pub fn main() -> Result<(), impl std::error::Error> {
     };
     let window = builder.build(&event_loop).unwrap();
 
-    #[cfg(web_platform)]
+    #[cfg(wasm_platform)]
     let log_list = wasm::insert_canvas_and_create_log_list(&window);
 
     event_loop.run(move |event, elwt| {
-        #[cfg(web_platform)]
+        #[cfg(wasm_platform)]
         wasm::log_event(&log_list, &event);
 
         match event {
@@ -39,13 +39,13 @@ pub fn main() -> Result<(), impl std::error::Error> {
                     WindowEvent::KeyboardInput {
                         event:
                             KeyEvent {
-                                logical_key: Key::Character(c),
+                                physical_key: KeyCode::KeyF,
                                 state: ElementState::Released,
                                 ..
                             },
                         ..
                     },
-            } if window_id == window.id() && c == "f" => {
+            } if window_id == window.id() => {
                 if window.fullscreen().is_some() {
                     window.set_fullscreen(None);
                 } else {
@@ -57,7 +57,7 @@ pub fn main() -> Result<(), impl std::error::Error> {
     })
 }
 
-#[cfg(web_platform)]
+#[cfg(wasm_platform)]
 mod wasm {
     use std::num::NonZeroU32;
 

examples/web_aspect_ratio.rs

@@ -4,7 +4,7 @@ pub fn main() {
     println!("This example must be run with cargo run-wasm --example web_aspect_ratio")
 }
 
-#[cfg(web_platform)]
+#[cfg(wasm_platform)]
 mod wasm {
     use wasm_bindgen::prelude::*;
     use wasm_bindgen::JsCast;
@@ -14,7 +14,7 @@ mod wasm {
         event::{Event, WindowEvent},
         event_loop::EventLoop,
         platform::web::WindowBuilderExtWebSys,
-        window::Window,
+        window::{Window, WindowBuilder},
     };
 
     const EXPLANATION: &str = "
@@ -33,7 +33,7 @@ This example demonstrates the desired future functionality which will possibly b
         console_log::init_with_level(log::Level::Debug).expect("error initializing logger");
         let event_loop = EventLoop::new().unwrap();
 
-        let window = Window::builder()
+        let window = WindowBuilder::new()
             .with_title("A fantastic window!")
             // When running in a non-wasm environment this would set the window size to 100x100.
             // However in this example it just sets a default initial size of 100x100 that is immediately overwritten due to the layout + styling of the page.

examples/window.rs

@@ -4,7 +4,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
     event_loop::EventLoop,
-    window::Window,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -14,7 +14,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
         .build(&event_loop)

examples/window_buttons.rs

@@ -8,7 +8,7 @@ use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::{DeviceEvents, EventLoop},
     keyboard::Key,
-    window::{Window, WindowButtons},
+    window::{WindowBuilder, WindowButtons},
 };
 
 #[path = "util/fill.rs"]
@@ -18,7 +18,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .with_inner_size(LogicalSize::new(300.0, 300.0))
         .build(&event_loop)

examples/window_debug.rs

@@ -7,8 +7,8 @@ use winit::{
     dpi::{LogicalSize, PhysicalSize},
     event::{DeviceEvent, ElementState, Event, KeyEvent, RawKeyEvent, WindowEvent},
     event_loop::{DeviceEvents, EventLoop},
-    keyboard::{Key, KeyCode, PhysicalKey},
-    window::{Fullscreen, Window},
+    keyboard::{Key, KeyCode},
+    window::{Fullscreen, WindowBuilder},
 };
 
 #[path = "util/fill.rs"]
@@ -18,7 +18,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .with_inner_size(LogicalSize::new(100.0, 100.0))
         .build(&event_loop)
@@ -51,14 +51,14 @@ fn main() -> Result<(), impl std::error::Error> {
                     }),
                 ..
             } => match physical_key {
-                PhysicalKey::Code(KeyCode::KeyM) => {
+                KeyCode::KeyM => {
                     if minimized {
                         minimized = !minimized;
                         window.set_minimized(minimized);
                         window.focus_window();
                     }
                 }
-                PhysicalKey::Code(KeyCode::KeyV) => {
+                KeyCode::KeyV => {
                     if !visible {
                         visible = !visible;
                         window.set_visible(visible);

examples/window_drag_resize.rs

@@ -5,7 +5,7 @@ use winit::{
     event::{ElementState, Event, KeyEvent, MouseButton, StartCause, WindowEvent},
     event_loop::EventLoop,
     keyboard::Key,
-    window::{CursorIcon, ResizeDirection, Window},
+    window::{CursorIcon, ResizeDirection, WindowBuilder},
 };
 
 const BORDER: f64 = 8.0;
@@ -17,7 +17,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_inner_size(winit::dpi::LogicalSize::new(600.0, 400.0))
         .with_min_inner_size(winit::dpi::LogicalSize::new(400.0, 200.0))
         .with_decorations(false)
@@ -40,7 +40,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
                     if new_location != cursor_location {
                         cursor_location = new_location;
-                        window.set_cursor(cursor_direction_icon(cursor_location))
+                        window.set_cursor_icon(cursor_direction_icon(cursor_location))
                     }
                 }
             }

examples/window_icon.rs

@@ -6,7 +6,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
     event_loop::EventLoop,
-    window::{Icon, Window},
+    window::{Icon, WindowBuilder},
 };
 
 #[path = "util/fill.rs"]
@@ -25,7 +25,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("An iconic window!")
         // At present, this only does anything on Windows and X11, so if you want to save load
         // time, you can put icon loading behind a function that returns `None` on other platforms.

examples/window_on_demand.rs

@@ -12,7 +12,7 @@ fn main() -> Result<(), impl std::error::Error> {
         event::{Event, WindowEvent},
         event_loop::EventLoop,
         platform::run_on_demand::EventLoopExtRunOnDemand,
-        window::{Window, WindowId},
+        window::{Window, WindowBuilder, WindowId},
     };
 
     #[path = "util/fill.rs"]
@@ -40,7 +40,6 @@ fn main() -> Result<(), impl std::error::Error> {
                         window_id,
                     } if window.id() == window_id => {
                         println!("--------------------------------------------------------- Window {idx} CloseRequested");
-                        fill::cleanup_window(window);
                         app.window = None;
                     }
                     Event::AboutToWait => window.request_redraw(),
@@ -65,7 +64,7 @@ fn main() -> Result<(), impl std::error::Error> {
                     _ => (),
                 }
             } else if let Event::Resumed = event {
-                let window = Window::builder()
+                let window = WindowBuilder::new()
                         .with_title("Fantastic window number one!")
                         .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
                         .build(elwt)

examples/window_option_as_alt.rs

@@ -8,7 +8,7 @@ use winit::{
     event::ElementState,
     event::{Event, MouseButton, WindowEvent},
     event_loop::EventLoop,
-    window::Window,
+    window::WindowBuilder,
 };
 
 #[cfg(target_os = "macos")]
@@ -21,7 +21,7 @@ mod fill;
 fn main() -> Result<(), impl std::error::Error> {
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
         .build(&event_loop)

examples/window_pump_events.rs

@@ -16,7 +16,7 @@ fn main() -> std::process::ExitCode {
         event::{Event, WindowEvent},
         event_loop::EventLoop,
         platform::pump_events::{EventLoopExtPumpEvents, PumpStatus},
-        window::Window,
+        window::WindowBuilder,
     };
 
     #[path = "util/fill.rs"]
@@ -25,7 +25,7 @@ fn main() -> std::process::ExitCode {
     let mut event_loop = EventLoop::new().unwrap();
 
     SimpleLogger::new().init().unwrap();
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .build(&event_loop)
         .unwrap();
@@ -68,7 +68,7 @@ fn main() -> std::process::ExitCode {
     }
 }
 
-#[cfg(any(ios_platform, web_platform, orbital_platform))]
+#[cfg(any(ios_platform, wasm_platform, orbital_platform))]
 fn main() {
     println!("This platform doesn't support pump_events.");
 }

examples/window_resize_increments.rs

@@ -2,10 +2,10 @@ use log::debug;
 use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,
-    event::{ElementState, Event, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    keyboard::NamedKey,
-    window::Window,
+    keyboard::Key,
+    window::WindowBuilder,
 };
 
 #[path = "util/fill.rs"]
@@ -15,7 +15,7 @@ fn main() -> Result<(), impl std::error::Error> {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new().unwrap();
 
-    let window = Window::builder()
+    let window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .with_inner_size(LogicalSize::new(128.0, 128.0))
         .with_resize_increments(LogicalSize::new(25.0, 25.0))
@@ -27,10 +27,15 @@ fn main() -> Result<(), impl std::error::Error> {
     event_loop.run(move |event, elwt| match event {
         Event::WindowEvent { event, window_id } if window_id == window.id() => match event {
             WindowEvent::CloseRequested => elwt.exit(),
-            WindowEvent::KeyboardInput { event, .. }
-                if event.logical_key == NamedKey::Space
-                    && event.state == ElementState::Released =>
-            {
+            WindowEvent::KeyboardInput {
+                event:
+                    KeyEvent {
+                        logical_key: Key::Space,
+                        state: ElementState::Released,
+                        ..
+                    },
+                ..
+            } => {
                 has_increments = !has_increments;
 
                 let new_increments = match window.resize_increments() {

examples/window_tabbing.rs

@@ -9,9 +9,9 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    keyboard::{Key, NamedKey},
+    keyboard::Key,
     platform::macos::{WindowBuilderExtMacOS, WindowExtMacOS},
-    window::Window,
+    window::{Window, WindowBuilder},
 };
 
 #[cfg(target_os = "macos")]
@@ -60,7 +60,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 } => match logical_key.as_ref() {
                     Key::Character("t") => {
                         let tabbing_id = windows.get(&window_id).unwrap().tabbing_identifier();
-                        let window = Window::builder()
+                        let window = WindowBuilder::new()
                             .with_tabbing_identifier(&tabbing_id)
                             .build(elwt)
                             .unwrap();
@@ -70,10 +70,10 @@ fn main() -> Result<(), impl std::error::Error> {
                     Key::Character("w") => {
                         let _ = windows.remove(&window_id);
                     }
-                    Key::Named(NamedKey::ArrowRight) => {
+                    Key::ArrowRight => {
                         windows.get(&window_id).unwrap().select_next_tab();
                     }
-                    Key::Named(NamedKey::ArrowLeft) => {
+                    Key::ArrowLeft => {
                         windows.get(&window_id).unwrap().select_previous_tab();
                     }
                     Key::Character(ch) => {

examples/x11_embed.rs

@@ -12,7 +12,7 @@ mod imple {
         event::{Event, WindowEvent},
         event_loop::EventLoop,
         platform::x11::WindowBuilderExtX11,
-        window::Window,
+        window::WindowBuilder,
     };
 
     pub(super) fn entry() -> Result<(), Box<dyn std::error::Error>> {
@@ -25,7 +25,7 @@ mod imple {
         SimpleLogger::new().init().unwrap();
         let event_loop = EventLoop::new()?;
 
-        let window = Window::builder()
+        let window = WindowBuilder::new()
             .with_title("An embedded window!")
             .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
             .with_embed_parent_window(parent_window_id)

src/cursor.rs

@@ -1,304 +0,0 @@
-use core::fmt;
-use std::hash::Hasher;
-use std::sync::Arc;
-use std::{error::Error, hash::Hash};
-
-use cursor_icon::CursorIcon;
-
-use crate::event_loop::EventLoopWindowTarget;
-use crate::platform_impl::{self, PlatformCustomCursor, PlatformCustomCursorBuilder};
-
-/// The maximum width and height for a cursor when using [`CustomCursor::from_rgba`].
-pub const MAX_CURSOR_SIZE: u16 = 2048;
-
-const PIXEL_SIZE: usize = 4;
-
-/// See [`Window::set_cursor()`](crate::window::Window::set_cursor) for more details.
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub enum Cursor {
-    Icon(CursorIcon),
-    Custom(CustomCursor),
-}
-
-impl Default for Cursor {
-    fn default() -> Self {
-        Self::Icon(CursorIcon::default())
-    }
-}
-
-impl From<CursorIcon> for Cursor {
-    fn from(icon: CursorIcon) -> Self {
-        Self::Icon(icon)
-    }
-}
-
-impl From<CustomCursor> for Cursor {
-    fn from(custom: CustomCursor) -> Self {
-        Self::Custom(custom)
-    }
-}
-
-/// Use a custom image as a cursor (mouse pointer).
-///
-/// Is guaranteed to be cheap to clone.
-///
-/// ## Platform-specific
-///
-/// **Web**: Some browsers have limits on cursor sizes usually at 128x128.
-///
-/// # Example
-///
-/// ```no_run
-/// use winit::{
-///     event::{Event, WindowEvent},
-///     event_loop::{ControlFlow, EventLoop},
-///     window::{CustomCursor, Window},
-/// };
-///
-/// let mut event_loop = EventLoop::new().unwrap();
-///
-/// let w = 10;
-/// let h = 10;
-/// let rgba = vec![255; (w * h * 4) as usize];
-///
-/// #[cfg(not(target_family = "wasm"))]
-/// let builder = CustomCursor::from_rgba(rgba, w, h, w / 2, h / 2).unwrap();
-///
-/// #[cfg(target_family = "wasm")]
-/// let builder = {
-///     use winit::platform::web::CustomCursorExtWebSys;
-///     CustomCursor::from_url(String::from("http://localhost:3000/cursor.png"), 0, 0)
-/// };
-///
-/// let custom_cursor = builder.build(&event_loop);
-///
-/// let window = Window::new(&event_loop).unwrap();
-/// window.set_cursor(custom_cursor.clone());
-/// ```
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct CustomCursor {
-    /// Platforms should make sure this is cheap to clone.
-    pub(crate) inner: PlatformCustomCursor,
-}
-
-impl CustomCursor {
-    /// Creates a new cursor from an rgba buffer.
-    ///
-    /// The alpha channel is assumed to be **not** premultiplied.
-    pub fn from_rgba(
-        rgba: impl Into<Vec<u8>>,
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    ) -> Result<CustomCursorBuilder, BadImage> {
-        Ok(CustomCursorBuilder {
-            inner: PlatformCustomCursorBuilder::from_rgba(
-                rgba.into(),
-                width,
-                height,
-                hotspot_x,
-                hotspot_y,
-            )?,
-        })
-    }
-}
-
-/// Builds a [`CustomCursor`].
-///
-/// See [`CustomCursor`] for more details.
-#[derive(Debug)]
-pub struct CustomCursorBuilder {
-    pub(crate) inner: PlatformCustomCursorBuilder,
-}
-
-impl CustomCursorBuilder {
-    pub fn build(self, window_target: &EventLoopWindowTarget) -> CustomCursor {
-        CustomCursor {
-            inner: PlatformCustomCursor::build(self.inner, &window_target.p),
-        }
-    }
-}
-
-/// An error produced when using [`CustomCursor::from_rgba`] with invalid arguments.
-#[derive(Debug, Clone)]
-pub enum BadImage {
-    /// Produced when the image dimensions are larger than [`MAX_CURSOR_SIZE`]. This doesn't
-    /// guarantee that the cursor will work, but should avoid many platform and device specific
-    /// limits.
-    TooLarge { width: u16, height: u16 },
-    /// Produced when the length of the `rgba` argument isn't divisible by 4, thus `rgba` can't be
-    /// safely interpreted as 32bpp RGBA pixels.
-    ByteCountNotDivisibleBy4 { byte_count: usize },
-    /// Produced when the number of pixels (`rgba.len() / 4`) isn't equal to `width * height`.
-    /// At least one of your arguments is incorrect.
-    DimensionsVsPixelCount {
-        width: u16,
-        height: u16,
-        width_x_height: u64,
-        pixel_count: u64,
-    },
-    /// Produced when the hotspot is outside the image bounds
-    HotspotOutOfBounds {
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    },
-}
-
-impl fmt::Display for BadImage {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            BadImage::TooLarge { width, height } => write!(f,
-                "The specified dimensions ({width:?}x{height:?}) are too large. The maximum is {MAX_CURSOR_SIZE:?}x{MAX_CURSOR_SIZE:?}.",
-            ),
-            BadImage::ByteCountNotDivisibleBy4 { byte_count } => write!(f,
-                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
-            ),
-            BadImage::DimensionsVsPixelCount {
-                width,
-                height,
-                width_x_height,
-                pixel_count,
-            } => write!(f,
-                "The specified dimensions ({width:?}x{height:?}) don't match the number of pixels supplied by the `rgba` argument ({pixel_count:?}). For those dimensions, the expected pixel count is {width_x_height:?}.",
-            ),
-            BadImage::HotspotOutOfBounds {
-                width,
-                height,
-                hotspot_x,
-                hotspot_y,
-            } => write!(f,
-                "The specified hotspot ({hotspot_x:?}, {hotspot_y:?}) is outside the image bounds ({width:?}x{height:?}).",
-            ),
-        }
-    }
-}
-
-impl Error for BadImage {}
-
-/// Platforms export this directly as `PlatformCustomCursorBuilder` if they need to only work with images.
-#[derive(Debug)]
-pub(crate) struct OnlyCursorImageBuilder(pub(crate) CursorImage);
-
-#[allow(dead_code)]
-impl OnlyCursorImageBuilder {
-    pub(crate) fn from_rgba(
-        rgba: Vec<u8>,
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    ) -> Result<Self, BadImage> {
-        CursorImage::from_rgba(rgba, width, height, hotspot_x, hotspot_y).map(Self)
-    }
-}
-
-/// Platforms export this directly as `PlatformCustomCursor` if they don't implement caching.
-#[derive(Debug, Clone)]
-pub(crate) struct OnlyCursorImage(pub(crate) Arc<CursorImage>);
-
-impl Hash for OnlyCursorImage {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        Arc::as_ptr(&self.0).hash(state);
-    }
-}
-
-impl PartialEq for OnlyCursorImage {
-    fn eq(&self, other: &Self) -> bool {
-        Arc::ptr_eq(&self.0, &other.0)
-    }
-}
-
-impl Eq for OnlyCursorImage {}
-
-#[allow(dead_code)]
-impl OnlyCursorImage {
-    pub(crate) fn build(
-        builder: OnlyCursorImageBuilder,
-        _: &platform_impl::EventLoopWindowTarget,
-    ) -> Self {
-        Self(Arc::new(builder.0))
-    }
-}
-
-#[derive(Debug)]
-#[allow(dead_code)]
-pub(crate) struct CursorImage {
-    pub(crate) rgba: Vec<u8>,
-    pub(crate) width: u16,
-    pub(crate) height: u16,
-    pub(crate) hotspot_x: u16,
-    pub(crate) hotspot_y: u16,
-}
-
-impl CursorImage {
-    pub(crate) fn from_rgba(
-        rgba: Vec<u8>,
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    ) -> Result<Self, BadImage> {
-        if width > MAX_CURSOR_SIZE || height > MAX_CURSOR_SIZE {
-            return Err(BadImage::TooLarge { width, height });
-        }
-
-        if rgba.len() % PIXEL_SIZE != 0 {
-            return Err(BadImage::ByteCountNotDivisibleBy4 {
-                byte_count: rgba.len(),
-            });
-        }
-
-        let pixel_count = (rgba.len() / PIXEL_SIZE) as u64;
-        let width_x_height = width as u64 * height as u64;
-        if pixel_count != width_x_height {
-            return Err(BadImage::DimensionsVsPixelCount {
-                width,
-                height,
-                width_x_height,
-                pixel_count,
-            });
-        }
-
-        if hotspot_x >= width || hotspot_y >= height {
-            return Err(BadImage::HotspotOutOfBounds {
-                width,
-                height,
-                hotspot_x,
-                hotspot_y,
-            });
-        }
-
-        Ok(CursorImage {
-            rgba,
-            width,
-            height,
-            hotspot_x,
-            hotspot_y,
-        })
-    }
-}
-
-// Platforms that don't support cursors will export this as `PlatformCustomCursor`.
-#[derive(Debug, Clone, Hash, PartialEq, Eq)]
-pub(crate) struct NoCustomCursor;
-
-#[allow(dead_code)]
-impl NoCustomCursor {
-    pub(crate) fn from_rgba(
-        rgba: Vec<u8>,
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    ) -> Result<Self, BadImage> {
-        CursorImage::from_rgba(rgba, width, height, hotspot_x, hotspot_y)?;
-        Ok(Self)
-    }
-
-    fn build(self, _: &platform_impl::EventLoopWindowTarget) -> NoCustomCursor {
-        self
-    }
-}

src/dpi.rs

@@ -4,13 +4,13 @@
 //!
 //! Modern computer screens don't have a consistent relationship between resolution and size.
 //! 1920x1080 is a common resolution for both desktop and mobile screens, despite mobile screens
-//! typically being less than a quarter the size of their desktop counterparts. Moreover, neither
-//! desktop nor mobile screens have consistent resolutions within their own size classes - common
+//! normally being less than a quarter the size of their desktop counterparts. What's more, neither
+//! desktop nor mobile screens are consistent resolutions within their own size classes - common
 //! mobile screens range from below 720p to above 1440p, and desktop screens range from 720p to 5K
 //! and beyond.
 //!
 //! Given that, it's a mistake to assume that 2D content will only be displayed on screens with
-//! a consistent pixel density. If you were to render a 96-pixel-square image on a 1080p screen and
+//! a consistent pixel density. If you were to render a 96-pixel-square image on a 1080p screen,
 //! then render the same image on a similarly-sized 4K screen, the 4K rendition would only take up
 //! about a quarter of the physical space as it did on the 1080p screen. That issue is especially
 //! problematic with text rendering, where quarter-sized text becomes a significant legibility
@@ -25,12 +25,12 @@
 //!
 //! The solution to this problem is to account for the device's *scale factor*. The scale factor is
 //! the factor UI elements should be scaled by to be consistent with the rest of the user's system -
-//! for example, a button that's usually 50 pixels across would be 100 pixels across on a device
+//! for example, a button that's normally 50 pixels across would be 100 pixels across on a device
 //! with a scale factor of `2.0`, or 75 pixels across with a scale factor of `1.5`.
 //!
 //! Many UI systems, such as CSS, expose DPI-dependent units like [points] or [picas]. That's
-//! usually a mistake since there's no consistent mapping between the scale factor and the screen's
-//! actual DPI. Unless printing to a physical medium, you should work in scaled pixels rather
+//! usually a mistake, since there's no consistent mapping between the scale factor and the screen's
+//! actual DPI. Unless you're printing to a physical medium, you should work in scaled pixels rather
 //! than any DPI-dependent units.
 //!
 //! ### Position and Size types
@@ -42,11 +42,11 @@
 //! coordinates as input, allowing you to use the most convenient coordinate system for your
 //! particular application.
 //!
-//! Winit's position and size types are generic over their exact pixel type, `P`, to allow the
+//! Winit's position and size types types are generic over their exact pixel type, `P`, to allow the
 //! API to have integer precision where appropriate (e.g. most window manipulation functions) and
 //! floating precision when necessary (e.g. logical sizes for fractional scale factors and touch
 //! input). If `P` is a floating-point type, please do not cast the values with `as {int}`. Doing so
-//! will truncate the fractional part of the float rather than properly round to the nearest
+//! will truncate the fractional part of the float, rather than properly round to the nearest
 //! integer. Use the provided `cast` function or [`From`]/[`Into`] conversions, which handle the
 //! rounding properly. Note that precision loss will still occur when rounding from a float to an
 //! int, although rounding lessens the problem.
@@ -55,35 +55,34 @@
 //!
 //! Winit will dispatch a [`ScaleFactorChanged`] event whenever a window's scale factor has changed.
 //! This can happen if the user drags their window from a standard-resolution monitor to a high-DPI
-//! monitor or if the user changes their DPI settings. This allows you to rescale your application's
-//! UI elements and adjust how the platform changes the window's size to reflect the new scale
-//! factor. If a window hasn't received a [`ScaleFactorChanged`] event, its scale factor
+//! monitor, or if the user changes their DPI settings. This gives you a chance to rescale your
+//! application's UI elements and adjust how the platform changes the window's size to reflect the new
+//! scale factor. If a window hasn't received a [`ScaleFactorChanged`] event,  then its scale factor
 //! can be found by calling [`window.scale_factor()`].
 //!
 //! ## How is the scale factor calculated?
 //!
-//! The scale factor is calculated differently on different platforms:
+//! Scale factor is calculated differently on different platforms:
 //!
 //! - **Windows:** On Windows 8 and 10, per-monitor scaling is readily configured by users from the
 //!   display settings. While users are free to select any option they want, they're only given a
-//!   selection of "nice" scale factors, i.e. 1.0, 1.25, 1.5... on Windows 7. The scale factor is
+//!   selection of "nice" scale factors, i.e. 1.0, 1.25, 1.5... on Windows 7, the scale factor is
 //!   global and changing it requires logging out. See [this article][windows_1] for technical
 //!   details.
-//! - **macOS:** Recent macOS versions allow the user to change the scaling factor for specific
-//!   displays. When available, the user may pick a per-monitor scaling factor from a set of
-//!   pre-defined settings. All "retina displays" have a scaling factor above 1.0 by default,
-//!   but the specific value varies across devices.
+//! - **macOS:** Recent versions of macOS allow the user to change the scaling factor for certain
+//!   displays. When this is available, the user may pick a per-monitor scaling factor from a set
+//!   of pre-defined settings. All "retina displays" have a scaling factor above 1.0 by default but
+//!   the specific value varies across devices.
 //! - **X11:** Many man-hours have been spent trying to figure out how to handle DPI in X11. Winit
 //!   currently uses a three-pronged approach:
-//!   + Use the value in the `WINIT_X11_SCALE_FACTOR` environment variable if present.
+//!   + Use the value in the `WINIT_X11_SCALE_FACTOR` environment variable, if present.
 //!   + If not present, use the value set in `Xft.dpi` in Xresources.
 //!   + Otherwise, calculate the scale factor based on the millimeter monitor dimensions provided by XRandR.
 //!
 //!   If `WINIT_X11_SCALE_FACTOR` is set to `randr`, it'll ignore the `Xft.dpi` field and use the
 //!   XRandR scaling method. Generally speaking, you should try to configure the standard system
 //!   variables to do what you want before resorting to `WINIT_X11_SCALE_FACTOR`.
-//! - **Wayland:** The scale factor is suggested by the compositor for each window individually. The
-//!   monitor scale factor may differ from the window scale factor.
+//! - **Wayland:** Scale factor is suggested by the the compositor.
 //! - **iOS:** Scale factors are set by Apple to the value that best suits the device, and range
 //!   from `1.0` to `3.0`. See [this article][apple_1] and [this article][apple_2] for more
 //!   information.
@@ -104,9 +103,6 @@
 //! [android_1]: https://developer.android.com/training/multiscreen/screendensities
 //! [web_1]: https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio
 
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-
 pub trait Pixel: Copy + Into<f64> {
     fn from_f64(f: f64) -> Self;
     fn cast<P: Pixel>(self) -> P {

src/error.rs

@@ -35,6 +35,8 @@ pub enum EventLoopError {
     NotSupported(NotSupportedError),
     /// The OS cannot perform the operation.
     Os(OsError),
+    /// The event loop can't be re-run while it's already running
+    AlreadyRunning,
     /// The event loop can't be re-created.
     RecreationAttempt,
     /// Application has exit with an error status.
@@ -103,6 +105,7 @@ impl fmt::Display for NotSupportedError {
 impl fmt::Display for EventLoopError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
+            EventLoopError::AlreadyRunning => write!(f, "EventLoop is already running"),
             EventLoopError::RecreationAttempt => write!(f, "EventLoop can't be recreated"),
             EventLoopError::NotSupported(e) => e.fmt(f),
             EventLoopError::Os(e) => e.fmt(f),

src/event.rs

@@ -34,13 +34,11 @@
 //! [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
 use std::path::PathBuf;
 use std::sync::{Mutex, Weak};
-#[cfg(not(web_platform))]
+#[cfg(not(wasm_platform))]
 use std::time::Instant;
 
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
-#[cfg(web_platform)]
+#[cfg(wasm_platform)]
 use web_time::Instant;
 
 use crate::error::ExternalError;
@@ -447,23 +445,21 @@ pub enum WindowEvent {
         button: MouseButton,
     },
 
-    /// Two-finger pinch gesture, often used for magnification.
+    /// Touchpad magnification event with two-finger pinch gesture.
+    ///
+    /// Positive delta values indicate magnification (zooming in) and
+    /// negative delta values indicate shrinking (zooming out).
     ///
     /// ## Platform-specific
     ///
-    /// - Only available on **macOS** and **iOS**.
-    /// - On iOS, not recognized by default. It must be enabled when needed.
-    PinchGesture {
+    /// - Only available on **macOS**.
+    TouchpadMagnify {
         device_id: DeviceId,
-        /// Positive values indicate magnification (zooming in) and  negative
-        /// values indicate shrinking (zooming out).
-        ///
-        /// This value may be NaN.
         delta: f64,
         phase: TouchPhase,
     },
 
-    /// Double tap gesture.
+    /// Smart magnification event.
     ///
     /// On a Mac, smart magnification is triggered by a double tap with two fingers
     /// on the trackpad and is commonly used to zoom on a certain object
@@ -479,20 +475,18 @@ pub enum WindowEvent {
     ///
     /// ## Platform-specific
     ///
-    /// - Only available on **macOS 10.8** and later, and **iOS**.
-    /// - On iOS, not recognized by default. It must be enabled when needed.
-    DoubleTapGesture { device_id: DeviceId },
+    /// - Only available on **macOS 10.8** and later.
+    SmartMagnify { device_id: DeviceId },
 
-    /// Two-finger rotation gesture.
+    /// Touchpad rotation event with two-finger rotation gesture.
     ///
     /// Positive delta values indicate rotation counterclockwise and
     /// negative delta values indicate rotation clockwise.
     ///
     /// ## Platform-specific
     ///
-    /// - Only available on **macOS** and **iOS**.
-    /// - On iOS, not recognized by default. It must be enabled when needed.
-    RotationGesture {
+    /// - Only available on **macOS**.
+    TouchpadRotate {
         device_id: DeviceId,
         delta: f32,
         phase: TouchPhase,
@@ -536,8 +530,9 @@ 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 window is
-    /// resized to the value suggested by the OS, but it can be changed to any value.
+    /// After this event callback has been processed, the window will be resized to whatever value
+    /// is pointed to by the `new_inner_size` reference. By default, this will contain the size suggested
+    /// by the OS, but it can be changed to any value.
     ///
     /// For more information about DPI in general, see the [`dpi`](crate::dpi) module.
     ScaleFactorChanged {
@@ -579,7 +574,7 @@ pub enum WindowEvent {
     /// ### Others
     ///
     /// - **Web:** Doesn't take into account CSS [`border`], [`padding`], or [`transform`].
-    /// - **Android / Wayland / Windows / Orbital:** Unsupported.
+    /// - **Android / Windows / Orbital:** Unsupported.
     ///
     /// [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
     /// [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
@@ -676,7 +671,7 @@ pub enum DeviceEvent {
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct RawKeyEvent {
-    pub physical_key: keyboard::PhysicalKey,
+    pub physical_key: keyboard::KeyCode,
     pub state: ElementState,
 }
 
@@ -708,7 +703,7 @@ pub struct KeyEvent {
     /// `Fn` and `FnLock` key events are *exceedingly unlikely* to be emitted by Winit. These keys
     /// are usually handled at the hardware or OS level, and aren't surfaced to applications. If
     /// you somehow see this in the wild, we'd like to know :)
-    pub physical_key: keyboard::PhysicalKey,
+    pub physical_key: keyboard::KeyCode,
 
     // Allowing `broken_intra_doc_links` for `logical_key`, because
     // `key_without_modifiers` is not available on all platforms
@@ -748,7 +743,7 @@ pub struct KeyEvent {
     /// An additional difference from `logical_key` is that
     /// this field stores the text representation of any key
     /// that has such a representation. For example when
-    /// `logical_key` is `Key::Named(NamedKey::Enter)`, this field is `Some("\r")`.
+    /// `logical_key` is `Key::Enter`, this field is `Some("\r")`.
     ///
     /// This is `None` if the current keypress cannot
     /// be interpreted as text.
@@ -1204,13 +1199,13 @@ mod tests {
                     state: event::ElementState::Pressed,
                     button: event::MouseButton::Other(0),
                 });
-                with_window_event(PinchGesture {
+                with_window_event(TouchpadMagnify {
                     device_id: did,
                     delta: 0.0,
                     phase: event::TouchPhase::Started,
                 });
-                with_window_event(DoubleTapGesture { device_id: did });
-                with_window_event(RotationGesture {
+                with_window_event(SmartMagnify { device_id: did });
+                with_window_event(TouchpadRotate {
                     device_id: did,
                     delta: 0.0,
                     phase: event::TouchPhase::Started,

src/event_loop.rs

@@ -9,14 +9,12 @@
 //! handle events.
 use std::marker::PhantomData;
 use std::ops::Deref;
-#[cfg(any(x11_platform, wayland_platform))]
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::{error, fmt};
 
-#[cfg(not(web_platform))]
+#[cfg(not(wasm_platform))]
 use std::time::{Duration, Instant};
-#[cfg(web_platform)]
+#[cfg(wasm_platform)]
 use web_time::{Duration, Instant};
 
 use crate::error::EventLoopError;
@@ -48,8 +46,8 @@ pub struct EventLoop<T: 'static> {
 /// your callback. [`EventLoop`] will coerce into this type (`impl<T> Deref for
 /// EventLoop<T>`), so functions that take this as a parameter can also take
 /// `&EventLoop`.
-pub struct EventLoopWindowTarget {
-    pub(crate) p: platform_impl::EventLoopWindowTarget,
+pub struct EventLoopWindowTarget<T: 'static> {
+    pub(crate) p: platform_impl::EventLoopWindowTarget<T>,
     pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
 }
 
@@ -57,26 +55,33 @@ pub struct EventLoopWindowTarget {
 ///
 /// This is used to make specifying options that affect the whole application
 /// easier. But note that constructing multiple event loops is not supported.
-///
-/// This can be created using [`EventLoop::new`] or [`EventLoop::with_user_event`].
 #[derive(Default)]
 pub struct EventLoopBuilder<T: 'static> {
     pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
     _p: PhantomData<T>,
 }
 
-static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
-
 impl EventLoopBuilder<()> {
     /// Start building a new event loop.
     #[inline]
-    #[deprecated = "use `EventLoop::builder` instead"]
     pub fn new() -> Self {
-        EventLoop::builder()
+        Self::with_user_event()
     }
 }
 
+static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
+
 impl<T> EventLoopBuilder<T> {
+    /// Start building a new event loop, with the given type as the user event
+    /// type.
+    #[inline]
+    pub fn with_user_event() -> Self {
+        Self {
+            platform_specific: Default::default(),
+            _p: PhantomData,
+        }
+    }
+
     /// Builds a new event loop.
     ///
     /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
@@ -123,7 +128,7 @@ impl<T> EventLoopBuilder<T> {
         })
     }
 
-    #[cfg(web_platform)]
+    #[cfg(wasm_platform)]
     pub(crate) fn allow_event_loop_recreation() {
         EVENT_LOOP_CREATED.store(false, Ordering::Relaxed);
     }
@@ -135,7 +140,7 @@ impl<T> fmt::Debug for EventLoop<T> {
     }
 }
 
-impl fmt::Debug for EventLoopWindowTarget {
+impl<T> fmt::Debug for EventLoopWindowTarget<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("EventLoopWindowTarget { .. }")
     }
@@ -186,38 +191,27 @@ impl ControlFlow {
 }
 
 impl EventLoop<()> {
-    /// Create the event loop.
+    /// Alias for [`EventLoopBuilder::new().build()`].
     ///
-    /// This is an alias of `EventLoop::builder().build()`.
+    /// [`EventLoopBuilder::new().build()`]: EventLoopBuilder::build
     #[inline]
     pub fn new() -> Result<EventLoop<()>, EventLoopError> {
-        Self::builder().build()
-    }
-
-    /// Start building a new event loop.
-    ///
-    /// This returns an [`EventLoopBuilder`], to allow configuring the event loop before creation.
-    ///
-    /// To get the actual event loop, call [`build`][EventLoopBuilder::build] on that.
-    #[inline]
-    pub fn builder() -> EventLoopBuilder<()> {
-        Self::with_user_event()
+        EventLoopBuilder::new().build()
     }
 }
 
 impl<T> EventLoop<T> {
-    /// Start building a new event loop, with the given type as the user event
-    /// type.
-    pub fn with_user_event() -> EventLoopBuilder<T> {
-        EventLoopBuilder {
-            platform_specific: Default::default(),
-            _p: PhantomData,
-        }
+    #[deprecated = "Use `EventLoopBuilder::<T>::with_user_event().build()` instead."]
+    pub fn with_user_event() -> Result<EventLoop<T>, EventLoopError> {
+        EventLoopBuilder::<T>::with_user_event().build()
     }
 
     /// Runs the event loop in the calling thread and calls the given `event_handler` closure
     /// to dispatch any pending events.
     ///
+    /// Since the closure is `'static`, it must be a `move` closure if it needs to
+    /// access any data from the calling context.
+    ///
     /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
     ///
     /// ## Platform-specific
@@ -228,27 +222,19 @@ impl<T> EventLoop<T> {
     ///   (that Rust doesn't see) that will also mean that the rest of the function is never executed
     ///   and any values not passed to this function will *not* be dropped.
     ///
-    ///   Web applications are recommended to use
-    #[cfg_attr(
-        web_platform,
-        doc = "[`EventLoopExtWebSys::spawn()`][crate::platform::web::EventLoopExtWebSys::spawn()]"
-    )]
-    #[cfg_attr(not(web_platform), doc = "`EventLoopExtWebSys::spawn()`")]
-    ///   [^1] instead of [`run()`] to avoid the need
+    ///   Web applications are recommended to use `spawn()` instead of `run()` to avoid the need
     ///   for the Javascript exception trick, and to make it clearer that the event loop runs
     ///   asynchronously (via the browser's own, internal, event loop) and doesn't block the
     ///   current thread of execution like it does on other platforms.
     ///
     ///   This function won't be available with `target_feature = "exception-handling"`.
     ///
-    /// [`set_control_flow()`]: EventLoopWindowTarget::set_control_flow()
-    /// [`run()`]: Self::run()
-    /// [^1]: `EventLoopExtWebSys::spawn()` is only available on Web.
+    /// [`set_control_flow()`]: EventLoopWindowTarget::set_control_flow
     #[inline]
-    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
+    #[cfg(not(all(wasm_platform, target_feature = "exception-handling")))]
     pub fn run<F>(self, event_handler: F) -> Result<(), EventLoopError>
     where
-        F: FnMut(Event<T>, &EventLoopWindowTarget),
+        F: FnMut(Event<T>, &EventLoopWindowTarget<T>),
     {
         self.event_loop.run(event_handler)
     }
@@ -270,48 +256,20 @@ impl<T> rwh_06::HasDisplayHandle for EventLoop<T> {
 
 #[cfg(feature = "rwh_05")]
 unsafe impl<T> rwh_05::HasRawDisplayHandle for EventLoop<T> {
-    /// Returns a [`rwh_05::RawDisplayHandle`] for the event loop.
+    /// Returns a [`raw_window_handle::RawDisplayHandle`] for the event loop.
     fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
         rwh_05::HasRawDisplayHandle::raw_display_handle(&**self)
     }
 }
 
-#[cfg(any(x11_platform, wayland_platform))]
-impl<T> AsFd for EventLoop<T> {
-    /// Get the underlying [EventLoop]'s `fd` which you can register
-    /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
-    /// loop must be polled with the [`pump_events`] API.
-    ///
-    /// [`calloop`]: https://crates.io/crates/calloop
-    /// [`mio`]: https://crates.io/crates/mio
-    /// [`pump_events`]: crate::platform::pump_events::EventLoopExtPumpEvents::pump_events
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        self.event_loop.as_fd()
-    }
-}
-
-#[cfg(any(x11_platform, wayland_platform))]
-impl<T> AsRawFd for EventLoop<T> {
-    /// Get the underlying [EventLoop]'s raw `fd` which you can register
-    /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
-    /// loop must be polled with the [`pump_events`] API.
-    ///
-    /// [`calloop`]: https://crates.io/crates/calloop
-    /// [`mio`]: https://crates.io/crates/mio
-    /// [`pump_events`]: crate::platform::pump_events::EventLoopExtPumpEvents::pump_events
-    fn as_raw_fd(&self) -> RawFd {
-        self.event_loop.as_raw_fd()
-    }
-}
-
 impl<T> Deref for EventLoop<T> {
-    type Target = EventLoopWindowTarget;
-    fn deref(&self) -> &EventLoopWindowTarget {
+    type Target = EventLoopWindowTarget<T>;
+    fn deref(&self) -> &EventLoopWindowTarget<T> {
         self.event_loop.window_target()
     }
 }
 
-impl EventLoopWindowTarget {
+impl<T> EventLoopWindowTarget<T> {
     /// Returns the list of all the monitors available on the system.
     #[inline]
     pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
@@ -374,19 +332,10 @@ impl EventLoopWindowTarget {
     pub fn exiting(&self) -> bool {
         self.p.exiting()
     }
-
-    /// Gets a persistent reference to the underlying platform display.
-    ///
-    /// See the [`OwnedDisplayHandle`] type for more information.
-    pub fn owned_display_handle(&self) -> OwnedDisplayHandle {
-        OwnedDisplayHandle {
-            platform: self.p.owned_display_handle(),
-        }
-    }
 }
 
 #[cfg(feature = "rwh_06")]
-impl rwh_06::HasDisplayHandle for EventLoopWindowTarget {
+impl<T> rwh_06::HasDisplayHandle for EventLoopWindowTarget<T> {
     fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
         let raw = self.p.raw_display_handle_rwh_06()?;
         // SAFETY: The display will never be deallocated while the event loop is alive.
@@ -395,59 +344,13 @@ impl rwh_06::HasDisplayHandle for EventLoopWindowTarget {
 }
 
 #[cfg(feature = "rwh_05")]
-unsafe impl rwh_05::HasRawDisplayHandle for EventLoopWindowTarget {
-    /// Returns a [`rwh_05::RawDisplayHandle`] for the event loop.
+unsafe impl<T> rwh_05::HasRawDisplayHandle for EventLoopWindowTarget<T> {
+    /// Returns a [`raw_window_handle::RawDisplayHandle`] for the event loop.
     fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
         self.p.raw_display_handle_rwh_05()
     }
 }
 
-/// A proxy for the underlying display handle.
-///
-/// The purpose of this type is to provide a cheaply clonable handle to the underlying
-/// display handle. This is often used by graphics APIs to connect to the underlying APIs.
-/// It is difficult to keep a handle to the [`EventLoop`] type or the [`EventLoopWindowTarget`]
-/// type. In contrast, this type involves no lifetimes and can be persisted for as long as
-/// needed.
-///
-/// For all platforms, this is one of the following:
-///
-/// - A zero-sized type that is likely optimized out.
-/// - A reference-counted pointer to the underlying type.
-#[derive(Clone)]
-pub struct OwnedDisplayHandle {
-    #[cfg_attr(not(any(feature = "rwh_05", feature = "rwh_06")), allow(dead_code))]
-    platform: platform_impl::OwnedDisplayHandle,
-}
-
-impl fmt::Debug for OwnedDisplayHandle {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("OwnedDisplayHandle").finish_non_exhaustive()
-    }
-}
-
-#[cfg(feature = "rwh_06")]
-impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
-    #[inline]
-    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
-        let raw = self.platform.raw_display_handle_rwh_06()?;
-
-        // SAFETY: The underlying display handle should be safe.
-        let handle = unsafe { rwh_06::DisplayHandle::borrow_raw(raw) };
-
-        Ok(handle)
-    }
-}
-
-#[cfg(feature = "rwh_05")]
-unsafe impl rwh_05::HasRawDisplayHandle for OwnedDisplayHandle {
-    #[inline]
-    fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
-        self.platform.raw_display_handle_rwh_05()
-    }
-}
-
 /// Used to send custom events to [`EventLoop`].
 pub struct EventLoopProxy<T: 'static> {
     event_loop_proxy: platform_impl::EventLoopProxy<T>,
@@ -518,16 +421,16 @@ pub enum DeviceEvents {
 /// executed and removed from the list.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct AsyncRequestSerial {
-    serial: usize,
+    serial: u64,
 }
 
 impl AsyncRequestSerial {
-    // TODO(kchibisov): Remove `cfg` when the clipboard will be added.
+    // TODO(kchibisov) remove `cfg` when the clipboard will be added.
     #[allow(dead_code)]
     pub(crate) fn get() -> Self {
-        static CURRENT_SERIAL: AtomicUsize = AtomicUsize::new(0);
-        // NOTE: We rely on wrap around here, while the user may just request
-        // in the loop usize::MAX times that's issue is considered on them.
+        static CURRENT_SERIAL: AtomicU64 = AtomicU64::new(0);
+        // NOTE: we rely on wrap around here, while the user may just request
+        // in the loop u64::MAX times that's issue is considered on them.
         let serial = CURRENT_SERIAL.fetch_add(1, Ordering::Relaxed);
         Self { serial }
     }

src/icon.rs

@@ -49,7 +49,11 @@ impl fmt::Display for BadIcon {
     }
 }
 
-impl Error for BadIcon {}
+impl Error for BadIcon {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        Some(self)
+    }
+}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct RgbaIcon {

src/keyboard.rs

@@ -69,9 +69,6 @@
 //
 // --------- END OF W3C SHORT NOTICE ---------------------------------------------------------------
 
-use bitflags::bitflags;
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
 pub use smol_str::SmolStr;
 
 /// Contains the platform-native physical key identifier
@@ -188,112 +185,26 @@ impl std::fmt::Debug for NativeKey {
     }
 }
 
-impl From<NativeKeyCode> for NativeKey {
-    #[inline]
-    fn from(code: NativeKeyCode) -> Self {
-        match code {
-            NativeKeyCode::Unidentified => NativeKey::Unidentified,
-            NativeKeyCode::Android(x) => NativeKey::Android(x),
-            NativeKeyCode::MacOS(x) => NativeKey::MacOS(x),
-            NativeKeyCode::Windows(x) => NativeKey::Windows(x),
-            NativeKeyCode::Xkb(x) => NativeKey::Xkb(x),
-        }
-    }
-}
-
-impl PartialEq<NativeKey> for NativeKeyCode {
-    #[allow(clippy::cmp_owned)] // uses less code than direct match; target is stack allocated
-    #[inline]
-    fn eq(&self, rhs: &NativeKey) -> bool {
-        NativeKey::from(*self) == *rhs
-    }
-}
-
-impl PartialEq<NativeKeyCode> for NativeKey {
-    #[inline]
-    fn eq(&self, rhs: &NativeKeyCode) -> bool {
-        rhs == self
-    }
-}
-
 /// Represents the location of a physical key.
 ///
-/// This type is a superset of [`KeyCode`], including an [`Unidentified`](Self::Unidentified)
-/// variant.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum PhysicalKey {
-    /// A known key code
-    Code(KeyCode),
-    /// This variant is used when the key cannot be translated to a [`KeyCode`]
-    ///
-    /// The native keycode is provided (if available) so you're able to more reliably match
-    /// key-press and key-release events by hashing the [`PhysicalKey`]. It is also possible to use
-    /// this for keybinds for non-standard keys, but such keybinds are tied to a given platform.
-    Unidentified(NativeKeyCode),
-}
-
-impl From<KeyCode> for PhysicalKey {
-    #[inline]
-    fn from(code: KeyCode) -> Self {
-        PhysicalKey::Code(code)
-    }
-}
-
-impl From<NativeKeyCode> for PhysicalKey {
-    #[inline]
-    fn from(code: NativeKeyCode) -> Self {
-        PhysicalKey::Unidentified(code)
-    }
-}
-
-impl PartialEq<KeyCode> for PhysicalKey {
-    #[inline]
-    fn eq(&self, rhs: &KeyCode) -> bool {
-        match self {
-            PhysicalKey::Code(ref code) => code == rhs,
-            _ => false,
-        }
-    }
-}
-
-impl PartialEq<PhysicalKey> for KeyCode {
-    #[inline]
-    fn eq(&self, rhs: &PhysicalKey) -> bool {
-        rhs == self
-    }
-}
-
-impl PartialEq<NativeKeyCode> for PhysicalKey {
-    #[inline]
-    fn eq(&self, rhs: &NativeKeyCode) -> bool {
-        match self {
-            PhysicalKey::Unidentified(ref code) => code == rhs,
-            _ => false,
-        }
-    }
-}
-
-impl PartialEq<PhysicalKey> for NativeKeyCode {
-    #[inline]
-    fn eq(&self, rhs: &PhysicalKey) -> bool {
-        rhs == self
-    }
-}
-
-/// Code representing the location of a physical key
-///
 /// This mostly conforms to the UI Events Specification's [`KeyboardEvent.code`] with a few
 /// exceptions:
 /// - The keys that the specification calls "MetaLeft" and "MetaRight" are named "SuperLeft" and
 ///   "SuperRight" here.
 /// - The key that the specification calls "Super" is reported as `Unidentified` here.
+/// - The `Unidentified` variant here, can still identify a key through it's `NativeKeyCode`.
 ///
 /// [`KeyboardEvent.code`]: https://w3c.github.io/uievents-code/#code-value-tables
 #[non_exhaustive]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum KeyCode {
+    /// This variant is used when the key cannot be translated to any other variant.
+    ///
+    /// The native keycode is provided (if available) so you're able to more reliably match
+    /// key-press and key-release events by hashing the [`KeyCode`]. It is also possible to use
+    /// this for keybinds for non-standard keys, but such keybinds are tied to a given platform.
+    Unidentified(NativeKeyCode),
     /// <kbd>`</kbd> on a US keyboard. This is also called a backtick or grave.
     /// This is the <kbd>半角</kbd>/<kbd>全角</kbd>/<kbd>漢字</kbd>
     /// (hankaku/zenkaku/kanji) key on Japanese keyboards
@@ -737,7 +648,7 @@ pub enum KeyCode {
     F35,
 }
 
-/// A [`Key::Named`] value
+/// Key represents the meaning of a keypress.
 ///
 /// This mostly conforms to the UI Events Specification's [`KeyboardEvent.key`] with a few
 /// exceptions:
@@ -745,12 +656,32 @@ pub enum KeyCode {
 ///   another key which the specification calls `Super`. That does not exist here.)
 /// - The `Space` variant here, can be identified by the character it generates in the
 ///   specificaiton.
+/// - The `Unidentified` variant here, can still identifiy a key through it's `NativeKeyCode`.
+/// - The `Dead` variant here, can specify the character which is inserted when pressing the
+///   dead-key twice.
 ///
 /// [`KeyboardEvent.key`]: https://w3c.github.io/uievents-key/
 #[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum NamedKey {
+pub enum Key<Str = SmolStr> {
+    /// A key string that corresponds to the character typed by the user, taking into account the
+    /// user’s current locale setting, and any system-level keyboard mapping overrides that are in
+    /// effect.
+    Character(Str),
+
+    /// This variant is used when the key cannot be translated to any other variant.
+    ///
+    /// The native key is provided (if available) in order to allow the user to specify keybindings
+    /// for keys which are not defined by this API, mainly through some sort of UI.
+    Unidentified(NativeKey),
+
+    /// Contains the text representation of the dead-key when available.
+    ///
+    /// ## Platform-specific
+    /// - **Web:** Always contains `None`
+    Dead(Option<char>),
+
     /// The `Alt` (Alternative) key.
     ///
     /// This key enables the alternate modifier function for interpreting concurrent or subsequent
@@ -1454,131 +1385,83 @@ pub enum NamedKey {
     F35,
 }
 
-/// Key represents the meaning of a keypress.
-///
-/// This is a superset of the UI Events Specification's [`KeyboardEvent.key`] with
-/// additions:
-/// - All simple variants are wrapped under the `Named` variant
-/// - The `Unidentified` variant here, can still identifiy a key through it's `NativeKeyCode`.
-/// - The `Dead` variant here, can specify the character which is inserted when pressing the
-///   dead-key twice.
-///
-/// [`KeyboardEvent.key`]: https://w3c.github.io/uievents-key/
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum Key<Str = SmolStr> {
-    /// A simple (unparameterised) action
-    Named(NamedKey),
-
-    /// A key string that corresponds to the character typed by the user, taking into account the
-    /// user’s current locale setting, and any system-level keyboard mapping overrides that are in
-    /// effect.
-    Character(Str),
-
-    /// This variant is used when the key cannot be translated to any other variant.
-    ///
-    /// The native key is provided (if available) in order to allow the user to specify keybindings
-    /// for keys which are not defined by this API, mainly through some sort of UI.
-    Unidentified(NativeKey),
-
-    /// Contains the text representation of the dead-key when available.
-    ///
-    /// ## Platform-specific
-    /// - **Web:** Always contains `None`
-    Dead(Option<char>),
-}
-
-impl From<NamedKey> for Key {
-    #[inline]
-    fn from(action: NamedKey) -> Self {
-        Key::Named(action)
-    }
-}
-
-impl From<NativeKey> for Key {
-    #[inline]
-    fn from(code: NativeKey) -> Self {
-        Key::Unidentified(code)
-    }
-}
-
-impl<Str> PartialEq<NamedKey> for Key<Str> {
-    #[inline]
-    fn eq(&self, rhs: &NamedKey) -> bool {
-        match self {
-            Key::Named(ref a) => a == rhs,
-            _ => false,
+macro_rules! map_match {
+    (
+        $to_match:expr,
+        // Custom match arms
+        { $( $from:pat => $to:expr ),* },
+        // The enum's name
+        $prefix:path,
+        // Trivial match arms for unit variants
+        { $( $t:tt ),* }) => {
+        match $to_match {
+            $( $from => $to, )*
+            $( Key::$t => Key::$t, )*
         }
-    }
-}
-
-impl<Str: PartialEq<str>> PartialEq<str> for Key<Str> {
-    #[inline]
-    fn eq(&self, rhs: &str) -> bool {
-        match self {
-            Key::Character(ref s) => s == rhs,
-            _ => false,
-        }
-    }
-}
-
-impl<Str: PartialEq<str>> PartialEq<&str> for Key<Str> {
-    #[inline]
-    fn eq(&self, rhs: &&str) -> bool {
-        self == *rhs
-    }
-}
-
-impl<Str> PartialEq<NativeKey> for Key<Str> {
-    #[inline]
-    fn eq(&self, rhs: &NativeKey) -> bool {
-        match self {
-            Key::Unidentified(ref code) => code == rhs,
-            _ => false,
-        }
-    }
-}
-
-impl<Str> PartialEq<Key<Str>> for NativeKey {
-    #[inline]
-    fn eq(&self, rhs: &Key<Str>) -> bool {
-        rhs == self
-    }
+    };
 }
 
 impl Key<SmolStr> {
     /// Convert `Key::Character(SmolStr)` to `Key::Character(&str)` so you can more easily match on
     /// `Key`. All other variants remain unchanged.
     pub fn as_ref(&self) -> Key<&str> {
-        match self {
-            Key::Named(a) => Key::Named(*a),
-            Key::Character(ch) => Key::Character(ch.as_str()),
-            Key::Dead(d) => Key::Dead(*d),
-            Key::Unidentified(u) => Key::Unidentified(u.clone()),
-        }
-    }
-}
-
-impl NamedKey {
-    /// Convert an action to its approximate textual equivalent.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use winit::keyboard::NamedKey;
-    ///
-    /// assert_eq!(NamedKey::Enter.to_text(), Some("\r"));
-    /// assert_eq!(NamedKey::F20.to_text(), None);
-    /// ```
-    pub fn to_text(&self) -> Option<&str> {
-        match self {
-            NamedKey::Enter => Some("\r"),
-            NamedKey::Backspace => Some("\x08"),
-            NamedKey::Tab => Some("\t"),
-            NamedKey::Space => Some(" "),
-            NamedKey::Escape => Some("\x1b"),
-            _ => None,
-        }
+        map_match!(
+            self,
+            {
+                Key::Character(ch) => Key::Character(ch.as_str()),
+                Key::Dead(d) => Key::Dead(*d),
+                Key::Unidentified(u) => Key::Unidentified(u.clone())
+            },
+            Key,
+            {
+                Alt, AltGraph, CapsLock, Control, Fn, FnLock, NumLock, ScrollLock, Shift, Symbol,
+                SymbolLock, Meta, Hyper, Super, Enter, Tab, Space, ArrowDown, ArrowLeft,
+                ArrowRight, ArrowUp, End, Home, PageDown, PageUp, Backspace, Clear, Copy, CrSel,
+                Cut, Delete, EraseEof, ExSel, Insert, Paste, Redo, Undo, Accept, Again, Attn,
+                Cancel, ContextMenu, Escape, Execute, Find, Help, Pause, Play, Props, Select,
+                ZoomIn, ZoomOut, BrightnessDown, BrightnessUp, Eject, LogOff, Power, PowerOff,
+                PrintScreen, Hibernate, Standby, WakeUp, AllCandidates, Alphanumeric, CodeInput,
+                Compose, Convert, FinalMode, GroupFirst, GroupLast, GroupNext, GroupPrevious,
+                ModeChange, NextCandidate, NonConvert, PreviousCandidate, Process, SingleCandidate,
+                HangulMode, HanjaMode, JunjaMode, Eisu, Hankaku, Hiragana, HiraganaKatakana,
+                KanaMode, KanjiMode, Katakana, Romaji, Zenkaku, ZenkakuHankaku, Soft1, Soft2,
+                Soft3, Soft4, ChannelDown, ChannelUp, Close, MailForward, MailReply, MailSend,
+                MediaClose, MediaFastForward, MediaPause, MediaPlay, MediaPlayPause, MediaRecord,
+                MediaRewind, MediaStop, MediaTrackNext, MediaTrackPrevious, New, Open, Print, Save,
+                SpellCheck, Key11, Key12, AudioBalanceLeft, AudioBalanceRight, AudioBassBoostDown,
+                AudioBassBoostToggle, AudioBassBoostUp, AudioFaderFront, AudioFaderRear,
+                AudioSurroundModeNext, AudioTrebleDown, AudioTrebleUp, AudioVolumeDown,
+                AudioVolumeUp, AudioVolumeMute, MicrophoneToggle, MicrophoneVolumeDown,
+                MicrophoneVolumeUp, MicrophoneVolumeMute, SpeechCorrectionList, SpeechInputToggle,
+                LaunchApplication1, LaunchApplication2, LaunchCalendar, LaunchContacts, LaunchMail,
+                LaunchMediaPlayer, LaunchMusicPlayer, LaunchPhone, LaunchScreenSaver,
+                LaunchSpreadsheet, LaunchWebBrowser, LaunchWebCam, LaunchWordProcessor,
+                BrowserBack, BrowserFavorites, BrowserForward, BrowserHome, BrowserRefresh,
+                BrowserSearch, BrowserStop, AppSwitch, Call, Camera, CameraFocus, EndCall, GoBack,
+                GoHome, HeadsetHook, LastNumberRedial, Notification, MannerMode, VoiceDial, TV,
+                TV3DMode, TVAntennaCable, TVAudioDescription, TVAudioDescriptionMixDown,
+                TVAudioDescriptionMixUp, TVContentsMenu, TVDataService, TVInput, TVInputComponent1,
+                TVInputComponent2, TVInputComposite1, TVInputComposite2, TVInputHDMI1,
+                TVInputHDMI2, TVInputHDMI3, TVInputHDMI4, TVInputVGA1, TVMediaContext, TVNetwork,
+                TVNumberEntry, TVPower, TVRadioService, TVSatellite, TVSatelliteBS, TVSatelliteCS,
+                TVSatelliteToggle, TVTerrestrialAnalog, TVTerrestrialDigital, TVTimer, AVRInput,
+                AVRPower, ColorF0Red, ColorF1Green, ColorF2Yellow, ColorF3Blue, ColorF4Grey,
+                ColorF5Brown, ClosedCaptionToggle, Dimmer, DisplaySwap, DVR, Exit, FavoriteClear0,
+                FavoriteClear1, FavoriteClear2, FavoriteClear3, FavoriteRecall0, FavoriteRecall1,
+                FavoriteRecall2, FavoriteRecall3, FavoriteStore0, FavoriteStore1, FavoriteStore2,
+                FavoriteStore3, Guide, GuideNextDay, GuidePreviousDay, Info, InstantReplay, Link,
+                ListProgram, LiveContent, Lock, MediaApps, MediaAudioTrack, MediaLast,
+                MediaSkipBackward, MediaSkipForward, MediaStepBackward, MediaStepForward,
+                MediaTopMenu, NavigateIn, NavigateNext, NavigateOut, NavigatePrevious,
+                NextFavoriteChannel, NextUserProfile, OnDemand, Pairing, PinPDown, PinPMove,
+                PinPToggle, PinPUp, PlaySpeedDown, PlaySpeedReset, PlaySpeedUp, RandomToggle,
+                RcLowBattery, RecordSpeedNext, RfBypass, ScanChannelsToggle, ScreenModeNext,
+                Settings, SplitScreenToggle, STBInput, STBPower, Subtitle, Teletext, VideoModeNext,
+                Wink, ZoomToggle, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15,
+                F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31,
+                F32, F33, F34, F35
+            }
+        )
     }
 }
 
@@ -1588,16 +1471,20 @@ impl Key {
     /// # Examples
     ///
     /// ```
-    /// use winit::keyboard::{NamedKey, Key};
+    /// use winit::keyboard::Key;
     ///
     /// assert_eq!(Key::Character("a".into()).to_text(), Some("a"));
-    /// assert_eq!(Key::Named(NamedKey::Enter).to_text(), Some("\r"));
-    /// assert_eq!(Key::Named(NamedKey::F20).to_text(), None);
+    /// assert_eq!(Key::Enter.to_text(), Some("\r"));
+    /// assert_eq!(Key::F20.to_text(), None);
     /// ```
     pub fn to_text(&self) -> Option<&str> {
         match self {
-            Key::Named(action) => action.to_text(),
             Key::Character(ch) => Some(ch.as_str()),
+            Key::Enter => Some("\r"),
+            Key::Backspace => Some("\x08"),
+            Key::Tab => Some("\t"),
+            Key::Space => Some(" "),
+            Key::Escape => Some("\x1b"),
             _ => None,
         }
     }
@@ -1685,7 +1572,7 @@ bitflags! {
     /// Represents the current state of the keyboard modifiers
     ///
     /// Each flag represents a modifier and is set if this modifier is active.
-    #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
     pub struct ModifiersState: u32 {
         /// The "shift" key.
         const SHIFT = 0b100;

src/lib.rs

@@ -10,12 +10,12 @@
 //! let event_loop = EventLoop::new().unwrap();
 //! ```
 //!
-//! Once this is done, there are two ways to create a [`Window`]:
+//! Once this is done there are two ways to create a [`Window`]:
 //!
 //!  - Calling [`Window::new(&event_loop)`][window_new].
-//!  - Calling [`let builder = Window::builder()`][window_builder_new] then [`builder.build(&event_loop)`][window_builder_build].
+//!  - Calling [`let builder = WindowBuilder::new()`][window_builder_new] then [`builder.build(&event_loop)`][window_builder_build].
 //!
-//! The first method is the simplest and will give you default values for everything. The second
+//! The first method is the simplest, and will give you default values for everything. The second
 //! method allows you to customize the way your [`Window`] will look and behave by modifying the
 //! fields of the [`WindowBuilder`] object before you create the [`Window`].
 //!
@@ -26,48 +26,28 @@
 //! window or a key getting pressed while the window is focused. Devices can generate
 //! [`DeviceEvent`]s, which contain unfiltered event data that isn't specific to a certain window.
 //! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
-//! [`DeviceEvent`]. You can also create and handle your own custom [`Event::UserEvent`]s, if desired.
+//! [`DeviceEvent`]. You can also create and handle your own custom [`UserEvent`]s, if desired.
 //!
-//! You can retrieve events by calling [`EventLoop::run()`]. This function will
+//! You can retrieve events by calling [`EventLoop::run`][event_loop_run]. This function will
 //! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
-//! will run until [`exit()`] is used, at which point [`Event::LoopExiting`].
+//! will run until [`exit()`] is used, at which point [`Event`]`::`[`LoopExiting`].
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
 //! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works poorly on
 //! most other platforms. However, this model can be re-implemented to an extent with
-#![cfg_attr(
-    any(
-        windows_platform,
-        macos_platform,
-        android_platform,
-        x11_platform,
-        wayland_platform
-    ),
-    doc = "[`EventLoopExtPumpEvents::pump_events()`][platform::pump_events::EventLoopExtPumpEvents::pump_events()]"
-)]
-#![cfg_attr(
-    not(any(
-        windows_platform,
-        macos_platform,
-        android_platform,
-        x11_platform,
-        wayland_platform
-    )),
-    doc = "`EventLoopExtPumpEvents::pump_events()`"
-)]
-//! [^1]. See that method's documentation for more reasons about why
-//! it's discouraged beyond compatibility reasons.
+//! [`EventLoopExtPumpEvents::pump_events`]. See that method's documentation for more reasons about why
+//! it's discouraged, beyond compatibility reasons.
 //!
 //!
 //! ```no_run
 //! use winit::{
 //!     event::{Event, WindowEvent},
 //!     event_loop::{ControlFlow, EventLoop},
-//!     window::Window,
+//!     window::WindowBuilder,
 //! };
 //!
 //! let event_loop = EventLoop::new().unwrap();
-//! let window = Window::builder().build(&event_loop).unwrap();
+//! let window = WindowBuilder::new().build(&event_loop).unwrap();
 //!
 //! // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
 //! // dispatched any events. This is ideal for games and similar applications.
@@ -92,9 +72,9 @@
 //!
 //!             // Queue a RedrawRequested event.
 //!             //
-//!             // You only need to call this if you've determined that you need to redraw in
+//!             // You only need to call this if you've determined that you need to redraw, in
 //!             // applications which do not always need to. Applications that redraw continuously
-//!             // can render here instead.
+//!             // can just render here instead.
 //!             window.request_redraw();
 //!         },
 //!         Event::WindowEvent {
@@ -112,16 +92,16 @@
 //! });
 //! ```
 //!
-//! [`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
-//! compared to the value returned by [`Window::id()`] to determine which [`Window`]
+//! [`Event`]`::`[`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
+//! compared to the value returned by [`Window::id()`][window_id_fn] to determine which [`Window`]
 //! dispatched the event.
 //!
 //! # Drawing on the window
 //!
-//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However, it allows you to
+//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However it allows you to
 //! retrieve the raw handle of the window and display (see the [`platform`] module and/or the
 //! [`raw_window_handle`] and [`raw_display_handle`] methods), which in turn allows
-//! you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
+//!  you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
 //!
 //! Note that many platforms will display garbage data in the window's client area if the
 //! application doesn't render anything to the window by the time the desktop compositor is ready to
@@ -130,23 +110,25 @@
 //! window visible only once you're ready to render into it.
 //!
 //! [`EventLoop`]: event_loop::EventLoop
+//! [`EventLoopExtPumpEvents::pump_events`]: ./platform/pump_events/trait.EventLoopExtPumpEvents.html#tymethod.pump_events
 //! [`EventLoop::new()`]: event_loop::EventLoop::new
-//! [`EventLoop::run()`]: event_loop::EventLoop::run
+//! [event_loop_run]: event_loop::EventLoop::run
 //! [`exit()`]: event_loop::EventLoopWindowTarget::exit
 //! [`Window`]: window::Window
 //! [`WindowId`]: window::WindowId
 //! [`WindowBuilder`]: window::WindowBuilder
 //! [window_new]: window::Window::new
-//! [window_builder_new]: window::Window::builder
+//! [window_builder_new]: window::WindowBuilder::new
 //! [window_builder_build]: window::WindowBuilder::build
-//! [`Window::id()`]: window::Window::id
+//! [window_id_fn]: window::Window::id
+//! [`Event`]: event::Event
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
-//! [`Event::UserEvent`]: event::Event::UserEvent
-//! [`Event::LoopExiting`]: event::Event::LoopExiting
+//! [`UserEvent`]: event::Event::UserEvent
+//! [`LoopExiting`]: event::Event::LoopExiting
+//! [`platform`]: platform
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 //! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
-//! [^1]: `EventLoopExtPumpEvents::pump_events()` is only available on Windows, macOS, Android, X11 and Wayland.
 
 #![deny(rust_2018_idioms)]
 #![deny(rustdoc::broken_intra_doc_links)]
@@ -154,20 +136,24 @@
 #![deny(unsafe_op_in_unsafe_fn)]
 #![cfg_attr(feature = "cargo-clippy", deny(warnings))]
 // Doc feature labels can be tested locally by running RUSTDOCFLAGS="--cfg=docsrs" cargo +nightly doc
-#![cfg_attr(
-    docsrs,
-    feature(doc_auto_cfg, doc_cfg_hide),
-    doc(cfg_hide(doc, docsrs))
-)]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![allow(clippy::missing_safety_doc)]
 
 #[cfg(feature = "rwh_06")]
 pub use rwh_06 as raw_window_handle;
 
+#[allow(unused_imports)]
+#[macro_use]
+extern crate log;
+#[cfg(feature = "serde")]
+#[macro_use]
+extern crate serde;
+#[macro_use]
+extern crate bitflags;
+
 pub mod dpi;
 #[macro_use]
 pub mod error;
-mod cursor;
 pub mod event;
 pub mod event_loop;
 mod icon;

src/monitor.rs

@@ -10,32 +10,28 @@ use crate::{
     platform_impl,
 };
 
-/// Deprecated! Use `VideoModeHandle` instead.
-#[deprecated = "Renamed to `VideoModeHandle`"]
-pub type VideoMode = VideoModeHandle;
-
 /// Describes a fullscreen video mode of a monitor.
 ///
 /// Can be acquired with [`MonitorHandle::video_modes`].
 #[derive(Clone, PartialEq, Eq, Hash)]
-pub struct VideoModeHandle {
-    pub(crate) video_mode: platform_impl::VideoModeHandle,
+pub struct VideoMode {
+    pub(crate) video_mode: platform_impl::VideoMode,
 }
 
-impl std::fmt::Debug for VideoModeHandle {
+impl std::fmt::Debug for VideoMode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         self.video_mode.fmt(f)
     }
 }
 
-impl PartialOrd for VideoModeHandle {
-    fn partial_cmp(&self, other: &VideoModeHandle) -> Option<std::cmp::Ordering> {
+impl PartialOrd for VideoMode {
+    fn partial_cmp(&self, other: &VideoMode) -> Option<std::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl Ord for VideoModeHandle {
-    fn cmp(&self, other: &VideoModeHandle) -> std::cmp::Ordering {
+impl Ord for VideoMode {
+    fn cmp(&self, other: &VideoMode) -> std::cmp::Ordering {
         self.monitor().cmp(&other.monitor()).then(
             self.size()
                 .cmp(&other.size())
@@ -49,7 +45,7 @@ impl Ord for VideoModeHandle {
     }
 }
 
-impl VideoModeHandle {
+impl VideoMode {
     /// Returns the resolution of this video mode.
     #[inline]
     pub fn size(&self) -> PhysicalSize<u32> {
@@ -85,7 +81,7 @@ impl VideoModeHandle {
     }
 }
 
-impl std::fmt::Display for VideoModeHandle {
+impl std::fmt::Display for VideoMode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
@@ -135,25 +131,21 @@ impl MonitorHandle {
     /// Return `Some` if succeed, or `None` if failed, which usually happens when the monitor
     /// the window is on is removed.
     ///
-    /// When using exclusive fullscreen, the refresh rate of the [`VideoModeHandle`] that was
-    /// used to enter fullscreen should be used instead.
+    /// When using exclusive fullscreen, the refresh rate of the [`VideoMode`] that was used to
+    /// enter fullscreen should be used instead.
     #[inline]
     pub fn refresh_rate_millihertz(&self) -> Option<u32> {
         self.inner.refresh_rate_millihertz()
     }
 
-    /// Returns the scale factor of the underlying monitor. To map logical pixels to physical
-    /// pixels and vice versa, use [`Window::scale_factor`].
+    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.
     ///
     /// See the [`dpi`](crate::dpi) module for more information.
     ///
     /// ## Platform-specific
     ///
     /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
-    /// - **Wayland:** May differ from [`Window::scale_factor`].
     /// - **Android:** Always returns 1.0.
-    ///
-    /// [`Window::scale_factor`]: crate::window::Window::scale_factor
     #[inline]
     pub fn scale_factor(&self) -> f64 {
         self.inner.scale_factor()
@@ -165,9 +157,9 @@ impl MonitorHandle {
     ///
     /// - **Web:** Always returns an empty iterator
     #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
         self.inner
             .video_modes()
-            .map(|video_mode| VideoModeHandle { video_mode })
+            .map(|video_mode| VideoMode { video_mode })
     }
 }

src/platform/android.rs

@@ -3,7 +3,7 @@ use crate::{
     window::{Window, WindowBuilder},
 };
 
-use self::activity::{AndroidApp, ConfigurationRef, Rect};
+use android_activity::{AndroidApp, ConfigurationRef, Rect};
 
 /// Additional methods on [`EventLoop`] that are specific to Android.
 pub trait EventLoopExtAndroid {}
@@ -30,7 +30,7 @@ impl WindowExtAndroid for Window {
     }
 }
 
-impl EventLoopWindowTargetExtAndroid for EventLoopWindowTarget {}
+impl<T> EventLoopWindowTargetExtAndroid for EventLoopWindowTarget<T> {}
 
 /// Additional methods on [`WindowBuilder`] that are specific to Android.
 pub trait WindowBuilderExtAndroid {}
@@ -84,21 +84,5 @@ impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
 /// use winit::platform::android::activity::AndroidApp;
 /// ```
 pub mod activity {
-    // We enable the `"native-activity"` feature just so that we can build the
-    // docs, but it'll be very confusing for users to see the docs with that
-    // feature enabled, so we avoid inlining it so that they're forced to view
-    // it on the crate's own docs.rs page.
-    #[doc(no_inline)]
-    #[cfg(android_platform)]
     pub use android_activity::*;
-
-    #[cfg(not(android_platform))]
-    #[doc(hidden)]
-    pub struct Rect;
-    #[cfg(not(android_platform))]
-    #[doc(hidden)]
-    pub struct ConfigurationRef;
-    #[cfg(not(android_platform))]
-    #[doc(hidden)]
-    pub struct AndroidApp;
 }

src/platform/ios.rs

@@ -1,8 +1,11 @@
 use std::os::raw::c_void;
 
+use icrate::Foundation::MainThreadMarker;
+use objc2::rc::Id;
+
 use crate::{
     event_loop::EventLoop,
-    monitor::{MonitorHandle, VideoModeHandle},
+    monitor::{MonitorHandle, VideoMode},
     window::{Window, WindowBuilder},
 };
 
@@ -66,40 +69,11 @@ pub trait WindowExtIOS {
     ///
     /// The default is to prefer showing the status bar.
     ///
-    /// This sets the value of the
-    /// [`prefersStatusBarHidden`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc)
-    /// property.
-    ///
-    /// [`setNeedsStatusBarAppearanceUpdate()`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621354-setneedsstatusbarappearanceupdat?language=objc)
-    /// is also called for you.
+    /// This changes the value returned by
+    /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc),
+    /// and then calls
+    /// [`-[UIViewController setNeedsStatusBarAppearanceUpdate]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621354-setneedsstatusbarappearanceupdat?language=objc).
     fn set_prefers_status_bar_hidden(&self, hidden: bool);
-
-    /// Sets the preferred status bar style for the [`Window`].
-    ///
-    /// The default is system-defined.
-    ///
-    /// This sets the value of the
-    /// [`preferredStatusBarStyle`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621416-preferredstatusbarstyle?language=objc)
-    /// property.
-    ///
-    /// [`setNeedsStatusBarAppearanceUpdate()`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621354-setneedsstatusbarappearanceupdat?language=objc)
-    /// is also called for you.
-    fn set_preferred_status_bar_style(&self, status_bar_style: StatusBarStyle);
-
-    /// Sets whether the [`Window`] should recognize pinch gestures.
-    ///
-    /// The default is to not recognize gestures.
-    fn recognize_pinch_gesture(&self, should_recognize: bool);
-
-    /// Sets whether the [`Window`] should recognize double tap gestures.
-    ///
-    /// The default is to not recognize gestures.
-    fn recognize_doubletap_gesture(&self, should_recognize: bool);
-
-    /// Sets whether the [`Window`] should recognize rotation gestures.
-    ///
-    /// The default is to not recognize gestures.
-    fn recognize_rotation_gesture(&self, should_recognize: bool);
 }
 
 impl WindowExtIOS for Window {
@@ -133,30 +107,6 @@ impl WindowExtIOS for Window {
         self.window
             .maybe_queue_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))
-    }
-
-    #[inline]
-    fn recognize_pinch_gesture(&self, should_recognize: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.recognize_pinch_gesture(should_recognize));
-    }
-
-    #[inline]
-    fn recognize_doubletap_gesture(&self, should_recognize: bool) {
-        self.window
-            .maybe_queue_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));
-    }
 }
 
 /// Additional methods on [`WindowBuilder`] that are specific to iOS.
@@ -204,52 +154,37 @@ pub trait WindowBuilderExtIOS {
     /// This sets the initial value returned by
     /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc).
     fn with_prefers_status_bar_hidden(self, hidden: bool) -> Self;
-
-    /// Sets the style of the [`Window`]'s status bar.
-    ///
-    /// The default is system-defined.
-    ///
-    /// This sets the initial value returned by
-    /// [`-[UIViewController preferredStatusBarStyle]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621416-preferredstatusbarstyle?language=objc),
-    fn with_preferred_status_bar_style(self, status_bar_style: StatusBarStyle) -> Self;
 }
 
 impl WindowBuilderExtIOS for WindowBuilder {
     #[inline]
     fn with_scale_factor(mut self, scale_factor: f64) -> Self {
-        self.window.platform_specific.scale_factor = Some(scale_factor);
+        self.platform_specific.scale_factor = Some(scale_factor);
         self
     }
 
     #[inline]
     fn with_valid_orientations(mut self, valid_orientations: ValidOrientations) -> Self {
-        self.window.platform_specific.valid_orientations = valid_orientations;
+        self.platform_specific.valid_orientations = valid_orientations;
         self
     }
 
     #[inline]
     fn with_prefers_home_indicator_hidden(mut self, hidden: bool) -> Self {
-        self.window.platform_specific.prefers_home_indicator_hidden = hidden;
+        self.platform_specific.prefers_home_indicator_hidden = hidden;
         self
     }
 
     #[inline]
     fn with_preferred_screen_edges_deferring_system_gestures(mut self, edges: ScreenEdge) -> Self {
-        self.window
-            .platform_specific
+        self.platform_specific
             .preferred_screen_edges_deferring_system_gestures = edges;
         self
     }
 
     #[inline]
     fn with_prefers_status_bar_hidden(mut self, hidden: bool) -> Self {
-        self.window.platform_specific.prefers_status_bar_hidden = hidden;
-        self
-    }
-
-    #[inline]
-    fn with_preferred_status_bar_style(mut self, status_bar_style: StatusBarStyle) -> Self {
-        self.window.platform_specific.preferred_status_bar_style = status_bar_style;
+        self.platform_specific.prefers_status_bar_hidden = hidden;
         self
     }
 }
@@ -261,23 +196,23 @@ pub trait MonitorHandleExtIOS {
     /// [`UIScreen`]: https://developer.apple.com/documentation/uikit/uiscreen?language=objc
     fn ui_screen(&self) -> *mut c_void;
 
-    /// Returns the preferred [`VideoModeHandle`] for this monitor.
+    /// Returns the preferred [`VideoMode`] for this monitor.
     ///
     /// This translates to a call to [`-[UIScreen preferredMode]`](https://developer.apple.com/documentation/uikit/uiscreen/1617823-preferredmode?language=objc).
-    fn preferred_video_mode(&self) -> VideoModeHandle;
+    fn preferred_video_mode(&self) -> VideoMode;
 }
 
 impl MonitorHandleExtIOS for MonitorHandle {
     #[inline]
     fn ui_screen(&self) -> *mut c_void {
         // SAFETY: The marker is only used to get the pointer of the screen
-        let mtm = unsafe { icrate::Foundation::MainThreadMarker::new_unchecked() };
-        objc2::rc::Id::as_ptr(self.inner.ui_screen(mtm)) as *mut c_void
+        let mtm = unsafe { MainThreadMarker::new_unchecked() };
+        Id::as_ptr(self.inner.ui_screen(mtm)) as *mut c_void
     }
 
     #[inline]
-    fn preferred_video_mode(&self) -> VideoModeHandle {
-        VideoModeHandle {
+    fn preferred_video_mode(&self) -> VideoMode {
+        VideoMode {
             video_mode: self.inner.preferred_video_mode(),
         }
     }
@@ -314,7 +249,7 @@ pub enum Idiom {
     CarPlay,
 }
 
-bitflags::bitflags! {
+bitflags! {
     /// The [edges] of a screen.
     ///
     /// [edges]: https://developer.apple.com/documentation/uikit/uirectedge?language=objc
@@ -329,11 +264,3 @@ bitflags::bitflags! {
             | ScreenEdge::BOTTOM.bits() | ScreenEdge::RIGHT.bits();
     }
 }
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub enum StatusBarStyle {
-    #[default]
-    Default,
-    LightContent,
-    DarkContent,
-}

src/platform/macos.rs

@@ -1,7 +1,6 @@
 use std::os::raw::c_void;
 
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
+use objc2::rc::Id;
 
 use crate::{
     event_loop::{EventLoopBuilder, EventLoopWindowTarget},
@@ -212,62 +211,61 @@ pub trait WindowBuilderExtMacOS {
 impl WindowBuilderExtMacOS for WindowBuilder {
     #[inline]
     fn with_movable_by_window_background(mut self, movable_by_window_background: bool) -> Self {
-        self.window.platform_specific.movable_by_window_background = movable_by_window_background;
+        self.platform_specific.movable_by_window_background = movable_by_window_background;
         self
     }
 
     #[inline]
     fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> Self {
-        self.window.platform_specific.titlebar_transparent = titlebar_transparent;
+        self.platform_specific.titlebar_transparent = titlebar_transparent;
         self
     }
 
     #[inline]
     fn with_titlebar_hidden(mut self, titlebar_hidden: bool) -> Self {
-        self.window.platform_specific.titlebar_hidden = titlebar_hidden;
+        self.platform_specific.titlebar_hidden = titlebar_hidden;
         self
     }
 
     #[inline]
     fn with_titlebar_buttons_hidden(mut self, titlebar_buttons_hidden: bool) -> Self {
-        self.window.platform_specific.titlebar_buttons_hidden = titlebar_buttons_hidden;
+        self.platform_specific.titlebar_buttons_hidden = titlebar_buttons_hidden;
         self
     }
 
     #[inline]
     fn with_title_hidden(mut self, title_hidden: bool) -> Self {
-        self.window.platform_specific.title_hidden = title_hidden;
+        self.platform_specific.title_hidden = title_hidden;
         self
     }
 
     #[inline]
     fn with_fullsize_content_view(mut self, fullsize_content_view: bool) -> Self {
-        self.window.platform_specific.fullsize_content_view = fullsize_content_view;
+        self.platform_specific.fullsize_content_view = fullsize_content_view;
         self
     }
 
     #[inline]
     fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> Self {
-        self.window.platform_specific.disallow_hidpi = disallow_hidpi;
+        self.platform_specific.disallow_hidpi = disallow_hidpi;
         self
     }
 
     #[inline]
     fn with_has_shadow(mut self, has_shadow: bool) -> Self {
-        self.window.platform_specific.has_shadow = has_shadow;
+        self.platform_specific.has_shadow = has_shadow;
         self
     }
 
     #[inline]
     fn with_accepts_first_mouse(mut self, accepts_first_mouse: bool) -> Self {
-        self.window.platform_specific.accepts_first_mouse = accepts_first_mouse;
+        self.platform_specific.accepts_first_mouse = accepts_first_mouse;
         self
     }
 
     #[inline]
     fn with_tabbing_identifier(mut self, tabbing_identifier: &str) -> Self {
-        self.window
-            .platform_specific
+        self.platform_specific
             .tabbing_identifier
             .replace(tabbing_identifier.to_string());
         self
@@ -275,7 +273,7 @@ impl WindowBuilderExtMacOS for WindowBuilder {
 
     #[inline]
     fn with_option_as_alt(mut self, option_as_alt: OptionAsAlt) -> Self {
-        self.window.platform_specific.option_as_alt = option_as_alt;
+        self.platform_specific.option_as_alt = option_as_alt;
         self
     }
 }
@@ -367,11 +365,7 @@ impl MonitorHandleExtMacOS for MonitorHandle {
     }
 
     fn ns_screen(&self) -> Option<*mut c_void> {
-        // SAFETY: We only use the marker to get a pointer
-        let mtm = unsafe { icrate::Foundation::MainThreadMarker::new_unchecked() };
-        self.inner
-            .ns_screen(mtm)
-            .map(|s| objc2::rc::Id::as_ptr(&s) as _)
+        self.inner.ns_screen().map(|s| Id::as_ptr(&s) as _)
     }
 }
 
@@ -389,7 +383,7 @@ pub trait EventLoopWindowTargetExtMacOS {
     fn allows_automatic_window_tabbing(&self) -> bool;
 }
 
-impl EventLoopWindowTargetExtMacOS for EventLoopWindowTarget {
+impl<T> EventLoopWindowTargetExtMacOS for EventLoopWindowTarget<T> {
     fn hide_application(&self) {
         self.p.hide_application()
     }

src/platform/mod.rs

@@ -1,24 +1,38 @@
 //! Contains traits with platform-specific methods in them.
 //!
-//! Only the modules corresponding to the platform you're compiling to will be available.
+//! Contains the follow OS-specific modules:
+//!
+//!  - `android`
+//!  - `ios`
+//!  - `macos`
+//!  - `unix`
+//!  - `windows`
+//!  - `web`
+//!
+//! And the following platform-specific modules:
+//!
+//! - `run_on_demand` (available on `windows`, `unix`, `macos`, `android`)
+//! - `pump_events` (available on `windows`, `unix`, `macos`, `android`)
+//!
+//! However only the module corresponding to the platform you're compiling to will be available.
 
-#[cfg(any(android_platform, docsrs))]
+#[cfg(android_platform)]
 pub mod android;
-#[cfg(any(ios_platform, docsrs))]
+#[cfg(ios_platform)]
 pub mod ios;
-#[cfg(any(macos_platform, docsrs))]
+#[cfg(macos_platform)]
 pub mod macos;
-#[cfg(any(orbital_platform, docsrs))]
+#[cfg(orbital_platform)]
 pub mod orbital;
-#[cfg(any(x11_platform, wayland_platform, docsrs))]
+#[cfg(any(x11_platform, wayland_platform))]
 pub mod startup_notify;
-#[cfg(any(wayland_platform, docsrs))]
+#[cfg(wayland_platform)]
 pub mod wayland;
-#[cfg(any(web_platform, docsrs))]
+#[cfg(wasm_platform)]
 pub mod web;
-#[cfg(any(windows_platform, docsrs))]
+#[cfg(windows_platform)]
 pub mod windows;
-#[cfg(any(x11_platform, docsrs))]
+#[cfg(x11_platform)]
 pub mod x11;
 
 #[cfg(any(
@@ -26,8 +40,7 @@ pub mod x11;
     macos_platform,
     android_platform,
     x11_platform,
-    wayland_platform,
-    docsrs,
+    wayland_platform
 ))]
 pub mod run_on_demand;
 
@@ -36,26 +49,9 @@ pub mod run_on_demand;
     macos_platform,
     android_platform,
     x11_platform,
-    wayland_platform,
-    docsrs,
+    wayland_platform
 ))]
 pub mod pump_events;
 
-#[cfg(any(
-    windows_platform,
-    macos_platform,
-    x11_platform,
-    wayland_platform,
-    orbital_platform,
-    docsrs
-))]
 pub mod modifier_supplement;
-
-#[cfg(any(
-    windows_platform,
-    macos_platform,
-    x11_platform,
-    wayland_platform,
-    docsrs
-))]
 pub mod scancode;

src/platform/modifier_supplement.rs

@@ -1,4 +1,5 @@
-use crate::event::KeyEvent;
+#![cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform))]
+
 use crate::keyboard::Key;
 
 /// Additional methods for the `KeyEvent` which cannot be implemented on all
@@ -21,18 +22,3 @@ pub trait KeyEventExtModifierSupplement {
     /// cannot be `Dead`.
     fn key_without_modifiers(&self) -> Key;
 }
-
-impl KeyEventExtModifierSupplement for KeyEvent {
-    #[inline]
-    fn text_with_all_modifiers(&self) -> Option<&str> {
-        self.platform_specific
-            .text_with_all_modifiers
-            .as_ref()
-            .map(|s| s.as_str())
-    }
-
-    #[inline]
-    fn key_without_modifiers(&self) -> Key {
-        self.platform_specific.key_without_modifiers.clone()
-    }
-}

src/platform/pump_events.rs

@@ -51,12 +51,12 @@ pub trait EventLoopExtPumpEvents {
     /// #         event::{Event, WindowEvent},
     /// #         event_loop::EventLoop,
     /// #         platform::pump_events::{EventLoopExtPumpEvents, PumpStatus},
-    /// #         window::Window,
+    /// #         window::WindowBuilder,
     /// #     };
     ///     let mut event_loop = EventLoop::new().unwrap();
     /// #
     /// #   SimpleLogger::new().init().unwrap();
-    ///     let window = Window::builder()
+    ///     let window = WindowBuilder::new()
     ///         .with_title("A fantastic window!")
     ///         .build(&event_loop)
     ///         .unwrap();
@@ -155,26 +155,26 @@ pub trait EventLoopExtPumpEvents {
     /// - **Windows**: The implementation will use `PeekMessage` when checking for
     ///   window messages to avoid blocking your external event loop.
     ///
-    /// - **MacOS**: The implementation works in terms of stopping the global application
+    /// - **MacOS**: The implementation works in terms of stopping the global `NSApp`
     ///   whenever the application `RunLoop` indicates that it is preparing to block
     ///   and wait for new events.
     ///
     ///   This is very different to the polling APIs that are available on other
     ///   platforms (the lower level polling primitives on MacOS are private
-    ///   implementation details for `NSApplication` which aren't accessible to
-    ///   application developers)
+    ///   implementation details for `NSApp` which aren't accessible to application
+    ///   developers)
     ///
     ///   It's likely this will be less efficient than polling on other OSs and
-    ///   it also means the `NSApplication` is stopped while outside of the Winit
+    ///   it also means the `NSApp` is stopped while outside of the Winit
     ///   event loop - and that's observable (for example to crates like `rfd`)
-    ///   because the `NSApplication` is global state.
+    ///   because the `NSApp` is global state.
     ///
     ///   If you render outside of Winit you are likely to see window resizing artifacts
     ///   since MacOS expects applications to render synchronously during any `drawRect`
     ///   callback.
     fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
     where
-        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget);
+        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>);
 }
 
 impl<T> EventLoopExtPumpEvents for EventLoop<T> {
@@ -182,7 +182,7 @@ impl<T> EventLoopExtPumpEvents for EventLoop<T> {
 
     fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
     where
-        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget),
+        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>),
     {
         self.event_loop.pump_events(timeout, event_handler)
     }

src/platform/run_on_demand.rs

@@ -35,9 +35,9 @@ pub trait EventLoopExtRunOnDemand {
     /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
     ///
     /// # Caveats
-    /// - This extension isn't available on all platforms, since it's not always possible to return
-    ///   to the caller (specifically this is impossible on iOS and Web - though with the Web
-    ///   backend it is possible to use `EventLoopExtWebSys::spawn()`[^1] more than once instead).
+    /// - This extension isn't available on all platforms, since it's not always possible to
+    ///   return to the caller (specifically this is impossible on iOS and Web - though with
+    ///   the Web backend it is possible to use `spawn()` more than once instead).
     /// - No [`Window`] state can be carried between separate runs of the event loop.
     ///
     /// You are strongly encouraged to use [`EventLoop::run()`] for portability, unless you specifically need
@@ -55,18 +55,13 @@ pub trait EventLoopExtRunOnDemand {
     ///   loop that would block the browser and there is nothing that can be
     ///   polled to ask for new events. Events are delivered via callbacks based
     ///   on an event loop that is internal to the browser itself.
-    /// - **iOS:** It's not possible to stop and start an `UIApplication` repeatedly on iOS.
+    /// - **iOS:** It's not possible to stop and start an `NSApplication` repeatedly on iOS.
     ///
-    #[cfg_attr(
-        not(web_platform),
-        doc = "[^1]: `spawn()` is only available on `wasm` platforms."
-    )]
-    ///
-    /// [`exit()`]: EventLoopWindowTarget::exit()
-    /// [`set_control_flow()`]: EventLoopWindowTarget::set_control_flow()
+    /// [`exit()`]: EventLoopWindowTarget::exit
+    /// [`set_control_flow()`]: EventLoopWindowTarget::set_control_flow
     fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
     where
-        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget);
+        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>);
 }
 
 impl<T> EventLoopExtRunOnDemand for EventLoop<T> {
@@ -74,29 +69,8 @@ impl<T> EventLoopExtRunOnDemand for EventLoop<T> {
 
     fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
     where
-        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget),
+        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>),
     {
-        self.event_loop.window_target().clear_exit();
         self.event_loop.run_on_demand(event_handler)
     }
 }
-
-impl EventLoopWindowTarget {
-    /// Clear exit status.
-    pub(crate) fn clear_exit(&self) {
-        self.p.clear_exit()
-    }
-}
-
-/// ```compile_fail
-/// use winit::event_loop::EventLoop;
-/// use winit::platform::run_on_demand::EventLoopExtRunOnDemand;
-///
-/// let mut event_loop = EventLoop::new().unwrap();
-/// event_loop.run_on_demand(|_, _| {
-///     // Attempt to run the event loop re-entrantly; this must fail.
-///     event_loop.run_on_demand(|_, _| {});
-/// });
-/// ```
-#[allow(dead_code)]
-fn test_run_on_demand_cannot_access_event_loop() {}

src/platform/scancode.rs

@@ -1,12 +1,14 @@
-use crate::keyboard::{KeyCode, PhysicalKey};
+#![cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform))]
+
+use crate::keyboard::KeyCode;
 
 // TODO: Describe what this value contains for each platform
 
-/// Additional methods for the [`PhysicalKey`] type that allow the user to access the platform-specific
+/// Additional methods for the [`KeyCode`] type that allow the user to access the platform-specific
 /// scancode.
 ///
-/// [`PhysicalKey`]: crate::keyboard::PhysicalKey
-pub trait PhysicalKeyExtScancode {
+/// [`KeyCode`]: crate::keyboard::KeyCode
+pub trait KeyCodeExtScancode {
     /// The raw value of the platform-specific physical key identifier.
     ///
     /// Returns `Some(key_id)` if the conversion was succesful; returns `None` otherwise.
@@ -16,35 +18,13 @@ pub trait PhysicalKeyExtScancode {
     /// - **Wayland/X11**: A 32-bit linux scancode, which is X11/Wayland keycode subtracted by 8.
     fn to_scancode(self) -> Option<u32>;
 
-    /// Constructs a `PhysicalKey` from a platform-specific physical key identifier.
+    /// Constructs a `KeyCode` from a platform-specific physical key identifier.
     ///
-    /// Note that this conversion may be lossy, i.e. converting the returned `PhysicalKey` back
+    /// Note that this conversion may be lossy, i.e. converting the returned `KeyCode` back
     /// using `to_scancode` might not yield the original value.
     ///
     /// ## Platform-specific
     /// - **Wayland/X11**: A 32-bit linux scancode. When building from X11/Wayland keycode subtract
     ///                    `8` to get the value you wanted.
-    fn from_scancode(scancode: u32) -> PhysicalKey;
-}
-
-impl PhysicalKeyExtScancode for PhysicalKey {
-    fn to_scancode(self) -> Option<u32> {
-        crate::platform_impl::physicalkey_to_scancode(self)
-    }
-
-    fn from_scancode(scancode: u32) -> PhysicalKey {
-        crate::platform_impl::scancode_to_physicalkey(scancode)
-    }
-}
-
-impl PhysicalKeyExtScancode for KeyCode {
-    #[inline]
-    fn to_scancode(self) -> Option<u32> {
-        <PhysicalKey as PhysicalKeyExtScancode>::to_scancode(PhysicalKey::Code(self))
-    }
-
-    #[inline]
-    fn from_scancode(scancode: u32) -> PhysicalKey {
-        <PhysicalKey as PhysicalKeyExtScancode>::from_scancode(scancode)
-    }
+    fn from_scancode(scancode: u32) -> KeyCode;
 }

src/platform/startup_notify.rs

@@ -55,7 +55,7 @@ pub trait WindowBuilderExtStartupNotify {
     fn with_activation_token(self, token: ActivationToken) -> Self;
 }
 
-impl EventLoopExtStartupNotify for EventLoopWindowTarget {
+impl<T> EventLoopExtStartupNotify for EventLoopWindowTarget<T> {
     fn read_token_from_env(&self) -> Option<ActivationToken> {
         match self.p {
             #[cfg(wayland_platform)]
@@ -76,7 +76,7 @@ impl WindowExtStartupNotify for Window {
 
 impl WindowBuilderExtStartupNotify for WindowBuilder {
     fn with_activation_token(mut self, token: ActivationToken) -> Self {
-        self.window.platform_specific.activation_token = Some(token);
+        self.platform_specific.activation_token = Some(token);
         self
     }
 }

src/platform/wayland.rs

@@ -4,6 +4,8 @@ use crate::{
     window::{Window, WindowBuilder},
 };
 
+use crate::platform_impl::{ApplicationName, Backend};
+
 pub use crate::window::Theme;
 
 /// Additional methods on [`EventLoopWindowTarget`] that are specific to Wayland.
@@ -12,7 +14,7 @@ pub trait EventLoopWindowTargetExtWayland {
     fn is_wayland(&self) -> bool;
 }
 
-impl EventLoopWindowTargetExtWayland for EventLoopWindowTarget {
+impl<T> EventLoopWindowTargetExtWayland for EventLoopWindowTarget<T> {
     #[inline]
     fn is_wayland(&self) -> bool {
         self.p.is_wayland()
@@ -34,7 +36,7 @@ pub trait EventLoopBuilderExtWayland {
 impl<T> EventLoopBuilderExtWayland for EventLoopBuilder<T> {
     #[inline]
     fn with_wayland(&mut self) -> &mut Self {
-        self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::Wayland);
+        self.platform_specific.forced_backend = Some(Backend::Wayland);
         self
     }
 
@@ -65,10 +67,7 @@ pub trait WindowBuilderExtWayland {
 impl WindowBuilderExtWayland for WindowBuilder {
     #[inline]
     fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
-        self.window.platform_specific.name = Some(crate::platform_impl::ApplicationName::new(
-            general.into(),
-            instance.into(),
-        ));
+        self.platform_specific.name = Some(ApplicationName::new(general.into(), instance.into()));
         self
     }
 }

src/platform/web.rs

@@ -27,47 +27,16 @@
 //! [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
 //! [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
 
-use std::error::Error;
-use std::fmt::{self, Display, Formatter};
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
-use std::time::Duration;
+use crate::event::Event;
+use crate::event_loop::EventLoop;
+use crate::event_loop::EventLoopWindowTarget;
+use crate::window::{Window, WindowBuilder};
 
-#[cfg(web_platform)]
 use web_sys::HtmlCanvasElement;
 
-use crate::cursor::CustomCursorBuilder;
-use crate::event::Event;
-use crate::event_loop::{EventLoop, EventLoopWindowTarget};
-#[cfg(web_platform)]
-use crate::platform_impl::CustomCursorFuture as PlatformCustomCursorFuture;
-use crate::platform_impl::{PlatformCustomCursor, PlatformCustomCursorBuilder};
-use crate::window::{CustomCursor, Window, WindowBuilder};
-
-#[cfg(not(web_platform))]
-#[doc(hidden)]
-pub struct HtmlCanvasElement;
-
 pub trait WindowExtWebSys {
-    /// Only returns the canvas if called from inside the window context (the
-    /// main thread).
+    /// Only returns the canvas if called from inside the window.
     fn canvas(&self) -> Option<HtmlCanvasElement>;
-
-    /// Returns [`true`] if calling `event.preventDefault()` is enabled.
-    ///
-    /// See [`Window::set_prevent_default()`] for more details.
-    fn prevent_default(&self) -> bool;
-
-    /// Sets whether `event.preventDefault()` should be called on events on the
-    /// canvas that have side effects.
-    ///
-    /// For example, by default using the mouse wheel would cause the page to scroll, enabling this
-    /// would prevent that.
-    ///
-    /// Some events are impossible to prevent. E.g. Firefox allows to access the native browser
-    /// context menu with Shift+Rightclick.
-    fn set_prevent_default(&self, prevent_default: bool);
 }
 
 impl WindowExtWebSys for Window {
@@ -75,14 +44,6 @@ impl WindowExtWebSys for Window {
     fn canvas(&self) -> Option<HtmlCanvasElement> {
         self.window.canvas()
     }
-
-    fn prevent_default(&self) -> bool {
-        self.window.prevent_default()
-    }
-
-    fn set_prevent_default(&self, prevent_default: bool) {
-        self.window.set_prevent_default(prevent_default)
-    }
 }
 
 pub trait WindowBuilderExtWebSys {
@@ -92,17 +53,16 @@ pub trait WindowBuilderExtWebSys {
     /// In any case, the canvas won't be automatically inserted into the web page.
     ///
     /// [`None`] by default.
-    #[cfg_attr(
-        not(web_platform),
-        doc = "",
-        doc = "[`HtmlCanvasElement`]: #only-available-on-wasm"
-    )]
     fn with_canvas(self, canvas: Option<HtmlCanvasElement>) -> Self;
 
-    /// Sets whether `event.preventDefault()` should be called on events on the
-    /// canvas that have side effects.
+    /// Whether `event.preventDefault` should be automatically called to prevent event propagation
+    /// when appropriate.
     ///
-    /// See [`Window::set_prevent_default()`] for more details.
+    /// For example, mouse wheel events are only handled by the canvas by default. This avoids
+    /// the default behavior of scrolling the page.
+    ///
+    /// Some events are impossible to prevent. E.g. Firefox allows to access the native browser
+    /// context menu with Shift+Rightclick.
     ///
     /// Enabled by default.
     fn with_prevent_default(self, prevent_default: bool) -> Self;
@@ -121,22 +81,26 @@ pub trait WindowBuilderExtWebSys {
 
 impl WindowBuilderExtWebSys for WindowBuilder {
     fn with_canvas(mut self, canvas: Option<HtmlCanvasElement>) -> Self {
-        self.window.platform_specific.set_canvas(canvas);
+        self.platform_specific.canvas = canvas;
+
         self
     }
 
     fn with_prevent_default(mut self, prevent_default: bool) -> Self {
-        self.window.platform_specific.prevent_default = prevent_default;
+        self.platform_specific.prevent_default = prevent_default;
+
         self
     }
 
     fn with_focusable(mut self, focusable: bool) -> Self {
-        self.window.platform_specific.focusable = focusable;
+        self.platform_specific.focusable = focusable;
+
         self
     }
 
     fn with_append(mut self, append: bool) -> Self {
-        self.window.platform_specific.append = append;
+        self.platform_specific.append = append;
+
         self
     }
 }
@@ -148,31 +112,16 @@ pub trait EventLoopExtWebSys {
 
     /// Initializes the winit event loop.
     ///
-    /// Unlike
-    #[cfg_attr(
-        all(web_platform, target_feature = "exception-handling"),
-        doc = "`run()`"
-    )]
-    #[cfg_attr(
-        not(all(web_platform, target_feature = "exception-handling")),
-        doc = "[`run()`]"
-    )]
-    /// [^1], this returns immediately, and doesn't throw an exception in order to
-    /// satisfy its [`!`] return type.
+    /// Unlike `run`, this returns immediately, and doesn't throw an exception in order to
+    /// satisfy its `!` return type.
     ///
     /// Once the event loop has been destroyed, it's possible to reinitialize another event loop
     /// by calling this function again. This can be useful if you want to recreate the event loop
     /// while the WebAssembly module is still loaded. For example, this can be used to recreate the
     /// event loop when switching between tabs on a single page application.
-    ///
-    #[cfg_attr(
-        not(all(web_platform, target_feature = "exception-handling")),
-        doc = "[`run()`]: EventLoop::run()"
-    )]
-    /// [^1]: `run()` is _not_ available on WASM when the target supports `exception-handling`.
     fn spawn<F>(self, event_handler: F)
     where
-        F: 'static + FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget);
+        F: 'static + FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>);
 }
 
 impl<T> EventLoopExtWebSys for EventLoop<T> {
@@ -180,7 +129,7 @@ impl<T> EventLoopExtWebSys for EventLoop<T> {
 
     fn spawn<F>(self, event_handler: F)
     where
-        F: 'static + FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget),
+        F: 'static + FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>),
     {
         self.event_loop.spawn(event_handler)
     }
@@ -202,7 +151,7 @@ pub trait EventLoopWindowTargetExtWebSys {
     fn poll_strategy(&self) -> PollStrategy;
 }
 
-impl EventLoopWindowTargetExtWebSys for EventLoopWindowTarget {
+impl<T> EventLoopWindowTargetExtWebSys for EventLoopWindowTarget<T> {
     #[inline]
     fn set_poll_strategy(&self, strategy: PollStrategy) {
         self.p.set_poll_strategy(strategy);
@@ -239,126 +188,3 @@ pub enum PollStrategy {
     #[default]
     Scheduler,
 }
-
-pub trait CustomCursorExtWebSys {
-    /// Returns if this cursor is an animation.
-    fn is_animation(&self) -> bool;
-
-    /// Creates a new cursor from a URL pointing to an image.
-    /// It uses the [url css function](https://developer.mozilla.org/en-US/docs/Web/CSS/url),
-    /// but browser support for image formats is inconsistent. Using [PNG] is recommended.
-    ///
-    /// [PNG]: https://en.wikipedia.org/wiki/PNG
-    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorBuilder;
-
-    /// Crates a new animated cursor from multiple [`CustomCursor`]s.
-    /// Supplied `cursors` can't be empty or other animations.
-    fn from_animation(
-        duration: Duration,
-        cursors: Vec<CustomCursor>,
-    ) -> Result<CustomCursorBuilder, BadAnimation>;
-}
-
-impl CustomCursorExtWebSys for CustomCursor {
-    fn is_animation(&self) -> bool {
-        self.inner.animation
-    }
-
-    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorBuilder {
-        CustomCursorBuilder {
-            inner: PlatformCustomCursorBuilder::Url {
-                url,
-                hotspot_x,
-                hotspot_y,
-            },
-        }
-    }
-
-    fn from_animation(
-        duration: Duration,
-        cursors: Vec<CustomCursor>,
-    ) -> Result<CustomCursorBuilder, BadAnimation> {
-        if cursors.is_empty() {
-            return Err(BadAnimation::Empty);
-        }
-
-        if cursors.iter().any(CustomCursor::is_animation) {
-            return Err(BadAnimation::Animation);
-        }
-
-        Ok(CustomCursorBuilder {
-            inner: PlatformCustomCursorBuilder::Animation { duration, cursors },
-        })
-    }
-}
-
-/// An error produced when using [`CustomCursor::from_animation`] with invalid arguments.
-#[derive(Debug, Clone)]
-pub enum BadAnimation {
-    /// Produced when no cursors were supplied.
-    Empty,
-    /// Produced when a supplied cursor is an animation.
-    Animation,
-}
-
-impl fmt::Display for BadAnimation {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Empty => write!(f, "No cursors supplied"),
-            Self::Animation => write!(f, "A supplied cursor is an animtion"),
-        }
-    }
-}
-
-impl Error for BadAnimation {}
-
-pub trait CustomCursorBuilderExtWebSys {
-    /// Async version of [`CustomCursorBuilder::build()`] which waits until the
-    /// cursor has completely finished loading.
-    fn build_async(self, window_target: &EventLoopWindowTarget) -> CustomCursorFuture;
-}
-
-impl CustomCursorBuilderExtWebSys for CustomCursorBuilder {
-    fn build_async(self, window_target: &EventLoopWindowTarget) -> CustomCursorFuture {
-        CustomCursorFuture(PlatformCustomCursor::build_async(
-            self.inner,
-            &window_target.p,
-        ))
-    }
-}
-
-#[cfg(not(web_platform))]
-struct PlatformCustomCursorFuture;
-
-#[derive(Debug)]
-pub struct CustomCursorFuture(PlatformCustomCursorFuture);
-
-impl Future for CustomCursorFuture {
-    type Output = Result<CustomCursor, CustomCursorError>;
-
-    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        Pin::new(&mut self.0)
-            .poll(cx)
-            .map_ok(|cursor| CustomCursor { inner: cursor })
-    }
-}
-
-#[derive(Clone, Debug)]
-pub enum CustomCursorError {
-    Blob,
-    Decode(String),
-    Animation,
-}
-
-impl Display for CustomCursorError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Blob => write!(f, "failed to create `Blob`"),
-            Self::Decode(error) => write!(f, "failed to decode image: {error}"),
-            Self::Animation => write!(
-                f,
-                "found `CustomCursor` that is an animation when building an animation"
-            ),
-        }
-    }
-}

src/platform/windows.rs

@@ -2,9 +2,12 @@ use std::{ffi::c_void, path::Path};
 
 use crate::{
     dpi::PhysicalSize,
-    event::DeviceId,
+    event::{DeviceId, KeyEvent},
     event_loop::EventLoopBuilder,
+    keyboard::Key,
     monitor::MonitorHandle,
+    platform::modifier_supplement::KeyEventExtModifierSupplement,
+    platform_impl::WinIcon,
     window::{BadIcon, Icon, Window, WindowBuilder},
 };
 
@@ -15,92 +18,6 @@ pub type HMENU = isize;
 /// Monitor Handle type used by Win32 API
 pub type HMONITOR = isize;
 
-/// Describes a system-drawn backdrop material of a window.
-///
-/// For a detailed explanation, see [`DWM_SYSTEMBACKDROP_TYPE docs`].
-///
-/// [`DWM_SYSTEMBACKDROP_TYPE docs`]: https://learn.microsoft.com/en-us/windows/win32/api/dwmapi/ne-dwmapi-dwm_systembackdrop_type
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum BackdropType {
-    /// Corresponds to `DWMSBT_AUTO`.
-    ///
-    /// Usually draws a default backdrop effect on the title bar.
-    #[default]
-    Auto = 0,
-
-    /// Corresponds to `DWMSBT_NONE`.
-    None = 1,
-
-    /// Corresponds to `DWMSBT_MAINWINDOW`.
-    ///
-    /// Draws the Mica backdrop material.
-    MainWindow = 2,
-
-    /// Corresponds to `DWMSBT_TRANSIENTWINDOW`.
-    ///
-    /// Draws the Background Acrylic backdrop material.
-    TransientWindow = 3,
-
-    /// Corresponds to `DWMSBT_TABBEDWINDOW`.
-    ///
-    /// Draws the Alt Mica backdrop material.
-    TabbedWindow = 4,
-}
-
-/// Describes a color used by Windows
-#[repr(transparent)]
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct Color(u32);
-
-impl Color {
-    /// Use the system's default color
-    pub const SYSTEM_DEFAULT: Color = Color(0xFFFFFFFF);
-
-    //Special constant only valid for the window border and therefore modeled using Option<Color> for user facing code
-    const NONE: Color = Color(0xFFFFFFFE);
-
-    /// Create a new color from the given RGB values
-    pub const fn from_rgb(r: u8, g: u8, b: u8) -> Self {
-        Self((r as u32) | ((g as u32) << 8) | ((b as u32) << 16))
-    }
-}
-
-impl Default for Color {
-    fn default() -> Self {
-        Self::SYSTEM_DEFAULT
-    }
-}
-
-/// Describes how the corners of a window should look like.
-///
-/// For a detailed explanation, see [`DWM_WINDOW_CORNER_PREFERENCE docs`].
-///
-/// [`DWM_WINDOW_CORNER_PREFERENCE docs`]: https://learn.microsoft.com/en-us/windows/win32/api/dwmapi/ne-dwmapi-dwm_window_corner_preference
-#[repr(i32)]
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum CornerPreference {
-    /// Corresponds to `DWMWCP_DEFAULT`.
-    ///
-    /// Let the system decide when to round window corners.
-    #[default]
-    Default = 0,
-
-    /// Corresponds to `DWMWCP_DONOTROUND`.
-    ///
-    /// Never round window corners.
-    DoNotRound = 1,
-
-    /// Corresponds to `DWMWCP_ROUND`.
-    ///
-    /// Round the corners, if appropriate.
-    Round = 2,
-
-    /// Corresponds to `DWMWCP_ROUNDSMALL`.
-    ///
-    /// Round the corners if appropriate, with a small radius.
-    RoundSmall = 3,
-}
-
 /// Additional methods on `EventLoop` that are specific to Windows.
 pub trait EventLoopBuilderExtWindows {
     /// Whether to allow the event loop to be created off of the main thread.
@@ -219,31 +136,6 @@ pub trait WindowExtWindows {
     ///
     /// Enabling the shadow causes a thin 1px line to appear on the top of the window.
     fn set_undecorated_shadow(&self, shadow: bool);
-
-    /// Sets system-drawn backdrop type.
-    ///
-    /// Requires Windows 11 build 22523+.
-    fn set_system_backdrop(&self, backdrop_type: BackdropType);
-
-    /// Sets the color of the window border.
-    ///
-    /// Supported starting with Windows 11 Build 22000.
-    fn set_border_color(&self, color: Option<Color>);
-
-    /// Sets the background color of the title bar.
-    ///
-    /// Supported starting with Windows 11 Build 22000.
-    fn set_title_background_color(&self, color: Option<Color>);
-
-    /// Sets the color of the window title.
-    ///
-    /// Supported starting with Windows 11 Build 22000.
-    fn set_title_text_color(&self, color: Color);
-
-    /// Sets the preferred style of the window corners.
-    ///
-    /// Supported starting with Windows 11 Build 22000.
-    fn set_corner_preference(&self, preference: CornerPreference);
 }
 
 impl WindowExtWindows for Window {
@@ -266,34 +158,6 @@ impl WindowExtWindows for Window {
     fn set_undecorated_shadow(&self, shadow: bool) {
         self.window.set_undecorated_shadow(shadow)
     }
-
-    #[inline]
-    fn set_system_backdrop(&self, backdrop_type: BackdropType) {
-        self.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))
-    }
-
-    #[inline]
-    fn set_title_background_color(&self, color: Option<Color>) {
-        // 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))
-    }
-
-    #[inline]
-    fn set_title_text_color(&self, color: Color) {
-        self.window.set_title_text_color(color)
-    }
-
-    #[inline]
-    fn set_corner_preference(&self, preference: CornerPreference) {
-        self.window.set_corner_preference(preference)
-    }
 }
 
 /// Additional methods on `WindowBuilder` that are specific to Windows.
@@ -321,14 +185,7 @@ pub trait WindowBuilderExtWindows {
     /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how the menus look.
     /// If you use this, it is recommended that you combine it with `with_theme(Some(Theme::Light))` to avoid a jarring effect.
     ///
-    #[cfg_attr(
-        platform_windows,
-        doc = "[`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu"
-    )]
-    #[cfg_attr(
-        not(platform_windows),
-        doc = "[`CreateMenu`]: #only-available-on-windows"
-    )]
+    /// [`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu
     fn with_menu(self, menu: HMENU) -> Self;
 
     /// This sets `ICON_BIG`. A good ceiling here is 256x256.
@@ -356,118 +213,54 @@ pub trait WindowBuilderExtWindows {
     /// The shadow is hidden by default.
     /// Enabling the shadow causes a thin 1px line to appear on the top of the window.
     fn with_undecorated_shadow(self, shadow: bool) -> Self;
-
-    /// Sets system-drawn backdrop type.
-    ///
-    /// Requires Windows 11 build 22523+.
-    fn with_system_backdrop(self, backdrop_type: BackdropType) -> Self;
-
-    /// This sets or removes `WS_CLIPCHILDREN` style.
-    fn with_clip_children(self, flag: bool) -> Self;
-
-    /// Sets the color of the window border.
-    ///
-    /// Supported starting with Windows 11 Build 22000.
-    fn with_border_color(self, color: Option<Color>) -> Self;
-
-    /// Sets the background color of the title bar.
-    ///
-    /// Supported starting with Windows 11 Build 22000.
-    fn with_title_background_color(self, color: Option<Color>) -> Self;
-
-    /// Sets the color of the window title.
-    ///
-    /// Supported starting with Windows 11 Build 22000.
-    fn with_title_text_color(self, color: Color) -> Self;
-
-    /// Sets the preferred style of the window corners.
-    ///
-    /// Supported starting with Windows 11 Build 22000.
-    fn with_corner_preference(self, corners: CornerPreference) -> Self;
 }
 
 impl WindowBuilderExtWindows for WindowBuilder {
     #[inline]
     fn with_owner_window(mut self, parent: HWND) -> Self {
-        self.window.platform_specific.owner = Some(parent);
+        self.platform_specific.owner = Some(parent);
         self
     }
 
     #[inline]
     fn with_menu(mut self, menu: HMENU) -> Self {
-        self.window.platform_specific.menu = Some(menu);
+        self.platform_specific.menu = Some(menu);
         self
     }
 
     #[inline]
     fn with_taskbar_icon(mut self, taskbar_icon: Option<Icon>) -> Self {
-        self.window.platform_specific.taskbar_icon = taskbar_icon;
+        self.platform_specific.taskbar_icon = taskbar_icon;
         self
     }
 
     #[inline]
     fn with_no_redirection_bitmap(mut self, flag: bool) -> Self {
-        self.window.platform_specific.no_redirection_bitmap = flag;
+        self.platform_specific.no_redirection_bitmap = flag;
         self
     }
 
     #[inline]
     fn with_drag_and_drop(mut self, flag: bool) -> Self {
-        self.window.platform_specific.drag_and_drop = flag;
+        self.platform_specific.drag_and_drop = flag;
         self
     }
 
     #[inline]
     fn with_skip_taskbar(mut self, skip: bool) -> Self {
-        self.window.platform_specific.skip_taskbar = skip;
+        self.platform_specific.skip_taskbar = skip;
         self
     }
 
     #[inline]
     fn with_class_name<S: Into<String>>(mut self, class_name: S) -> Self {
-        self.window.platform_specific.class_name = class_name.into();
+        self.platform_specific.class_name = class_name.into();
         self
     }
 
     #[inline]
     fn with_undecorated_shadow(mut self, shadow: bool) -> Self {
-        self.window.platform_specific.decoration_shadow = shadow;
-        self
-    }
-
-    #[inline]
-    fn with_system_backdrop(mut self, backdrop_type: BackdropType) -> Self {
-        self.window.platform_specific.backdrop_type = backdrop_type;
-        self
-    }
-
-    #[inline]
-    fn with_clip_children(mut self, flag: bool) -> Self {
-        self.window.platform_specific.clip_children = flag;
-        self
-    }
-
-    #[inline]
-    fn with_border_color(mut self, color: Option<Color>) -> Self {
-        self.window.platform_specific.border_color = Some(color.unwrap_or(Color::NONE));
-        self
-    }
-
-    #[inline]
-    fn with_title_background_color(mut self, color: Option<Color>) -> Self {
-        self.window.platform_specific.title_background_color = Some(color.unwrap_or(Color::NONE));
-        self
-    }
-
-    #[inline]
-    fn with_title_text_color(mut self, color: Color) -> Self {
-        self.window.platform_specific.title_text_color = Some(color);
-        self
-    }
-
-    #[inline]
-    fn with_corner_preference(mut self, corners: CornerPreference) -> Self {
-        self.window.platform_specific.corner_preference = Some(corners);
+        self.platform_specific.decoration_shadow = shadow;
         self
     }
 }
@@ -535,12 +328,27 @@ impl IconExtWindows for Icon {
         path: P,
         size: Option<PhysicalSize<u32>>,
     ) -> Result<Self, BadIcon> {
-        let win_icon = crate::platform_impl::WinIcon::from_path(path, size)?;
+        let win_icon = WinIcon::from_path(path, size)?;
         Ok(Icon { inner: win_icon })
     }
 
     fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
-        let win_icon = crate::platform_impl::WinIcon::from_resource(ordinal, size)?;
+        let win_icon = WinIcon::from_resource(ordinal, size)?;
         Ok(Icon { inner: win_icon })
     }
 }
+
+impl KeyEventExtModifierSupplement for KeyEvent {
+    #[inline]
+    fn text_with_all_modifiers(&self) -> Option<&str> {
+        self.platform_specific
+            .text_with_all_modifers
+            .as_ref()
+            .map(|s| s.as_str())
+    }
+
+    #[inline]
+    fn key_without_modifiers(&self) -> Key {
+        self.platform_specific.key_without_modifiers.clone()
+    }
+}

src/platform/x11.rs

@@ -1,6 +1,3 @@
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-
 use crate::{
     event_loop::{EventLoopBuilder, EventLoopWindowTarget},
     monitor::MonitorHandle,
@@ -8,50 +5,9 @@ use crate::{
 };
 
 use crate::dpi::Size;
+use crate::platform_impl::{ApplicationName, Backend, XLIB_ERROR_HOOKS};
 
-/// X window type. Maps directly to
-/// [`_NET_WM_WINDOW_TYPE`](https://specifications.freedesktop.org/wm-spec/wm-spec-1.5.html).
-#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum WindowType {
-    /// A desktop feature. This can include a single window containing desktop icons with the same dimensions as the
-    /// screen, allowing the desktop environment to have full control of the desktop, without the need for proxying
-    /// root window clicks.
-    Desktop,
-    /// A dock or panel feature. Typically a Window Manager would keep such windows on top of all other windows.
-    Dock,
-    /// Toolbar windows. "Torn off" from the main application.
-    Toolbar,
-    /// Pinnable menu windows. "Torn off" from the main application.
-    Menu,
-    /// A small persistent utility window, such as a palette or toolbox.
-    Utility,
-    /// The window is a splash screen displayed as an application is starting up.
-    Splash,
-    /// This is a dialog window.
-    Dialog,
-    /// A dropdown menu that usually appears when the user clicks on an item in a menu bar.
-    /// This property is typically used on override-redirect windows.
-    DropdownMenu,
-    /// A popup menu that usually appears when the user right clicks on an object.
-    /// This property is typically used on override-redirect windows.
-    PopupMenu,
-    /// A tooltip window. Usually used to show additional information when hovering over an object with the cursor.
-    /// This property is typically used on override-redirect windows.
-    Tooltip,
-    /// The window is a notification.
-    /// This property is typically used on override-redirect windows.
-    Notification,
-    /// This should be used on the windows that are popped up by combo boxes.
-    /// This property is typically used on override-redirect windows.
-    Combo,
-    /// This indicates the the window is being dragged.
-    /// This property is typically used on override-redirect windows.
-    Dnd,
-    /// This is a normal, top-level window.
-    #[default]
-    Normal,
-}
+pub use crate::platform_impl::{x11::util::WindowType as XWindowType, XNotSupported};
 
 /// The first argument in the provided hook will be the pointer to `XDisplay`
 /// and the second one the pointer to [`XErrorEvent`]. The returned `bool` is an
@@ -82,10 +38,7 @@ pub type XWindow = u32;
 pub fn register_xlib_error_hook(hook: XlibErrorHook) {
     // Append new hook.
     unsafe {
-        crate::platform_impl::XLIB_ERROR_HOOKS
-            .lock()
-            .unwrap()
-            .push(hook);
+        XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
     }
 }
 
@@ -95,7 +48,7 @@ pub trait EventLoopWindowTargetExtX11 {
     fn is_x11(&self) -> bool;
 }
 
-impl EventLoopWindowTargetExtX11 for EventLoopWindowTarget {
+impl<T> EventLoopWindowTargetExtX11 for EventLoopWindowTarget<T> {
     #[inline]
     fn is_x11(&self) -> bool {
         !self.p.is_wayland()
@@ -117,7 +70,7 @@ pub trait EventLoopBuilderExtX11 {
 impl<T> EventLoopBuilderExtX11 for EventLoopBuilder<T> {
     #[inline]
     fn with_x11(&mut self) -> &mut Self {
-        self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::X);
+        self.platform_specific.forced_backend = Some(Backend::X);
         self
     }
 
@@ -143,29 +96,29 @@ pub trait WindowBuilderExtX11 {
     /// Build window with the given `general` and `instance` names.
     ///
     /// The `general` sets general class of `WM_CLASS(STRING)`, while `instance` set the
-    /// instance part of it. The resulted property looks like `WM_CLASS(STRING) = "instance", "general"`.
+    /// instance part of it. The resulted property looks like `WM_CLASS(STRING) = "general", "instance"`.
     ///
     /// For details about application ID conventions, see the
     /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
     fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;
 
-    /// Build window with override-redirect flag; defaults to false.
+    /// Build window with override-redirect flag; defaults to false. Only relevant on X11.
     fn with_override_redirect(self, override_redirect: bool) -> Self;
 
-    /// Build window with `_NET_WM_WINDOW_TYPE` hints; defaults to `Normal`.
-    fn with_x11_window_type(self, x11_window_type: Vec<WindowType>) -> Self;
+    /// Build window with `_NET_WM_WINDOW_TYPE` hints; defaults to `Normal`. Only relevant on X11.
+    fn with_x11_window_type(self, x11_window_type: Vec<XWindowType>) -> Self;
 
-    /// Build window with base size hint.
+    /// Build window with base size hint. Only implemented on X11.
     ///
     /// ```
     /// # use winit::dpi::{LogicalSize, PhysicalSize};
-    /// # use winit::window::Window;
+    /// # use winit::window::WindowBuilder;
     /// # use winit::platform::x11::WindowBuilderExtX11;
     /// // Specify the size in logical dimensions like this:
-    /// Window::builder().with_base_size(LogicalSize::new(400.0, 200.0));
+    /// WindowBuilder::new().with_base_size(LogicalSize::new(400.0, 200.0));
     ///
     /// // Or specify the size in physical dimensions like this:
-    /// Window::builder().with_base_size(PhysicalSize::new(400, 200));
+    /// WindowBuilder::new().with_base_size(PhysicalSize::new(400, 200));
     /// ```
     fn with_base_size<S: Into<Size>>(self, base_size: S) -> Self;
 
@@ -174,12 +127,12 @@ pub trait WindowBuilderExtX11 {
     /// # Example
     ///
     /// ```no_run
-    /// use winit::window::Window;
+    /// use winit::window::WindowBuilder;
     /// use winit::platform::x11::{XWindow, WindowBuilderExtX11};
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
     /// let event_loop = winit::event_loop::EventLoop::new().unwrap();
     /// let parent_window_id = std::env::args().nth(1).unwrap().parse::<XWindow>()?;
-    /// let window = Window::builder()
+    /// let window = WindowBuilder::new()
     ///     .with_embed_parent_window(parent_window_id)
     ///     .build(&event_loop)?;
     /// # Ok(()) }
@@ -190,46 +143,43 @@ pub trait WindowBuilderExtX11 {
 impl WindowBuilderExtX11 for WindowBuilder {
     #[inline]
     fn with_x11_visual(mut self, visual_id: XVisualID) -> Self {
-        self.window.platform_specific.x11.visual_id = Some(visual_id);
+        self.platform_specific.x11.visual_id = Some(visual_id);
         self
     }
 
     #[inline]
     fn with_x11_screen(mut self, screen_id: i32) -> Self {
-        self.window.platform_specific.x11.screen_id = Some(screen_id);
+        self.platform_specific.x11.screen_id = Some(screen_id);
         self
     }
 
     #[inline]
     fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
-        self.window.platform_specific.name = Some(crate::platform_impl::ApplicationName::new(
-            general.into(),
-            instance.into(),
-        ));
+        self.platform_specific.name = Some(ApplicationName::new(general.into(), instance.into()));
         self
     }
 
     #[inline]
     fn with_override_redirect(mut self, override_redirect: bool) -> Self {
-        self.window.platform_specific.x11.override_redirect = override_redirect;
+        self.platform_specific.x11.override_redirect = override_redirect;
         self
     }
 
     #[inline]
-    fn with_x11_window_type(mut self, x11_window_types: Vec<WindowType>) -> Self {
-        self.window.platform_specific.x11.x11_window_types = x11_window_types;
+    fn with_x11_window_type(mut self, x11_window_types: Vec<XWindowType>) -> Self {
+        self.platform_specific.x11.x11_window_types = x11_window_types;
         self
     }
 
     #[inline]
     fn with_base_size<S: Into<Size>>(mut self, base_size: S) -> Self {
-        self.window.platform_specific.x11.base_size = Some(base_size.into());
+        self.platform_specific.x11.base_size = Some(base_size.into());
         self
     }
 
     #[inline]
     fn with_embed_parent_window(mut self, parent_window_id: XWindow) -> Self {
-        self.window.platform_specific.x11.embed_window = Some(parent_window_id);
+        self.platform_specific.x11.embed_window = Some(parent_window_id);
         self
     }
 }

src/platform_impl/android/keycodes.rs

@@ -3,10 +3,10 @@ use android_activity::{
     AndroidApp,
 };
 
-use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
+use crate::keyboard::{Key, KeyCode, KeyLocation, NativeKey, NativeKeyCode};
 
-pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
-    PhysicalKey::Code(match keycode {
+pub fn to_physical_keycode(keycode: Keycode) -> KeyCode {
+    match keycode {
         Keycode::A => KeyCode::KeyA,
         Keycode::B => KeyCode::KeyB,
         Keycode::C => KeyCode::KeyC,
@@ -155,8 +155,8 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         Keycode::Sleep => KeyCode::Sleep, // what about SoftSleep?
         Keycode::Wakeup => KeyCode::WakeUp,
 
-        keycode => return PhysicalKey::Unidentified(NativeKeyCode::Android(keycode.into())),
-    })
+        keycode => KeyCode::Unidentified(NativeKeyCode::Android(keycode.into())),
+    }
 }
 
 /// Tries to map the `key_event` to a `KeyMapChar` containing a unicode character or dead key accent
@@ -231,10 +231,10 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
         None | Some(KeyMapChar::None) => match keycode {
             // Using `BrowserHome` instead of `GoHome` according to
             // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
-            Home => Key::Named(NamedKey::BrowserHome),
-            Back => Key::Named(NamedKey::BrowserBack),
-            Call => Key::Named(NamedKey::Call),
-            Endcall => Key::Named(NamedKey::EndCall),
+            Home => Key::BrowserHome,
+            Back => Key::BrowserBack,
+            Call => Key::Call,
+            Endcall => Key::EndCall,
 
             //-------------------------------------------------------------------------------
             // These should be redundant because they should have already been matched
@@ -291,81 +291,81 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
             At => Key::Character("@".into()),
             Plus => Key::Character("+".into()),
             //-------------------------------------------------------------------------------
-            DpadUp => Key::Named(NamedKey::ArrowUp),
-            DpadDown => Key::Named(NamedKey::ArrowDown),
-            DpadLeft => Key::Named(NamedKey::ArrowLeft),
-            DpadRight => Key::Named(NamedKey::ArrowRight),
-            DpadCenter => Key::Named(NamedKey::Enter),
+            DpadUp => Key::ArrowUp,
+            DpadDown => Key::ArrowDown,
+            DpadLeft => Key::ArrowLeft,
+            DpadRight => Key::ArrowRight,
+            DpadCenter => Key::Enter,
 
-            VolumeUp => Key::Named(NamedKey::AudioVolumeUp),
-            VolumeDown => Key::Named(NamedKey::AudioVolumeDown),
-            Power => Key::Named(NamedKey::Power),
-            Camera => Key::Named(NamedKey::Camera),
-            Clear => Key::Named(NamedKey::Clear),
+            VolumeUp => Key::AudioVolumeUp,
+            VolumeDown => Key::AudioVolumeDown,
+            Power => Key::Power,
+            Camera => Key::Camera,
+            Clear => Key::Clear,
 
-            AltLeft => Key::Named(NamedKey::Alt),
-            AltRight => Key::Named(NamedKey::Alt),
-            ShiftLeft => Key::Named(NamedKey::Shift),
-            ShiftRight => Key::Named(NamedKey::Shift),
-            Tab => Key::Named(NamedKey::Tab),
-            Space => Key::Named(NamedKey::Space),
-            Sym => Key::Named(NamedKey::Symbol),
-            Explorer => Key::Named(NamedKey::LaunchWebBrowser),
-            Envelope => Key::Named(NamedKey::LaunchMail),
-            Enter => Key::Named(NamedKey::Enter),
-            Del => Key::Named(NamedKey::Backspace),
+            AltLeft => Key::Alt,
+            AltRight => Key::Alt,
+            ShiftLeft => Key::Shift,
+            ShiftRight => Key::Shift,
+            Tab => Key::Tab,
+            Space => Key::Space,
+            Sym => Key::Symbol,
+            Explorer => Key::LaunchWebBrowser,
+            Envelope => Key::LaunchMail,
+            Enter => Key::Enter,
+            Del => Key::Backspace,
 
             // According to https://developer.android.com/reference/android/view/KeyEvent#KEYCODE_NUM
-            Num => Key::Named(NamedKey::Alt),
+            Num => Key::Alt,
 
-            Headsethook => Key::Named(NamedKey::HeadsetHook),
-            Focus => Key::Named(NamedKey::CameraFocus),
+            Headsethook => Key::HeadsetHook,
+            Focus => Key::CameraFocus,
 
-            Notification => Key::Named(NamedKey::Notification),
-            Search => Key::Named(NamedKey::BrowserSearch),
-            MediaPlayPause => Key::Named(NamedKey::MediaPlayPause),
-            MediaStop => Key::Named(NamedKey::MediaStop),
-            MediaNext => Key::Named(NamedKey::MediaTrackNext),
-            MediaPrevious => Key::Named(NamedKey::MediaTrackPrevious),
-            MediaRewind => Key::Named(NamedKey::MediaRewind),
-            MediaFastForward => Key::Named(NamedKey::MediaFastForward),
-            Mute => Key::Named(NamedKey::MicrophoneVolumeMute),
-            PageUp => Key::Named(NamedKey::PageUp),
-            PageDown => Key::Named(NamedKey::PageDown),
+            Notification => Key::Notification,
+            Search => Key::BrowserSearch,
+            MediaPlayPause => Key::MediaPlayPause,
+            MediaStop => Key::MediaStop,
+            MediaNext => Key::MediaTrackNext,
+            MediaPrevious => Key::MediaTrackPrevious,
+            MediaRewind => Key::MediaRewind,
+            MediaFastForward => Key::MediaFastForward,
+            Mute => Key::MicrophoneVolumeMute,
+            PageUp => Key::PageUp,
+            PageDown => Key::PageDown,
 
-            Escape => Key::Named(NamedKey::Escape),
-            ForwardDel => Key::Named(NamedKey::Delete),
-            CtrlLeft => Key::Named(NamedKey::Control),
-            CtrlRight => Key::Named(NamedKey::Control),
-            CapsLock => Key::Named(NamedKey::CapsLock),
-            ScrollLock => Key::Named(NamedKey::ScrollLock),
-            MetaLeft => Key::Named(NamedKey::Super),
-            MetaRight => Key::Named(NamedKey::Super),
-            Function => Key::Named(NamedKey::Fn),
-            Sysrq => Key::Named(NamedKey::PrintScreen),
-            Break => Key::Named(NamedKey::Pause),
-            MoveHome => Key::Named(NamedKey::Home),
-            MoveEnd => Key::Named(NamedKey::End),
-            Insert => Key::Named(NamedKey::Insert),
-            Forward => Key::Named(NamedKey::BrowserForward),
-            MediaPlay => Key::Named(NamedKey::MediaPlay),
-            MediaPause => Key::Named(NamedKey::MediaPause),
-            MediaClose => Key::Named(NamedKey::MediaClose),
-            MediaEject => Key::Named(NamedKey::Eject),
-            MediaRecord => Key::Named(NamedKey::MediaRecord),
-            F1 => Key::Named(NamedKey::F1),
-            F2 => Key::Named(NamedKey::F2),
-            F3 => Key::Named(NamedKey::F3),
-            F4 => Key::Named(NamedKey::F4),
-            F5 => Key::Named(NamedKey::F5),
-            F6 => Key::Named(NamedKey::F6),
-            F7 => Key::Named(NamedKey::F7),
-            F8 => Key::Named(NamedKey::F8),
-            F9 => Key::Named(NamedKey::F9),
-            F10 => Key::Named(NamedKey::F10),
-            F11 => Key::Named(NamedKey::F11),
-            F12 => Key::Named(NamedKey::F12),
-            NumLock => Key::Named(NamedKey::NumLock),
+            Escape => Key::Escape,
+            ForwardDel => Key::Delete,
+            CtrlLeft => Key::Control,
+            CtrlRight => Key::Control,
+            CapsLock => Key::CapsLock,
+            ScrollLock => Key::ScrollLock,
+            MetaLeft => Key::Super,
+            MetaRight => Key::Super,
+            Function => Key::Fn,
+            Sysrq => Key::PrintScreen,
+            Break => Key::Pause,
+            MoveHome => Key::Home,
+            MoveEnd => Key::End,
+            Insert => Key::Insert,
+            Forward => Key::BrowserForward,
+            MediaPlay => Key::MediaPlay,
+            MediaPause => Key::MediaPause,
+            MediaClose => Key::MediaClose,
+            MediaEject => Key::Eject,
+            MediaRecord => Key::MediaRecord,
+            F1 => Key::F1,
+            F2 => Key::F2,
+            F3 => Key::F3,
+            F4 => Key::F4,
+            F5 => Key::F5,
+            F6 => Key::F6,
+            F7 => Key::F7,
+            F8 => Key::F8,
+            F9 => Key::F9,
+            F10 => Key::F10,
+            F11 => Key::F11,
+            F12 => Key::F12,
+            NumLock => Key::NumLock,
             Numpad0 => Key::Character("0".into()),
             Numpad1 => Key::Character("1".into()),
             Numpad2 => Key::Character("2".into()),
@@ -382,97 +382,97 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
             NumpadAdd => Key::Character("+".into()),
             NumpadDot => Key::Character(".".into()),
             NumpadComma => Key::Character(",".into()),
-            NumpadEnter => Key::Named(NamedKey::Enter),
+            NumpadEnter => Key::Enter,
             NumpadEquals => Key::Character("=".into()),
             NumpadLeftParen => Key::Character("(".into()),
             NumpadRightParen => Key::Character(")".into()),
 
-            VolumeMute => Key::Named(NamedKey::AudioVolumeMute),
-            Info => Key::Named(NamedKey::Info),
-            ChannelUp => Key::Named(NamedKey::ChannelUp),
-            ChannelDown => Key::Named(NamedKey::ChannelDown),
-            ZoomIn => Key::Named(NamedKey::ZoomIn),
-            ZoomOut => Key::Named(NamedKey::ZoomOut),
-            Tv => Key::Named(NamedKey::TV),
-            Guide => Key::Named(NamedKey::Guide),
-            Dvr => Key::Named(NamedKey::DVR),
-            Bookmark => Key::Named(NamedKey::BrowserFavorites),
-            Captions => Key::Named(NamedKey::ClosedCaptionToggle),
-            Settings => Key::Named(NamedKey::Settings),
-            TvPower => Key::Named(NamedKey::TVPower),
-            TvInput => Key::Named(NamedKey::TVInput),
-            StbPower => Key::Named(NamedKey::STBPower),
-            StbInput => Key::Named(NamedKey::STBInput),
-            AvrPower => Key::Named(NamedKey::AVRPower),
-            AvrInput => Key::Named(NamedKey::AVRInput),
-            ProgRed => Key::Named(NamedKey::ColorF0Red),
-            ProgGreen => Key::Named(NamedKey::ColorF1Green),
-            ProgYellow => Key::Named(NamedKey::ColorF2Yellow),
-            ProgBlue => Key::Named(NamedKey::ColorF3Blue),
-            AppSwitch => Key::Named(NamedKey::AppSwitch),
-            LanguageSwitch => Key::Named(NamedKey::GroupNext),
-            MannerMode => Key::Named(NamedKey::MannerMode),
-            Keycode3dMode => Key::Named(NamedKey::TV3DMode),
-            Contacts => Key::Named(NamedKey::LaunchContacts),
-            Calendar => Key::Named(NamedKey::LaunchCalendar),
-            Music => Key::Named(NamedKey::LaunchMusicPlayer),
-            Calculator => Key::Named(NamedKey::LaunchApplication2),
-            ZenkakuHankaku => Key::Named(NamedKey::ZenkakuHankaku),
-            Eisu => Key::Named(NamedKey::Eisu),
-            Muhenkan => Key::Named(NamedKey::NonConvert),
-            Henkan => Key::Named(NamedKey::Convert),
-            KatakanaHiragana => Key::Named(NamedKey::HiraganaKatakana),
-            Kana => Key::Named(NamedKey::KanjiMode),
-            BrightnessDown => Key::Named(NamedKey::BrightnessDown),
-            BrightnessUp => Key::Named(NamedKey::BrightnessUp),
-            MediaAudioTrack => Key::Named(NamedKey::MediaAudioTrack),
-            Sleep => Key::Named(NamedKey::Standby),
-            Wakeup => Key::Named(NamedKey::WakeUp),
-            Pairing => Key::Named(NamedKey::Pairing),
-            MediaTopMenu => Key::Named(NamedKey::MediaTopMenu),
-            LastChannel => Key::Named(NamedKey::MediaLast),
-            TvDataService => Key::Named(NamedKey::TVDataService),
-            VoiceAssist => Key::Named(NamedKey::VoiceDial),
-            TvRadioService => Key::Named(NamedKey::TVRadioService),
-            TvTeletext => Key::Named(NamedKey::Teletext),
-            TvNumberEntry => Key::Named(NamedKey::TVNumberEntry),
-            TvTerrestrialAnalog => Key::Named(NamedKey::TVTerrestrialAnalog),
-            TvTerrestrialDigital => Key::Named(NamedKey::TVTerrestrialDigital),
-            TvSatellite => Key::Named(NamedKey::TVSatellite),
-            TvSatelliteBs => Key::Named(NamedKey::TVSatelliteBS),
-            TvSatelliteCs => Key::Named(NamedKey::TVSatelliteCS),
-            TvSatelliteService => Key::Named(NamedKey::TVSatelliteToggle),
-            TvNetwork => Key::Named(NamedKey::TVNetwork),
-            TvAntennaCable => Key::Named(NamedKey::TVAntennaCable),
-            TvInputHdmi1 => Key::Named(NamedKey::TVInputHDMI1),
-            TvInputHdmi2 => Key::Named(NamedKey::TVInputHDMI2),
-            TvInputHdmi3 => Key::Named(NamedKey::TVInputHDMI3),
-            TvInputHdmi4 => Key::Named(NamedKey::TVInputHDMI4),
-            TvInputComposite1 => Key::Named(NamedKey::TVInputComposite1),
-            TvInputComposite2 => Key::Named(NamedKey::TVInputComposite2),
-            TvInputComponent1 => Key::Named(NamedKey::TVInputComponent1),
-            TvInputComponent2 => Key::Named(NamedKey::TVInputComponent2),
-            TvInputVga1 => Key::Named(NamedKey::TVInputVGA1),
-            TvAudioDescription => Key::Named(NamedKey::TVAudioDescription),
-            TvAudioDescriptionMixUp => Key::Named(NamedKey::TVAudioDescriptionMixUp),
-            TvAudioDescriptionMixDown => Key::Named(NamedKey::TVAudioDescriptionMixDown),
-            TvZoomMode => Key::Named(NamedKey::ZoomToggle),
-            TvContentsMenu => Key::Named(NamedKey::TVContentsMenu),
-            TvMediaContextMenu => Key::Named(NamedKey::TVMediaContext),
-            TvTimerProgramming => Key::Named(NamedKey::TVTimer),
-            Help => Key::Named(NamedKey::Help),
-            NavigatePrevious => Key::Named(NamedKey::NavigatePrevious),
-            NavigateNext => Key::Named(NamedKey::NavigateNext),
-            NavigateIn => Key::Named(NamedKey::NavigateIn),
-            NavigateOut => Key::Named(NamedKey::NavigateOut),
-            MediaSkipForward => Key::Named(NamedKey::MediaSkipForward),
-            MediaSkipBackward => Key::Named(NamedKey::MediaSkipBackward),
-            MediaStepForward => Key::Named(NamedKey::MediaStepForward),
-            MediaStepBackward => Key::Named(NamedKey::MediaStepBackward),
-            Cut => Key::Named(NamedKey::Cut),
-            Copy => Key::Named(NamedKey::Copy),
-            Paste => Key::Named(NamedKey::Paste),
-            Refresh => Key::Named(NamedKey::BrowserRefresh),
+            VolumeMute => Key::AudioVolumeMute,
+            Info => Key::Info,
+            ChannelUp => Key::ChannelUp,
+            ChannelDown => Key::ChannelDown,
+            ZoomIn => Key::ZoomIn,
+            ZoomOut => Key::ZoomOut,
+            Tv => Key::TV,
+            Guide => Key::Guide,
+            Dvr => Key::DVR,
+            Bookmark => Key::BrowserFavorites,
+            Captions => Key::ClosedCaptionToggle,
+            Settings => Key::Settings,
+            TvPower => Key::TVPower,
+            TvInput => Key::TVInput,
+            StbPower => Key::STBPower,
+            StbInput => Key::STBInput,
+            AvrPower => Key::AVRPower,
+            AvrInput => Key::AVRInput,
+            ProgRed => Key::ColorF0Red,
+            ProgGreen => Key::ColorF1Green,
+            ProgYellow => Key::ColorF2Yellow,
+            ProgBlue => Key::ColorF3Blue,
+            AppSwitch => Key::AppSwitch,
+            LanguageSwitch => Key::GroupNext,
+            MannerMode => Key::MannerMode,
+            Keycode3dMode => Key::TV3DMode,
+            Contacts => Key::LaunchContacts,
+            Calendar => Key::LaunchCalendar,
+            Music => Key::LaunchMusicPlayer,
+            Calculator => Key::LaunchApplication2,
+            ZenkakuHankaku => Key::ZenkakuHankaku,
+            Eisu => Key::Eisu,
+            Muhenkan => Key::NonConvert,
+            Henkan => Key::Convert,
+            KatakanaHiragana => Key::HiraganaKatakana,
+            Kana => Key::KanjiMode,
+            BrightnessDown => Key::BrightnessDown,
+            BrightnessUp => Key::BrightnessUp,
+            MediaAudioTrack => Key::MediaAudioTrack,
+            Sleep => Key::Standby,
+            Wakeup => Key::WakeUp,
+            Pairing => Key::Pairing,
+            MediaTopMenu => Key::MediaTopMenu,
+            LastChannel => Key::MediaLast,
+            TvDataService => Key::TVDataService,
+            VoiceAssist => Key::VoiceDial,
+            TvRadioService => Key::TVRadioService,
+            TvTeletext => Key::Teletext,
+            TvNumberEntry => Key::TVNumberEntry,
+            TvTerrestrialAnalog => Key::TVTerrestrialAnalog,
+            TvTerrestrialDigital => Key::TVTerrestrialDigital,
+            TvSatellite => Key::TVSatellite,
+            TvSatelliteBs => Key::TVSatelliteBS,
+            TvSatelliteCs => Key::TVSatelliteCS,
+            TvSatelliteService => Key::TVSatelliteToggle,
+            TvNetwork => Key::TVNetwork,
+            TvAntennaCable => Key::TVAntennaCable,
+            TvInputHdmi1 => Key::TVInputHDMI1,
+            TvInputHdmi2 => Key::TVInputHDMI2,
+            TvInputHdmi3 => Key::TVInputHDMI3,
+            TvInputHdmi4 => Key::TVInputHDMI4,
+            TvInputComposite1 => Key::TVInputComposite1,
+            TvInputComposite2 => Key::TVInputComposite2,
+            TvInputComponent1 => Key::TVInputComponent1,
+            TvInputComponent2 => Key::TVInputComponent2,
+            TvInputVga1 => Key::TVInputVGA1,
+            TvAudioDescription => Key::TVAudioDescription,
+            TvAudioDescriptionMixUp => Key::TVAudioDescriptionMixUp,
+            TvAudioDescriptionMixDown => Key::TVAudioDescriptionMixDown,
+            TvZoomMode => Key::ZoomToggle,
+            TvContentsMenu => Key::TVContentsMenu,
+            TvMediaContextMenu => Key::TVMediaContext,
+            TvTimerProgramming => Key::TVTimer,
+            Help => Key::Help,
+            NavigatePrevious => Key::NavigatePrevious,
+            NavigateNext => Key::NavigateNext,
+            NavigateIn => Key::NavigateIn,
+            NavigateOut => Key::NavigateOut,
+            MediaSkipForward => Key::MediaSkipForward,
+            MediaSkipBackward => Key::MediaSkipBackward,
+            MediaStepForward => Key::MediaStepForward,
+            MediaStepBackward => Key::MediaStepBackward,
+            Cut => Key::Cut,
+            Copy => Key::Copy,
+            Paste => Key::Paste,
+            Refresh => Key::BrowserRefresh,
 
             // -----------------------------------------------------------------
             // Keycodes that don't have a logical Key mapping
@@ -555,10 +555,6 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
             ThumbsUp => Key::Unidentified(native),
             ThumbsDown => Key::Unidentified(native),
             ProfileSwitch => Key::Unidentified(native),
-
-            // It's always possible that new versions of Android could introduce
-            // key codes we can't know about at compile time.
-            _ => Key::Unidentified(native),
         },
     }
 }

src/platform_impl/android/mod.rs

@@ -4,7 +4,6 @@ use std::{
     cell::Cell,
     collections::VecDeque,
     hash::Hash,
-    marker::PhantomData,
     sync::{
         atomic::{AtomicBool, Ordering},
         mpsc, Arc, Mutex, RwLock,
@@ -16,11 +15,9 @@ use android_activity::input::{InputEvent, KeyAction, Keycode, MotionAction};
 use android_activity::{
     AndroidApp, AndroidAppWaker, ConfigurationRef, InputStatus, MainEvent, Rect,
 };
-use log::{debug, trace, warn};
 use once_cell::sync::Lazy;
 
 use crate::{
-    cursor::Cursor,
     dpi::{PhysicalPosition, PhysicalSize, Position, Size},
     error,
     event::{self, Force, InnerSizeWriter, StartCause},
@@ -141,7 +138,7 @@ pub struct KeyEventExtra {}
 
 pub struct EventLoop<T: 'static> {
     android_app: AndroidApp,
-    window_target: event_loop::EventLoopWindowTarget,
+    window_target: event_loop::EventLoopWindowTarget<T>,
     redraw_flag: SharedFlag,
     user_events_sender: mpsc::Sender<T>,
     user_events_receiver: PeekableReceiver<T>, //must wake looper whenever something gets sent
@@ -188,8 +185,9 @@ impl<T: 'static> EventLoop<T> {
                         &redraw_flag,
                         android_app.create_waker(),
                     ),
+                    _marker: std::marker::PhantomData,
                 },
-                _marker: PhantomData,
+                _marker: std::marker::PhantomData,
             },
             redraw_flag,
             user_events_sender,
@@ -205,7 +203,7 @@ impl<T: 'static> EventLoop<T> {
 
     fn single_iteration<F>(&mut self, main_event: Option<MainEvent<'_>>, callback: &mut F)
     where
-        F: FnMut(event::Event<T>, &RootELW),
+        F: FnMut(event::Event<T>, &RootELW<T>),
     {
         trace!("Mainloop iteration");
 
@@ -377,7 +375,7 @@ impl<T: 'static> EventLoop<T> {
         callback: &mut F,
     ) -> InputStatus
     where
-        F: FnMut(event::Event<T>, &RootELW),
+        F: FnMut(event::Event<T>, &RootELW<T>),
     {
         let mut input_status = InputStatus::Handled;
         match event {
@@ -458,7 +456,7 @@ impl<T: 'static> EventLoop<T> {
                                 device_id: event::DeviceId(DeviceId(key.device_id())),
                                 event: event::KeyEvent {
                                     state,
-                                    physical_key: keycodes::to_physical_key(keycode),
+                                    physical_key: keycodes::to_physical_keycode(keycode),
                                     logical_key: keycodes::to_logical(key_char, keycode),
                                     location: keycodes::to_location(keycode),
                                     repeat: key.repeat_count() > 0,
@@ -482,15 +480,19 @@ impl<T: 'static> EventLoop<T> {
 
     pub fn run<F>(mut self, event_handler: F) -> Result<(), EventLoopError>
     where
-        F: FnMut(event::Event<T>, &event_loop::EventLoopWindowTarget),
+        F: FnMut(event::Event<T>, &event_loop::EventLoopWindowTarget<T>),
     {
         self.run_on_demand(event_handler)
     }
 
     pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
     where
-        F: FnMut(event::Event<T>, &event_loop::EventLoopWindowTarget),
+        F: FnMut(event::Event<T>, &event_loop::EventLoopWindowTarget<T>),
     {
+        if self.loop_running {
+            return Err(EventLoopError::AlreadyRunning);
+        }
+
         loop {
             match self.pump_events(None, &mut event_handler) {
                 PumpStatus::Exit(0) => {
@@ -508,7 +510,7 @@ impl<T: 'static> EventLoop<T> {
 
     pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
     where
-        F: FnMut(event::Event<T>, &RootELW),
+        F: FnMut(event::Event<T>, &RootELW<T>),
     {
         if !self.loop_running {
             self.loop_running = true;
@@ -541,7 +543,7 @@ impl<T: 'static> EventLoop<T> {
 
     fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
     where
-        F: FnMut(event::Event<T>, &RootELW),
+        F: FnMut(event::Event<T>, &RootELW<T>),
     {
         let start = Instant::now();
 
@@ -617,7 +619,7 @@ impl<T: 'static> EventLoop<T> {
         });
     }
 
-    pub fn window_target(&self) -> &event_loop::EventLoopWindowTarget {
+    pub fn window_target(&self) -> &event_loop::EventLoopWindowTarget<T> {
         &self.window_target
     }
 
@@ -661,14 +663,15 @@ impl<T> EventLoopProxy<T> {
     }
 }
 
-pub struct EventLoopWindowTarget {
+pub struct EventLoopWindowTarget<T: 'static> {
     app: AndroidApp,
     control_flow: Cell<ControlFlow>,
     exit: Cell<bool>,
     redraw_requester: RedrawRequester,
+    _marker: std::marker::PhantomData<T>,
 }
 
-impl EventLoopWindowTarget {
+impl<T: 'static> EventLoopWindowTarget<T> {
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
         Some(MonitorHandle::new(self.app.clone()))
     }
@@ -710,36 +713,9 @@ impl EventLoopWindowTarget {
         self.exit.set(true)
     }
 
-    pub(crate) fn clear_exit(&self) {
-        self.exit.set(false)
-    }
-
     pub(crate) fn exiting(&self) -> bool {
         self.exit.get()
     }
-
-    pub(crate) fn owned_display_handle(&self) -> OwnedDisplayHandle {
-        OwnedDisplayHandle
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct OwnedDisplayHandle;
-
-impl OwnedDisplayHandle {
-    #[cfg(feature = "rwh_05")]
-    #[inline]
-    pub fn raw_display_handle_rwh_05(&self) -> rwh_05::RawDisplayHandle {
-        rwh_05::AndroidDisplayHandle::empty().into()
-    }
-
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::AndroidDisplayHandle::new().into())
-    }
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -781,9 +757,10 @@ pub(crate) struct Window {
 }
 
 impl Window {
-    pub(crate) fn new(
-        el: &EventLoopWindowTarget,
+    pub(crate) fn new<T: 'static>(
+        el: &EventLoopWindowTarget<T>,
         _window_attrs: window::WindowAttributes,
+        _: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Self, error::OsError> {
         // FIXME this ignores requested window attributes
 
@@ -927,7 +904,7 @@ impl Window {
 
     pub fn request_user_attention(&self, _request_type: Option<window::UserAttentionType>) {}
 
-    pub fn set_cursor(&self, _: Cursor) {}
+    pub fn set_cursor_icon(&self, _: window::CursorIcon) {}
 
     pub fn set_cursor_position(&self, _: Position) -> Result<(), error::ExternalError> {
         Err(error::ExternalError::NotSupported(
@@ -969,10 +946,10 @@ impl Window {
 
     #[cfg(feature = "rwh_04")]
     pub fn raw_window_handle_rwh_04(&self) -> rwh_04::RawWindowHandle {
-        use rwh_04::HasRawWindowHandle;
-
         if let Some(native_window) = self.app.native_window().as_ref() {
-            native_window.raw_window_handle()
+            let mut handle = rwh_04::AndroidNdkHandle::empty();
+            handle.a_native_window = native_window.ptr().as_ptr() as *mut _;
+            rwh_04::RawWindowHandle::AndroidNdk(handle)
         } else {
             panic!("Cannot get the native window, it's null and will always be null before Event::Resumed and after Event::Suspended. Make sure you only call this function between those events.");
         }
@@ -995,13 +972,10 @@ impl Window {
     }
 
     #[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> {
-        use rwh_06::HasRawWindowHandle;
-
         if let Some(native_window) = self.app.native_window().as_ref() {
-            native_window.raw_window_handle()
+            let handle = rwh_06::AndroidNdkWindowHandle::new(native_window.ptr().cast());
+            Ok(rwh_06::RawWindowHandle::AndroidNdk(handle))
         } else {
             log::error!("Cannot get the native window, it's null and will always be null before Event::Resumed and after Event::Suspended. Make sure you only call this function between those events.");
             Err(rwh_06::HandleError::Unavailable)
@@ -1054,8 +1028,6 @@ impl Display for OsError {
     }
 }
 
-pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursor;
-pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursorBuilder;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -1107,11 +1079,11 @@ impl MonitorHandle {
         None
     }
 
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
         let size = self.size().into();
         // FIXME this is not the real refresh rate
         // (it is guaranteed to support 32 bit color though)
-        std::iter::once(VideoModeHandle {
+        std::iter::once(VideoMode {
             size,
             bit_depth: 32,
             refresh_rate_millihertz: 60000,
@@ -1121,14 +1093,14 @@ impl MonitorHandle {
 }
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct VideoModeHandle {
+pub struct VideoMode {
     size: (u32, u32),
     bit_depth: u16,
     refresh_rate_millihertz: u32,
     monitor: MonitorHandle,
 }
 
-impl VideoModeHandle {
+impl VideoMode {
     pub fn size(&self) -> PhysicalSize<u32> {
         self.size.into()
     }

src/platform_impl/ios/app_state.rs

@@ -3,7 +3,7 @@
 use std::{
     cell::{RefCell, RefMut},
     collections::HashSet,
-    fmt, mem,
+    mem,
     os::raw::c_void,
     ptr,
     sync::{Arc, Mutex},
@@ -24,12 +24,13 @@ use objc2::runtime::AnyObject;
 use objc2::{msg_send, sel};
 use once_cell::sync::Lazy;
 
+use super::event_loop::{EventHandler, Never};
 use super::uikit::UIView;
 use super::view::WinitUIWindow;
 use crate::{
     dpi::PhysicalSize,
     event::{Event, InnerSizeWriter, StartCause, WindowEvent},
-    event_loop::{ControlFlow, EventLoopWindowTarget as RootEventLoopWindowTarget},
+    event_loop::ControlFlow,
     window::WindowId as RootWindowId,
 };
 
@@ -46,32 +47,8 @@ macro_rules! bug_assert {
 }
 
 #[derive(Debug)]
-pub(crate) struct HandlePendingUserEvents;
-
-pub(crate) struct EventLoopHandler {
-    #[allow(clippy::type_complexity)]
-    pub(crate) handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootEventLoopWindowTarget)>,
-    pub(crate) event_loop: RootEventLoopWindowTarget,
-}
-
-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<HandlePendingUserEvents>) {
-        (self.handler)(event, &self.event_loop)
-    }
-}
-
-#[derive(Debug)]
-pub(crate) enum EventWrapper {
-    StaticEvent(Event<HandlePendingUserEvents>),
+pub enum EventWrapper {
+    StaticEvent(Event<Never>),
     ScaleFactorChanged(ScaleFactorChanged),
 }
 
@@ -84,7 +61,7 @@ pub struct ScaleFactorChanged {
 
 enum UserCallbackTransitionResult<'a> {
     Success {
-        handler: EventLoopHandler,
+        event_handler: Box<dyn EventHandler>,
         active_control_flow: ControlFlow,
         processing_redraws: bool,
     },
@@ -93,7 +70,7 @@ enum UserCallbackTransitionResult<'a> {
     },
 }
 
-impl Event<HandlePendingUserEvents> {
+impl Event<Never> {
     fn is_redraw(&self) -> bool {
         matches!(
             self,
@@ -117,11 +94,11 @@ enum AppStateImpl {
     Launching {
         queued_windows: Vec<Id<WinitUIWindow>>,
         queued_events: Vec<EventWrapper>,
-        queued_handler: EventLoopHandler,
+        queued_event_handler: Box<dyn EventHandler>,
         queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
     },
     ProcessingEvents {
-        handler: EventLoopHandler,
+        event_handler: Box<dyn EventHandler>,
         queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
         active_control_flow: ControlFlow,
     },
@@ -131,15 +108,15 @@ enum AppStateImpl {
         queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
     },
     ProcessingRedraws {
-        handler: EventLoopHandler,
+        event_handler: Box<dyn EventHandler>,
         active_control_flow: ControlFlow,
     },
     Waiting {
-        waiting_handler: EventLoopHandler,
+        waiting_event_handler: Box<dyn EventHandler>,
         start: Instant,
     },
     PollFinished {
-        waiting_handler: EventLoopHandler,
+        waiting_event_handler: Box<dyn EventHandler>,
     },
     Terminated,
 }
@@ -223,11 +200,7 @@ impl AppState {
         )
     }
 
-    fn has_terminated(&self) -> bool {
-        matches!(self.state(), AppStateImpl::Terminated)
-    }
-
-    fn will_launch_transition(&mut self, queued_handler: EventLoopHandler) {
+    fn will_launch_transition(&mut self, queued_event_handler: Box<dyn EventHandler>) {
         let (queued_windows, queued_events, queued_gpu_redraws) = match self.take_state() {
             AppStateImpl::NotLaunched {
                 queued_windows,
@@ -239,28 +212,28 @@ impl AppState {
         self.set_state(AppStateImpl::Launching {
             queued_windows,
             queued_events,
-            queued_handler,
+            queued_event_handler,
             queued_gpu_redraws,
         });
     }
 
     fn did_finish_launching_transition(&mut self) -> (Vec<Id<WinitUIWindow>>, Vec<EventWrapper>) {
-        let (windows, events, handler, queued_gpu_redraws) = match self.take_state() {
+        let (windows, events, event_handler, queued_gpu_redraws) = match self.take_state() {
             AppStateImpl::Launching {
                 queued_windows,
                 queued_events,
-                queued_handler,
+                queued_event_handler,
                 queued_gpu_redraws,
             } => (
                 queued_windows,
                 queued_events,
-                queued_handler,
+                queued_event_handler,
                 queued_gpu_redraws,
             ),
             s => bug!("unexpected state {:?}", s),
         };
         self.set_state(AppStateImpl::ProcessingEvents {
-            handler,
+            event_handler,
             active_control_flow: self.control_flow,
             queued_gpu_redraws,
         });
@@ -270,23 +243,28 @@ impl AppState {
     fn wakeup_transition(&mut self) -> Option<EventWrapper> {
         // before `AppState::did_finish_launching` is called, pretend there is no running
         // event loop.
-        if !self.has_launched() || self.has_terminated() {
+        if !self.has_launched() {
             return None;
         }
 
-        let (handler, event) = match (self.control_flow, self.take_state()) {
-            (ControlFlow::Poll, AppStateImpl::PollFinished { waiting_handler }) => (
-                waiting_handler,
+        let (event_handler, event) = match (self.control_flow, self.take_state()) {
+            (
+                ControlFlow::Poll,
+                AppStateImpl::PollFinished {
+                    waiting_event_handler,
+                },
+            ) => (
+                waiting_event_handler,
                 EventWrapper::StaticEvent(Event::NewEvents(StartCause::Poll)),
             ),
             (
                 ControlFlow::Wait,
                 AppStateImpl::Waiting {
-                    waiting_handler,
+                    waiting_event_handler,
                     start,
                 },
             ) => (
-                waiting_handler,
+                waiting_event_handler,
                 EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled {
                     start,
                     requested_resume: None,
@@ -295,7 +273,7 @@ impl AppState {
             (
                 ControlFlow::WaitUntil(requested_resume),
                 AppStateImpl::Waiting {
-                    waiting_handler,
+                    waiting_event_handler,
                     start,
                 },
             ) => {
@@ -310,13 +288,13 @@ impl AppState {
                         requested_resume: Some(requested_resume),
                     }))
                 };
-                (waiting_handler, event)
+                (waiting_event_handler, event)
             }
             s => bug!("`EventHandler` unexpectedly woke up {:?}", s),
         };
 
         self.set_state(AppStateImpl::ProcessingEvents {
-            handler,
+            event_handler,
             queued_gpu_redraws: Default::default(),
             active_control_flow: self.control_flow,
         });
@@ -361,20 +339,25 @@ impl AppState {
             }
         }
 
-        let (handler, queued_gpu_redraws, active_control_flow, processing_redraws) =
+        let (event_handler, queued_gpu_redraws, active_control_flow, processing_redraws) =
             match self.take_state() {
                 AppStateImpl::Launching { .. }
                 | AppStateImpl::NotLaunched { .. }
                 | AppStateImpl::InUserCallback { .. } => unreachable!(),
                 AppStateImpl::ProcessingEvents {
-                    handler,
+                    event_handler,
                     queued_gpu_redraws,
                     active_control_flow,
-                } => (handler, queued_gpu_redraws, active_control_flow, false),
-                AppStateImpl::ProcessingRedraws {
-                    handler,
+                } => (
+                    event_handler,
+                    queued_gpu_redraws,
                     active_control_flow,
-                } => (handler, Default::default(), active_control_flow, true),
+                    false,
+                ),
+                AppStateImpl::ProcessingRedraws {
+                    event_handler,
+                    active_control_flow,
+                } => (event_handler, Default::default(), active_control_flow, true),
                 AppStateImpl::PollFinished { .. }
                 | AppStateImpl::Waiting { .. }
                 | AppStateImpl::Terminated => unreachable!(),
@@ -384,37 +367,37 @@ impl AppState {
             queued_gpu_redraws,
         });
         UserCallbackTransitionResult::Success {
-            handler,
+            event_handler,
             active_control_flow,
             processing_redraws,
         }
     }
 
     fn main_events_cleared_transition(&mut self) -> HashSet<Id<WinitUIWindow>> {
-        let (handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
+        let (event_handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
             AppStateImpl::ProcessingEvents {
-                handler,
+                event_handler,
                 queued_gpu_redraws,
                 active_control_flow,
-            } => (handler, queued_gpu_redraws, active_control_flow),
+            } => (event_handler, queued_gpu_redraws, active_control_flow),
             s => bug!("unexpected state {:?}", s),
         };
         self.set_state(AppStateImpl::ProcessingRedraws {
-            handler,
+            event_handler,
             active_control_flow,
         });
         queued_gpu_redraws
     }
 
     fn events_cleared_transition(&mut self) {
-        if !self.has_launched() || self.has_terminated() {
+        if !self.has_launched() {
             return;
         }
-        let (waiting_handler, old) = match self.take_state() {
+        let (waiting_event_handler, old) = match self.take_state() {
             AppStateImpl::ProcessingRedraws {
-                handler,
+                event_handler,
                 active_control_flow,
-            } => (handler, active_control_flow),
+            } => (event_handler, active_control_flow),
             s => bug!("unexpected state {:?}", s),
         };
 
@@ -423,7 +406,7 @@ impl AppState {
             (ControlFlow::Wait, ControlFlow::Wait) => {
                 let start = Instant::now();
                 self.set_state(AppStateImpl::Waiting {
-                    waiting_handler,
+                    waiting_event_handler,
                     start,
                 });
             }
@@ -432,14 +415,14 @@ impl AppState {
             {
                 let start = Instant::now();
                 self.set_state(AppStateImpl::Waiting {
-                    waiting_handler,
+                    waiting_event_handler,
                     start,
                 });
             }
             (_, ControlFlow::Wait) => {
                 let start = Instant::now();
                 self.set_state(AppStateImpl::Waiting {
-                    waiting_handler,
+                    waiting_event_handler,
                     start,
                 });
                 self.waker.stop()
@@ -447,22 +430,24 @@ impl AppState {
             (_, ControlFlow::WaitUntil(new_instant)) => {
                 let start = Instant::now();
                 self.set_state(AppStateImpl::Waiting {
-                    waiting_handler,
+                    waiting_event_handler,
                     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 {
+                    waiting_event_handler,
+                });
                 self.waker.start()
             }
         }
     }
 
-    fn terminated_transition(&mut self) -> EventLoopHandler {
+    fn terminated_transition(&mut self) -> Box<dyn EventHandler> {
         match self.replace_state(AppStateImpl::Terminated) {
-            AppStateImpl::ProcessingEvents { handler, .. } => handler,
+            AppStateImpl::ProcessingEvents { event_handler, .. } => event_handler,
             s => bug!("`LoopExiting` happened while not processing events {:?}", s),
         }
     }
@@ -527,8 +512,8 @@ pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Id<WinitUI
     }
 }
 
-pub(crate) fn will_launch(mtm: MainThreadMarker, queued_handler: EventLoopHandler) {
-    AppState::get_mut(mtm).will_launch_transition(queued_handler)
+pub fn will_launch(mtm: MainThreadMarker, queued_event_handler: Box<dyn EventHandler>) {
+    AppState::get_mut(mtm).will_launch_transition(queued_event_handler)
 }
 
 pub fn did_finish_launching(mtm: MainThreadMarker) {
@@ -601,21 +586,17 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
     events: I,
 ) {
     let mut this = AppState::get_mut(mtm);
-    if this.has_terminated() {
-        return;
-    }
-
-    let (mut handler, active_control_flow, processing_redraws) =
+    let (mut event_handler, active_control_flow, processing_redraws) =
         match this.try_user_callback_transition() {
             UserCallbackTransitionResult::ReentrancyPrevented { queued_events } => {
                 queued_events.extend(events);
                 return;
             }
             UserCallbackTransitionResult::Success {
-                handler,
+                event_handler,
                 active_control_flow,
                 processing_redraws,
-            } => (handler, active_control_flow, processing_redraws),
+            } => (event_handler, active_control_flow, processing_redraws),
         };
     drop(this);
 
@@ -630,9 +611,11 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
                         event
                     );
                 }
-                handler.handle_event(event)
+                event_handler.handle_nonuser_event(event)
+            }
+            EventWrapper::ScaleFactorChanged(event) => {
+                handle_hidpi_proxy(&mut event_handler, event)
             }
-            EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
         }
     }
 
@@ -659,12 +642,12 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
                     "redraw queued while processing redraws"
                 );
                 AppStateImpl::ProcessingRedraws {
-                    handler,
+                    event_handler,
                     active_control_flow,
                 }
             } else {
                 AppStateImpl::ProcessingEvents {
-                    handler,
+                    event_handler,
                     queued_gpu_redraws,
                     active_control_flow,
                 }
@@ -684,9 +667,11 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
                             event
                         );
                     }
-                    handler.handle_event(event)
+                    event_handler.handle_nonuser_event(event)
+                }
+                EventWrapper::ScaleFactorChanged(event) => {
+                    handle_hidpi_proxy(&mut event_handler, event)
                 }
-                EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
             }
         }
     }
@@ -694,23 +679,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) =
+    let (mut event_handler, active_control_flow, processing_redraws) =
         match this.try_user_callback_transition() {
             UserCallbackTransitionResult::ReentrancyPrevented { .. } => {
                 bug!("unexpected attempted to process an event")
             }
             UserCallbackTransitionResult::Success {
-                handler,
+                event_handler,
                 active_control_flow,
                 processing_redraws,
-            } => (handler, active_control_flow, processing_redraws),
+            } => (event_handler, active_control_flow, processing_redraws),
         };
     if processing_redraws {
         bug!("user events attempted to be sent out while `ProcessingRedraws`");
     }
     drop(this);
 
-    handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
+    event_handler.handle_user_events();
 
     loop {
         let mut this = AppState::get_mut(mtm);
@@ -730,7 +715,7 @@ fn handle_user_events(mtm: MainThreadMarker) {
                 _ => unreachable!(),
             };
             this.app_state = Some(AppStateImpl::ProcessingEvents {
-                handler,
+                event_handler,
                 queued_gpu_redraws,
                 active_control_flow,
             });
@@ -740,18 +725,19 @@ fn handle_user_events(mtm: MainThreadMarker) {
 
         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) => event_handler.handle_nonuser_event(event),
+                EventWrapper::ScaleFactorChanged(event) => {
+                    handle_hidpi_proxy(&mut event_handler, event)
+                }
             }
         }
-
-        handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
+        event_handler.handle_user_events();
     }
 }
 
 pub fn handle_main_events_cleared(mtm: MainThreadMarker) {
     let mut this = AppState::get_mut(mtm);
-    if !this.has_launched() || this.has_terminated() {
+    if !this.has_launched() {
         return;
     }
     match this.state_mut() {
@@ -785,13 +771,13 @@ pub fn handle_events_cleared(mtm: MainThreadMarker) {
 
 pub fn terminated(mtm: MainThreadMarker) {
     let mut this = AppState::get_mut(mtm);
-    let mut handler = this.terminated_transition();
+    let mut event_handler = this.terminated_transition();
     drop(this);
 
-    handler.handle_event(Event::LoopExiting)
+    event_handler.handle_nonuser_event(Event::LoopExiting)
 }
 
-fn handle_hidpi_proxy(handler: &mut EventLoopHandler, event: ScaleFactorChanged) {
+fn handle_hidpi_proxy(event_handler: &mut Box<dyn EventHandler>, event: ScaleFactorChanged) {
     let ScaleFactorChanged {
         suggested_size,
         scale_factor,
@@ -805,7 +791,7 @@ fn handle_hidpi_proxy(handler: &mut EventLoopHandler, event: ScaleFactorChanged)
             inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
         },
     };
-    handler.handle_event(event);
+    event_handler.handle_nonuser_event(event);
     let (view, screen_frame) = get_view_and_screen_frame(&window);
     let physical_size = *new_inner_size.lock().unwrap();
     drop(new_inner_size);

src/platform_impl/ios/event_loop.rs

@@ -1,6 +1,7 @@
 use std::{
     collections::VecDeque,
     ffi::c_void,
+    fmt::{self, Debug},
     marker::PhantomData,
     ptr,
     sync::mpsc::{self, Receiver, Sender},
@@ -24,7 +25,6 @@ use crate::{
         EventLoopWindowTarget as RootEventLoopWindowTarget,
     },
     platform::ios::Idiom,
-    platform_impl::platform::app_state::{EventLoopHandler, HandlePendingUserEvents},
 };
 
 use super::{app_state, monitor, view, MonitorHandle};
@@ -34,11 +34,12 @@ use super::{
 };
 
 #[derive(Debug)]
-pub struct EventLoopWindowTarget {
+pub struct EventLoopWindowTarget<T: 'static> {
     pub(super) mtm: MainThreadMarker,
+    p: PhantomData<T>,
 }
 
-impl EventLoopWindowTarget {
+impl<T: 'static> EventLoopWindowTarget<T> {
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
         monitor::uiscreens(self.mtm)
     }
@@ -77,56 +78,19 @@ impl EventLoopWindowTarget {
     pub(crate) fn exit(&self) {
         // https://developer.apple.com/library/archive/qa/qa1561/_index.html
         // it is not possible to quit an iOS app gracefully and programatically
-        log::warn!("`ControlFlow::Exit` ignored on iOS");
+        warn!("`ControlFlow::Exit` ignored on iOS");
     }
 
     pub(crate) fn exiting(&self) -> bool {
         false
     }
-
-    pub(crate) fn owned_display_handle(&self) -> OwnedDisplayHandle {
-        OwnedDisplayHandle
-    }
-}
-
-#[derive(Clone)]
-pub(crate) struct OwnedDisplayHandle;
-
-impl OwnedDisplayHandle {
-    #[cfg(feature = "rwh_05")]
-    #[inline]
-    pub fn raw_display_handle_rwh_05(&self) -> rwh_05::RawDisplayHandle {
-        rwh_05::UiKitDisplayHandle::empty().into()
-    }
-
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::UiKitDisplayHandle::new().into())
-    }
-}
-
-fn map_user_event<T: 'static>(
-    mut handler: impl FnMut(Event<T>, &RootEventLoopWindowTarget),
-    receiver: mpsc::Receiver<T>,
-) -> impl FnMut(Event<HandlePendingUserEvents>, &RootEventLoopWindowTarget) {
-    move |event, window_target| match event.map_nonuser_event() {
-        Ok(event) => (handler)(event, window_target),
-        Err(_) => {
-            for event in receiver.try_iter() {
-                (handler)(Event::UserEvent(event), window_target);
-            }
-        }
-    }
 }
 
 pub struct EventLoop<T: 'static> {
     mtm: MainThreadMarker,
     sender: Sender<T>,
     receiver: Receiver<T>,
-    window_target: RootEventLoopWindowTarget,
+    window_target: RootEventLoopWindowTarget<T>,
 }
 
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -159,59 +123,59 @@ impl<T: 'static> EventLoop<T> {
             sender,
             receiver,
             window_target: RootEventLoopWindowTarget {
-                p: EventLoopWindowTarget { mtm },
+                p: EventLoopWindowTarget {
+                    mtm,
+                    p: PhantomData,
+                },
                 _marker: PhantomData,
             },
         })
     }
 
-    pub fn run<F>(self, handler: F) -> !
+    pub fn run<F>(self, event_handler: F) -> !
     where
-        F: FnMut(Event<T>, &RootEventLoopWindowTarget),
+        F: FnMut(Event<T>, &RootEventLoopWindowTarget<T>),
     {
-        let application = UIApplication::shared(self.mtm);
-        assert!(
-            application.is_none(),
-            "\
+        unsafe {
+            let application = UIApplication::shared(self.mtm);
+            assert!(
+                application.is_none(),
+                "\
                 `EventLoop` cannot be `run` after a call to `UIApplicationMain` on iOS\n\
                  Note: `EventLoop::run` calls `UIApplicationMain` on iOS",
-        );
+            );
 
-        let handler = map_user_event(handler, self.receiver);
+            let event_handler = std::mem::transmute::<
+                Box<dyn FnMut(Event<T>, &RootEventLoopWindowTarget<T>)>,
+                Box<EventHandlerCallback<T>>,
+            >(Box::new(event_handler));
 
-        let handler = unsafe {
-            std::mem::transmute::<
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootEventLoopWindowTarget)>,
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootEventLoopWindowTarget)>,
-            >(Box::new(handler))
-        };
+            let handler = EventLoopHandler {
+                f: event_handler,
+                receiver: self.receiver,
+                event_loop: self.window_target,
+            };
 
-        let handler = EventLoopHandler {
-            handler,
-            event_loop: self.window_target,
-        };
+            app_state::will_launch(self.mtm, Box::new(handler));
 
-        app_state::will_launch(self.mtm, handler);
+            // Ensure application delegate is initialized
+            view::WinitApplicationDelegate::class();
 
-        // Ensure application delegate is initialized
-        view::WinitApplicationDelegate::class();
-
-        unsafe {
             UIApplicationMain(
                 0,
                 ptr::null(),
                 None,
                 Some(&NSString::from_str("WinitApplicationDelegate")),
-            )
-        };
-        unreachable!()
+            );
+            unreachable!()
+        }
     }
 
     pub fn create_proxy(&self) -> EventLoopProxy<T> {
         EventLoopProxy::new(self.sender.clone())
     }
 
-    pub fn window_target(&self) -> &RootEventLoopWindowTarget {
+    pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
         &self.window_target
     }
 }
@@ -325,7 +289,7 @@ fn setup_control_flow_observers() {
             #[allow(non_upper_case_globals)]
             match activity {
                 kCFRunLoopBeforeWaiting => app_state::handle_main_events_cleared(mtm),
-                kCFRunLoopExit => {} // may happen when running on macOS
+                kCFRunLoopExit => unimplemented!(), // not expected to ever happen
                 _ => unreachable!(),
             }
         }
@@ -340,7 +304,7 @@ fn setup_control_flow_observers() {
             #[allow(non_upper_case_globals)]
             match activity {
                 kCFRunLoopBeforeWaiting => app_state::handle_events_cleared(mtm),
-                kCFRunLoopExit => {} // may happen when running on macOS
+                kCFRunLoopExit => unimplemented!(), // not expected to ever happen
                 _ => unreachable!(),
             }
         }
@@ -378,3 +342,39 @@ fn setup_control_flow_observers() {
         CFRunLoopAddObserver(main_loop, end_observer, kCFRunLoopDefaultMode);
     }
 }
+
+#[derive(Debug)]
+pub enum Never {}
+
+type EventHandlerCallback<T> = dyn FnMut(Event<T>, &RootEventLoopWindowTarget<T>) + 'static;
+
+pub trait EventHandler: Debug {
+    fn handle_nonuser_event(&mut self, event: Event<Never>);
+    fn handle_user_events(&mut self);
+}
+
+struct EventLoopHandler<T: 'static> {
+    f: Box<EventHandlerCallback<T>>,
+    receiver: Receiver<T>,
+    event_loop: RootEventLoopWindowTarget<T>,
+}
+
+impl<T: 'static> Debug for EventLoopHandler<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventLoopHandler")
+            .field("event_loop", &self.event_loop)
+            .finish()
+    }
+}
+
+impl<T: 'static> EventHandler for EventLoopHandler<T> {
+    fn handle_nonuser_event(&mut self, event: Event<Never>) {
+        (self.f)(event.map_nonuser_event().unwrap(), &self.event_loop);
+    }
+
+    fn handle_user_events(&mut self) {
+        for event in self.receiver.try_iter() {
+            (self.f)(Event::UserEvent(event), &self.event_loop);
+        }
+    }
+}

src/platform_impl/ios/mod.rs

@@ -68,35 +68,33 @@ mod window;
 
 use std::fmt;
 
-use crate::event::DeviceId as RootDeviceId;
-
 pub(crate) use self::{
     event_loop::{
-        EventLoop, EventLoopProxy, EventLoopWindowTarget, OwnedDisplayHandle,
-        PlatformSpecificEventLoopAttributes,
+        EventLoop, EventLoopProxy, EventLoopWindowTarget, PlatformSpecificEventLoopAttributes,
     },
-    monitor::{MonitorHandle, VideoModeHandle},
+    monitor::{MonitorHandle, VideoMode},
     window::{PlatformSpecificWindowBuilderAttributes, Window, WindowId},
 };
-pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursor;
-pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursorBuilder;
+
+use self::uikit::UIScreen;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
 
-/// There is no way to detect which device that performed a certain event in
-/// UIKit (i.e. you can't differentiate between different external keyboards,
-/// or wether it was the main touchscreen, assistive technologies, or some
-/// other pointer device that caused a touch event).
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct DeviceId;
+pub struct DeviceId {
+    uiscreen: *const UIScreen,
+}
 
 impl DeviceId {
     pub const unsafe fn dummy() -> Self {
-        DeviceId
+        DeviceId {
+            uiscreen: std::ptr::null(),
+        }
     }
 }
 
-pub(crate) const DEVICE_ID: RootDeviceId = RootDeviceId(DeviceId);
+unsafe impl Send for DeviceId {}
+unsafe impl Sync for DeviceId {}
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct KeyEventExtra {}

src/platform_impl/ios/monitor.rs

@@ -8,12 +8,11 @@ use std::{
 use icrate::Foundation::{MainThreadBound, MainThreadMarker, NSInteger};
 use objc2::mutability::IsRetainable;
 use objc2::rc::Id;
-use objc2::Message;
 
 use super::uikit::{UIScreen, UIScreenMode};
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize},
-    monitor::VideoModeHandle as RootVideoModeHandle,
+    monitor::VideoMode as RootVideoMode,
     platform_impl::platform::app_state,
 };
 
@@ -21,15 +20,16 @@ use crate::{
 #[derive(Debug)]
 struct MainThreadBoundDelegateImpls<T>(MainThreadBound<Id<T>>);
 
-impl<T: IsRetainable + Message> Clone for MainThreadBoundDelegateImpls<T> {
+impl<T: IsRetainable> Clone for MainThreadBoundDelegateImpls<T> {
     fn clone(&self) -> Self {
-        Self(MainThreadMarker::run_on_main(|mtm| {
-            MainThreadBound::new(Id::clone(self.0.get(mtm)), mtm)
-        }))
+        Self(
+            self.0
+                .get_on_main(|inner, mtm| MainThreadBound::new(Id::clone(inner), mtm)),
+        )
     }
 }
 
-impl<T: IsRetainable + Message> hash::Hash for MainThreadBoundDelegateImpls<T> {
+impl<T: IsRetainable> hash::Hash for MainThreadBoundDelegateImpls<T> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         // SAFETY: Marker only used to get the pointer
         let mtm = unsafe { MainThreadMarker::new_unchecked() };
@@ -37,7 +37,7 @@ impl<T: IsRetainable + Message> hash::Hash for MainThreadBoundDelegateImpls<T> {
     }
 }
 
-impl<T: IsRetainable + Message> PartialEq for MainThreadBoundDelegateImpls<T> {
+impl<T: IsRetainable> PartialEq for MainThreadBoundDelegateImpls<T> {
     fn eq(&self, other: &Self) -> bool {
         // SAFETY: Marker only used to get the pointer
         let mtm = unsafe { MainThreadMarker::new_unchecked() };
@@ -45,10 +45,10 @@ impl<T: IsRetainable + Message> PartialEq for MainThreadBoundDelegateImpls<T> {
     }
 }
 
-impl<T: IsRetainable + Message> Eq for MainThreadBoundDelegateImpls<T> {}
+impl<T: IsRetainable> Eq for MainThreadBoundDelegateImpls<T> {}
 
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
-pub struct VideoModeHandle {
+pub struct VideoMode {
     pub(crate) size: (u32, u32),
     pub(crate) bit_depth: u16,
     pub(crate) refresh_rate_millihertz: u32,
@@ -56,15 +56,15 @@ pub struct VideoModeHandle {
     pub(crate) monitor: MonitorHandle,
 }
 
-impl VideoModeHandle {
+impl VideoMode {
     fn new(
         uiscreen: Id<UIScreen>,
         screen_mode: Id<UIScreenMode>,
         mtm: MainThreadMarker,
-    ) -> VideoModeHandle {
+    ) -> VideoMode {
         let refresh_rate_millihertz = refresh_rate_millihertz(&uiscreen);
         let size = screen_mode.size();
-        VideoModeHandle {
+        VideoMode {
             size: (size.width as u32, size.height as u32),
             bit_depth: 32,
             refresh_rate_millihertz,
@@ -100,9 +100,11 @@ pub struct MonitorHandle {
 
 impl Clone for MonitorHandle {
     fn clone(&self) -> Self {
-        MainThreadMarker::run_on_main(|mtm| Self {
-            ui_screen: MainThreadBound::new(self.ui_screen.get(mtm).clone(), mtm),
-        })
+        Self {
+            ui_screen: self
+                .ui_screen
+                .get_on_main(|inner, mtm| MainThreadBound::new(inner.clone(), mtm)),
+        }
     }
 }
 
@@ -135,13 +137,24 @@ impl Ord for MonitorHandle {
 
 impl fmt::Debug for MonitorHandle {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("MonitorHandle")
-            .field("name", &self.name())
-            .field("size", &self.size())
-            .field("position", &self.position())
-            .field("scale_factor", &self.scale_factor())
-            .field("refresh_rate_millihertz", &self.refresh_rate_millihertz())
-            .finish_non_exhaustive()
+        // TODO: Do this using the proper fmt API
+        #[derive(Debug)]
+        #[allow(dead_code)]
+        struct MonitorHandle {
+            name: Option<String>,
+            size: PhysicalSize<u32>,
+            position: PhysicalPosition<i32>,
+            scale_factor: f64,
+        }
+
+        let monitor_id_proxy = MonitorHandle {
+            name: self.name(),
+            size: self.size(),
+            position: self.position(),
+            scale_factor: self.scale_factor(),
+        };
+
+        monitor_id_proxy.fmt(f)
     }
 }
 
@@ -155,16 +168,16 @@ impl MonitorHandle {
     }
 
     pub fn name(&self) -> Option<String> {
-        MainThreadMarker::run_on_main(|mtm| {
+        self.ui_screen.get_on_main(|ui_screen, mtm| {
             let main = UIScreen::main(mtm);
-            if *self.ui_screen(mtm) == main {
+            if *ui_screen == main {
                 Some("Primary".to_string())
-            } else if *self.ui_screen(mtm) == main.mirroredScreen() {
+            } else if *ui_screen == main.mirroredScreen() {
                 Some("Mirrored".to_string())
             } else {
                 UIScreen::screens(mtm)
                     .iter()
-                    .position(|rhs| rhs == &**self.ui_screen(mtm))
+                    .position(|rhs| rhs == &**ui_screen)
                     .map(|idx| idx.to_string())
             }
         })
@@ -173,39 +186,38 @@ impl MonitorHandle {
     pub fn size(&self) -> PhysicalSize<u32> {
         let bounds = self
             .ui_screen
-            .get_on_main(|ui_screen| ui_screen.nativeBounds());
+            .get_on_main(|ui_screen, _| ui_screen.nativeBounds());
         PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
     }
 
     pub fn position(&self) -> PhysicalPosition<i32> {
         let bounds = self
             .ui_screen
-            .get_on_main(|ui_screen| ui_screen.nativeBounds());
+            .get_on_main(|ui_screen, _| ui_screen.nativeBounds());
         (bounds.origin.x as f64, bounds.origin.y as f64).into()
     }
 
     pub fn scale_factor(&self) -> f64 {
         self.ui_screen
-            .get_on_main(|ui_screen| ui_screen.nativeScale()) as f64
+            .get_on_main(|ui_screen, _| ui_screen.nativeScale()) as f64
     }
 
     pub fn refresh_rate_millihertz(&self) -> Option<u32> {
         Some(
             self.ui_screen
-                .get_on_main(|ui_screen| refresh_rate_millihertz(ui_screen)),
+                .get_on_main(|ui_screen, _| refresh_rate_millihertz(ui_screen)),
         )
     }
 
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
-        MainThreadMarker::run_on_main(|mtm| {
-            let ui_screen = self.ui_screen(mtm);
-            // Use Ord impl of RootVideoModeHandle
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
+        self.ui_screen.get_on_main(|ui_screen, mtm| {
+            // Use Ord impl of RootVideoMode
 
             let modes: BTreeSet<_> = ui_screen
                 .availableModes()
                 .into_iter()
-                .map(|mode| RootVideoModeHandle {
-                    video_mode: VideoModeHandle::new(ui_screen.clone(), mode, mtm),
+                .map(|mode| RootVideoMode {
+                    video_mode: VideoMode::new(ui_screen.clone(), mode, mtm),
                 })
                 .collect();
 
@@ -217,13 +229,9 @@ impl MonitorHandle {
         self.ui_screen.get(mtm)
     }
 
-    pub fn preferred_video_mode(&self) -> VideoModeHandle {
-        MainThreadMarker::run_on_main(|mtm| {
-            VideoModeHandle::new(
-                self.ui_screen(mtm).clone(),
-                self.ui_screen(mtm).preferredMode().unwrap(),
-                mtm,
-            )
+    pub fn preferred_video_mode(&self) -> VideoMode {
+        self.ui_screen.get_on_main(|ui_screen, mtm| {
+            VideoMode::new(ui_screen.clone(), ui_screen.preferredMode().unwrap(), mtm)
         })
     }
 }

src/platform_impl/ios/uikit/gesture_recognizer.rs

@@ -1,121 +0,0 @@
-use icrate::Foundation::{CGFloat, NSInteger, NSObject, NSUInteger};
-use objc2::{
-    encode::{Encode, Encoding},
-    extern_class, extern_methods, mutability, ClassType,
-};
-
-// https://developer.apple.com/documentation/uikit/uigesturerecognizer
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIGestureRecognizer;
-
-    unsafe impl ClassType for UIGestureRecognizer {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIGestureRecognizer {
-        #[method(state)]
-        pub fn state(&self) -> UIGestureRecognizerState;
-    }
-);
-
-unsafe impl Encode for UIGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-// https://developer.apple.com/documentation/uikit/uigesturerecognizer/state
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIGestureRecognizerState(NSInteger);
-
-unsafe impl Encode for UIGestureRecognizerState {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
-
-#[allow(dead_code)]
-impl UIGestureRecognizerState {
-    pub const Possible: Self = Self(0);
-    pub const Began: Self = Self(1);
-    pub const Changed: Self = Self(2);
-    pub const Ended: Self = Self(3);
-    pub const Cancelled: Self = Self(4);
-    pub const Failed: Self = Self(5);
-}
-
-// https://developer.apple.com/documentation/uikit/uipinchgesturerecognizer
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIPinchGestureRecognizer;
-
-    unsafe impl ClassType for UIPinchGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIPinchGestureRecognizer {
-        #[method(scale)]
-        pub fn scale(&self) -> CGFloat;
-
-        #[method(velocity)]
-        pub fn velocity(&self) -> CGFloat;
-    }
-);
-
-unsafe impl Encode for UIPinchGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-// https://developer.apple.com/documentation/uikit/uirotationgesturerecognizer
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIRotationGestureRecognizer;
-
-    unsafe impl ClassType for UIRotationGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIRotationGestureRecognizer {
-        #[method(rotation)]
-        pub fn rotation(&self) -> CGFloat;
-
-        #[method(velocity)]
-        pub fn velocity(&self) -> CGFloat;
-    }
-);
-
-unsafe impl Encode for UIRotationGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-// https://developer.apple.com/documentation/uikit/uitapgesturerecognizer
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UITapGestureRecognizer;
-
-    unsafe impl ClassType for UITapGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UITapGestureRecognizer {
-        #[method(setNumberOfTapsRequired:)]
-        pub fn setNumberOfTapsRequired(&self, number_of_taps_required: NSUInteger);
-
-        #[method(setNumberOfTouchesRequired:)]
-        pub fn setNumberOfTouchesRequired(&self, number_of_touches_required: NSUInteger);
-    }
-);
-
-unsafe impl Encode for UITapGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}

src/platform_impl/ios/uikit/mod.rs

@@ -9,11 +9,9 @@ mod application;
 mod coordinate_space;
 mod device;
 mod event;
-mod gesture_recognizer;
 mod responder;
 mod screen;
 mod screen_mode;
-mod status_bar_style;
 mod touch;
 mod trait_collection;
 mod view;
@@ -24,14 +22,9 @@ pub(crate) use self::application::UIApplication;
 pub(crate) use self::coordinate_space::UICoordinateSpace;
 pub(crate) use self::device::UIDevice;
 pub(crate) use self::event::UIEvent;
-pub(crate) use self::gesture_recognizer::{
-    UIGestureRecognizer, UIGestureRecognizerState, UIPinchGestureRecognizer,
-    UIRotationGestureRecognizer, UITapGestureRecognizer,
-};
 pub(crate) use self::responder::UIResponder;
 pub(crate) use self::screen::{UIScreen, UIScreenOverscanCompensation};
 pub(crate) use self::screen_mode::UIScreenMode;
-pub(crate) use self::status_bar_style::UIStatusBarStyle;
 pub(crate) use self::touch::{UITouch, UITouchPhase, UITouchType};
 pub(crate) use self::trait_collection::{UIForceTouchCapability, UITraitCollection};
 #[allow(unused_imports)]

src/platform_impl/ios/uikit/status_bar_style.rs

@@ -1,27 +0,0 @@
-use crate::platform::ios::StatusBarStyle;
-use icrate::Foundation::NSInteger;
-use objc2::encode::{Encode, Encoding};
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UIStatusBarStyle {
-    #[default]
-    Default = 0,
-    LightContent = 1,
-    DarkContent = 3,
-}
-
-impl From<StatusBarStyle> for UIStatusBarStyle {
-    fn from(value: StatusBarStyle) -> Self {
-        match value {
-            StatusBarStyle::Default => Self::Default,
-            StatusBarStyle::LightContent => Self::LightContent,
-            StatusBarStyle::DarkContent => Self::DarkContent,
-        }
-    }
-}
-
-unsafe impl Encode for UIStatusBarStyle {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}

src/platform_impl/ios/uikit/view.rs

@@ -3,7 +3,7 @@ use objc2::encode::{Encode, Encoding};
 use objc2::rc::Id;
 use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
 
-use super::{UICoordinateSpace, UIGestureRecognizer, UIResponder, UIViewController};
+use super::{UICoordinateSpace, UIResponder, UIViewController};
 
 extern_class!(
     #[derive(Debug, PartialEq, Eq, Hash)]
@@ -65,12 +65,6 @@ extern_methods!(
 
         #[method(setNeedsDisplay)]
         pub fn setNeedsDisplay(&self);
-
-        #[method(addGestureRecognizer:)]
-        pub fn addGestureRecognizer(&self, gestureRecognizer: &UIGestureRecognizer);
-
-        #[method(removeGestureRecognizer:)]
-        pub fn removeGestureRecognizer(&self, gestureRecognizer: &UIGestureRecognizer);
     }
 );
 

src/platform_impl/ios/uikit/view_controller.rs

@@ -39,7 +39,7 @@ extern_methods!(
     }
 );
 
-bitflags::bitflags! {
+bitflags! {
     #[derive(Clone, Copy)]
     pub struct UIInterfaceOrientationMask: NSUInteger {
         const Portrait = 1 << 1;

src/platform_impl/ios/view.rs

@@ -1,38 +1,32 @@
 #![allow(clippy::unnecessary_cast)]
-use std::cell::{Cell, RefCell};
+use std::cell::Cell;
+use std::ptr::NonNull;
 
 use icrate::Foundation::{CGFloat, CGRect, MainThreadMarker, NSObject, NSObjectProtocol, NSSet};
+use objc2::declare::{Ivar, IvarDrop};
 use objc2::rc::Id;
 use objc2::runtime::AnyClass;
-use objc2::{
-    declare_class, extern_methods, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass,
-};
+use objc2::{declare_class, extern_methods, msg_send, msg_send_id, mutability, ClassType};
 
 use super::app_state::{self, EventWrapper};
 use super::uikit::{
-    UIApplication, UIDevice, UIEvent, UIForceTouchCapability, UIGestureRecognizerState,
-    UIInterfaceOrientationMask, UIPinchGestureRecognizer, UIResponder, UIRotationGestureRecognizer,
-    UIStatusBarStyle, UITapGestureRecognizer, UITouch, UITouchPhase, UITouchType,
-    UITraitCollection, UIView, UIViewController, UIWindow,
+    UIApplication, UIDevice, UIEvent, UIForceTouchCapability, UIInterfaceOrientationMask,
+    UIResponder, UITouch, UITouchPhase, UITouchType, UITraitCollection, UIView, UIViewController,
+    UIWindow,
 };
 use super::window::WindowId;
 use crate::{
     dpi::PhysicalPosition,
-    event::{Event, Force, Touch, TouchPhase, WindowEvent},
+    event::{DeviceId as RootDeviceId, Event, Force, Touch, TouchPhase, WindowEvent},
     platform::ios::ValidOrientations,
     platform_impl::platform::{
         ffi::{UIRectEdge, UIUserInterfaceIdiom},
-        Fullscreen, DEVICE_ID,
+        window::PlatformSpecificWindowBuilderAttributes,
+        DeviceId, Fullscreen,
     },
     window::{WindowAttributes, WindowId as RootWindowId},
 };
 
-pub struct WinitViewState {
-    pinch_gesture_recognizer: RefCell<Option<Id<UIPinchGestureRecognizer>>>,
-    doubletap_gesture_recognizer: RefCell<Option<Id<UITapGestureRecognizer>>>,
-    rotation_gesture_recognizer: RefCell<Option<Id<UIRotationGestureRecognizer>>>,
-}
-
 declare_class!(
     pub(crate) struct WinitView;
 
@@ -43,10 +37,6 @@ declare_class!(
         const NAME: &'static str = "WinitUIView";
     }
 
-    impl DeclaredClass for WinitView {
-        type Ivars = WinitViewState;
-    }
-
     unsafe impl WinitView {
         #[method(drawRect:)]
         fn draw_rect(&self, rect: CGRect) {
@@ -167,79 +157,6 @@ declare_class!(
         fn touches_cancelled(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
             self.handle_touches(touches)
         }
-
-        #[method(pinchGesture:)]
-        fn pinch_gesture(&self, recognizer: &UIPinchGestureRecognizer) {
-            let window = self.window().unwrap();
-
-            let phase = match recognizer.state() {
-                UIGestureRecognizerState::Began => TouchPhase::Started,
-                UIGestureRecognizerState::Changed => TouchPhase::Moved,
-                UIGestureRecognizerState::Ended => TouchPhase::Ended,
-                UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => {
-                    TouchPhase::Cancelled
-                }
-                state => panic!("unexpected recognizer state: {:?}", state),
-            };
-
-            let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
-                window_id: RootWindowId(window.id()),
-                event: WindowEvent::PinchGesture {
-                    device_id: DEVICE_ID,
-                    delta: recognizer.velocity() as _,
-                    phase,
-                },
-            });
-
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, gesture_event);
-        }
-
-        #[method(doubleTapGesture:)]
-        fn double_tap_gesture(&self, recognizer: &UITapGestureRecognizer) {
-            let window = self.window().unwrap();
-
-            if recognizer.state() == UIGestureRecognizerState::Ended {
-                let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: RootWindowId(window.id()),
-                    event: WindowEvent::DoubleTapGesture {
-                        device_id: DEVICE_ID,
-                    },
-                });
-
-                let mtm = MainThreadMarker::new().unwrap();
-                app_state::handle_nonuser_event(mtm, gesture_event);
-            }
-        }
-
-        #[method(rotationGesture:)]
-        fn rotation_gesture(&self, recognizer: &UIRotationGestureRecognizer) {
-            let window = self.window().unwrap();
-
-            let phase = match recognizer.state() {
-                UIGestureRecognizerState::Began => TouchPhase::Started,
-                UIGestureRecognizerState::Changed => TouchPhase::Moved,
-                UIGestureRecognizerState::Ended => TouchPhase::Ended,
-                UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => {
-                    TouchPhase::Cancelled
-                }
-                state => panic!("unexpected recognizer state: {:?}", state),
-            };
-
-            // Flip the velocity to match macOS.
-            let delta = -recognizer.velocity() as _;
-            let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
-                window_id: RootWindowId(window.id()),
-                event: WindowEvent::RotationGesture {
-                    device_id: DEVICE_ID,
-                    delta,
-                    phase,
-                },
-            });
-
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, gesture_event);
-        }
     }
 );
 
@@ -263,73 +180,24 @@ extern_methods!(
 impl WinitView {
     pub(crate) fn new(
         _mtm: MainThreadMarker,
-        window_attributes: &WindowAttributes,
+        _window_attributes: &WindowAttributes,
+        platform_attributes: &PlatformSpecificWindowBuilderAttributes,
         frame: CGRect,
     ) -> Id<Self> {
-        let this = Self::alloc().set_ivars(WinitViewState {
-            pinch_gesture_recognizer: RefCell::new(None),
-            doubletap_gesture_recognizer: RefCell::new(None),
-            rotation_gesture_recognizer: RefCell::new(None),
-        });
-        let this: Id<Self> = unsafe { msg_send_id![super(this), initWithFrame: frame] };
+        let this: Id<Self> = unsafe { msg_send_id![Self::alloc(), initWithFrame: frame] };
 
         this.setMultipleTouchEnabled(true);
 
-        if let Some(scale_factor) = window_attributes.platform_specific.scale_factor {
+        if let Some(scale_factor) = platform_attributes.scale_factor {
             this.setContentScaleFactor(scale_factor as _);
         }
 
         this
     }
 
-    pub(crate) fn recognize_pinch_gesture(&self, should_recognize: bool) {
-        if should_recognize {
-            if self.ivars().pinch_gesture_recognizer.borrow().is_none() {
-                let pinch: Id<UIPinchGestureRecognizer> = unsafe {
-                    msg_send_id![UIPinchGestureRecognizer::alloc(), initWithTarget: self, action: sel!(pinchGesture:)]
-                };
-                self.addGestureRecognizer(&pinch);
-                self.ivars().pinch_gesture_recognizer.replace(Some(pinch));
-            }
-        } else if let Some(recognizer) = self.ivars().pinch_gesture_recognizer.take() {
-            self.removeGestureRecognizer(&recognizer);
-        }
-    }
-
-    pub(crate) fn recognize_doubletap_gesture(&self, should_recognize: bool) {
-        if should_recognize {
-            if self.ivars().doubletap_gesture_recognizer.borrow().is_none() {
-                let tap: Id<UITapGestureRecognizer> = unsafe {
-                    msg_send_id![UITapGestureRecognizer::alloc(), initWithTarget: self, action: sel!(doubleTapGesture:)]
-                };
-                tap.setNumberOfTapsRequired(2);
-                tap.setNumberOfTouchesRequired(1);
-                self.addGestureRecognizer(&tap);
-                self.ivars().doubletap_gesture_recognizer.replace(Some(tap));
-            }
-        } else if let Some(recognizer) = self.ivars().doubletap_gesture_recognizer.take() {
-            self.removeGestureRecognizer(&recognizer);
-        }
-    }
-
-    pub(crate) fn recognize_rotation_gesture(&self, should_recognize: bool) {
-        if should_recognize {
-            if self.ivars().rotation_gesture_recognizer.borrow().is_none() {
-                let rotation: Id<UIRotationGestureRecognizer> = unsafe {
-                    msg_send_id![UIRotationGestureRecognizer::alloc(), initWithTarget: self, action: sel!(rotationGesture:)]
-                };
-                self.addGestureRecognizer(&rotation);
-                self.ivars()
-                    .rotation_gesture_recognizer
-                    .replace(Some(rotation));
-            }
-        } else if let Some(recognizer) = self.ivars().rotation_gesture_recognizer.take() {
-            self.removeGestureRecognizer(&recognizer);
-        }
-    }
-
     fn handle_touches(&self, touches: &NSSet<UITouch>) {
         let window = self.window().unwrap();
+        let uiscreen = window.screen();
         let mut touch_events = Vec::new();
         let os_supports_force = app_state::os_capabilities().force_touch;
         for touch in touches {
@@ -382,7 +250,9 @@ impl WinitView {
             touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent {
                 window_id: RootWindowId(window.id()),
                 event: WindowEvent::Touch(Touch {
-                    device_id: DEVICE_ID,
+                    device_id: RootDeviceId(DeviceId {
+                        uiscreen: Id::as_ptr(&uiscreen),
+                    }),
                     id: touch_id,
                     location: physical_location,
                     force,
@@ -397,14 +267,17 @@ impl WinitView {
 
 pub struct ViewControllerState {
     prefers_status_bar_hidden: Cell<bool>,
-    preferred_status_bar_style: Cell<UIStatusBarStyle>,
     prefers_home_indicator_auto_hidden: Cell<bool>,
     supported_orientations: Cell<UIInterfaceOrientationMask>,
     preferred_screen_edges_deferring_system_gestures: Cell<UIRectEdge>,
 }
 
 declare_class!(
-    pub(crate) struct WinitViewController;
+    pub(crate) struct WinitViewController {
+        state: IvarDrop<Box<ViewControllerState>, "_state">,
+    }
+
+    mod view_controller_ivars;
 
     unsafe impl ClassType for WinitViewController {
         #[inherits(UIResponder, NSObject)]
@@ -413,8 +286,27 @@ declare_class!(
         const NAME: &'static str = "WinitUIViewController";
     }
 
-    impl DeclaredClass for WinitViewController {
-        type Ivars = ViewControllerState;
+    unsafe impl WinitViewController {
+        #[method(init)]
+        unsafe fn init(this: *mut Self) -> Option<NonNull<Self>> {
+            let this: Option<&mut Self> = msg_send![super(this), init];
+            this.map(|this| {
+                // These are set in WinitViewController::new, it's just to set them
+                // to _something_.
+                Ivar::write(
+                    &mut this.state,
+                    Box::new(ViewControllerState {
+                        prefers_status_bar_hidden: Cell::new(false),
+                        prefers_home_indicator_auto_hidden: Cell::new(false),
+                        supported_orientations: Cell::new(UIInterfaceOrientationMask::All),
+                        preferred_screen_edges_deferring_system_gestures: Cell::new(
+                            UIRectEdge::NONE,
+                        ),
+                    }),
+                );
+                NonNull::from(this)
+            })
+        }
     }
 
     unsafe impl WinitViewController {
@@ -425,27 +317,22 @@ declare_class!(
 
         #[method(prefersStatusBarHidden)]
         fn prefers_status_bar_hidden(&self) -> bool {
-            self.ivars().prefers_status_bar_hidden.get()
-        }
-
-        #[method(preferredStatusBarStyle)]
-        fn preferred_status_bar_style(&self) -> UIStatusBarStyle {
-            self.ivars().preferred_status_bar_style.get()
+            self.state.prefers_status_bar_hidden.get()
         }
 
         #[method(prefersHomeIndicatorAutoHidden)]
         fn prefers_home_indicator_auto_hidden(&self) -> bool {
-            self.ivars().prefers_home_indicator_auto_hidden.get()
+            self.state.prefers_home_indicator_auto_hidden.get()
         }
 
         #[method(supportedInterfaceOrientations)]
         fn supported_orientations(&self) -> UIInterfaceOrientationMask {
-            self.ivars().supported_orientations.get()
+            self.state.supported_orientations.get()
         }
 
         #[method(preferredScreenEdgesDeferringSystemGestures)]
         fn preferred_screen_edges_deferring_system_gestures(&self) -> UIRectEdge {
-            self.ivars()
+            self.state
                 .preferred_screen_edges_deferring_system_gestures
                 .get()
         }
@@ -454,17 +341,12 @@ declare_class!(
 
 impl WinitViewController {
     pub(crate) fn set_prefers_status_bar_hidden(&self, val: bool) {
-        self.ivars().prefers_status_bar_hidden.set(val);
-        self.setNeedsStatusBarAppearanceUpdate();
-    }
-
-    pub(crate) fn set_preferred_status_bar_style(&self, val: UIStatusBarStyle) {
-        self.ivars().preferred_status_bar_style.set(val);
+        self.state.prefers_status_bar_hidden.set(val);
         self.setNeedsStatusBarAppearanceUpdate();
     }
 
     pub(crate) fn set_prefers_home_indicator_auto_hidden(&self, val: bool) {
-        self.ivars().prefers_home_indicator_auto_hidden.set(val);
+        self.state.prefers_home_indicator_auto_hidden.set(val);
         let os_capabilities = app_state::os_capabilities();
         if os_capabilities.home_indicator_hidden {
             self.setNeedsUpdateOfHomeIndicatorAutoHidden();
@@ -474,7 +356,7 @@ impl WinitViewController {
     }
 
     pub(crate) fn set_preferred_screen_edges_deferring_system_gestures(&self, val: UIRectEdge) {
-        self.ivars()
+        self.state
             .preferred_screen_edges_deferring_system_gestures
             .set(val);
         let os_capabilities = app_state::os_capabilities();
@@ -507,52 +389,28 @@ impl WinitViewController {
                     | UIInterfaceOrientationMask::PortraitUpsideDown
             }
         };
-        self.ivars().supported_orientations.set(mask);
+        self.state.supported_orientations.set(mask);
         UIViewController::attemptRotationToDeviceOrientation();
     }
 
     pub(crate) fn new(
         mtm: MainThreadMarker,
-        window_attributes: &WindowAttributes,
+        _window_attributes: &WindowAttributes,
+        platform_attributes: &PlatformSpecificWindowBuilderAttributes,
         view: &UIView,
     ) -> Id<Self> {
-        // These are set properly below, we just to set them to something in the meantime.
-        let this = Self::alloc().set_ivars(ViewControllerState {
-            prefers_status_bar_hidden: Cell::new(false),
-            preferred_status_bar_style: Cell::new(UIStatusBarStyle::Default),
-            prefers_home_indicator_auto_hidden: Cell::new(false),
-            supported_orientations: Cell::new(UIInterfaceOrientationMask::All),
-            preferred_screen_edges_deferring_system_gestures: Cell::new(UIRectEdge::NONE),
-        });
-        let this: Id<Self> = unsafe { msg_send_id![super(this), init] };
+        let this: Id<Self> = unsafe { msg_send_id![Self::alloc(), init] };
 
-        this.set_prefers_status_bar_hidden(
-            window_attributes
-                .platform_specific
-                .prefers_status_bar_hidden,
-        );
+        this.set_prefers_status_bar_hidden(platform_attributes.prefers_status_bar_hidden);
 
-        this.set_preferred_status_bar_style(
-            window_attributes
-                .platform_specific
-                .preferred_status_bar_style
-                .into(),
-        );
-
-        this.set_supported_interface_orientations(
-            mtm,
-            window_attributes.platform_specific.valid_orientations,
-        );
+        this.set_supported_interface_orientations(mtm, platform_attributes.valid_orientations);
 
         this.set_prefers_home_indicator_auto_hidden(
-            window_attributes
-                .platform_specific
-                .prefers_home_indicator_hidden,
+            platform_attributes.prefers_home_indicator_hidden,
         );
 
         this.set_preferred_screen_edges_deferring_system_gestures(
-            window_attributes
-                .platform_specific
+            platform_attributes
                 .preferred_screen_edges_deferring_system_gestures
                 .into(),
         );
@@ -574,8 +432,6 @@ declare_class!(
         const NAME: &'static str = "WinitUIWindow";
     }
 
-    impl DeclaredClass for WinitUIWindow {}
-
     unsafe impl WinitUIWindow {
         #[method(becomeKeyWindow)]
         fn become_key_window(&self) {
@@ -609,6 +465,7 @@ impl WinitUIWindow {
     pub(crate) fn new(
         mtm: MainThreadMarker,
         window_attributes: &WindowAttributes,
+        _platform_attributes: &PlatformSpecificWindowBuilderAttributes,
         frame: CGRect,
         view_controller: &UIViewController,
     ) -> Id<Self> {
@@ -647,8 +504,6 @@ declare_class!(
         const NAME: &'static str = "WinitApplicationDelegate";
     }
 
-    impl DeclaredClass for WinitApplicationDelegate {}
-
     // UIApplicationDelegate protocol
     unsafe impl WinitApplicationDelegate {
         #[method(application:didFinishLaunchingWithOptions:)]

src/platform_impl/ios/window.rs

@@ -3,7 +3,6 @@
 use std::collections::VecDeque;
 
 use icrate::Foundation::{CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker};
-use log::{debug, warn};
 use objc2::rc::Id;
 use objc2::runtime::AnyObject;
 use objc2::{class, msg_send};
@@ -12,18 +11,17 @@ use super::app_state::EventWrapper;
 use super::uikit::{UIApplication, UIScreen, UIScreenOverscanCompensation};
 use super::view::{WinitUIWindow, WinitView, WinitViewController};
 use crate::{
-    cursor::Cursor,
     dpi::{self, LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size},
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
     event::{Event, WindowEvent},
     icon::Icon,
-    platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations},
+    platform::ios::{ScreenEdge, ValidOrientations},
     platform_impl::platform::{
         app_state, monitor, EventLoopWindowTarget, Fullscreen, MonitorHandle,
     },
     window::{
-        CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, WindowAttributes,
-        WindowButtons, WindowId as RootWindowId, WindowLevel,
+        CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
+        WindowAttributes, WindowButtons, WindowId as RootWindowId, WindowLevel,
     },
 };
 
@@ -175,8 +173,8 @@ impl Inner {
         self.view.contentScaleFactor() as _
     }
 
-    pub fn set_cursor(&self, _cursor: Cursor) {
-        debug!("`Window::set_cursor` ignored on iOS")
+    pub fn set_cursor_icon(&self, _cursor: CursorIcon) {
+        debug!("`Window::set_cursor_icon` ignored on iOS")
     }
 
     pub fn set_cursor_position(&self, _position: Position) -> Result<(), ExternalError> {
@@ -357,14 +355,23 @@ impl Inner {
     }
 
     #[cfg(feature = "rwh_06")]
-    pub fn raw_window_handle_rwh_06(&self) -> rwh_06::RawWindowHandle {
+    pub fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
         let mut window_handle = rwh_06::UiKitWindowHandle::new({
             let ui_view = Id::as_ptr(&self.view) as _;
             std::ptr::NonNull::new(ui_view).expect("Id<T> should never be null")
         });
         window_handle.ui_view_controller =
             std::ptr::NonNull::new(Id::as_ptr(&self.view_controller) as _);
-        rwh_06::RawWindowHandle::UiKit(window_handle)
+        Ok(rwh_06::RawWindowHandle::UiKit(window_handle))
+    }
+
+    #[cfg(feature = "rwh_06")]
+    pub fn raw_display_handle_rwh_06(
+        &self,
+    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
+        Ok(rwh_06::RawDisplayHandle::UiKit(
+            rwh_06::UiKitDisplayHandle::new(),
+        ))
     }
 
     pub fn theme(&self) -> Option<Theme> {
@@ -398,9 +405,10 @@ pub struct Window {
 }
 
 impl Window {
-    pub(crate) fn new(
-        event_loop: &EventLoopWindowTarget,
+    pub(crate) fn new<T>(
+        event_loop: &EventLoopWindowTarget<T>,
         window_attributes: WindowAttributes,
+        platform_attributes: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Window, RootOsError> {
         let mtm = event_loop.mtm;
 
@@ -438,7 +446,7 @@ impl Window {
             None => screen_bounds,
         };
 
-        let view = WinitView::new(mtm, &window_attributes, frame);
+        let view = WinitView::new(mtm, &window_attributes, &platform_attributes, frame);
 
         let gl_or_metal_backed = unsafe {
             let layer_class = WinitView::layerClass();
@@ -447,8 +455,15 @@ impl Window {
             is_metal || is_gl
         };
 
-        let view_controller = WinitViewController::new(mtm, &window_attributes, &view);
-        let window = WinitUIWindow::new(mtm, &window_attributes, frame, &view_controller);
+        let view_controller =
+            WinitViewController::new(mtm, &window_attributes, &platform_attributes, &view);
+        let window = WinitUIWindow::new(
+            mtm,
+            &window_attributes,
+            &platform_attributes,
+            frame,
+            &view_controller,
+        );
 
         app_state::set_key_window(mtm, &window);
 
@@ -501,29 +516,7 @@ impl Window {
     }
 
     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))
-    }
-
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub(crate) fn raw_window_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
-        if let Some(mtm) = MainThreadMarker::new() {
-            Ok(self.inner.get(mtm).raw_window_handle_rwh_06())
-        } else {
-            Err(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::UiKit(
-            rwh_06::UiKitDisplayHandle::new(),
-        ))
+        self.inner.get_on_main(|inner, _mtm| f(inner))
     }
 }
 
@@ -558,23 +551,6 @@ impl Inner {
     pub fn set_prefers_status_bar_hidden(&self, hidden: bool) {
         self.view_controller.set_prefers_status_bar_hidden(hidden);
     }
-
-    pub fn set_preferred_status_bar_style(&self, status_bar_style: StatusBarStyle) {
-        self.view_controller
-            .set_preferred_status_bar_style(status_bar_style.into());
-    }
-
-    pub fn recognize_pinch_gesture(&self, should_recognize: bool) {
-        self.view.recognize_pinch_gesture(should_recognize);
-    }
-
-    pub fn recognize_doubletap_gesture(&self, should_recognize: bool) {
-        self.view.recognize_doubletap_gesture(should_recognize);
-    }
-
-    pub fn recognize_rotation_gesture(&self, should_recognize: bool) {
-        self.view.recognize_rotation_gesture(should_recognize);
-    }
 }
 
 impl Inner {
@@ -677,12 +653,11 @@ impl From<&AnyObject> for WindowId {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Default)]
 pub struct PlatformSpecificWindowBuilderAttributes {
     pub scale_factor: Option<f64>,
     pub valid_orientations: ValidOrientations,
     pub prefers_home_indicator_hidden: bool,
     pub prefers_status_bar_hidden: bool,
-    pub preferred_status_bar_style: StatusBarStyle,
     pub preferred_screen_edges_deferring_system_gestures: ScreenEdge,
 }

src/platform_impl/linux/common/keymap.rs

@@ -1,18 +1,18 @@
 //! Convert XKB keys to Winit keys.
 
-use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
+use crate::keyboard::{Key, KeyCode, KeyLocation, NativeKey, NativeKeyCode};
 
 /// Map the raw X11-style keycode to the `KeyCode` enum.
 ///
 /// X11-style keycodes are offset by 8 from the keycodes the Linux kernel uses.
-pub fn raw_keycode_to_physicalkey(keycode: u32) -> PhysicalKey {
-    scancode_to_physicalkey(keycode.saturating_sub(8))
+pub fn raw_keycode_to_keycode(keycode: u32) -> KeyCode {
+    scancode_to_keycode(keycode.saturating_sub(8))
 }
 
 /// Map the linux scancode to Keycode.
 ///
 /// Both X11 and Wayland use keys with `+ 8` offset to linux scancode.
-pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
+pub fn scancode_to_keycode(scancode: u32) -> KeyCode {
     // The keycode values are taken from linux/include/uapi/linux/input-event-codes.h, as
     // libxkbcommon's documentation seems to suggest that the keycode values we're interested in
     // are defined by the Linux kernel. If Winit programs end up being run on other Unix-likes,
@@ -21,8 +21,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
     // Some of the keycodes are likely superfluous for our purposes, and some are ones which are
     // difficult to test the correctness of, or discover the purpose of. Because of this, they've
     // either been commented out here, or not included at all.
-    PhysicalKey::Code(match scancode {
-        0 => return PhysicalKey::Unidentified(NativeKeyCode::Xkb(0)),
+    match scancode {
+        0 => KeyCode::Unidentified(NativeKeyCode::Xkb(0)),
         1 => KeyCode::Escape,
         2 => KeyCode::Digit1,
         3 => KeyCode::Digit2,
@@ -256,7 +256,7 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         // 237 => KeyCode::BLUETOOTH,
         // 238 => KeyCode::WLAN,
         // 239 => KeyCode::UWB,
-        240 => return PhysicalKey::Unidentified(NativeKeyCode::Unidentified),
+        240 => KeyCode::Unidentified(NativeKeyCode::Unidentified),
         // 241 => KeyCode::VIDEO_NEXT,
         // 242 => KeyCode::VIDEO_PREV,
         // 243 => KeyCode::BRIGHTNESS_CYCLE,
@@ -265,23 +265,14 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         // 246 => KeyCode::WWAN,
         // 247 => KeyCode::RFKILL,
         // 248 => KeyCode::KEY_MICMUTE,
-        _ => return PhysicalKey::Unidentified(NativeKeyCode::Xkb(scancode)),
-    })
+        _ => KeyCode::Unidentified(NativeKeyCode::Xkb(scancode)),
+    }
 }
 
-pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
-    let code = match key {
-        PhysicalKey::Code(code) => code,
-        PhysicalKey::Unidentified(code) => {
-            return match code {
-                NativeKeyCode::Unidentified => Some(240),
-                NativeKeyCode::Xkb(raw) => Some(raw),
-                _ => None,
-            };
-        }
-    };
-
-    match code {
+pub fn keycode_to_scancode(keycode: KeyCode) -> Option<u32> {
+    match keycode {
+        KeyCode::Unidentified(NativeKeyCode::Unidentified) => Some(240),
+        KeyCode::Unidentified(NativeKeyCode::Xkb(raw)) => Some(raw),
         KeyCode::Escape => Some(1),
         KeyCode::Digit1 => Some(2),
         KeyCode::Digit2 => Some(3),
@@ -424,213 +415,213 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
 
 pub fn keysym_to_key(keysym: u32) -> Key {
     use xkbcommon_dl::keysyms;
-    Key::Named(match keysym {
+    match keysym {
         // TTY function keys
-        keysyms::BackSpace => NamedKey::Backspace,
-        keysyms::Tab => NamedKey::Tab,
-        // keysyms::Linefeed => NamedKey::Linefeed,
-        keysyms::Clear => NamedKey::Clear,
-        keysyms::Return => NamedKey::Enter,
-        keysyms::Pause => NamedKey::Pause,
-        keysyms::Scroll_Lock => NamedKey::ScrollLock,
-        keysyms::Sys_Req => NamedKey::PrintScreen,
-        keysyms::Escape => NamedKey::Escape,
-        keysyms::Delete => NamedKey::Delete,
+        keysyms::BackSpace => Key::Backspace,
+        keysyms::Tab => Key::Tab,
+        // keysyms::Linefeed => Key::Linefeed,
+        keysyms::Clear => Key::Clear,
+        keysyms::Return => Key::Enter,
+        keysyms::Pause => Key::Pause,
+        keysyms::Scroll_Lock => Key::ScrollLock,
+        keysyms::Sys_Req => Key::PrintScreen,
+        keysyms::Escape => Key::Escape,
+        keysyms::Delete => Key::Delete,
 
         // IME keys
-        keysyms::Multi_key => NamedKey::Compose,
-        keysyms::Codeinput => NamedKey::CodeInput,
-        keysyms::SingleCandidate => NamedKey::SingleCandidate,
-        keysyms::MultipleCandidate => NamedKey::AllCandidates,
-        keysyms::PreviousCandidate => NamedKey::PreviousCandidate,
+        keysyms::Multi_key => Key::Compose,
+        keysyms::Codeinput => Key::CodeInput,
+        keysyms::SingleCandidate => Key::SingleCandidate,
+        keysyms::MultipleCandidate => Key::AllCandidates,
+        keysyms::PreviousCandidate => Key::PreviousCandidate,
 
         // Japanese keys
-        keysyms::Kanji => NamedKey::KanjiMode,
-        keysyms::Muhenkan => NamedKey::NonConvert,
-        keysyms::Henkan_Mode => NamedKey::Convert,
-        keysyms::Romaji => NamedKey::Romaji,
-        keysyms::Hiragana => NamedKey::Hiragana,
-        keysyms::Hiragana_Katakana => NamedKey::HiraganaKatakana,
-        keysyms::Zenkaku => NamedKey::Zenkaku,
-        keysyms::Hankaku => NamedKey::Hankaku,
-        keysyms::Zenkaku_Hankaku => NamedKey::ZenkakuHankaku,
-        // keysyms::Touroku => NamedKey::Touroku,
-        // keysyms::Massyo => NamedKey::Massyo,
-        keysyms::Kana_Lock => NamedKey::KanaMode,
-        keysyms::Kana_Shift => NamedKey::KanaMode,
-        keysyms::Eisu_Shift => NamedKey::Alphanumeric,
-        keysyms::Eisu_toggle => NamedKey::Alphanumeric,
+        keysyms::Kanji => Key::KanjiMode,
+        keysyms::Muhenkan => Key::NonConvert,
+        keysyms::Henkan_Mode => Key::Convert,
+        keysyms::Romaji => Key::Romaji,
+        keysyms::Hiragana => Key::Hiragana,
+        keysyms::Hiragana_Katakana => Key::HiraganaKatakana,
+        keysyms::Zenkaku => Key::Zenkaku,
+        keysyms::Hankaku => Key::Hankaku,
+        keysyms::Zenkaku_Hankaku => Key::ZenkakuHankaku,
+        // keysyms::Touroku => Key::Touroku,
+        // keysyms::Massyo => Key::Massyo,
+        keysyms::Kana_Lock => Key::KanaMode,
+        keysyms::Kana_Shift => Key::KanaMode,
+        keysyms::Eisu_Shift => Key::Alphanumeric,
+        keysyms::Eisu_toggle => Key::Alphanumeric,
         // NOTE: The next three items are aliases for values we've already mapped.
-        // keysyms::Kanji_Bangou => NamedKey::CodeInput,
-        // keysyms::Zen_Koho => NamedKey::AllCandidates,
-        // keysyms::Mae_Koho => NamedKey::PreviousCandidate,
+        // keysyms::Kanji_Bangou => Key::CodeInput,
+        // keysyms::Zen_Koho => Key::AllCandidates,
+        // keysyms::Mae_Koho => Key::PreviousCandidate,
 
         // Cursor control & motion
-        keysyms::Home => NamedKey::Home,
-        keysyms::Left => NamedKey::ArrowLeft,
-        keysyms::Up => NamedKey::ArrowUp,
-        keysyms::Right => NamedKey::ArrowRight,
-        keysyms::Down => NamedKey::ArrowDown,
-        // keysyms::Prior => NamedKey::PageUp,
-        keysyms::Page_Up => NamedKey::PageUp,
-        // keysyms::Next => NamedKey::PageDown,
-        keysyms::Page_Down => NamedKey::PageDown,
-        keysyms::End => NamedKey::End,
-        // keysyms::Begin => NamedKey::Begin,
+        keysyms::Home => Key::Home,
+        keysyms::Left => Key::ArrowLeft,
+        keysyms::Up => Key::ArrowUp,
+        keysyms::Right => Key::ArrowRight,
+        keysyms::Down => Key::ArrowDown,
+        // keysyms::Prior => Key::PageUp,
+        keysyms::Page_Up => Key::PageUp,
+        // keysyms::Next => Key::PageDown,
+        keysyms::Page_Down => Key::PageDown,
+        keysyms::End => Key::End,
+        // keysyms::Begin => Key::Begin,
 
         // Misc. functions
-        keysyms::Select => NamedKey::Select,
-        keysyms::Print => NamedKey::PrintScreen,
-        keysyms::Execute => NamedKey::Execute,
-        keysyms::Insert => NamedKey::Insert,
-        keysyms::Undo => NamedKey::Undo,
-        keysyms::Redo => NamedKey::Redo,
-        keysyms::Menu => NamedKey::ContextMenu,
-        keysyms::Find => NamedKey::Find,
-        keysyms::Cancel => NamedKey::Cancel,
-        keysyms::Help => NamedKey::Help,
-        keysyms::Break => NamedKey::Pause,
-        keysyms::Mode_switch => NamedKey::ModeChange,
-        // keysyms::script_switch => NamedKey::ModeChange,
-        keysyms::Num_Lock => NamedKey::NumLock,
+        keysyms::Select => Key::Select,
+        keysyms::Print => Key::PrintScreen,
+        keysyms::Execute => Key::Execute,
+        keysyms::Insert => Key::Insert,
+        keysyms::Undo => Key::Undo,
+        keysyms::Redo => Key::Redo,
+        keysyms::Menu => Key::ContextMenu,
+        keysyms::Find => Key::Find,
+        keysyms::Cancel => Key::Cancel,
+        keysyms::Help => Key::Help,
+        keysyms::Break => Key::Pause,
+        keysyms::Mode_switch => Key::ModeChange,
+        // keysyms::script_switch => Key::ModeChange,
+        keysyms::Num_Lock => Key::NumLock,
 
         // Keypad keys
-        // keysyms::KP_Space => return Key::Character(" "),
-        keysyms::KP_Tab => NamedKey::Tab,
-        keysyms::KP_Enter => NamedKey::Enter,
-        keysyms::KP_F1 => NamedKey::F1,
-        keysyms::KP_F2 => NamedKey::F2,
-        keysyms::KP_F3 => NamedKey::F3,
-        keysyms::KP_F4 => NamedKey::F4,
-        keysyms::KP_Home => NamedKey::Home,
-        keysyms::KP_Left => NamedKey::ArrowLeft,
-        keysyms::KP_Up => NamedKey::ArrowUp,
-        keysyms::KP_Right => NamedKey::ArrowRight,
-        keysyms::KP_Down => NamedKey::ArrowDown,
-        // keysyms::KP_Prior => NamedKey::PageUp,
-        keysyms::KP_Page_Up => NamedKey::PageUp,
-        // keysyms::KP_Next => NamedKey::PageDown,
-        keysyms::KP_Page_Down => NamedKey::PageDown,
-        keysyms::KP_End => NamedKey::End,
+        // keysyms::KP_Space => Key::Character(" "),
+        keysyms::KP_Tab => Key::Tab,
+        keysyms::KP_Enter => Key::Enter,
+        keysyms::KP_F1 => Key::F1,
+        keysyms::KP_F2 => Key::F2,
+        keysyms::KP_F3 => Key::F3,
+        keysyms::KP_F4 => Key::F4,
+        keysyms::KP_Home => Key::Home,
+        keysyms::KP_Left => Key::ArrowLeft,
+        keysyms::KP_Up => Key::ArrowLeft,
+        keysyms::KP_Right => Key::ArrowRight,
+        keysyms::KP_Down => Key::ArrowDown,
+        // keysyms::KP_Prior => Key::PageUp,
+        keysyms::KP_Page_Up => Key::PageUp,
+        // keysyms::KP_Next => Key::PageDown,
+        keysyms::KP_Page_Down => Key::PageDown,
+        keysyms::KP_End => Key::End,
         // This is the key labeled "5" on the numpad when NumLock is off.
-        // keysyms::KP_Begin => NamedKey::Begin,
-        keysyms::KP_Insert => NamedKey::Insert,
-        keysyms::KP_Delete => NamedKey::Delete,
-        // keysyms::KP_Equal => NamedKey::Equal,
-        // keysyms::KP_Multiply => NamedKey::Multiply,
-        // keysyms::KP_Add => NamedKey::Add,
-        // keysyms::KP_Separator => NamedKey::Separator,
-        // keysyms::KP_Subtract => NamedKey::Subtract,
-        // keysyms::KP_Decimal => NamedKey::Decimal,
-        // keysyms::KP_Divide => NamedKey::Divide,
+        // keysyms::KP_Begin => Key::Begin,
+        keysyms::KP_Insert => Key::Insert,
+        keysyms::KP_Delete => Key::Delete,
+        // keysyms::KP_Equal => Key::Equal,
+        // keysyms::KP_Multiply => Key::Multiply,
+        // keysyms::KP_Add => Key::Add,
+        // keysyms::KP_Separator => Key::Separator,
+        // keysyms::KP_Subtract => Key::Subtract,
+        // keysyms::KP_Decimal => Key::Decimal,
+        // keysyms::KP_Divide => Key::Divide,
 
-        // keysyms::KP_0 => return Key::Character("0"),
-        // keysyms::KP_1 => return Key::Character("1"),
-        // keysyms::KP_2 => return Key::Character("2"),
-        // keysyms::KP_3 => return Key::Character("3"),
-        // keysyms::KP_4 => return Key::Character("4"),
-        // keysyms::KP_5 => return Key::Character("5"),
-        // keysyms::KP_6 => return Key::Character("6"),
-        // keysyms::KP_7 => return Key::Character("7"),
-        // keysyms::KP_8 => return Key::Character("8"),
-        // keysyms::KP_9 => return Key::Character("9"),
+        // keysyms::KP_0 => Key::Character("0"),
+        // keysyms::KP_1 => Key::Character("1"),
+        // keysyms::KP_2 => Key::Character("2"),
+        // keysyms::KP_3 => Key::Character("3"),
+        // keysyms::KP_4 => Key::Character("4"),
+        // keysyms::KP_5 => Key::Character("5"),
+        // keysyms::KP_6 => Key::Character("6"),
+        // keysyms::KP_7 => Key::Character("7"),
+        // keysyms::KP_8 => Key::Character("8"),
+        // keysyms::KP_9 => Key::Character("9"),
 
         // Function keys
-        keysyms::F1 => NamedKey::F1,
-        keysyms::F2 => NamedKey::F2,
-        keysyms::F3 => NamedKey::F3,
-        keysyms::F4 => NamedKey::F4,
-        keysyms::F5 => NamedKey::F5,
-        keysyms::F6 => NamedKey::F6,
-        keysyms::F7 => NamedKey::F7,
-        keysyms::F8 => NamedKey::F8,
-        keysyms::F9 => NamedKey::F9,
-        keysyms::F10 => NamedKey::F10,
-        keysyms::F11 => NamedKey::F11,
-        keysyms::F12 => NamedKey::F12,
-        keysyms::F13 => NamedKey::F13,
-        keysyms::F14 => NamedKey::F14,
-        keysyms::F15 => NamedKey::F15,
-        keysyms::F16 => NamedKey::F16,
-        keysyms::F17 => NamedKey::F17,
-        keysyms::F18 => NamedKey::F18,
-        keysyms::F19 => NamedKey::F19,
-        keysyms::F20 => NamedKey::F20,
-        keysyms::F21 => NamedKey::F21,
-        keysyms::F22 => NamedKey::F22,
-        keysyms::F23 => NamedKey::F23,
-        keysyms::F24 => NamedKey::F24,
-        keysyms::F25 => NamedKey::F25,
-        keysyms::F26 => NamedKey::F26,
-        keysyms::F27 => NamedKey::F27,
-        keysyms::F28 => NamedKey::F28,
-        keysyms::F29 => NamedKey::F29,
-        keysyms::F30 => NamedKey::F30,
-        keysyms::F31 => NamedKey::F31,
-        keysyms::F32 => NamedKey::F32,
-        keysyms::F33 => NamedKey::F33,
-        keysyms::F34 => NamedKey::F34,
-        keysyms::F35 => NamedKey::F35,
+        keysyms::F1 => Key::F1,
+        keysyms::F2 => Key::F2,
+        keysyms::F3 => Key::F3,
+        keysyms::F4 => Key::F4,
+        keysyms::F5 => Key::F5,
+        keysyms::F6 => Key::F6,
+        keysyms::F7 => Key::F7,
+        keysyms::F8 => Key::F8,
+        keysyms::F9 => Key::F9,
+        keysyms::F10 => Key::F10,
+        keysyms::F11 => Key::F11,
+        keysyms::F12 => Key::F12,
+        keysyms::F13 => Key::F13,
+        keysyms::F14 => Key::F14,
+        keysyms::F15 => Key::F15,
+        keysyms::F16 => Key::F16,
+        keysyms::F17 => Key::F17,
+        keysyms::F18 => Key::F18,
+        keysyms::F19 => Key::F19,
+        keysyms::F20 => Key::F20,
+        keysyms::F21 => Key::F21,
+        keysyms::F22 => Key::F22,
+        keysyms::F23 => Key::F23,
+        keysyms::F24 => Key::F24,
+        keysyms::F25 => Key::F25,
+        keysyms::F26 => Key::F26,
+        keysyms::F27 => Key::F27,
+        keysyms::F28 => Key::F28,
+        keysyms::F29 => Key::F29,
+        keysyms::F30 => Key::F30,
+        keysyms::F31 => Key::F31,
+        keysyms::F32 => Key::F32,
+        keysyms::F33 => Key::F33,
+        keysyms::F34 => Key::F34,
+        keysyms::F35 => Key::F35,
 
         // Modifiers
-        keysyms::Shift_L => NamedKey::Shift,
-        keysyms::Shift_R => NamedKey::Shift,
-        keysyms::Control_L => NamedKey::Control,
-        keysyms::Control_R => NamedKey::Control,
-        keysyms::Caps_Lock => NamedKey::CapsLock,
-        // keysyms::Shift_Lock => NamedKey::ShiftLock,
+        keysyms::Shift_L => Key::Shift,
+        keysyms::Shift_R => Key::Shift,
+        keysyms::Control_L => Key::Control,
+        keysyms::Control_R => Key::Control,
+        keysyms::Caps_Lock => Key::CapsLock,
+        // keysyms::Shift_Lock => Key::ShiftLock,
 
-        // keysyms::Meta_L => NamedKey::Meta,
-        // keysyms::Meta_R => NamedKey::Meta,
-        keysyms::Alt_L => NamedKey::Alt,
-        keysyms::Alt_R => NamedKey::Alt,
-        keysyms::Super_L => NamedKey::Super,
-        keysyms::Super_R => NamedKey::Super,
-        keysyms::Hyper_L => NamedKey::Hyper,
-        keysyms::Hyper_R => NamedKey::Hyper,
+        // keysyms::Meta_L => Key::Meta,
+        // keysyms::Meta_R => Key::Meta,
+        keysyms::Alt_L => Key::Alt,
+        keysyms::Alt_R => Key::Alt,
+        keysyms::Super_L => Key::Super,
+        keysyms::Super_R => Key::Super,
+        keysyms::Hyper_L => Key::Hyper,
+        keysyms::Hyper_R => Key::Hyper,
 
         // XKB function and modifier keys
-        // keysyms::ISO_Lock => NamedKey::IsoLock,
-        // keysyms::ISO_Level2_Latch => NamedKey::IsoLevel2Latch,
-        keysyms::ISO_Level3_Shift => NamedKey::AltGraph,
-        keysyms::ISO_Level3_Latch => NamedKey::AltGraph,
-        keysyms::ISO_Level3_Lock => NamedKey::AltGraph,
-        // keysyms::ISO_Level5_Shift => NamedKey::IsoLevel5Shift,
-        // keysyms::ISO_Level5_Latch => NamedKey::IsoLevel5Latch,
-        // keysyms::ISO_Level5_Lock => NamedKey::IsoLevel5Lock,
-        // keysyms::ISO_Group_Shift => NamedKey::IsoGroupShift,
-        // keysyms::ISO_Group_Latch => NamedKey::IsoGroupLatch,
-        // keysyms::ISO_Group_Lock => NamedKey::IsoGroupLock,
-        keysyms::ISO_Next_Group => NamedKey::GroupNext,
-        // keysyms::ISO_Next_Group_Lock => NamedKey::GroupNextLock,
-        keysyms::ISO_Prev_Group => NamedKey::GroupPrevious,
-        // keysyms::ISO_Prev_Group_Lock => NamedKey::GroupPreviousLock,
-        keysyms::ISO_First_Group => NamedKey::GroupFirst,
-        // keysyms::ISO_First_Group_Lock => NamedKey::GroupFirstLock,
-        keysyms::ISO_Last_Group => NamedKey::GroupLast,
-        // keysyms::ISO_Last_Group_Lock => NamedKey::GroupLastLock,
+        // keysyms::ISO_Lock => Key::IsoLock,
+        // keysyms::ISO_Level2_Latch => Key::IsoLevel2Latch,
+        keysyms::ISO_Level3_Shift => Key::AltGraph,
+        keysyms::ISO_Level3_Latch => Key::AltGraph,
+        keysyms::ISO_Level3_Lock => Key::AltGraph,
+        // keysyms::ISO_Level5_Shift => Key::IsoLevel5Shift,
+        // keysyms::ISO_Level5_Latch => Key::IsoLevel5Latch,
+        // keysyms::ISO_Level5_Lock => Key::IsoLevel5Lock,
+        // keysyms::ISO_Group_Shift => Key::IsoGroupShift,
+        // keysyms::ISO_Group_Latch => Key::IsoGroupLatch,
+        // keysyms::ISO_Group_Lock => Key::IsoGroupLock,
+        keysyms::ISO_Next_Group => Key::GroupNext,
+        // keysyms::ISO_Next_Group_Lock => Key::GroupNextLock,
+        keysyms::ISO_Prev_Group => Key::GroupPrevious,
+        // keysyms::ISO_Prev_Group_Lock => Key::GroupPreviousLock,
+        keysyms::ISO_First_Group => Key::GroupFirst,
+        // keysyms::ISO_First_Group_Lock => Key::GroupFirstLock,
+        keysyms::ISO_Last_Group => Key::GroupLast,
+        // keysyms::ISO_Last_Group_Lock => Key::GroupLastLock,
         //
-        keysyms::ISO_Left_Tab => NamedKey::Tab,
-        // keysyms::ISO_Move_Line_Up => NamedKey::IsoMoveLineUp,
-        // keysyms::ISO_Move_Line_Down => NamedKey::IsoMoveLineDown,
-        // keysyms::ISO_Partial_Line_Up => NamedKey::IsoPartialLineUp,
-        // keysyms::ISO_Partial_Line_Down => NamedKey::IsoPartialLineDown,
-        // keysyms::ISO_Partial_Space_Left => NamedKey::IsoPartialSpaceLeft,
-        // keysyms::ISO_Partial_Space_Right => NamedKey::IsoPartialSpaceRight,
-        // keysyms::ISO_Set_Margin_Left => NamedKey::IsoSetMarginLeft,
-        // keysyms::ISO_Set_Margin_Right => NamedKey::IsoSetMarginRight,
-        // keysyms::ISO_Release_Margin_Left => NamedKey::IsoReleaseMarginLeft,
-        // keysyms::ISO_Release_Margin_Right => NamedKey::IsoReleaseMarginRight,
-        // keysyms::ISO_Release_Both_Margins => NamedKey::IsoReleaseBothMargins,
-        // keysyms::ISO_Fast_Cursor_Left => NamedKey::IsoFastCursorLeft,
-        // keysyms::ISO_Fast_Cursor_Right => NamedKey::IsoFastCursorRight,
-        // keysyms::ISO_Fast_Cursor_Up => NamedKey::IsoFastCursorUp,
-        // keysyms::ISO_Fast_Cursor_Down => NamedKey::IsoFastCursorDown,
-        // keysyms::ISO_Continuous_Underline => NamedKey::IsoContinuousUnderline,
-        // keysyms::ISO_Discontinuous_Underline => NamedKey::IsoDiscontinuousUnderline,
-        // keysyms::ISO_Emphasize => NamedKey::IsoEmphasize,
-        // keysyms::ISO_Center_Object => NamedKey::IsoCenterObject,
-        keysyms::ISO_Enter => NamedKey::Enter,
+        keysyms::ISO_Left_Tab => Key::Tab,
+        // keysyms::ISO_Move_Line_Up => Key::IsoMoveLineUp,
+        // keysyms::ISO_Move_Line_Down => Key::IsoMoveLineDown,
+        // keysyms::ISO_Partial_Line_Up => Key::IsoPartialLineUp,
+        // keysyms::ISO_Partial_Line_Down => Key::IsoPartialLineDown,
+        // keysyms::ISO_Partial_Space_Left => Key::IsoPartialSpaceLeft,
+        // keysyms::ISO_Partial_Space_Right => Key::IsoPartialSpaceRight,
+        // keysyms::ISO_Set_Margin_Left => Key::IsoSetMarginLeft,
+        // keysyms::ISO_Set_Margin_Right => Key::IsoSetMarginRight,
+        // keysyms::ISO_Release_Margin_Left => Key::IsoReleaseMarginLeft,
+        // keysyms::ISO_Release_Margin_Right => Key::IsoReleaseMarginRight,
+        // keysyms::ISO_Release_Both_Margins => Key::IsoReleaseBothMargins,
+        // keysyms::ISO_Fast_Cursor_Left => Key::IsoFastCursorLeft,
+        // keysyms::ISO_Fast_Cursor_Right => Key::IsoFastCursorRight,
+        // keysyms::ISO_Fast_Cursor_Up => Key::IsoFastCursorUp,
+        // keysyms::ISO_Fast_Cursor_Down => Key::IsoFastCursorDown,
+        // keysyms::ISO_Continuous_Underline => Key::IsoContinuousUnderline,
+        // keysyms::ISO_Discontinuous_Underline => Key::IsoDiscontinuousUnderline,
+        // keysyms::ISO_Emphasize => Key::IsoEmphasize,
+        // keysyms::ISO_Center_Object => Key::IsoCenterObject,
+        keysyms::ISO_Enter => Key::Enter,
 
         // dead_grave..dead_currency
 
@@ -651,194 +642,194 @@ pub fn keysym_to_key(keysym: u32) -> Key {
         // ch..C_H
 
         // 3270 terminal keys
-        // keysyms::3270_Duplicate => NamedKey::Duplicate,
-        // keysyms::3270_FieldMark => NamedKey::FieldMark,
-        // keysyms::3270_Right2 => NamedKey::Right2,
-        // keysyms::3270_Left2 => NamedKey::Left2,
-        // keysyms::3270_BackTab => NamedKey::BackTab,
-        keysyms::_3270_EraseEOF => NamedKey::EraseEof,
-        // keysyms::3270_EraseInput => NamedKey::EraseInput,
-        // keysyms::3270_Reset => NamedKey::Reset,
-        // keysyms::3270_Quit => NamedKey::Quit,
-        // keysyms::3270_PA1 => NamedKey::Pa1,
-        // keysyms::3270_PA2 => NamedKey::Pa2,
-        // keysyms::3270_PA3 => NamedKey::Pa3,
-        // keysyms::3270_Test => NamedKey::Test,
-        keysyms::_3270_Attn => NamedKey::Attn,
-        // keysyms::3270_CursorBlink => NamedKey::CursorBlink,
-        // keysyms::3270_AltCursor => NamedKey::AltCursor,
-        // keysyms::3270_KeyClick => NamedKey::KeyClick,
-        // keysyms::3270_Jump => NamedKey::Jump,
-        // keysyms::3270_Ident => NamedKey::Ident,
-        // keysyms::3270_Rule => NamedKey::Rule,
-        // keysyms::3270_Copy => NamedKey::Copy,
-        keysyms::_3270_Play => NamedKey::Play,
-        // keysyms::3270_Setup => NamedKey::Setup,
-        // keysyms::3270_Record => NamedKey::Record,
-        // keysyms::3270_ChangeScreen => NamedKey::ChangeScreen,
-        // keysyms::3270_DeleteWord => NamedKey::DeleteWord,
-        keysyms::_3270_ExSelect => NamedKey::ExSel,
-        keysyms::_3270_CursorSelect => NamedKey::CrSel,
-        keysyms::_3270_PrintScreen => NamedKey::PrintScreen,
-        keysyms::_3270_Enter => NamedKey::Enter,
+        // keysyms::3270_Duplicate => Key::Duplicate,
+        // keysyms::3270_FieldMark => Key::FieldMark,
+        // keysyms::3270_Right2 => Key::Right2,
+        // keysyms::3270_Left2 => Key::Left2,
+        // keysyms::3270_BackTab => Key::BackTab,
+        keysyms::_3270_EraseEOF => Key::EraseEof,
+        // keysyms::3270_EraseInput => Key::EraseInput,
+        // keysyms::3270_Reset => Key::Reset,
+        // keysyms::3270_Quit => Key::Quit,
+        // keysyms::3270_PA1 => Key::Pa1,
+        // keysyms::3270_PA2 => Key::Pa2,
+        // keysyms::3270_PA3 => Key::Pa3,
+        // keysyms::3270_Test => Key::Test,
+        keysyms::_3270_Attn => Key::Attn,
+        // keysyms::3270_CursorBlink => Key::CursorBlink,
+        // keysyms::3270_AltCursor => Key::AltCursor,
+        // keysyms::3270_KeyClick => Key::KeyClick,
+        // keysyms::3270_Jump => Key::Jump,
+        // keysyms::3270_Ident => Key::Ident,
+        // keysyms::3270_Rule => Key::Rule,
+        // keysyms::3270_Copy => Key::Copy,
+        keysyms::_3270_Play => Key::Play,
+        // keysyms::3270_Setup => Key::Setup,
+        // keysyms::3270_Record => Key::Record,
+        // keysyms::3270_ChangeScreen => Key::ChangeScreen,
+        // keysyms::3270_DeleteWord => Key::DeleteWord,
+        keysyms::_3270_ExSelect => Key::ExSel,
+        keysyms::_3270_CursorSelect => Key::CrSel,
+        keysyms::_3270_PrintScreen => Key::PrintScreen,
+        keysyms::_3270_Enter => Key::Enter,
 
-        keysyms::space => NamedKey::Space,
+        keysyms::space => Key::Space,
         // exclam..Sinh_kunddaliya
 
         // XFree86
-        // keysyms::XF86_ModeLock => NamedKey::ModeLock,
+        // keysyms::XF86_ModeLock => Key::ModeLock,
 
         // XFree86 - Backlight controls
-        keysyms::XF86_MonBrightnessUp => NamedKey::BrightnessUp,
-        keysyms::XF86_MonBrightnessDown => NamedKey::BrightnessDown,
-        // keysyms::XF86_KbdLightOnOff => NamedKey::LightOnOff,
-        // keysyms::XF86_KbdBrightnessUp => NamedKey::KeyboardBrightnessUp,
-        // keysyms::XF86_KbdBrightnessDown => NamedKey::KeyboardBrightnessDown,
+        keysyms::XF86_MonBrightnessUp => Key::BrightnessUp,
+        keysyms::XF86_MonBrightnessDown => Key::BrightnessDown,
+        // keysyms::XF86_KbdLightOnOff => Key::LightOnOff,
+        // keysyms::XF86_KbdBrightnessUp => Key::KeyboardBrightnessUp,
+        // keysyms::XF86_KbdBrightnessDown => Key::KeyboardBrightnessDown,
 
         // XFree86 - "Internet"
-        keysyms::XF86_Standby => NamedKey::Standby,
-        keysyms::XF86_AudioLowerVolume => NamedKey::AudioVolumeDown,
-        keysyms::XF86_AudioRaiseVolume => NamedKey::AudioVolumeUp,
-        keysyms::XF86_AudioPlay => NamedKey::MediaPlay,
-        keysyms::XF86_AudioStop => NamedKey::MediaStop,
-        keysyms::XF86_AudioPrev => NamedKey::MediaTrackPrevious,
-        keysyms::XF86_AudioNext => NamedKey::MediaTrackNext,
-        keysyms::XF86_HomePage => NamedKey::BrowserHome,
-        keysyms::XF86_Mail => NamedKey::LaunchMail,
-        // keysyms::XF86_Start => NamedKey::Start,
-        keysyms::XF86_Search => NamedKey::BrowserSearch,
-        keysyms::XF86_AudioRecord => NamedKey::MediaRecord,
+        keysyms::XF86_Standby => Key::Standby,
+        keysyms::XF86_AudioLowerVolume => Key::AudioVolumeDown,
+        keysyms::XF86_AudioRaiseVolume => Key::AudioVolumeUp,
+        keysyms::XF86_AudioPlay => Key::MediaPlay,
+        keysyms::XF86_AudioStop => Key::MediaStop,
+        keysyms::XF86_AudioPrev => Key::MediaTrackPrevious,
+        keysyms::XF86_AudioNext => Key::MediaTrackNext,
+        keysyms::XF86_HomePage => Key::BrowserHome,
+        keysyms::XF86_Mail => Key::LaunchMail,
+        // keysyms::XF86_Start => Key::Start,
+        keysyms::XF86_Search => Key::BrowserSearch,
+        keysyms::XF86_AudioRecord => Key::MediaRecord,
 
         // XFree86 - PDA
-        keysyms::XF86_Calculator => NamedKey::LaunchApplication2,
-        // keysyms::XF86_Memo => NamedKey::Memo,
-        // keysyms::XF86_ToDoList => NamedKey::ToDoList,
-        keysyms::XF86_Calendar => NamedKey::LaunchCalendar,
-        keysyms::XF86_PowerDown => NamedKey::Power,
-        // keysyms::XF86_ContrastAdjust => NamedKey::AdjustContrast,
-        // keysyms::XF86_RockerUp => NamedKey::RockerUp,
-        // keysyms::XF86_RockerDown => NamedKey::RockerDown,
-        // keysyms::XF86_RockerEnter => NamedKey::RockerEnter,
+        keysyms::XF86_Calculator => Key::LaunchApplication2,
+        // keysyms::XF86_Memo => Key::Memo,
+        // keysyms::XF86_ToDoList => Key::ToDoList,
+        keysyms::XF86_Calendar => Key::LaunchCalendar,
+        keysyms::XF86_PowerDown => Key::Power,
+        // keysyms::XF86_ContrastAdjust => Key::AdjustContrast,
+        // keysyms::XF86_RockerUp => Key::RockerUp,
+        // keysyms::XF86_RockerDown => Key::RockerDown,
+        // keysyms::XF86_RockerEnter => Key::RockerEnter,
 
         // XFree86 - More "Internet"
-        keysyms::XF86_Back => NamedKey::BrowserBack,
-        keysyms::XF86_Forward => NamedKey::BrowserForward,
-        // keysyms::XF86_Stop => NamedKey::Stop,
-        keysyms::XF86_Refresh => NamedKey::BrowserRefresh,
-        keysyms::XF86_PowerOff => NamedKey::Power,
-        keysyms::XF86_WakeUp => NamedKey::WakeUp,
-        keysyms::XF86_Eject => NamedKey::Eject,
-        keysyms::XF86_ScreenSaver => NamedKey::LaunchScreenSaver,
-        keysyms::XF86_WWW => NamedKey::LaunchWebBrowser,
-        keysyms::XF86_Sleep => NamedKey::Standby,
-        keysyms::XF86_Favorites => NamedKey::BrowserFavorites,
-        keysyms::XF86_AudioPause => NamedKey::MediaPause,
-        // keysyms::XF86_AudioMedia => NamedKey::AudioMedia,
-        keysyms::XF86_MyComputer => NamedKey::LaunchApplication1,
-        // keysyms::XF86_VendorHome => NamedKey::VendorHome,
-        // keysyms::XF86_LightBulb => NamedKey::LightBulb,
-        // keysyms::XF86_Shop => NamedKey::BrowserShop,
-        // keysyms::XF86_History => NamedKey::BrowserHistory,
-        // keysyms::XF86_OpenURL => NamedKey::OpenUrl,
-        // keysyms::XF86_AddFavorite => NamedKey::AddFavorite,
-        // keysyms::XF86_HotLinks => NamedKey::HotLinks,
-        // keysyms::XF86_BrightnessAdjust => NamedKey::BrightnessAdjust,
-        // keysyms::XF86_Finance => NamedKey::BrowserFinance,
-        // keysyms::XF86_Community => NamedKey::BrowserCommunity,
-        keysyms::XF86_AudioRewind => NamedKey::MediaRewind,
+        keysyms::XF86_Back => Key::BrowserBack,
+        keysyms::XF86_Forward => Key::BrowserForward,
+        // keysyms::XF86_Stop => Key::Stop,
+        keysyms::XF86_Refresh => Key::BrowserRefresh,
+        keysyms::XF86_PowerOff => Key::Power,
+        keysyms::XF86_WakeUp => Key::WakeUp,
+        keysyms::XF86_Eject => Key::Eject,
+        keysyms::XF86_ScreenSaver => Key::LaunchScreenSaver,
+        keysyms::XF86_WWW => Key::LaunchWebBrowser,
+        keysyms::XF86_Sleep => Key::Standby,
+        keysyms::XF86_Favorites => Key::BrowserFavorites,
+        keysyms::XF86_AudioPause => Key::MediaPause,
+        // keysyms::XF86_AudioMedia => Key::AudioMedia,
+        keysyms::XF86_MyComputer => Key::LaunchApplication1,
+        // keysyms::XF86_VendorHome => Key::VendorHome,
+        // keysyms::XF86_LightBulb => Key::LightBulb,
+        // keysyms::XF86_Shop => Key::BrowserShop,
+        // keysyms::XF86_History => Key::BrowserHistory,
+        // keysyms::XF86_OpenURL => Key::OpenUrl,
+        // keysyms::XF86_AddFavorite => Key::AddFavorite,
+        // keysyms::XF86_HotLinks => Key::HotLinks,
+        // keysyms::XF86_BrightnessAdjust => Key::BrightnessAdjust,
+        // keysyms::XF86_Finance => Key::BrowserFinance,
+        // keysyms::XF86_Community => Key::BrowserCommunity,
+        keysyms::XF86_AudioRewind => Key::MediaRewind,
         // keysyms::XF86_BackForward => Key::???,
         // XF86_Launch0..XF86_LaunchF
 
         // XF86_ApplicationLeft..XF86_CD
-        keysyms::XF86_Calculater => NamedKey::LaunchApplication2, // Nice typo, libxkbcommon :)
+        keysyms::XF86_Calculater => Key::LaunchApplication2, // Nice typo, libxkbcommon :)
         // XF86_Clear
-        keysyms::XF86_Close => NamedKey::Close,
-        keysyms::XF86_Copy => NamedKey::Copy,
-        keysyms::XF86_Cut => NamedKey::Cut,
+        keysyms::XF86_Close => Key::Close,
+        keysyms::XF86_Copy => Key::Copy,
+        keysyms::XF86_Cut => Key::Cut,
         // XF86_Display..XF86_Documents
-        keysyms::XF86_Excel => NamedKey::LaunchSpreadsheet,
+        keysyms::XF86_Excel => Key::LaunchSpreadsheet,
         // XF86_Explorer..XF86iTouch
-        keysyms::XF86_LogOff => NamedKey::LogOff,
+        keysyms::XF86_LogOff => Key::LogOff,
         // XF86_Market..XF86_MenuPB
-        keysyms::XF86_MySites => NamedKey::BrowserFavorites,
-        keysyms::XF86_New => NamedKey::New,
+        keysyms::XF86_MySites => Key::BrowserFavorites,
+        keysyms::XF86_New => Key::New,
         // XF86_News..XF86_OfficeHome
-        keysyms::XF86_Open => NamedKey::Open,
+        keysyms::XF86_Open => Key::Open,
         // XF86_Option
-        keysyms::XF86_Paste => NamedKey::Paste,
-        keysyms::XF86_Phone => NamedKey::LaunchPhone,
+        keysyms::XF86_Paste => Key::Paste,
+        keysyms::XF86_Phone => Key::LaunchPhone,
         // XF86_Q
-        keysyms::XF86_Reply => NamedKey::MailReply,
-        keysyms::XF86_Reload => NamedKey::BrowserRefresh,
+        keysyms::XF86_Reply => Key::MailReply,
+        keysyms::XF86_Reload => Key::BrowserRefresh,
         // XF86_RotateWindows..XF86_RotationKB
-        keysyms::XF86_Save => NamedKey::Save,
+        keysyms::XF86_Save => Key::Save,
         // XF86_ScrollUp..XF86_ScrollClick
-        keysyms::XF86_Send => NamedKey::MailSend,
-        keysyms::XF86_Spell => NamedKey::SpellCheck,
-        keysyms::XF86_SplitScreen => NamedKey::SplitScreenToggle,
+        keysyms::XF86_Send => Key::MailSend,
+        keysyms::XF86_Spell => Key::SpellCheck,
+        keysyms::XF86_SplitScreen => Key::SplitScreenToggle,
         // XF86_Support..XF86_User2KB
-        keysyms::XF86_Video => NamedKey::LaunchMediaPlayer,
+        keysyms::XF86_Video => Key::LaunchMediaPlayer,
         // XF86_WheelButton
-        keysyms::XF86_Word => NamedKey::LaunchWordProcessor,
+        keysyms::XF86_Word => Key::LaunchWordProcessor,
         // XF86_Xfer
-        keysyms::XF86_ZoomIn => NamedKey::ZoomIn,
-        keysyms::XF86_ZoomOut => NamedKey::ZoomOut,
+        keysyms::XF86_ZoomIn => Key::ZoomIn,
+        keysyms::XF86_ZoomOut => Key::ZoomOut,
 
         // XF86_Away..XF86_Messenger
-        keysyms::XF86_WebCam => NamedKey::LaunchWebCam,
-        keysyms::XF86_MailForward => NamedKey::MailForward,
+        keysyms::XF86_WebCam => Key::LaunchWebCam,
+        keysyms::XF86_MailForward => Key::MailForward,
         // XF86_Pictures
-        keysyms::XF86_Music => NamedKey::LaunchMusicPlayer,
+        keysyms::XF86_Music => Key::LaunchMusicPlayer,
 
         // XF86_Battery..XF86_UWB
         //
-        keysyms::XF86_AudioForward => NamedKey::MediaFastForward,
+        keysyms::XF86_AudioForward => Key::MediaFastForward,
         // XF86_AudioRepeat
-        keysyms::XF86_AudioRandomPlay => NamedKey::RandomToggle,
-        keysyms::XF86_Subtitle => NamedKey::Subtitle,
-        keysyms::XF86_AudioCycleTrack => NamedKey::MediaAudioTrack,
+        keysyms::XF86_AudioRandomPlay => Key::RandomToggle,
+        keysyms::XF86_Subtitle => Key::Subtitle,
+        keysyms::XF86_AudioCycleTrack => Key::MediaAudioTrack,
         // XF86_CycleAngle..XF86_Blue
         //
-        keysyms::XF86_Suspend => NamedKey::Standby,
-        keysyms::XF86_Hibernate => NamedKey::Hibernate,
+        keysyms::XF86_Suspend => Key::Standby,
+        keysyms::XF86_Hibernate => Key::Hibernate,
         // XF86_TouchpadToggle..XF86_TouchpadOff
         //
-        keysyms::XF86_AudioMute => NamedKey::AudioVolumeMute,
+        keysyms::XF86_AudioMute => Key::AudioVolumeMute,
 
         // XF86_Switch_VT_1..XF86_Switch_VT_12
 
         // XF86_Ungrab..XF86_ClearGrab
-        keysyms::XF86_Next_VMode => NamedKey::VideoModeNext,
-        // keysyms::XF86_Prev_VMode => NamedKey::VideoModePrevious,
+        keysyms::XF86_Next_VMode => Key::VideoModeNext,
+        // keysyms::XF86_Prev_VMode => Key::VideoModePrevious,
         // XF86_LogWindowTree..XF86_LogGrabInfo
 
         // SunFA_Grave..SunFA_Cedilla
 
-        // keysyms::SunF36 => NamedKey::F36 | NamedKey::F11,
-        // keysyms::SunF37 => NamedKey::F37 | NamedKey::F12,
+        // keysyms::SunF36 => Key::F36 | Key::F11,
+        // keysyms::SunF37 => Key::F37 | Key::F12,
 
-        // keysyms::SunSys_Req => NamedKey::PrintScreen,
+        // keysyms::SunSys_Req => Key::PrintScreen,
         // The next couple of xkb (until SunStop) are already handled.
         // SunPrint_Screen..SunPageDown
 
         // SunUndo..SunFront
-        keysyms::SUN_Copy => NamedKey::Copy,
-        keysyms::SUN_Open => NamedKey::Open,
-        keysyms::SUN_Paste => NamedKey::Paste,
-        keysyms::SUN_Cut => NamedKey::Cut,
+        keysyms::SUN_Copy => Key::Copy,
+        keysyms::SUN_Open => Key::Open,
+        keysyms::SUN_Paste => Key::Paste,
+        keysyms::SUN_Cut => Key::Cut,
 
         // SunPowerSwitch
-        keysyms::SUN_AudioLowerVolume => NamedKey::AudioVolumeDown,
-        keysyms::SUN_AudioMute => NamedKey::AudioVolumeMute,
-        keysyms::SUN_AudioRaiseVolume => NamedKey::AudioVolumeUp,
+        keysyms::SUN_AudioLowerVolume => Key::AudioVolumeDown,
+        keysyms::SUN_AudioMute => Key::AudioVolumeMute,
+        keysyms::SUN_AudioRaiseVolume => Key::AudioVolumeUp,
         // SUN_VideoDegauss
-        keysyms::SUN_VideoLowerBrightness => NamedKey::BrightnessDown,
-        keysyms::SUN_VideoRaiseBrightness => NamedKey::BrightnessUp,
+        keysyms::SUN_VideoLowerBrightness => Key::BrightnessDown,
+        keysyms::SUN_VideoRaiseBrightness => Key::BrightnessUp,
         // SunPowerSwitchShift
         //
-        0 => return Key::Unidentified(NativeKey::Unidentified),
-        _ => return Key::Unidentified(NativeKey::Xkb(keysym)),
-    })
+        0 => Key::Unidentified(NativeKey::Unidentified),
+        _ => Key::Unidentified(NativeKey::Xkb(keysym)),
+    }
 }
 
 pub fn keysym_location(keysym: u32) -> KeyLocation {

src/platform_impl/linux/common/xkb_state.rs

@@ -22,7 +22,7 @@ use crate::platform_impl::common::keymap;
 use crate::platform_impl::KeyEventExtra;
 use crate::{
     event::ElementState,
-    keyboard::{Key, KeyLocation, PhysicalKey},
+    keyboard::{Key, KeyCode, KeyLocation},
 };
 
 // TODO: Wire this up without using a static `AtomicBool`.
@@ -391,15 +391,15 @@ impl KbdState {
     ) -> KeyEvent {
         let mut event =
             KeyEventResults::new(self, keycode, !repeat && state == ElementState::Pressed);
-        let physical_key = event.physical_key();
+        let physical_key = event.keycode();
         let (logical_key, location) = event.key();
         let text = event.text();
         let (key_without_modifiers, _) = event.key_without_modifiers();
         let text_with_all_modifiers = event.text_with_all_modifiers();
 
         let platform_specific = KeyEventExtra {
-            text_with_all_modifiers,
             key_without_modifiers,
+            text_with_all_modifiers,
         };
 
         KeyEvent {
@@ -498,8 +498,8 @@ impl<'a> KeyEventResults<'a> {
         }
     }
 
-    fn physical_key(&self) -> PhysicalKey {
-        keymap::raw_keycode_to_physicalkey(self.keycode)
+    fn keycode(&mut self) -> KeyCode {
+        keymap::raw_keycode_to_keycode(self.keycode)
     }
 
     pub fn key(&mut self) -> (Key, KeyLocation) {
@@ -553,7 +553,6 @@ impl<'a> KeyEventResults<'a> {
         } else {
             0
         };
-
         self.keysym_to_key(keysym)
             .unwrap_or_else(|(key, location)| {
                 (
@@ -566,7 +565,7 @@ impl<'a> KeyEventResults<'a> {
             })
     }
 
-    fn keysym_to_key(&self, keysym: u32) -> Result<(Key, KeyLocation), (Key, KeyLocation)> {
+    fn keysym_to_key(&mut self, keysym: u32) -> Result<(Key, KeyLocation), (Key, KeyLocation)> {
         let location = super::keymap::keysym_location(keysym);
         let key = super::keymap::keysym_to_key(keysym);
         if matches!(key, Key::Unidentified(_)) {
@@ -683,7 +682,7 @@ fn byte_slice_to_smol_str(bytes: &[u8]) -> Option<SmolStr> {
     std::str::from_utf8(bytes)
         .map(SmolStr::new)
         .map_err(|e| {
-            log::warn!(
+            warn!(
                 "UTF-8 received from libxkbcommon ({:?}) was invalid: {e}",
                 bytes
             )

src/platform_impl/linux/mod.rs

@@ -3,7 +3,6 @@
 #[cfg(all(not(x11_platform), not(wayland_platform)))]
 compile_error!("Please select a feature to build for unix: `x11`, `wayland`");
 
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::Arc;
 use std::time::Duration;
 use std::{collections::VecDeque, env, fmt};
@@ -15,35 +14,39 @@ use once_cell::sync::Lazy;
 use smol_str::SmolStr;
 
 #[cfg(x11_platform)]
-use self::x11::{X11Error, XConnection, XError, XNotSupported};
-#[cfg(x11_platform)]
-use crate::platform::x11::{WindowType as XWindowType, XlibErrorHook};
+use crate::platform::x11::XlibErrorHook;
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize, Position, Size},
     error::{EventLoopError, ExternalError, NotSupportedError, OsError as RootOsError},
+    event::KeyEvent,
     event_loop::{
         AsyncRequestSerial, ControlFlow, DeviceEvents, EventLoopClosed,
         EventLoopWindowTarget as RootELW,
     },
     icon::Icon,
-    keyboard::Key,
-    platform::pump_events::PumpStatus,
+    keyboard::{Key, KeyCode},
+    platform::{
+        modifier_supplement::KeyEventExtModifierSupplement, pump_events::PumpStatus,
+        scancode::KeyCodeExtScancode,
+    },
     window::{
-        ActivationToken, Cursor, CursorGrabMode, ImePurpose, ResizeDirection, Theme,
+        ActivationToken, CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme,
         UserAttentionType, WindowAttributes, WindowButtons, WindowLevel,
     },
 };
+#[cfg(x11_platform)]
+pub use x11::XNotSupported;
+#[cfg(x11_platform)]
+use x11::{util::WindowType as XWindowType, X11Error, XConnection, XError};
 
-pub(crate) use self::common::keymap::{physicalkey_to_scancode, scancode_to_physicalkey};
-pub(crate) use crate::cursor::OnlyCursorImageBuilder as PlatformCustomCursorBuilder;
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
 
-pub(crate) mod common;
+pub mod common;
 #[cfg(wayland_platform)]
-pub(crate) mod wayland;
+pub mod wayland;
 #[cfg(x11_platform)]
-pub(crate) mod x11;
+pub mod x11;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) enum Backend {
@@ -71,7 +74,7 @@ impl ApplicationName {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct PlatformSpecificWindowBuilderAttributes {
     pub name: Option<ApplicationName>,
     pub activation_token: Option<ActivationToken>,
@@ -79,7 +82,7 @@ pub struct PlatformSpecificWindowBuilderAttributes {
     pub x11: X11WindowBuilderAttributes,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 #[cfg(x11_platform)]
 pub struct X11WindowBuilderAttributes {
     pub visual_id: Option<x11rb::protocol::xproto::Visualid>,
@@ -248,55 +251,56 @@ impl MonitorHandle {
     }
 
     #[inline]
-    pub fn video_modes(&self) -> Box<dyn Iterator<Item = VideoModeHandle>> {
+    pub fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
         x11_or_wayland!(match self; MonitorHandle(m) => Box::new(m.video_modes()))
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum VideoModeHandle {
+pub enum VideoMode {
     #[cfg(x11_platform)]
-    X(x11::VideoModeHandle),
+    X(x11::VideoMode),
     #[cfg(wayland_platform)]
-    Wayland(wayland::VideoModeHandle),
+    Wayland(wayland::VideoMode),
 }
 
-impl VideoModeHandle {
+impl VideoMode {
     #[inline]
     pub fn size(&self) -> PhysicalSize<u32> {
-        x11_or_wayland!(match self; VideoModeHandle(m) => m.size())
+        x11_or_wayland!(match self; VideoMode(m) => m.size())
     }
 
     #[inline]
     pub fn bit_depth(&self) -> u16 {
-        x11_or_wayland!(match self; VideoModeHandle(m) => m.bit_depth())
+        x11_or_wayland!(match self; VideoMode(m) => m.bit_depth())
     }
 
     #[inline]
     pub fn refresh_rate_millihertz(&self) -> u32 {
-        x11_or_wayland!(match self; VideoModeHandle(m) => m.refresh_rate_millihertz())
+        x11_or_wayland!(match self; VideoMode(m) => m.refresh_rate_millihertz())
     }
 
     #[inline]
     pub fn monitor(&self) -> MonitorHandle {
-        x11_or_wayland!(match self; VideoModeHandle(m) => m.monitor(); as MonitorHandle)
+        x11_or_wayland!(match self; VideoMode(m) => m.monitor(); as MonitorHandle)
     }
 }
 
 impl Window {
     #[inline]
-    pub(crate) fn new(
-        window_target: &EventLoopWindowTarget,
+    pub(crate) fn new<T>(
+        window_target: &EventLoopWindowTarget<T>,
         attribs: WindowAttributes,
+        pl_attribs: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Self, RootOsError> {
         match *window_target {
             #[cfg(wayland_platform)]
             EventLoopWindowTarget::Wayland(ref window_target) => {
-                wayland::Window::new(window_target, attribs).map(Window::Wayland)
+                wayland::Window::new(window_target, attribs, pl_attribs).map(Window::Wayland)
             }
             #[cfg(x11_platform)]
             EventLoopWindowTarget::X(ref window_target) => {
-                x11::Window::new(window_target, attribs).map(Window::X)
+                x11::Window::new(window_target, attribs, pl_attribs).map(Window::X)
             }
         }
     }
@@ -415,8 +419,8 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_cursor(&self, cursor: Cursor) {
-        x11_or_wayland!(match self; Window(w) => w.set_cursor(cursor))
+    pub fn set_cursor_icon(&self, cursor: CursorIcon) {
+        x11_or_wayland!(match self; Window(w) => w.set_cursor_icon(cursor))
     }
 
     #[inline]
@@ -633,30 +637,32 @@ impl Window {
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct KeyEventExtra {
-    pub text_with_all_modifiers: Option<SmolStr>,
     pub key_without_modifiers: Key,
+    pub text_with_all_modifiers: Option<SmolStr>,
 }
 
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub(crate) enum PlatformCustomCursor {
-    #[cfg(wayland_platform)]
-    Wayland(wayland::CustomCursor),
-    #[cfg(x11_platform)]
-    X(x11::CustomCursor),
+impl KeyEventExtModifierSupplement for KeyEvent {
+    #[inline]
+    fn text_with_all_modifiers(&self) -> Option<&str> {
+        self.platform_specific
+            .text_with_all_modifiers
+            .as_ref()
+            .map(|s| s.as_str())
+    }
+
+    #[inline]
+    fn key_without_modifiers(&self) -> Key {
+        self.platform_specific.key_without_modifiers.clone()
+    }
 }
-impl PlatformCustomCursor {
-    pub(crate) fn build(
-        builder: PlatformCustomCursorBuilder,
-        p: &EventLoopWindowTarget,
-    ) -> PlatformCustomCursor {
-        match p {
-            #[cfg(wayland_platform)]
-            EventLoopWindowTarget::Wayland(_) => {
-                Self::Wayland(wayland::CustomCursor::build(builder, p))
-            }
-            #[cfg(x11_platform)]
-            EventLoopWindowTarget::X(p) => Self::X(x11::CustomCursor::build(builder, p)),
-        }
+
+impl KeyCodeExtScancode for KeyCode {
+    fn from_scancode(scancode: u32) -> KeyCode {
+        common::keymap::scancode_to_keycode(scancode)
+    }
+
+    fn to_scancode(self) -> Option<u32> {
+        common::keymap::keycode_to_scancode(self)
     }
 }
 
@@ -703,7 +709,7 @@ unsafe extern "C" fn x_error_callback(
 
         // Don't log error.
         if !error_handled {
-            log::error!("X11 error: {:#?}", error);
+            error!("X11 error: {:#?}", error);
             // XXX only update the error, if it wasn't handled by any of the hooks.
             *xconn.latest_error.lock().unwrap() = Some(error);
         }
@@ -745,19 +751,11 @@ impl<T: 'static> EventLoop<T> {
             );
         }
 
-        // NOTE: Wayland first because of X11 could be present under Wayland as well. Empty
-        // variables are also treated as not set.
+        // NOTE: Wayland first because of X11 could be present under wayland as well.
         let backend = match (
             attributes.forced_backend,
-            env::var("WAYLAND_DISPLAY")
-                .ok()
-                .filter(|var| !var.is_empty())
-                .or_else(|| env::var("WAYLAND_SOCKET").ok())
-                .filter(|var| !var.is_empty())
-                .is_some(),
-            env::var("DISPLAY")
-                .map(|var| !var.is_empty())
-                .unwrap_or(false),
+            env::var("WAYLAND_DISPLAY").is_ok(),
+            env::var("DISPLAY").is_ok(),
         ) {
             // User is forcing a backend.
             (Some(backend), _, _) => backend,
@@ -768,15 +766,10 @@ impl<T: 'static> EventLoop<T> {
             #[cfg(x11_platform)]
             (None, _, true) => Backend::X,
             // No backend is present.
-            (_, wayland_display, x11_display) => {
-                let msg = if wayland_display && !cfg!(wayland_platform) {
-                    "DISPLAY is not set; note: enable the `winit/wayland` feature to support Wayland"
-                } else if x11_display && !cfg!(x11_platform) {
-                    "neither WAYLAND_DISPLAY nor WAYLAND_SOCKET is set; note: enable the `winit/x11` feature to support X11"
-                } else {
-                    "neither WAYLAND_DISPLAY nor WAYLAND_SOCKET nor DISPLAY is set."
-                };
-                return Err(EventLoopError::Os(os_error!(OsError::Misc(msg))));
+            _ => {
+                return Err(EventLoopError::Os(os_error!(OsError::Misc(
+                    "neither WAYLAND_DISPLAY nor DISPLAY is set."
+                ))));
             }
         };
 
@@ -785,7 +778,7 @@ impl<T: 'static> EventLoop<T> {
             #[cfg(wayland_platform)]
             Backend::Wayland => EventLoop::new_wayland_any_thread().map_err(Into::into),
             #[cfg(x11_platform)]
-            Backend::X => EventLoop::new_x11_any_thread().map_err(Into::into),
+            Backend::X => Ok(EventLoop::new_x11_any_thread().unwrap()),
         }
     }
 
@@ -795,10 +788,10 @@ impl<T: 'static> EventLoop<T> {
     }
 
     #[cfg(x11_platform)]
-    fn new_x11_any_thread() -> Result<EventLoop<T>, EventLoopError> {
+    fn new_x11_any_thread() -> Result<EventLoop<T>, XNotSupported> {
         let xconn = match X11_BACKEND.lock().unwrap().as_ref() {
             Ok(xconn) => xconn.clone(),
-            Err(_) => return Err(EventLoopError::NotSupported(NotSupportedError::new())),
+            Err(err) => return Err(err.clone()),
         };
 
         Ok(EventLoop::X(x11::EventLoop::new(xconn)))
@@ -810,56 +803,44 @@ impl<T: 'static> EventLoop<T> {
 
     pub fn run<F>(mut self, callback: F) -> Result<(), EventLoopError>
     where
-        F: FnMut(crate::event::Event<T>, &RootELW),
+        F: FnMut(crate::event::Event<T>, &RootELW<T>),
     {
         self.run_on_demand(callback)
     }
 
     pub fn run_on_demand<F>(&mut self, callback: F) -> Result<(), EventLoopError>
     where
-        F: FnMut(crate::event::Event<T>, &RootELW),
+        F: FnMut(crate::event::Event<T>, &RootELW<T>),
     {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_on_demand(callback))
     }
 
     pub fn pump_events<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus
     where
-        F: FnMut(crate::event::Event<T>, &RootELW),
+        F: FnMut(crate::event::Event<T>, &RootELW<T>),
     {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_events(timeout, callback))
     }
 
-    pub fn window_target(&self) -> &crate::event_loop::EventLoopWindowTarget {
+    pub fn window_target(&self) -> &crate::event_loop::EventLoopWindowTarget<T> {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.window_target())
     }
 }
 
-impl<T> AsFd for EventLoop<T> {
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_fd())
-    }
-}
-
-impl<T> AsRawFd for EventLoop<T> {
-    fn as_raw_fd(&self) -> RawFd {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_raw_fd())
-    }
-}
-
 impl<T: 'static> EventLoopProxy<T> {
     pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
         x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.send_event(event))
     }
 }
 
-pub enum EventLoopWindowTarget {
+pub enum EventLoopWindowTarget<T> {
     #[cfg(wayland_platform)]
-    Wayland(wayland::EventLoopWindowTarget),
+    Wayland(wayland::EventLoopWindowTarget<T>),
     #[cfg(x11_platform)]
-    X(x11::EventLoopWindowTarget),
+    X(x11::EventLoopWindowTarget<T>),
 }
 
-impl EventLoopWindowTarget {
+impl<T> EventLoopWindowTarget<T> {
     #[inline]
     pub fn is_wayland(&self) -> bool {
         match *self {
@@ -919,10 +900,6 @@ impl EventLoopWindowTarget {
         x11_or_wayland!(match self; Self(evlp) => evlp.control_flow())
     }
 
-    pub(crate) fn clear_exit(&self) {
-        x11_or_wayland!(match self; Self(evlp) => evlp.clear_exit())
-    }
-
     pub(crate) fn exit(&self) {
         x11_or_wayland!(match self; Self(evlp) => evlp.exit())
     }
@@ -931,87 +908,15 @@ impl EventLoopWindowTarget {
         x11_or_wayland!(match self; Self(evlp) => evlp.exiting())
     }
 
-    pub(crate) fn owned_display_handle(&self) -> OwnedDisplayHandle {
-        match self {
-            #[cfg(x11_platform)]
-            Self::X(conn) => OwnedDisplayHandle::X(conn.x_connection().clone()),
-            #[cfg(wayland_platform)]
-            Self::Wayland(conn) => OwnedDisplayHandle::Wayland(conn.connection.clone()),
-        }
-    }
-
-    #[allow(dead_code)]
     fn set_exit_code(&self, code: i32) {
         x11_or_wayland!(match self; Self(evlp) => evlp.set_exit_code(code))
     }
 
-    #[allow(dead_code)]
     fn exit_code(&self) -> Option<i32> {
         x11_or_wayland!(match self; Self(evlp) => evlp.exit_code())
     }
 }
 
-#[derive(Clone)]
-#[allow(dead_code)]
-pub(crate) enum OwnedDisplayHandle {
-    #[cfg(x11_platform)]
-    X(Arc<XConnection>),
-    #[cfg(wayland_platform)]
-    Wayland(wayland_client::Connection),
-}
-
-impl OwnedDisplayHandle {
-    #[cfg(feature = "rwh_05")]
-    #[inline]
-    pub fn raw_display_handle_rwh_05(&self) -> rwh_05::RawDisplayHandle {
-        match self {
-            #[cfg(x11_platform)]
-            Self::X(xconn) => {
-                let mut xlib_handle = rwh_05::XlibDisplayHandle::empty();
-                xlib_handle.display = xconn.display.cast();
-                xlib_handle.screen = xconn.default_screen_index() as _;
-                xlib_handle.into()
-            }
-
-            #[cfg(wayland_platform)]
-            Self::Wayland(conn) => {
-                use sctk::reexports::client::Proxy;
-
-                let mut wayland_handle = rwh_05::WaylandDisplayHandle::empty();
-                wayland_handle.display = conn.display().id().as_ptr() as *mut _;
-                wayland_handle.into()
-            }
-        }
-    }
-
-    #[cfg(feature = "rwh_06")]
-    #[inline]
-    pub fn raw_display_handle_rwh_06(
-        &self,
-    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        use std::ptr::NonNull;
-
-        match self {
-            #[cfg(x11_platform)]
-            Self::X(xconn) => Ok(rwh_06::XlibDisplayHandle::new(
-                NonNull::new(xconn.display.cast()),
-                xconn.default_screen_index() as _,
-            )
-            .into()),
-
-            #[cfg(wayland_platform)]
-            Self::Wayland(conn) => {
-                use sctk::reexports::client::Proxy;
-
-                Ok(rwh_06::WaylandDisplayHandle::new(
-                    NonNull::new(conn.display().id().as_ptr().cast()).unwrap(),
-                )
-                .into())
-            }
-        }
-    }
-}
-
 /// Returns the minimum `Option<Duration>`, taking into account that `None`
 /// equates to an infinite timeout, not a zero timeout (so can't just use
 /// `Option::min`)

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

@@ -4,7 +4,6 @@ use std::cell::{Cell, RefCell};
 use std::io::Result as IOResult;
 use std::marker::PhantomData;
 use std::mem;
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::rc::Rc;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
@@ -16,7 +15,7 @@ use sctk::reexports::calloop_wayland_source::WaylandSource;
 use sctk::reexports::client::globals;
 use sctk::reexports::client::{Connection, QueueHandle};
 
-use crate::dpi::LogicalSize;
+use crate::dpi::{LogicalSize, PhysicalSize};
 use crate::error::{EventLoopError, OsError as RootOsError};
 use crate::event::{Event, InnerSizeWriter, StartCause, WindowEvent};
 use crate::event_loop::{
@@ -34,7 +33,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::{DeviceId, WaylandError, WindowId};
 
 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;
 
@@ -63,7 +62,7 @@ pub struct EventLoop<T: 'static> {
     connection: Connection,
 
     /// Event loop window target.
-    window_target: RootEventLoopWindowTarget,
+    window_target: RootEventLoopWindowTarget<T>,
 
     // XXX drop after everything else, just to be safe.
     /// Calloop's event loop.
@@ -167,6 +166,7 @@ impl<T: 'static> EventLoop<T> {
             control_flow: Cell::new(ControlFlow::default()),
             exit: Cell::new(None),
             state: RefCell::new(winit_state),
+            _marker: PhantomData,
         };
 
         let event_loop = Self {
@@ -190,8 +190,12 @@ impl<T: 'static> EventLoop<T> {
 
     pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
     where
-        F: FnMut(Event<T>, &RootEventLoopWindowTarget),
+        F: FnMut(Event<T>, &RootEventLoopWindowTarget<T>),
     {
+        if self.loop_running {
+            return Err(EventLoopError::AlreadyRunning);
+        }
+
         let exit = loop {
             match self.pump_events(None, &mut event_handler) {
                 PumpStatus::Exit(0) => {
@@ -217,7 +221,7 @@ impl<T: 'static> EventLoop<T> {
 
     pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
     where
-        F: FnMut(Event<T>, &RootEventLoopWindowTarget),
+        F: FnMut(Event<T>, &RootEventLoopWindowTarget<T>),
     {
         if !self.loop_running {
             self.loop_running = true;
@@ -244,7 +248,7 @@ impl<T: 'static> EventLoop<T> {
 
     pub fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
     where
-        F: FnMut(Event<T>, &RootEventLoopWindowTarget),
+        F: FnMut(Event<T>, &RootEventLoopWindowTarget<T>),
     {
         let cause = loop {
             let start = Instant::now();
@@ -320,7 +324,7 @@ impl<T: 'static> EventLoop<T> {
 
     fn single_iteration<F>(&mut self, callback: &mut F, cause: StartCause)
     where
-        F: FnMut(Event<T>, &RootEventLoopWindowTarget),
+        F: FnMut(Event<T>, &RootEventLoopWindowTarget<T>),
     {
         // NOTE currently just indented to simplify the diff
 
@@ -351,13 +355,15 @@ impl<T: 'static> EventLoop<T> {
 
         for mut compositor_update in compositor_updates.drain(..) {
             let window_id = compositor_update.window_id;
-            if compositor_update.scale_changed {
-                let (physical_size, scale_factor) = self.with_state(|state| {
+            if let Some(scale_factor) = compositor_update.scale_factor {
+                let physical_size = self.with_state(|state| {
                     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);
-                    (size, scale_factor)
+                    let mut window = windows.get(&window_id).unwrap().lock().unwrap();
+
+                    // Set the new scale factor.
+                    window.set_scale_factor(scale_factor);
+                    let window_size = compositor_update.size.unwrap_or(window.inner_size());
+                    logical_to_physical_rounded(window_size, scale_factor)
                 });
 
                 // Stash the old window size.
@@ -379,32 +385,30 @@ impl<T: 'static> EventLoop<T> {
 
                 let physical_size = *new_inner_size.lock().unwrap();
                 drop(new_inner_size);
+                let new_logical_size = physical_size.to_logical(scale_factor);
 
                 // Resize the window when user altered the size.
                 if old_physical_size != physical_size {
                     self.with_state(|state| {
                         let windows = state.windows.get_mut();
                         let mut window = windows.get(&window_id).unwrap().lock().unwrap();
-
-                        let new_logical_size: LogicalSize<f64> =
-                            physical_size.to_logical(scale_factor);
-                        window.request_inner_size(new_logical_size.into());
+                        window.resize(new_logical_size);
                     });
-
-                    // Make it queue resize.
-                    compositor_update.resized = true;
                 }
+
+                // Make it queue resize.
+                compositor_update.size = Some(new_logical_size);
             }
 
-            // NOTE: Rescale changed the physical size which winit operates in, thus we should
-            // resize.
-            if compositor_update.resized || compositor_update.scale_changed {
+            if let Some(size) = compositor_update.size.take() {
                 let physical_size = self.with_state(|state| {
                     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 physical_size = logical_to_physical_rounded(size, scale_factor);
+
+                    // TODO could probably bring back size reporting optimization.
 
                     // Mark the window as needed a redraw.
                     state
@@ -415,7 +419,7 @@ impl<T: 'static> EventLoop<T> {
                         .redraw_requested
                         .store(true, Ordering::Relaxed);
 
-                    size
+                    physical_size
                 });
 
                 callback(
@@ -461,45 +465,45 @@ impl<T: 'static> EventLoop<T> {
             window_ids.extend(state.window_requests.get_mut().keys());
         });
 
-        for window_id in window_ids.iter() {
-            let event = self.with_state(|state| {
+        for window_id in window_ids.drain(..) {
+            let request_redraw = self.with_state(|state| {
                 let window_requests = state.window_requests.get_mut();
-                if window_requests.get(window_id).unwrap().take_closed() {
-                    mem::drop(window_requests.remove(window_id));
-                    mem::drop(state.windows.get_mut().remove(window_id));
-                    return Some(WindowEvent::Destroyed);
+                if window_requests.get(&window_id).unwrap().take_closed() {
+                    mem::drop(window_requests.remove(&window_id));
+                    mem::drop(state.windows.get_mut().remove(&window_id));
+                    false
+                } else {
+                    let mut window = state
+                        .windows
+                        .get_mut()
+                        .get_mut(&window_id)
+                        .unwrap()
+                        .lock()
+                        .unwrap();
+
+                    if window.frame_callback_state() == FrameCallbackState::Requested {
+                        false
+                    } else {
+                        // Reset the frame callbacks state.
+                        window.frame_callback_reset();
+                        let mut redraw_requested = window_requests
+                            .get(&window_id)
+                            .unwrap()
+                            .take_redraw_requested();
+
+                        // Redraw the frame while at it.
+                        redraw_requested |= window.refresh_frame();
+
+                        redraw_requested
+                    }
                 }
-
-                let mut window = state
-                    .windows
-                    .get_mut()
-                    .get_mut(window_id)
-                    .unwrap()
-                    .lock()
-                    .unwrap();
-
-                if window.frame_callback_state() == FrameCallbackState::Requested {
-                    return None;
-                }
-
-                // Reset the frame callbacks state.
-                window.frame_callback_reset();
-                let mut redraw_requested = window_requests
-                    .get(window_id)
-                    .unwrap()
-                    .take_redraw_requested();
-
-                // Redraw the frame while at it.
-                redraw_requested |= window.refresh_frame();
-
-                redraw_requested.then_some(WindowEvent::RedrawRequested)
             });
 
-            if let Some(event) = event {
+            if request_redraw {
                 callback(
                     Event::WindowEvent {
-                        window_id: crate::window::WindowId(*window_id),
-                        event,
+                        window_id: crate::window::WindowId(window_id),
+                        event: WindowEvent::RedrawRequested,
                     },
                     &self.window_target,
                 );
@@ -514,42 +518,6 @@ impl<T: 'static> EventLoop<T> {
         // This is always the last event we dispatch before poll again
         callback(Event::AboutToWait, &self.window_target);
 
-        // Update the window frames and schedule redraws.
-        let mut wake_up = false;
-        for window_id in window_ids.drain(..) {
-            wake_up |= self.with_state(|state| match state.windows.get_mut().get_mut(&window_id) {
-                Some(window) => {
-                    let refresh = window.lock().unwrap().refresh_frame();
-                    if refresh {
-                        state
-                            .window_requests
-                            .get_mut()
-                            .get_mut(&window_id)
-                            .unwrap()
-                            .redraw_requested
-                            .store(true, Ordering::Relaxed);
-                    }
-
-                    refresh
-                }
-                None => false,
-            });
-        }
-
-        // Wakeup event loop if needed.
-        //
-        // If the user draws from the `AboutToWait` this is likely not required, however
-        // we can't do much about it.
-        if wake_up {
-            match &self.window_target.p {
-                PlatformEventLoopWindowTarget::Wayland(window_target) => {
-                    window_target.event_loop_awakener.ping();
-                }
-                #[cfg(x11_platform)]
-                PlatformEventLoopWindowTarget::X(_) => unreachable!(),
-            }
-        }
-
         std::mem::swap(&mut self.compositor_updates, &mut compositor_updates);
         std::mem::swap(&mut self.buffer_sink, &mut buffer_sink);
         std::mem::swap(&mut self.window_ids, &mut window_ids);
@@ -561,7 +529,7 @@ impl<T: 'static> EventLoop<T> {
     }
 
     #[inline]
-    pub fn window_target(&self) -> &RootEventLoopWindowTarget {
+    pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
         &self.window_target
     }
 
@@ -583,7 +551,7 @@ impl<T: 'static> EventLoop<T> {
         };
 
         self.event_loop.dispatch(timeout, state).map_err(|error| {
-            log::error!("Error dispatching event loop: {}", error);
+            error!("Error dispatching event loop: {}", error);
             error.into()
         })
     }
@@ -621,19 +589,7 @@ impl<T: 'static> EventLoop<T> {
     }
 }
 
-impl<T> AsFd for EventLoop<T> {
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        self.event_loop.as_fd()
-    }
-}
-
-impl<T> AsRawFd for EventLoop<T> {
-    fn as_raw_fd(&self) -> RawFd {
-        self.event_loop.as_raw_fd()
-    }
-}
-
-pub struct EventLoopWindowTarget {
+pub struct EventLoopWindowTarget<T> {
     /// The event loop wakeup source.
     pub event_loop_awakener: calloop::ping::Ping,
 
@@ -655,37 +611,11 @@ pub struct EventLoopWindowTarget {
 
     /// Connection to the wayland server.
     pub connection: Connection,
+
+    _marker: std::marker::PhantomData<T>,
 }
 
-impl EventLoopWindowTarget {
-    pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
-        self.control_flow.set(control_flow)
-    }
-
-    pub(crate) fn control_flow(&self) -> ControlFlow {
-        self.control_flow.get()
-    }
-
-    pub(crate) fn exit(&self) {
-        self.exit.set(Some(0))
-    }
-
-    pub(crate) fn clear_exit(&self) {
-        self.exit.set(None)
-    }
-
-    pub(crate) fn exiting(&self) -> bool {
-        self.exit.get().is_some()
-    }
-
-    pub(crate) fn set_exit_code(&self, code: i32) {
-        self.exit.set(Some(code))
-    }
-
-    pub(crate) fn exit_code(&self) -> Option<i32> {
-        self.exit.get()
-    }
-
+impl<T> EventLoopWindowTarget<T> {
     #[inline]
     pub fn listen_device_events(&self, _allowed: DeviceEvents) {}
 
@@ -713,3 +643,10 @@ impl EventLoopWindowTarget {
         .into())
     }
 }
+
+// The default routine does floor, but we need round on Wayland.
+fn logical_to_physical_rounded(size: LogicalSize<u32>, scale_factor: f64) -> PhysicalSize<u32> {
+    let width = size.width as f64 * scale_factor;
+    let height = size.height as f64 * scale_factor;
+    (width.round(), height.round()).into()
+}

src/platform_impl/linux/wayland/mod.rs

@@ -9,11 +9,9 @@ use sctk::reexports::client::globals::{BindError, GlobalError};
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::{self, ConnectError, DispatchError, Proxy};
 
-pub(super) use crate::cursor::OnlyCursorImage as CustomCursor;
-use crate::dpi::{LogicalSize, PhysicalSize};
 pub use crate::platform_impl::platform::{OsError, WindowId};
 pub use event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget};
-pub use output::{MonitorHandle, VideoModeHandle};
+pub use output::{MonitorHandle, VideoMode};
 pub use window::Window;
 
 mod event_loop;
@@ -78,10 +76,3 @@ impl DeviceId {
 fn make_wid(surface: &WlSurface) -> WindowId {
     WindowId(surface.id().as_ptr() as u64)
 }
-
-/// The default routine does floor, but we need round on Wayland.
-fn logical_to_physical_rounded(size: LogicalSize<u32>, scale_factor: f64) -> PhysicalSize<u32> {
-    let width = size.width as f64 * scale_factor;
-    let height = size.height as f64 * scale_factor;
-    (width.round(), height.round()).into()
-}

src/platform_impl/linux/wayland/output.rs

@@ -4,11 +4,12 @@ use sctk::reexports::client::Proxy;
 use sctk::output::OutputData;
 
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use crate::platform_impl::platform::VideoModeHandle as PlatformVideoModeHandle;
+use crate::event_loop::ControlFlow;
+use crate::platform_impl::platform::VideoMode as PlatformVideoMode;
 
 use super::event_loop::EventLoopWindowTarget;
 
-impl EventLoopWindowTarget {
+impl<T> EventLoopWindowTarget<T> {
     #[inline]
     pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
         self.state
@@ -23,6 +24,30 @@ impl EventLoopWindowTarget {
         // There's no primary monitor on Wayland.
         None
     }
+
+    pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
+        self.control_flow.set(control_flow)
+    }
+
+    pub(crate) fn control_flow(&self) -> ControlFlow {
+        self.control_flow.get()
+    }
+
+    pub(crate) fn exit(&self) {
+        self.exit.set(Some(0))
+    }
+
+    pub(crate) fn exiting(&self) -> bool {
+        self.exit.get().is_some()
+    }
+
+    pub(crate) fn set_exit_code(&self, code: i32) {
+        self.exit.set(Some(code))
+    }
+
+    pub(crate) fn exit_code(&self) -> Option<i32> {
+        self.exit.get()
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -98,14 +123,14 @@ impl MonitorHandle {
     }
 
     #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoModeHandle> {
+    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoMode> {
         let output_data = self.proxy.data::<OutputData>().unwrap();
         let modes = output_data.with_output_info(|info| info.modes.clone());
 
         let monitor = self.clone();
 
         modes.into_iter().map(move |mode| {
-            PlatformVideoModeHandle::Wayland(VideoModeHandle {
+            PlatformVideoMode::Wayland(VideoMode {
                 size: (mode.dimensions.0 as u32, mode.dimensions.1 as u32).into(),
                 refresh_rate_millihertz: mode.refresh_rate as u32,
                 bit_depth: 32,
@@ -142,14 +167,14 @@ impl std::hash::Hash for MonitorHandle {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct VideoModeHandle {
+pub struct VideoMode {
     pub(crate) size: PhysicalSize<u32>,
     pub(crate) bit_depth: u16,
     pub(crate) refresh_rate_millihertz: u32,
     pub(crate) monitor: MonitorHandle,
 }
 
-impl VideoModeHandle {
+impl VideoMode {
     #[inline]
     pub fn size(&self) -> PhysicalSize<u32> {
         self.size

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

@@ -61,13 +61,8 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                 let window_id = wayland::make_wid(&surface);
 
                 // Mark the window as focused.
-                let was_unfocused = match state.windows.get_mut().get(&window_id) {
-                    Some(window) => {
-                        let mut window = window.lock().unwrap();
-                        let was_unfocused = !window.has_focus();
-                        window.add_seat_focus(data.seat.id());
-                        was_unfocused
-                    }
+                match state.windows.get_mut().get(&window_id) {
+                    Some(window) => window.lock().unwrap().set_has_focus(true),
                     None => return,
                 };
 
@@ -78,14 +73,12 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                     keyboard_state.loop_handle.remove(token);
                 }
 
-                *data.window_id.lock().unwrap() = Some(window_id);
-
                 // The keyboard focus is considered as general focus.
-                if was_unfocused {
-                    state
-                        .events_sink
-                        .push_window_event(WindowEvent::Focused(true), window_id);
-                }
+                state
+                    .events_sink
+                    .push_window_event(WindowEvent::Focused(true), window_id);
+
+                *data.window_id.lock().unwrap() = Some(window_id);
 
                 // HACK: this is just for GNOME not fixing their ordering issue of modifiers.
                 if std::mem::take(&mut seat_state.modifiers_pending) {
@@ -108,30 +101,24 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
 
                 // NOTE: The check whether the window exists is essential as we might get a
                 // nil surface, regardless of what protocol says.
-                let focused = match state.windows.get_mut().get(&window_id) {
-                    Some(window) => {
-                        let mut window = window.lock().unwrap();
-                        window.remove_seat_focus(&data.seat.id());
-                        window.has_focus()
-                    }
+                match state.windows.get_mut().get(&window_id) {
+                    Some(window) => window.lock().unwrap().set_has_focus(false),
                     None => return,
                 };
 
+                // Notify that no modifiers are being pressed.
+                state.events_sink.push_window_event(
+                    WindowEvent::ModifiersChanged(ModifiersState::empty().into()),
+                    window_id,
+                );
+
                 // We don't need to update it above, because the next `Enter` will overwrite
                 // anyway.
                 *data.window_id.lock().unwrap() = None;
 
-                if !focused {
-                    // Notify that no modifiers are being pressed.
-                    state.events_sink.push_window_event(
-                        WindowEvent::ModifiersChanged(ModifiersState::empty().into()),
-                        window_id,
-                    );
-
-                    state
-                        .events_sink
-                        .push_window_event(WindowEvent::Focused(false), window_id);
-                }
+                state
+                    .events_sink
+                    .push_window_event(WindowEvent::Focused(false), window_id);
             }
             WlKeyboardEvent::Key {
                 key,

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

@@ -4,7 +4,6 @@ use std::sync::Arc;
 
 use ahash::AHashMap;
 
-use sctk::reexports::client::backend::ObjectId;
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
 use sctk::reexports::client::protocol::wl_touch::WlTouch;
 use sctk::reexports::client::{Connection, Proxy, QueueHandle};
@@ -14,7 +13,6 @@ use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::
 use sctk::seat::pointer::{ThemeSpec, ThemedPointer};
 use sctk::seat::{Capability as SeatCapability, SeatHandler, SeatState};
 
-use crate::event::WindowEvent;
 use crate::keyboard::ModifiersState;
 use crate::platform_impl::wayland::state::WinitState;
 
@@ -145,10 +143,6 @@ impl SeatHandler for WinitState {
     ) {
         let seat_state = self.seats.get_mut(&seat.id()).unwrap();
 
-        if let Some(text_input) = seat_state.text_input.take() {
-            text_input.destroy();
-        }
-
         match capability {
             SeatCapability::Touch => {
                 if let Some(touch) = seat_state.touch.take() {
@@ -180,10 +174,13 @@ impl SeatHandler for WinitState {
             }
             SeatCapability::Keyboard => {
                 seat_state.keyboard_state = None;
-                self.on_keyboard_destroy(&seat.id());
             }
             _ => (),
         }
+
+        if let Some(text_input) = seat_state.text_input.take() {
+            text_input.destroy();
+        }
     }
 
     fn new_seat(
@@ -202,21 +199,6 @@ impl SeatHandler for WinitState {
         seat: WlSeat,
     ) {
         let _ = self.seats.remove(&seat.id());
-        self.on_keyboard_destroy(&seat.id());
-    }
-}
-
-impl WinitState {
-    fn on_keyboard_destroy(&mut self, seat: &ObjectId) {
-        for (window_id, window) in self.windows.get_mut() {
-            let mut window = window.lock().unwrap();
-            let had_focus = window.has_focus();
-            window.remove_seat_focus(seat);
-            if had_focus != window.has_focus() {
-                self.events_sink
-                    .push_window_event(WindowEvent::Focused(false), *window_id);
-            }
-        }
     }
 }
 

src/platform_impl/linux/wayland/state.rs

@@ -19,23 +19,24 @@ use sctk::seat::SeatState;
 use sctk::shell::xdg::window::{Window, WindowConfigure, WindowHandler};
 use sctk::shell::xdg::XdgShell;
 use sctk::shell::WaylandSurface;
-use sctk::shm::slot::SlotPool;
 use sctk::shm::{Shm, ShmHandler};
 use sctk::subcompositor::SubcompositorState;
 
-use crate::platform_impl::wayland::event_loop::sink::EventSink;
-use crate::platform_impl::wayland::output::MonitorHandle;
-use crate::platform_impl::wayland::seat::{
+use crate::dpi::LogicalSize;
+use crate::platform_impl::OsError;
+
+use super::event_loop::sink::EventSink;
+use super::output::MonitorHandle;
+use super::seat::{
     PointerConstraintsState, RelativePointerState, TextInputState, WinitPointerData,
     WinitPointerDataExt, WinitSeatState,
 };
-use crate::platform_impl::wayland::types::kwin_blur::KWinBlurManager;
-use crate::platform_impl::wayland::types::wp_fractional_scaling::FractionalScalingManager;
-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 super::types::kwin_blur::KWinBlurManager;
+use super::types::wp_fractional_scaling::FractionalScalingManager;
+use super::types::wp_viewporter::ViewporterState;
+use super::types::xdg_activation::XdgActivationState;
+use super::window::{WindowRequests, WindowState};
+use super::{WaylandError, WindowId};
 
 /// Winit's Wayland state.
 pub struct WinitState {
@@ -49,7 +50,7 @@ pub struct WinitState {
     pub compositor_state: Arc<CompositorState>,
 
     /// The state of the subcompositor.
-    pub subcompositor_state: Option<Arc<SubcompositorState>>,
+    pub subcompositor_state: Arc<SubcompositorState>,
 
     /// The seat state responsible for all sorts of input.
     pub seat_state: SeatState,
@@ -57,9 +58,6 @@ pub struct WinitState {
     /// The shm for software buffers, such as cursors.
     pub shm: Shm,
 
-    /// The pool where custom cursors are allocated.
-    pub custom_cursor_pool: Arc<Mutex<SlotPool>>,
-
     /// The XDG shell that is used for widnows.
     pub xdg_shell: XdgShell,
 
@@ -126,17 +124,12 @@ impl WinitState {
         let registry_state = RegistryState::new(globals);
         let compositor_state =
             CompositorState::bind(globals, queue_handle).map_err(WaylandError::Bind)?;
-        let subcompositor_state = match SubcompositorState::bind(
+        let subcompositor_state = SubcompositorState::bind(
             compositor_state.wl_compositor().clone(),
             globals,
             queue_handle,
-        ) {
-            Ok(c) => Some(c),
-            Err(e) => {
-                log::warn!("Subcompositor protocol not available, ignoring CSD: {e:?}");
-                None
-            }
-        };
+        )
+        .map_err(WaylandError::Bind)?;
 
         let output_state = OutputState::new(globals, queue_handle);
         let monitors = output_state.outputs().map(MonitorHandle::new).collect();
@@ -155,17 +148,13 @@ impl WinitState {
                 (None, None)
             };
 
-        let shm = Shm::bind(globals, queue_handle).map_err(WaylandError::Bind)?;
-        let custom_cursor_pool = Arc::new(Mutex::new(SlotPool::new(2, &shm).unwrap()));
-
         Ok(Self {
             registry_state,
             compositor_state: Arc::new(compositor_state),
-            subcompositor_state: subcompositor_state.map(Arc::new),
+            subcompositor_state: Arc::new(subcompositor_state),
             output_state,
             seat_state,
-            shm,
-            custom_cursor_pool,
+            shm: Shm::bind(globals, queue_handle).map_err(WaylandError::Bind)?,
 
             xdg_shell: XdgShell::bind(globals, queue_handle).map_err(WaylandError::Bind)?,
             xdg_activation: XdgActivationState::bind(globals, queue_handle).ok(),
@@ -225,7 +214,7 @@ impl WinitState {
 
             // Update the scale factor right away.
             window.lock().unwrap().set_scale_factor(scale_factor);
-            self.window_compositor_updates[pos].scale_changed = true;
+            self.window_compositor_updates[pos].scale_factor = Some(scale_factor);
         } else if let Some(pointer) = self.pointer_surfaces.get(&surface.id()) {
             // Get the window, where the pointer resides right now.
             let focused_window = match pointer.pointer().winit_data().focused_window() {
@@ -289,26 +278,23 @@ impl WindowHandler for WinitState {
         };
 
         // Populate the configure to the window.
-        self.window_compositor_updates[pos].resized |= self
+        //
+        // XXX the size on the window will be updated right before dispatching the size to the user.
+        let new_size = self
             .windows
             .get_mut()
             .get_mut(&window_id)
             .expect("got configure for dead window.")
             .lock()
             .unwrap()
-            .configure(configure, &self.shm, &self.subcompositor_state);
+            .configure(
+                configure,
+                &self.shm,
+                &self.subcompositor_state,
+                &mut self.events_sink,
+            );
 
-        // NOTE: configure demands wl_surface::commit, however winit doesn't commit on behalf of the
-        // users, since it can break a lot of things, thus it'll ask users to redraw instead.
-        self.window_requests
-            .get_mut()
-            .get(&window_id)
-            .unwrap()
-            .redraw_requested
-            .store(true, Ordering::Relaxed);
-
-        // Manually mark that we've got an event, since configure may not generate a resize.
-        self.dispatched_events = true;
+        self.window_compositor_updates[pos].size = Some(new_size);
     }
 }
 
@@ -402,10 +388,10 @@ pub struct WindowCompositorUpdate {
     pub window_id: WindowId,
 
     /// New window size.
-    pub resized: bool,
+    pub size: Option<LogicalSize<u32>>,
 
     /// New scale factor.
-    pub scale_changed: bool,
+    pub scale_factor: Option<f64>,
 
     /// Close the window.
     pub close_window: bool,
@@ -415,8 +401,8 @@ impl WindowCompositorUpdate {
     fn new(window_id: WindowId) -> Self {
         Self {
             window_id,
-            resized: false,
-            scale_changed: false,
+            size: None,
+            scale_factor: None,
             close_window: false,
         }
     }

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

@@ -1,59 +0,0 @@
-use cursor_icon::CursorIcon;
-
-use sctk::reexports::client::protocol::wl_shm::Format;
-use sctk::shm::slot::{Buffer, SlotPool};
-
-use crate::cursor::CursorImage;
-
-#[derive(Debug)]
-pub enum SelectedCursor {
-    Named(CursorIcon),
-    Custom(CustomCursor),
-}
-
-impl Default for SelectedCursor {
-    fn default() -> Self {
-        Self::Named(Default::default())
-    }
-}
-
-#[derive(Debug)]
-pub struct CustomCursor {
-    pub buffer: Buffer,
-    pub w: i32,
-    pub h: i32,
-    pub hotspot_x: i32,
-    pub hotspot_y: i32,
-}
-
-impl CustomCursor {
-    pub(crate) fn new(pool: &mut SlotPool, image: &CursorImage) -> Self {
-        let (buffer, canvas) = pool
-            .create_buffer(
-                image.width as i32,
-                image.height as i32,
-                4 * (image.width as i32),
-                Format::Argb8888,
-            )
-            .unwrap();
-
-        for (canvas_chunk, rgba) in canvas.chunks_exact_mut(4).zip(image.rgba.chunks_exact(4)) {
-            // Alpha in buffer is premultiplied.
-            let alpha = rgba[3] as f32 / 255.;
-            let r = (rgba[0] as f32 * alpha) as u32;
-            let g = (rgba[1] as f32 * alpha) as u32;
-            let b = (rgba[2] as f32 * alpha) as u32;
-            let color = ((rgba[3] as u32) << 24) + (r << 16) + (g << 8) + b;
-            let array: &mut [u8; 4] = canvas_chunk.try_into().unwrap();
-            *array = color.to_le_bytes();
-        }
-
-        CustomCursor {
-            buffer,
-            w: image.width as i32,
-            h: image.height as i32,
-            hotspot_x: image.hotspot_x as i32,
-            hotspot_y: image.hotspot_y as i32,
-        }
-    }
-}