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

CHANGELOG.md

@@ -2,82 +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.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`.
@@ -94,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
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.29.2"
+version = "0.29.1-beta"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 edition = "2021"
@@ -45,9 +45,6 @@ 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"
@@ -66,16 +63,16 @@ 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 = "0.8.0"
-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"
@@ -215,5 +212,7 @@ web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }
 
 [workspace]
 members = [
+    "xbuild/android-target",
+    "xbuild/ios-target",
     "run-wasm",
 ]

FEATURES.md

@@ -150,7 +150,7 @@ 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
+* Status bar visibility
 * Deferrring system gestures
 * Getting the device idiom
 * Getting the preferred video mode

README.md

@@ -6,7 +6,7 @@
 
 ```toml
 [dependencies]
-winit = "0.29.2"
+winit = "0.29.1-beta"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -32,6 +32,32 @@ Winit is designed to be a low-level brick in a hierarchy of libraries. Consequen
 show something on the window you need to use the platform-specific getters provided by winit, or
 another library.
 
+```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:
@@ -116,7 +142,7 @@ clash.
 
 | winit |       ndk-glue               |
 | :---: | :--------------------------: |
-| 0.29.2| `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"`           |
@@ -151,13 +177,40 @@ class. Your application _must_ specify the base class it needs via a feature fla
 [agdk_releases]: https://developer.android.com/games/agdk/download#agdk-libraries
 [Gradle]: https://developer.android.com/studio/build
 
+For 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:
 1. Remove `ndk-glue` from your `Cargo.toml`
-2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.2", features = [ "android-native-activity" ] }`
+2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.1-beta", features = [ "android-native-activity" ] }`
 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize logging as above).
 4. Pass a clone of the `AndroidApp` that your application receives to Winit when building your event loop (as shown above).
 
@@ -168,13 +221,13 @@ doing anything; this includes creating windows, fetching monitors, drawing,
 and so on, see issues [#2238], [#2051] and [#2087].
 
 If you encounter problems, you should try doing your initialization inside
-`Event::Resumed`.
+`Event::NewEvents(StartCause::Init)`.
 
 #### iOS
 
 Similar to macOS, iOS's main `UIApplicationMain` does some init work that's required
 by all UI related code, see issue [#1705]. You should consider creating your windows
-inside `Event::Resumed`.
+inside `Event::NewEvents(StartCause::Init)`.
 
 
 [#2238]: https://github.com/rust-windowing/winit/issues/2238

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 = []
 

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/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/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_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/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};
 
@@ -258,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> {
@@ -375,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/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

@@ -163,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 excute on a single thread.
-///
-/// # Safety
-///
-/// Winit can run only one event loop at the time and the event loop itself is tied to some thread.
-/// The objects could be send across the threads, but once passed to winit, they execute on the
-/// mean 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/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/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
     }
 }

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,
@@ -946,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.");
         }
@@ -972,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/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))

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};
@@ -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,

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

@@ -151,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");
             }

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,
@@ -1207,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,

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,
@@ -658,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,

src/platform_impl/linux/x11/window.rs

@@ -64,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)]
@@ -106,7 +105,7 @@ impl SharedState {
             resize_increments: None,
             base_size: None,
             has_focus: false,
-            cursor_hittest: None,
+            cursor_hittest: true,
         })
     }
 }
@@ -151,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"),
@@ -548,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()
                 }
@@ -1296,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);
         }
     }
@@ -1628,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(())
     }
 

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

@@ -218,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,
 };
 
@@ -115,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
@@ -134,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);
             }
@@ -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/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},
@@ -90,30 +90,30 @@ impl ModLocationMask {
 
 fn key_to_modifier(key: &Key) -> ModifiersState {
     match key {
-        Key::Named(NamedKey::Alt) => ModifiersState::ALT,
-        Key::Named(NamedKey::Control) => ModifiersState::CONTROL,
-        Key::Named(NamedKey::Super) => ModifiersState::SUPER,
-        Key::Named(NamedKey::Shift) => ModifiersState::SHIFT,
+        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,24 +918,19 @@ 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.
-        if is_flags_changed_event && ns_event.key_code() != 0 {
+        // has already been pressed
+        if is_flags_changed_event {
             let scancode = ns_event.key_code();
-            let physical_key = PhysicalKey::from_scancode(scancode as u32);
+            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));
+            let mut event = create_key_event(ns_event, false, false, Some(keycode));
 
-            let key = code_to_key(physical_key, scancode);
+            let key = code_to_key(keycode, scancode);
             let event_modifier = key_to_modifier(&key);
-            event.physical_key = physical_key;
+            event.physical_key = keycode;
             event.logical_key = key.clone();
-            event.location = code_to_location(physical_key);
+            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();
@@ -956,7 +951,7 @@ impl WinitView {
                 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();
+                    event.physical_key = get_left_modifier_code(&event.logical_key);
                     events.push_back(WindowEvent::KeyboardInput {
                         device_id: DEVICE_ID,
                         event,
@@ -965,7 +960,7 @@ impl WinitView {
                 }
                 if phys_mod.contains(ModLocationMask::RIGHT) {
                     event.location = KeyLocation::Right;
-                    event.physical_key = get_right_modifier_code(&event.logical_key).into();
+                    event.physical_key = get_right_modifier_code(&event.logical_key);
                     events.push_back(WindowEvent::KeyboardInput {
                         device_id: DEVICE_ID,
                         event,

src/platform_impl/macos/window.rs

@@ -295,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)
@@ -449,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`.
@@ -520,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
@@ -1525,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 {
@@ -702,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,5 +1,6 @@
 use std::cell::Cell;
 use std::rc::{Rc, Weak};
+use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex};
 
 use smol_str::SmolStr;
@@ -11,7 +12,7 @@ use web_sys::{
 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};
 
@@ -28,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)>>,
@@ -63,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")
@@ -127,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();
         }
 
@@ -138,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,
@@ -258,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| {
@@ -280,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",

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

@@ -49,15 +49,15 @@ 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_KEY_E0, RI_KEY_E1, 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,
+            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,
@@ -80,8 +80,8 @@ use crate::{
         WindowEvent,
     },
     event_loop::{ControlFlow, DeviceEvents, EventLoopClosed, EventLoopWindowTarget as RootELW},
-    keyboard::{KeyCode, ModifiersState, PhysicalKey},
-    platform::{pump_events::PumpStatus, scancode::PhysicalKeyExtScancode},
+    keyboard::{KeyCode, ModifiersState},
+    platform::{pump_events::PumpStatus, scancode::KeyCodeExtScancode},
     platform_impl::platform::{
         dark_mode::try_theme,
         dpi::{become_dpi_aware, dpi_to_scale_factor},
@@ -1168,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 {
@@ -1447,63 +1438,48 @@ 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();
-
-                        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();
-
-                        userdata.send_event(Event::WindowEvent {
-                            window_id: RootWindowId(WindowId(window)),
-                            event: CursorLeft {
-                                device_id: DEVICE_ID,
-                            },
-                        });
-                    }
-                    PointerMoveKind::None => (),
-                }
-
                 // 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
+                let mut w = userdata.window_state_lock();
                 cursor_moved = w.mouse.last_position != Some(position);
                 w.mouse.last_position = Some(position);
             }
-
             if cursor_moved {
                 update_modifiers(window, userdata);
 
@@ -1542,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);
@@ -1562,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);
@@ -2448,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 {
@@ -2458,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 },
                 });
             }
         }
@@ -2531,7 +2503,7 @@ unsafe fn handle_raw_input<T: 'static>(userdata: &ThreadMsgTargetData<T>, data:
             // https://devblogs.microsoft.com/oldnewthing/20080211-00/?p=23503
             return;
         }
-        let physical_key = if keyboard.VKey == VK_NUMLOCK {
+        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
@@ -2544,86 +2516,49 @@ unsafe fn handle_raw_input<T: 'static>(userdata: &ThreadMsgTargetData<T>, data:
             // 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)
+            KeyCode::NumLock
         } else {
-            PhysicalKey::from_scancode(scancode as u32)
+            KeyCode::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;
-                    }
-                    _ => (),
+            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,
+                physical_key: code,
                 state,
             }),
         });
     }
 }
-
-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
-    }
-}

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]

src/platform_impl/windows/raw_input.rs

@@ -17,10 +17,8 @@ use windows_sys::Win32::{
             RID_DEVICE_INFO_MOUSE, RID_INPUT, RIM_TYPEHID, RIM_TYPEKEYBOARD, RIM_TYPEMOUSE,
         },
         WindowsAndMessaging::{
-            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,
         },
     },
 };
@@ -211,12 +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,
+        ),
     ]
 }

src/platform_impl/windows/window.rs

@@ -149,8 +149,6 @@ impl Window {
 
     #[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);
         }
@@ -872,22 +870,17 @@ impl Window {
 
     #[inline]
     pub fn set_ime_cursor_area(&self, spot: Position, size: Size) {
-        let window = self.window.clone();
-        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.0).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.clone();
-        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.0, allowed);
-        })
+        self.window_state_lock().ime_allowed = allowed;
+        unsafe {
+            ImeContext::set_ime_allowed(self.hwnd(), allowed);
+        }
     }
 
     #[inline]
@@ -1192,8 +1185,8 @@ 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));
+        if attributes.fullscreen.is_some() {
+            win.set_fullscreen(attributes.fullscreen.map(Into::into));
             unsafe { force_window_active(win.window.0) };
         } else {
             let size = attributes
@@ -1279,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
     }
 
@@ -585,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.
@@ -1522,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.
@@ -1535,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.
@@ -1548,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
     }
 }
@@ -1570,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>();
 }

tests/sync_object.rs

@@ -6,8 +6,3 @@ fn window_sync() {
     // ensures that `winit::Window` implements `Sync`
     needs_sync::<winit::window::Window>();
 }
-
-#[test]
-fn window_builder_sync() {
-    needs_sync::<winit::window::WindowBuilder>();
-}

xbuild/README.md

@@ -0,0 +1,3 @@
+# xbuild-target
+
+These are crates that can be built via `x build` in order to simplify CI testing.

xbuild/android-target/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "android-xbuild-target"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[lib]
+crate_type = ["cdylib"]
+
+[dependencies.winit]
+version = "0.29.1-beta"
+path = "../.."
+features = ["android-native-activity"]

xbuild/android-target/src/lib.rs

@@ -0,0 +1,11 @@
+use winit::platform::android::{activity::AndroidApp, EventLoopBuilderExtAndroid};
+
+#[no_mangle]
+fn android_main(app: AndroidApp) {
+    winit::event_loop::EventLoopBuilder::new()
+        .with_android_app(app)
+        .build()
+        .unwrap()
+        .run(|_, _| todo!())
+        .ok();
+}

xbuild/ios-target/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "ios-xbuild-target"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies.winit]
+version = "0.29.1-beta"
+path = "../.."

xbuild/ios-target/src/main.rs

@@ -0,0 +1,7 @@
+fn main() {
+    winit::event_loop::EventLoopBuilder::new()
+        .build()
+        .unwrap()
+        .run(|_, _| todo!())
+        .ok();
+}