Review comments

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

.github/workflows/ci.yml

@@ -35,19 +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.65.0'
-            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
         include:
+          # 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', cmd: 'apk --' }
+            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: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity' }
+
 
     env:
       # Set more verbose terminal output
@@ -59,7 +60,6 @@ jobs:
       RUSTDOCFLAGS: '--deny=warnings'
 
       OPTIONS: --target=${{ matrix.platform.target }} ${{ matrix.platform.options }}
-      CMD: ${{ matrix.platform.cmd }}
 
     steps:
     - uses: actions/checkout@v3
@@ -87,23 +87,11 @@ jobs:
       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:
@@ -111,17 +99,30 @@ jobs:
         targets: ${{ matrix.platform.target }}
         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
 
-    - 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') &&
+        !contains(matrix.platform.target, 'android') &&
         matrix.toolchain != '1.65.0'
-      run: cargo $CMD test --no-run $OPTIONS
+      run: cargo test --no-run $OPTIONS
 
     - name: Run tests
       if: >
@@ -130,7 +131,7 @@ jobs:
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
         matrix.toolchain != '1.65.0'
-      run: cargo $CMD test $OPTIONS
+      run: cargo test $OPTIONS
 
     - name: Lint with clippy
       if: (matrix.toolchain == 'stable') && !contains(matrix.platform.options, '--no-default-features')
@@ -139,8 +140,9 @@ jobs:
     - name: Build tests with serde enabled
       if: >
         !contains(matrix.platform.target, 'redox') &&
+        !contains(matrix.platform.target, 'android') &&
         matrix.toolchain != '1.65.0'
-      run: cargo $CMD test --no-run $OPTIONS --features serde
+      run: cargo test --no-run $OPTIONS --features serde
 
     - name: Run tests with serde enabled
       if: >
@@ -149,7 +151,7 @@ jobs:
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
         matrix.toolchain != '1.65.0'
-      run: cargo $CMD test $OPTIONS --features serde
+      run: cargo test $OPTIONS --features serde
 
     # See restore step above
     - name: Save cache of cargo folder

.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,123 +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
 
-# 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.
-
-# 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`.
@@ -135,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
@@ -21,7 +21,7 @@ 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.65.
-- you tested your modifications on all the platforms impacted, or if not possible, detail which platforms
+- 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.6"
+version = "0.29.1-beta"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 edition = "2021"
@@ -13,14 +13,7 @@ categories = ["gui"]
 rust-version = "1.65.0"
 
 [package.metadata.docs.rs]
-features = [
-    "rwh_04",
-    "rwh_05",
-    "rwh_06",
-    "serde",
-    # 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 = [
@@ -52,37 +45,34 @@ 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.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 = "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"
@@ -160,13 +150,13 @@ 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]
@@ -222,5 +212,7 @@ web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }
 
 [workspace]
 members = [
+    "xbuild/android-target",
+    "xbuild/ios-target",
     "run-wasm",
 ]

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,7 +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 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.
@@ -150,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)
@@ -166,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

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

@@ -6,7 +6,7 @@
 
 ```toml
 [dependencies]
-winit = "0.29.6"
+winit = "0.29.1-beta"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -26,12 +26,38 @@ Join us in any of these:
 
 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:
@@ -42,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.65**. 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
@@ -53,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
@@ -85,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 with WebAssembly, 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].
 
@@ -108,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"`           |
@@ -126,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]
@@ -134,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
@@ -150,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 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.6", 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).
 
@@ -167,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
@@ -183,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.

deny.toml

@@ -34,7 +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/control_flow.rs

@@ -10,7 +10,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
-    keyboard::{Key, NamedKey},
+    keyboard::Key,
     window::WindowBuilder,
 };
 
@@ -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_grab.rs

@@ -4,7 +4,7 @@ use simple_logger::SimpleLogger;
 use winit::{
     event::{DeviceEvent, ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    keyboard::{Key, ModifiersState, NamedKey},
+    keyboard::{Key, ModifiersState},
     window::{CursorGrabMode, WindowBuilder},
 };
 
@@ -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/focus.rs

@@ -1,56 +0,0 @@
-#![allow(clippy::single_match)]
-
-//! Example for focusing a window.
-
-use simple_logger::SimpleLogger;
-#[cfg(not(wasm_platform))]
-use std::time;
-#[cfg(wasm_platform)]
-use web_time as time;
-use winit::{
-    event::{Event, StartCause, WindowEvent},
-    event_loop::EventLoop,
-    window::WindowBuilder,
-};
-
-#[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 = WindowBuilder::new()
-        .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

@@ -4,7 +4,7 @@ use simple_logger::SimpleLogger;
 use winit::dpi::PhysicalSize;
 use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
 use winit::event_loop::EventLoop;
-use winit::keyboard::{Key, NamedKey};
+use winit::keyboard::Key;
 use winit::window::{Fullscreen, WindowBuilder};
 
 #[cfg(target_os = "macos")]
@@ -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() {

examples/ime.rs

@@ -6,7 +6,7 @@ use winit::{
     dpi::{PhysicalPosition, PhysicalSize},
     event::{ElementState, Event, Ime, WindowEvent},
     event_loop::EventLoop,
-    keyboard::NamedKey,
+    keyboard::{Key, KeyCode},
     window::{ImePurpose, WindowBuilder},
 };
 
@@ -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/multithreaded.rs

@@ -9,7 +9,7 @@ fn main() -> Result<(), impl std::error::Error> {
         dpi::{PhysicalPosition, PhysicalSize, Position, Size},
         event::{ElementState, Event, KeyEvent, WindowEvent},
         event_loop::EventLoop,
-        keyboard::{Key, ModifiersState, NamedKey},
+        keyboard::{Key, ModifiersState},
         window::{CursorGrabMode, CursorIcon, Fullscreen, WindowBuilder, WindowLevel},
     };
 
@@ -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.
@@ -185,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,
                             ..
                         },
                     ..

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/resizable.rs

@@ -5,7 +5,7 @@ use winit::{
     dpi::LogicalSize,
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    keyboard::{KeyCode, PhysicalKey},
+    keyboard::KeyCode,
     window::WindowBuilder,
 };
 
@@ -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,6 +11,7 @@ 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,
     };
@@ -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.

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,7 +3,7 @@
 use winit::{
     event::{ElementState, Event, KeyEvent, WindowEvent},
     event_loop::EventLoop,
-    keyboard::Key,
+    keyboard::KeyCode,
     window::{Fullscreen, WindowBuilder},
 };
 
@@ -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 {

examples/window_debug.rs

@@ -7,7 +7,7 @@ use winit::{
     dpi::{LogicalSize, PhysicalSize},
     event::{DeviceEvent, ElementState, Event, KeyEvent, RawKeyEvent, WindowEvent},
     event_loop::{DeviceEvents, EventLoop},
-    keyboard::{Key, KeyCode, PhysicalKey},
+    keyboard::{Key, KeyCode},
     window::{Fullscreen, WindowBuilder},
 };
 
@@ -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_on_demand.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(),

examples/window_resize_increments.rs

@@ -2,9 +2,9 @@ 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,
+    keyboard::Key,
     window::WindowBuilder,
 };
 
@@ -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,7 +9,7 @@ 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, WindowBuilder},
 };
@@ -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) => {

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.

src/event.rs

@@ -671,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,
 }
 
@@ -703,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
@@ -743,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.

src/event_loop.rs

@@ -9,8 +9,6 @@
 //! 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, AtomicU64, Ordering};
 use std::{error, fmt};
 
@@ -224,22 +222,14 @@ 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(
-        wasm_platform,
-        doc = "[`EventLoopExtWebSys::spawn()`][crate::platform::web::EventLoopExtWebSys::spawn()]"
-    )]
-    #[cfg_attr(not(wasm_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 WASM.
+    /// [`set_control_flow()`]: EventLoopWindowTarget::set_control_flow
     #[inline]
     #[cfg(not(all(wasm_platform, target_feature = "exception-handling")))]
     pub fn run<F>(self, event_handler: F) -> Result<(), EventLoopError>
@@ -266,40 +256,12 @@ 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<T>;
     fn deref(&self) -> &EventLoopWindowTarget<T> {
@@ -383,7 +345,7 @@ impl<T> rwh_06::HasDisplayHandle for EventLoopWindowTarget<T> {
 
 #[cfg(feature = "rwh_05")]
 unsafe impl<T> rwh_05::HasRawDisplayHandle for EventLoopWindowTarget<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 {
         self.p.raw_display_handle_rwh_05()
     }

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

@@ -185,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
@@ -734,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:
@@ -742,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
@@ -1451,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
+            }
+        )
     }
 }
 
@@ -1585,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,
         }
     }
@@ -1682,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 = 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,37 +26,17 @@
 //! 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
@@ -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,8 +110,9 @@
 //! 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
@@ -139,14 +120,15 @@
 //! [window_new]: window::Window::new
 //! [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)]
@@ -181,18 +163,3 @@ mod platform_impl;
 pub mod window;
 
 pub mod platform;
-
-/// Wrapper for objects which winit will access on the main thread so they are effectively `Send`
-/// and `Sync`, since they always execute on a single thread.
-///
-/// # Safety
-///
-/// Winit can run only one event loop at a time, and the event loop itself is tied to some thread.
-/// The objects could be sent across the threads, but once passed to winit, they execute on the
-/// main thread if the platform demands it. Thus, marking such objects as `Send + Sync` is safe.
-#[doc(hidden)]
-#[derive(Clone, Debug)]
-pub(crate) struct SendSyncWrapper<T>(pub(crate) T);
-
-unsafe impl<T> Send for SendSyncWrapper<T> {}
-unsafe impl<T> Sync for SendSyncWrapper<T> {}

src/monitor.rs

@@ -138,18 +138,14 @@ impl MonitorHandle {
         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()

src/platform/android.rs

@@ -84,10 +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)]
     pub use android_activity::*;
 }

src/platform/ios.rs

@@ -69,25 +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);
 }
 
 impl WindowExtIOS for Window {
@@ -121,12 +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))
-    }
 }
 
 /// Additional methods on [`WindowBuilder`] that are specific to iOS.
@@ -174,14 +154,6 @@ 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 {
@@ -215,12 +187,6 @@ impl WindowBuilderExtIOS for WindowBuilder {
         self.platform_specific.prefers_status_bar_hidden = hidden;
         self
     }
-
-    #[inline]
-    fn with_preferred_status_bar_style(mut self, status_bar_style: StatusBarStyle) -> Self {
-        self.platform_specific.preferred_status_bar_style = status_bar_style;
-        self
-    }
 }
 
 /// Additional methods on [`MonitorHandle`] that are specific to iOS.
@@ -298,11 +264,3 @@ bitflags! {
             | ScreenEdge::BOTTOM.bits() | ScreenEdge::RIGHT.bits();
     }
 }
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub enum StatusBarStyle {
-    #[default]
-    Default,
-    LightContent,
-    DarkContent,
-}

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
@@ -57,13 +57,8 @@ pub trait EventLoopExtRunOnDemand {
     ///   on an event loop that is internal to the browser itself.
     /// - **iOS:** It's not possible to stop and start an `NSApplication` repeatedly on iOS.
     ///
-    #[cfg_attr(
-        not(wasm_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<Self::UserEvent>);
@@ -76,14 +71,6 @@ impl<T> EventLoopExtRunOnDemand for EventLoop<T> {
     where
         F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>),
     {
-        self.event_loop.window_target().clear_exit();
         self.event_loop.run_on_demand(event_handler)
     }
 }
-
-impl<T> EventLoopWindowTarget<T> {
-    /// Clear exit status.
-    pub(crate) fn clear_exit(&self) {
-        self.p.clear_exit()
-    }
-}

src/platform/scancode.rs

@@ -1,14 +1,14 @@
 #![cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform))]
 
-use crate::keyboard::{KeyCode, PhysicalKey};
+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.
@@ -18,28 +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 KeyCode
-where
-    PhysicalKey: PhysicalKeyExtScancode,
-{
-    #[inline]
-    fn from_scancode(scancode: u32) -> PhysicalKey {
-        <PhysicalKey as PhysicalKeyExtScancode>::from_scancode(scancode)
-    }
-
-    #[inline]
-    fn to_scancode(self) -> Option<u32> {
-        <PhysicalKey as PhysicalKeyExtScancode>::to_scancode(PhysicalKey::Code(self))
-    }
+    fn from_scancode(scancode: u32) -> KeyCode;
 }

src/platform/web.rs

@@ -31,7 +31,6 @@ use crate::event::Event;
 use crate::event_loop::EventLoop;
 use crate::event_loop::EventLoopWindowTarget;
 use crate::window::{Window, WindowBuilder};
-use crate::SendSyncWrapper;
 
 use web_sys::HtmlCanvasElement;
 
@@ -82,22 +81,26 @@ pub trait WindowBuilderExtWebSys {
 
 impl WindowBuilderExtWebSys for WindowBuilder {
     fn with_canvas(mut self, canvas: Option<HtmlCanvasElement>) -> Self {
-        self.platform_specific.canvas = SendSyncWrapper(canvas);
+        self.platform_specific.canvas = canvas;
+
         self
     }
 
     fn with_prevent_default(mut self, prevent_default: bool) -> Self {
         self.platform_specific.prevent_default = prevent_default;
+
         self
     }
 
     fn with_focusable(mut self, focusable: bool) -> Self {
         self.platform_specific.focusable = focusable;
+
         self
     }
 
     fn with_append(mut self, append: bool) -> Self {
         self.platform_specific.append = append;
+
         self
     }
 }
@@ -109,28 +112,13 @@ pub trait EventLoopExtWebSys {
 
     /// Initializes the winit event loop.
     ///
-    /// Unlike
-    #[cfg_attr(
-        all(wasm_platform, target_feature = "exception-handling"),
-        doc = "`run()`"
-    )]
-    #[cfg_attr(
-        not(all(wasm_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(wasm_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<Self::UserEvent>);

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

@@ -456,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,
@@ -713,10 +713,6 @@ impl<T: 'static> EventLoopWindowTarget<T> {
         self.exit.set(true)
     }
 
-    pub(crate) fn clear_exit(&self) {
-        self.exit.set(false)
-    }
-
     pub(crate) fn exiting(&self) -> bool {
         self.exit.get()
     }
@@ -950,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.");
         }
@@ -976,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)

src/platform_impl/ios/app_state.rs

@@ -200,10 +200,6 @@ impl AppState {
         )
     }
 
-    fn has_terminated(&self) -> bool {
-        matches!(self.state(), AppStateImpl::Terminated)
-    }
-
     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 {
@@ -247,7 +243,7 @@ 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;
         }
 
@@ -394,7 +390,7 @@ impl AppState {
     }
 
     fn events_cleared_transition(&mut self) {
-        if !self.has_launched() || self.has_terminated() {
+        if !self.has_launched() {
             return;
         }
         let (waiting_event_handler, old) = match self.take_state() {
@@ -590,10 +586,6 @@ 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 event_handler, active_control_flow, processing_redraws) =
         match this.try_user_callback_transition() {
             UserCallbackTransitionResult::ReentrancyPrevented { queued_events } => {
@@ -745,7 +737,7 @@ fn handle_user_events(mtm: MainThreadMarker) {
 
 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() {

src/platform_impl/ios/event_loop.rs

@@ -289,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!(),
             }
         }
@@ -304,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!(),
             }
         }

src/platform_impl/ios/uikit/mod.rs

@@ -12,7 +12,6 @@ mod event;
 mod responder;
 mod screen;
 mod screen_mode;
-mod status_bar_style;
 mod touch;
 mod trait_collection;
 mod view;
@@ -26,7 +25,6 @@ pub(crate) use self::event::UIEvent;
 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/view.rs

@@ -11,8 +11,8 @@ use objc2::{declare_class, extern_methods, msg_send, msg_send_id, mutability, Cl
 use super::app_state::{self, EventWrapper};
 use super::uikit::{
     UIApplication, UIDevice, UIEvent, UIForceTouchCapability, UIInterfaceOrientationMask,
-    UIResponder, UIStatusBarStyle, UITouch, UITouchPhase, UITouchType, UITraitCollection, UIView,
-    UIViewController, UIWindow,
+    UIResponder, UITouch, UITouchPhase, UITouchType, UITraitCollection, UIView, UIViewController,
+    UIWindow,
 };
 use super::window::WindowId;
 use crate::{
@@ -267,7 +267,6 @@ 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>,
@@ -298,7 +297,6 @@ declare_class!(
                     &mut this.state,
                     Box::new(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(
@@ -322,11 +320,6 @@ declare_class!(
             self.state.prefers_status_bar_hidden.get()
         }
 
-        #[method(preferredStatusBarStyle)]
-        fn preferred_status_bar_style(&self) -> UIStatusBarStyle {
-            self.state.preferred_status_bar_style.get()
-        }
-
         #[method(prefersHomeIndicatorAutoHidden)]
         fn prefers_home_indicator_auto_hidden(&self) -> bool {
             self.state.prefers_home_indicator_auto_hidden.get()
@@ -352,11 +345,6 @@ impl WinitViewController {
         self.setNeedsStatusBarAppearanceUpdate();
     }
 
-    pub(crate) fn set_preferred_status_bar_style(&self, val: UIStatusBarStyle) {
-        self.state.preferred_status_bar_style.set(val);
-        self.setNeedsStatusBarAppearanceUpdate();
-    }
-
     pub(crate) fn set_prefers_home_indicator_auto_hidden(&self, val: bool) {
         self.state.prefers_home_indicator_auto_hidden.set(val);
         let os_capabilities = app_state::os_capabilities();
@@ -415,8 +403,6 @@ impl WinitViewController {
 
         this.set_prefers_status_bar_hidden(platform_attributes.prefers_status_bar_hidden);
 
-        this.set_preferred_status_bar_style(platform_attributes.preferred_status_bar_style.into());
-
         this.set_supported_interface_orientations(mtm, platform_attributes.valid_orientations);
 
         this.set_prefers_home_indicator_auto_hidden(
@@ -487,7 +473,7 @@ impl WinitUIWindow {
 
         this.setRootViewController(Some(view_controller));
 
-        match window_attributes.fullscreen.0.clone().map(Into::into) {
+        match window_attributes.fullscreen.clone().map(Into::into) {
             Some(Fullscreen::Exclusive(ref video_mode)) => {
                 let monitor = video_mode.monitor();
                 let screen = monitor.ui_screen(mtm);

src/platform_impl/ios/window.rs

@@ -15,7 +15,7 @@ use crate::{
     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,
     },
@@ -422,7 +422,7 @@ impl Window {
         // TODO: transparency, visible
 
         let main_screen = UIScreen::main(mtm);
-        let fullscreen = window_attributes.fullscreen.0.clone().map(Into::into);
+        let fullscreen = window_attributes.fullscreen.clone().map(Into::into);
         let screen = match fullscreen {
             Some(Fullscreen::Exclusive(ref video_mode)) => video_mode.monitor.ui_screen(mtm),
             Some(Fullscreen::Borderless(Some(ref monitor))) => monitor.ui_screen(mtm),
@@ -551,11 +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());
-    }
 }
 
 impl Inner {
@@ -664,6 +659,5 @@ pub struct PlatformSpecificWindowBuilderAttributes {
     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 {
+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_keycode(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_keycode(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_keycode(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_keycode(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::ArrowLeft,
-        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,7 +391,7 @@ 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();
@@ -498,8 +498,8 @@ impl<'a> KeyEventResults<'a> {
         }
     }
 
-    fn physical_key(&mut 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) {

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};
@@ -25,10 +24,10 @@ use crate::{
         EventLoopWindowTarget as RootELW,
     },
     icon::Icon,
-    keyboard::{Key, PhysicalKey},
+    keyboard::{Key, KeyCode},
     platform::{
         modifier_supplement::KeyEventExtModifierSupplement, pump_events::PumpStatus,
-        scancode::PhysicalKeyExtScancode,
+        scancode::KeyCodeExtScancode,
     },
     window::{
         ActivationToken, CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme,
@@ -657,13 +656,13 @@ impl KeyEventExtModifierSupplement for KeyEvent {
     }
 }
 
-impl PhysicalKeyExtScancode for PhysicalKey {
-    fn from_scancode(scancode: u32) -> PhysicalKey {
+impl KeyCodeExtScancode for KeyCode {
+    fn from_scancode(scancode: u32) -> KeyCode {
         common::keymap::scancode_to_keycode(scancode)
     }
 
     fn to_scancode(self) -> Option<u32> {
-        common::keymap::physicalkey_to_scancode(self)
+        common::keymap::keycode_to_scancode(self)
     }
 }
 
@@ -752,16 +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")
-                .map(|var| !var.is_empty())
-                .unwrap_or(false),
-            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,
@@ -833,18 +827,6 @@ impl<T: 'static> EventLoop<T> {
     }
 }
 
-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))
@@ -918,10 +900,6 @@ impl<T> EventLoopWindowTarget<T> {
         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())
     }

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};
@@ -393,7 +392,7 @@ impl<T: 'static> EventLoop<T> {
                     self.with_state(|state| {
                         let windows = state.windows.get_mut();
                         let mut window = windows.get(&window_id).unwrap().lock().unwrap();
-                        window.request_inner_size(new_logical_size.into());
+                        window.resize(new_logical_size);
                     });
                 }
 
@@ -467,44 +466,44 @@ impl<T: 'static> EventLoop<T> {
         });
 
         for window_id in window_ids.drain(..) {
-            let event = self.with_state(|state| {
+            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);
+                    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,
+                        event: WindowEvent::RedrawRequested,
                     },
                     &self.window_target,
                 );
@@ -590,18 +589,6 @@ 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<T> {
     /// The event loop wakeup source.
     pub event_loop_awakener: calloop::ping::Ping,
@@ -629,34 +616,6 @@ pub struct EventLoopWindowTarget<T> {
 }
 
 impl<T> EventLoopWindowTarget<T> {
-    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()
-    }
-
     #[inline]
     pub fn listen_device_events(&self, _allowed: DeviceEvents) {}
 

src/platform_impl/linux/wayland/output.rs

@@ -4,6 +4,7 @@ use sctk::reexports::client::Proxy;
 use sctk::output::OutputData;
 
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
+use crate::event_loop::ControlFlow;
 use crate::platform_impl::platform::VideoMode as PlatformVideoMode;
 
 use super::event_loop::EventLoopWindowTarget;
@@ -23,6 +24,30 @@ impl<T> EventLoopWindowTarget<T> {
         // 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)]

src/platform_impl/linux/wayland/state.rs

@@ -50,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,
@@ -124,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) => {
-                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();
@@ -156,7 +151,7 @@ impl WinitState {
         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: Shm::bind(globals, queue_handle).map_err(WaylandError::Bind)?,
@@ -299,11 +294,7 @@ impl WindowHandler for WinitState {
                 &mut self.events_sink,
             );
 
-        // NOTE: Only update when the value is `Some` to not override consequent configures with
-        // the same sizes.
-        if new_size.is_some() {
-            self.window_compositor_updates[pos].size = new_size;
-        }
+        self.window_compositor_updates[pos].size = Some(new_size);
     }
 }
 

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

@@ -97,9 +97,11 @@ impl Window {
             .map(|activation_state| activation_state.global().clone());
         let display = event_loop_window_target.connection.display();
 
-        let size: Size = attributes
+        // XXX The initial scale factor must be 1, but it might cause sizing issues on HiDPI.
+        let size: LogicalSize<u32> = attributes
             .inner_size
-            .unwrap_or(LogicalSize::new(800., 600.).into());
+            .map(|size| size.to_logical::<u32>(1.))
+            .unwrap_or((800, 600).into());
 
         // We prefer server side decorations, however to not have decorations we ask for client
         // side decorations instead.
@@ -139,8 +141,7 @@ impl Window {
         // Set the window title.
         window_state.set_title(attributes.title);
 
-        // Set the min and max sizes. We must set the hints upon creating a window, so
-        // we use the default `1.` scaling...
+        // Set the min and max sizes.
         let min_size = attributes.min_inner_size.map(|size| size.to_logical(1.));
         let max_size = attributes.max_inner_size.map(|size| size.to_logical(1.));
         window_state.set_min_inner_size(min_size);
@@ -150,7 +151,7 @@ impl Window {
         window_state.set_resizable(attributes.resizable);
 
         // Set startup mode.
-        match attributes.fullscreen.0.map(Into::into) {
+        match attributes.fullscreen.map(Into::into) {
             Some(Fullscreen::Exclusive(_)) => {
                 warn!("`Fullscreen::Exclusive` is ignored on Wayland");
             }
@@ -314,9 +315,12 @@ impl Window {
     #[inline]
     pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let mut window_state = self.window_state.lock().unwrap();
-        let new_size = window_state.request_inner_size(size);
+        let scale_factor = window_state.scale_factor();
+        window_state.resize(size.to_logical::<u32>(scale_factor));
+
         self.request_redraw();
-        Some(new_size)
+
+        Some(window_state.inner_size().to_physical(scale_factor))
     }
 
     /// Set the minimum inner size for the window.

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

@@ -1,5 +1,6 @@
 //! The state of the window, which is shared with the event-loop.
 
+use std::mem::ManuallyDrop;
 use std::num::NonZeroU32;
 use std::sync::{Arc, Weak};
 use std::time::Duration;
@@ -27,7 +28,7 @@ use sctk::shm::Shm;
 use sctk::subcompositor::SubcompositorState;
 use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 
-use crate::dpi::{LogicalPosition, LogicalSize, PhysicalSize, Size};
+use crate::dpi::{LogicalPosition, LogicalSize};
 use crate::error::{ExternalError, NotSupportedError};
 use crate::event::WindowEvent;
 use crate::platform_impl::wayland::event_loop::sink::EventSink;
@@ -54,6 +55,9 @@ pub struct WindowState {
     /// The connection to Wayland server.
     pub connection: Connection,
 
+    /// The underlying SCTK window.
+    pub window: ManuallyDrop<Window>,
+
     /// The window frame, which is created from the configure request.
     frame: Option<WinitFrame>,
 
@@ -129,10 +133,6 @@ pub struct WindowState {
     /// sends `None` for the new size in the configure.
     stateless_size: LogicalSize<u32>,
 
-    /// Initial window size provided by the user. Removed on the first
-    /// configure.
-    initial_size: Option<Size>,
-
     /// The state of the frame callback.
     frame_callback_state: FrameCallbackState,
 
@@ -145,9 +145,6 @@ pub struct WindowState {
     ///
     /// The value is the serial of the event triggered moved.
     has_pending_move: Option<u32>,
-
-    /// The underlying SCTK window.
-    pub window: Window,
 }
 
 impl WindowState {
@@ -156,7 +153,7 @@ impl WindowState {
         connection: Connection,
         queue_handle: &QueueHandle<WinitState>,
         winit_state: &WinitState,
-        initial_size: Size,
+        size: LogicalSize<u32>,
         window: Window,
         theme: Option<Theme>,
     ) -> Self {
@@ -197,15 +194,14 @@ impl WindowState {
             resizable: true,
             scale_factor: 1.,
             shm: winit_state.shm.wl_shm().clone(),
-            size: initial_size.to_logical(1.),
-            stateless_size: initial_size.to_logical(1.),
-            initial_size: Some(initial_size),
+            size,
+            stateless_size: size,
             text_inputs: Vec::new(),
             theme,
             title: String::default(),
             transparent: false,
             viewport,
-            window,
+            window: ManuallyDrop::new(window),
         }
     }
 
@@ -254,27 +250,16 @@ impl WindowState {
         &mut self,
         configure: WindowConfigure,
         shm: &Shm,
-        subcompositor: &Option<Arc<SubcompositorState>>,
+        subcompositor: &Arc<SubcompositorState>,
         event_sink: &mut EventSink,
-    ) -> Option<LogicalSize<u32>> {
-        // NOTE: when using fractional scaling or wl_compositor@v6 the scaling
-        // should be delivered before the first configure, thus apply it to
-        // properly scale the physical sizes provided by the users.
-        if let Some(initial_size) = self.initial_size.take() {
-            self.size = initial_size.to_logical(self.scale_factor());
-            self.stateless_size = self.size;
-        }
-
-        if let Some(subcompositor) = subcompositor.as_ref().filter(|_| {
-            configure.decoration_mode == DecorationMode::Client
-                && self.frame.is_none()
-                && !self.csd_fails
-        }) {
+    ) -> LogicalSize<u32> {
+        if configure.decoration_mode == DecorationMode::Client
+            && self.frame.is_none()
+            && !self.csd_fails
+        {
             match WinitFrame::new(
-                &self.window,
+                &*self.window,
                 shm,
-                #[cfg(feature = "sctk-adwaita")]
-                self.compositor.clone(),
                 subcompositor.clone(),
                 self.queue_handle.clone(),
                 #[cfg(feature = "sctk-adwaita")]
@@ -312,90 +297,37 @@ impl WindowState {
             event_sink.push_window_event(WindowEvent::Occluded(occluded), window_id);
         }
 
-        let (mut new_size, constrain) = if let Some(frame) = self.frame.as_mut() {
+        let new_size = if let Some(frame) = self.frame.as_mut() {
             // Configure the window states.
             frame.update_state(configure.state);
 
             match configure.new_size {
                 (Some(width), Some(height)) => {
                     let (width, height) = frame.subtract_borders(width, height);
-                    let width = width.map(|w| w.get()).unwrap_or(1);
-                    let height = height.map(|h| h.get()).unwrap_or(1);
-                    ((width, height).into(), false)
+                    (
+                        width.map(|w| w.get()).unwrap_or(1),
+                        height.map(|h| h.get()).unwrap_or(1),
+                    )
+                        .into()
                 }
-                (_, _) if stateless => (self.stateless_size, true),
-                _ => (self.size, true),
+                (_, _) if stateless => self.stateless_size,
+                _ => self.size,
             }
         } else {
             match configure.new_size {
-                (Some(width), Some(height)) => ((width.get(), height.get()).into(), false),
-                _ if stateless => (self.stateless_size, true),
-                _ => (self.size, true),
+                (Some(width), Some(height)) => (width.get(), height.get()).into(),
+                _ if stateless => self.stateless_size,
+                _ => self.size,
             }
         };
 
-        // Apply configure bounds only when compositor let the user decide what size to pick.
-        if constrain {
-            let bounds = self.inner_size_bounds(&configure);
-            new_size.width = bounds
-                .0
-                .map(|bound_w| new_size.width.min(bound_w.get()))
-                .unwrap_or(new_size.width);
-            new_size.height = bounds
-                .1
-                .map(|bound_h| new_size.height.min(bound_h.get()))
-                .unwrap_or(new_size.height);
-        }
-
-        let new_state = configure.state;
-        let old_state = self
-            .last_configure
-            .as_ref()
-            .map(|configure| configure.state);
-
-        let state_change_requires_resize = old_state
-            .map(|old_state| {
-                !old_state
-                    .symmetric_difference(new_state)
-                    .difference(XdgWindowState::ACTIVATED | XdgWindowState::SUSPENDED)
-                    .is_empty()
-            })
-            // NOTE: `None` is present for the initial configure, thus we must always resize.
-            .unwrap_or(true);
-
-        // NOTE: Set the configure before doing a resize, since we query it during it.
+        // XXX Set the configure before doing a resize.
         self.last_configure = Some(configure);
 
-        if state_change_requires_resize || new_size != self.inner_size() {
-            self.resize(new_size);
-            Some(new_size)
-        } else {
-            None
-        }
-    }
+        // XXX Update the new size right away.
+        self.resize(new_size);
 
-    /// Compute the bounds for the inner size of the surface.
-    fn inner_size_bounds(
-        &self,
-        configure: &WindowConfigure,
-    ) -> (Option<NonZeroU32>, Option<NonZeroU32>) {
-        let configure_bounds = match configure.suggested_bounds {
-            Some((width, height)) => (NonZeroU32::new(width), NonZeroU32::new(height)),
-            None => (None, None),
-        };
-
-        if let Some(frame) = self.frame.as_ref() {
-            let (width, height) = frame.subtract_borders(
-                configure_bounds.0.unwrap_or(NonZeroU32::new(1).unwrap()),
-                configure_bounds.1.unwrap_or(NonZeroU32::new(1).unwrap()),
-            );
-            (
-                configure_bounds.0.and(width),
-                configure_bounds.1.and(height),
-            )
-        } else {
-            configure_bounds
-        }
+        new_size
     }
 
     #[inline]
@@ -605,7 +537,7 @@ impl WindowState {
     /// Refresh the decorations frame if it's present returning whether the client should redraw.
     pub fn refresh_frame(&mut self) -> bool {
         if let Some(frame) = self.frame.as_mut() {
-            if !frame.is_hidden() && frame.is_dirty() {
+            if frame.is_dirty() {
                 return frame.draw();
             }
         }
@@ -636,22 +568,8 @@ impl WindowState {
         }
     }
 
-    /// Try to resize the window when the user can do so.
-    pub fn request_inner_size(&mut self, inner_size: Size) -> PhysicalSize<u32> {
-        if self
-            .last_configure
-            .as_ref()
-            .map(Self::is_stateless)
-            .unwrap_or(true)
-        {
-            self.resize(inner_size.to_logical(self.scale_factor()))
-        }
-
-        self.inner_size().to_physical(self.scale_factor())
-    }
-
     /// Resize the window to the new inner size.
-    fn resize(&mut self, inner_size: LogicalSize<u32>) {
+    pub fn resize(&mut self, inner_size: LogicalSize<u32>) {
         self.size = inner_size;
 
         // Update the stateless size.
@@ -925,7 +843,7 @@ impl WindowState {
 
     /// Set the IME position.
     pub fn set_ime_cursor_area(&self, position: LogicalPosition<u32>, size: LogicalSize<u32>) {
-        // FIXME: This won't fly unless user will have a way to request IME window per seat, since
+        // XXX This won't fly unless user will have a way to request IME window per seat, since
         // the ime windows will be overlapping, but winit doesn't expose API to specify for
         // which seat we're setting IME position.
         let (x, y) = (position.x as i32, position.y as i32);
@@ -956,7 +874,7 @@ impl WindowState {
     pub fn set_scale_factor(&mut self, scale_factor: f64) {
         self.scale_factor = scale_factor;
 
-        // NOTE: When fractional scaling is not used update the buffer scale.
+        // XXX when fractional scaling is not used update the buffer scale.
         if self.fractional_scale.is_none() {
             let _ = self.window.set_buffer_scale(self.scale_factor as _);
         }
@@ -1041,6 +959,13 @@ impl WindowState {
 
 impl Drop for WindowState {
     fn drop(&mut self) {
+        let surface = self.window.wl_surface().clone();
+        unsafe {
+            ManuallyDrop::drop(&mut self.window);
+        }
+
+        // Cleanup objects.
+
         if let Some(blur) = self.blur.take() {
             blur.release();
         }
@@ -1053,8 +978,7 @@ impl Drop for WindowState {
             viewport.destroy();
         }
 
-        // NOTE: the wl_surface used by the window is being cleaned up when
-        // dropping SCTK `Window`.
+        surface.destroy();
     }
 }
 
@@ -1104,7 +1028,7 @@ impl From<ResizeDirection> for XdgResizeEdge {
     }
 }
 
-// NOTE: Rust doesn't allow `From<Option<Theme>>`.
+// XXX rust doesn't allow from `Option`.
 #[cfg(feature = "sctk-adwaita")]
 fn into_sctk_adwaita_config(theme: Option<Theme>) -> sctk_adwaita::FrameConfig {
     match theme {

src/platform_impl/linux/x11/event_processor.rs

@@ -484,7 +484,6 @@ impl<T: 'static> EventProcessor<T> {
                     }
 
                     let mut shared_state_lock = window.shared_state_lock();
-                    let hittest = shared_state_lock.cursor_hittest;
 
                     // This is a hack to ensure that the DPI adjusted resize is actually applied on all WMs. KWin
                     // doesn't need this, but Xfwm does. The hack should not be run on other WMs, since tiling
@@ -502,11 +501,6 @@ impl<T: 'static> EventProcessor<T> {
                     // Unlock shared state to prevent deadlock in callback below
                     drop(shared_state_lock);
 
-                    // Reload hittest.
-                    if hittest.unwrap_or(false) {
-                        let _ = window.set_cursor_hittest(true);
-                    }
-
                     if resized {
                         callback(Event::WindowEvent {
                             window_id,
@@ -570,14 +564,6 @@ impl<T: 'static> EventProcessor<T> {
                     event: WindowEvent::Destroyed,
                 });
             }
-            ffi::PropertyNotify => {
-                let xev: &ffi::XPropertyEvent = xev.as_ref();
-                let atom = xev.atom as xproto::Atom;
-
-                if atom == xproto::Atom::from(xproto::AtomEnum::RESOURCE_MANAGER) {
-                    self.process_dpi_change(&mut callback);
-                }
-            }
 
             ffi::VisibilityNotify => {
                 let xev: &ffi::XVisibilityEvent = xev.as_ref();
@@ -1215,7 +1201,7 @@ impl<T: 'static> EventProcessor<T> {
                         if keycode < KEYCODE_OFFSET as u32 {
                             return;
                         }
-                        let physical_key = keymap::raw_keycode_to_physicalkey(keycode);
+                        let physical_key = keymap::raw_keycode_to_keycode(keycode);
 
                         callback(Event::DeviceEvent {
                             device_id,
@@ -1314,7 +1300,72 @@ impl<T: 'static> EventProcessor<T> {
                     }
                 }
                 if event_type == self.randr_event_offset as c_int {
-                    self.process_dpi_change(&mut callback);
+                    // In the future, it would be quite easy to emit monitor hotplug events.
+                    let prev_list = wt.xconn.invalidate_cached_monitor_list();
+                    if let Some(prev_list) = prev_list {
+                        let new_list = wt
+                            .xconn
+                            .available_monitors()
+                            .expect("Failed to get monitor list");
+                        for new_monitor in new_list {
+                            // Previous list may be empty, in case of disconnecting and
+                            // reconnecting the only one monitor. We still need to emit events in
+                            // this case.
+                            let maybe_prev_scale_factor = prev_list
+                                .iter()
+                                .find(|prev_monitor| prev_monitor.name == new_monitor.name)
+                                .map(|prev_monitor| prev_monitor.scale_factor);
+                            if Some(new_monitor.scale_factor) != maybe_prev_scale_factor {
+                                for (window_id, window) in wt.windows.borrow().iter() {
+                                    if let Some(window) = window.upgrade() {
+                                        // Check if the window is on this monitor
+                                        let monitor =
+                                            window.shared_state_lock().last_monitor.clone();
+                                        if monitor.name == new_monitor.name {
+                                            let (width, height) = window.inner_size_physical();
+                                            let (new_width, new_height) = window.adjust_for_dpi(
+                                                // If we couldn't determine the previous scale
+                                                // factor (e.g., because all monitors were closed
+                                                // before), just pick whatever the current monitor
+                                                // has set as a baseline.
+                                                maybe_prev_scale_factor
+                                                    .unwrap_or(monitor.scale_factor),
+                                                new_monitor.scale_factor,
+                                                width,
+                                                height,
+                                                &window.shared_state_lock(),
+                                            );
+
+                                            let window_id = crate::window::WindowId(*window_id);
+                                            let old_inner_size = PhysicalSize::new(width, height);
+                                            let inner_size = Arc::new(Mutex::new(
+                                                PhysicalSize::new(new_width, new_height),
+                                            ));
+                                            callback(Event::WindowEvent {
+                                                window_id,
+                                                event: WindowEvent::ScaleFactorChanged {
+                                                    scale_factor: new_monitor.scale_factor,
+                                                    inner_size_writer: InnerSizeWriter::new(
+                                                        Arc::downgrade(&inner_size),
+                                                    ),
+                                                },
+                                            });
+
+                                            let new_inner_size = *inner_size.lock().unwrap();
+                                            drop(inner_size);
+
+                                            if new_inner_size != old_inner_size {
+                                                let (new_width, new_height) = new_inner_size.into();
+                                                window.request_inner_size_physical(
+                                                    new_width, new_height,
+                                                );
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
@@ -1407,45 +1458,6 @@ impl<T: 'static> EventProcessor<T> {
             });
         }
     }
-
-    fn process_dpi_change<F>(&self, callback: &mut F)
-    where
-        F: FnMut(Event<T>),
-    {
-        let wt = get_xtarget(&self.target);
-
-        // In the future, it would be quite easy to emit monitor hotplug events.
-        let prev_list = {
-            let prev_list = wt.xconn.invalidate_cached_monitor_list();
-            match prev_list {
-                Some(prev_list) => prev_list,
-                None => return,
-            }
-        };
-
-        let new_list = wt
-            .xconn
-            .available_monitors()
-            .expect("Failed to get monitor list");
-        for new_monitor in new_list {
-            // Previous list may be empty, in case of disconnecting and
-            // reconnecting the only one monitor. We still need to emit events in
-            // this case.
-            let maybe_prev_scale_factor = prev_list
-                .iter()
-                .find(|prev_monitor| prev_monitor.name == new_monitor.name)
-                .map(|prev_monitor| prev_monitor.scale_factor);
-            if Some(new_monitor.scale_factor) != maybe_prev_scale_factor {
-                for window in wt.windows.borrow().iter().filter_map(|(_, w)| w.upgrade()) {
-                    window.refresh_dpi_for_monitor(
-                        &new_monitor,
-                        maybe_prev_scale_factor,
-                        &mut *callback,
-                    )
-                }
-            }
-        }
-    }
 }
 
 fn is_first_touch(first: &mut Option<u64>, num: &mut u32, id: u64, phase: TouchPhase) -> bool {

src/platform_impl/linux/x11/ffi.rs

@@ -1 +1,8 @@
-pub use x11_dl::{error::OpenError, xcursor::*, xinput2::*, xlib::*, xlib_xcb::*};
+use x11_dl::xmd::CARD32;
+pub use x11_dl::{
+    error::OpenError, keysym::*, xcursor::*, xinput::*, xinput2::*, xlib::*, xlib_xcb::*,
+};
+
+// Isn't defined by x11_dl
+#[allow(non_upper_case_globals)]
+pub const IconicState: CARD32 = 3;

src/platform_impl/linux/x11/mod.rs

@@ -32,7 +32,7 @@ use std::{
     ops::Deref,
     os::{
         raw::*,
-        unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd},
+        unix::io::{AsRawFd, BorrowedFd},
     },
     ptr,
     rc::Rc,
@@ -81,7 +81,6 @@ use crate::{
 // Xinput constants not defined in x11rb
 const ALL_DEVICES: u16 = 0;
 const ALL_MASTER_DEVICES: u16 = 1;
-const ICONIC_STATE: u32 = 3;
 
 type X11Source = Generic<BorrowedFd<'static>>;
 
@@ -659,18 +658,6 @@ 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(crate) fn get_xtarget<T>(target: &RootELW<T>) -> &EventLoopWindowTarget<T> {
     match target.p {
         super::EventLoopWindowTarget::X(ref target) => target,
@@ -752,10 +739,6 @@ impl<T> EventLoopWindowTarget<T> {
         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()
     }
@@ -1133,9 +1116,3 @@ impl Device {
         }
     }
 }
-
-/// Convert the raw X11 representation for a 32-bit floating point to a double.
-#[inline]
-fn xinput_fp1616_to_float(fp: xinput::Fp1616) -> f64 {
-    (fp as f64) / ((1 << 16) as f64)
-}

src/platform_impl/linux/x11/monitor.rs

@@ -212,7 +212,7 @@ impl XConnection {
             return Ok(MonitorHandle::dummy());
         }
 
-        let default = monitors.first().unwrap();
+        let default = monitors.get(0).unwrap();
 
         let window_rect = match window_rect {
             Some(rect) => rect,
@@ -284,16 +284,22 @@ impl XConnection {
 
     pub fn available_monitors(&self) -> Result<Vec<MonitorHandle>, X11Error> {
         let mut monitors_lock = self.monitor_handles.lock().unwrap();
-        match *monitors_lock {
-            Some(ref monitors) => Ok(monitors.clone()),
-            None => {
-                let monitors = self.query_monitor_list()?;
-                if !DISABLE_MONITOR_LIST_CACHING {
-                    *monitors_lock = Some(monitors.clone());
-                }
-                Ok(monitors)
-            }
-        }
+        (*monitors_lock)
+            .as_ref()
+            .cloned()
+            .map(Ok)
+            .or_else(|| {
+                self.query_monitor_list()
+                    .map(|mon_list| {
+                        let monitors = Some(mon_list);
+                        if !DISABLE_MONITOR_LIST_CACHING {
+                            (*monitors_lock) = monitors.clone();
+                        }
+                        monitors
+                    })
+                    .transpose()
+            })
+            .unwrap()
     }
 
     #[inline]

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

@@ -1,5 +1,4 @@
 use std::ffi::CString;
-use std::iter;
 
 use x11rb::connection::Connection;
 
@@ -57,22 +56,10 @@ impl XConnection {
             None => return self.create_empty_cursor(),
         };
 
-        let mut xcursor = 0;
-        for &name in iter::once(&cursor.name()).chain(cursor.alt_names().iter()) {
-            let name = CString::new(name).unwrap();
-            xcursor = unsafe {
-                (self.xcursor.XcursorLibraryLoadCursor)(
-                    self.display,
-                    name.as_ptr() as *const c_char,
-                )
-            };
-
-            if xcursor != 0 {
-                break;
-            }
+        let name = CString::new(cursor.name()).unwrap();
+        unsafe {
+            (self.xcursor.XcursorLibraryLoadCursor)(self.display, name.as_ptr() as *const c_char)
         }
-
-        xcursor
     }
 
     fn update_cursor(&self, window: xproto::Window, cursor: ffi::Cursor) -> Result<(), X11Error> {

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

@@ -13,7 +13,9 @@ mod randr;
 mod window_property;
 mod wm;
 
-pub use self::{geometry::*, hint::*, input::*, window_property::*, wm::*};
+pub use self::{
+    client_msg::*, geometry::*, hint::*, icon::*, input::*, randr::*, window_property::*, wm::*,
+};
 
 use std::{
     mem::{self, MaybeUninit},

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

@@ -38,7 +38,7 @@ impl XConnection {
     // Retrieve DPI from Xft.dpi property
     pub fn get_xft_dpi(&self) -> Option<f64> {
         self.database()
-            .get_string("Xft.dpi", "")
+            .get_string("Xfi.dpi", "")
             .and_then(|s| f64::from_str(s).ok())
     }
     pub fn get_output_info(

src/platform_impl/linux/x11/window.rs

@@ -22,13 +22,9 @@ use x11rb::{
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize, Position, Size},
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
-    event::{Event, InnerSizeWriter, WindowEvent},
     event_loop::AsyncRequestSerial,
     platform_impl::{
-        x11::{
-            atoms::*, xinput_fp1616_to_float, MonitorHandle as X11MonitorHandle, WakeSender,
-            X11Error,
-        },
+        x11::{atoms::*, MonitorHandle as X11MonitorHandle, WakeSender, X11Error},
         Fullscreen, MonitorHandle as PlatformMonitorHandle, OsError, PlatformIcon,
         PlatformSpecificWindowBuilderAttributes, VideoMode as PlatformVideoMode,
     },
@@ -68,8 +64,7 @@ pub struct SharedState {
     pub base_size: Option<Size>,
     pub visibility: Visibility,
     pub has_focus: bool,
-    // Use `Option` to not apply hittest logic when it was never requested.
-    pub cursor_hittest: Option<bool>,
+    pub cursor_hittest: bool,
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -110,7 +105,7 @@ impl SharedState {
             resize_increments: None,
             base_size: None,
             has_focus: false,
-            cursor_hittest: None,
+            cursor_hittest: true,
         })
     }
 }
@@ -155,7 +150,7 @@ impl UnownedWindow {
         let xconn = &event_loop.xconn;
         let atoms = xconn.atoms();
         #[cfg(feature = "rwh_06")]
-        let root = match window_attrs.parent_window.0 {
+        let root = match window_attrs.parent_window {
             Some(rwh_06::RawWindowHandle::Xlib(handle)) => handle.window as xproto::Window,
             Some(rwh_06::RawWindowHandle::Xcb(handle)) => handle.window.get(),
             Some(raw) => unreachable!("Invalid raw window handle {raw:?} on X11"),
@@ -280,8 +275,7 @@ impl UnownedWindow {
                 | EventMask::KEYMAP_STATE
                 | EventMask::BUTTON_PRESS
                 | EventMask::BUTTON_RELEASE
-                | EventMask::POINTER_MOTION
-                | EventMask::PROPERTY_CHANGE;
+                | EventMask::POINTER_MOTION;
 
             aux = aux.event_mask(event_mask).border_pixel(0);
 
@@ -553,10 +547,10 @@ impl UnownedWindow {
             if window_attrs.maximized {
                 leap!(window.set_maximized_inner(window_attrs.maximized)).ignore_error();
             }
-            if window_attrs.fullscreen.0.is_some() {
+            if window_attrs.fullscreen.is_some() {
                 if let Some(flusher) =
                     leap!(window
-                        .set_fullscreen_inner(window_attrs.fullscreen.0.clone().map(Into::into)))
+                        .set_fullscreen_inner(window_attrs.fullscreen.clone().map(Into::into)))
                 {
                     flusher.ignore_error()
                 }
@@ -928,51 +922,6 @@ impl UnownedWindow {
         })
     }
 
-    /// Refresh the API for the given monitor.
-    #[inline]
-    pub(super) fn refresh_dpi_for_monitor<T: 'static>(
-        &self,
-        new_monitor: &X11MonitorHandle,
-        maybe_prev_scale_factor: Option<f64>,
-        mut callback: impl FnMut(Event<T>),
-    ) {
-        // Check if the self is on this monitor
-        let monitor = self.shared_state_lock().last_monitor.clone();
-        if monitor.name == new_monitor.name {
-            let (width, height) = self.inner_size_physical();
-            let (new_width, new_height) = self.adjust_for_dpi(
-                // If we couldn't determine the previous scale
-                // factor (e.g., because all monitors were closed
-                // before), just pick whatever the current monitor
-                // has set as a baseline.
-                maybe_prev_scale_factor.unwrap_or(monitor.scale_factor),
-                new_monitor.scale_factor,
-                width,
-                height,
-                &self.shared_state_lock(),
-            );
-
-            let window_id = crate::window::WindowId(self.id());
-            let old_inner_size = PhysicalSize::new(width, height);
-            let inner_size = Arc::new(Mutex::new(PhysicalSize::new(new_width, new_height)));
-            callback(Event::WindowEvent {
-                window_id,
-                event: WindowEvent::ScaleFactorChanged {
-                    scale_factor: new_monitor.scale_factor,
-                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&inner_size)),
-                },
-            });
-
-            let new_inner_size = *inner_size.lock().unwrap();
-            drop(inner_size);
-
-            if new_inner_size != old_inner_size {
-                let (new_width, new_height) = new_inner_size.into();
-                self.request_inner_size_physical(new_width, new_height);
-            }
-        }
-    }
-
     fn set_minimized_inner(&self, minimized: bool) -> Result<VoidCookie<'_>, X11Error> {
         let atoms = self.xconn.atoms();
 
@@ -1346,8 +1295,8 @@ impl UnownedWindow {
         self.xconn
             .flush_requests()
             .expect("Failed to call XResizeWindow");
-        // cursor_hittest needs to be reapplied after each window resize.
-        if self.shared_state_lock().cursor_hittest.unwrap_or(false) {
+        // cursor_hittest needs to be reapplied after window resize
+        if self.shared_state_lock().cursor_hittest {
             let _ = self.set_cursor_hittest(true);
         }
     }
@@ -1377,8 +1326,7 @@ impl UnownedWindow {
             self.xwindow as xproto::Window,
             xproto::AtomEnum::WM_NORMAL_HINTS,
         )?
-        .reply()?
-        .unwrap_or_default();
+        .reply()?;
         callback(&mut normal_hints);
         normal_hints
             .set(
@@ -1431,7 +1379,6 @@ impl UnownedWindow {
         )
         .ok()
         .and_then(|cookie| cookie.reply().ok())
-        .flatten()
         .and_then(|hints| hints.size_increment)
         .map(|(width, height)| (width as u32, height as u32).into())
     }
@@ -1680,7 +1627,7 @@ impl UnownedWindow {
             .xcb_connection()
             .xfixes_set_window_shape_region(self.xwindow, SK::INPUT, 0, 0, region.region())
             .map_err(|_e| ExternalError::Ignored)?;
-        self.shared_state_lock().cursor_hittest = Some(hittest);
+        self.shared_state_lock().cursor_hittest = hittest;
         Ok(())
     }
 
@@ -1744,8 +1691,8 @@ impl UnownedWindow {
                         | xproto::EventMask::SUBSTRUCTURE_NOTIFY,
                 ),
                 [
-                    (window.x as u32 + xinput_fp1616_to_float(pointer.win_x) as u32),
-                    (window.y as u32 + xinput_fp1616_to_float(pointer.win_y) as u32),
+                    (window.x as u32 + pointer.win_x as u32),
+                    (window.y as u32 + pointer.win_y as u32),
                     action.try_into().unwrap(),
                     1, // Button 1
                     1,
@@ -1787,9 +1734,9 @@ impl UnownedWindow {
         let state_type_atom = atoms[CARD32];
         let is_minimized = if let Ok(state) =
             self.xconn
-                .get_property::<u32>(self.xwindow, state_atom, state_type_atom)
+                .get_property(self.xwindow, state_atom, state_type_atom)
         {
-            state.contains(&super::ICONIC_STATE)
+            state.contains(&(ffi::IconicState as c_ulong))
         } else {
             false
         };
@@ -1826,7 +1773,6 @@ impl UnownedWindow {
             WmHints::get(self.xconn.xcb_connection(), self.xwindow as xproto::Window)
                 .ok()
                 .and_then(|cookie| cookie.reply().ok())
-                .flatten()
                 .unwrap_or_default();
 
         wm_hints.urgent = request_type.is_some();

src/platform_impl/macos/app_state.rs

@@ -209,10 +209,6 @@ impl Handler {
         self.exit.store(true, Ordering::Relaxed)
     }
 
-    pub fn clear_exit(&self) {
-        self.exit.store(false, Ordering::Relaxed)
-    }
-
     pub fn exiting(&self) -> bool {
         self.exit.load(Ordering::Relaxed)
     }
@@ -333,7 +329,7 @@ impl Handler {
     ) {
         if let Some(ref mut callback) = *self.callback.lock().unwrap() {
             let new_inner_size = Arc::new(Mutex::new(suggested_size));
-            let scale_factor_changed_event = Event::WindowEvent {
+            let event = Event::WindowEvent {
                 window_id: WindowId(window.id()),
                 event: WindowEvent::ScaleFactorChanged {
                     scale_factor,
@@ -341,19 +337,13 @@ impl Handler {
                 },
             };
 
-            callback.handle_nonuser_event(scale_factor_changed_event);
+            callback.handle_nonuser_event(event);
 
             let physical_size = *new_inner_size.lock().unwrap();
             drop(new_inner_size);
             let logical_size = physical_size.to_logical(scale_factor);
             let size = NSSize::new(logical_size.width, logical_size.height);
             window.setContentSize(size);
-
-            let resized_event = Event::WindowEvent {
-                window_id: WindowId(window.id()),
-                event: WindowEvent::Resized(physical_size),
-            };
-            callback.handle_nonuser_event(resized_event);
         }
     }
 }
@@ -438,10 +428,6 @@ impl AppState {
         HANDLER.exit()
     }
 
-    pub fn clear_exit() {
-        HANDLER.clear_exit()
-    }
-
     pub fn exiting() -> bool {
         HANDLER.exiting()
     }
@@ -508,9 +494,9 @@ impl AppState {
 
         // Return when in callback due to https://github.com/rust-windowing/winit/issues/1779
         if panic_info.is_panicking()
-            || HANDLER.get_in_callback()
             || !HANDLER.have_callback()
             || !HANDLER.is_running()
+            || HANDLER.get_in_callback()
         {
             return;
         }
@@ -615,9 +601,9 @@ impl AppState {
         // XXX: how does it make sense that `get_in_callback()` can ever return `true` here if we're
         // about to return to the `CFRunLoop` to poll for new events?
         if panic_info.is_panicking()
-            || HANDLER.get_in_callback()
             || !HANDLER.have_callback()
             || !HANDLER.is_running()
+            || HANDLER.get_in_callback()
         {
             return;
         }

src/platform_impl/macos/appkit/tab_group.rs

@@ -23,7 +23,7 @@ extern_methods!(
         pub fn selectPreviousTab(&self);
 
         #[method_id(windows)]
-        pub fn tabbedWindows(&self) -> Option<Id<NSArray<NSWindow>>>;
+        pub fn tabbedWindows(&self) -> Id<NSArray<NSWindow>>;
 
         #[method(setSelectedWindow:)]
         pub fn setSelectedWindow(&self, window: &NSWindow);

src/platform_impl/macos/appkit/window.rs

@@ -36,9 +36,6 @@ extern_methods!(
         #[method(frame)]
         pub(crate) fn frame(&self) -> NSRect;
 
-        #[method(windowNumber)]
-        pub(crate) fn windowNumber(&self) -> NSInteger;
-
         #[method(backingScaleFactor)]
         pub(crate) fn backingScaleFactor(&self) -> CGFloat;
 
@@ -221,7 +218,7 @@ extern_methods!(
         pub(crate) fn tabbingIdentifier(&self) -> Id<NSString>;
 
         #[method_id(tabGroup)]
-        pub(crate) fn tabGroup(&self) -> Option<Id<NSWindowTabGroup>>;
+        pub(crate) fn tabGroup(&self) -> Id<NSWindowTabGroup>;
 
         #[method(isDocumentEdited)]
         pub(crate) fn isDocumentEdited(&self) -> bool;

src/platform_impl/macos/event.rs

@@ -11,12 +11,9 @@ use super::appkit::{NSEvent, NSEventModifierFlags};
 use crate::{
     event::{ElementState, KeyEvent, Modifiers},
     keyboard::{
-        Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey,
-        NativeKeyCode, PhysicalKey,
-    },
-    platform::{
-        modifier_supplement::KeyEventExtModifierSupplement, scancode::PhysicalKeyExtScancode,
+        Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NativeKey, NativeKeyCode,
     },
+    platform::{modifier_supplement::KeyEventExtModifierSupplement, scancode::KeyCodeExtScancode},
     platform_impl::platform::ffi,
 };
 
@@ -88,9 +85,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
         return Key::Unidentified(NativeKey::MacOS(scancode));
     }
     if result_len == 0 {
-        // This is fine - not all keys have text representation.
-        // For instance, users that have mapped the `Fn` key to toggle
-        // keyboard layouts will hit this code path.
+        log::error!("`UCKeyTranslate` was succesful but gave a string of 0 length.");
         return Key::Unidentified(NativeKey::MacOS(scancode));
     }
     let chars = String::from_utf16_lossy(&string[0..result_len as usize]);
@@ -117,14 +112,13 @@ pub(crate) fn create_key_event(
     ns_event: &NSEvent,
     is_press: bool,
     is_repeat: bool,
-    key_override: Option<PhysicalKey>,
+    key_override: Option<KeyCode>,
 ) -> KeyEvent {
     use ElementState::{Pressed, Released};
     let state = if is_press { Pressed } else { Released };
 
     let scancode = ns_event.key_code();
-    let mut physical_key =
-        key_override.unwrap_or_else(|| PhysicalKey::from_scancode(scancode as u32));
+    let mut physical_key = key_override.unwrap_or_else(|| KeyCode::from_scancode(scancode as u32));
 
     let text_with_all_modifiers: Option<SmolStr> = if key_override.is_some() {
         None
@@ -136,7 +130,7 @@ pub(crate) fn create_key_event(
         if characters.is_empty() {
             None
         } else {
-            if matches!(physical_key, PhysicalKey::Unidentified(_)) {
+            if matches!(physical_key, KeyCode::Unidentified(_)) {
                 // The key may be one of the funky function keys
                 physical_key = extra_function_key_to_code(scancode, &characters);
             }
@@ -158,11 +152,13 @@ pub(crate) fn create_key_event(
             // Also not checking if this is a release event because then this issue would
             // still affect the key release.
             Some(text) if !has_ctrl => Key::Character(text.clone()),
-            _ => match key_without_modifiers.as_ref() {
-                Key::Character(ch) => get_logical_key_char(ns_event, ch),
-                // Don't try to get text for events which likely don't have it.
-                _ => key_without_modifiers.clone(),
-            },
+            _ => {
+                let modifierless_chars = match key_without_modifiers.as_ref() {
+                    Key::Character(ch) => ch,
+                    _ => "",
+                };
+                get_logical_key_char(ns_event, modifierless_chars)
+            }
         };
 
         (logical_key, key_without_modifiers)
@@ -192,75 +188,65 @@ pub(crate) fn create_key_event(
     }
 }
 
-pub fn code_to_key(key: PhysicalKey, scancode: u16) -> Key {
-    let code = match key {
-        PhysicalKey::Code(code) => code,
-        PhysicalKey::Unidentified(code) => return Key::Unidentified(code.into()),
-    };
+pub fn code_to_key(code: KeyCode, scancode: u16) -> Key {
+    match code {
+        KeyCode::Enter => Key::Enter,
+        KeyCode::Tab => Key::Tab,
+        KeyCode::Space => Key::Space,
+        KeyCode::Backspace => Key::Backspace,
+        KeyCode::Escape => Key::Escape,
+        KeyCode::SuperRight => Key::Super,
+        KeyCode::SuperLeft => Key::Super,
+        KeyCode::ShiftLeft => Key::Shift,
+        KeyCode::AltLeft => Key::Alt,
+        KeyCode::ControlLeft => Key::Control,
+        KeyCode::ShiftRight => Key::Shift,
+        KeyCode::AltRight => Key::Alt,
+        KeyCode::ControlRight => Key::Control,
 
-    Key::Named(match code {
-        KeyCode::Enter => NamedKey::Enter,
-        KeyCode::Tab => NamedKey::Tab,
-        KeyCode::Space => NamedKey::Space,
-        KeyCode::Backspace => NamedKey::Backspace,
-        KeyCode::Escape => NamedKey::Escape,
-        KeyCode::SuperRight => NamedKey::Super,
-        KeyCode::SuperLeft => NamedKey::Super,
-        KeyCode::ShiftLeft => NamedKey::Shift,
-        KeyCode::AltLeft => NamedKey::Alt,
-        KeyCode::ControlLeft => NamedKey::Control,
-        KeyCode::ShiftRight => NamedKey::Shift,
-        KeyCode::AltRight => NamedKey::Alt,
-        KeyCode::ControlRight => NamedKey::Control,
-
-        KeyCode::NumLock => NamedKey::NumLock,
-        KeyCode::AudioVolumeUp => NamedKey::AudioVolumeUp,
-        KeyCode::AudioVolumeDown => NamedKey::AudioVolumeDown,
+        KeyCode::NumLock => Key::NumLock,
+        KeyCode::AudioVolumeUp => Key::AudioVolumeUp,
+        KeyCode::AudioVolumeDown => Key::AudioVolumeDown,
 
         // Other numpad keys all generate text on macOS (if I understand correctly)
-        KeyCode::NumpadEnter => NamedKey::Enter,
+        KeyCode::NumpadEnter => Key::Enter,
 
-        KeyCode::F1 => NamedKey::F1,
-        KeyCode::F2 => NamedKey::F2,
-        KeyCode::F3 => NamedKey::F3,
-        KeyCode::F4 => NamedKey::F4,
-        KeyCode::F5 => NamedKey::F5,
-        KeyCode::F6 => NamedKey::F6,
-        KeyCode::F7 => NamedKey::F7,
-        KeyCode::F8 => NamedKey::F8,
-        KeyCode::F9 => NamedKey::F9,
-        KeyCode::F10 => NamedKey::F10,
-        KeyCode::F11 => NamedKey::F11,
-        KeyCode::F12 => NamedKey::F12,
-        KeyCode::F13 => NamedKey::F13,
-        KeyCode::F14 => NamedKey::F14,
-        KeyCode::F15 => NamedKey::F15,
-        KeyCode::F16 => NamedKey::F16,
-        KeyCode::F17 => NamedKey::F17,
-        KeyCode::F18 => NamedKey::F18,
-        KeyCode::F19 => NamedKey::F19,
-        KeyCode::F20 => NamedKey::F20,
+        KeyCode::F1 => Key::F1,
+        KeyCode::F2 => Key::F2,
+        KeyCode::F3 => Key::F3,
+        KeyCode::F4 => Key::F4,
+        KeyCode::F5 => Key::F5,
+        KeyCode::F6 => Key::F6,
+        KeyCode::F7 => Key::F7,
+        KeyCode::F8 => Key::F8,
+        KeyCode::F9 => Key::F9,
+        KeyCode::F10 => Key::F10,
+        KeyCode::F11 => Key::F11,
+        KeyCode::F12 => Key::F12,
+        KeyCode::F13 => Key::F13,
+        KeyCode::F14 => Key::F14,
+        KeyCode::F15 => Key::F15,
+        KeyCode::F16 => Key::F16,
+        KeyCode::F17 => Key::F17,
+        KeyCode::F18 => Key::F18,
+        KeyCode::F19 => Key::F19,
+        KeyCode::F20 => Key::F20,
 
-        KeyCode::Insert => NamedKey::Insert,
-        KeyCode::Home => NamedKey::Home,
-        KeyCode::PageUp => NamedKey::PageUp,
-        KeyCode::Delete => NamedKey::Delete,
-        KeyCode::End => NamedKey::End,
-        KeyCode::PageDown => NamedKey::PageDown,
-        KeyCode::ArrowLeft => NamedKey::ArrowLeft,
-        KeyCode::ArrowRight => NamedKey::ArrowRight,
-        KeyCode::ArrowDown => NamedKey::ArrowDown,
-        KeyCode::ArrowUp => NamedKey::ArrowUp,
-        _ => return Key::Unidentified(NativeKey::MacOS(scancode)),
-    })
+        KeyCode::Insert => Key::Insert,
+        KeyCode::Home => Key::Home,
+        KeyCode::PageUp => Key::PageUp,
+        KeyCode::Delete => Key::Delete,
+        KeyCode::End => Key::End,
+        KeyCode::PageDown => Key::PageDown,
+        KeyCode::ArrowLeft => Key::ArrowLeft,
+        KeyCode::ArrowRight => Key::ArrowRight,
+        KeyCode::ArrowDown => Key::ArrowDown,
+        KeyCode::ArrowUp => Key::ArrowUp,
+        _ => Key::Unidentified(NativeKey::MacOS(scancode)),
+    }
 }
 
-pub fn code_to_location(key: PhysicalKey) -> KeyLocation {
-    let code = match key {
-        PhysicalKey::Code(code) => code,
-        PhysicalKey::Unidentified(_) => return KeyLocation::Standard,
-    };
-
+pub fn code_to_location(code: KeyCode) -> KeyLocation {
     match code {
         KeyCode::SuperRight => KeyLocation::Right,
         KeyCode::SuperLeft => KeyLocation::Left,
@@ -297,17 +283,17 @@ pub fn code_to_location(key: PhysicalKey) -> KeyLocation {
 // While F1-F20 have scancodes we can match on, we have to check against UTF-16
 // constants for the rest.
 // https://developer.apple.com/documentation/appkit/1535851-function-key_unicodes?preferredLanguage=occ
-pub fn extra_function_key_to_code(scancode: u16, string: &str) -> PhysicalKey {
+pub fn extra_function_key_to_code(scancode: u16, string: &str) -> KeyCode {
     if let Some(ch) = string.encode_utf16().next() {
         match ch {
-            0xf718 => PhysicalKey::Code(KeyCode::F21),
-            0xf719 => PhysicalKey::Code(KeyCode::F22),
-            0xf71a => PhysicalKey::Code(KeyCode::F23),
-            0xf71b => PhysicalKey::Code(KeyCode::F24),
-            _ => PhysicalKey::Unidentified(NativeKeyCode::MacOS(scancode)),
+            0xf718 => KeyCode::F21,
+            0xf719 => KeyCode::F22,
+            0xf71a => KeyCode::F23,
+            0xf71b => KeyCode::F24,
+            _ => KeyCode::Unidentified(NativeKeyCode::MacOS(scancode)),
         }
     } else {
-        PhysicalKey::Unidentified(NativeKeyCode::MacOS(scancode))
+        KeyCode::Unidentified(NativeKeyCode::MacOS(scancode))
     }
 }
 
@@ -354,14 +340,9 @@ pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
     }
 }
 
-impl PhysicalKeyExtScancode for PhysicalKey {
+impl KeyCodeExtScancode for KeyCode {
     fn to_scancode(self) -> Option<u32> {
-        let code = match self {
-            PhysicalKey::Code(code) => code,
-            PhysicalKey::Unidentified(_) => return None,
-        };
-
-        match code {
+        match self {
             KeyCode::KeyA => Some(0x00),
             KeyCode::KeyS => Some(0x01),
             KeyCode::KeyD => Some(0x02),
@@ -477,8 +458,8 @@ impl PhysicalKeyExtScancode for PhysicalKey {
         }
     }
 
-    fn from_scancode(scancode: u32) -> PhysicalKey {
-        PhysicalKey::Code(match scancode {
+    fn from_scancode(scancode: u32) -> KeyCode {
+        match scancode {
             0x00 => KeyCode::KeyA,
             0x01 => KeyCode::KeyS,
             0x02 => KeyCode::KeyD,
@@ -615,7 +596,7 @@ impl PhysicalKeyExtScancode for PhysicalKey {
             // 0xA is the caret (^) an macOS's German QERTZ layout. This key is at the same location as
             // backquote (`) on Windows' US layout.
             0xa => KeyCode::Backquote,
-            _ => return PhysicalKey::Unidentified(NativeKeyCode::MacOS(scancode as u16)),
-        })
+            _ => KeyCode::Unidentified(NativeKeyCode::MacOS(scancode as u16)),
+        }
     }
 }

src/platform_impl/macos/event_loop.rs

@@ -116,10 +116,6 @@ impl<T: 'static> EventLoopWindowTarget<T> {
         AppState::exit()
     }
 
-    pub(crate) fn clear_exit(&self) {
-        AppState::clear_exit()
-    }
-
     pub(crate) fn exiting(&self) -> bool {
         AppState::exiting()
     }

src/platform_impl/macos/ffi.rs

@@ -11,7 +11,6 @@ use core_graphics::{
     base::CGError,
     display::{CGDirectDisplayID, CGDisplayConfigRef},
 };
-use objc2::{ffi::NSInteger, runtime::AnyObject};
 
 pub type CGDisplayFadeInterval = f32;
 pub type CGDisplayReservationInterval = f32;
@@ -114,14 +113,6 @@ extern "C" {
     pub fn CGDisplayModeCopyPixelEncoding(mode: CGDisplayModeRef) -> CFStringRef;
     pub fn CGDisplayModeRetain(mode: CGDisplayModeRef);
     pub fn CGDisplayModeRelease(mode: CGDisplayModeRef);
-
-    // Wildly used private APIs; Apple uses them for their Terminal.app.
-    pub fn CGSMainConnectionID() -> *mut AnyObject;
-    pub fn CGSSetWindowBackgroundBlurRadius(
-        connection_id: *mut AnyObject,
-        window_id: NSInteger,
-        radius: i64,
-    ) -> i32;
 }
 
 mod core_video {

src/platform_impl/macos/monitor.rs

@@ -7,9 +7,7 @@ use core_foundation::{
     base::{CFRelease, TCFType},
     string::CFString,
 };
-use core_graphics::display::{
-    CGDirectDisplayID, CGDisplay, CGDisplayBounds, CGDisplayCopyDisplayMode,
-};
+use core_graphics::display::{CGDirectDisplayID, CGDisplay, CGDisplayBounds};
 use objc2::rc::Id;
 
 use super::appkit::NSScreen;
@@ -218,12 +216,6 @@ impl MonitorHandle {
 
     pub fn refresh_rate_millihertz(&self) -> Option<u32> {
         unsafe {
-            let current_display_mode = NativeDisplayMode(CGDisplayCopyDisplayMode(self.0) as _);
-            let refresh_rate = ffi::CGDisplayModeGetRefreshRate(current_display_mode.0);
-            if refresh_rate > 0.0 {
-                return Some((refresh_rate * 1000.0).round() as u32);
-            }
-
             let mut display_link = std::ptr::null_mut();
             if ffi::CVDisplayLinkCreateWithCGDisplay(self.0, &mut display_link)
                 != ffi::kCVReturnSuccess

src/platform_impl/macos/view.rs

@@ -26,9 +26,9 @@ use crate::{
         DeviceEvent, ElementState, Event, Ime, Modifiers, MouseButton, MouseScrollDelta,
         TouchPhase, WindowEvent,
     },
-    keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey, PhysicalKey},
+    keyboard::{Key, KeyCode, KeyLocation, ModifiersState},
     platform::macos::{OptionAsAlt, WindowExtMacOS},
-    platform::scancode::PhysicalKeyExtScancode,
+    platform::scancode::KeyCodeExtScancode,
     platform_impl::platform::{
         app_state::AppState,
         event::{create_key_event, event_mods},
@@ -74,8 +74,8 @@ enum ImeState {
 bitflags! {
     #[derive(Debug, Clone, Copy, PartialEq)]
     struct ModLocationMask: u8 {
-        const LEFT     = 0b0001;
-        const RIGHT    = 0b0010;
+        const LEFT = 1;
+        const RIGHT = 2;
     }
 }
 impl ModLocationMask {
@@ -88,32 +88,32 @@ impl ModLocationMask {
     }
 }
 
-fn key_to_modifier(key: &Key) -> Option<ModifiersState> {
+fn key_to_modifier(key: &Key) -> ModifiersState {
     match key {
-        Key::Named(NamedKey::Alt) => Some(ModifiersState::ALT),
-        Key::Named(NamedKey::Control) => Some(ModifiersState::CONTROL),
-        Key::Named(NamedKey::Super) => Some(ModifiersState::SUPER),
-        Key::Named(NamedKey::Shift) => Some(ModifiersState::SHIFT),
-        _ => None,
+        Key::Alt => ModifiersState::ALT,
+        Key::Control => ModifiersState::CONTROL,
+        Key::Super => ModifiersState::SUPER,
+        Key::Shift => ModifiersState::SHIFT,
+        _ => unreachable!(),
     }
 }
 
 fn get_right_modifier_code(key: &Key) -> KeyCode {
     match key {
-        Key::Named(NamedKey::Alt) => KeyCode::AltRight,
-        Key::Named(NamedKey::Control) => KeyCode::ControlRight,
-        Key::Named(NamedKey::Shift) => KeyCode::ShiftRight,
-        Key::Named(NamedKey::Super) => KeyCode::SuperRight,
+        Key::Alt => KeyCode::AltRight,
+        Key::Control => KeyCode::ControlRight,
+        Key::Shift => KeyCode::ShiftRight,
+        Key::Super => KeyCode::SuperRight,
         _ => unreachable!(),
     }
 }
 
 fn get_left_modifier_code(key: &Key) -> KeyCode {
     match key {
-        Key::Named(NamedKey::Alt) => KeyCode::AltLeft,
-        Key::Named(NamedKey::Control) => KeyCode::ControlLeft,
-        Key::Named(NamedKey::Shift) => KeyCode::ShiftLeft,
-        Key::Named(NamedKey::Super) => KeyCode::SuperLeft,
+        Key::Alt => KeyCode::AltLeft,
+        Key::Control => KeyCode::ControlLeft,
+        Key::Shift => KeyCode::ShiftLeft,
+        Key::Super => KeyCode::SuperLeft,
         _ => unreachable!(),
     }
 }
@@ -918,102 +918,92 @@ impl WinitView {
 
         // This function was called form the flagsChanged event, which is triggered
         // when the user presses/releases a modifier even if the same kind of modifier
-        // has already been pressed.
-        //
-        // When flags changed event has key code of zero it means that event doesn't carry any key
-        // event, thus we can't generate regular presses based on that. The `ModifiersChanged`
-        // later will work though, since the flags are attached to the event and contain valid
-        // information.
-        'send_event: {
-            if is_flags_changed_event && ns_event.key_code() != 0 {
-                let scancode = ns_event.key_code();
-                let physical_key = PhysicalKey::from_scancode(scancode as u32);
+        // has already been pressed
+        if is_flags_changed_event {
+            let scancode = ns_event.key_code();
+            let keycode = KeyCode::from_scancode(scancode as u32);
 
-                // We'll correct the `is_press` later.
-                let mut event = create_key_event(ns_event, false, false, Some(physical_key));
+            // We'll correct the `is_press` later.
+            let mut event = create_key_event(ns_event, false, false, Some(keycode));
 
-                let key = code_to_key(physical_key, scancode);
-                // Ignore processing of unkown modifiers because we can't determine whether
-                // it was pressed or release reliably.
-                let Some(event_modifier) = key_to_modifier(&key) else {
-                    break 'send_event;
-                };
-                event.physical_key = physical_key;
-                event.logical_key = key.clone();
-                event.location = code_to_location(physical_key);
-                let location_mask = ModLocationMask::from_location(event.location);
+            let key = code_to_key(keycode, scancode);
+            let event_modifier = key_to_modifier(&key);
+            event.physical_key = keycode;
+            event.logical_key = key.clone();
+            event.location = code_to_location(keycode);
+            let location_mask = ModLocationMask::from_location(event.location);
 
-                let mut phys_mod_state = self.state.phys_modifiers.borrow_mut();
-                let phys_mod = phys_mod_state
-                    .entry(key)
-                    .or_insert(ModLocationMask::empty());
+            let mut phys_mod_state = self.state.phys_modifiers.borrow_mut();
+            let phys_mod = phys_mod_state
+                .entry(key)
+                .or_insert(ModLocationMask::empty());
 
-                let is_active = current_modifiers.state().contains(event_modifier);
-                let mut events = VecDeque::with_capacity(2);
-
-                // There is no API for getting whether the button was pressed or released
-                // during this event. For this reason we have to do a bit of magic below
-                // to come up with a good guess whether this key was pressed or released.
-                // (This is not trivial because there are multiple buttons that may affect
-                // the same modifier)
-                if !is_active {
-                    event.state = Released;
-                    if phys_mod.contains(ModLocationMask::LEFT) {
-                        let mut event = event.clone();
-                        event.location = KeyLocation::Left;
-                        event.physical_key = get_left_modifier_code(&event.logical_key).into();
-                        events.push_back(WindowEvent::KeyboardInput {
-                            device_id: DEVICE_ID,
-                            event,
-                            is_synthetic: false,
-                        });
-                    }
-                    if phys_mod.contains(ModLocationMask::RIGHT) {
-                        event.location = KeyLocation::Right;
-                        event.physical_key = get_right_modifier_code(&event.logical_key).into();
-                        events.push_back(WindowEvent::KeyboardInput {
-                            device_id: DEVICE_ID,
-                            event,
-                            is_synthetic: false,
-                        });
-                    }
-                    *phys_mod = ModLocationMask::empty();
-                } else {
-                    if *phys_mod == location_mask {
-                        // Here we hit a contradiction:
-                        // The modifier state was "changed" to active,
-                        // yet the only pressed modifier key was the one that we
-                        // just got a change event for.
-                        // This seemingly means that the only pressed modifier is now released,
-                        // but at the same time the modifier became active.
-                        //
-                        // But this scenario is possible if we released modifiers
-                        // while the application was not in focus. (Because we don't
-                        // get informed of modifier key events while the application
-                        // is not focused)
-
-                        // In this case we prioritize the information
-                        // about the current modifier state which means
-                        // that the button was pressed.
-                        event.state = Pressed;
-                    } else {
-                        phys_mod.toggle(location_mask);
-                        let is_pressed = phys_mod.contains(location_mask);
-                        event.state = if is_pressed { Pressed } else { Released };
-                    }
+            let is_active = current_modifiers.state().contains(event_modifier);
+            let mut events = VecDeque::with_capacity(2);
 
+            // There is no API for getting whether the button was pressed or released
+            // during this event. For this reason we have to do a bit of magic below
+            // to come up with a good guess whether this key was pressed or released.
+            // (This is not trivial because there are multiple buttons that may affect
+            // the same modifier)
+            if !is_active {
+                event.state = Released;
+                if phys_mod.contains(ModLocationMask::LEFT) {
+                    let mut event = event.clone();
+                    event.location = KeyLocation::Left;
+                    event.physical_key = get_left_modifier_code(&event.logical_key);
                     events.push_back(WindowEvent::KeyboardInput {
                         device_id: DEVICE_ID,
                         event,
                         is_synthetic: false,
                     });
                 }
-
-                drop(phys_mod_state);
-
-                for event in events {
-                    self.queue_event(event);
+                if phys_mod.contains(ModLocationMask::RIGHT) {
+                    event.location = KeyLocation::Right;
+                    event.physical_key = get_right_modifier_code(&event.logical_key);
+                    events.push_back(WindowEvent::KeyboardInput {
+                        device_id: DEVICE_ID,
+                        event,
+                        is_synthetic: false,
+                    });
                 }
+                *phys_mod = ModLocationMask::empty();
+            } else {
+                // is_active
+                if *phys_mod == location_mask {
+                    // Here we hit a contradiction:
+                    // The modifier state was "changed" to active,
+                    // yet the only pressed modifier key was the one that we
+                    // just got a change event for.
+                    // This seemingly means that the only pressed modifier is now released,
+                    // but at the same time the modifier became active.
+                    //
+                    // But this scenario is possible if we released modifiers
+                    // while the application was not in focus. (Because we don't
+                    // get informed of modifier key events while the application
+                    // is not focused)
+
+                    // In this case we prioritize the information
+                    // about the current modifier state which means
+                    // that the button was pressed.
+                    event.state = Pressed;
+                } else {
+                    phys_mod.toggle(location_mask);
+                    let is_pressed = phys_mod.contains(location_mask);
+                    event.state = if is_pressed { Pressed } else { Released };
+                }
+
+                events.push_back(WindowEvent::KeyboardInput {
+                    device_id: DEVICE_ID,
+                    event,
+                    is_synthetic: false,
+                });
+            }
+
+            drop(phys_mod_state);
+
+            for event in events {
+                self.queue_event(event);
             }
         }
 

src/platform_impl/macos/window.rs

@@ -46,8 +46,6 @@ use super::appkit::{
     NSView, NSWindow, NSWindowButton, NSWindowLevel, NSWindowSharingType, NSWindowStyleMask,
     NSWindowTabbingMode, NSWindowTitleVisibility,
 };
-use super::ffi::CGSMainConnectionID;
-use super::ffi::CGSSetWindowBackgroundBlurRadius;
 
 pub(crate) struct Window {
     window: MainThreadBound<Id<WinitWindow>>,
@@ -297,7 +295,7 @@ impl WinitWindow {
         trace_scope!("WinitWindow::new");
 
         let this = autoreleasepool(|_| {
-            let screen = match attrs.fullscreen.0.clone().map(Into::into) {
+            let screen = match attrs.fullscreen.clone().map(Into::into) {
                 Some(Fullscreen::Borderless(Some(monitor)))
                 | Some(Fullscreen::Exclusive(VideoMode { monitor, .. })) => {
                     monitor.ns_screen().or_else(NSScreen::main)
@@ -451,7 +449,7 @@ impl WinitWindow {
         .ok_or_else(|| os_error!(OsError::CreationError("Couldn't create `NSWindow`")))?;
 
         #[cfg(feature = "rwh_06")]
-        match attrs.parent_window.0 {
+        match attrs.parent_window {
             Some(rwh_06::RawWindowHandle::AppKit(handle)) => {
                 // SAFETY: Caller ensures the pointer is valid or NULL
                 // Unwrap is fine, since the pointer comes from `NonNull`.
@@ -496,10 +494,6 @@ impl WinitWindow {
             this.setBackgroundColor(&NSColor::clear());
         }
 
-        if attrs.blur {
-            this.set_blur(attrs.blur);
-        }
-
         if let Some(dim) = attrs.min_inner_size {
             this.set_min_inner_size(Some(dim));
         }
@@ -526,14 +520,14 @@ impl WinitWindow {
             }
         }
 
-        let delegate = WinitWindowDelegate::new(&this, attrs.fullscreen.0.is_some());
+        let delegate = WinitWindowDelegate::new(&this, attrs.fullscreen.is_some());
 
         // XXX Send `Focused(false)` right after creating the window delegate, so we won't
         // obscure the real focused events on the startup.
         delegate.queue_event(WindowEvent::Focused(false));
 
         // Set fullscreen mode after we setup everything
-        this.set_fullscreen(attrs.fullscreen.0.map(Into::into));
+        this.set_fullscreen(attrs.fullscreen.map(Into::into));
 
         // Setting the window as key has to happen *after* we set the fullscreen
         // state, since otherwise we'll briefly see the window at normal size
@@ -588,15 +582,7 @@ impl WinitWindow {
         self.setOpaque(!transparent)
     }
 
-    pub fn set_blur(&self, blur: bool) {
-        // NOTE: in general we want to specify the blur radius, but the choice of 80
-        // should be a reasonable default.
-        let radius = if blur { 80 } else { 0 };
-        let window_number = self.windowNumber();
-        unsafe {
-            CGSSetWindowBackgroundBlurRadius(CGSMainConnectionID(), window_number, radius);
-        }
-    }
+    pub fn set_blur(&self, _blur: bool) {}
 
     pub fn set_visible(&self, visible: bool) {
         match visible {
@@ -1539,35 +1525,27 @@ impl WindowExtMacOS for WinitWindow {
 
     #[inline]
     fn select_next_tab(&self) {
-        if let Some(group) = self.tabGroup() {
-            group.selectNextTab();
-        }
+        self.tabGroup().selectNextTab();
     }
 
     #[inline]
     fn select_previous_tab(&self) {
-        if let Some(group) = self.tabGroup() {
-            group.selectPreviousTab()
-        }
+        self.tabGroup().selectPreviousTab();
     }
 
     #[inline]
     fn select_tab_at_index(&self, index: usize) {
-        if let Some(group) = self.tabGroup() {
-            if let Some(windows) = group.tabbedWindows() {
-                if index < windows.len() {
-                    group.setSelectedWindow(&windows[index]);
-                }
-            }
+        let tab_group = self.tabGroup();
+        let windows = tab_group.tabbedWindows();
+        if index < windows.len() {
+            tab_group.setSelectedWindow(&windows[index]);
         }
     }
 
     #[inline]
     fn num_tabs(&self) -> usize {
-        self.tabGroup()
-            .and_then(|group| group.tabbedWindows())
-            .map(|windows| windows.len())
-            .unwrap_or(1)
+        let tab_group = self.tabGroup();
+        tab_group.tabbedWindows().len()
     }
 
     fn is_document_edited(&self) -> bool {

src/platform_impl/orbital/event_loop.rs

@@ -18,7 +18,6 @@ use crate::{
     event_loop::{self, ControlFlow, DeviceEvents},
     keyboard::{
         Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NativeKey, NativeKeyCode,
-        PhysicalKey,
     },
     window::WindowId as RootWindowId,
 };
@@ -28,8 +27,8 @@ use super::{
     RedoxSocket, TimeSocket, WindowId, WindowProperties,
 };
 
-fn convert_scancode(scancode: u8) -> PhysicalKey {
-    PhysicalKey::Code(match scancode {
+fn convert_scancode(scancode: u8) -> KeyCode {
+    match scancode {
         orbclient::K_A => KeyCode::KeyA,
         orbclient::K_B => KeyCode::KeyB,
         orbclient::K_C => KeyCode::KeyC,
@@ -110,8 +109,8 @@ fn convert_scancode(scancode: u8) -> PhysicalKey {
         orbclient::K_F11 => KeyCode::F11,
         orbclient::K_F12 => KeyCode::F12,
 
-        _ => return PhysicalKey::Unidentified(NativeKeyCode::Unidentified),
-    })
+        _ => KeyCode::Unidentified(NativeKeyCode::Unidentified),
+    }
 }
 
 fn element_state(pressed: bool) -> event::ElementState {
@@ -153,12 +152,7 @@ struct EventState {
 }
 
 impl EventState {
-    fn key(&mut self, key: PhysicalKey, pressed: bool) {
-        let code = match key {
-            PhysicalKey::Code(code) => code,
-            _ => return,
-        };
-
+    fn key(&mut self, code: KeyCode, pressed: bool) {
         match code {
             KeyCode::ShiftLeft => self.keyboard.set(KeyboardModifierState::LSHIFT, pressed),
             KeyCode::ShiftRight => self.keyboard.set(KeyboardModifierState::RSHIFT, pressed),
@@ -338,16 +332,16 @@ impl<T: 'static> EventLoop<T> {
                 pressed,
             }) => {
                 if scancode != 0 {
-                    let physical_key = convert_scancode(scancode);
+                    let code = convert_scancode(scancode);
                     let modifiers_before = event_state.keyboard;
-                    event_state.key(physical_key, pressed);
+                    event_state.key(code, pressed);
                     event_handler(event::Event::WindowEvent {
                         window_id: RootWindowId(window_id),
                         event: event::WindowEvent::KeyboardInput {
                             device_id: event::DeviceId(DeviceId),
                             event: event::KeyEvent {
                                 logical_key: Key::Unidentified(NativeKey::Unidentified),
-                                physical_key,
+                                physical_key: code,
                                 location: KeyLocation::Standard,
                                 state: element_state(pressed),
                                 repeat: false,

src/platform_impl/web/async.rs

@@ -0,0 +1,297 @@
+use atomic_waker::AtomicWaker;
+use std::future;
+use std::marker::PhantomData;
+use std::ops::Deref;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::{self, Receiver, RecvError, SendError, Sender, TryRecvError};
+use std::sync::{Arc, Condvar, Mutex, RwLock};
+use std::task::Poll;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::{JsCast, JsValue};
+
+// Unsafe wrapper type that allows us to use `T` when it's not `Send` from other threads.
+// `value` **must** only be accessed on the main thread.
+pub struct MainThreadSafe<const SYNC: bool, T: 'static, E: 'static> {
+    // We wrap this in an `Arc` to allow it to be safely cloned without accessing the value.
+    // The `RwLock` lets us safely drop in any thread.
+    // The `Option` lets us safely drop `T` only in the main thread, while letting other threads drop `None`.
+    value: Arc<RwLock<Option<T>>>,
+    handler: fn(&RwLock<Option<T>>, E),
+    sender: AsyncSender<E>,
+    // Prevent's `Send` or `Sync` to be automatically implemented.
+    local: PhantomData<*const ()>,
+}
+
+impl<const SYNC: bool, T, E> MainThreadSafe<SYNC, T, E> {
+    thread_local! {
+        static MAIN_THREAD: bool = {
+            #[wasm_bindgen]
+            extern "C" {
+                #[derive(Clone)]
+                type Global;
+
+                #[wasm_bindgen(method, getter, js_name = Window)]
+                fn window(this: &Global) -> JsValue;
+            }
+
+            let global: Global = js_sys::global().unchecked_into();
+            !global.window().is_undefined()
+        };
+    }
+
+    #[track_caller]
+    fn new(value: T, handler: fn(&RwLock<Option<T>>, E)) -> Option<Self> {
+        Self::MAIN_THREAD.with(|safe| {
+            if !safe {
+                panic!("only callable from inside the `Window`")
+            }
+        });
+
+        let value = Arc::new(RwLock::new(Some(value)));
+
+        let (sender, receiver) = channel::<E>();
+
+        wasm_bindgen_futures::spawn_local({
+            let value = Arc::clone(&value);
+            async move {
+                while let Ok(event) = receiver.next().await {
+                    handler(&value, event)
+                }
+
+                // An error was returned because the channel was closed, which
+                // happens when all senders are dropped.
+                value.write().unwrap().take().unwrap();
+            }
+        });
+
+        Some(Self {
+            value,
+            handler,
+            sender,
+            local: PhantomData,
+        })
+    }
+
+    pub fn send(&self, event: E) {
+        Self::MAIN_THREAD.with(|is_main_thread| {
+            if *is_main_thread {
+                (self.handler)(&self.value, event)
+            } else {
+                self.sender.send(event).unwrap()
+            }
+        })
+    }
+
+    fn is_main_thread(&self) -> bool {
+        Self::MAIN_THREAD.with(|is_main_thread| *is_main_thread)
+    }
+
+    pub fn with<R>(&self, f: impl FnOnce(&T) -> R) -> Option<R> {
+        Self::MAIN_THREAD.with(|is_main_thread| {
+            if *is_main_thread {
+                Some(f(self.value.read().unwrap().as_ref().unwrap()))
+            } else {
+                None
+            }
+        })
+    }
+}
+
+impl<const SYNC: bool, T, E> Clone for MainThreadSafe<SYNC, T, E> {
+    fn clone(&self) -> Self {
+        Self {
+            value: self.value.clone(),
+            handler: self.handler,
+            sender: self.sender.clone(),
+            local: PhantomData,
+        }
+    }
+}
+
+unsafe impl<const SYNC: bool, T, E> Send for MainThreadSafe<SYNC, T, E> {}
+unsafe impl<T, E> Sync for MainThreadSafe<true, T, E> {}
+
+fn channel<T>() -> (AsyncSender<T>, AsyncReceiver<T>) {
+    let (sender, receiver) = mpsc::channel();
+    let sender = Arc::new(Mutex::new(sender));
+    let waker = Arc::new(AtomicWaker::new());
+    let closed = Arc::new(AtomicBool::new(false));
+
+    let sender = AsyncSender {
+        sender,
+        closed: closed.clone(),
+        waker: Arc::clone(&waker),
+    };
+    let receiver = AsyncReceiver {
+        receiver,
+        closed,
+        waker,
+    };
+
+    (sender, receiver)
+}
+
+struct AsyncSender<T> {
+    // We need to wrap it into a `Mutex` to make it `Sync`. So the sender can't
+    // be accessed on the main thread, as it could block. Additionally we need
+    // to wrap it in an `Arc` to make it clonable on the main thread without
+    // having to block.
+    sender: Arc<Mutex<Sender<T>>>,
+    closed: Arc<AtomicBool>,
+    waker: Arc<AtomicWaker>,
+}
+
+impl<T> AsyncSender<T> {
+    pub fn send(&self, event: T) -> Result<(), SendError<T>> {
+        self.sender.lock().unwrap().send(event)?;
+        self.waker.wake();
+
+        Ok(())
+    }
+}
+
+impl<T> Clone for AsyncSender<T> {
+    fn clone(&self) -> Self {
+        Self {
+            sender: self.sender.clone(),
+            waker: self.waker.clone(),
+            closed: self.closed.clone(),
+        }
+    }
+}
+
+impl<T> Drop for AsyncSender<T> {
+    fn drop(&mut self) {
+        // If it's the last + the one held by the receiver make sure to wake it
+        // up and tell it that all receiver have dropped.
+        if Arc::strong_count(&self.closed) == 2 {
+            self.closed.store(true, Ordering::Relaxed);
+            self.waker.wake()
+        }
+    }
+}
+
+struct AsyncReceiver<T> {
+    receiver: Receiver<T>,
+    closed: Arc<AtomicBool>,
+    waker: Arc<AtomicWaker>,
+}
+
+impl<T> AsyncReceiver<T> {
+    pub async fn next(&self) -> Result<T, RecvError> {
+        future::poll_fn(|cx| match self.receiver.try_recv() {
+            Ok(event) => Poll::Ready(Ok(event)),
+            Err(TryRecvError::Empty) => {
+                if self.closed.load(Ordering::Relaxed) {
+                    return Poll::Ready(Err(RecvError));
+                }
+
+                self.waker.register(cx.waker());
+
+                match self.receiver.try_recv() {
+                    Ok(event) => Poll::Ready(Ok(event)),
+                    Err(TryRecvError::Empty) => {
+                        if self.closed.load(Ordering::Relaxed) {
+                            Poll::Ready(Err(RecvError))
+                        } else {
+                            Poll::Pending
+                        }
+                    }
+                    Err(TryRecvError::Disconnected) => Poll::Ready(Err(RecvError)),
+                }
+            }
+            Err(TryRecvError::Disconnected) => Poll::Ready(Err(RecvError)),
+        })
+        .await
+    }
+}
+
+pub struct Dispatcher<T: 'static>(MainThreadSafe<true, T, Closure<T>>);
+
+pub struct Closure<T>(Box<dyn FnOnce(&T) + Send>);
+
+impl<T> Dispatcher<T> {
+    #[track_caller]
+    pub fn new(value: T) -> Option<Self> {
+        MainThreadSafe::new(value, |value, Closure(closure)| {
+            // SAFETY: The given `Closure` here isn't really `'static`, so we shouldn't do anything
+            // funny with it here. See `Self::queue()`.
+            closure(value.read().unwrap().as_ref().unwrap())
+        })
+        .map(Self)
+    }
+
+    pub fn dispatch(&self, f: impl 'static + FnOnce(&T) + Send) {
+        if self.is_main_thread() {
+            self.0.with(f).unwrap()
+        } else {
+            self.0.send(Closure(Box::new(f)))
+        }
+    }
+
+    pub fn queue<R: Send>(&self, f: impl FnOnce(&T) -> R + Send) -> R {
+        if self.is_main_thread() {
+            self.0.with(f).unwrap()
+        } else {
+            let pair = Arc::new((Mutex::new(None), Condvar::new()));
+            let closure = Box::new({
+                let pair = pair.clone();
+                move |value: &T| {
+                    *pair.0.lock().unwrap() = Some(f(value));
+                    pair.1.notify_one();
+                }
+            }) as Box<dyn FnOnce(&T) + Send>;
+            // SAFETY: The `transmute` is necessary because `Closure` requires `'static`. This is
+            // safe because this function won't return until `f` has finished executing. See
+            // `Self::new()`.
+            let closure = Closure(unsafe { std::mem::transmute(closure) });
+
+            self.0.send(closure);
+
+            let mut started = pair.0.lock().unwrap();
+
+            while started.is_none() {
+                started = pair.1.wait(started).unwrap();
+            }
+
+            started.take().unwrap()
+        }
+    }
+}
+
+impl<T> Deref for Dispatcher<T> {
+    type Target = MainThreadSafe<true, T, Closure<T>>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+type ChannelValue<T, E> = MainThreadSafe<false, (T, fn(&T, E)), E>;
+
+pub struct Channel<T: 'static, E: 'static>(ChannelValue<T, E>);
+
+impl<T, E> Channel<T, E> {
+    pub fn new(value: T, handler: fn(&T, E)) -> Option<Self> {
+        MainThreadSafe::new((value, handler), |runner, event| {
+            let lock = runner.read().unwrap();
+            let (value, handler) = lock.as_ref().unwrap();
+            handler(value, event);
+        })
+        .map(Self)
+    }
+}
+
+impl<T, E> Clone for Channel<T, E> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<T, E> Deref for Channel<T, E> {
+    type Target = ChannelValue<T, E>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}

src/platform_impl/web/async/channel.rs

@@ -1,115 +0,0 @@
-use atomic_waker::AtomicWaker;
-use std::future;
-use std::rc::Rc;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::mpsc::{self, Receiver, RecvError, SendError, Sender, TryRecvError};
-use std::sync::{Arc, Mutex};
-use std::task::Poll;
-
-// NOTE: This channel doesn't wake up when all senders or receivers are
-// dropped. This is acceptable as long as it's only used in `Dispatcher`, which
-// has it's own `Drop` behavior.
-
-pub fn channel<T>() -> (AsyncSender<T>, AsyncReceiver<T>) {
-    let (sender, receiver) = mpsc::channel();
-    let sender = Arc::new(Mutex::new(sender));
-    let inner = Arc::new(Inner {
-        closed: AtomicBool::new(false),
-        waker: AtomicWaker::new(),
-    });
-
-    let sender = AsyncSender {
-        sender,
-        inner: Arc::clone(&inner),
-    };
-    let receiver = AsyncReceiver {
-        receiver: Rc::new(receiver),
-        inner,
-    };
-
-    (sender, receiver)
-}
-
-pub struct AsyncSender<T> {
-    // We need to wrap it into a `Mutex` to make it `Sync`. So the sender can't
-    // be accessed on the main thread, as it could block. Additionally we need
-    // to wrap it in an `Arc` to make it clonable on the main thread without
-    // having to block.
-    sender: Arc<Mutex<Sender<T>>>,
-    inner: Arc<Inner>,
-}
-
-impl<T> AsyncSender<T> {
-    pub fn send(&self, event: T) -> Result<(), SendError<T>> {
-        self.sender.lock().unwrap().send(event)?;
-        self.inner.waker.wake();
-
-        Ok(())
-    }
-
-    pub fn close(&self) {
-        self.inner.closed.store(true, Ordering::Relaxed);
-        self.inner.waker.wake()
-    }
-}
-
-impl<T> Clone for AsyncSender<T> {
-    fn clone(&self) -> Self {
-        Self {
-            sender: Arc::clone(&self.sender),
-            inner: Arc::clone(&self.inner),
-        }
-    }
-}
-
-pub struct AsyncReceiver<T> {
-    receiver: Rc<Receiver<T>>,
-    inner: Arc<Inner>,
-}
-
-impl<T> AsyncReceiver<T> {
-    pub async fn next(&self) -> Result<T, RecvError> {
-        future::poll_fn(|cx| match self.receiver.try_recv() {
-            Ok(event) => Poll::Ready(Ok(event)),
-            Err(TryRecvError::Empty) => {
-                self.inner.waker.register(cx.waker());
-
-                match self.receiver.try_recv() {
-                    Ok(event) => Poll::Ready(Ok(event)),
-                    Err(TryRecvError::Empty) => {
-                        if self.inner.closed.load(Ordering::Relaxed) {
-                            Poll::Ready(Err(RecvError))
-                        } else {
-                            Poll::Pending
-                        }
-                    }
-                    Err(TryRecvError::Disconnected) => Poll::Ready(Err(RecvError)),
-                }
-            }
-            Err(TryRecvError::Disconnected) => Poll::Ready(Err(RecvError)),
-        })
-        .await
-    }
-
-    pub fn try_recv(&self) -> Result<Option<T>, RecvError> {
-        match self.receiver.try_recv() {
-            Ok(value) => Ok(Some(value)),
-            Err(TryRecvError::Empty) => Ok(None),
-            Err(TryRecvError::Disconnected) => Err(RecvError),
-        }
-    }
-}
-
-impl<T> Clone for AsyncReceiver<T> {
-    fn clone(&self) -> Self {
-        Self {
-            receiver: Rc::clone(&self.receiver),
-            inner: Arc::clone(&self.inner),
-        }
-    }
-}
-
-struct Inner {
-    closed: AtomicBool,
-    waker: AtomicWaker,
-}

src/platform_impl/web/async/dispatcher.rs

@@ -1,113 +0,0 @@
-use super::{channel, AsyncReceiver, AsyncSender, Wrapper};
-use std::{
-    cell::Ref,
-    sync::{Arc, Condvar, Mutex},
-};
-
-pub struct Dispatcher<T: 'static>(Wrapper<true, T, AsyncSender<Closure<T>>, Closure<T>>);
-
-struct Closure<T>(Box<dyn FnOnce(&T) + Send>);
-
-impl<T> Dispatcher<T> {
-    #[track_caller]
-    pub fn new(value: T) -> Option<(Self, DispatchRunner<T>)> {
-        let (sender, receiver) = channel::<Closure<T>>();
-
-        Wrapper::new(
-            value,
-            |value, Closure(closure)| {
-                // SAFETY: The given `Closure` here isn't really `'static`, so we shouldn't do anything
-                // funny with it here. See `Self::queue()`.
-                closure(value.borrow().as_ref().unwrap())
-            },
-            {
-                let receiver = receiver.clone();
-                move |value| async move {
-                    while let Ok(Closure(closure)) = receiver.next().await {
-                        // SAFETY: The given `Closure` here isn't really `'static`, so we shouldn't do anything
-                        // funny with it here. See `Self::queue()`.
-                        closure(value.borrow().as_ref().unwrap())
-                    }
-                }
-            },
-            sender,
-            |sender, closure| {
-                // SAFETY: The given `Closure` here isn't really `'static`, so we shouldn't do anything
-                // funny with it here. See `Self::queue()`.
-                sender.send(closure).unwrap()
-            },
-        )
-        .map(|wrapper| (Self(wrapper.clone()), DispatchRunner { wrapper, receiver }))
-    }
-
-    pub fn value(&self) -> Option<Ref<'_, T>> {
-        self.0.value()
-    }
-
-    pub fn dispatch(&self, f: impl 'static + FnOnce(&T) + Send) {
-        if let Some(value) = self.0.value() {
-            f(&value)
-        } else {
-            self.0.send(Closure(Box::new(f)))
-        }
-    }
-
-    pub fn queue<R: Send>(&self, f: impl FnOnce(&T) -> R + Send) -> R {
-        if let Some(value) = self.0.value() {
-            f(&value)
-        } else {
-            let pair = Arc::new((Mutex::new(None), Condvar::new()));
-            let closure = Box::new({
-                let pair = pair.clone();
-                move |value: &T| {
-                    *pair.0.lock().unwrap() = Some(f(value));
-                    pair.1.notify_one();
-                }
-            }) as Box<dyn FnOnce(&T) + Send>;
-            // SAFETY: The `transmute` is necessary because `Closure` requires `'static`. This is
-            // safe because this function won't return until `f` has finished executing. See
-            // `Self::new()`.
-            let closure = Closure(unsafe { std::mem::transmute(closure) });
-
-            self.0.send(closure);
-
-            let mut started = pair.0.lock().unwrap();
-
-            while started.is_none() {
-                started = pair.1.wait(started).unwrap();
-            }
-
-            started.take().unwrap()
-        }
-    }
-}
-
-impl<T> Drop for Dispatcher<T> {
-    fn drop(&mut self) {
-        self.0.with_sender_data(|sender| sender.close())
-    }
-}
-
-pub struct DispatchRunner<T: 'static> {
-    wrapper: Wrapper<true, T, AsyncSender<Closure<T>>, Closure<T>>,
-    receiver: AsyncReceiver<Closure<T>>,
-}
-
-impl<T> DispatchRunner<T> {
-    pub fn run(&self) {
-        while let Some(Closure(closure)) = self
-            .receiver
-            .try_recv()
-            .expect("should only be closed when `Dispatcher` is dropped")
-        {
-            // SAFETY: The given `Closure` here isn't really `'static`, so we shouldn't do anything
-            // funny with it here. See `Self::queue()`.
-            closure(
-                &self
-                    .wrapper
-                    .value()
-                    .expect("don't call this outside the main thread"),
-            )
-        }
-    }
-}

src/platform_impl/web/async/mod.rs

@@ -1,9 +0,0 @@
-mod channel;
-mod dispatcher;
-mod waker;
-mod wrapper;
-
-use self::channel::{channel, AsyncReceiver, AsyncSender};
-pub use self::dispatcher::{DispatchRunner, Dispatcher};
-pub use self::waker::{Waker, WakerSpawner};
-use self::wrapper::Wrapper;

src/platform_impl/web/async/waker.rs

@@ -1,123 +0,0 @@
-use super::Wrapper;
-use atomic_waker::AtomicWaker;
-use std::future;
-use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::sync::Arc;
-use std::task::Poll;
-
-pub struct WakerSpawner<T: 'static>(Wrapper<false, Handler<T>, Sender, usize>);
-
-pub struct Waker<T: 'static>(Wrapper<false, Handler<T>, Sender, usize>);
-
-struct Handler<T> {
-    value: T,
-    handler: fn(&T, usize),
-}
-
-#[derive(Clone)]
-struct Sender(Arc<Inner>);
-
-impl<T> WakerSpawner<T> {
-    #[track_caller]
-    pub fn new(value: T, handler: fn(&T, usize)) -> Option<Self> {
-        let inner = Arc::new(Inner {
-            counter: AtomicUsize::new(0),
-            waker: AtomicWaker::new(),
-            closed: AtomicBool::new(false),
-        });
-
-        let handler = Handler { value, handler };
-
-        let sender = Sender(Arc::clone(&inner));
-
-        let wrapper = Wrapper::new(
-            handler,
-            |handler, count| {
-                let handler = handler.borrow();
-                let handler = handler.as_ref().unwrap();
-                (handler.handler)(&handler.value, count);
-            },
-            {
-                let inner = Arc::clone(&inner);
-
-                move |handler| async move {
-                    while let Some(count) = future::poll_fn(|cx| {
-                        let count = inner.counter.swap(0, Ordering::Relaxed);
-
-                        if count > 0 {
-                            Poll::Ready(Some(count))
-                        } else {
-                            inner.waker.register(cx.waker());
-
-                            let count = inner.counter.swap(0, Ordering::Relaxed);
-
-                            if count > 0 {
-                                Poll::Ready(Some(count))
-                            } else {
-                                if inner.closed.load(Ordering::Relaxed) {
-                                    return Poll::Ready(None);
-                                }
-
-                                Poll::Pending
-                            }
-                        }
-                    })
-                    .await
-                    {
-                        let handler = handler.borrow();
-                        let handler = handler.as_ref().unwrap();
-                        (handler.handler)(&handler.value, count);
-                    }
-                }
-            },
-            sender,
-            |inner, _| {
-                inner.0.counter.fetch_add(1, Ordering::Relaxed);
-                inner.0.waker.wake();
-            },
-        )?;
-
-        Some(Self(wrapper))
-    }
-
-    pub fn waker(&self) -> Waker<T> {
-        Waker(self.0.clone())
-    }
-
-    pub fn fetch(&self) -> usize {
-        debug_assert!(
-            self.0.is_main_thread(),
-            "this should only be called from the main thread"
-        );
-
-        self.0
-            .with_sender_data(|inner| inner.0.counter.swap(0, Ordering::Relaxed))
-    }
-}
-
-impl<T> Drop for WakerSpawner<T> {
-    fn drop(&mut self) {
-        self.0.with_sender_data(|inner| {
-            inner.0.closed.store(true, Ordering::Relaxed);
-            inner.0.waker.wake();
-        });
-    }
-}
-
-impl<T> Waker<T> {
-    pub fn wake(&self) {
-        self.0.send(1)
-    }
-}
-
-impl<T> Clone for Waker<T> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-struct Inner {
-    counter: AtomicUsize,
-    waker: AtomicWaker,
-    closed: AtomicBool,
-}

src/platform_impl/web/async/wrapper.rs

@@ -1,131 +0,0 @@
-use std::cell::{Ref, RefCell};
-use std::future::Future;
-use std::marker::PhantomData;
-use std::sync::Arc;
-use wasm_bindgen::prelude::wasm_bindgen;
-use wasm_bindgen::{JsCast, JsValue};
-
-// Unsafe wrapper type that allows us to use `T` when it's not `Send` from other threads.
-// `value` **must** only be accessed on the main thread.
-pub struct Wrapper<const SYNC: bool, V: 'static, S: Clone + Send, E> {
-    value: Value<SYNC, V>,
-    handler: fn(&RefCell<Option<V>>, E),
-    sender_data: S,
-    sender_handler: fn(&S, E),
-}
-
-struct Value<const SYNC: bool, V> {
-    // SAFETY:
-    // This value must not be accessed if not on the main thread.
-    //
-    // - We wrap this in an `Arc` to allow it to be safely cloned without
-    //   accessing the value.
-    // - The `RefCell` lets us mutably access in the main thread but is safe to
-    //   drop in any thread because it has no `Drop` behavior.
-    // - The `Option` lets us safely drop `T` only in the main thread.
-    value: Arc<RefCell<Option<V>>>,
-    // Prevent's `Send` or `Sync` to be automatically implemented.
-    local: PhantomData<*const ()>,
-}
-
-// SAFETY: See `Self::value`.
-unsafe impl<const SYNC: bool, V> Send for Value<SYNC, V> {}
-// SAFETY: See `Self::value`.
-unsafe impl<V> Sync for Value<true, V> {}
-
-impl<const SYNC: bool, V, S: Clone + Send, E> Wrapper<SYNC, V, S, E> {
-    thread_local! {
-        static MAIN_THREAD: bool = {
-            #[wasm_bindgen]
-            extern "C" {
-                #[derive(Clone)]
-                type Global;
-
-                #[wasm_bindgen(method, getter, js_name = Window)]
-                fn window(this: &Global) -> JsValue;
-            }
-
-            let global: Global = js_sys::global().unchecked_into();
-            !global.window().is_undefined()
-        };
-    }
-
-    #[track_caller]
-    pub fn new<R: Future<Output = ()>>(
-        value: V,
-        handler: fn(&RefCell<Option<V>>, E),
-        receiver: impl 'static + FnOnce(Arc<RefCell<Option<V>>>) -> R,
-        sender_data: S,
-        sender_handler: fn(&S, E),
-    ) -> Option<Self> {
-        Self::MAIN_THREAD.with(|safe| {
-            if !safe {
-                panic!("only callable from inside the `Window`")
-            }
-        });
-
-        let value = Arc::new(RefCell::new(Some(value)));
-
-        wasm_bindgen_futures::spawn_local({
-            let value = Arc::clone(&value);
-            async move {
-                receiver(Arc::clone(&value)).await;
-                drop(value.borrow_mut().take().unwrap());
-            }
-        });
-
-        Some(Self {
-            value: Value {
-                value,
-                local: PhantomData,
-            },
-            handler,
-            sender_data,
-            sender_handler,
-        })
-    }
-
-    pub fn send(&self, event: E) {
-        Self::MAIN_THREAD.with(|is_main_thread| {
-            if *is_main_thread {
-                (self.handler)(&self.value.value, event)
-            } else {
-                (self.sender_handler)(&self.sender_data, event)
-            }
-        })
-    }
-
-    pub fn is_main_thread(&self) -> bool {
-        Self::MAIN_THREAD.with(|is_main_thread| *is_main_thread)
-    }
-
-    pub fn value(&self) -> Option<Ref<'_, V>> {
-        Self::MAIN_THREAD.with(|is_main_thread| {
-            if *is_main_thread {
-                Some(Ref::map(self.value.value.borrow(), |value| {
-                    value.as_ref().unwrap()
-                }))
-            } else {
-                None
-            }
-        })
-    }
-
-    pub fn with_sender_data<T>(&self, f: impl FnOnce(&S) -> T) -> T {
-        f(&self.sender_data)
-    }
-}
-
-impl<const SYNC: bool, V, S: Clone + Send, E> Clone for Wrapper<SYNC, V, S, E> {
-    fn clone(&self) -> Self {
-        Self {
-            value: Value {
-                value: self.value.value.clone(),
-                local: PhantomData,
-            },
-            handler: self.handler,
-            sender_data: self.sender_data.clone(),
-            sender_handler: self.sender_handler,
-        }
-    }
-}

src/platform_impl/web/event_loop/mod.rs

@@ -27,12 +27,11 @@ pub(crate) struct PlatformSpecificEventLoopAttributes {}
 impl<T> EventLoop<T> {
     pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
         let (user_event_sender, user_event_receiver) = mpsc::channel();
-        let elw = RootEventLoopWindowTarget {
-            p: EventLoopWindowTarget::new(),
-            _marker: PhantomData,
-        };
         Ok(EventLoop {
-            elw,
+            elw: RootEventLoopWindowTarget {
+                p: EventLoopWindowTarget::new(),
+                _marker: PhantomData,
+            },
             user_event_sender,
             user_event_receiver,
         })
@@ -102,7 +101,7 @@ impl<T> EventLoop<T> {
     }
 
     pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.elw.p.waker(), self.user_event_sender.clone())
+        EventLoopProxy::new(self.elw.p.runner.clone(), self.user_event_sender.clone())
     }
 
     pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {

src/platform_impl/web/event_loop/proxy.rs

@@ -1,25 +1,30 @@
-use std::rc::Weak;
-use std::sync::mpsc::{SendError, Sender};
+use std::sync::mpsc::Sender;
 
-use super::runner::Execution;
+use super::runner;
+use crate::event::Event;
 use crate::event_loop::EventLoopClosed;
-use crate::platform_impl::platform::r#async::Waker;
+use crate::platform_impl::platform::r#async::Channel;
 
 pub struct EventLoopProxy<T: 'static> {
-    runner: Waker<Weak<Execution>>,
+    // used to wake the event loop handler, not to actually pass data
+    runner: Channel<runner::Shared, ()>,
     sender: Sender<T>,
 }
 
 impl<T: 'static> EventLoopProxy<T> {
-    pub fn new(runner: Waker<Weak<Execution>>, sender: Sender<T>) -> Self {
-        Self { runner, sender }
+    pub fn new(runner: runner::Shared, sender: Sender<T>) -> Self {
+        Self {
+            runner: Channel::new(runner, |runner, event| {
+                runner.send_event(Event::UserEvent(event))
+            })
+            .unwrap(),
+            sender,
+        }
     }
 
     pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.sender
-            .send(event)
-            .map_err(|SendError(event)| EventLoopClosed(event))?;
-        self.runner.wake();
+        self.sender.send(event).unwrap();
+        self.runner.send(());
         Ok(())
     }
 }

src/platform_impl/web/event_loop/runner.rs

@@ -8,10 +8,9 @@ use crate::event::{
 use crate::event_loop::{ControlFlow, DeviceEvents};
 use crate::platform::web::PollStrategy;
 use crate::platform_impl::platform::backend::EventListenerHandle;
-use crate::platform_impl::platform::r#async::{DispatchRunner, Waker, WakerSpawner};
-use crate::platform_impl::platform::window::Inner;
 use crate::window::WindowId;
 
+use std::sync::atomic::Ordering;
 use std::{
     cell::{Cell, RefCell},
     clone::Clone,
@@ -37,7 +36,6 @@ impl Clone for Shared {
 type OnEventHandle<T> = RefCell<Option<EventListenerHandle<dyn FnMut(T)>>>;
 
 pub struct Execution {
-    proxy_spawner: WakerSpawner<Weak<Self>>,
     control_flow: Cell<ControlFlow>,
     poll_strategy: Cell<PollStrategy>,
     exit: Cell<bool>,
@@ -48,14 +46,7 @@ pub struct Execution {
     id: RefCell<u32>,
     window: web_sys::Window,
     document: Document,
-    #[allow(clippy::type_complexity)]
-    all_canvases: RefCell<
-        Vec<(
-            WindowId,
-            Weak<RefCell<backend::Canvas>>,
-            DispatchRunner<Inner>,
-        )>,
-    >,
+    all_canvases: RefCell<Vec<(WindowId, Weak<RefCell<backend::Canvas>>)>>,
     redraw_pending: RefCell<HashSet<WindowId>>,
     destroy_pending: RefCell<VecDeque<WindowId>>,
     page_transition_event_handle: RefCell<Option<backend::PageTransitionEventHandle>>,
@@ -149,40 +140,30 @@ impl Shared {
         #[allow(clippy::disallowed_methods)]
         let document = window.document().expect("Failed to obtain document");
 
-        Shared(Rc::<Execution>::new_cyclic(|weak| {
-            let proxy_spawner = WakerSpawner::new(weak.clone(), |runner, count| {
-                if let Some(runner) = runner.upgrade() {
-                    Shared(runner).send_events(iter::repeat(Event::UserEvent(())).take(count))
-                }
-            })
-            .expect("`EventLoop` has to be created in the main thread");
-
-            Execution {
-                proxy_spawner,
-                control_flow: Cell::new(ControlFlow::default()),
-                poll_strategy: Cell::new(PollStrategy::default()),
-                exit: Cell::new(false),
-                runner: RefCell::new(RunnerEnum::Pending),
-                suspended: Cell::new(false),
-                event_loop_recreation: Cell::new(false),
-                events: RefCell::new(VecDeque::new()),
-                window,
-                document,
-                id: RefCell::new(0),
-                all_canvases: RefCell::new(Vec::new()),
-                redraw_pending: RefCell::new(HashSet::new()),
-                destroy_pending: RefCell::new(VecDeque::new()),
-                page_transition_event_handle: RefCell::new(None),
-                device_events: Cell::default(),
-                on_mouse_move: RefCell::new(None),
-                on_wheel: RefCell::new(None),
-                on_mouse_press: RefCell::new(None),
-                on_mouse_release: RefCell::new(None),
-                on_key_press: RefCell::new(None),
-                on_key_release: RefCell::new(None),
-                on_visibility_change: RefCell::new(None),
-                on_touch_end: RefCell::new(None),
-            }
+        Shared(Rc::new(Execution {
+            control_flow: Cell::new(ControlFlow::default()),
+            poll_strategy: Cell::new(PollStrategy::default()),
+            exit: Cell::new(false),
+            runner: RefCell::new(RunnerEnum::Pending),
+            suspended: Cell::new(false),
+            event_loop_recreation: Cell::new(false),
+            events: RefCell::new(VecDeque::new()),
+            window,
+            document,
+            id: RefCell::new(0),
+            all_canvases: RefCell::new(Vec::new()),
+            redraw_pending: RefCell::new(HashSet::new()),
+            destroy_pending: RefCell::new(VecDeque::new()),
+            page_transition_event_handle: RefCell::new(None),
+            device_events: Cell::default(),
+            on_mouse_move: RefCell::new(None),
+            on_wheel: RefCell::new(None),
+            on_mouse_press: RefCell::new(None),
+            on_mouse_release: RefCell::new(None),
+            on_key_press: RefCell::new(None),
+            on_key_release: RefCell::new(None),
+            on_visibility_change: RefCell::new(None),
+            on_touch_end: RefCell::new(None),
         }))
     }
 
@@ -194,13 +175,11 @@ impl Shared {
         &self.0.document
     }
 
-    pub fn add_canvas(
-        &self,
-        id: WindowId,
-        canvas: Weak<RefCell<backend::Canvas>>,
-        runner: DispatchRunner<Inner>,
-    ) {
-        self.0.all_canvases.borrow_mut().push((id, canvas, runner));
+    pub fn add_canvas(&self, id: WindowId, canvas: &Rc<RefCell<backend::Canvas>>) {
+        self.0
+            .all_canvases
+            .borrow_mut()
+            .push((id, Rc::downgrade(canvas)));
     }
 
     pub fn notify_destroy_window(&self, id: WindowId) {
@@ -432,7 +411,7 @@ impl Shared {
             "visibilitychange",
             Closure::new(move |_| {
                 if !runner.0.suspended.get() {
-                    for (id, canvas, _) in &*runner.0.all_canvases.borrow() {
+                    for (id, canvas) in &*runner.0.all_canvases.borrow() {
                         if let Some(canvas) = canvas.upgrade() {
                             let is_visible = backend::is_visible(runner.document());
                             // only fire if:
@@ -570,7 +549,7 @@ impl Shared {
             self.0
                 .all_canvases
                 .borrow_mut()
-                .retain(|&(item_id, _, _)| item_id != id);
+                .retain(|&(item_id, _)| item_id != id);
             self.handle_event(Event::WindowEvent {
                 window_id: id,
                 event: crate::event::WindowEvent::Destroyed,
@@ -639,29 +618,9 @@ impl Shared {
         // Don't take events out of the queue if the loop is closed or the runner doesn't exist
         // If the runner doesn't exist and this method recurses, it will recurse infinitely
         if !is_closed && self.0.runner.borrow().maybe_runner().is_some() {
-            // Pre-fetch window commands to avoid having to wait until the next event loop cycle
-            // and potentially block other threads in the meantime.
-            for (_, window, runner) in self.0.all_canvases.borrow().iter() {
-                if let Some(window) = window.upgrade() {
-                    runner.run();
-                    drop(window)
-                }
-            }
-
             // Take an event out of the queue and handle it
             // Make sure not to let the borrow_mut live during the next handle_event
-            let event = {
-                let mut events = self.0.events.borrow_mut();
-
-                // Pre-fetch `UserEvent`s to avoid having to wait until the next event loop cycle.
-                events.extend(
-                    iter::repeat(Event::UserEvent(()))
-                        .take(self.0.proxy_spawner.fetch())
-                        .map(EventWrapper::from),
-                );
-
-                events.pop_front()
-            };
+            let event = { self.0.events.borrow_mut().pop_front() };
             if let Some(event) = event {
                 self.handle_event(event);
             }
@@ -731,7 +690,7 @@ impl Shared {
         // Dropping the `Runner` drops the event handler closure, which will in
         // turn drop all `Window`s moved into the closure.
         *self.0.runner.borrow_mut() = RunnerEnum::Destroyed;
-        for (_, canvas, _) in all_canvases {
+        for (_, canvas) in all_canvases {
             // In case any remaining `Window`s are still not dropped, we will need
             // to explicitly remove the event handlers associated with their canvases.
             if let Some(canvas) = canvas.upgrade() {
@@ -775,29 +734,23 @@ impl Shared {
     fn device_events(&self) -> bool {
         match self.0.device_events.get() {
             DeviceEvents::Always => true,
-            DeviceEvents::WhenFocused => {
-                self.0.all_canvases.borrow().iter().any(|(_, canvas, _)| {
-                    if let Some(canvas) = canvas.upgrade() {
-                        canvas.borrow().has_focus.get()
-                    } else {
-                        false
-                    }
-                })
-            }
+            DeviceEvents::WhenFocused => self.0.all_canvases.borrow().iter().any(|(_, canvas)| {
+                if let Some(canvas) = canvas.upgrade() {
+                    canvas.borrow().has_focus.load(Ordering::Relaxed)
+                } else {
+                    false
+                }
+            }),
             DeviceEvents::Never => false,
         }
     }
 
     fn transient_activation(&self) {
-        self.0
-            .all_canvases
-            .borrow()
-            .iter()
-            .for_each(|(_, canvas, _)| {
-                if let Some(canvas) = canvas.upgrade() {
-                    canvas.borrow().transient_activation();
-                }
-            });
+        self.0.all_canvases.borrow().iter().for_each(|(_, canvas)| {
+            if let Some(canvas) = canvas.upgrade() {
+                canvas.borrow().transient_activation();
+            }
+        });
     }
 
     pub fn event_loop_recreation(&self, allow: bool) {
@@ -827,10 +780,6 @@ impl Shared {
     pub(crate) fn poll_strategy(&self) -> PollStrategy {
         self.0.poll_strategy.get()
     }
-
-    pub(crate) fn waker(&self) -> Waker<Weak<Execution>> {
-        self.0.proxy_spawner.waker()
-    }
 }
 
 pub(crate) enum EventWrapper {

src/platform_impl/web/event_loop/window_target.rs

@@ -3,9 +3,10 @@ use std::clone::Clone;
 use std::collections::{vec_deque::IntoIter as VecDequeIter, VecDeque};
 use std::iter;
 use std::marker::PhantomData;
-use std::rc::{Rc, Weak};
+use std::rc::Rc;
+use std::sync::atomic::Ordering;
 
-use super::runner::{EventWrapper, Execution};
+use super::runner::EventWrapper;
 use super::{
     super::{monitor::MonitorHandle, KeyEventExtra},
     backend,
@@ -19,7 +20,6 @@ use crate::event::{
 use crate::event_loop::{ControlFlow, DeviceEvents};
 use crate::keyboard::ModifiersState;
 use crate::platform::web::PollStrategy;
-use crate::platform_impl::platform::r#async::Waker;
 use crate::window::{Theme, WindowId as RootWindowId};
 
 #[derive(Default)]
@@ -81,6 +81,7 @@ impl<T> EventLoopWindowTarget<T> {
         id: WindowId,
         prevent_default: bool,
     ) {
+        self.runner.add_canvas(RootWindowId(id), canvas);
         let canvas_clone = canvas.clone();
         let mut canvas = canvas.borrow_mut();
         canvas.set_attribute("data-raw-handle", &id.0.to_string());
@@ -91,7 +92,7 @@ impl<T> EventLoopWindowTarget<T> {
         let has_focus = canvas.has_focus.clone();
         let modifiers = self.modifiers.clone();
         canvas.on_blur(move || {
-            has_focus.set(false);
+            has_focus.store(false, Ordering::Relaxed);
 
             let clear_modifiers = (!modifiers.get().is_empty()).then(|| {
                 modifiers.set(ModifiersState::empty());
@@ -114,7 +115,7 @@ impl<T> EventLoopWindowTarget<T> {
         let runner = self.runner.clone();
         let has_focus = canvas.has_focus.clone();
         canvas.on_focus(move || {
-            if !has_focus.replace(true) {
+            if !has_focus.swap(true, Ordering::Relaxed) {
                 runner.send_event(Event::WindowEvent {
                     window_id: RootWindowId(id),
                     event: WindowEvent::Focused(true),
@@ -203,13 +204,15 @@ impl<T> EventLoopWindowTarget<T> {
             let modifiers = self.modifiers.clone();
 
             move |active_modifiers, pointer_id| {
-                let focus = (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
-                    modifiers.set(active_modifiers);
-                    Event::WindowEvent {
-                        window_id: RootWindowId(id),
-                        event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                    }
-                });
+                let focus = (has_focus.load(Ordering::Relaxed)
+                    && modifiers.get() != active_modifiers)
+                    .then(|| {
+                        modifiers.set(active_modifiers);
+                        Event::WindowEvent {
+                            window_id: RootWindowId(id),
+                            event: WindowEvent::ModifiersChanged(active_modifiers.into()),
+                        }
+                    });
 
                 let pointer = pointer_id.map(|pointer_id| Event::WindowEvent {
                     window_id: RootWindowId(id),
@@ -230,13 +233,15 @@ impl<T> EventLoopWindowTarget<T> {
             let modifiers = self.modifiers.clone();
 
             move |active_modifiers, pointer_id| {
-                let focus = (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
-                    modifiers.set(active_modifiers);
-                    Event::WindowEvent {
-                        window_id: RootWindowId(id),
-                        event: WindowEvent::ModifiersChanged(active_modifiers.into()),
-                    }
-                });
+                let focus = (has_focus.load(Ordering::Relaxed)
+                    && modifiers.get() != active_modifiers)
+                    .then(|| {
+                        modifiers.set(active_modifiers);
+                        Event::WindowEvent {
+                            window_id: RootWindowId(id),
+                            event: WindowEvent::ModifiersChanged(active_modifiers.into()),
+                        }
+                    });
 
                 let pointer = pointer_id.map(|pointer_id| Event::WindowEvent {
                     window_id: RootWindowId(id),
@@ -258,7 +263,7 @@ impl<T> EventLoopWindowTarget<T> {
                 let modifiers = self.modifiers.clone();
 
                 move |active_modifiers| {
-                    if has_focus.get() && modifiers.get() != active_modifiers {
+                    if has_focus.load(Ordering::Relaxed) && modifiers.get() != active_modifiers {
                         modifiers.set(active_modifiers);
                         runner.send_event(Event::WindowEvent {
                             window_id: RootWindowId(id),
@@ -273,8 +278,9 @@ impl<T> EventLoopWindowTarget<T> {
                 let modifiers = self.modifiers.clone();
 
                 move |active_modifiers, pointer_id, events| {
-                    let modifiers =
-                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
+                    let modifiers = (has_focus.load(Ordering::Relaxed)
+                        && modifiers.get() != active_modifiers)
+                        .then(|| {
                             modifiers.set(active_modifiers);
                             Event::WindowEvent {
                                 window_id: RootWindowId(id),
@@ -301,8 +307,9 @@ impl<T> EventLoopWindowTarget<T> {
                 let modifiers = self.modifiers.clone();
 
                 move |active_modifiers, device_id, events| {
-                    let modifiers =
-                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
+                    let modifiers = (has_focus.load(Ordering::Relaxed)
+                        && modifiers.get() != active_modifiers)
+                        .then(|| {
                             modifiers.set(active_modifiers);
                             Event::WindowEvent {
                                 window_id: RootWindowId(id),
@@ -334,8 +341,9 @@ impl<T> EventLoopWindowTarget<T> {
                       position: crate::dpi::PhysicalPosition<f64>,
                       buttons,
                       button| {
-                    let modifiers =
-                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
+                    let modifiers = (has_focus.load(Ordering::Relaxed)
+                        && modifiers.get() != active_modifiers)
+                        .then(|| {
                             modifiers.set(active_modifiers);
                             Event::WindowEvent {
                                 window_id: RootWindowId(id),
@@ -465,7 +473,7 @@ impl<T> EventLoopWindowTarget<T> {
                 let modifiers = self.modifiers.clone();
 
                 move |active_modifiers| {
-                    if has_focus.get() && modifiers.get() != active_modifiers {
+                    if has_focus.load(Ordering::Relaxed) && modifiers.get() != active_modifiers {
                         modifiers.set(active_modifiers);
                         runner.send_event(Event::WindowEvent {
                             window_id: RootWindowId(id),
@@ -480,8 +488,9 @@ impl<T> EventLoopWindowTarget<T> {
                 let modifiers = self.modifiers.clone();
 
                 move |active_modifiers, pointer_id, position, button| {
-                    let modifiers =
-                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
+                    let modifiers = (has_focus.load(Ordering::Relaxed)
+                        && modifiers.get() != active_modifiers)
+                        .then(|| {
                             modifiers.set(active_modifiers);
                             Event::WindowEvent {
                                 window_id: RootWindowId(id),
@@ -519,8 +528,9 @@ impl<T> EventLoopWindowTarget<T> {
                 let modifiers = self.modifiers.clone();
 
                 move |active_modifiers, device_id, location, force| {
-                    let modifiers =
-                        (has_focus.get() && modifiers.get() != active_modifiers).then(|| {
+                    let modifiers = (has_focus.load(Ordering::Relaxed)
+                        && modifiers.get() != active_modifiers)
+                        .then(|| {
                             modifiers.set(active_modifiers);
                             Event::WindowEvent {
                                 window_id: RootWindowId(id),
@@ -548,7 +558,8 @@ impl<T> EventLoopWindowTarget<T> {
         let modifiers = self.modifiers.clone();
         canvas.on_mouse_wheel(
             move |pointer_id, delta, active_modifiers| {
-                let modifiers_changed = (has_focus.get() && modifiers.get() != active_modifiers)
+                let modifiers_changed = (has_focus.load(Ordering::Relaxed)
+                    && modifiers.get() != active_modifiers)
                     .then(|| {
                         modifiers.set(active_modifiers);
                         Event::WindowEvent {
@@ -649,8 +660,6 @@ impl<T> EventLoopWindowTarget<T> {
         canvas.on_animation_frame(move || runner.request_redraw(RootWindowId(id)));
 
         canvas.on_touch_end();
-
-        canvas.on_context_menu(prevent_default);
     }
 
     pub fn available_monitors(&self) -> VecDequeIter<MonitorHandle> {
@@ -704,8 +713,4 @@ impl<T> EventLoopWindowTarget<T> {
     pub(crate) fn poll_strategy(&self) -> PollStrategy {
         self.runner.poll_strategy()
     }
-
-    pub(crate) fn waker(&self) -> Waker<Weak<Execution>> {
-        self.runner.waker()
-    }
 }

src/platform_impl/web/keyboard.rs

@@ -1,328 +1,328 @@
 use smol_str::SmolStr;
 
-use crate::keyboard::{Key, KeyCode, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
+use crate::keyboard::{Key, KeyCode, NativeKey, NativeKeyCode};
 
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub(crate) struct KeyEventExtra;
 
 impl Key {
     pub(crate) fn from_key_attribute_value(kav: &str) -> Self {
-        Key::Named(match kav {
-            "Unidentified" => return Key::Unidentified(NativeKey::Web(SmolStr::new(kav))),
-            "Dead" => return Key::Dead(None),
-            "Alt" => NamedKey::Alt,
-            "AltGraph" => NamedKey::AltGraph,
-            "CapsLock" => NamedKey::CapsLock,
-            "Control" => NamedKey::Control,
-            "Fn" => NamedKey::Fn,
-            "FnLock" => NamedKey::FnLock,
-            "NumLock" => NamedKey::NumLock,
-            "ScrollLock" => NamedKey::ScrollLock,
-            "Shift" => NamedKey::Shift,
-            "Symbol" => NamedKey::Symbol,
-            "SymbolLock" => NamedKey::SymbolLock,
-            "Hyper" => NamedKey::Hyper,
-            "Meta" => NamedKey::Super,
-            "Enter" => NamedKey::Enter,
-            "Tab" => NamedKey::Tab,
-            " " => NamedKey::Space,
-            "ArrowDown" => NamedKey::ArrowDown,
-            "ArrowLeft" => NamedKey::ArrowLeft,
-            "ArrowRight" => NamedKey::ArrowRight,
-            "ArrowUp" => NamedKey::ArrowUp,
-            "End" => NamedKey::End,
-            "Home" => NamedKey::Home,
-            "PageDown" => NamedKey::PageDown,
-            "PageUp" => NamedKey::PageUp,
-            "Backspace" => NamedKey::Backspace,
-            "Clear" => NamedKey::Clear,
-            "Copy" => NamedKey::Copy,
-            "CrSel" => NamedKey::CrSel,
-            "Cut" => NamedKey::Cut,
-            "Delete" => NamedKey::Delete,
-            "EraseEof" => NamedKey::EraseEof,
-            "ExSel" => NamedKey::ExSel,
-            "Insert" => NamedKey::Insert,
-            "Paste" => NamedKey::Paste,
-            "Redo" => NamedKey::Redo,
-            "Undo" => NamedKey::Undo,
-            "Accept" => NamedKey::Accept,
-            "Again" => NamedKey::Again,
-            "Attn" => NamedKey::Attn,
-            "Cancel" => NamedKey::Cancel,
-            "ContextMenu" => NamedKey::ContextMenu,
-            "Escape" => NamedKey::Escape,
-            "Execute" => NamedKey::Execute,
-            "Find" => NamedKey::Find,
-            "Help" => NamedKey::Help,
-            "Pause" => NamedKey::Pause,
-            "Play" => NamedKey::Play,
-            "Props" => NamedKey::Props,
-            "Select" => NamedKey::Select,
-            "ZoomIn" => NamedKey::ZoomIn,
-            "ZoomOut" => NamedKey::ZoomOut,
-            "BrightnessDown" => NamedKey::BrightnessDown,
-            "BrightnessUp" => NamedKey::BrightnessUp,
-            "Eject" => NamedKey::Eject,
-            "LogOff" => NamedKey::LogOff,
-            "Power" => NamedKey::Power,
-            "PowerOff" => NamedKey::PowerOff,
-            "PrintScreen" => NamedKey::PrintScreen,
-            "Hibernate" => NamedKey::Hibernate,
-            "Standby" => NamedKey::Standby,
-            "WakeUp" => NamedKey::WakeUp,
-            "AllCandidates" => NamedKey::AllCandidates,
-            "Alphanumeric" => NamedKey::Alphanumeric,
-            "CodeInput" => NamedKey::CodeInput,
-            "Compose" => NamedKey::Compose,
-            "Convert" => NamedKey::Convert,
-            "FinalMode" => NamedKey::FinalMode,
-            "GroupFirst" => NamedKey::GroupFirst,
-            "GroupLast" => NamedKey::GroupLast,
-            "GroupNext" => NamedKey::GroupNext,
-            "GroupPrevious" => NamedKey::GroupPrevious,
-            "ModeChange" => NamedKey::ModeChange,
-            "NextCandidate" => NamedKey::NextCandidate,
-            "NonConvert" => NamedKey::NonConvert,
-            "PreviousCandidate" => NamedKey::PreviousCandidate,
-            "Process" => NamedKey::Process,
-            "SingleCandidate" => NamedKey::SingleCandidate,
-            "HangulMode" => NamedKey::HangulMode,
-            "HanjaMode" => NamedKey::HanjaMode,
-            "JunjaMode" => NamedKey::JunjaMode,
-            "Eisu" => NamedKey::Eisu,
-            "Hankaku" => NamedKey::Hankaku,
-            "Hiragana" => NamedKey::Hiragana,
-            "HiraganaKatakana" => NamedKey::HiraganaKatakana,
-            "KanaMode" => NamedKey::KanaMode,
-            "KanjiMode" => NamedKey::KanjiMode,
-            "Katakana" => NamedKey::Katakana,
-            "Romaji" => NamedKey::Romaji,
-            "Zenkaku" => NamedKey::Zenkaku,
-            "ZenkakuHankaku" => NamedKey::ZenkakuHankaku,
-            "Soft1" => NamedKey::Soft1,
-            "Soft2" => NamedKey::Soft2,
-            "Soft3" => NamedKey::Soft3,
-            "Soft4" => NamedKey::Soft4,
-            "ChannelDown" => NamedKey::ChannelDown,
-            "ChannelUp" => NamedKey::ChannelUp,
-            "Close" => NamedKey::Close,
-            "MailForward" => NamedKey::MailForward,
-            "MailReply" => NamedKey::MailReply,
-            "MailSend" => NamedKey::MailSend,
-            "MediaClose" => NamedKey::MediaClose,
-            "MediaFastForward" => NamedKey::MediaFastForward,
-            "MediaPause" => NamedKey::MediaPause,
-            "MediaPlay" => NamedKey::MediaPlay,
-            "MediaPlayPause" => NamedKey::MediaPlayPause,
-            "MediaRecord" => NamedKey::MediaRecord,
-            "MediaRewind" => NamedKey::MediaRewind,
-            "MediaStop" => NamedKey::MediaStop,
-            "MediaTrackNext" => NamedKey::MediaTrackNext,
-            "MediaTrackPrevious" => NamedKey::MediaTrackPrevious,
-            "New" => NamedKey::New,
-            "Open" => NamedKey::Open,
-            "Print" => NamedKey::Print,
-            "Save" => NamedKey::Save,
-            "SpellCheck" => NamedKey::SpellCheck,
-            "Key11" => NamedKey::Key11,
-            "Key12" => NamedKey::Key12,
-            "AudioBalanceLeft" => NamedKey::AudioBalanceLeft,
-            "AudioBalanceRight" => NamedKey::AudioBalanceRight,
-            "AudioBassBoostDown" => NamedKey::AudioBassBoostDown,
-            "AudioBassBoostToggle" => NamedKey::AudioBassBoostToggle,
-            "AudioBassBoostUp" => NamedKey::AudioBassBoostUp,
-            "AudioFaderFront" => NamedKey::AudioFaderFront,
-            "AudioFaderRear" => NamedKey::AudioFaderRear,
-            "AudioSurroundModeNext" => NamedKey::AudioSurroundModeNext,
-            "AudioTrebleDown" => NamedKey::AudioTrebleDown,
-            "AudioTrebleUp" => NamedKey::AudioTrebleUp,
-            "AudioVolumeDown" => NamedKey::AudioVolumeDown,
-            "AudioVolumeUp" => NamedKey::AudioVolumeUp,
-            "AudioVolumeMute" => NamedKey::AudioVolumeMute,
-            "MicrophoneToggle" => NamedKey::MicrophoneToggle,
-            "MicrophoneVolumeDown" => NamedKey::MicrophoneVolumeDown,
-            "MicrophoneVolumeUp" => NamedKey::MicrophoneVolumeUp,
-            "MicrophoneVolumeMute" => NamedKey::MicrophoneVolumeMute,
-            "SpeechCorrectionList" => NamedKey::SpeechCorrectionList,
-            "SpeechInputToggle" => NamedKey::SpeechInputToggle,
-            "LaunchApplication1" => NamedKey::LaunchApplication1,
-            "LaunchApplication2" => NamedKey::LaunchApplication2,
-            "LaunchCalendar" => NamedKey::LaunchCalendar,
-            "LaunchContacts" => NamedKey::LaunchContacts,
-            "LaunchMail" => NamedKey::LaunchMail,
-            "LaunchMediaPlayer" => NamedKey::LaunchMediaPlayer,
-            "LaunchMusicPlayer" => NamedKey::LaunchMusicPlayer,
-            "LaunchPhone" => NamedKey::LaunchPhone,
-            "LaunchScreenSaver" => NamedKey::LaunchScreenSaver,
-            "LaunchSpreadsheet" => NamedKey::LaunchSpreadsheet,
-            "LaunchWebBrowser" => NamedKey::LaunchWebBrowser,
-            "LaunchWebCam" => NamedKey::LaunchWebCam,
-            "LaunchWordProcessor" => NamedKey::LaunchWordProcessor,
-            "BrowserBack" => NamedKey::BrowserBack,
-            "BrowserFavorites" => NamedKey::BrowserFavorites,
-            "BrowserForward" => NamedKey::BrowserForward,
-            "BrowserHome" => NamedKey::BrowserHome,
-            "BrowserRefresh" => NamedKey::BrowserRefresh,
-            "BrowserSearch" => NamedKey::BrowserSearch,
-            "BrowserStop" => NamedKey::BrowserStop,
-            "AppSwitch" => NamedKey::AppSwitch,
-            "Call" => NamedKey::Call,
-            "Camera" => NamedKey::Camera,
-            "CameraFocus" => NamedKey::CameraFocus,
-            "EndCall" => NamedKey::EndCall,
-            "GoBack" => NamedKey::GoBack,
-            "GoHome" => NamedKey::GoHome,
-            "HeadsetHook" => NamedKey::HeadsetHook,
-            "LastNumberRedial" => NamedKey::LastNumberRedial,
-            "Notification" => NamedKey::Notification,
-            "MannerMode" => NamedKey::MannerMode,
-            "VoiceDial" => NamedKey::VoiceDial,
-            "TV" => NamedKey::TV,
-            "TV3DMode" => NamedKey::TV3DMode,
-            "TVAntennaCable" => NamedKey::TVAntennaCable,
-            "TVAudioDescription" => NamedKey::TVAudioDescription,
-            "TVAudioDescriptionMixDown" => NamedKey::TVAudioDescriptionMixDown,
-            "TVAudioDescriptionMixUp" => NamedKey::TVAudioDescriptionMixUp,
-            "TVContentsMenu" => NamedKey::TVContentsMenu,
-            "TVDataService" => NamedKey::TVDataService,
-            "TVInput" => NamedKey::TVInput,
-            "TVInputComponent1" => NamedKey::TVInputComponent1,
-            "TVInputComponent2" => NamedKey::TVInputComponent2,
-            "TVInputComposite1" => NamedKey::TVInputComposite1,
-            "TVInputComposite2" => NamedKey::TVInputComposite2,
-            "TVInputHDMI1" => NamedKey::TVInputHDMI1,
-            "TVInputHDMI2" => NamedKey::TVInputHDMI2,
-            "TVInputHDMI3" => NamedKey::TVInputHDMI3,
-            "TVInputHDMI4" => NamedKey::TVInputHDMI4,
-            "TVInputVGA1" => NamedKey::TVInputVGA1,
-            "TVMediaContext" => NamedKey::TVMediaContext,
-            "TVNetwork" => NamedKey::TVNetwork,
-            "TVNumberEntry" => NamedKey::TVNumberEntry,
-            "TVPower" => NamedKey::TVPower,
-            "TVRadioService" => NamedKey::TVRadioService,
-            "TVSatellite" => NamedKey::TVSatellite,
-            "TVSatelliteBS" => NamedKey::TVSatelliteBS,
-            "TVSatelliteCS" => NamedKey::TVSatelliteCS,
-            "TVSatelliteToggle" => NamedKey::TVSatelliteToggle,
-            "TVTerrestrialAnalog" => NamedKey::TVTerrestrialAnalog,
-            "TVTerrestrialDigital" => NamedKey::TVTerrestrialDigital,
-            "TVTimer" => NamedKey::TVTimer,
-            "AVRInput" => NamedKey::AVRInput,
-            "AVRPower" => NamedKey::AVRPower,
-            "ColorF0Red" => NamedKey::ColorF0Red,
-            "ColorF1Green" => NamedKey::ColorF1Green,
-            "ColorF2Yellow" => NamedKey::ColorF2Yellow,
-            "ColorF3Blue" => NamedKey::ColorF3Blue,
-            "ColorF4Grey" => NamedKey::ColorF4Grey,
-            "ColorF5Brown" => NamedKey::ColorF5Brown,
-            "ClosedCaptionToggle" => NamedKey::ClosedCaptionToggle,
-            "Dimmer" => NamedKey::Dimmer,
-            "DisplaySwap" => NamedKey::DisplaySwap,
-            "DVR" => NamedKey::DVR,
-            "Exit" => NamedKey::Exit,
-            "FavoriteClear0" => NamedKey::FavoriteClear0,
-            "FavoriteClear1" => NamedKey::FavoriteClear1,
-            "FavoriteClear2" => NamedKey::FavoriteClear2,
-            "FavoriteClear3" => NamedKey::FavoriteClear3,
-            "FavoriteRecall0" => NamedKey::FavoriteRecall0,
-            "FavoriteRecall1" => NamedKey::FavoriteRecall1,
-            "FavoriteRecall2" => NamedKey::FavoriteRecall2,
-            "FavoriteRecall3" => NamedKey::FavoriteRecall3,
-            "FavoriteStore0" => NamedKey::FavoriteStore0,
-            "FavoriteStore1" => NamedKey::FavoriteStore1,
-            "FavoriteStore2" => NamedKey::FavoriteStore2,
-            "FavoriteStore3" => NamedKey::FavoriteStore3,
-            "Guide" => NamedKey::Guide,
-            "GuideNextDay" => NamedKey::GuideNextDay,
-            "GuidePreviousDay" => NamedKey::GuidePreviousDay,
-            "Info" => NamedKey::Info,
-            "InstantReplay" => NamedKey::InstantReplay,
-            "Link" => NamedKey::Link,
-            "ListProgram" => NamedKey::ListProgram,
-            "LiveContent" => NamedKey::LiveContent,
-            "Lock" => NamedKey::Lock,
-            "MediaApps" => NamedKey::MediaApps,
-            "MediaAudioTrack" => NamedKey::MediaAudioTrack,
-            "MediaLast" => NamedKey::MediaLast,
-            "MediaSkipBackward" => NamedKey::MediaSkipBackward,
-            "MediaSkipForward" => NamedKey::MediaSkipForward,
-            "MediaStepBackward" => NamedKey::MediaStepBackward,
-            "MediaStepForward" => NamedKey::MediaStepForward,
-            "MediaTopMenu" => NamedKey::MediaTopMenu,
-            "NavigateIn" => NamedKey::NavigateIn,
-            "NavigateNext" => NamedKey::NavigateNext,
-            "NavigateOut" => NamedKey::NavigateOut,
-            "NavigatePrevious" => NamedKey::NavigatePrevious,
-            "NextFavoriteChannel" => NamedKey::NextFavoriteChannel,
-            "NextUserProfile" => NamedKey::NextUserProfile,
-            "OnDemand" => NamedKey::OnDemand,
-            "Pairing" => NamedKey::Pairing,
-            "PinPDown" => NamedKey::PinPDown,
-            "PinPMove" => NamedKey::PinPMove,
-            "PinPToggle" => NamedKey::PinPToggle,
-            "PinPUp" => NamedKey::PinPUp,
-            "PlaySpeedDown" => NamedKey::PlaySpeedDown,
-            "PlaySpeedReset" => NamedKey::PlaySpeedReset,
-            "PlaySpeedUp" => NamedKey::PlaySpeedUp,
-            "RandomToggle" => NamedKey::RandomToggle,
-            "RcLowBattery" => NamedKey::RcLowBattery,
-            "RecordSpeedNext" => NamedKey::RecordSpeedNext,
-            "RfBypass" => NamedKey::RfBypass,
-            "ScanChannelsToggle" => NamedKey::ScanChannelsToggle,
-            "ScreenModeNext" => NamedKey::ScreenModeNext,
-            "Settings" => NamedKey::Settings,
-            "SplitScreenToggle" => NamedKey::SplitScreenToggle,
-            "STBInput" => NamedKey::STBInput,
-            "STBPower" => NamedKey::STBPower,
-            "Subtitle" => NamedKey::Subtitle,
-            "Teletext" => NamedKey::Teletext,
-            "VideoModeNext" => NamedKey::VideoModeNext,
-            "Wink" => NamedKey::Wink,
-            "ZoomToggle" => NamedKey::ZoomToggle,
-            "F1" => NamedKey::F1,
-            "F2" => NamedKey::F2,
-            "F3" => NamedKey::F3,
-            "F4" => NamedKey::F4,
-            "F5" => NamedKey::F5,
-            "F6" => NamedKey::F6,
-            "F7" => NamedKey::F7,
-            "F8" => NamedKey::F8,
-            "F9" => NamedKey::F9,
-            "F10" => NamedKey::F10,
-            "F11" => NamedKey::F11,
-            "F12" => NamedKey::F12,
-            "F13" => NamedKey::F13,
-            "F14" => NamedKey::F14,
-            "F15" => NamedKey::F15,
-            "F16" => NamedKey::F16,
-            "F17" => NamedKey::F17,
-            "F18" => NamedKey::F18,
-            "F19" => NamedKey::F19,
-            "F20" => NamedKey::F20,
-            "F21" => NamedKey::F21,
-            "F22" => NamedKey::F22,
-            "F23" => NamedKey::F23,
-            "F24" => NamedKey::F24,
-            "F25" => NamedKey::F25,
-            "F26" => NamedKey::F26,
-            "F27" => NamedKey::F27,
-            "F28" => NamedKey::F28,
-            "F29" => NamedKey::F29,
-            "F30" => NamedKey::F30,
-            "F31" => NamedKey::F31,
-            "F32" => NamedKey::F32,
-            "F33" => NamedKey::F33,
-            "F34" => NamedKey::F34,
-            "F35" => NamedKey::F35,
-            string => return Key::Character(SmolStr::new(string)),
-        })
+        match kav {
+            "Unidentified" => Key::Unidentified(NativeKey::Web(SmolStr::new(kav))),
+            "Dead" => Key::Dead(None),
+            "Alt" => Key::Alt,
+            "AltGraph" => Key::AltGraph,
+            "CapsLock" => Key::CapsLock,
+            "Control" => Key::Control,
+            "Fn" => Key::Fn,
+            "FnLock" => Key::FnLock,
+            "NumLock" => Key::NumLock,
+            "ScrollLock" => Key::ScrollLock,
+            "Shift" => Key::Shift,
+            "Symbol" => Key::Symbol,
+            "SymbolLock" => Key::SymbolLock,
+            "Hyper" => Key::Hyper,
+            "Meta" => Key::Super,
+            "Enter" => Key::Enter,
+            "Tab" => Key::Tab,
+            " " => Key::Space,
+            "ArrowDown" => Key::ArrowDown,
+            "ArrowLeft" => Key::ArrowLeft,
+            "ArrowRight" => Key::ArrowRight,
+            "ArrowUp" => Key::ArrowUp,
+            "End" => Key::End,
+            "Home" => Key::Home,
+            "PageDown" => Key::PageDown,
+            "PageUp" => Key::PageUp,
+            "Backspace" => Key::Backspace,
+            "Clear" => Key::Clear,
+            "Copy" => Key::Copy,
+            "CrSel" => Key::CrSel,
+            "Cut" => Key::Cut,
+            "Delete" => Key::Delete,
+            "EraseEof" => Key::EraseEof,
+            "ExSel" => Key::ExSel,
+            "Insert" => Key::Insert,
+            "Paste" => Key::Paste,
+            "Redo" => Key::Redo,
+            "Undo" => Key::Undo,
+            "Accept" => Key::Accept,
+            "Again" => Key::Again,
+            "Attn" => Key::Attn,
+            "Cancel" => Key::Cancel,
+            "ContextMenu" => Key::ContextMenu,
+            "Escape" => Key::Escape,
+            "Execute" => Key::Execute,
+            "Find" => Key::Find,
+            "Help" => Key::Help,
+            "Pause" => Key::Pause,
+            "Play" => Key::Play,
+            "Props" => Key::Props,
+            "Select" => Key::Select,
+            "ZoomIn" => Key::ZoomIn,
+            "ZoomOut" => Key::ZoomOut,
+            "BrightnessDown" => Key::BrightnessDown,
+            "BrightnessUp" => Key::BrightnessUp,
+            "Eject" => Key::Eject,
+            "LogOff" => Key::LogOff,
+            "Power" => Key::Power,
+            "PowerOff" => Key::PowerOff,
+            "PrintScreen" => Key::PrintScreen,
+            "Hibernate" => Key::Hibernate,
+            "Standby" => Key::Standby,
+            "WakeUp" => Key::WakeUp,
+            "AllCandidates" => Key::AllCandidates,
+            "Alphanumeric" => Key::Alphanumeric,
+            "CodeInput" => Key::CodeInput,
+            "Compose" => Key::Compose,
+            "Convert" => Key::Convert,
+            "FinalMode" => Key::FinalMode,
+            "GroupFirst" => Key::GroupFirst,
+            "GroupLast" => Key::GroupLast,
+            "GroupNext" => Key::GroupNext,
+            "GroupPrevious" => Key::GroupPrevious,
+            "ModeChange" => Key::ModeChange,
+            "NextCandidate" => Key::NextCandidate,
+            "NonConvert" => Key::NonConvert,
+            "PreviousCandidate" => Key::PreviousCandidate,
+            "Process" => Key::Process,
+            "SingleCandidate" => Key::SingleCandidate,
+            "HangulMode" => Key::HangulMode,
+            "HanjaMode" => Key::HanjaMode,
+            "JunjaMode" => Key::JunjaMode,
+            "Eisu" => Key::Eisu,
+            "Hankaku" => Key::Hankaku,
+            "Hiragana" => Key::Hiragana,
+            "HiraganaKatakana" => Key::HiraganaKatakana,
+            "KanaMode" => Key::KanaMode,
+            "KanjiMode" => Key::KanjiMode,
+            "Katakana" => Key::Katakana,
+            "Romaji" => Key::Romaji,
+            "Zenkaku" => Key::Zenkaku,
+            "ZenkakuHankaku" => Key::ZenkakuHankaku,
+            "Soft1" => Key::Soft1,
+            "Soft2" => Key::Soft2,
+            "Soft3" => Key::Soft3,
+            "Soft4" => Key::Soft4,
+            "ChannelDown" => Key::ChannelDown,
+            "ChannelUp" => Key::ChannelUp,
+            "Close" => Key::Close,
+            "MailForward" => Key::MailForward,
+            "MailReply" => Key::MailReply,
+            "MailSend" => Key::MailSend,
+            "MediaClose" => Key::MediaClose,
+            "MediaFastForward" => Key::MediaFastForward,
+            "MediaPause" => Key::MediaPause,
+            "MediaPlay" => Key::MediaPlay,
+            "MediaPlayPause" => Key::MediaPlayPause,
+            "MediaRecord" => Key::MediaRecord,
+            "MediaRewind" => Key::MediaRewind,
+            "MediaStop" => Key::MediaStop,
+            "MediaTrackNext" => Key::MediaTrackNext,
+            "MediaTrackPrevious" => Key::MediaTrackPrevious,
+            "New" => Key::New,
+            "Open" => Key::Open,
+            "Print" => Key::Print,
+            "Save" => Key::Save,
+            "SpellCheck" => Key::SpellCheck,
+            "Key11" => Key::Key11,
+            "Key12" => Key::Key12,
+            "AudioBalanceLeft" => Key::AudioBalanceLeft,
+            "AudioBalanceRight" => Key::AudioBalanceRight,
+            "AudioBassBoostDown" => Key::AudioBassBoostDown,
+            "AudioBassBoostToggle" => Key::AudioBassBoostToggle,
+            "AudioBassBoostUp" => Key::AudioBassBoostUp,
+            "AudioFaderFront" => Key::AudioFaderFront,
+            "AudioFaderRear" => Key::AudioFaderRear,
+            "AudioSurroundModeNext" => Key::AudioSurroundModeNext,
+            "AudioTrebleDown" => Key::AudioTrebleDown,
+            "AudioTrebleUp" => Key::AudioTrebleUp,
+            "AudioVolumeDown" => Key::AudioVolumeDown,
+            "AudioVolumeUp" => Key::AudioVolumeUp,
+            "AudioVolumeMute" => Key::AudioVolumeMute,
+            "MicrophoneToggle" => Key::MicrophoneToggle,
+            "MicrophoneVolumeDown" => Key::MicrophoneVolumeDown,
+            "MicrophoneVolumeUp" => Key::MicrophoneVolumeUp,
+            "MicrophoneVolumeMute" => Key::MicrophoneVolumeMute,
+            "SpeechCorrectionList" => Key::SpeechCorrectionList,
+            "SpeechInputToggle" => Key::SpeechInputToggle,
+            "LaunchApplication1" => Key::LaunchApplication1,
+            "LaunchApplication2" => Key::LaunchApplication2,
+            "LaunchCalendar" => Key::LaunchCalendar,
+            "LaunchContacts" => Key::LaunchContacts,
+            "LaunchMail" => Key::LaunchMail,
+            "LaunchMediaPlayer" => Key::LaunchMediaPlayer,
+            "LaunchMusicPlayer" => Key::LaunchMusicPlayer,
+            "LaunchPhone" => Key::LaunchPhone,
+            "LaunchScreenSaver" => Key::LaunchScreenSaver,
+            "LaunchSpreadsheet" => Key::LaunchSpreadsheet,
+            "LaunchWebBrowser" => Key::LaunchWebBrowser,
+            "LaunchWebCam" => Key::LaunchWebCam,
+            "LaunchWordProcessor" => Key::LaunchWordProcessor,
+            "BrowserBack" => Key::BrowserBack,
+            "BrowserFavorites" => Key::BrowserFavorites,
+            "BrowserForward" => Key::BrowserForward,
+            "BrowserHome" => Key::BrowserHome,
+            "BrowserRefresh" => Key::BrowserRefresh,
+            "BrowserSearch" => Key::BrowserSearch,
+            "BrowserStop" => Key::BrowserStop,
+            "AppSwitch" => Key::AppSwitch,
+            "Call" => Key::Call,
+            "Camera" => Key::Camera,
+            "CameraFocus" => Key::CameraFocus,
+            "EndCall" => Key::EndCall,
+            "GoBack" => Key::GoBack,
+            "GoHome" => Key::GoHome,
+            "HeadsetHook" => Key::HeadsetHook,
+            "LastNumberRedial" => Key::LastNumberRedial,
+            "Notification" => Key::Notification,
+            "MannerMode" => Key::MannerMode,
+            "VoiceDial" => Key::VoiceDial,
+            "TV" => Key::TV,
+            "TV3DMode" => Key::TV3DMode,
+            "TVAntennaCable" => Key::TVAntennaCable,
+            "TVAudioDescription" => Key::TVAudioDescription,
+            "TVAudioDescriptionMixDown" => Key::TVAudioDescriptionMixDown,
+            "TVAudioDescriptionMixUp" => Key::TVAudioDescriptionMixUp,
+            "TVContentsMenu" => Key::TVContentsMenu,
+            "TVDataService" => Key::TVDataService,
+            "TVInput" => Key::TVInput,
+            "TVInputComponent1" => Key::TVInputComponent1,
+            "TVInputComponent2" => Key::TVInputComponent2,
+            "TVInputComposite1" => Key::TVInputComposite1,
+            "TVInputComposite2" => Key::TVInputComposite2,
+            "TVInputHDMI1" => Key::TVInputHDMI1,
+            "TVInputHDMI2" => Key::TVInputHDMI2,
+            "TVInputHDMI3" => Key::TVInputHDMI3,
+            "TVInputHDMI4" => Key::TVInputHDMI4,
+            "TVInputVGA1" => Key::TVInputVGA1,
+            "TVMediaContext" => Key::TVMediaContext,
+            "TVNetwork" => Key::TVNetwork,
+            "TVNumberEntry" => Key::TVNumberEntry,
+            "TVPower" => Key::TVPower,
+            "TVRadioService" => Key::TVRadioService,
+            "TVSatellite" => Key::TVSatellite,
+            "TVSatelliteBS" => Key::TVSatelliteBS,
+            "TVSatelliteCS" => Key::TVSatelliteCS,
+            "TVSatelliteToggle" => Key::TVSatelliteToggle,
+            "TVTerrestrialAnalog" => Key::TVTerrestrialAnalog,
+            "TVTerrestrialDigital" => Key::TVTerrestrialDigital,
+            "TVTimer" => Key::TVTimer,
+            "AVRInput" => Key::AVRInput,
+            "AVRPower" => Key::AVRPower,
+            "ColorF0Red" => Key::ColorF0Red,
+            "ColorF1Green" => Key::ColorF1Green,
+            "ColorF2Yellow" => Key::ColorF2Yellow,
+            "ColorF3Blue" => Key::ColorF3Blue,
+            "ColorF4Grey" => Key::ColorF4Grey,
+            "ColorF5Brown" => Key::ColorF5Brown,
+            "ClosedCaptionToggle" => Key::ClosedCaptionToggle,
+            "Dimmer" => Key::Dimmer,
+            "DisplaySwap" => Key::DisplaySwap,
+            "DVR" => Key::DVR,
+            "Exit" => Key::Exit,
+            "FavoriteClear0" => Key::FavoriteClear0,
+            "FavoriteClear1" => Key::FavoriteClear1,
+            "FavoriteClear2" => Key::FavoriteClear2,
+            "FavoriteClear3" => Key::FavoriteClear3,
+            "FavoriteRecall0" => Key::FavoriteRecall0,
+            "FavoriteRecall1" => Key::FavoriteRecall1,
+            "FavoriteRecall2" => Key::FavoriteRecall2,
+            "FavoriteRecall3" => Key::FavoriteRecall3,
+            "FavoriteStore0" => Key::FavoriteStore0,
+            "FavoriteStore1" => Key::FavoriteStore1,
+            "FavoriteStore2" => Key::FavoriteStore2,
+            "FavoriteStore3" => Key::FavoriteStore3,
+            "Guide" => Key::Guide,
+            "GuideNextDay" => Key::GuideNextDay,
+            "GuidePreviousDay" => Key::GuidePreviousDay,
+            "Info" => Key::Info,
+            "InstantReplay" => Key::InstantReplay,
+            "Link" => Key::Link,
+            "ListProgram" => Key::ListProgram,
+            "LiveContent" => Key::LiveContent,
+            "Lock" => Key::Lock,
+            "MediaApps" => Key::MediaApps,
+            "MediaAudioTrack" => Key::MediaAudioTrack,
+            "MediaLast" => Key::MediaLast,
+            "MediaSkipBackward" => Key::MediaSkipBackward,
+            "MediaSkipForward" => Key::MediaSkipForward,
+            "MediaStepBackward" => Key::MediaStepBackward,
+            "MediaStepForward" => Key::MediaStepForward,
+            "MediaTopMenu" => Key::MediaTopMenu,
+            "NavigateIn" => Key::NavigateIn,
+            "NavigateNext" => Key::NavigateNext,
+            "NavigateOut" => Key::NavigateOut,
+            "NavigatePrevious" => Key::NavigatePrevious,
+            "NextFavoriteChannel" => Key::NextFavoriteChannel,
+            "NextUserProfile" => Key::NextUserProfile,
+            "OnDemand" => Key::OnDemand,
+            "Pairing" => Key::Pairing,
+            "PinPDown" => Key::PinPDown,
+            "PinPMove" => Key::PinPMove,
+            "PinPToggle" => Key::PinPToggle,
+            "PinPUp" => Key::PinPUp,
+            "PlaySpeedDown" => Key::PlaySpeedDown,
+            "PlaySpeedReset" => Key::PlaySpeedReset,
+            "PlaySpeedUp" => Key::PlaySpeedUp,
+            "RandomToggle" => Key::RandomToggle,
+            "RcLowBattery" => Key::RcLowBattery,
+            "RecordSpeedNext" => Key::RecordSpeedNext,
+            "RfBypass" => Key::RfBypass,
+            "ScanChannelsToggle" => Key::ScanChannelsToggle,
+            "ScreenModeNext" => Key::ScreenModeNext,
+            "Settings" => Key::Settings,
+            "SplitScreenToggle" => Key::SplitScreenToggle,
+            "STBInput" => Key::STBInput,
+            "STBPower" => Key::STBPower,
+            "Subtitle" => Key::Subtitle,
+            "Teletext" => Key::Teletext,
+            "VideoModeNext" => Key::VideoModeNext,
+            "Wink" => Key::Wink,
+            "ZoomToggle" => Key::ZoomToggle,
+            "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,
+            "F13" => Key::F13,
+            "F14" => Key::F14,
+            "F15" => Key::F15,
+            "F16" => Key::F16,
+            "F17" => Key::F17,
+            "F18" => Key::F18,
+            "F19" => Key::F19,
+            "F20" => Key::F20,
+            "F21" => Key::F21,
+            "F22" => Key::F22,
+            "F23" => Key::F23,
+            "F24" => Key::F24,
+            "F25" => Key::F25,
+            "F26" => Key::F26,
+            "F27" => Key::F27,
+            "F28" => Key::F28,
+            "F29" => Key::F29,
+            "F30" => Key::F30,
+            "F31" => Key::F31,
+            "F32" => Key::F32,
+            "F33" => Key::F33,
+            "F34" => Key::F34,
+            "F35" => Key::F35,
+            string => Key::Character(SmolStr::new(string)),
+        }
     }
 }
 
-impl PhysicalKey {
+impl KeyCode {
     pub fn from_key_code_attribute_value(kcav: &str) -> Self {
-        PhysicalKey::Code(match kcav {
+        match kcav {
             "Backquote" => KeyCode::Backquote,
             "Backslash" => KeyCode::Backslash,
             "BracketLeft" => KeyCode::BracketLeft,
@@ -516,7 +516,7 @@ impl PhysicalKey {
             "F33" => KeyCode::F33,
             "F34" => KeyCode::F34,
             "F35" => KeyCode::F35,
-            _ => return PhysicalKey::Unidentified(NativeKeyCode::Unidentified),
-        })
+            _ => KeyCode::Unidentified(NativeKeyCode::Unidentified),
+        }
     }
 }

src/platform_impl/web/web_sys/canvas.rs

@@ -1,18 +1,18 @@
 use std::cell::Cell;
 use std::rc::{Rc, Weak};
+use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex};
 
 use smol_str::SmolStr;
 use wasm_bindgen::{closure::Closure, JsCast};
 use web_sys::{
-    CssStyleDeclaration, Document, Event, FocusEvent, HtmlCanvasElement, KeyboardEvent,
-    PointerEvent, WheelEvent,
+    CssStyleDeclaration, Document, Event, FocusEvent, HtmlCanvasElement, KeyboardEvent, WheelEvent,
 };
 
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
 use crate::error::OsError as RootOE;
 use crate::event::{Force, InnerSizeWriter, MouseButton, MouseScrollDelta};
-use crate::keyboard::{Key, KeyLocation, ModifiersState, PhysicalKey};
+use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState};
 use crate::platform_impl::{OsError, PlatformSpecificWindowBuilderAttributes};
 use crate::window::{WindowAttributes, WindowId as RootWindowId};
 
@@ -29,7 +29,7 @@ use super::{event, ButtonsState, ResizeScaleHandle};
 pub struct Canvas {
     common: Common,
     id: WindowId,
-    pub has_focus: Rc<Cell<bool>>,
+    pub has_focus: Arc<AtomicBool>,
     pub is_intersecting: Option<bool>,
     on_touch_start: Option<EventListenerHandle<dyn FnMut(Event)>>,
     on_focus: Option<EventListenerHandle<dyn FnMut(FocusEvent)>>,
@@ -43,7 +43,6 @@ pub struct Canvas {
     on_intersect: Option<IntersectionObserverHandle>,
     animation_frame_handler: AnimationFrameHandler,
     on_touch_end: Option<EventListenerHandle<dyn FnMut(Event)>>,
-    on_context_menu: Option<EventListenerHandle<dyn FnMut(PointerEvent)>>,
 }
 
 pub struct Common {
@@ -65,7 +64,7 @@ impl Canvas {
         attr: &WindowAttributes,
         platform_attr: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Self, RootOE> {
-        let canvas = match platform_attr.canvas.0 {
+        let canvas = match platform_attr.canvas {
             Some(canvas) => canvas,
             None => document
                 .create_element("canvas")
@@ -129,7 +128,7 @@ impl Canvas {
             super::set_canvas_position(&common.document, &common.raw, &common.style, position);
         }
 
-        if attr.fullscreen.0.is_some() {
+        if attr.fullscreen.is_some() {
             common.fullscreen_handler.request_fullscreen();
         }
 
@@ -140,7 +139,7 @@ impl Canvas {
         Ok(Canvas {
             common,
             id,
-            has_focus: Rc::new(Cell::new(false)),
+            has_focus: Arc::new(AtomicBool::new(false)),
             is_intersecting: None,
             on_touch_start: None,
             on_blur: None,
@@ -154,7 +153,6 @@ impl Canvas {
             on_intersect: None,
             animation_frame_handler: AnimationFrameHandler::new(window),
             on_touch_end: None,
-            on_context_menu: None,
         })
     }
 
@@ -261,7 +259,7 @@ impl Canvas {
 
     pub fn on_keyboard_release<F>(&mut self, mut handler: F, prevent_default: bool)
     where
-        F: 'static + FnMut(PhysicalKey, Key, Option<SmolStr>, KeyLocation, bool, ModifiersState),
+        F: 'static + FnMut(KeyCode, Key, Option<SmolStr>, KeyLocation, bool, ModifiersState),
     {
         self.on_keyboard_release =
             Some(self.common.add_event("keyup", move |event: KeyboardEvent| {
@@ -283,7 +281,7 @@ impl Canvas {
 
     pub fn on_keyboard_press<F>(&mut self, mut handler: F, prevent_default: bool)
     where
-        F: 'static + FnMut(PhysicalKey, Key, Option<SmolStr>, KeyLocation, bool, ModifiersState),
+        F: 'static + FnMut(KeyCode, Key, Option<SmolStr>, KeyLocation, bool, ModifiersState),
     {
         self.on_keyboard_press = Some(self.common.add_transient_event(
             "keydown",
@@ -449,17 +447,6 @@ impl Canvas {
         self.on_touch_end = Some(self.common.add_transient_event("touchend", |_| {}));
     }
 
-    pub(crate) fn on_context_menu(&mut self, prevent_default: bool) {
-        self.on_context_menu = Some(self.common.add_event(
-            "contextmenu",
-            move |event: PointerEvent| {
-                if prevent_default {
-                    event.prevent_default();
-                }
-            },
-        ));
-    }
-
     pub fn request_fullscreen(&self) {
         self.common.fullscreen_handler.request_fullscreen()
     }
@@ -538,7 +525,6 @@ impl Canvas {
         self.animation_frame_handler.cancel();
         self.on_touch_end = None;
         self.common.fullscreen_handler.cancel();
-        self.on_context_menu = None;
     }
 }
 

src/platform_impl/web/web_sys/event.rs

@@ -1,6 +1,6 @@
 use crate::dpi::LogicalPosition;
 use crate::event::{MouseButton, MouseScrollDelta};
-use crate::keyboard::{Key, KeyLocation, ModifiersState, NamedKey, PhysicalKey};
+use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState};
 
 use once_cell::unsync::OnceCell;
 use smol_str::SmolStr;
@@ -149,9 +149,9 @@ pub fn mouse_scroll_delta(
     }
 }
 
-pub fn key_code(event: &KeyboardEvent) -> PhysicalKey {
+pub fn key_code(event: &KeyboardEvent) -> KeyCode {
     let code = event.code();
-    PhysicalKey::from_key_code_attribute_value(&code)
+    KeyCode::from_key_code_attribute_value(&code)
 }
 
 pub fn key(event: &KeyboardEvent) -> Key {
@@ -163,9 +163,9 @@ pub fn key_text(event: &KeyboardEvent) -> Option<SmolStr> {
     let key = Key::from_key_attribute_value(&key);
     match &key {
         Key::Character(text) => Some(text.clone()),
-        Key::Named(NamedKey::Tab) => Some(SmolStr::new("\t")),
-        Key::Named(NamedKey::Enter) => Some(SmolStr::new("\r")),
-        Key::Named(NamedKey::Space) => Some(SmolStr::new(" ")),
+        Key::Tab => Some(SmolStr::new("\t")),
+        Key::Enter => Some(SmolStr::new("\r")),
+        Key::Space => Some(SmolStr::new(" ")),
         _ => None,
     }
     .map(SmolStr::new)

src/platform_impl/web/window.rs

@@ -5,7 +5,6 @@ use crate::window::{
     CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
     WindowAttributes, WindowButtons, WindowId as RootWI, WindowLevel,
 };
-use crate::SendSyncWrapper;
 
 use web_sys::HtmlCanvasElement;
 
@@ -15,6 +14,8 @@ use super::{backend, monitor::MonitorHandle, EventLoopWindowTarget, Fullscreen};
 use std::cell::RefCell;
 use std::collections::VecDeque;
 use std::rc::Rc;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
 
 pub struct Window {
     inner: Dispatcher<Inner>,
@@ -26,6 +27,7 @@ pub struct Inner {
     canvas: Rc<RefCell<backend::Canvas>>,
     previous_pointer: RefCell<&'static str>,
     destroy_fn: Option<Box<dyn FnOnce()>>,
+    has_focus: Arc<AtomicBool>,
 }
 
 impl Window {
@@ -49,12 +51,14 @@ impl Window {
         let runner = target.runner.clone();
         let destroy_fn = Box::new(move || runner.notify_destroy_window(RootWI(id)));
 
+        let has_focus = canvas.borrow().has_focus.clone();
         let inner = Inner {
             id,
             window: window.clone(),
             canvas,
             previous_pointer: RefCell::new("auto"),
             destroy_fn: Some(destroy_fn),
+            has_focus,
         };
 
         inner.set_title(&attr.title);
@@ -62,11 +66,9 @@ impl Window {
         inner.set_visible(attr.visible);
         inner.set_window_icon(attr.window_icon);
 
-        let canvas = Rc::downgrade(&inner.canvas);
-        let (dispatcher, runner) = Dispatcher::new(inner).unwrap();
-        target.runner.add_canvas(RootWI(id), canvas, runner);
-
-        Ok(Window { inner: dispatcher })
+        Ok(Window {
+            inner: Dispatcher::new(inner).unwrap(),
+        })
     }
 
     pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Inner) + Send + 'static) {
@@ -78,9 +80,7 @@ impl Window {
     }
 
     pub fn canvas(&self) -> Option<HtmlCanvasElement> {
-        self.inner
-            .value()
-            .map(|inner| inner.canvas.borrow().raw().clone())
+        self.inner.with(|inner| inner.canvas.borrow().raw().clone())
     }
 }
 
@@ -414,7 +414,7 @@ impl Inner {
 
     #[inline]
     pub fn has_focus(&self) -> bool {
-        self.canvas.borrow().has_focus.get()
+        self.has_focus.load(Ordering::Relaxed)
     }
 
     pub fn title(&self) -> String {
@@ -456,7 +456,7 @@ impl From<u64> for WindowId {
 
 #[derive(Clone)]
 pub struct PlatformSpecificWindowBuilderAttributes {
-    pub(crate) canvas: SendSyncWrapper<Option<backend::RawCanvasType>>,
+    pub(crate) canvas: Option<backend::RawCanvasType>,
     pub(crate) prevent_default: bool,
     pub(crate) focusable: bool,
     pub(crate) append: bool,
@@ -465,7 +465,7 @@ pub struct PlatformSpecificWindowBuilderAttributes {
 impl Default for PlatformSpecificWindowBuilderAttributes {
     fn default() -> Self {
         Self {
-            canvas: SendSyncWrapper(None),
+            canvas: None,
             prevent_default: true,
             focusable: true,
             append: false,

src/platform_impl/windows/dpi.rs

@@ -9,8 +9,8 @@ use windows_sys::Win32::{
     },
     UI::{
         HiDpi::{
-            DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE, DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2,
-            MDT_EFFECTIVE_DPI, PROCESS_PER_MONITOR_DPI_AWARE,
+            DPI_AWARENESS_CONTEXT, DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE, MDT_EFFECTIVE_DPI,
+            PROCESS_PER_MONITOR_DPI_AWARE,
         },
         WindowsAndMessaging::IsProcessDPIAware,
     },
@@ -21,6 +21,8 @@ use crate::platform_impl::platform::util::{
     SET_PROCESS_DPI_AWARENESS, SET_PROCESS_DPI_AWARENESS_CONTEXT,
 };
 
+const DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2: DPI_AWARENESS_CONTEXT = -4;
+
 pub fn become_dpi_aware() {
     static ENABLE_DPI_AWARENESS: Once = Once::new();
     ENABLE_DPI_AWARENESS.call_once(|| {

src/platform_impl/windows/event_loop.rs

@@ -21,7 +21,7 @@ use once_cell::sync::Lazy;
 
 use windows_sys::Win32::{
     Devices::HumanInterfaceDevice::MOUSE_MOVE_RELATIVE,
-    Foundation::{HWND, LPARAM, LRESULT, POINT, RECT, WPARAM},
+    Foundation::{BOOL, HANDLE, HWND, LPARAM, LRESULT, POINT, RECT, WPARAM},
     Graphics::Gdi::{
         GetMonitorInfoW, MonitorFromRect, MonitorFromWindow, RedrawWindow, ScreenToClient,
         ValidateRect, MONITORINFO, MONITOR_DEFAULTTONULL, RDW_INTERNALPAINT, SC_SCREENSAVE,
@@ -35,9 +35,13 @@ use windows_sys::Win32::{
         Input::{
             Ime::{GCS_COMPSTR, GCS_RESULTSTR, ISC_SHOWUICOMPOSITIONWINDOW},
             KeyboardAndMouse::{
-                ReleaseCapture, SetCapture, TrackMouseEvent, TME_LEAVE, TRACKMOUSEEVENT,
+                MapVirtualKeyW, ReleaseCapture, SetCapture, TrackMouseEvent, MAPVK_VK_TO_VSC_EX,
+                TME_LEAVE, TRACKMOUSEEVENT, VK_NUMLOCK, VK_SHIFT,
+            },
+            Pointer::{
+                POINTER_FLAG_DOWN, POINTER_FLAG_UP, POINTER_FLAG_UPDATE, POINTER_INFO,
+                POINTER_PEN_INFO, POINTER_TOUCH_INFO,
             },
-            Pointer::{POINTER_FLAG_DOWN, POINTER_FLAG_UP, POINTER_FLAG_UPDATE},
             Touch::{
                 CloseTouchInputHandle, GetTouchInputInfo, TOUCHEVENTF_DOWN, TOUCHEVENTF_MOVE,
                 TOUCHEVENTF_UP, TOUCHINPUT,
@@ -45,24 +49,25 @@ use windows_sys::Win32::{
             RAWINPUT, RIM_TYPEKEYBOARD, RIM_TYPEMOUSE,
         },
         WindowsAndMessaging::{
-            CreateWindowExW, DefWindowProcW, DestroyWindow, DispatchMessageW, GetClientRect,
-            GetCursorPos, GetMenu, GetMessageW, KillTimer, LoadCursorW, PeekMessageW, PostMessageW,
+            CreateWindowExW, DefWindowProcW, DestroyWindow, DispatchMessageW, GetCursorPos,
+            GetMenu, GetMessageW, KillTimer, LoadCursorW, PeekMessageW, PostMessageW,
             RegisterClassExW, RegisterWindowMessageA, SetCursor, SetTimer, SetWindowPos,
             TranslateMessage, CREATESTRUCTW, GIDC_ARRIVAL, GIDC_REMOVAL, GWL_STYLE, GWL_USERDATA,
             HTCAPTION, HTCLIENT, MINMAXINFO, MNC_CLOSE, MSG, NCCALCSIZE_PARAMS, PM_REMOVE, PT_PEN,
-            PT_TOUCH, RI_MOUSE_HWHEEL, RI_MOUSE_WHEEL, SC_MINIMIZE, SC_RESTORE, SIZE_MAXIMIZED,
-            SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, SWP_NOZORDER, WHEEL_DELTA, WINDOWPOS,
-            WM_CAPTURECHANGED, WM_CLOSE, WM_CREATE, WM_DESTROY, WM_DPICHANGED, WM_ENTERSIZEMOVE,
-            WM_EXITSIZEMOVE, WM_GETMINMAXINFO, WM_IME_COMPOSITION, WM_IME_ENDCOMPOSITION,
-            WM_IME_SETCONTEXT, WM_IME_STARTCOMPOSITION, WM_INPUT, WM_INPUT_DEVICE_CHANGE,
-            WM_KEYDOWN, WM_KEYUP, WM_KILLFOCUS, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MBUTTONDOWN,
-            WM_MBUTTONUP, WM_MENUCHAR, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_NCACTIVATE,
-            WM_NCCALCSIZE, WM_NCCREATE, WM_NCDESTROY, WM_NCLBUTTONDOWN, WM_PAINT, WM_POINTERDOWN,
-            WM_POINTERUP, WM_POINTERUPDATE, WM_RBUTTONDOWN, WM_RBUTTONUP, WM_SETCURSOR,
-            WM_SETFOCUS, WM_SETTINGCHANGE, WM_SIZE, WM_SYSCOMMAND, WM_SYSKEYDOWN, WM_SYSKEYUP,
-            WM_TOUCH, WM_WINDOWPOSCHANGED, WM_WINDOWPOSCHANGING, WM_XBUTTONDOWN, WM_XBUTTONUP,
-            WNDCLASSEXW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT,
-            WS_OVERLAPPED, WS_POPUP, WS_VISIBLE,
+            PT_TOUCH, RI_KEY_E0, RI_KEY_E1, RI_MOUSE_WHEEL, SC_MINIMIZE, SC_RESTORE,
+            SIZE_MAXIMIZED, SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, SWP_NOZORDER, WHEEL_DELTA,
+            WINDOWPOS, WM_CAPTURECHANGED, WM_CLOSE, WM_CREATE, WM_DESTROY, WM_DPICHANGED,
+            WM_ENTERSIZEMOVE, WM_EXITSIZEMOVE, WM_GETMINMAXINFO, WM_IME_COMPOSITION,
+            WM_IME_ENDCOMPOSITION, WM_IME_SETCONTEXT, WM_IME_STARTCOMPOSITION, WM_INPUT,
+            WM_INPUT_DEVICE_CHANGE, WM_KEYDOWN, WM_KEYUP, WM_KILLFOCUS, WM_LBUTTONDOWN,
+            WM_LBUTTONUP, WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MENUCHAR, WM_MOUSEHWHEEL, WM_MOUSEMOVE,
+            WM_MOUSEWHEEL, WM_NCACTIVATE, WM_NCCALCSIZE, WM_NCCREATE, WM_NCDESTROY,
+            WM_NCLBUTTONDOWN, WM_PAINT, WM_POINTERDOWN, WM_POINTERUP, WM_POINTERUPDATE,
+            WM_RBUTTONDOWN, WM_RBUTTONUP, WM_SETCURSOR, WM_SETFOCUS, WM_SETTINGCHANGE, WM_SIZE,
+            WM_SYSCOMMAND, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_TOUCH, WM_WINDOWPOSCHANGED,
+            WM_WINDOWPOSCHANGING, WM_XBUTTONDOWN, WM_XBUTTONUP, WNDCLASSEXW, WS_EX_LAYERED,
+            WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, WS_EX_TRANSPARENT, WS_OVERLAPPED, WS_POPUP,
+            WS_VISIBLE,
         },
     },
 };
@@ -75,8 +80,8 @@ use crate::{
         WindowEvent,
     },
     event_loop::{ControlFlow, DeviceEvents, EventLoopClosed, EventLoopWindowTarget as RootELW},
-    keyboard::ModifiersState,
-    platform::pump_events::PumpStatus,
+    keyboard::{KeyCode, ModifiersState},
+    platform::{pump_events::PumpStatus, scancode::KeyCodeExtScancode},
     platform_impl::platform::{
         dark_mode::try_theme,
         dpi::{become_dpi_aware, dpi_to_scale_factor},
@@ -98,6 +103,37 @@ use self::runner::RunnerState;
 
 use super::window::set_skip_taskbar;
 
+type GetPointerFrameInfoHistory = unsafe extern "system" fn(
+    pointerId: u32,
+    entriesCount: *mut u32,
+    pointerCount: *mut u32,
+    pointerInfo: *mut POINTER_INFO,
+) -> BOOL;
+
+type SkipPointerFrameMessages = unsafe extern "system" fn(pointerId: u32) -> BOOL;
+type GetPointerDeviceRects = unsafe extern "system" fn(
+    device: HANDLE,
+    pointerDeviceRect: *mut RECT,
+    displayRect: *mut RECT,
+) -> BOOL;
+
+type GetPointerTouchInfo =
+    unsafe extern "system" fn(pointerId: u32, touchInfo: *mut POINTER_TOUCH_INFO) -> BOOL;
+
+type GetPointerPenInfo =
+    unsafe extern "system" fn(pointId: u32, penInfo: *mut POINTER_PEN_INFO) -> BOOL;
+
+static GET_POINTER_FRAME_INFO_HISTORY: Lazy<Option<GetPointerFrameInfoHistory>> =
+    Lazy::new(|| get_function!("user32.dll", GetPointerFrameInfoHistory));
+static SKIP_POINTER_FRAME_MESSAGES: Lazy<Option<SkipPointerFrameMessages>> =
+    Lazy::new(|| get_function!("user32.dll", SkipPointerFrameMessages));
+static GET_POINTER_DEVICE_RECTS: Lazy<Option<GetPointerDeviceRects>> =
+    Lazy::new(|| get_function!("user32.dll", GetPointerDeviceRects));
+static GET_POINTER_TOUCH_INFO: Lazy<Option<GetPointerTouchInfo>> =
+    Lazy::new(|| get_function!("user32.dll", GetPointerTouchInfo));
+static GET_POINTER_PEN_INFO: Lazy<Option<GetPointerPenInfo>> =
+    Lazy::new(|| get_function!("user32.dll", GetPointerPenInfo));
+
 pub(crate) struct WindowData<T: 'static> {
     pub window_state: Arc<Mutex<WindowState>>,
     pub event_loop_runner: EventLoopRunnerShared<T>,
@@ -320,6 +356,19 @@ impl<T: 'static> EventLoop<T> {
 
     /// Wait for one message and dispatch it, optionally with a timeout
     fn wait_and_dispatch_message(&mut self, timeout: Option<Duration>) {
+        let start = Instant::now();
+
+        let runner = &self.window_target.p.runner_shared;
+
+        let control_flow_timeout = match runner.control_flow() {
+            ControlFlow::Wait => None,
+            ControlFlow::Poll => Some(Duration::ZERO),
+            ControlFlow::WaitUntil(wait_deadline) => {
+                Some(wait_deadline.saturating_duration_since(start))
+            }
+        };
+        let timeout = min_timeout(control_flow_timeout, timeout);
+
         fn get_msg_with_timeout(msg: &mut MSG, timeout: Option<Duration>) -> PumpStatus {
             unsafe {
                 // A timeout of None means wait indefinitely (so we don't need to call SetTimer)
@@ -355,8 +404,6 @@ impl<T: 'static> EventLoop<T> {
             }
         }
 
-        let runner = &self.window_target.p.runner_shared;
-
         // We aim to be consistent with the MacOS backend which has a RunLoop
         // observer that will dispatch AboutToWait when about to wait for
         // events, and NewEvents after the RunLoop wakes up.
@@ -368,16 +415,6 @@ impl<T: 'static> EventLoop<T> {
         //
         runner.prepare_wait();
 
-        let control_flow_timeout = match runner.control_flow() {
-            ControlFlow::Wait => None,
-            ControlFlow::Poll => Some(Duration::ZERO),
-            ControlFlow::WaitUntil(wait_deadline) => {
-                let start = Instant::now();
-                Some(wait_deadline.saturating_duration_since(start))
-            }
-        };
-        let timeout = min_timeout(control_flow_timeout, timeout);
-
         // # Safety
         // The Windows API has no documented requirement for bitwise
         // initializing a `MSG` struct (it can be uninitialized memory for the C
@@ -530,10 +567,6 @@ impl<T> EventLoopWindowTarget<T> {
         self.runner_shared.exit_code().is_some()
     }
 
-    pub(crate) fn clear_exit(&self) {
-        self.runner_shared.clear_exit();
-    }
-
     fn exit_code(&self) -> Option<i32> {
         self.runner_shared.exit_code()
     }
@@ -1135,28 +1168,19 @@ unsafe fn public_window_callback_inner<T: 'static>(
         }
 
         WM_PAINT => {
-            userdata.window_state_lock().redraw_requested =
-                userdata.event_loop_runner.should_buffer();
-
-            // We'll buffer only in response to `UpdateWindow`, if win32 decides to redraw the
-            // window outside the normal flow of the event loop. This way mark event as handled
-            // and request a normal redraw with `RedrawWindow`.
-            if !userdata.event_loop_runner.should_buffer() {
+            if userdata.event_loop_runner.should_buffer() {
+                // this branch can happen in response to `UpdateWindow`, if win32 decides to
+                // redraw the window outside the normal flow of the event loop.
+                unsafe { RedrawWindow(window, ptr::null(), 0, RDW_INTERNALPAINT) };
+            } else {
                 userdata.send_event(Event::WindowEvent {
                     window_id: RootWindowId(WindowId(window)),
                     event: WindowEvent::RedrawRequested,
                 });
             }
-
-            // NOTE: calling `RedrawWindow` during `WM_PAINT` does nothing, since to mark
-            // `WM_PAINT` as handled we should call the `DefWindowProcW`. Call it and check whether
-            // user asked for redraw during `RedrawRequested` event handling and request it again
-            // after marking `WM_PAINT` as handled.
-            result = ProcResult::Value(unsafe { DefWindowProcW(window, msg, wparam, lparam) });
-            if std::mem::take(&mut userdata.window_state_lock().redraw_requested) {
-                unsafe { RedrawWindow(window, ptr::null(), 0, RDW_INTERNALPAINT) };
-            }
+            result = ProcResult::DefWindowProc(wparam);
         }
+
         WM_WINDOWPOSCHANGING => {
             let mut window_state = userdata.window_state_lock();
             if let Some(ref mut fullscreen) = window_state.fullscreen {
@@ -1414,58 +1438,41 @@ unsafe fn public_window_callback_inner<T: 'static>(
         }
 
         WM_MOUSEMOVE => {
-            use crate::event::WindowEvent::{CursorEntered, CursorLeft, CursorMoved};
+            use crate::event::WindowEvent::{CursorEntered, CursorMoved};
+            let mouse_was_outside_window = {
+                let mut w = userdata.window_state_lock();
 
-            let x = super::get_x_lparam(lparam as u32) as i32;
-            let y = super::get_y_lparam(lparam as u32) as i32;
-            let position = PhysicalPosition::new(x as f64, y as f64);
+                let was_outside_window = !w.mouse.cursor_flags().contains(CursorFlags::IN_WINDOW);
+                w.mouse
+                    .set_cursor_flags(window, |f| f.set(CursorFlags::IN_WINDOW, true))
+                    .ok();
+                was_outside_window
+            };
 
+            if mouse_was_outside_window {
+                userdata.send_event(Event::WindowEvent {
+                    window_id: RootWindowId(WindowId(window)),
+                    event: CursorEntered {
+                        device_id: DEVICE_ID,
+                    },
+                });
+
+                // Calling TrackMouseEvent in order to receive mouse leave events.
+                unsafe {
+                    TrackMouseEvent(&mut TRACKMOUSEEVENT {
+                        cbSize: mem::size_of::<TRACKMOUSEEVENT>() as u32,
+                        dwFlags: TME_LEAVE,
+                        hwndTrack: window,
+                        dwHoverTime: HOVER_DEFAULT,
+                    })
+                };
+            }
+
+            let x = super::get_x_lparam(lparam as u32) as f64;
+            let y = super::get_y_lparam(lparam as u32) as f64;
+            let position = PhysicalPosition::new(x, y);
             let cursor_moved;
             {
-                let mut w = userdata.window_state_lock();
-                let mouse_was_inside_window =
-                    w.mouse.cursor_flags().contains(CursorFlags::IN_WINDOW);
-
-                match get_pointer_move_kind(window, mouse_was_inside_window, x, y) {
-                    PointerMoveKind::Enter => {
-                        w.mouse
-                            .set_cursor_flags(window, |f| f.set(CursorFlags::IN_WINDOW, true))
-                            .ok();
-
-                        drop(w);
-                        userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
-                            event: CursorEntered {
-                                device_id: DEVICE_ID,
-                            },
-                        });
-
-                        // Calling TrackMouseEvent in order to receive mouse leave events.
-                        unsafe {
-                            TrackMouseEvent(&mut TRACKMOUSEEVENT {
-                                cbSize: mem::size_of::<TRACKMOUSEEVENT>() as u32,
-                                dwFlags: TME_LEAVE,
-                                hwndTrack: window,
-                                dwHoverTime: HOVER_DEFAULT,
-                            })
-                        };
-                    }
-                    PointerMoveKind::Leave => {
-                        w.mouse
-                            .set_cursor_flags(window, |f| f.set(CursorFlags::IN_WINDOW, false))
-                            .ok();
-
-                        drop(w);
-                        userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
-                            event: CursorLeft {
-                                device_id: DEVICE_ID,
-                            },
-                        });
-                    }
-                    PointerMoveKind::None => drop(w),
-                }
-
                 // handle spurious WM_MOUSEMOVE messages
                 // see https://devblogs.microsoft.com/oldnewthing/20031001-00/?p=42343
                 // and http://debugandconquer.blogspot.com/2015/08/the-cause-of-spurious-mouse-move.html
@@ -1473,7 +1480,6 @@ unsafe fn public_window_callback_inner<T: 'static>(
                 cursor_moved = w.mouse.last_position != Some(position);
                 w.mouse.last_position = Some(position);
             }
-
             if cursor_moved {
                 update_modifiers(window, userdata);
 
@@ -1512,6 +1518,7 @@ unsafe fn public_window_callback_inner<T: 'static>(
             use crate::event::MouseScrollDelta::LineDelta;
 
             let value = (wparam >> 16) as i16;
+            let value = value as i32;
             let value = value as f32 / WHEEL_DELTA as f32;
 
             update_modifiers(window, userdata);
@@ -1532,6 +1539,7 @@ unsafe fn public_window_callback_inner<T: 'static>(
             use crate::event::MouseScrollDelta::LineDelta;
 
             let value = (wparam >> 16) as i16;
+            let value = value as i32;
             let value = -value as f32 / WHEEL_DELTA as f32; // NOTE: inverted! See https://github.com/rust-windowing/winit/pull/2105/
 
             update_modifiers(window, userdata);
@@ -1799,9 +1807,9 @@ unsafe fn public_window_callback_inner<T: 'static>(
                 Some(SkipPointerFrameMessages),
                 Some(GetPointerDeviceRects),
             ) = (
-                *util::GET_POINTER_FRAME_INFO_HISTORY,
-                *util::SKIP_POINTER_FRAME_MESSAGES,
-                *util::GET_POINTER_DEVICE_RECTS,
+                *GET_POINTER_FRAME_INFO_HISTORY,
+                *SKIP_POINTER_FRAME_MESSAGES,
+                *GET_POINTER_DEVICE_RECTS,
             ) {
                 let pointer_id = super::loword(wparam as u32) as u32;
                 let mut entries_count = 0u32;
@@ -1883,7 +1891,7 @@ unsafe fn public_window_callback_inner<T: 'static>(
                     let force = match pointer_info.pointerType {
                         PT_TOUCH => {
                             let mut touch_info = mem::MaybeUninit::uninit();
-                            util::GET_POINTER_TOUCH_INFO.and_then(|GetPointerTouchInfo| {
+                            GET_POINTER_TOUCH_INFO.and_then(|GetPointerTouchInfo| {
                                 match unsafe {
                                     GetPointerTouchInfo(
                                         pointer_info.pointerId,
@@ -1899,7 +1907,7 @@ unsafe fn public_window_callback_inner<T: 'static>(
                         }
                         PT_PEN => {
                             let mut pen_info = mem::MaybeUninit::uninit();
-                            util::GET_POINTER_PEN_INFO.and_then(|GetPointerPenInfo| {
+                            GET_POINTER_PEN_INFO.and_then(|GetPointerPenInfo| {
                                 match unsafe {
                                     GetPointerPenInfo(pointer_info.pointerId, pen_info.as_mut_ptr())
                                 } {
@@ -2418,9 +2426,11 @@ unsafe fn handle_raw_input<T: 'static>(userdata: &ThreadMsgTargetData<T>, data:
         }
 
         let button_flags = unsafe { mouse.Anonymous.Anonymous.usButtonFlags };
+
         if util::has_flag(button_flags as u32, RI_MOUSE_WHEEL) {
-            let button_data = unsafe { mouse.Anonymous.Anonymous.usButtonData } as i16;
-            let delta = button_data as f32 / WHEEL_DELTA as f32;
+            let button_data = unsafe { mouse.Anonymous.Anonymous.usButtonData };
+            // We must cast to i16 first, becaues `usButtonData` must be interpreted as signed.
+            let delta = button_data as i16 as f32 / WHEEL_DELTA as f32;
             userdata.send_event(Event::DeviceEvent {
                 device_id,
                 event: MouseWheel {
@@ -2428,26 +2438,18 @@ unsafe fn handle_raw_input<T: 'static>(userdata: &ThreadMsgTargetData<T>, data:
                 },
             });
         }
-        if util::has_flag(button_flags as u32, RI_MOUSE_HWHEEL) {
-            let button_data = unsafe { mouse.Anonymous.Anonymous.usButtonData } as i16;
-            let delta = -button_data as f32 / WHEEL_DELTA as f32;
-            userdata.send_event(Event::DeviceEvent {
-                device_id,
-                event: MouseWheel {
-                    delta: LineDelta(delta, 0.0),
-                },
-            });
-        }
 
         let button_state = raw_input::get_raw_mouse_button_state(button_flags as u32);
-        for (button, state) in button_state.iter().enumerate() {
+        // Left, middle, and right, respectively.
+        for (index, state) in button_state.iter().enumerate() {
             if let Some(state) = *state {
+                // This gives us consistency with X11, since there doesn't
+                // seem to be anything else reasonable to do for a mouse
+                // button ID.
+                let button = (index + 1) as _;
                 userdata.send_event(Event::DeviceEvent {
                     device_id,
-                    event: Button {
-                        button: button as _,
-                        state,
-                    },
+                    event: Button { button, state },
                 });
             }
         }
@@ -2461,51 +2463,102 @@ unsafe fn handle_raw_input<T: 'static>(userdata: &ThreadMsgTargetData<T>, data:
             return;
         }
 
-        if let Some(physical_key) = raw_input::get_keyboard_physical_key(keyboard) {
-            let state = if pressed { Pressed } else { Released };
-
-            userdata.send_event(Event::DeviceEvent {
-                device_id,
-                event: Key(RawKeyEvent {
-                    physical_key,
-                    state,
-                }),
-            });
+        let state = if pressed { Pressed } else { Released };
+        let extension = {
+            if util::has_flag(keyboard.Flags, RI_KEY_E0 as _) {
+                0xE000
+            } else if util::has_flag(keyboard.Flags, RI_KEY_E1 as _) {
+                0xE100
+            } else {
+                0x0000
+            }
+        };
+        let scancode = if keyboard.MakeCode == 0 {
+            // In some cases (often with media keys) the device reports a scancode of 0 but a
+            // valid virtual key. In these cases we obtain the scancode from the virtual key.
+            unsafe { MapVirtualKeyW(keyboard.VKey as u32, MAPVK_VK_TO_VSC_EX) as u16 }
+        } else {
+            keyboard.MakeCode | extension
+        };
+        if scancode == 0xE11D || scancode == 0xE02A {
+            // At the hardware (or driver?) level, pressing the Pause key is equivalent to pressing
+            // Ctrl+NumLock.
+            // This equvalence means that if the user presses Pause, the keyboard will emit two
+            // subsequent keypresses:
+            // 1, 0xE11D - Which is a left Ctrl (0x1D) with an extension flag (0xE100)
+            // 2, 0x0045 - Which on its own can be interpreted as Pause
+            //
+            // There's another combination which isn't quite an equivalence:
+            // PrtSc used to be Shift+Asterisk. This means that on some keyboards, presssing
+            // PrtSc (print screen) produces the following sequence:
+            // 1, 0xE02A - Which is a left shift (0x2A) with an extension flag (0xE000)
+            // 2, 0xE037 - Which is a numpad multiply (0x37) with an exteion flag (0xE000). This on
+            //             its own it can be interpreted as PrtSc
+            //
+            // For this reason, if we encounter the first keypress, we simply ignore it, trusting
+            // that there's going to be another event coming, from which we can extract the
+            // appropriate key.
+            // For more on this, read the article by Raymond Chen, titled:
+            // "Why does Ctrl+ScrollLock cancel dialogs?"
+            // https://devblogs.microsoft.com/oldnewthing/20080211-00/?p=23503
+            return;
         }
-    }
-}
-
-enum PointerMoveKind {
-    /// Pointer enterd to the window.
-    Enter,
-    /// Pointer leaved the window client area.
-    Leave,
-    /// Pointer is inside the window or `GetClientRect` failed.
-    None,
-}
-
-fn get_pointer_move_kind(
-    window: HWND,
-    mouse_was_inside_window: bool,
-    x: i32,
-    y: i32,
-) -> PointerMoveKind {
-    let rect: RECT = unsafe {
-        let mut rect: RECT = mem::zeroed();
-        if GetClientRect(window, &mut rect) == false.into() {
-            return PointerMoveKind::None; // exit early if GetClientRect failed
-        }
-        rect
-    };
-
-    let x = (rect.left..rect.right).contains(&x);
-    let y = (rect.top..rect.bottom).contains(&y);
-
-    if !mouse_was_inside_window && x && y {
-        PointerMoveKind::Enter
-    } else if mouse_was_inside_window && !(x && y) {
-        PointerMoveKind::Leave
-    } else {
-        PointerMoveKind::None
+        let code = if keyboard.VKey == VK_NUMLOCK {
+            // Historically, the NumLock and the Pause key were one and the same physical key.
+            // The user could trigger Pause by pressing Ctrl+NumLock.
+            // Now these are often physically separate and the two keys can be differentiated by
+            // checking the extension flag of the scancode. NumLock is 0xE045, Pause is 0x0045.
+            //
+            // However in this event, both keys are reported as 0x0045 even on modern hardware.
+            // Therefore we use the virtual key instead to determine whether it's a NumLock and
+            // set the KeyCode accordingly.
+            //
+            // For more on this, read the article by Raymond Chen, titled:
+            // "Why does Ctrl+ScrollLock cancel dialogs?"
+            // https://devblogs.microsoft.com/oldnewthing/20080211-00/?p=23503
+            KeyCode::NumLock
+        } else {
+            KeyCode::from_scancode(scancode as u32)
+        };
+        if keyboard.VKey == VK_SHIFT {
+            match code {
+                KeyCode::NumpadDecimal
+                | KeyCode::Numpad0
+                | KeyCode::Numpad1
+                | KeyCode::Numpad2
+                | KeyCode::Numpad3
+                | KeyCode::Numpad4
+                | KeyCode::Numpad5
+                | KeyCode::Numpad6
+                | KeyCode::Numpad7
+                | KeyCode::Numpad8
+                | KeyCode::Numpad9 => {
+                    // On Windows, holding the Shift key makes numpad keys behave as if NumLock
+                    // wasn't active. The way this is exposed to applications by the system is that
+                    // the application receives a fake key release event for the shift key at the
+                    // moment when the numpad key is pressed, just before receiving the numpad key
+                    // as well.
+                    //
+                    // The issue is that in the raw device event (here), the fake shift release
+                    // event reports the numpad key as the scancode. Unfortunately, the event doesn't
+                    // have any information to tell whether it's the left shift or the right shift
+                    // that needs to get the fake release (or press) event so we don't forward this
+                    // event to the application at all.
+                    //
+                    // For more on this, read the article by Raymond Chen, titled:
+                    // "The shift key overrides NumLock"
+                    // https://devblogs.microsoft.com/oldnewthing/20040906-00/?p=37953
+                    return;
+                }
+                _ => (),
+            }
+        }
+        userdata.send_event(Event::DeviceEvent {
+            device_id,
+            event: Key(RawKeyEvent {
+                physical_key: code,
+                state,
+            }),
+        });
     }
 }

src/platform_impl/windows/event_loop/runner.rs

@@ -163,10 +163,6 @@ impl<T> EventLoopRunner<T> {
         self.exit.get()
     }
 
-    pub fn clear_exit(&self) {
-        self.exit.set(None);
-    }
-
     pub fn should_buffer(&self) -> bool {
         let handler = self.event_handler.take();
         let should_buffer = handler.is_none();

src/platform_impl/windows/ime.rs

@@ -10,9 +10,9 @@ use windows_sys::Win32::{
     UI::{
         Input::Ime::{
             ImmAssociateContextEx, ImmGetCompositionStringW, ImmGetContext, ImmReleaseContext,
-            ImmSetCandidateWindow, ImmSetCompositionWindow, ATTR_TARGET_CONVERTED,
-            ATTR_TARGET_NOTCONVERTED, CANDIDATEFORM, CFS_EXCLUDE, CFS_POINT, COMPOSITIONFORM,
-            GCS_COMPATTR, GCS_COMPSTR, GCS_CURSORPOS, GCS_RESULTSTR, IACE_CHILDREN, IACE_DEFAULT,
+            ImmSetCandidateWindow, ATTR_TARGET_CONVERTED, ATTR_TARGET_NOTCONVERTED, CANDIDATEFORM,
+            CFS_EXCLUDE, GCS_COMPATTR, GCS_COMPSTR, GCS_CURSORPOS, GCS_RESULTSTR, IACE_CHILDREN,
+            IACE_DEFAULT,
         },
         WindowsAndMessaging::{GetSystemMetrics, SM_IMMENABLED},
     },
@@ -124,7 +124,7 @@ impl ImeContext {
             left: x,
             top: y,
             right: x + width,
-            bottom: y + height,
+            bottom: y - height,
         };
         let candidate_form = CANDIDATEFORM {
             dwIndex: 0,
@@ -132,16 +132,8 @@ impl ImeContext {
             ptCurrentPos: POINT { x, y },
             rcArea: rc_area,
         };
-        let composition_form = COMPOSITIONFORM {
-            dwStyle: CFS_POINT,
-            ptCurrentPos: POINT { x, y: y + height },
-            rcArea: rc_area,
-        };
 
-        unsafe {
-            ImmSetCompositionWindow(self.himc, &composition_form);
-            ImmSetCandidateWindow(self.himc, &candidate_form);
-        }
+        unsafe { ImmSetCandidateWindow(self.himc, &candidate_form) };
     }
 
     pub unsafe fn set_ime_allowed(hwnd: HWND, allowed: bool) {

src/platform_impl/windows/keyboard.rs

@@ -37,8 +37,8 @@ use unicode_segmentation::UnicodeSegmentation;
 
 use crate::{
     event::{ElementState, KeyEvent},
-    keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey},
-    platform::scancode::PhysicalKeyExtScancode,
+    keyboard::{Key, KeyCode, KeyLocation, NativeKey, NativeKeyCode},
+    platform::scancode::KeyCodeExtScancode,
     platform_impl::platform::{
         event_loop::ProcResult,
         keyboard_layout::{Layout, LayoutCache, WindowsModifiers, LAYOUT_CACHE},
@@ -264,8 +264,8 @@ impl KeyEventBuilder {
                             let mod_no_ctrl = mod_state.remove_only_ctrl();
                             let num_lock_on = kbd_state[VK_NUMLOCK as usize] & 1 != 0;
                             let vkey = event_info.vkey;
-                            let physical_key = &event_info.physical_key;
-                            let key = layout.get_key(mod_no_ctrl, num_lock_on, vkey, physical_key);
+                            let keycode = &event_info.code;
+                            let key = layout.get_key(mod_no_ctrl, num_lock_on, vkey, keycode);
                             event_info.text = PartialText::Text(key.to_text().map(SmolStr::new));
                         }
                         let ev = event_info.finalize();
@@ -454,16 +454,15 @@ impl KeyEventBuilder {
             return None;
         }
         let scancode = scancode as ExScancode;
-        let physical_key = PhysicalKey::from_scancode(scancode as u32);
+        let code = KeyCode::from_scancode(scancode as u32);
         let mods = if caps_lock_on {
             WindowsModifiers::CAPS_LOCK
         } else {
             WindowsModifiers::empty()
         };
         let layout = layouts.layouts.get(&(locale_id as u64)).unwrap();
-        let logical_key = layout.get_key(mods, num_lock_on, vk, &physical_key);
-        let key_without_modifiers =
-            layout.get_key(WindowsModifiers::empty(), false, vk, &physical_key);
+        let logical_key = layout.get_key(mods, num_lock_on, vk, &code);
+        let key_without_modifiers = layout.get_key(WindowsModifiers::empty(), false, vk, &code);
         let text = if key_state == ElementState::Pressed {
             logical_key.to_text().map(SmolStr::new)
         } else {
@@ -475,7 +474,7 @@ impl KeyEventBuilder {
             key_without_modifiers,
             key_state,
             is_repeat: false,
-            physical_key,
+            code,
             location: get_location(scancode, locale_id),
             utf16parts: Vec::with_capacity(8),
             text: PartialText::Text(text.clone()),
@@ -512,7 +511,7 @@ struct PartialKeyEventInfo {
     vkey: VIRTUAL_KEY,
     key_state: ElementState,
     is_repeat: bool,
-    physical_key: PhysicalKey,
+    code: KeyCode,
     location: KeyLocation,
     logical_key: PartialLogicalKey,
 
@@ -544,7 +543,7 @@ impl PartialKeyEventInfo {
         } else {
             new_ex_scancode(lparam_struct.scancode, lparam_struct.extended)
         };
-        let physical_key = PhysicalKey::from_scancode(scancode as u32);
+        let code = KeyCode::from_scancode(scancode as u32);
         let location = get_location(scancode, layout.hkl as HKL);
 
         let kbd_state = get_kbd_state();
@@ -559,17 +558,16 @@ impl PartialKeyEventInfo {
         // "Why does Ctrl+ScrollLock cancel dialogs?"
         // https://devblogs.microsoft.com/oldnewthing/20080211-00/?p=23503
         let code_as_key = if mods.contains(WindowsModifiers::CONTROL) {
-            match physical_key {
-                PhysicalKey::Code(KeyCode::NumLock) => Some(Key::Named(NamedKey::NumLock)),
-                PhysicalKey::Code(KeyCode::Pause) => Some(Key::Named(NamedKey::Pause)),
+            match code {
+                KeyCode::NumLock => Some(Key::NumLock),
+                KeyCode::Pause => Some(Key::Pause),
                 _ => None,
             }
         } else {
             None
         };
 
-        let preliminary_logical_key =
-            layout.get_key(mods_without_ctrl, num_lock_on, vkey, &physical_key);
+        let preliminary_logical_key = layout.get_key(mods_without_ctrl, num_lock_on, vkey, &code);
         let key_is_char = matches!(preliminary_logical_key, Key::Character(_));
         let is_pressed = state == ElementState::Pressed;
 
@@ -585,7 +583,7 @@ impl PartialKeyEventInfo {
         let key_without_modifiers = if let Some(key) = code_as_key {
             key
         } else {
-            match layout.get_key(NO_MODS, false, vkey, &physical_key) {
+            match layout.get_key(NO_MODS, false, vkey, &code) {
                 // We convert dead keys into their character.
                 // The reason for this is that `key_without_modifiers` is designed for key-bindings,
                 // but the US International layout treats `'` (apostrophe) as a dead key and the
@@ -611,7 +609,7 @@ impl PartialKeyEventInfo {
             logical_key,
             key_without_modifiers,
             is_repeat: lparam_struct.is_repeat,
-            physical_key,
+            code,
             location,
             utf16parts: Vec::with_capacity(8),
             text: PartialText::System(Vec::new()),
@@ -658,7 +656,7 @@ impl PartialKeyEventInfo {
         };
 
         KeyEvent {
-            physical_key: self.physical_key,
+            physical_key: self.code,
             logical_key,
             text,
             location: self.location,
@@ -742,10 +740,7 @@ fn get_async_kbd_state() -> [u8; 256] {
 /// the next event is a right Alt (AltGr) event. If this is the case, the current event must be the
 /// fake Ctrl event.
 fn is_current_fake(curr_info: &PartialKeyEventInfo, next_msg: MSG, layout: &Layout) -> bool {
-    let curr_is_ctrl = matches!(
-        curr_info.logical_key,
-        PartialLogicalKey::This(Key::Named(NamedKey::Control))
-    );
+    let curr_is_ctrl = matches!(curr_info.logical_key, PartialLogicalKey::This(Key::Control));
     if layout.has_alt_graph {
         let next_code = ex_scancode_from_lparam(next_msg.lParam);
         let next_is_altgr = next_code == 0xE038; // 0xE038 is right alt
@@ -942,7 +937,7 @@ fn get_location(scancode: ExScancode, hkl: HKL) -> KeyLocation {
     }
 }
 
-impl PhysicalKeyExtScancode for PhysicalKey {
+impl KeyCodeExtScancode for KeyCode {
     fn to_scancode(self) -> Option<u32> {
         // See `from_scancode` for more info
 
@@ -951,17 +946,7 @@ impl PhysicalKeyExtScancode for PhysicalKey {
         let primary_lang_id = primarylangid(loword(hkl as u32));
         let is_korean = primary_lang_id as u32 == LANG_KOREAN;
 
-        let code = match self {
-            PhysicalKey::Code(code) => code,
-            PhysicalKey::Unidentified(code) => {
-                return match code {
-                    NativeKeyCode::Windows(scancode) => Some(scancode as u32),
-                    _ => None,
-                };
-            }
-        };
-
-        match code {
+        match self {
             KeyCode::Backquote => Some(0x0029),
             KeyCode::Backslash => Some(0x002B),
             KeyCode::Backspace => Some(0x000E),
@@ -1121,16 +1106,17 @@ impl PhysicalKeyExtScancode for PhysicalKey {
             KeyCode::AudioVolumeDown => Some(0xE02E),
             KeyCode::AudioVolumeMute => Some(0xE020),
             KeyCode::AudioVolumeUp => Some(0xE030),
+            KeyCode::Unidentified(NativeKeyCode::Windows(scancode)) => Some(scancode as u32),
             _ => None,
         }
     }
 
-    fn from_scancode(scancode: u32) -> PhysicalKey {
+    fn from_scancode(scancode: u32) -> KeyCode {
         // See: https://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
         // and: https://www.w3.org/TR/uievents-code/
         // and: The widget/NativeKeyToDOMCodeName.h file in the firefox source
 
-        PhysicalKey::Code(match scancode {
+        match scancode {
             0x0029 => KeyCode::Backquote,
             0x002B => KeyCode::Backslash,
             0x000E => KeyCode::Backspace,
@@ -1280,7 +1266,7 @@ impl PhysicalKeyExtScancode for PhysicalKey {
             0xE02E => KeyCode::AudioVolumeDown,
             0xE020 => KeyCode::AudioVolumeMute,
             0xE030 => KeyCode::AudioVolumeUp,
-            _ => return PhysicalKey::Unidentified(NativeKeyCode::Windows(scancode as u16)),
-        })
+            _ => KeyCode::Unidentified(NativeKeyCode::Windows(scancode as u16)),
+        }
     }
 }

src/platform_impl/windows/keyboard_layout.rs

@@ -52,8 +52,8 @@ use windows_sys::Win32::{
 };
 
 use crate::{
-    keyboard::{Key, KeyCode, ModifiersState, NamedKey, NativeKey, PhysicalKey},
-    platform::scancode::PhysicalKeyExtScancode,
+    keyboard::{Key, KeyCode, ModifiersState, NativeKey},
+    platform::scancode::KeyCodeExtScancode,
     platform_impl::{loword, primarylangid},
 };
 
@@ -224,7 +224,7 @@ impl Layout {
         mods: WindowsModifiers,
         num_lock_on: bool,
         vkey: VIRTUAL_KEY,
-        physical_key: &PhysicalKey,
+        keycode: &KeyCode,
     ) -> Key {
         let native_code = NativeKey::Windows(vkey);
 
@@ -252,11 +252,9 @@ impl Layout {
         } else if let Some(key) = self.numlock_off_keys.get(&vkey) {
             return key.clone();
         }
-        if let PhysicalKey::Code(code) = physical_key {
-            if let Some(keys) = self.keys.get(&mods) {
-                if let Some(key) = keys.get(code) {
-                    return key.clone();
-                }
+        if let Some(keys) = self.keys.get(&mods) {
+            if let Some(key) = keys.get(keycode) {
+                return key.clone();
             }
         }
         Key::Unidentified(native_code)
@@ -336,11 +334,7 @@ impl LayoutCache {
             if scancode == 0 {
                 continue;
             }
-            let keycode = match PhysicalKey::from_scancode(scancode) {
-                PhysicalKey::Code(code) => code,
-                // TODO: validate that we can skip on unidentified keys (probably never occurs?)
-                _ => continue,
-            };
+            let keycode = KeyCode::from_scancode(scancode);
             if !is_numpad_specific(vk as VIRTUAL_KEY) && NUMPAD_KEYCODES.contains(&keycode) {
                 let native_code = NativeKey::Windows(vk as VIRTUAL_KEY);
                 let map_vkey = keycode_to_vkey(keycode, locale_id);
@@ -388,11 +382,7 @@ impl LayoutCache {
                 }
 
                 let native_code = NativeKey::Windows(vk as VIRTUAL_KEY);
-                let key_code = match PhysicalKey::from_scancode(scancode) {
-                    PhysicalKey::Code(code) => code,
-                    // TODO: validate that we can skip on unidentified keys (probably never occurs?)
-                    _ => continue,
-                };
+                let key_code = KeyCode::from_scancode(scancode);
                 // Let's try to get the key from just the scancode and vk
                 // We don't necessarily know yet if AltGraph is present on this layout so we'll
                 // assume it isn't. Then we'll do a second pass where we set the "AltRight" keys to
@@ -456,7 +446,7 @@ impl LayoutCache {
                 let mod_state = WindowsModifiers::from_bits_retain(mod_state);
                 if let Some(keys) = layout.keys.get_mut(&mod_state) {
                     if let Some(key) = keys.get_mut(&KeyCode::AltRight) {
-                        *key = Key::Named(NamedKey::AltGraph);
+                        *key = Key::AltGraph;
                     }
                 }
             }
@@ -743,6 +733,7 @@ fn keycode_to_vkey(keycode: KeyCode, hkl: u64) -> VIRTUAL_KEY {
         KeyCode::F33 => 0,
         KeyCode::F34 => 0,
         KeyCode::F35 => 0,
+        KeyCode::Unidentified(_) => 0,
         _ => 0,
     }
 }
@@ -778,56 +769,56 @@ fn vkey_to_non_char_key(
         VK_MBUTTON => Key::Unidentified(NativeKey::Unidentified), // Mouse
         VK_XBUTTON1 => Key::Unidentified(NativeKey::Unidentified), // Mouse
         VK_XBUTTON2 => Key::Unidentified(NativeKey::Unidentified), // Mouse
-        VK_BACK => Key::Named(NamedKey::Backspace),
-        VK_TAB => Key::Named(NamedKey::Tab),
-        VK_CLEAR => Key::Named(NamedKey::Clear),
-        VK_RETURN => Key::Named(NamedKey::Enter),
-        VK_SHIFT => Key::Named(NamedKey::Shift),
-        VK_CONTROL => Key::Named(NamedKey::Control),
-        VK_MENU => Key::Named(NamedKey::Alt),
-        VK_PAUSE => Key::Named(NamedKey::Pause),
-        VK_CAPITAL => Key::Named(NamedKey::CapsLock),
+        VK_BACK => Key::Backspace,
+        VK_TAB => Key::Tab,
+        VK_CLEAR => Key::Clear,
+        VK_RETURN => Key::Enter,
+        VK_SHIFT => Key::Shift,
+        VK_CONTROL => Key::Control,
+        VK_MENU => Key::Alt,
+        VK_PAUSE => Key::Pause,
+        VK_CAPITAL => Key::CapsLock,
 
-        //VK_HANGEUL => Key::Named(NamedKey::HangulMode), // Deprecated in favour of VK_HANGUL
+        //VK_HANGEUL => Key::HangulMode, // Deprecated in favour of VK_HANGUL
 
         // VK_HANGUL and VK_KANA are defined as the same constant, therefore
         // we use appropriate conditions to differentate between them
-        VK_HANGUL if is_korean => Key::Named(NamedKey::HangulMode),
-        VK_KANA if is_japanese => Key::Named(NamedKey::KanaMode),
+        VK_HANGUL if is_korean => Key::HangulMode,
+        VK_KANA if is_japanese => Key::KanaMode,
 
-        VK_JUNJA => Key::Named(NamedKey::JunjaMode),
-        VK_FINAL => Key::Named(NamedKey::FinalMode),
+        VK_JUNJA => Key::JunjaMode,
+        VK_FINAL => Key::FinalMode,
 
         // VK_HANJA and VK_KANJI are defined as the same constant, therefore
         // we use appropriate conditions to differentate between them
-        VK_HANJA if is_korean => Key::Named(NamedKey::HanjaMode),
-        VK_KANJI if is_japanese => Key::Named(NamedKey::KanjiMode),
+        VK_HANJA if is_korean => Key::HanjaMode,
+        VK_KANJI if is_japanese => Key::KanjiMode,
 
-        VK_ESCAPE => Key::Named(NamedKey::Escape),
-        VK_CONVERT => Key::Named(NamedKey::Convert),
-        VK_NONCONVERT => Key::Named(NamedKey::NonConvert),
-        VK_ACCEPT => Key::Named(NamedKey::Accept),
-        VK_MODECHANGE => Key::Named(NamedKey::ModeChange),
-        VK_SPACE => Key::Named(NamedKey::Space),
-        VK_PRIOR => Key::Named(NamedKey::PageUp),
-        VK_NEXT => Key::Named(NamedKey::PageDown),
-        VK_END => Key::Named(NamedKey::End),
-        VK_HOME => Key::Named(NamedKey::Home),
-        VK_LEFT => Key::Named(NamedKey::ArrowLeft),
-        VK_UP => Key::Named(NamedKey::ArrowUp),
-        VK_RIGHT => Key::Named(NamedKey::ArrowRight),
-        VK_DOWN => Key::Named(NamedKey::ArrowDown),
-        VK_SELECT => Key::Named(NamedKey::Select),
-        VK_PRINT => Key::Named(NamedKey::Print),
-        VK_EXECUTE => Key::Named(NamedKey::Execute),
-        VK_SNAPSHOT => Key::Named(NamedKey::PrintScreen),
-        VK_INSERT => Key::Named(NamedKey::Insert),
-        VK_DELETE => Key::Named(NamedKey::Delete),
-        VK_HELP => Key::Named(NamedKey::Help),
-        VK_LWIN => Key::Named(NamedKey::Super),
-        VK_RWIN => Key::Named(NamedKey::Super),
-        VK_APPS => Key::Named(NamedKey::ContextMenu),
-        VK_SLEEP => Key::Named(NamedKey::Standby),
+        VK_ESCAPE => Key::Escape,
+        VK_CONVERT => Key::Convert,
+        VK_NONCONVERT => Key::NonConvert,
+        VK_ACCEPT => Key::Accept,
+        VK_MODECHANGE => Key::ModeChange,
+        VK_SPACE => Key::Space,
+        VK_PRIOR => Key::PageUp,
+        VK_NEXT => Key::PageDown,
+        VK_END => Key::End,
+        VK_HOME => Key::Home,
+        VK_LEFT => Key::ArrowLeft,
+        VK_UP => Key::ArrowUp,
+        VK_RIGHT => Key::ArrowRight,
+        VK_DOWN => Key::ArrowDown,
+        VK_SELECT => Key::Select,
+        VK_PRINT => Key::Print,
+        VK_EXECUTE => Key::Execute,
+        VK_SNAPSHOT => Key::PrintScreen,
+        VK_INSERT => Key::Insert,
+        VK_DELETE => Key::Delete,
+        VK_HELP => Key::Help,
+        VK_LWIN => Key::Super,
+        VK_RWIN => Key::Super,
+        VK_APPS => Key::ContextMenu,
+        VK_SLEEP => Key::Standby,
 
         // Numpad keys produce characters
         VK_NUMPAD0 => Key::Unidentified(native_code),
@@ -847,30 +838,30 @@ fn vkey_to_non_char_key(
         VK_DECIMAL => Key::Unidentified(native_code),
         VK_DIVIDE => Key::Unidentified(native_code),
 
-        VK_F1 => Key::Named(NamedKey::F1),
-        VK_F2 => Key::Named(NamedKey::F2),
-        VK_F3 => Key::Named(NamedKey::F3),
-        VK_F4 => Key::Named(NamedKey::F4),
-        VK_F5 => Key::Named(NamedKey::F5),
-        VK_F6 => Key::Named(NamedKey::F6),
-        VK_F7 => Key::Named(NamedKey::F7),
-        VK_F8 => Key::Named(NamedKey::F8),
-        VK_F9 => Key::Named(NamedKey::F9),
-        VK_F10 => Key::Named(NamedKey::F10),
-        VK_F11 => Key::Named(NamedKey::F11),
-        VK_F12 => Key::Named(NamedKey::F12),
-        VK_F13 => Key::Named(NamedKey::F13),
-        VK_F14 => Key::Named(NamedKey::F14),
-        VK_F15 => Key::Named(NamedKey::F15),
-        VK_F16 => Key::Named(NamedKey::F16),
-        VK_F17 => Key::Named(NamedKey::F17),
-        VK_F18 => Key::Named(NamedKey::F18),
-        VK_F19 => Key::Named(NamedKey::F19),
-        VK_F20 => Key::Named(NamedKey::F20),
-        VK_F21 => Key::Named(NamedKey::F21),
-        VK_F22 => Key::Named(NamedKey::F22),
-        VK_F23 => Key::Named(NamedKey::F23),
-        VK_F24 => Key::Named(NamedKey::F24),
+        VK_F1 => Key::F1,
+        VK_F2 => Key::F2,
+        VK_F3 => Key::F3,
+        VK_F4 => Key::F4,
+        VK_F5 => Key::F5,
+        VK_F6 => Key::F6,
+        VK_F7 => Key::F7,
+        VK_F8 => Key::F8,
+        VK_F9 => Key::F9,
+        VK_F10 => Key::F10,
+        VK_F11 => Key::F11,
+        VK_F12 => Key::F12,
+        VK_F13 => Key::F13,
+        VK_F14 => Key::F14,
+        VK_F15 => Key::F15,
+        VK_F16 => Key::F16,
+        VK_F17 => Key::F17,
+        VK_F18 => Key::F18,
+        VK_F19 => Key::F19,
+        VK_F20 => Key::F20,
+        VK_F21 => Key::F21,
+        VK_F22 => Key::F22,
+        VK_F23 => Key::F23,
+        VK_F24 => Key::F24,
         VK_NAVIGATION_VIEW => Key::Unidentified(native_code),
         VK_NAVIGATION_MENU => Key::Unidentified(native_code),
         VK_NAVIGATION_UP => Key::Unidentified(native_code),
@@ -879,44 +870,44 @@ fn vkey_to_non_char_key(
         VK_NAVIGATION_RIGHT => Key::Unidentified(native_code),
         VK_NAVIGATION_ACCEPT => Key::Unidentified(native_code),
         VK_NAVIGATION_CANCEL => Key::Unidentified(native_code),
-        VK_NUMLOCK => Key::Named(NamedKey::NumLock),
-        VK_SCROLL => Key::Named(NamedKey::ScrollLock),
+        VK_NUMLOCK => Key::NumLock,
+        VK_SCROLL => Key::ScrollLock,
         VK_OEM_NEC_EQUAL => Key::Unidentified(native_code),
         //VK_OEM_FJ_JISHO => Key::Unidentified(native_code), // Conflicts with `VK_OEM_NEC_EQUAL`
         VK_OEM_FJ_MASSHOU => Key::Unidentified(native_code),
         VK_OEM_FJ_TOUROKU => Key::Unidentified(native_code),
         VK_OEM_FJ_LOYA => Key::Unidentified(native_code),
         VK_OEM_FJ_ROYA => Key::Unidentified(native_code),
-        VK_LSHIFT => Key::Named(NamedKey::Shift),
-        VK_RSHIFT => Key::Named(NamedKey::Shift),
-        VK_LCONTROL => Key::Named(NamedKey::Control),
-        VK_RCONTROL => Key::Named(NamedKey::Control),
-        VK_LMENU => Key::Named(NamedKey::Alt),
+        VK_LSHIFT => Key::Shift,
+        VK_RSHIFT => Key::Shift,
+        VK_LCONTROL => Key::Control,
+        VK_RCONTROL => Key::Control,
+        VK_LMENU => Key::Alt,
         VK_RMENU => {
             if has_alt_graph {
-                Key::Named(NamedKey::AltGraph)
+                Key::AltGraph
             } else {
-                Key::Named(NamedKey::Alt)
+                Key::Alt
             }
         }
-        VK_BROWSER_BACK => Key::Named(NamedKey::BrowserBack),
-        VK_BROWSER_FORWARD => Key::Named(NamedKey::BrowserForward),
-        VK_BROWSER_REFRESH => Key::Named(NamedKey::BrowserRefresh),
-        VK_BROWSER_STOP => Key::Named(NamedKey::BrowserStop),
-        VK_BROWSER_SEARCH => Key::Named(NamedKey::BrowserSearch),
-        VK_BROWSER_FAVORITES => Key::Named(NamedKey::BrowserFavorites),
-        VK_BROWSER_HOME => Key::Named(NamedKey::BrowserHome),
-        VK_VOLUME_MUTE => Key::Named(NamedKey::AudioVolumeMute),
-        VK_VOLUME_DOWN => Key::Named(NamedKey::AudioVolumeDown),
-        VK_VOLUME_UP => Key::Named(NamedKey::AudioVolumeUp),
-        VK_MEDIA_NEXT_TRACK => Key::Named(NamedKey::MediaTrackNext),
-        VK_MEDIA_PREV_TRACK => Key::Named(NamedKey::MediaTrackPrevious),
-        VK_MEDIA_STOP => Key::Named(NamedKey::MediaStop),
-        VK_MEDIA_PLAY_PAUSE => Key::Named(NamedKey::MediaPlayPause),
-        VK_LAUNCH_MAIL => Key::Named(NamedKey::LaunchMail),
-        VK_LAUNCH_MEDIA_SELECT => Key::Named(NamedKey::LaunchMediaPlayer),
-        VK_LAUNCH_APP1 => Key::Named(NamedKey::LaunchApplication1),
-        VK_LAUNCH_APP2 => Key::Named(NamedKey::LaunchApplication2),
+        VK_BROWSER_BACK => Key::BrowserBack,
+        VK_BROWSER_FORWARD => Key::BrowserForward,
+        VK_BROWSER_REFRESH => Key::BrowserRefresh,
+        VK_BROWSER_STOP => Key::BrowserStop,
+        VK_BROWSER_SEARCH => Key::BrowserSearch,
+        VK_BROWSER_FAVORITES => Key::BrowserFavorites,
+        VK_BROWSER_HOME => Key::BrowserHome,
+        VK_VOLUME_MUTE => Key::AudioVolumeMute,
+        VK_VOLUME_DOWN => Key::AudioVolumeDown,
+        VK_VOLUME_UP => Key::AudioVolumeUp,
+        VK_MEDIA_NEXT_TRACK => Key::MediaTrackNext,
+        VK_MEDIA_PREV_TRACK => Key::MediaTrackPrevious,
+        VK_MEDIA_STOP => Key::MediaStop,
+        VK_MEDIA_PLAY_PAUSE => Key::MediaPlayPause,
+        VK_LAUNCH_MAIL => Key::LaunchMail,
+        VK_LAUNCH_MEDIA_SELECT => Key::LaunchMediaPlayer,
+        VK_LAUNCH_APP1 => Key::LaunchApplication1,
+        VK_LAUNCH_APP2 => Key::LaunchApplication2,
 
         // This function only converts "non-printable"
         VK_OEM_1 => Key::Unidentified(native_code),
@@ -964,7 +955,7 @@ fn vkey_to_non_char_key(
         VK_ICO_HELP => Key::Unidentified(native_code),
         VK_ICO_00 => Key::Unidentified(native_code),
 
-        VK_PROCESSKEY => Key::Named(NamedKey::Process),
+        VK_PROCESSKEY => Key::Process,
 
         VK_ICO_CLEAR => Key::Unidentified(native_code),
         VK_PACKET => Key::Unidentified(native_code),
@@ -976,32 +967,32 @@ fn vkey_to_non_char_key(
         VK_OEM_WSCTRL => Key::Unidentified(native_code),
         VK_OEM_CUSEL => Key::Unidentified(native_code),
 
-        VK_OEM_ATTN => Key::Named(NamedKey::Attn),
+        VK_OEM_ATTN => Key::Attn,
         VK_OEM_FINISH => {
             if is_japanese {
-                Key::Named(NamedKey::Katakana)
+                Key::Katakana
             } else {
                 // This matches IE and Firefox behaviour according to
                 // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
-                // At the time of writing, there is no `NamedKey::Finish` variant as
+                // At the time of writing, there is no `Key::Finish` variant as
                 // Finish is not mentionned at https://w3c.github.io/uievents-key/
                 // Also see: https://github.com/pyfisch/keyboard-types/issues/9
                 Key::Unidentified(native_code)
             }
         }
-        VK_OEM_COPY => Key::Named(NamedKey::Copy),
-        VK_OEM_AUTO => Key::Named(NamedKey::Hankaku),
-        VK_OEM_ENLW => Key::Named(NamedKey::Zenkaku),
-        VK_OEM_BACKTAB => Key::Named(NamedKey::Romaji),
-        VK_ATTN => Key::Named(NamedKey::KanaMode),
-        VK_CRSEL => Key::Named(NamedKey::CrSel),
-        VK_EXSEL => Key::Named(NamedKey::ExSel),
-        VK_EREOF => Key::Named(NamedKey::EraseEof),
-        VK_PLAY => Key::Named(NamedKey::Play),
-        VK_ZOOM => Key::Named(NamedKey::ZoomToggle),
+        VK_OEM_COPY => Key::Copy,
+        VK_OEM_AUTO => Key::Hankaku,
+        VK_OEM_ENLW => Key::Zenkaku,
+        VK_OEM_BACKTAB => Key::Romaji,
+        VK_ATTN => Key::KanaMode,
+        VK_CRSEL => Key::CrSel,
+        VK_EXSEL => Key::ExSel,
+        VK_EREOF => Key::EraseEof,
+        VK_PLAY => Key::Play,
+        VK_ZOOM => Key::ZoomToggle,
         VK_NONAME => Key::Unidentified(native_code),
         VK_PA1 => Key::Unidentified(native_code),
-        VK_OEM_CLEAR => Key::Named(NamedKey::Clear),
+        VK_OEM_CLEAR => Key::Clear,
         _ => Key::Unidentified(native_code),
     }
 }

src/platform_impl/windows/monitor.rs

@@ -209,15 +209,11 @@ impl MonitorHandle {
 
     #[inline]
     pub fn position(&self) -> PhysicalPosition<i32> {
-        get_monitor_info(self.0)
-            .map(|info| {
-                let rc_monitor = info.monitorInfo.rcMonitor;
-                PhysicalPosition {
-                    x: rc_monitor.left,
-                    y: rc_monitor.top,
-                }
-            })
-            .unwrap_or(PhysicalPosition { x: 0, y: 0 })
+        let rc_monitor = get_monitor_info(self.0).unwrap().monitorInfo.rcMonitor;
+        PhysicalPosition {
+            x: rc_monitor.left,
+            y: rc_monitor.top,
+        }
     }
 
     #[inline]
@@ -230,45 +226,37 @@ impl MonitorHandle {
         // EnumDisplaySettingsExW can return duplicate values (or some of the
         // fields are probably changing, but we aren't looking at those fields
         // anyway), so we're using a BTreeSet deduplicate
-        let mut modes = BTreeSet::<RootVideoMode>::new();
-        let mod_map = |mode: RootVideoMode| mode.video_mode;
-
-        let monitor_info = match get_monitor_info(self.0) {
-            Ok(monitor_info) => monitor_info,
-            Err(error) => {
-                log::warn!("Error from get_monitor_info: {error}");
-                return modes.into_iter().map(mod_map);
-            }
-        };
-
-        let device_name = monitor_info.szDevice.as_ptr();
-
+        let mut modes = BTreeSet::new();
         let mut i = 0;
+
         loop {
-            let mut mode: DEVMODEW = unsafe { mem::zeroed() };
-            mode.dmSize = mem::size_of_val(&mode) as u16;
-            if unsafe { EnumDisplaySettingsExW(device_name, i, &mut mode, 0) } == false.into() {
-                break;
+            unsafe {
+                let monitor_info = get_monitor_info(self.0).unwrap();
+                let device_name = monitor_info.szDevice.as_ptr();
+                let mut mode: DEVMODEW = mem::zeroed();
+                mode.dmSize = mem::size_of_val(&mode) as u16;
+                if EnumDisplaySettingsExW(device_name, i, &mut mode, 0) == false.into() {
+                    break;
+                }
+                i += 1;
+
+                const REQUIRED_FIELDS: u32 =
+                    DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
+                assert!(has_flag(mode.dmFields, REQUIRED_FIELDS));
+
+                // Use Ord impl of RootVideoMode
+                modes.insert(RootVideoMode {
+                    video_mode: VideoMode {
+                        size: (mode.dmPelsWidth, mode.dmPelsHeight),
+                        bit_depth: mode.dmBitsPerPel as u16,
+                        refresh_rate_millihertz: mode.dmDisplayFrequency * 1000,
+                        monitor: self.clone(),
+                        native_video_mode: Box::new(mode),
+                    },
+                });
             }
-
-            const REQUIRED_FIELDS: u32 =
-                DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
-            assert!(has_flag(mode.dmFields, REQUIRED_FIELDS));
-
-            // Use Ord impl of RootVideoMode
-            modes.insert(RootVideoMode {
-                video_mode: VideoMode {
-                    size: (mode.dmPelsWidth, mode.dmPelsHeight),
-                    bit_depth: mode.dmBitsPerPel as u16,
-                    refresh_rate_millihertz: mode.dmDisplayFrequency * 1000,
-                    monitor: self.clone(),
-                    native_video_mode: Box::new(mode),
-                },
-            });
-
-            i += 1;
         }
 
-        modes.into_iter().map(mod_map)
+        modes.into_iter().map(|mode| mode.video_mode)
     }
 }

src/platform_impl/windows/raw_input.rs

@@ -11,29 +11,19 @@ use windows_sys::Win32::{
     UI::{
         Input::{
             GetRawInputData, GetRawInputDeviceInfoW, GetRawInputDeviceList,
-            KeyboardAndMouse::{MapVirtualKeyW, MAPVK_VK_TO_VSC_EX, VK_NUMLOCK, VK_SHIFT},
             RegisterRawInputDevices, HRAWINPUT, RAWINPUT, RAWINPUTDEVICE, RAWINPUTDEVICELIST,
-            RAWINPUTHEADER, RAWKEYBOARD, RIDEV_DEVNOTIFY, RIDEV_INPUTSINK, RIDEV_REMOVE,
-            RIDI_DEVICEINFO, RIDI_DEVICENAME, RID_DEVICE_INFO, RID_DEVICE_INFO_HID,
-            RID_DEVICE_INFO_KEYBOARD, RID_DEVICE_INFO_MOUSE, RID_INPUT, RIM_TYPEHID,
-            RIM_TYPEKEYBOARD, RIM_TYPEMOUSE,
+            RAWINPUTHEADER, RIDEV_DEVNOTIFY, RIDEV_INPUTSINK, RIDEV_REMOVE, RIDI_DEVICEINFO,
+            RIDI_DEVICENAME, RID_DEVICE_INFO, RID_DEVICE_INFO_HID, RID_DEVICE_INFO_KEYBOARD,
+            RID_DEVICE_INFO_MOUSE, RID_INPUT, RIM_TYPEHID, RIM_TYPEKEYBOARD, RIM_TYPEMOUSE,
         },
         WindowsAndMessaging::{
-            RI_KEY_E0, RI_KEY_E1, RI_MOUSE_BUTTON_1_DOWN, RI_MOUSE_BUTTON_1_UP,
-            RI_MOUSE_BUTTON_2_DOWN, RI_MOUSE_BUTTON_2_UP, RI_MOUSE_BUTTON_3_DOWN,
-            RI_MOUSE_BUTTON_3_UP, RI_MOUSE_BUTTON_4_DOWN, RI_MOUSE_BUTTON_4_UP,
-            RI_MOUSE_BUTTON_5_DOWN, RI_MOUSE_BUTTON_5_UP,
+            RI_MOUSE_LEFT_BUTTON_DOWN, RI_MOUSE_LEFT_BUTTON_UP, RI_MOUSE_MIDDLE_BUTTON_DOWN,
+            RI_MOUSE_MIDDLE_BUTTON_UP, RI_MOUSE_RIGHT_BUTTON_DOWN, RI_MOUSE_RIGHT_BUTTON_UP,
         },
     },
 };
 
-use crate::{
-    event::ElementState,
-    event_loop::DeviceEvents,
-    keyboard::{KeyCode, PhysicalKey},
-    platform::scancode::PhysicalKeyExtScancode,
-    platform_impl::platform::util,
-};
+use crate::{event::ElementState, event_loop::DeviceEvents, platform_impl::platform::util};
 
 #[allow(dead_code)]
 pub fn get_raw_input_device_list() -> Option<Vec<RAWINPUTDEVICELIST>> {
@@ -219,108 +209,22 @@ fn button_flags_to_element_state(
     }
 }
 
-pub fn get_raw_mouse_button_state(button_flags: u32) -> [Option<ElementState>; 5] {
+pub fn get_raw_mouse_button_state(button_flags: u32) -> [Option<ElementState>; 3] {
     [
-        button_flags_to_element_state(button_flags, RI_MOUSE_BUTTON_1_DOWN, RI_MOUSE_BUTTON_1_UP),
-        button_flags_to_element_state(button_flags, RI_MOUSE_BUTTON_2_DOWN, RI_MOUSE_BUTTON_2_UP),
-        button_flags_to_element_state(button_flags, RI_MOUSE_BUTTON_3_DOWN, RI_MOUSE_BUTTON_3_UP),
-        button_flags_to_element_state(button_flags, RI_MOUSE_BUTTON_4_DOWN, RI_MOUSE_BUTTON_4_UP),
-        button_flags_to_element_state(button_flags, RI_MOUSE_BUTTON_5_DOWN, RI_MOUSE_BUTTON_5_UP),
+        button_flags_to_element_state(
+            button_flags,
+            RI_MOUSE_LEFT_BUTTON_DOWN,
+            RI_MOUSE_LEFT_BUTTON_UP,
+        ),
+        button_flags_to_element_state(
+            button_flags,
+            RI_MOUSE_MIDDLE_BUTTON_DOWN,
+            RI_MOUSE_MIDDLE_BUTTON_UP,
+        ),
+        button_flags_to_element_state(
+            button_flags,
+            RI_MOUSE_RIGHT_BUTTON_DOWN,
+            RI_MOUSE_RIGHT_BUTTON_UP,
+        ),
     ]
 }
-
-pub fn get_keyboard_physical_key(keyboard: RAWKEYBOARD) -> Option<PhysicalKey> {
-    let extension = {
-        if util::has_flag(keyboard.Flags, RI_KEY_E0 as _) {
-            0xE000
-        } else if util::has_flag(keyboard.Flags, RI_KEY_E1 as _) {
-            0xE100
-        } else {
-            0x0000
-        }
-    };
-    let scancode = if keyboard.MakeCode == 0 {
-        // In some cases (often with media keys) the device reports a scancode of 0 but a
-        // valid virtual key. In these cases we obtain the scancode from the virtual key.
-        unsafe { MapVirtualKeyW(keyboard.VKey as u32, MAPVK_VK_TO_VSC_EX) as u16 }
-    } else {
-        keyboard.MakeCode | extension
-    };
-    if scancode == 0xE11D || scancode == 0xE02A {
-        // At the hardware (or driver?) level, pressing the Pause key is equivalent to pressing
-        // Ctrl+NumLock.
-        // This equvalence means that if the user presses Pause, the keyboard will emit two
-        // subsequent keypresses:
-        // 1, 0xE11D - Which is a left Ctrl (0x1D) with an extension flag (0xE100)
-        // 2, 0x0045 - Which on its own can be interpreted as Pause
-        //
-        // There's another combination which isn't quite an equivalence:
-        // PrtSc used to be Shift+Asterisk. This means that on some keyboards, presssing
-        // PrtSc (print screen) produces the following sequence:
-        // 1, 0xE02A - Which is a left shift (0x2A) with an extension flag (0xE000)
-        // 2, 0xE037 - Which is a numpad multiply (0x37) with an exteion flag (0xE000). This on
-        //             its own it can be interpreted as PrtSc
-        //
-        // For this reason, if we encounter the first keypress, we simply ignore it, trusting
-        // that there's going to be another event coming, from which we can extract the
-        // appropriate key.
-        // For more on this, read the article by Raymond Chen, titled:
-        // "Why does Ctrl+ScrollLock cancel dialogs?"
-        // https://devblogs.microsoft.com/oldnewthing/20080211-00/?p=23503
-        return None;
-    }
-    let physical_key = if keyboard.VKey == VK_NUMLOCK {
-        // Historically, the NumLock and the Pause key were one and the same physical key.
-        // The user could trigger Pause by pressing Ctrl+NumLock.
-        // Now these are often physically separate and the two keys can be differentiated by
-        // checking the extension flag of the scancode. NumLock is 0xE045, Pause is 0x0045.
-        //
-        // However in this event, both keys are reported as 0x0045 even on modern hardware.
-        // Therefore we use the virtual key instead to determine whether it's a NumLock and
-        // set the KeyCode accordingly.
-        //
-        // For more on this, read the article by Raymond Chen, titled:
-        // "Why does Ctrl+ScrollLock cancel dialogs?"
-        // https://devblogs.microsoft.com/oldnewthing/20080211-00/?p=23503
-        PhysicalKey::Code(KeyCode::NumLock)
-    } else {
-        PhysicalKey::from_scancode(scancode as u32)
-    };
-    if keyboard.VKey == VK_SHIFT {
-        if let PhysicalKey::Code(code) = physical_key {
-            match code {
-                KeyCode::NumpadDecimal
-                | KeyCode::Numpad0
-                | KeyCode::Numpad1
-                | KeyCode::Numpad2
-                | KeyCode::Numpad3
-                | KeyCode::Numpad4
-                | KeyCode::Numpad5
-                | KeyCode::Numpad6
-                | KeyCode::Numpad7
-                | KeyCode::Numpad8
-                | KeyCode::Numpad9 => {
-                    // On Windows, holding the Shift key makes numpad keys behave as if NumLock
-                    // wasn't active. The way this is exposed to applications by the system is that
-                    // the application receives a fake key release event for the shift key at the
-                    // moment when the numpad key is pressed, just before receiving the numpad key
-                    // as well.
-                    //
-                    // The issue is that in the raw device event (here), the fake shift release
-                    // event reports the numpad key as the scancode. Unfortunately, the event doesn't
-                    // have any information to tell whether it's the left shift or the right shift
-                    // that needs to get the fake release (or press) event so we don't forward this
-                    // event to the application at all.
-                    //
-                    // For more on this, read the article by Raymond Chen, titled:
-                    // "The shift key overrides NumLock"
-                    // https://devblogs.microsoft.com/oldnewthing/20040906-00/?p=37953
-                    return None;
-                }
-                _ => (),
-            }
-        }
-    }
-
-    Some(physical_key)
-}

src/platform_impl/windows/util.rs

@@ -13,7 +13,7 @@ use once_cell::sync::Lazy;
 use windows_sys::{
     core::{HRESULT, PCWSTR},
     Win32::{
-        Foundation::{BOOL, HANDLE, HMODULE, HWND, RECT},
+        Foundation::{BOOL, HMODULE, HWND, RECT},
         Graphics::Gdi::{ClientToScreen, HMONITOR},
         System::{
             LibraryLoader::{GetProcAddress, LoadLibraryA},
@@ -21,10 +21,7 @@ use windows_sys::{
         },
         UI::{
             HiDpi::{DPI_AWARENESS_CONTEXT, MONITOR_DPI_TYPE, PROCESS_DPI_AWARENESS},
-            Input::{
-                KeyboardAndMouse::GetActiveWindow,
-                Pointer::{POINTER_INFO, POINTER_PEN_INFO, POINTER_TOUCH_INFO},
-            },
+            Input::KeyboardAndMouse::GetActiveWindow,
             WindowsAndMessaging::{
                 ClipCursor, GetClientRect, GetClipCursor, GetSystemMetrics, GetWindowPlacement,
                 GetWindowRect, IsIconic, ShowCursor, IDC_APPSTARTING, IDC_ARROW, IDC_CROSS,
@@ -194,9 +191,7 @@ pub(crate) fn to_windows_cursor(cursor: CursorIcon) -> PCWSTR {
     }
 }
 
-// Helper function to dynamically load function pointer as some functions
-// may not be available on all Windows platforms supported by winit.
-//
+// Helper function to dynamically load function pointer.
 // `library` and `function` must be zero-terminated.
 pub(super) fn get_function_impl(library: &str, function: &str) -> Option<*const c_void> {
     assert_eq!(library.chars().last(), Some('\0'));
@@ -242,26 +237,6 @@ pub type AdjustWindowRectExForDpi = unsafe extern "system" fn(
     dpi: u32,
 ) -> BOOL;
 
-pub type GetPointerFrameInfoHistory = unsafe extern "system" fn(
-    pointerId: u32,
-    entriesCount: *mut u32,
-    pointerCount: *mut u32,
-    pointerInfo: *mut POINTER_INFO,
-) -> BOOL;
-
-pub type SkipPointerFrameMessages = unsafe extern "system" fn(pointerId: u32) -> BOOL;
-pub type GetPointerDeviceRects = unsafe extern "system" fn(
-    device: HANDLE,
-    pointerDeviceRect: *mut RECT,
-    displayRect: *mut RECT,
-) -> BOOL;
-
-pub type GetPointerTouchInfo =
-    unsafe extern "system" fn(pointerId: u32, touchInfo: *mut POINTER_TOUCH_INFO) -> BOOL;
-
-pub type GetPointerPenInfo =
-    unsafe extern "system" fn(pointId: u32, penInfo: *mut POINTER_PEN_INFO) -> BOOL;
-
 pub static GET_DPI_FOR_WINDOW: Lazy<Option<GetDpiForWindow>> =
     Lazy::new(|| get_function!("user32.dll", GetDpiForWindow));
 pub static ADJUST_WINDOW_RECT_EX_FOR_DPI: Lazy<Option<AdjustWindowRectExForDpi>> =
@@ -276,13 +251,3 @@ pub static SET_PROCESS_DPI_AWARENESS: Lazy<Option<SetProcessDpiAwareness>> =
     Lazy::new(|| get_function!("shcore.dll", SetProcessDpiAwareness));
 pub static SET_PROCESS_DPI_AWARE: Lazy<Option<SetProcessDPIAware>> =
     Lazy::new(|| get_function!("user32.dll", SetProcessDPIAware));
-pub static GET_POINTER_FRAME_INFO_HISTORY: Lazy<Option<GetPointerFrameInfoHistory>> =
-    Lazy::new(|| get_function!("user32.dll", GetPointerFrameInfoHistory));
-pub static SKIP_POINTER_FRAME_MESSAGES: Lazy<Option<SkipPointerFrameMessages>> =
-    Lazy::new(|| get_function!("user32.dll", SkipPointerFrameMessages));
-pub static GET_POINTER_DEVICE_RECTS: Lazy<Option<GetPointerDeviceRects>> =
-    Lazy::new(|| get_function!("user32.dll", GetPointerDeviceRects));
-pub static GET_POINTER_TOUCH_INFO: Lazy<Option<GetPointerTouchInfo>> =
-    Lazy::new(|| get_function!("user32.dll", GetPointerTouchInfo));
-pub static GET_POINTER_PEN_INFO: Lazy<Option<GetPointerPenInfo>> =
-    Lazy::new(|| get_function!("user32.dll", GetPointerPenInfo));

src/platform_impl/windows/window.rs

@@ -83,7 +83,7 @@ use crate::{
 /// The Win32 implementation of the main `Window` object.
 pub(crate) struct Window {
     /// Main handle for the window.
-    window: HWND,
+    window: WindowWrapper,
 
     /// The current window state.
     window_state: Arc<Mutex<WindowState>>,
@@ -126,26 +126,17 @@ impl Window {
         }
     }
 
-    pub fn set_transparent(&self, transparent: bool) {
-        let window = self.window;
-        let window_state = Arc::clone(&self.window_state);
-        self.thread_executor.execute_in_thread(move || {
-            let _ = &window;
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
-                f.set(WindowFlags::TRANSPARENT, transparent)
-            });
-        });
-    }
+    pub fn set_transparent(&self, _transparent: bool) {}
 
     pub fn set_blur(&self, _blur: bool) {}
 
     #[inline]
     pub fn set_visible(&self, visible: bool) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
         self.thread_executor.execute_in_thread(move || {
             let _ = &window;
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(WindowFlags::VISIBLE, visible)
             });
         });
@@ -153,13 +144,11 @@ impl Window {
 
     #[inline]
     pub fn is_visible(&self) -> Option<bool> {
-        Some(unsafe { IsWindowVisible(self.window) == 1 })
+        Some(unsafe { IsWindowVisible(self.window.0) == 1 })
     }
 
     #[inline]
     pub fn request_redraw(&self) {
-        // NOTE: mark that we requested a redraw to handle requests during `WM_PAINT` handling.
-        self.window_state.lock().unwrap().redraw_requested = true;
         unsafe {
             RedrawWindow(self.hwnd(), ptr::null(), 0, RDW_INTERNALPAINT);
         }
@@ -189,10 +178,10 @@ impl Window {
         let (x, y): (i32, i32) = position.to_physical::<i32>(self.scale_factor()).into();
 
         let window_state = Arc::clone(&self.window_state);
-        let window = self.window;
+        let window = self.window.clone();
         self.thread_executor.execute_in_thread(move || {
             let _ = &window;
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(WindowFlags::MAXIMIZED, false)
             });
         });
@@ -246,10 +235,10 @@ impl Window {
 
         if physical_size != self.inner_size() {
             let window_state = Arc::clone(&self.window_state);
-            let window = self.window;
+            let window = self.window.clone();
             self.thread_executor.execute_in_thread(move || {
                 let _ = &window;
-                WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+                WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                     f.set(WindowFlags::MAXIMIZED, false)
                 });
             });
@@ -284,12 +273,12 @@ impl Window {
 
     #[inline]
     pub fn set_resizable(&self, resizable: bool) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
         self.thread_executor.execute_in_thread(move || {
             let _ = &window;
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(WindowFlags::RESIZABLE, resizable)
             });
         });
@@ -303,12 +292,12 @@ impl Window {
 
     #[inline]
     pub fn set_enabled_buttons(&self, buttons: WindowButtons) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
         self.thread_executor.execute_in_thread(move || {
             let _ = &window;
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(
                     WindowFlags::MINIMIZABLE,
                     buttons.contains(WindowButtons::MINIMIZE),
@@ -342,14 +331,14 @@ impl Window {
     /// Returns the `hwnd` of this window.
     #[inline]
     pub fn hwnd(&self) -> HWND {
-        self.window
+        self.window.0
     }
 
     #[cfg(feature = "rwh_04")]
     #[inline]
     pub fn raw_window_handle_rwh_04(&self) -> rwh_04::RawWindowHandle {
         let mut window_handle = rwh_04::Win32Handle::empty();
-        window_handle.hwnd = self.window as *mut _;
+        window_handle.hwnd = self.window.0 as *mut _;
         let hinstance = unsafe { super::get_window_long(self.hwnd(), GWLP_HINSTANCE) };
         window_handle.hinstance = hinstance as *mut _;
         rwh_04::RawWindowHandle::Win32(window_handle)
@@ -359,7 +348,7 @@ impl Window {
     #[inline]
     pub fn raw_window_handle_rwh_05(&self) -> rwh_05::RawWindowHandle {
         let mut window_handle = rwh_05::Win32WindowHandle::empty();
-        window_handle.hwnd = self.window as *mut _;
+        window_handle.hwnd = self.window.0 as *mut _;
         let hinstance = unsafe { super::get_window_long(self.hwnd(), GWLP_HINSTANCE) };
         window_handle.hinstance = hinstance as *mut _;
         rwh_05::RawWindowHandle::Win32(window_handle)
@@ -376,7 +365,8 @@ impl Window {
     pub fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
         let mut window_handle = rwh_06::Win32WindowHandle::new(unsafe {
             // SAFETY: Handle will never be zero.
-            std::num::NonZeroIsize::new_unchecked(self.window)
+            let window = self.window.0;
+            std::num::NonZeroIsize::new_unchecked(window)
         });
         let hinstance = unsafe { super::get_window_long(self.hwnd(), GWLP_HINSTANCE) };
         window_handle.hinstance = std::num::NonZeroIsize::new(hinstance);
@@ -412,7 +402,7 @@ impl Window {
             }
         };
 
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
         let (tx, rx) = channel();
 
@@ -422,7 +412,7 @@ impl Window {
                 .lock()
                 .unwrap()
                 .mouse
-                .set_cursor_flags(window, |f| f.set(CursorFlags::GRABBED, confine))
+                .set_cursor_flags(window.0, |f| f.set(CursorFlags::GRABBED, confine))
                 .map_err(|e| ExternalError::Os(os_error!(e)));
             let _ = tx.send(result);
         });
@@ -431,7 +421,7 @@ impl Window {
 
     #[inline]
     pub fn set_cursor_visible(&self, visible: bool) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
         let (tx, rx) = channel();
 
@@ -441,7 +431,7 @@ impl Window {
                 .lock()
                 .unwrap()
                 .mouse
-                .set_cursor_flags(window, |f| f.set(CursorFlags::HIDDEN, !visible))
+                .set_cursor_flags(window.0, |f| f.set(CursorFlags::HIDDEN, !visible))
                 .map_err(|e| e.to_string());
             let _ = tx.send(result);
         });
@@ -471,41 +461,27 @@ impl Window {
     }
 
     unsafe fn handle_os_dragging(&self, wparam: WPARAM) {
-        let window = self.window;
-        let window_state = self.window_state.clone();
+        let points = {
+            let mut pos = unsafe { mem::zeroed() };
+            unsafe { GetCursorPos(&mut pos) };
+            pos
+        };
+        let points = POINTS {
+            x: points.x as i16,
+            y: points.y as i16,
+        };
+        unsafe { ReleaseCapture() };
 
-        self.thread_executor.execute_in_thread(move || {
-            {
-                let mut guard = window_state.lock().unwrap();
-                if !guard.dragging {
-                    guard.dragging = true;
-                } else {
-                    return;
-                }
-            }
+        self.window_state_lock().dragging = true;
 
-            let points = {
-                let mut pos = unsafe { mem::zeroed() };
-                unsafe { GetCursorPos(&mut pos) };
-                pos
-            };
-            let points = POINTS {
-                x: points.x as i16,
-                y: points.y as i16,
-            };
-
-            // ReleaseCapture needs to execute on the main thread
-            unsafe { ReleaseCapture() };
-
-            unsafe {
-                PostMessageW(
-                    window,
-                    WM_NCLBUTTONDOWN,
-                    wparam,
-                    &points as *const _ as LPARAM,
-                )
-            };
-        });
+        unsafe {
+            PostMessageW(
+                self.hwnd(),
+                WM_NCLBUTTONDOWN,
+                wparam,
+                &points as *const _ as LPARAM,
+            )
+        };
     }
 
     #[inline]
@@ -614,10 +590,10 @@ impl Window {
 
     #[inline]
     pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
         self.thread_executor.execute_in_thread(move || {
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(WindowFlags::IGNORE_CURSOR_EVENT, !hittest)
             });
         });
@@ -632,7 +608,7 @@ impl Window {
 
     #[inline]
     pub fn set_minimized(&self, minimized: bool) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
         let is_minimized = util::is_minimized(self.hwnd());
@@ -642,7 +618,7 @@ impl Window {
             WindowState::set_window_flags_in_place(&mut window_state.lock().unwrap(), |f| {
                 f.set(WindowFlags::MINIMIZED, is_minimized)
             });
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(WindowFlags::MINIMIZED, minimized)
             });
         });
@@ -655,12 +631,12 @@ impl Window {
 
     #[inline]
     pub fn set_maximized(&self, maximized: bool) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
         self.thread_executor.execute_in_thread(move || {
             let _ = &window;
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(WindowFlags::MAXIMIZED, maximized)
             });
         });
@@ -680,24 +656,14 @@ impl Window {
 
     #[inline]
     pub fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
         let mut window_state_lock = window_state.lock().unwrap();
         let old_fullscreen = window_state_lock.fullscreen.clone();
-
-        match (&old_fullscreen, &fullscreen) {
-            // Return if we already are in the same fullscreen mode
-            _ if old_fullscreen == fullscreen => return,
-            // Return if saved Borderless(monitor) is the same as current monitor when requested fullscreen is Borderless(None)
-            (Some(Fullscreen::Borderless(Some(monitor))), Some(Fullscreen::Borderless(None)))
-                if *monitor == monitor::current_monitor(window) =>
-            {
-                return
-            }
-            _ => {}
+        if window_state_lock.fullscreen == fullscreen {
+            return;
         }
-
         window_state_lock.fullscreen = fullscreen.clone();
         drop(window_state_lock);
 
@@ -760,7 +726,7 @@ impl Window {
             }
 
             // Update window style
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(
                     WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN,
                     matches!(fullscreen, Some(Fullscreen::Exclusive(_))),
@@ -776,7 +742,7 @@ impl Window {
             // this needs to be called before the below fullscreen SetWindowPos as this itself
             // will generate WM_SIZE messages of the old window size that can race with what we set below
             unsafe {
-                taskbar_mark_fullscreen(window, fullscreen.is_some());
+                taskbar_mark_fullscreen(window.0, fullscreen.is_some());
             }
 
             // Update window bounds
@@ -785,7 +751,7 @@ impl Window {
                     // Save window bounds before entering fullscreen
                     let placement = unsafe {
                         let mut placement = mem::zeroed();
-                        GetWindowPlacement(window, &mut placement);
+                        GetWindowPlacement(window.0, &mut placement);
                         placement
                     };
 
@@ -794,7 +760,7 @@ impl Window {
                     let monitor = match &fullscreen {
                         Fullscreen::Exclusive(video_mode) => video_mode.monitor(),
                         Fullscreen::Borderless(Some(monitor)) => monitor.clone(),
-                        Fullscreen::Borderless(None) => monitor::current_monitor(window),
+                        Fullscreen::Borderless(None) => monitor::current_monitor(window.0),
                     };
 
                     let position: (i32, i32) = monitor.position().into();
@@ -802,7 +768,7 @@ impl Window {
 
                     unsafe {
                         SetWindowPos(
-                            window,
+                            window.0,
                             0,
                             position.0,
                             position.1,
@@ -810,7 +776,7 @@ impl Window {
                             size.1 as i32,
                             SWP_ASYNCWINDOWPOS | SWP_NOZORDER,
                         );
-                        InvalidateRgn(window, 0, false.into());
+                        InvalidateRgn(window.0, 0, false.into());
                     }
                 }
                 None => {
@@ -818,8 +784,8 @@ impl Window {
                     if let Some(SavedWindow { placement }) = window_state_lock.saved_window.take() {
                         drop(window_state_lock);
                         unsafe {
-                            SetWindowPlacement(window, &placement);
-                            InvalidateRgn(window, 0, false.into());
+                            SetWindowPlacement(window.0, &placement);
+                            InvalidateRgn(window.0, 0, false.into());
                         }
                     }
                 }
@@ -829,12 +795,12 @@ impl Window {
 
     #[inline]
     pub fn set_decorations(&self, decorations: bool) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
         self.thread_executor.execute_in_thread(move || {
             let _ = &window;
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(WindowFlags::MARKER_DECORATIONS, decorations)
             });
         });
@@ -850,12 +816,12 @@ impl Window {
 
     #[inline]
     pub fn set_window_level(&self, level: WindowLevel) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
         self.thread_executor.execute_in_thread(move || {
             let _ = &window;
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(
                     WindowFlags::ALWAYS_ON_TOP,
                     level == WindowLevel::AlwaysOnTop,
@@ -904,22 +870,17 @@ impl Window {
 
     #[inline]
     pub fn set_ime_cursor_area(&self, spot: Position, size: Size) {
-        let window = self.window;
-        let state = self.window_state.clone();
-        self.thread_executor.execute_in_thread(move || unsafe {
-            let scale_factor = state.lock().unwrap().scale_factor;
-            ImeContext::current(window).set_ime_cursor_area(spot, size, scale_factor);
-        });
+        unsafe {
+            ImeContext::current(self.hwnd()).set_ime_cursor_area(spot, size, self.scale_factor());
+        }
     }
 
     #[inline]
     pub fn set_ime_allowed(&self, allowed: bool) {
-        let window = self.window;
-        let state = self.window_state.clone();
-        self.thread_executor.execute_in_thread(move || unsafe {
-            state.lock().unwrap().ime_allowed = allowed;
-            ImeContext::set_ime_allowed(window, allowed);
-        })
+        self.window_state_lock().ime_allowed = allowed;
+        unsafe {
+            ImeContext::set_ime_allowed(self.hwnd(), allowed);
+        }
     }
 
     #[inline]
@@ -927,13 +888,14 @@ impl Window {
 
     #[inline]
     pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
-        let window = self.window;
+        let window = self.window.clone();
         let active_window_handle = unsafe { GetActiveWindow() };
-        if window == active_window_handle {
+        if window.0 == active_window_handle {
             return;
         }
 
         self.thread_executor.execute_in_thread(move || unsafe {
+            let _ = &window;
             let (flags, count) = request_type
                 .map(|ty| match ty {
                     UserAttentionType::Critical => (FLASHW_ALL | FLASHW_TIMERNOFG, u32::MAX),
@@ -943,7 +905,7 @@ impl Window {
 
             let flash_info = FLASHWINFO {
                 cbSize: mem::size_of::<FLASHWINFO>() as u32,
-                hwnd: window,
+                hwnd: window.0,
                 dwFlags: flags,
                 uCount: count,
                 dwTimeout: 0,
@@ -954,7 +916,7 @@ impl Window {
 
     #[inline]
     pub fn set_theme(&self, theme: Option<Theme>) {
-        try_theme(self.window, theme);
+        try_theme(self.window.0, theme);
     }
 
     #[inline]
@@ -969,9 +931,9 @@ impl Window {
     }
 
     pub fn title(&self) -> String {
-        let len = unsafe { GetWindowTextLengthW(self.window) } + 1;
+        let len = unsafe { GetWindowTextLengthW(self.window.0) } + 1;
         let mut buf = vec![0; len as usize];
-        unsafe { GetWindowTextW(self.window, buf.as_mut_ptr(), len) };
+        unsafe { GetWindowTextW(self.window.0, buf.as_mut_ptr(), len) };
         util::decode_wide(&buf).to_string_lossy().to_string()
     }
 
@@ -983,12 +945,12 @@ impl Window {
 
     #[inline]
     pub fn set_undecorated_shadow(&self, shadow: bool) {
-        let window = self.window;
+        let window = self.window.clone();
         let window_state = Arc::clone(&self.window_state);
 
         self.thread_executor.execute_in_thread(move || {
             let _ = &window;
-            WindowState::set_window_flags(window_state.lock().unwrap(), window, |f| {
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
                 f.set(WindowFlags::MARKER_UNDECORATED_SHADOW, shadow)
             });
         });
@@ -996,14 +958,15 @@ impl Window {
 
     #[inline]
     pub fn focus_window(&self) {
+        let window = self.window.clone();
         let window_flags = self.window_state_lock().window_flags();
 
         let is_visible = window_flags.contains(WindowFlags::VISIBLE);
         let is_minimized = util::is_minimized(self.hwnd());
-        let is_foreground = self.window == unsafe { GetForegroundWindow() };
+        let is_foreground = window.0 == unsafe { GetForegroundWindow() };
 
         if is_visible && !is_minimized && !is_foreground {
-            unsafe { force_window_active(self.window) };
+            unsafe { force_window_active(window.0) };
         }
     }
 
@@ -1053,6 +1016,18 @@ impl Drop for Window {
     }
 }
 
+/// A simple non-owning wrapper around a window.
+#[doc(hidden)]
+#[derive(Clone)]
+pub struct WindowWrapper(HWND);
+
+// Send and Sync are not implemented for HWND and HDC, we have to wrap it and implement them manually.
+// For more info see:
+// https://github.com/retep998/winapi-rs/issues/360
+// https://github.com/retep998/winapi-rs/issues/396
+unsafe impl Sync for WindowWrapper {}
+unsafe impl Send for WindowWrapper {}
+
 pub(super) struct InitData<'a, T: 'static> {
     // inputs
     pub event_loop: &'a EventLoopWindowTarget<T>,
@@ -1100,7 +1075,7 @@ impl<'a, T: 'static> InitData<'a, T> {
         unsafe { ImeContext::set_ime_allowed(window, false) };
 
         Window {
-            window,
+            window: WindowWrapper(window),
             window_state,
             thread_executor: self.event_loop.create_thread_executor(),
         }
@@ -1123,7 +1098,7 @@ impl<'a, T: 'static> InitData<'a, T> {
 
             let file_drop_runner = self.event_loop.runner_shared.clone();
             let file_drop_handler = FileDropHandler::new(
-                win.window,
+                win.window.0,
                 Box::new(move |event| {
                     if let Ok(e) = event.map_nonuser_event() {
                         file_drop_runner.send_event(e)
@@ -1135,7 +1110,7 @@ impl<'a, T: 'static> InitData<'a, T> {
                 unsafe { &mut (*file_drop_handler.data).interface as *mut _ as *mut c_void };
 
             assert_eq!(
-                unsafe { RegisterDragDrop(win.window, handler_interface_ptr) },
+                unsafe { RegisterDragDrop(win.window.0, handler_interface_ptr) },
                 S_OK
             );
             Some(file_drop_handler)
@@ -1210,9 +1185,9 @@ impl<'a, T: 'static> InitData<'a, T> {
 
         win.set_enabled_buttons(attributes.enabled_buttons);
 
-        if attributes.fullscreen.0.is_some() {
-            win.set_fullscreen(attributes.fullscreen.0.map(Into::into));
-            unsafe { force_window_active(win.window) };
+        if attributes.fullscreen.is_some() {
+            win.set_fullscreen(attributes.fullscreen.map(Into::into));
+            unsafe { force_window_active(win.window.0) };
         } else {
             let size = attributes
                 .inner_size
@@ -1297,7 +1272,7 @@ where
     };
 
     #[cfg(feature = "rwh_06")]
-    let parent = match attributes.parent_window.0 {
+    let parent = match attributes.parent_window {
         Some(rwh_06::RawWindowHandle::Win32(handle)) => {
             window_flags.set(WindowFlags::CHILD, true);
             if pl_attribs.menu.is_some() {

src/platform_impl/windows/window_state.rs

@@ -52,9 +52,6 @@ pub(crate) struct WindowState {
     pub is_active: bool,
     pub is_focused: bool,
 
-    // Flag whether redraw was requested.
-    pub redraw_requested: bool,
-
     pub dragging: bool,
 
     pub skip_taskbar: bool,
@@ -169,7 +166,6 @@ impl WindowState {
 
             is_active: false,
             is_focused: false,
-            redraw_requested: false,
 
             dragging: false,
 

src/window.rs

@@ -6,7 +6,7 @@ use crate::{
     error::{ExternalError, NotSupportedError, OsError},
     event_loop::EventLoopWindowTarget,
     monitor::{MonitorHandle, VideoMode},
-    platform_impl, SendSyncWrapper,
+    platform_impl,
 };
 
 pub use crate::icon::{BadIcon, Icon};
@@ -141,6 +141,7 @@ pub struct WindowAttributes {
     pub resizable: bool,
     pub enabled_buttons: WindowButtons,
     pub title: String,
+    pub fullscreen: Option<Fullscreen>,
     pub maximized: bool,
     pub visible: bool,
     pub transparent: bool,
@@ -151,10 +152,9 @@ pub struct WindowAttributes {
     pub resize_increments: Option<Size>,
     pub content_protected: bool,
     pub window_level: WindowLevel,
-    pub active: bool,
     #[cfg(feature = "rwh_06")]
-    pub(crate) parent_window: SendSyncWrapper<Option<rwh_06::RawWindowHandle>>,
-    pub(crate) fullscreen: SendSyncWrapper<Option<Fullscreen>>,
+    pub parent_window: Option<rwh_06::RawWindowHandle>,
+    pub active: bool,
 }
 
 impl Default for WindowAttributes {
@@ -169,7 +169,7 @@ impl Default for WindowAttributes {
             enabled_buttons: WindowButtons::all(),
             title: "winit window".to_owned(),
             maximized: false,
-            fullscreen: SendSyncWrapper(None),
+            fullscreen: None,
             visible: true,
             transparent: false,
             blur: false,
@@ -180,25 +180,12 @@ impl Default for WindowAttributes {
             resize_increments: None,
             content_protected: false,
             #[cfg(feature = "rwh_06")]
-            parent_window: SendSyncWrapper(None),
+            parent_window: None,
             active: true,
         }
     }
 }
 
-impl WindowAttributes {
-    /// Get the parent window stored on the attributes.
-    #[cfg(feature = "rwh_06")]
-    pub fn parent_window(&self) -> Option<&rwh_06::RawWindowHandle> {
-        self.parent_window.0.as_ref()
-    }
-
-    /// Get `Fullscreen` option stored on the attributes.
-    pub fn fullscreen(&self) -> Option<&Fullscreen> {
-        self.fullscreen.0.as_ref()
-    }
-}
-
 impl WindowBuilder {
     /// Initializes a new builder with default values.
     #[inline]
@@ -316,7 +303,7 @@ impl WindowBuilder {
     /// See [`Window::set_fullscreen`] for details.
     #[inline]
     pub fn with_fullscreen(mut self, fullscreen: Option<Fullscreen>) -> Self {
-        self.window.fullscreen = SendSyncWrapper(fullscreen);
+        self.window.fullscreen = fullscreen;
         self
     }
 
@@ -492,7 +479,7 @@ impl WindowBuilder {
         mut self,
         parent_window: Option<rwh_06::RawWindowHandle>,
     ) -> Self {
-        self.window.parent_window = SendSyncWrapper(parent_window);
+        self.window.parent_window = parent_window;
         self
     }
 
@@ -543,17 +530,14 @@ impl Window {
         self.window.maybe_wait_on_main(|w| WindowId(w.id()))
     }
 
-    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and
-    /// vice versa.
+    /// 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.
     ///
     /// Note that this value can change depending on user action (for example if the window is
     /// moved to another screen); as such, tracking [`WindowEvent::ScaleFactorChanged`] events is
     /// the most robust way to track the DPI you need to use to draw.
     ///
-    /// This value may differ from [`MonitorHandle::scale_factor`].
-    ///
-    /// See the [`dpi`](crate::dpi) module for more information.
-    ///
     /// ## Platform-specific
     ///
     /// - **X11:** This respects Xft.dpi, and can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
@@ -588,7 +572,7 @@ impl Window {
     /// ## Platform-specific
     ///
     /// - **Windows** This API uses `RedrawWindow` to request a `WM_PAINT` message and `RedrawRequested`
-    ///   is emitted in sync with any `WM_PAINT` messages.
+    ///   is emitted in sync with any `WM_PAINT` messages
     /// - **iOS:** Can only be called on the main thread.
     /// - **Wayland:** The events are aligned with the frame callbacks when [`Window::pre_present_notify`]
     ///                is used.
@@ -600,11 +584,11 @@ impl Window {
         self.window.maybe_queue_on_main(|w| w.request_redraw())
     }
 
-    /// Notify the windowing system before presenting to the window.
+    /// Notify the windowing system that you're before presenting to the window.
     ///
-    /// You should call this event after your drawing operations, but before you submit
+    /// You should call this event after you've done drawing operations, but before you submit
     /// the buffer to the display or commit your drawings. Doing so will help winit to properly
-    /// schedule and make assumptions about its internal state. For example, it could properly
+    /// schedule and do assumptions about its internal state. For example, it could properly
     /// throttle [`WindowEvent::RedrawRequested`].
     ///
     /// ## Example
@@ -907,7 +891,7 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// - **Web / iOS / Android / Orbital:** Unsupported.
+    /// - **Windows / Web / iOS / Android / Orbital:** Unsupported.
     /// - **X11:** Can only be set while building the window, with [`WindowBuilder::with_transparent`].
     #[inline]
     pub fn set_transparent(&self, transparent: bool) {
@@ -921,7 +905,7 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// - **Android / iOS / X11 / Web / Windows:** Unsupported.
+    /// - **Android / iOS / macOS / X11 / Web / Windows:** Unsupported.
     /// - **Wayland:** Only works with org_kde_kwin_blur_manager protocol.
     #[inline]
     pub fn set_blur(&self, blur: bool) {
@@ -1475,6 +1459,10 @@ impl Window {
     /// Returns the monitor on which the window currently resides.
     ///
     /// Returns `None` if current monitor can't be detected.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **iOS:** Can only be called on the main thread.
     #[inline]
     pub fn current_monitor(&self) -> Option<MonitorHandle> {
         self.window
@@ -1485,6 +1473,10 @@ impl Window {
     ///
     /// This is the same as [`EventLoopWindowTarget::available_monitors`], and is provided for convenience.
     ///
+    /// ## Platform-specific
+    ///
+    /// **iOS:** Can only be called on the main thread.
+    ///
     /// [`EventLoopWindowTarget::available_monitors`]: crate::event_loop::EventLoopWindowTarget::available_monitors
     #[inline]
     pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
@@ -1503,7 +1495,8 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// **Wayland / Web:** Always returns `None`.
+    /// **iOS:** Can only be called on the main thread.
+    /// **Wayland:** Always returns `None`.
     ///
     /// [`EventLoopWindowTarget::primary_monitor`]: crate::event_loop::EventLoopWindowTarget::primary_monitor
     #[inline]
@@ -1516,9 +1509,12 @@ impl Window {
 #[cfg(feature = "rwh_06")]
 impl rwh_06::HasWindowHandle for Window {
     fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        struct Wrapper(rwh_06::RawWindowHandle);
+        unsafe impl Send for Wrapper {}
+
         let raw = self
             .window
-            .maybe_wait_on_main(|w| w.raw_window_handle_rwh_06().map(SendSyncWrapper))?
+            .maybe_wait_on_main(|w| w.raw_window_handle_rwh_06().map(Wrapper))?
             .0;
 
         // SAFETY: The window handle will never be deallocated while the window is alive.
@@ -1529,9 +1525,12 @@ impl rwh_06::HasWindowHandle for Window {
 #[cfg(feature = "rwh_06")]
 impl rwh_06::HasDisplayHandle for Window {
     fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        struct Wrapper(rwh_06::RawDisplayHandle);
+        unsafe impl Send for Wrapper {}
+
         let raw = self
             .window
-            .maybe_wait_on_main(|w| w.raw_display_handle_rwh_06().map(SendSyncWrapper))?
+            .maybe_wait_on_main(|w| w.raw_display_handle_rwh_06().map(Wrapper))?
             .0;
 
         // SAFETY: The window handle will never be deallocated while the window is alive.
@@ -1542,21 +1541,25 @@ impl rwh_06::HasDisplayHandle for Window {
 #[cfg(feature = "rwh_05")]
 unsafe impl rwh_05::HasRawWindowHandle for Window {
     fn raw_window_handle(&self) -> rwh_05::RawWindowHandle {
+        struct Wrapper(rwh_05::RawWindowHandle);
+        unsafe impl Send for Wrapper {}
         self.window
-            .maybe_wait_on_main(|w| SendSyncWrapper(w.raw_window_handle_rwh_05()))
+            .maybe_wait_on_main(|w| Wrapper(w.raw_window_handle_rwh_05()))
             .0
     }
 }
 
 #[cfg(feature = "rwh_05")]
 unsafe impl rwh_05::HasRawDisplayHandle for Window {
-    /// Returns a [`rwh_05::RawDisplayHandle`] used by the [`EventLoop`] that
+    /// Returns a [`raw_window_handle::RawDisplayHandle`] used by the [`EventLoop`] that
     /// created a window.
     ///
     /// [`EventLoop`]: crate::event_loop::EventLoop
     fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
+        struct Wrapper(rwh_05::RawDisplayHandle);
+        unsafe impl Send for Wrapper {}
         self.window
-            .maybe_wait_on_main(|w| SendSyncWrapper(w.raw_display_handle_rwh_05()))
+            .maybe_wait_on_main(|w| Wrapper(w.raw_display_handle_rwh_05()))
             .0
     }
 }
@@ -1564,8 +1567,10 @@ unsafe impl rwh_05::HasRawDisplayHandle for Window {
 #[cfg(feature = "rwh_04")]
 unsafe impl rwh_04::HasRawWindowHandle for Window {
     fn raw_window_handle(&self) -> rwh_04::RawWindowHandle {
+        struct Wrapper(rwh_04::RawWindowHandle);
+        unsafe impl Send for Wrapper {}
         self.window
-            .maybe_wait_on_main(|w| SendSyncWrapper(w.raw_window_handle_rwh_04()))
+            .maybe_wait_on_main(|w| Wrapper(w.raw_window_handle_rwh_04()))
             .0
     }
 }

tests/send_objects.rs

@@ -16,11 +16,6 @@ fn window_send() {
     needs_send::<winit::window::Window>();
 }
 
-#[test]
-fn window_builder_send() {
-    needs_send::<winit::window::WindowBuilder>();
-}
-
 #[test]
 fn ids_send() {
     // ensures that the various `..Id` types implement `Send`

tests/serde_objects.rs

@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 use winit::{
     dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize},
     event::{ElementState, MouseButton, MouseScrollDelta, TouchPhase},
-    keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey, PhysicalKey},
+    keyboard::{Key, KeyCode, KeyLocation, ModifiersState},
     window::CursorIcon,
 };
 
@@ -23,9 +23,7 @@ fn events_serde() {
     needs_serde::<MouseButton>();
     needs_serde::<MouseScrollDelta>();
     needs_serde::<Key>();
-    needs_serde::<NamedKey>();
     needs_serde::<KeyCode>();
-    needs_serde::<PhysicalKey>();
     needs_serde::<KeyLocation>();
     needs_serde::<ModifiersState>();
 }