Winit version 0.29.0-beta.0

On X11, fix IME not working
The change to xinput2 completely disabled IME support, thus we've got a dead keys reporting, because nothing was eating the key events anymore, however that's not what we really need, given that not working IME makes it impossible for some users to type. The proper solution is to not use Xlib at all for that and rely on xcb and its tooling around the XIM and text compose stuff, so we'll have full control over what is getting sent to the XIM/IC or not. Fixes #2888.
2026-06-26 22:53:15 -04:00 · 2023-06-30 23:33:29 +04:00 · 2023-06-30 19:59:24 +04:00 · 2023-06-29 15:53:58 +02:00 · 2023-06-28 15:38:49 +02:00 · 2023-06-28 14:48:35 +04:00
158 changed files with 16596 additions and 8288 deletions
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -28,8 +28,8 @@
 /src/platform_impl/macos            @madsmtm

 # Web (no maintainer)
-/src/platform/web.rs
-/src/platform_impl/web
+/src/platform/web.rs                @daxpedda
+/src/platform_impl/web              @daxpedda

 # Windows
 /src/platform/windows.rs            @msiglreith
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -9,20 +9,50 @@ jobs:
  Check_Formatting:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
    - uses: hecrj/setup-rust-action@v1
      with:
        rust-version: stable
        components: rustfmt
    - name: Check Formatting
      run: cargo +stable fmt --all -- --check
+  
+  cargo-deny:
+    name: cargo-deny
+
+    # TODO: remove this matrix when https://github.com/EmbarkStudios/cargo-deny/issues/324 is resolved
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - aarch64-apple-ios
+          - aarch64-linux-android
+          - i686-pc-windows-gnu
+          - i686-pc-windows-msvc
+          - i686-unknown-linux-gnu
+          - wasm32-unknown-unknown
+          - x86_64-apple-darwin
+          - x86_64-apple-ios
+          - x86_64-pc-windows-gnu
+          - x86_64-pc-windows-msvc
+          - x86_64-unknown-linux-gnu
+          - x86_64-unknown-redox
+
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: EmbarkStudios/cargo-deny-action@v1
+      with:
+        command: check
+        log-level: error
+        arguments: --all-features --target ${{ matrix.platform }}

  tests:
    name: Tests
    strategy:
      fail-fast: false
      matrix:
-        rust_version: ['1.60.0', stable, nightly]
+        rust_version: ['1.64.0', stable, nightly]
        platform:
          # Note: Make sure that we test all the `docs.rs` targets defined in Cargo.toml!
          - { target: x86_64-pc-windows-msvc,   os: windows-latest,  }
@@ -53,7 +83,7 @@ jobs:

    runs-on: ${{ matrix.platform.os }}
    steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
    # Used to cache cargo-web
    - name: Cache cargo folder
      uses: actions/cache@v1
@@ -86,7 +116,7 @@ jobs:
      shell: bash
      if: >
        !contains(matrix.platform.target, 'redox') &&
-        matrix.rust_version != '1.60.0'
+        matrix.rust_version != '1.64.0'
      run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES

    - name: Run tests
@@ -96,7 +126,7 @@ jobs:
        !contains(matrix.platform.target, 'ios') &&
        !contains(matrix.platform.target, 'wasm32') &&
        !contains(matrix.platform.target, 'redox') &&
-        matrix.rust_version != '1.60.0'
+        matrix.rust_version != '1.64.0'
      run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES

    - name: Lint with clippy
@@ -108,7 +138,7 @@ jobs:
      shell: bash
      if: >
        !contains(matrix.platform.target, 'redox') &&
-        matrix.rust_version != '1.60.0'
+        matrix.rust_version != '1.64.0'
      run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES
    - name: Run tests with serde enabled
      shell: bash
@@ -117,5 +147,5 @@ jobs:
        !contains(matrix.platform.target, 'ios') &&
        !contains(matrix.platform.target, 'wasm32') &&
        !contains(matrix.platform.target, 'redox') &&
-        matrix.rust_version != '1.60.0'
+        matrix.rust_version != '1.64.0'
      run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,125 @@ And please only add new entries to the top of this list, right below the `# Unre

 # Unreleased

+# 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 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 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.6
+
+- On macOS, fixed memory leak when getting monitor handle.
+- On macOS, fix `Backspace` being emitted when clearing preedit with it.
+
+# 0.28.5
+
+- On macOS, fix `key_up` being ignored when `Ime` is disabled.
+
+# 0.28.4
+
+- On macOS, fix empty marked text blocking regular input.
+- On macOS, fix potential panic when getting refresh rate.
+- On macOS, fix crash when calling `Window::set_ime_position` from another thread.
+
+# 0.28.3
+
+- Fix macOS memory leaks.
+
+# 0.28.2
+
+- Implement `HasRawDisplayHandle` for `EventLoop`.
+- On macOS, set resize increments only for live resizes.
+- On Wayland, fix rare crash on DPI change
+- Web: Added support for `Window::theme`.
+- On Wayland, fix rounding issues when doing resize.
+- On macOS, fix wrong focused state on startup.
+- On Windows, fix crash on setting taskbar when using Visual Studio debugger.
+- On macOS, resize simple fullscreen windows on windowDidChangeScreen events.
+
+# 0.28.1
+
+- On Wayland, fix crash when dropping a window in multi-window setup.
+
+# 0.28.0
+
 - On macOS, fixed `Ime::Commit` persisting for all input after interacting with `Ime`.
 - On macOS, added `WindowExtMacOS::option_as_alt` and `WindowExtMacOS::set_option_as_alt`.
 - On Windows, fix window size for maximized, undecorated windows.
@@ -277,7 +396,7 @@ And please only add new entries to the top of this list, right below the `# Unre

 # 0.23.0 (2020-10-02)

- On iOS, fixed support for the "Debug View Heirarchy" feature in Xcode.
+- On iOS, fixed support for the "Debug View Hierarchy" feature in Xcode.
 - On all platforms, `available_monitors` and `primary_monitor` are now on `EventLoopWindowTarget` rather than `EventLoop` to list monitors event in the event loop.
 - On Unix, X11 and Wayland are now optional features (enabled by default)
 - On X11, fix deadlock when calling `set_fullscreen_inner`.
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -20,7 +20,7 @@ your description of the issue as detailed as possible:

 When making a code contribution to winit, before opening your pull request, please make sure that:

- your patch builds with Winit's minimal supported rust version - Rust 1.60.
+- your patch builds with Winit's minimal supported rust version - Rust 1.64.
 - you tested your modifications on all the platforms impacted, or if not possible detail which platforms
  were not tested, and what should be tested, so that a maintainer or another contributor can test them
 - you updated any relevant documentation in winit
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.27.5"
+version = "0.29.0-beta.0"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 edition = "2021"
@@ -10,7 +10,7 @@ readme = "README.md"
 repository = "https://github.com/rust-windowing/winit"
 documentation = "https://docs.rs/winit"
 categories = ["gui"]
-rust-version = "1.60.0"
+rust-version = "1.64.0"

 [package.metadata.docs.rs]
 features = ["serde"]
@@ -36,46 +36,55 @@ rustdoc-args = ["--cfg", "docsrs"]

 [features]
 default = ["x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
-x11 = ["x11-dl", "mio", "percent-encoding"]
-wayland = ["wayland-client", "wayland-protocols", "sctk", "wayland-commons"]
-wayland-dlopen = ["sctk/dlopen", "wayland-client/dlopen"]
+x11 = ["x11-dl", "percent-encoding", "xkbcommon-dl/x11"]
+wayland = ["wayland-client", "wayland-backend", "wayland-protocols", "sctk", "fnv", "memmap2"]
+wayland-dlopen = ["wayland-backend/dlopen"]
 wayland-csd-adwaita = ["sctk-adwaita", "sctk-adwaita/ab_glyph"]
 wayland-csd-adwaita-crossfont = ["sctk-adwaita", "sctk-adwaita/crossfont"]
 wayland-csd-adwaita-notitle = ["sctk-adwaita"]
-android-native-activity = [ "android-activity/native-activity" ]
-android-game-activity = [ "android-activity/game-activity" ]
+android-native-activity = ["android-activity/native-activity"]
+android-game-activity = ["android-activity/game-activity"]
+serde = ["dep:serde", "cursor-icon/serde", "smol_str/serde"]

 [build-dependencies]
 cfg_aliases = "0.1.1"

 [dependencies]
-bitflags = "1"
-instant = { version = "0.1", features = ["wasm-bindgen"] }
+bitflags = "2"
+cursor-icon = "1.0.0"
 log = "0.4"
 mint = { version = "0.5.6", optional = true }
 once_cell = "1.12"
 raw_window_handle = { package = "raw-window-handle", version = "0.5" }
 serde = { version = "1", optional = true, features = ["serde_derive"] }
+smol_str = "0.2.0"

 [dev-dependencies]
 image = { version = "0.24.0", default-features = false, features = ["png"] }
 simple_logger = { version = "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]
 # Coordinate the next winit release with android-ndk-rs: https://github.com/rust-windowing/winit/issues/1995
 android-activity = "0.4.0"
 ndk = "0.7.0"
+ndk-sys = "0.4.0"

 [target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
 core-foundation = "0.9.3"
-objc2 = "=0.3.0-beta.3"
+objc2 = ">=0.3.0-beta.3, <0.3.0-beta.4" # Allow `0.3.0-beta.3.patch-leaks`

 [target.'cfg(target_os = "macos")'.dependencies]
 core-graphics = "0.22.3"
 dispatch = "0.2.0"

+[target.'cfg(target_os = "windows")'.dependencies]
+unicode-segmentation = "1.7.1"
+
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
-version = "0.45"
+version = "0.48"
 features = [
    "Win32_Devices_HumanInterfaceDevice",
    "Win32_Foundation",
@@ -103,56 +112,62 @@ features = [
    "Win32_UI_WindowsAndMessaging",
 ]

-[target.'cfg(all(unix, not(any(target_os = "redox", target_arch = "wasm32", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies]
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies]
 libc = "0.2.64"
-mio = { version = "0.8", features = ["os-ext"], optional = true }
 percent-encoding = { version = "2.0", optional = true }
-sctk = { package = "smithay-client-toolkit", version = "0.16.0", default_features = false, features = ["calloop"],  optional = true }
-sctk-adwaita = { version = "0.5.1", default_features = false, optional = true }
-wayland-client = { version = "0.29.5", default_features = false,  features = ["use_system_lib"], optional = true }
-wayland-protocols = { version = "0.29.5", features = [ "staging_protocols"], optional = true }
-wayland-commons = { version = "0.29.5", optional = true }
+fnv = { version = "1.0.3", optional = true }
+sctk = { package = "smithay-client-toolkit", version = "0.17.0", default-features = false, features = ["calloop"], optional = true }
+sctk-adwaita = { version = "0.6.0", default_features = false, optional = true }
+wayland-client = { version = "0.30.0", optional = true }
+wayland-backend = { version = "0.1.0", default_features = false, features = ["client_system"], optional = true }
+wayland-protocols = { version = "0.30.0", features = [ "staging"], optional = true }
+calloop = "0.10.5"
 x11-dl = { version = "2.18.5", optional = true }
+xkbcommon-dl = "0.4.0"
+memmap2 = { version = "0.5.0", optional = true }

 [target.'cfg(target_os = "redox")'.dependencies]
 orbclient = { version = "0.3.42", default-features = false }
 redox_syscall = "0.3"

-[target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.build-dependencies]
-wayland-scanner = "0.29.5"
-
-[target.'cfg(target_arch = "wasm32")'.dependencies.web_sys]
+[target.'cfg(target_family = "wasm")'.dependencies.web_sys]
 package = "web-sys"
-version = "0.3.22"
+version = "0.3.64"
 features = [
    'console',
-    "AddEventListenerOptions",
    'CssStyleDeclaration',
-    'BeforeUnloadEvent',
    'Document',
    'DomRect',
+    'DomRectReadOnly',
    'Element',
    'Event',
-    "EventListenerOptions",
    'EventTarget',
    'FocusEvent',
    'HtmlCanvasElement',
    'HtmlElement',
    'KeyboardEvent',
    'MediaQueryList',
-    'MediaQueryListEvent',
-    'MouseEvent',
    'Node',
+    'PageTransitionEvent',
    'PointerEvent',
+    'ResizeObserver',
+    'ResizeObserverBoxOptions',
+    'ResizeObserverEntry',
+    'ResizeObserverOptions',
+    'ResizeObserverSize',
    'Window',
    'WheelEvent'
 ]

-[target.'cfg(target_arch = "wasm32")'.dependencies.wasm-bindgen]
-version = "0.2.45"
+[target.'cfg(target_family = "wasm")'.dependencies]
+atomic-waker = "1"
+js-sys = "0.3.64"
+wasm-bindgen = "0.2"
+wasm-bindgen-futures = "0.4"
+web-time = "0.2"

-[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
-console_log = "0.2"
+[target.'cfg(target_family = "wasm")'.dev-dependencies]
+console_log = "1"
 web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }

 [workspace]
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -179,7 +179,7 @@ Legend:
 |Providing pointer to init Vulkan |✔️     |✔️     |✔️         |✔️             |✔️     |❓     |**N/A**|**N/A** |
 |Window decorations               |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|✔️      |
 |Window decorations toggle        |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
-|Window resizing                  |✔️     |▢[#219]|✔️         |▢[#306]        |**N/A**|**N/A**|✔️        |✔️      |
+|Window resizing                  |✔️     |✔️     |✔️         |✔️        |**N/A**|**N/A**|✔️        |✔️      |
 |Window resize increments         |❌     |✔️     |✔️         |❌             |**N/A**|**N/A**|**N/A**|**N/A** |
 |Window transparency              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|N/A        |✔️      |
 |Window maximization              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
@@ -210,7 +210,7 @@ Legend:
 |Touch pressure          |✔️       |❌      |❌       |❌          |❌    |✔️     |✔️        |**N/A** |
 |Multitouch              |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |❌        |**N/A** |
 |Keyboard events         |✔️       |✔️      |✔️       |✔️          |✔️    |❌     |✔️        |✔️      |
-|Drag & Drop             |▢[#720]  |▢[#720] |▢[#720]  |❌[#306]    |**N/A**|**N/A**|❓        |**N/A** |
+|Drag & Drop             |▢[#720]  |▢[#720] |▢[#720]  |▢[#720]   |**N/A**|**N/A**|❓        |**N/A** |
 |Raw Device Events       |▢[#750]  |▢[#750] |▢[#750]  |❌          |❌    |❌     |❓        |**N/A** |
 |Gamepad/Joystick events |❌[#804] |❌      |❌       |❌          |❌    |❌     |❓        |**N/A** |
 |Device movement events  |❓        |❓       |❓       |❓           |❌    |❌     |❓        |**N/A** |
@@ -222,9 +222,9 @@ Changes in the API that have been agreed upon but aren't implemented across all

 |Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |WASM      |Redox OS|
 |------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- | ------ |
-|New API for HiDPI ([#315] [#319])   |✔️    |✔️    |✔️       |✔️          |✔️     |✔️    |❓        |❓      |
-|Event Loop 2.0 ([#459])             |✔️    |✔️    |❌       |✔️          |✔️     |✔️    |❓        |❓      |
-|Keyboard Input ([#812])             |❌    |❌    |❌       |❌          |❌     |❌    |❓        |❓      |
+|New API for HiDPI ([#315] [#319])   |✔️      |✔️     |✔️        |✔️            |✔️      |✔️      |❓        |❓      |
+|Event Loop 2.0 ([#459])             |✔️      |✔️     |✔️        |✔️            |✔️      |✔️      |❓        |✔️       |
+|Keyboard Input 2.0 ([#753])         |✔️      |✔️     |✔️        |✔️            |✔️      |❌     |✔️         |✔️       |

 ### Completed API Reworks
 |Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |WASM      |Redox OS|
@@ -243,5 +243,5 @@ Changes in the API that have been agreed upon but aren't implemented across all
 [#720]: https://github.com/rust-windowing/winit/issues/720
 [#721]: https://github.com/rust-windowing/winit/issues/721
 [#750]: https://github.com/rust-windowing/winit/issues/750
+[#753]: https://github.com/rust-windowing/winit/issues/753
 [#804]: https://github.com/rust-windowing/winit/issues/804
-[#812]: https://github.com/rust-windowing/winit/issues/812
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@

 ```toml
 [dependencies]
-winit = "0.27.5"
+winit = "0.29.0-beta.0"
 ```

 ## [Documentation](https://docs.rs/winit)
@@ -73,10 +73,6 @@ Winit provides the following features, which can be enabled in your `Cargo.toml`

 Note that windows don't appear on Wayland until you draw/present to them.

-`winit` doesn't do drawing, try the examples in [`glutin`] instead.
-
-[`glutin`]: https://github.com/rust-windowing/glutin
-
 #### WebAssembly

 To run the web example: `cargo run-wasm --example web`
--- a/build.rs
+++ b/build.rs
@@ -1,41 +1,14 @@
 use cfg_aliases::cfg_aliases;

-#[cfg(all(
-    any(
-        target_os = "linux",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "openbsd",
-        target_os = "netbsd",
-    ),
-    feature = "wayland",
-))]
-mod wayland {
-    use std::env;
-    use std::path::PathBuf;
-    use wayland_scanner::Side;
-
-    pub fn main() {
-        let mut path = PathBuf::from(env::var("OUT_DIR").unwrap());
-        path.push("fractional_scale_v1.rs");
-        wayland_scanner::generate_code(
-            "wayland_protocols/fractional-scale-v1.xml",
-            &path,
-            Side::Client,
-        );
-    }
-}
-
 fn main() {
    // The script doesn't depend on our code
    println!("cargo:rerun-if-changed=build.rs");
-    println!("cargo:rerun-if-changed=wayland_protocols");

    // Setup cfg aliases
    cfg_aliases! {
        // Systems.
        android_platform: { target_os = "android" },
-        wasm_platform: { target_arch = "wasm32" },
+        wasm_platform: { target_family = "wasm" },
        macos_platform: { target_os = "macos" },
        ios_platform: { target_os = "ios" },
        windows_platform: { target_os = "windows" },
@@ -48,17 +21,4 @@ fn main() {
        wayland_platform: { all(feature = "wayland", free_unix, not(wasm), not(redox)) },
        orbital_platform: { redox },
    }
-
-    // XXX aliases are not available for the build script itself.
-    #[cfg(all(
-        any(
-            target_os = "linux",
-            target_os = "dragonfly",
-            target_os = "freebsd",
-            target_os = "openbsd",
-            target_os = "netbsd",
-        ),
-        feature = "wayland",
-    ))]
-    wayland::main();
 }
--- a/clippy.toml
+++ b/clippy.toml
@@ -0,0 +1,7 @@
+disallowed-methods = [
+    { path = "web_sys::window", reason = "is not available in every context" },
+    { path = "web_sys::HtmlCanvasElement::width", reason = "Winit shouldn't touch the internal canvas size" },
+    { path = "web_sys::HtmlCanvasElement::height", reason = "Winit shouldn't touch the internal canvas size" },
+    { path = "web_sys::HtmlCanvasElement::set_width", reason = "Winit shouldn't touch the internal canvas size" },
+    { path = "web_sys::HtmlCanvasElement::set_height", reason = "Winit shouldn't touch the internal canvas size" },
+]
--- a/deny.toml
+++ b/deny.toml
@@ -0,0 +1,70 @@
+# https://embarkstudios.github.io/cargo-deny/
+# cargo install cargo-deny
+# cargo update && cargo deny --all-features --log-level error --target aarch64-apple-ios check
+# Note: running just `cargo deny check` without a `--target` will result in
+# false positives due to https://github.com/EmbarkStudios/cargo-deny/issues/324
+targets = [
+    { triple = "aarch64-apple-ios" },
+    { triple = "aarch64-linux-android" },
+    { triple = "i686-pc-windows-gnu" },
+    { triple = "i686-pc-windows-msvc" },
+    { triple = "i686-unknown-linux-gnu" },
+    { triple = "wasm32-unknown-unknown" },
+    { triple = "x86_64-apple-darwin" },
+    { triple = "x86_64-apple-ios" },
+    { triple = "x86_64-pc-windows-gnu" },
+    { triple = "x86_64-pc-windows-msvc" },
+    { triple = "x86_64-unknown-linux-gnu" },
+    { triple = "x86_64-unknown-redox" },
+]
+
+
+[advisories]
+vulnerability = "deny"
+unmaintained = "warn"
+yanked = "deny"
+ignore = []
+
+
+[bans]
+multiple-versions = "deny"
+wildcards = "allow" # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
+deny = []
+skip = [
+    { name = "bitflags" },      # the ecosystem is in the process of migrating.
+    { name = "nix" },           # differing version - as of 2023-03-02 whis can be solved with `cargo update && cargo update -p calloop --precise 0.10.2`
+    { name = "memoffset"},      # due to different nix versions.
+    { name = "memmap2" },       # sctk uses a different version until the next update
+    { name = "libloading" },    # x11rb uses a different version until the next update
+    { name = "syn" },           # https://github.com/rust-mobile/ndk/issues/392 and https://github.com/rustwasm/wasm-bindgen/issues/3390
+    { 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
+]
+skip-tree = []
+
+
+[licenses]
+private = { ignore = true }
+unlicensed = "deny"
+allow-osi-fsf-free = "neither"
+confidence-threshold = 0.92 # We want really high confidence when inferring licenses from text
+copyleft = "deny"
+allow = [
+    "Apache-2.0 WITH LLVM-exception", # https://spdx.org/licenses/LLVM-exception.html
+    "Apache-2.0",                     # https://tldrlegal.com/license/apache-license-2.0-(apache-2.0)
+    "BSD-2-Clause",                   # https://tldrlegal.com/license/bsd-2-clause-license-(freebsd)
+    "BSD-3-Clause",                   # https://tldrlegal.com/license/bsd-3-clause-license-(revised)
+    "BSL-1.0",                        # https://tldrlegal.com/license/boost-software-license-1.0-explained
+    "CC0-1.0",                        # https://creativecommons.org/publicdomain/zero/1.0/
+    "ISC",                            # https://tldrlegal.com/license/-isc-license
+    "LicenseRef-UFL-1.0",             # https://tldrlegal.com/license/ubuntu-font-license,-1.0 - no official SPDX, see https://github.com/emilk/egui/issues/2321
+    "MIT-0",                          # https://choosealicense.com/licenses/mit-0/
+    "MIT",                            # https://tldrlegal.com/license/mit-license
+    "MPL-2.0",                        # https://www.mozilla.org/en-US/MPL/2.0/FAQ/ - see Q11. Used by webpki-roots on Linux.
+    "OFL-1.1",                        # https://spdx.org/licenses/OFL-1.1.html
+    "OpenSSL",                        # https://www.openssl.org/source/license.html - used on Linux
+    "Unicode-DFS-2016",               # https://spdx.org/licenses/Unicode-DFS-2016.html
+    "Zlib",                           # https://tldrlegal.com/license/zlib-libpng-license-(zlib)
+]
--- a/docs/res/ATTRIBUTION.md
+++ b/docs/res/ATTRIBUTION.md
@@ -0,0 +1,11 @@
+# Image Attribution
+
+These images are used in the documentation of `winit`.
+
+## keyboard_*.svg
+
+These files are a modified version of "[ANSI US QWERTY (Windows)](https://commons.wikimedia.org/wiki/File:ANSI_US_QWERTY_(Windows).svg)"
+by [Tomiĉo] (https://commons.wikimedia.org/wiki/User:Tomi%C4%89o). It is
+originally released under the [CC-BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/deed.en)
+License. Minor modifications have been made by [John Nunley](https://github.com/notgull),
+which have been released under the same license as a derivative work.
--- a/docs/res/keyboard_left_shift_key.svg
+++ b/docs/res/keyboard_left_shift_key.svg
--- a/docs/res/keyboard_numpad_1_key.svg
+++ b/docs/res/keyboard_numpad_1_key.svg
--- a/docs/res/keyboard_right_shift_key.svg
+++ b/docs/res/keyboard_right_shift_key.svg
--- a/docs/res/keyboard_standard_1_key.svg
+++ b/docs/res/keyboard_standard_1_key.svg
--- a/examples/child_window.rs
+++ b/examples/child_window.rs
@@ -1,3 +1,7 @@
+#[cfg(any(x11_platform, macos_platform, windows_platform))]
+#[path = "util/fill.rs"]
+mod fill;
+
 #[cfg(any(x11_platform, macos_platform, windows_platform))]
 fn main() {
    use std::collections::HashMap;
@@ -5,7 +9,7 @@ fn main() {
    use raw_window_handle::HasRawWindowHandle;
    use winit::{
        dpi::{LogicalPosition, LogicalSize, Position},
-        event::{ElementState, Event, KeyboardInput, WindowEvent},
+        event::{ElementState, Event, KeyEvent, WindowEvent},
        event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
        window::{Window, WindowBuilder, WindowId},
    };
@@ -59,8 +63,8 @@ fn main() {
                    println!("cursor entered in the window {window_id:?}");
                }
                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
+                    event:
+                        KeyEvent {
                            state: ElementState::Pressed,
                            ..
                        },
@@ -70,6 +74,10 @@ fn main() {
                }
                _ => (),
            }
+        } else if let Event::RedrawRequested(wid) = event {
+            if let Some(window) = windows.get(&wid) {
+                fill::fill_window(window);
+            }
        }
    })
 }
--- a/examples/control_flow.rs
+++ b/examples/control_flow.rs
@@ -1,14 +1,22 @@
 #![allow(clippy::single_match)]

-use std::{thread, time};
+use std::thread;
+#[cfg(not(wasm_platform))]
+use std::time;
+#[cfg(wasm_platform)]
+use web_time as time;

 use simple_logger::SimpleLogger;
 use winit::{
-    event::{Event, KeyboardInput, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
    event_loop::EventLoop,
+    keyboard::Key,
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Mode {
    Wait,
@@ -40,7 +48,7 @@ fn main() {
    let mut close_requested = false;

    event_loop.run(move |event, _, control_flow| {
-        use winit::event::{ElementState, StartCause, VirtualKeyCode};
+        use winit::event::StartCause;
        println!("{event:?}");
        match event {
            Event::NewEvents(start_cause) => {
@@ -54,31 +62,33 @@ fn main() {
                    close_requested = true;
                }
                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            virtual_keycode: Some(virtual_code),
+                    event:
+                        KeyEvent {
+                            logical_key: key,
                            state: ElementState::Pressed,
                            ..
                        },
                    ..
-                } => match virtual_code {
-                    VirtualKeyCode::Key1 => {
+                } => match key.as_ref() {
+                    // WARNING: Consider using `key_without_modifers()` if available on your platform.
+                    // See the `key_binding` example
+                    Key::Character("1") => {
                        mode = Mode::Wait;
                        println!("\nmode: {mode:?}\n");
                    }
-                    VirtualKeyCode::Key2 => {
+                    Key::Character("2") => {
                        mode = Mode::WaitUntil;
                        println!("\nmode: {mode:?}\n");
                    }
-                    VirtualKeyCode::Key3 => {
+                    Key::Character("3") => {
                        mode = Mode::Poll;
                        println!("\nmode: {mode:?}\n");
                    }
-                    VirtualKeyCode::R => {
+                    Key::Character("r") => {
                        request_redraw = !request_redraw;
                        println!("\nrequest_redraw: {request_redraw}\n");
                    }
-                    VirtualKeyCode::Escape => {
+                    Key::Escape => {
                        close_requested = true;
                    }
                    _ => (),
@@ -93,13 +103,15 @@ fn main() {
                    control_flow.set_exit();
                }
            }
-            Event::RedrawRequested(_window_id) => {}
+            Event::RedrawRequested(_window_id) => {
+                fill::fill_window(&window);
+            }
            Event::RedrawEventsCleared => {
                match mode {
                    Mode::Wait => control_flow.set_wait(),
                    Mode::WaitUntil => {
                        if !wait_cancelled {
-                            control_flow.set_wait_until(instant::Instant::now() + WAIT_TIME);
+                            control_flow.set_wait_until(time::Instant::now() + WAIT_TIME);
                        }
                    }
                    Mode::Poll => {
--- a/examples/cursor.rs
+++ b/examples/cursor.rs
@@ -2,11 +2,14 @@

 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyboardInput, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
    event_loop::EventLoop,
    window::{CursorIcon, WindowBuilder},
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -23,8 +26,8 @@ fn main() {
            Event::WindowEvent {
                event:
                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
+                        event:
+                            KeyEvent {
                                state: ElementState::Pressed,
                                ..
                            },
@@ -46,6 +49,9 @@ fn main() {
            } => {
                control_flow.set_exit();
            }
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
@@ -54,8 +60,7 @@ fn main() {
 const CURSORS: &[CursorIcon] = &[
    CursorIcon::Default,
    CursorIcon::Crosshair,
-    CursorIcon::Hand,
-    CursorIcon::Arrow,
+    CursorIcon::Pointer,
    CursorIcon::Move,
    CursorIcon::Text,
    CursorIcon::Wait,
--- a/examples/cursor_grab.rs
+++ b/examples/cursor_grab.rs
@@ -2,11 +2,15 @@

 use simple_logger::SimpleLogger;
 use winit::{
-    event::{DeviceEvent, ElementState, Event, KeyboardInput, ModifiersState, WindowEvent},
+    event::{DeviceEvent, ElementState, Event, KeyEvent, WindowEvent},
    event_loop::EventLoop,
+    keyboard::{Key, ModifiersState},
    window::{CursorGrabMode, WindowBuilder},
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -25,27 +29,29 @@ fn main() {
            Event::WindowEvent { event, .. } => match event {
                WindowEvent::CloseRequested => control_flow.set_exit(),
                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
+                    event:
+                        KeyEvent {
+                            logical_key: key,
                            state: ElementState::Released,
-                            virtual_keycode: Some(key),
                            ..
                        },
                    ..
                } => {
-                    use winit::event::VirtualKeyCode::*;
                    let result = match key {
-                        Escape => {
+                        Key::Escape => {
                            control_flow.set_exit();
                            Ok(())
                        }
-                        G => window.set_cursor_grab(CursorGrabMode::Confined),
-                        L => window.set_cursor_grab(CursorGrabMode::Locked),
-                        A => window.set_cursor_grab(CursorGrabMode::None),
-                        H => {
-                            window.set_cursor_visible(modifiers.shift());
-                            Ok(())
-                        }
+                        Key::Character(ch) => match ch.to_lowercase().as_str() {
+                            "g" => window.set_cursor_grab(CursorGrabMode::Confined),
+                            "l" => window.set_cursor_grab(CursorGrabMode::Locked),
+                            "a" => window.set_cursor_grab(CursorGrabMode::None),
+                            "h" => {
+                                window.set_cursor_visible(modifiers.shift_key());
+                                Ok(())
+                            }
+                            _ => Ok(()),
+                        },
                        _ => Ok(()),
                    };

@@ -53,7 +59,7 @@ fn main() {
                        println!("error: {err}");
                    }
                }
-                WindowEvent::ModifiersChanged(m) => modifiers = m,
+                WindowEvent::ModifiersChanged(new) => modifiers = new.state(),
                _ => (),
            },
            Event::DeviceEvent { event, .. } => match event {
@@ -64,6 +70,7 @@ fn main() {
                },
                _ => (),
            },
+            Event::RedrawRequested(_) => fill::fill_window(&window),
            _ => (),
        }
    });
--- a/examples/custom_events.rs
+++ b/examples/custom_events.rs
@@ -9,6 +9,9 @@ fn main() {
        window::WindowBuilder,
    };

+    #[path = "util/fill.rs"]
+    mod fill;
+
    #[derive(Debug, Clone, Copy)]
    enum CustomEvent {
        Timer,
@@ -17,7 +20,7 @@ fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoopBuilder::<CustomEvent>::with_user_event().build();

-    let _window = WindowBuilder::new()
+    let window = WindowBuilder::new()
        .with_title("A fantastic window!")
        .build(&event_loop)
        .unwrap();
@@ -44,6 +47,9 @@ fn main() {
                event: WindowEvent::CloseRequested,
                ..
            } => control_flow.set_exit(),
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/drag_window.rs
+++ b/examples/drag_window.rs
@@ -2,13 +2,15 @@

 use simple_logger::SimpleLogger;
 use winit::{
-    event::{
-        ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
-    },
+    event::{ElementState, Event, KeyEvent, MouseButton, StartCause, WindowEvent},
    event_loop::EventLoop,
+    keyboard::Key,
    window::{Window, WindowBuilder, WindowId},
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -45,20 +47,27 @@ fn main() {
                name_windows(entered_id, switched, &window_1, &window_2)
            }
            WindowEvent::KeyboardInput {
-                input:
-                    KeyboardInput {
+                event:
+                    KeyEvent {
                        state: ElementState::Released,
-                        virtual_keycode: Some(VirtualKeyCode::X),
+                        logical_key: Key::Character(c),
                        ..
                    },
                ..
-            } => {
+            } if c == "x" => {
                switched = !switched;
                name_windows(entered_id, switched, &window_1, &window_2);
                println!("Switched!")
            }
            _ => (),
        },
+        Event::RedrawRequested(wid) => {
+            if wid == window_1.id() {
+                fill::fill_window(&window_1);
+            } else if wid == window_2.id() {
+                fill::fill_window(&window_2);
+            }
+        }
        _ => (),
    });
 }
--- a/examples/fullscreen.rs
+++ b/examples/fullscreen.rs
@@ -1,10 +1,17 @@
 #![allow(clippy::single_match)]

 use simple_logger::SimpleLogger;
-use winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent};
+use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
 use winit::event_loop::EventLoop;
+use winit::keyboard::Key;
 use winit::window::{Fullscreen, WindowBuilder};

+#[cfg(target_os = "macos")]
+use winit::platform::macos::WindowExtMacOS;
+
+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -32,6 +39,8 @@ fn main() {
    println!("- Esc\tExit");
    println!("- F\tToggle exclusive fullscreen mode");
    println!("- B\tToggle borderless mode");
+    #[cfg(target_os = "macos")]
+    println!("- C\tToggle simple fullscreen mode");
    println!("- S\tNext screen");
    println!("- M\tNext mode for this screen");
    println!("- D\tToggle window decorations");
@@ -45,68 +54,81 @@ fn main() {
            Event::WindowEvent { event, .. } => match event {
                WindowEvent::CloseRequested => control_flow.set_exit(),
                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            virtual_keycode: Some(virtual_code),
+                    event:
+                        KeyEvent {
+                            logical_key: key,
                            state: ElementState::Pressed,
                            ..
                        },
                    ..
-                } => match virtual_code {
-                    VirtualKeyCode::Escape => control_flow.set_exit(),
-                    VirtualKeyCode::F | VirtualKeyCode::B if window.fullscreen().is_some() => {
-                        window.set_fullscreen(None);
-                    }
-                    VirtualKeyCode::F => {
-                        let fullscreen = Some(Fullscreen::Exclusive(mode.clone()));
-                        println!("Setting mode: {fullscreen:?}");
-                        window.set_fullscreen(fullscreen);
-                    }
-                    VirtualKeyCode::B => {
-                        let fullscreen = Some(Fullscreen::Borderless(Some(monitor.clone())));
-                        println!("Setting mode: {fullscreen:?}");
-                        window.set_fullscreen(fullscreen);
-                    }
-                    VirtualKeyCode::S => {
-                        monitor_index += 1;
-                        if let Some(mon) = elwt.available_monitors().nth(monitor_index) {
-                            monitor = mon;
-                        } else {
-                            monitor_index = 0;
-                            monitor = elwt.available_monitors().next().expect("no monitor found!");
+                } => match key {
+                    Key::Escape => control_flow.set_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() {
+                        "f" | "b" if window.fullscreen().is_some() => {
+                            window.set_fullscreen(None);
                        }
-                        println!("Monitor: {:?}", monitor.name());
+                        "f" => {
+                            let fullscreen = Some(Fullscreen::Exclusive(mode.clone()));
+                            println!("Setting mode: {fullscreen:?}");
+                            window.set_fullscreen(fullscreen);
+                        }
+                        "b" => {
+                            let fullscreen = Some(Fullscreen::Borderless(Some(monitor.clone())));
+                            println!("Setting mode: {fullscreen:?}");
+                            window.set_fullscreen(fullscreen);
+                        }
+                        #[cfg(target_os = "macos")]
+                        "c" => {
+                            window.set_simple_fullscreen(!window.simple_fullscreen());
+                        }
+                        "s" => {
+                            monitor_index += 1;
+                            if let Some(mon) = elwt.available_monitors().nth(monitor_index) {
+                                monitor = mon;
+                            } else {
+                                monitor_index = 0;
+                                monitor =
+                                    elwt.available_monitors().next().expect("no monitor found!");
+                            }
+                            println!("Monitor: {:?}", monitor.name());

-                        mode_index = 0;
-                        mode = monitor.video_modes().next().expect("no mode found");
-                        println!("Mode: {mode}");
-                    }
-                    VirtualKeyCode::M => {
-                        mode_index += 1;
-                        if let Some(m) = monitor.video_modes().nth(mode_index) {
-                            mode = m;
-                        } else {
                            mode_index = 0;
                            mode = monitor.video_modes().next().expect("no mode found");
+                            println!("Mode: {mode}");
                        }
-                        println!("Mode: {mode}");
-                    }
-                    VirtualKeyCode::D => {
-                        decorations = !decorations;
-                        window.set_decorations(decorations);
-                    }
-                    VirtualKeyCode::X => {
-                        let is_maximized = window.is_maximized();
-                        window.set_maximized(!is_maximized);
-                    }
-                    VirtualKeyCode::Z => {
-                        minimized = !minimized;
-                        window.set_minimized(minimized);
-                    }
+                        "m" => {
+                            mode_index += 1;
+                            if let Some(m) = monitor.video_modes().nth(mode_index) {
+                                mode = m;
+                            } else {
+                                mode_index = 0;
+                                mode = monitor.video_modes().next().expect("no mode found");
+                            }
+                            println!("Mode: {mode}");
+                        }
+                        "d" => {
+                            decorations = !decorations;
+                            window.set_decorations(decorations);
+                        }
+                        "x" => {
+                            let is_maximized = window.is_maximized();
+                            window.set_maximized(!is_maximized);
+                        }
+                        "z" => {
+                            minimized = !minimized;
+                            window.set_minimized(minimized);
+                        }
+                        _ => (),
+                    },
                    _ => (),
                },
                _ => (),
            },
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => {}
        }
    });
--- a/examples/handling_close.rs
+++ b/examples/handling_close.rs
@@ -2,16 +2,20 @@

 use simple_logger::SimpleLogger;
 use winit::{
-    event::{Event, KeyboardInput, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
    event_loop::EventLoop,
+    keyboard::Key,
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();

-    let _window = WindowBuilder::new()
+    let window = WindowBuilder::new()
        .with_title("Your faithful window")
        .build(&event_loop)
        .unwrap();
@@ -19,10 +23,6 @@ fn main() {
    let mut close_requested = false;

    event_loop.run(move |event, _, control_flow| {
-        use winit::event::{
-            ElementState::Released,
-            VirtualKeyCode::{N, Y},
-        };
        control_flow.set_wait();

        match event {
@@ -46,16 +46,18 @@ fn main() {
                        // the Y key.
                    }
                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                virtual_keycode: Some(virtual_code),
-                                state: Released,
+                        event:
+                            KeyEvent {
+                                logical_key: key,
+                                state: ElementState::Released,
                                ..
                            },
                        ..
                    } => {
-                        match virtual_code {
-                            Y => {
+                        // WARNING: Consider using `key_without_modifers()` if available on your platform.
+                        // See the `key_binding` example
+                        match key.as_ref() {
+                            Key::Character("y") => {
                                if close_requested {
                                    // This is where you'll want to do any cleanup you need.
                                    println!("Buh-bye!");
@@ -68,7 +70,7 @@ fn main() {
                                    control_flow.set_exit();
                                }
                            }
-                            N => {
+                            Key::Character("n") => {
                                if close_requested {
                                    println!("Your window will continue to stay by your side.");
                                    close_requested = false;
@@ -80,6 +82,9 @@ fn main() {
                    _ => (),
                }
            }
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/ime.rs
+++ b/examples/ime.rs
@@ -3,12 +3,16 @@
 use log::LevelFilter;
 use simple_logger::SimpleLogger;
 use winit::{
-    dpi::PhysicalPosition,
-    event::{ElementState, Event, Ime, VirtualKeyCode, WindowEvent},
+    dpi::{PhysicalPosition, PhysicalSize},
+    event::{ElementState, Event, Ime, WindowEvent},
    event_loop::{ControlFlow, EventLoop},
+    keyboard::{Key, KeyCode},
    window::{ImePurpose, WindowBuilder},
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new()
        .with_level(LevelFilter::Trace)
@@ -62,7 +66,7 @@ fn main() {
                );
                ime_pos = cursor_position;
                if may_show_ime {
-                    window.set_ime_position(ime_pos);
+                    window.set_ime_cursor_area(ime_pos, PhysicalSize::new(10, 10));
                }
            }
            Event::WindowEvent {
@@ -72,31 +76,21 @@ fn main() {
                println!("{event:?}");
                may_show_ime = event != Ime::Disabled;
                if may_show_ime {
-                    window.set_ime_position(ime_pos);
+                    window.set_ime_cursor_area(ime_pos, PhysicalSize::new(10, 10));
                }
            }
            Event::WindowEvent {
-                event: WindowEvent::ReceivedCharacter(ch),
+                event: WindowEvent::KeyboardInput { event, .. },
                ..
            } => {
-                println!("ch: {ch:?}");
-            }
-            Event::WindowEvent {
-                event: WindowEvent::KeyboardInput { input, .. },
-                ..
-            } => {
-                println!("key: {input:?}");
+                println!("key: {event:?}");

-                if input.state == ElementState::Pressed
-                    && input.virtual_keycode == Some(VirtualKeyCode::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 input.state == ElementState::Pressed
-                    && input.virtual_keycode == Some(VirtualKeyCode::F3)
-                {
+                if event.state == ElementState::Pressed && event.logical_key == Key::F3 {
                    ime_purpose = match ime_purpose {
                        ImePurpose::Normal => ImePurpose::Password,
                        ImePurpose::Password => ImePurpose::Terminal,
@@ -106,6 +100,9 @@ fn main() {
                    println!("\nIME purpose: {ime_purpose:?}\n");
                }
            }
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/key_binding.rs
+++ b/examples/key_binding.rs
@@ -0,0 +1,65 @@
+#![allow(clippy::single_match)]
+
+#[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
+use winit::{
+    dpi::LogicalSize,
+    event::{ElementState, Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    keyboard::{Key, ModifiersState},
+    // WARNING: This is not available on all platforms (for example on the web).
+    platform::modifier_supplement::KeyEventExtModifierSupplement,
+    window::WindowBuilder,
+};
+
+#[cfg(not(any(target_os = "macos", target_os = "windows", target_os = "linux")))]
+fn main() {
+    println!("This example is not supported on this platform");
+}
+
+#[cfg(any(target_os = "macos", target_os = "windows", target_os = "linux"))]
+fn main() {
+    #[path = "util/fill.rs"]
+    mod fill;
+
+    simple_logger::SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_inner_size(LogicalSize::new(400.0, 200.0))
+        .build(&event_loop)
+        .unwrap();
+
+    let mut modifiers = ModifiersState::default();
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            Event::WindowEvent { event, .. } => match event {
+                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::ModifiersChanged(new) => {
+                    modifiers = new.state();
+                }
+                WindowEvent::KeyboardInput { event, .. } => {
+                    if event.state == ElementState::Pressed && !event.repeat {
+                        match event.key_without_modifiers().as_ref() {
+                            Key::Character("1") => {
+                                if modifiers.shift_key() {
+                                    println!("Shift + 1 | logical_key: {:?}", event.logical_key);
+                                } else {
+                                    println!("1");
+                                }
+                            }
+                            _ => (),
+                        }
+                    }
+                }
+                _ => (),
+            },
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
+            _ => (),
+        };
+    });
+}
--- a/examples/mouse_wheel.rs
+++ b/examples/mouse_wheel.rs
@@ -7,6 +7,9 @@ use winit::{
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -56,6 +59,9 @@ In other words, the deltas indicate the direction in which to move the content (
                },
                _ => (),
            },
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/multithreaded.rs
+++ b/examples/multithreaded.rs
@@ -7,8 +7,9 @@ fn main() {
    use simple_logger::SimpleLogger;
    use winit::{
        dpi::{PhysicalPosition, PhysicalSize, Position, Size},
-        event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+        event::{ElementState, Event, KeyEvent, WindowEvent},
        event_loop::EventLoop,
+        keyboard::{Key, ModifiersState},
        window::{CursorGrabMode, CursorIcon, Fullscreen, WindowBuilder, WindowLevel},
    };

@@ -29,6 +30,7 @@ fn main() {

        let (tx, rx) = mpsc::channel();
        window_senders.insert(window.id(), tx);
+        let mut modifiers = ModifiersState::default();
        thread::spawn(move || {
            while let Ok(event) = rx.recv() {
                match event {
@@ -51,107 +53,116 @@ fn main() {
                            );
                        }
                    }
-                    #[allow(deprecated)]
+                    WindowEvent::ModifiersChanged(new) => {
+                        modifiers = new.state();
+                    }
                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
+                        event:
+                            KeyEvent {
                                state: ElementState::Released,
-                                virtual_keycode: Some(key),
-                                modifiers,
+                                logical_key: key,
                                ..
                            },
                        ..
                    } => {
+                        use Key::{ArrowLeft, ArrowRight};
                        window.set_title(&format!("{key:?}"));
-                        let state = !modifiers.shift();
-                        use VirtualKeyCode::*;
+                        let state = !modifiers.shift_key();
                        match key {
-                            Key1 => window.set_window_level(WindowLevel::AlwaysOnTop),
-                            Key2 => window.set_window_level(WindowLevel::AlwaysOnBottom),
-                            Key3 => window.set_window_level(WindowLevel::Normal),
-                            C => window.set_cursor_icon(match state {
-                                true => CursorIcon::Progress,
-                                false => CursorIcon::Default,
-                            }),
-                            D => window.set_decorations(!state),
                            // Cycle through video modes
-                            Right | Left => {
+                            Key::ArrowRight | Key::ArrowLeft => {
                                video_mode_id = match key {
-                                    Left => video_mode_id.saturating_sub(1),
-                                    Right => (video_modes.len() - 1).min(video_mode_id + 1),
+                                    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]);
                            }
-                            F => window.set_fullscreen(match (state, modifiers.alt()) {
-                                (true, false) => Some(Fullscreen::Borderless(None)),
-                                (true, true) => {
-                                    Some(Fullscreen::Exclusive(video_modes[video_mode_id].clone()))
+                            // 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() {
+                                "1" => window.set_window_level(WindowLevel::AlwaysOnTop),
+                                "2" => window.set_window_level(WindowLevel::AlwaysOnBottom),
+                                "3" => window.set_window_level(WindowLevel::Normal),
+                                "c" => window.set_cursor_icon(match state {
+                                    true => CursorIcon::Progress,
+                                    false => CursorIcon::Default,
+                                }),
+                                "d" => window.set_decorations(!state),
+                                "f" => window.set_fullscreen(match (state, modifiers.alt_key()) {
+                                    (true, false) => Some(Fullscreen::Borderless(None)),
+                                    (true, true) => Some(Fullscreen::Exclusive(
+                                        video_modes[video_mode_id].clone(),
+                                    )),
+                                    (false, _) => None,
+                                }),
+                                "l" if state => {
+                                    if let Err(err) = window.set_cursor_grab(CursorGrabMode::Locked)
+                                    {
+                                        println!("error: {err}");
+                                    }
                                }
-                                (false, _) => None,
-                            }),
-                            L if state => {
-                                if let Err(err) = window.set_cursor_grab(CursorGrabMode::Locked) {
-                                    println!("error: {err}");
+                                "g" if state => {
+                                    if let Err(err) =
+                                        window.set_cursor_grab(CursorGrabMode::Confined)
+                                    {
+                                        println!("error: {err}");
+                                    }
                                }
-                            }
-                            G if state => {
-                                if let Err(err) = window.set_cursor_grab(CursorGrabMode::Confined) {
-                                    println!("error: {err}");
+                                "g" | "l" if !state => {
+                                    if let Err(err) = window.set_cursor_grab(CursorGrabMode::None) {
+                                        println!("error: {err}");
+                                    }
                                }
-                            }
-                            G | L if !state => {
-                                if let Err(err) = window.set_cursor_grab(CursorGrabMode::None) {
-                                    println!("error: {err}");
+                                "h" => window.set_cursor_visible(!state),
+                                "i" => {
+                                    println!("Info:");
+                                    println!("-> outer_position : {:?}", window.outer_position());
+                                    println!("-> inner_position : {:?}", window.inner_position());
+                                    println!("-> outer_size     : {:?}", window.outer_size());
+                                    println!("-> inner_size     : {:?}", window.inner_size());
+                                    println!("-> fullscreen     : {:?}", window.fullscreen());
                                }
-                            }
-                            H => window.set_cursor_visible(!state),
-                            I => {
-                                println!("Info:");
-                                println!("-> outer_position : {:?}", window.outer_position());
-                                println!("-> inner_position : {:?}", window.inner_position());
-                                println!("-> outer_size     : {:?}", window.outer_size());
-                                println!("-> inner_size     : {:?}", window.inner_size());
-                                println!("-> fullscreen     : {:?}", window.fullscreen());
-                            }
-                            L => window.set_min_inner_size(match state {
-                                true => Some(WINDOW_SIZE),
-                                false => None,
-                            }),
-                            M => window.set_maximized(state),
-                            P => window.set_outer_position({
-                                let mut position = window.outer_position().unwrap();
-                                let sign = if state { 1 } else { -1 };
-                                position.x += 10 * sign;
-                                position.y += 10 * sign;
-                                position
-                            }),
-                            Q => window.request_redraw(),
-                            R => window.set_resizable(state),
-                            S => window.set_inner_size(match state {
-                                true => PhysicalSize::new(
-                                    WINDOW_SIZE.width + 100,
-                                    WINDOW_SIZE.height + 100,
-                                ),
-                                false => WINDOW_SIZE,
-                            }),
-                            W => {
-                                if let Size::Physical(size) = WINDOW_SIZE.into() {
-                                    window
-                                        .set_cursor_position(Position::Physical(
-                                            PhysicalPosition::new(
-                                                size.width as i32 / 2,
-                                                size.height as i32 / 2,
-                                            ),
-                                        ))
-                                        .unwrap()
+                                "l" => window.set_min_inner_size(match state {
+                                    true => Some(WINDOW_SIZE),
+                                    false => None,
+                                }),
+                                "m" => window.set_maximized(state),
+                                "p" => window.set_outer_position({
+                                    let mut position = window.outer_position().unwrap();
+                                    let sign = if state { 1 } else { -1 };
+                                    position.x += 10 * sign;
+                                    position.y += 10 * sign;
+                                    position
+                                }),
+                                "q" => window.request_redraw(),
+                                "r" => window.set_resizable(state),
+                                "s" => window.set_inner_size(match state {
+                                    true => PhysicalSize::new(
+                                        WINDOW_SIZE.width + 100,
+                                        WINDOW_SIZE.height + 100,
+                                    ),
+                                    false => WINDOW_SIZE,
+                                }),
+                                "w" => {
+                                    if let Size::Physical(size) = WINDOW_SIZE.into() {
+                                        window
+                                            .set_cursor_position(Position::Physical(
+                                                PhysicalPosition::new(
+                                                    size.width as i32 / 2,
+                                                    size.height as i32 / 2,
+                                                ),
+                                            ))
+                                            .unwrap()
+                                    }
                                }
-                            }
-                            Z => {
-                                window.set_visible(false);
-                                thread::sleep(Duration::from_secs(1));
-                                window.set_visible(true);
-                            }
+                                "z" => {
+                                    window.set_visible(false);
+                                    thread::sleep(Duration::from_secs(1));
+                                    window.set_visible(true);
+                                }
+                                _ => (),
+                            },
                            _ => (),
                        }
                    }
@@ -170,10 +181,10 @@ fn main() {
                WindowEvent::CloseRequested
                | WindowEvent::Destroyed
                | WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
+                    event:
+                        KeyEvent {
                            state: ElementState::Released,
-                            virtual_keycode: Some(VirtualKeyCode::Escape),
+                            logical_key: Key::Escape,
                            ..
                        },
                    ..
--- a/examples/multiwindow.rs
+++ b/examples/multiwindow.rs
@@ -4,11 +4,15 @@ use std::collections::HashMap;

 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
    event_loop::EventLoop,
+    keyboard::Key,
    window::Window,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -39,15 +43,15 @@ fn main() {
                        }
                    }
                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
+                        event:
+                            KeyEvent {
                                state: ElementState::Pressed,
-                                virtual_keycode: Some(VirtualKeyCode::N),
+                                logical_key: Key::Character(c),
                                ..
                            },
                        is_synthetic: false,
                        ..
-                    } => {
+                    } if matches!(c.as_ref(), "n" | "N") => {
                        let window = Window::new(event_loop).unwrap();
                        println!("Opened a new window: {:?}", window.id());
                        windows.insert(window.id(), window);
@@ -55,6 +59,11 @@ fn main() {
                    _ => (),
                }
            }
+            Event::RedrawRequested(window_id) => {
+                if let Some(window) = windows.get(&window_id) {
+                    fill::fill_window(window);
+                }
+            }
            _ => (),
        }
    })
--- a/examples/request_redraw.rs
+++ b/examples/request_redraw.rs
@@ -7,6 +7,9 @@ use winit::{
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -34,6 +37,7 @@ fn main() {
            },
            Event::RedrawRequested(_) => {
                println!("\nredrawing!\n");
+                fill::fill_window(&window);
            }
            _ => (),
        }
--- a/examples/request_redraw_threaded.rs
+++ b/examples/request_redraw_threaded.rs
@@ -2,7 +2,7 @@

 #[cfg(not(wasm_platform))]
 fn main() {
-    use std::{thread, time};
+    use std::{sync::Arc, thread, time};

    use simple_logger::SimpleLogger;
    use winit::{
@@ -11,17 +11,26 @@ fn main() {
        window::WindowBuilder,
    };

+    #[path = "util/fill.rs"]
+    mod fill;
+
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();

-    let window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .build(&event_loop)
-        .unwrap();
+    let window = {
+        let window = WindowBuilder::new()
+            .with_title("A fantastic window!")
+            .build(&event_loop)
+            .unwrap();
+        Arc::new(window)
+    };

-    thread::spawn(move || loop {
-        thread::sleep(time::Duration::from_secs(1));
-        window.request_redraw();
+    thread::spawn({
+        let window = window.clone();
+        move || loop {
+            thread::sleep(time::Duration::from_secs(1));
+            window.request_redraw();
+        }
    });

    event_loop.run(move |event, _, control_flow| {
@@ -36,6 +45,7 @@ fn main() {
            } => control_flow.set_exit(),
            Event::RedrawRequested(_) => {
                println!("\nredrawing!\n");
+                fill::fill_window(&window);
            }
            _ => (),
        }
--- a/examples/resizable.rs
+++ b/examples/resizable.rs
@@ -3,11 +3,15 @@
 use simple_logger::SimpleLogger;
 use winit::{
    dpi::LogicalSize,
-    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
    event_loop::EventLoop,
+    keyboard::KeyCode,
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -30,9 +34,9 @@ fn main() {
            Event::WindowEvent { event, .. } => match event {
                WindowEvent::CloseRequested => control_flow.set_exit(),
                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            virtual_keycode: Some(VirtualKeyCode::Space),
+                    event:
+                        KeyEvent {
+                            physical_key: KeyCode::Space,
                            state: ElementState::Released,
                            ..
                        },
@@ -44,6 +48,9 @@ fn main() {
                }
                _ => (),
            },
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        };
    });
--- a/examples/theme.rs
+++ b/examples/theme.rs
@@ -2,11 +2,15 @@

 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
    event_loop::{ControlFlow, EventLoop},
+    keyboard::Key,
    window::{Theme, WindowBuilder},
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -41,30 +45,34 @@ fn main() {
            Event::WindowEvent {
                event:
                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                virtual_keycode: Some(key),
+                        event:
+                            KeyEvent {
+                                logical_key: key,
                                state: ElementState::Pressed,
                                ..
                            },
                        ..
                    },
                ..
-            } => match key {
-                VirtualKeyCode::A => {
+            } => match key.as_ref() {
+                Key::Character("A" | "a") => {
                    println!("Theme was: {:?}", window.theme());
                    window.set_theme(None);
                }
-                VirtualKeyCode::L => {
+                Key::Character("L" | "l") => {
                    println!("Theme was: {:?}", window.theme());
                    window.set_theme(Some(Theme::Light));
                }
-                VirtualKeyCode::D => {
+                Key::Character("D" | "d") => {
                    println!("Theme was: {:?}", window.theme());
                    window.set_theme(Some(Theme::Dark));
                }
                _ => (),
            },
+            Event::RedrawRequested(_) => {
+                println!("\nredrawing!\n");
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/timer.rs
+++ b/examples/timer.rs
@@ -1,7 +1,10 @@
 #![allow(clippy::single_match)]

-use instant::Instant;
 use std::time::Duration;
+#[cfg(not(wasm_platform))]
+use std::time::Instant;
+#[cfg(wasm_platform)]
+use web_time::Instant;

 use simple_logger::SimpleLogger;
 use winit::{
@@ -10,11 +13,14 @@ use winit::{
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();

-    let _window = WindowBuilder::new()
+    let window = WindowBuilder::new()
        .with_title("A fantastic window!")
        .build(&event_loop)
        .unwrap();
@@ -36,6 +42,9 @@ fn main() {
                event: WindowEvent::CloseRequested,
                ..
            } => control_flow.set_exit(),
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/touchpad_gestures.rs
+++ b/examples/touchpad_gestures.rs
@@ -5,11 +5,14 @@ use winit::{
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();

-    let _window = WindowBuilder::new()
+    let window = WindowBuilder::new()
        .with_title("Touchpad gestures")
        .build(&event_loop)
        .unwrap();
@@ -41,6 +44,8 @@ fn main() {
                }
                _ => (),
            }
+        } else if let Event::RedrawRequested(_) = event {
+            fill::fill_window(&window);
        }
    });
 }
--- a/examples/transparent.rs
+++ b/examples/transparent.rs
@@ -7,6 +7,9 @@ use winit::{
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -28,6 +31,9 @@ fn main() {
                event: WindowEvent::CloseRequested,
                ..
            } => control_flow.set_exit(),
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/util/fill.rs
+++ b/examples/util/fill.rs
@@ -0,0 +1,86 @@
+//! Fill the window buffer with a solid color.
+//!
+//! Launching a window without drawing to it has unpredictable results varying from platform to
+//! platform. In order to have well-defined examples, this module provides an easy way to
+//! fill the window buffer with a solid color.
+//!
+//! The `softbuffer` crate is used, largely because of its ease of use. `glutin` or `wgpu` could
+//! also be used to fill the window buffer, but they are more complicated to use.
+
+use winit::window::Window;
+
+#[cfg(not(any(target_os = "android", target_os = "ios")))]
+pub(super) fn fill_window(window: &Window) {
+    use softbuffer::{Context, Surface};
+    use std::cell::RefCell;
+    use std::collections::HashMap;
+    use std::mem::ManuallyDrop;
+    use std::num::NonZeroU32;
+    use winit::window::WindowId;
+
+    /// The graphics context used to draw to a window.
+    struct GraphicsContext {
+        /// The global softbuffer context.
+        context: Context,
+
+        /// The hash map of window IDs to surfaces.
+        surfaces: HashMap<WindowId, Surface>,
+    }
+
+    impl GraphicsContext {
+        fn new(w: &Window) -> Self {
+            Self {
+                context: unsafe { Context::new(w) }.expect("Failed to create a softbuffer context"),
+                surfaces: HashMap::new(),
+            }
+        }
+
+        fn surface(&mut self, w: &Window) -> &mut Surface {
+            self.surfaces.entry(w.id()).or_insert_with(|| {
+                unsafe { Surface::new(&self.context, w) }
+                    .expect("Failed to create a softbuffer surface")
+            })
+        }
+    }
+
+    thread_local! {
+        // NOTE: You should never do things like that, create context and drop it before
+        // you drop the event loop. We do this for brevity to not blow up examples. We use
+        // ManuallyDrop to prevent destructors from running.
+        //
+        // A static, thread-local map of graphics contexts to open windows.
+        static GC: ManuallyDrop<RefCell<Option<GraphicsContext>>> = ManuallyDrop::new(RefCell::new(None));
+    }
+
+    GC.with(|gc| {
+        // Either get the last context used or create a new one.
+        let mut gc = gc.borrow_mut();
+        let surface = gc
+            .get_or_insert_with(|| GraphicsContext::new(window))
+            .surface(window);
+
+        // Fill a buffer with a solid color.
+        const DARK_GRAY: u32 = 0xFF181818;
+        let size = window.inner_size();
+
+        surface
+            .resize(
+                NonZeroU32::new(size.width).expect("Width must be greater than zero"),
+                NonZeroU32::new(size.height).expect("Height must be greater than zero"),
+            )
+            .expect("Failed to resize the softbuffer surface");
+
+        let mut buffer = surface
+            .buffer_mut()
+            .expect("Failed to get the softbuffer buffer");
+        buffer.fill(DARK_GRAY);
+        buffer
+            .present()
+            .expect("Failed to present the softbuffer buffer");
+    })
+}
+
+#[cfg(any(target_os = "android", target_os = "ios"))]
+pub(super) fn fill_window(_window: &Window) {
+    // No-op on mobile platforms.
+}
--- a/examples/web.rs
+++ b/examples/web.rs
@@ -1,9 +1,10 @@
-#![allow(clippy::single_match)]
+#![allow(clippy::disallowed_methods, clippy::single_match)]

 use winit::{
-    event::{Event, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
    event_loop::EventLoop,
-    window::WindowBuilder,
+    keyboard::KeyCode,
+    window::{Fullscreen, WindowBuilder},
 };

 pub fn main() {
@@ -31,6 +32,25 @@ pub fn main() {
            Event::MainEventsCleared => {
                window.request_redraw();
            }
+            Event::WindowEvent {
+                window_id,
+                event:
+                    WindowEvent::KeyboardInput {
+                        event:
+                            KeyEvent {
+                                physical_key: KeyCode::KeyF,
+                                state: ElementState::Released,
+                                ..
+                            },
+                        ..
+                    },
+            } if window_id == window.id() => {
+                if window.fullscreen().is_some() {
+                    window.set_fullscreen(None);
+                } else {
+                    window.set_fullscreen(Some(Fullscreen::Borderless(None)));
+                }
+            }
            _ => (),
        }
    });
@@ -52,14 +72,17 @@ mod wasm {
    pub fn insert_canvas_and_create_log_list(window: &Window) -> web_sys::Element {
        use winit::platform::web::WindowExtWebSys;

-        let canvas = window.canvas();
+        let canvas = window.canvas().unwrap();

        let window = web_sys::window().unwrap();
        let document = window.document().unwrap();
        let body = document.body().unwrap();

        // Set a background color for the canvas to make it easier to tell where the canvas is for debugging purposes.
-        canvas.style().set_css_text("background-color: crimson;");
+        canvas
+            .style()
+            .set_property("background-color", "crimson")
+            .unwrap();
        body.append_child(&canvas).unwrap();

        let log_header = document.create_element("h2").unwrap();
--- a/examples/web_aspect_ratio.rs
+++ b/examples/web_aspect_ratio.rs
@@ -1,3 +1,5 @@
+#![allow(clippy::disallowed_methods)]
+
 pub fn main() {
    println!("This example must be run with cargo run-wasm --example web_aspect_ratio")
 }
@@ -66,7 +68,7 @@ This example demonstrates the desired future functionality which will possibly b
        let body = document.body().unwrap();

        // Set a background color for the canvas to make it easier to tell the where the canvas is for debugging purposes.
-        let canvas = window.canvas();
+        let canvas = window.canvas().unwrap();
        canvas
            .style()
            .set_css_text("display: block; background-color: crimson; margin: auto; width: 50%; aspect-ratio: 4 / 1;");
--- a/examples/window.rs
+++ b/examples/window.rs
@@ -7,6 +7,9 @@ use winit::{
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -29,6 +32,9 @@ fn main() {
            Event::MainEventsCleared => {
                window.request_redraw();
            }
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/window_buttons.rs
+++ b/examples/window_buttons.rs
@@ -5,11 +5,15 @@
 use simple_logger::SimpleLogger;
 use winit::{
    dpi::LogicalSize,
-    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-    event_loop::{DeviceEventFilter, EventLoop},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event_loop::{DeviceEvents, EventLoop},
+    keyboard::Key,
    window::{WindowBuilder, WindowButtons},
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -25,7 +29,7 @@ fn main() {
    eprintln!("  (G) Toggle maximize button");
    eprintln!("  (H) Toggle minimize button");

-    event_loop.set_device_event_filter(DeviceEventFilter::Never);
+    event_loop.listen_device_events(DeviceEvents::Always);

    event_loop.run(move |event, _, control_flow| {
        control_flow.set_wait();
@@ -34,25 +38,25 @@ fn main() {
            Event::WindowEvent {
                event:
                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                virtual_keycode: Some(key),
+                        event:
+                            KeyEvent {
+                                logical_key: key,
                                state: ElementState::Pressed,
                                ..
                            },
                        ..
                    },
                ..
-            } => match key {
-                VirtualKeyCode::F => {
+            } => match key.as_ref() {
+                Key::Character("F" | "f") => {
                    let buttons = window.enabled_buttons();
                    window.set_enabled_buttons(buttons ^ WindowButtons::CLOSE);
                }
-                VirtualKeyCode::G => {
+                Key::Character("G" | "g") => {
                    let buttons = window.enabled_buttons();
                    window.set_enabled_buttons(buttons ^ WindowButtons::MAXIMIZE);
                }
-                VirtualKeyCode::H => {
+                Key::Character("H" | "h") => {
                    let buttons = window.enabled_buttons();
                    window.set_enabled_buttons(buttons ^ WindowButtons::MINIMIZE);
                }
@@ -62,6 +66,9 @@ fn main() {
                event: WindowEvent::CloseRequested,
                window_id,
            } if window_id == window.id() => control_flow.set_exit(),
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/window_debug.rs
+++ b/examples/window_debug.rs
@@ -5,11 +5,15 @@
 use simple_logger::SimpleLogger;
 use winit::{
    dpi::{LogicalSize, PhysicalSize},
-    event::{DeviceEvent, ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-    event_loop::{DeviceEventFilter, EventLoop},
+    event::{DeviceEvent, ElementState, Event, KeyEvent, RawKeyEvent, WindowEvent},
+    event_loop::{DeviceEvents, EventLoop},
+    keyboard::{Key, KeyCode},
    window::{Fullscreen, WindowBuilder},
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -32,29 +36,31 @@ fn main() {
    let mut minimized = false;
    let mut visible = true;

-    event_loop.set_device_event_filter(DeviceEventFilter::Never);
+    event_loop.listen_device_events(DeviceEvents::Always);

    event_loop.run(move |event, _, control_flow| {
        control_flow.set_wait();

        match event {
+            // This used to use the virtual key, but the new API
+            // only provides the `physical_key` (`Code`).
            Event::DeviceEvent {
                event:
-                    DeviceEvent::Key(KeyboardInput {
-                        virtual_keycode: Some(key),
-                        state: ElementState::Pressed,
+                    DeviceEvent::Key(RawKeyEvent {
+                        physical_key,
+                        state: ElementState::Released,
                        ..
                    }),
                ..
-            } => match key {
-                VirtualKeyCode::M => {
+            } => match physical_key {
+                KeyCode::KeyM => {
                    if minimized {
                        minimized = !minimized;
                        window.set_minimized(minimized);
                        window.focus_window();
                    }
                }
-                VirtualKeyCode::V => {
+                KeyCode::KeyV => {
                    if !visible {
                        visible = !visible;
                        window.set_visible(visible);
@@ -65,17 +71,19 @@ fn main() {
            Event::WindowEvent {
                event:
                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                virtual_keycode: Some(key),
+                        event:
+                            KeyEvent {
+                                logical_key: Key::Character(key_str),
                                state: ElementState::Pressed,
                                ..
                            },
                        ..
                    },
                ..
-            } => match key {
-                VirtualKeyCode::E => {
+            } => match key_str.as_ref() {
+                // WARNING: Consider using `key_without_modifers()` if available on your platform.
+                // See the `key_binding` example
+                "e" => {
                    fn area(size: PhysicalSize<u32>) -> u32 {
                        size.width * size.height
                    }
@@ -90,7 +98,7 @@ fn main() {
                        eprintln!("no video modes available");
                    }
                }
-                VirtualKeyCode::F => {
+                "f" => {
                    if window.fullscreen().is_some() {
                        window.set_fullscreen(None);
                    } else {
@@ -98,25 +106,25 @@ fn main() {
                        window.set_fullscreen(Some(Fullscreen::Borderless(monitor)));
                    }
                }
-                VirtualKeyCode::P => {
+                "p" => {
                    if window.fullscreen().is_some() {
                        window.set_fullscreen(None);
                    } else {
                        window.set_fullscreen(Some(Fullscreen::Borderless(None)));
                    }
                }
-                VirtualKeyCode::M => {
+                "m" => {
                    minimized = !minimized;
                    window.set_minimized(minimized);
                }
-                VirtualKeyCode::Q => {
+                "q" => {
                    control_flow.set_exit();
                }
-                VirtualKeyCode::V => {
+                "v" => {
                    visible = !visible;
                    window.set_visible(visible);
                }
-                VirtualKeyCode::X => {
+                "x" => {
                    let is_maximized = window.is_maximized();
                    window.set_maximized(!is_maximized);
                }
@@ -126,6 +134,9 @@ fn main() {
                event: WindowEvent::CloseRequested,
                window_id,
            } if window_id == window.id() => control_flow.set_exit(),
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/window_drag_resize.rs
+++ b/examples/window_drag_resize.rs
@@ -2,15 +2,17 @@

 use simple_logger::SimpleLogger;
 use winit::{
-    event::{
-        ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
-    },
+    event::{ElementState, Event, KeyEvent, MouseButton, StartCause, WindowEvent},
    event_loop::{ControlFlow, EventLoop},
+    keyboard::Key,
    window::{CursorIcon, ResizeDirection, WindowBuilder},
 };

 const BORDER: f64 = 8.0;

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -53,19 +55,22 @@ fn main() {
                }
            }
            WindowEvent::KeyboardInput {
-                input:
-                    KeyboardInput {
+                event:
+                    KeyEvent {
                        state: ElementState::Released,
-                        virtual_keycode: Some(VirtualKeyCode::B),
+                        logical_key: Key::Character(c),
                        ..
                    },
                ..
-            } => {
+            } if matches!(c.as_ref(), "B" | "b") => {
                border = !border;
                window.set_decorations(border);
            }
            _ => (),
        },
+        Event::RedrawRequested(_) => {
+            fill::fill_window(&window);
+        }
        _ => (),
    });
 }
--- a/examples/window_icon.rs
+++ b/examples/window_icon.rs
@@ -9,6 +9,9 @@ use winit::{
    window::{Icon, WindowBuilder},
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();

@@ -42,6 +45,8 @@ fn main() {
                }
                _ => (),
            }
+        } else if let Event::RedrawRequested(_) = event {
+            fill::fill_window(&window);
        }
    });
 }
--- a/examples/window_option_as_alt.rs
+++ b/examples/window_option_as_alt.rs
@@ -11,6 +11,10 @@ use winit::{
    window::WindowBuilder,
 };

+#[cfg(target_os = "macos")]
+#[path = "util/fill.rs"]
+mod fill;
+
 /// Prints the keyboard events characters received when option_is_alt is true versus false.
 /// A left mouse click will toggle option_is_alt.
 #[cfg(target_os = "macos")]
@@ -23,6 +27,8 @@ fn main() {
        .build(&event_loop)
        .unwrap();

+    window.set_ime_allowed(true);
+
    let mut option_as_alt = window.option_as_alt();

    event_loop.run(move |event, _, control_flow| {
@@ -49,13 +55,15 @@ fn main() {
                    println!("Received Mouse click, toggling option_as_alt to: {option_as_alt:?}");
                    window.set_option_as_alt(option_as_alt);
                }
-                WindowEvent::ReceivedCharacter(c) => println!("ReceivedCharacter: {c:?}"),
                WindowEvent::KeyboardInput { .. } => println!("KeyboardInput: {event:?}"),
                _ => (),
            },
            Event::MainEventsCleared => {
                window.request_redraw();
            }
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/window_resize_increments.rs
+++ b/examples/window_resize_increments.rs
@@ -2,11 +2,15 @@ use log::debug;
 use simple_logger::SimpleLogger;
 use winit::{
    dpi::LogicalSize,
-    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event::{ElementState, Event, KeyEvent, WindowEvent},
    event_loop::EventLoop,
+    keyboard::Key,
    window::WindowBuilder,
 };

+#[path = "util/fill.rs"]
+mod fill;
+
 fn main() {
    SimpleLogger::new().init().unwrap();
    let event_loop = EventLoop::new();
@@ -31,9 +35,9 @@ fn main() {
            Event::WindowEvent {
                event:
                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                virtual_keycode: Some(VirtualKeyCode::Space),
+                        event:
+                            KeyEvent {
+                                logical_key: Key::Space,
                                state: ElementState::Released,
                                ..
                            },
@@ -51,6 +55,9 @@ fn main() {
                window.set_resize_increments(new_increments);
            }
            Event::MainEventsCleared => window.request_redraw(),
+            Event::RedrawRequested(_) => {
+                fill::fill_window(&window);
+            }
            _ => (),
        }
    });
--- a/examples/window_run_return.rs
+++ b/examples/window_run_return.rs
@@ -19,10 +19,14 @@ fn main() {
        platform::run_return::EventLoopExtRunReturn,
        window::WindowBuilder,
    };
+
+    #[path = "util/fill.rs"]
+    mod fill;
+
    let mut event_loop = EventLoop::new();

    SimpleLogger::new().init().unwrap();
-    let _window = WindowBuilder::new()
+    let window = WindowBuilder::new()
        .with_title("A fantastic window!")
        .build(&event_loop)
        .unwrap();
@@ -48,6 +52,9 @@ fn main() {
                Event::MainEventsCleared => {
                    control_flow.set_exit();
                }
+                Event::RedrawRequested(_) => {
+                    fill::fill_window(&window);
+                }
                _ => (),
            }
        });
--- a/src/dpi.rs
+++ b/src/dpi.rs
@@ -167,7 +167,7 @@ pub fn validate_scale_factor(scale_factor: f64) -> bool {
 /// The position is stored as floats, so please be careful. Casting floats to integers truncates the
 /// fractional part, which can cause noticable issues. To help with that, an `Into<(i32, i32)>`
 /// implementation is provided which does the rounding for you.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct LogicalPosition<P> {
    pub x: P,
@@ -246,7 +246,7 @@ impl<P: Pixel> From<LogicalPosition<P>> for mint::Point2<P> {
 }

 /// A position represented in physical pixels.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PhysicalPosition<P> {
    pub x: P,
@@ -325,7 +325,7 @@ impl<P: Pixel> From<PhysicalPosition<P>> for mint::Point2<P> {
 }

 /// A size represented in logical pixels.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct LogicalSize<P> {
    pub width: P,
@@ -407,7 +407,7 @@ impl<P: Pixel> From<LogicalSize<P>> for mint::Vector2<P> {
 }

 /// A size represented in physical pixels.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PhysicalSize<P> {
    pub width: P,
--- a/src/event.rs
+++ b/src/event.rs
@@ -34,13 +34,18 @@
 //!
 //! [`EventLoop::run(...)`]: crate::event_loop::EventLoop::run
 //! [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
-use instant::Instant;
+use smol_str::SmolStr;
 use std::path::PathBuf;
+#[cfg(not(wasm_platform))]
+use std::time::Instant;
+#[cfg(wasm_platform)]
+use web_time::Instant;

 #[cfg(doc)]
 use crate::window::Window;
 use crate::{
    dpi::{PhysicalPosition, PhysicalSize},
+    keyboard::{self, ModifiersKeyState, ModifiersKeys, ModifiersState},
    platform_impl,
    window::{Theme, WindowId},
 };
@@ -120,6 +125,18 @@ pub enum Event<'a, T: 'static> {
    /// [`applicationWillResignActive`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622950-applicationwillresignactive
    /// [iOS application lifecycle]: https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle
    ///
+    /// ## Web
+    ///
+    /// On Web, the `Suspended` event is emitted in response to a [`pagehide`] event
+    /// with the property [`persisted`] being true, which means that the page is being
+    /// put in the [´bfcache`] (back/forward cache) - an in-memory cache that stores a
+    /// complete snapshot of a page (including the JavaScript heap) as the user is
+    /// navigating away.
+    ///
+    /// [`pagehide`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/pagehide_event
+    /// [`persisted`]: https://developer.mozilla.org/en-US/docs/Web/API/PageTransitionEvent/persisted
+    /// [`bfcache`]: https://web.dev/bfcache/
+    ///
    /// [`Resumed`]: Self::Resumed
    Suspended,

@@ -174,6 +191,18 @@ pub enum Event<'a, T: 'static> {
    /// [`applicationDidBecomeActive`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622956-applicationdidbecomeactive
    /// [iOS application lifecycle]: https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle
    ///
+    /// ## Web
+    ///
+    /// On Web, the `Resumed` event is emitted in response to a [`pageshow`] event
+    /// with the property [`persisted`] being true, which means that the page is being
+    /// restored from the [´bfcache`] (back/forward cache) - an in-memory cache that
+    /// stores a complete snapshot of a page (including the JavaScript heap) as the
+    /// user is navigating away.
+    ///
+    /// [`pageshow`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/pageshow_event
+    /// [`persisted`]: https://developer.mozilla.org/en-US/docs/Web/API/PageTransitionEvent/persisted
+    /// [`bfcache`]: https://web.dev/bfcache/
+    ///
    /// [`Suspended`]: Self::Suspended
    Resumed,

@@ -227,7 +256,7 @@ pub enum Event<'a, T: 'static> {
    /// Emitted when the event loop is being shut down.
    ///
    /// This is irreversible - if this event is emitted, it is guaranteed to be the last event that
-    /// gets emitted. You generally want to treat this as an "do on quit" event.
+    /// gets emitted. You generally want to treat this as a "do on quit" event.
    LoopDestroyed,
 }

@@ -256,6 +285,7 @@ impl<T: Clone> Clone for Event<'static, T> {
 }

 impl<'a, T> Event<'a, T> {
+    #[allow(clippy::result_large_err)]
    pub fn map_nonuser_event<U>(self) -> Result<Event<'a, U>, Event<'a, T>> {
        use self::Event::*;
        match self {
@@ -360,20 +390,21 @@ pub enum WindowEvent<'a> {
    /// hovered.
    HoveredFileCancelled,

-    /// The window received a unicode character.
-    ///
-    /// See also the [`Ime`](Self::Ime) event for more complex character sequences.
-    ReceivedCharacter(char),
-
    /// The window gained or lost focus.
    ///
    /// The parameter is true if the window has gained focus, and false if it has lost focus.
    Focused(bool),

    /// An event from the keyboard has been received.
+    ///
+    /// ## Platform-specific
+    /// - **Windows:** The shift key overrides NumLock. In other words, while shift is held down,
+    ///   numpad keys act as if NumLock wasn't active. When this is used, the OS sends fake key
+    ///   events which are not marked as `is_synthetic`.
    KeyboardInput {
        device_id: DeviceId,
-        input: KeyboardInput,
+        event: KeyEvent,
+
        /// If `true`, the event was generated synthetically by winit
        /// in one of the following circumstances:
        ///
@@ -387,12 +418,7 @@ pub enum WindowEvent<'a> {
    },

    /// The keyboard modifiers have changed.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** This API is currently unimplemented on the web. This isn't by design - it's an
-    ///   issue, and it should get fixed - but it's the current state of the API.
-    ModifiersChanged(ModifiersState),
+    ModifiersChanged(Modifiers),

    /// An event from an input method.
    ///
@@ -411,8 +437,6 @@ pub enum WindowEvent<'a> {
        /// limited by the display area and it may have been transformed by the OS to implement effects such as cursor
        /// acceleration, it should not be used to implement non-cursor-like interactions such as 3D camera control.
        position: PhysicalPosition<f64>,
-        #[deprecated = "Deprecated in favor of WindowEvent::ModifiersChanged"]
-        modifiers: ModifiersState,
    },

    /// The cursor has entered the window.
@@ -426,8 +450,6 @@ pub enum WindowEvent<'a> {
        device_id: DeviceId,
        delta: MouseScrollDelta,
        phase: TouchPhase,
-        #[deprecated = "Deprecated in favor of WindowEvent::ModifiersChanged"]
-        modifiers: ModifiersState,
    },

    /// An mouse button press has been received.
@@ -435,8 +457,6 @@ pub enum WindowEvent<'a> {
        device_id: DeviceId,
        state: ElementState,
        button: MouseButton,
-        #[deprecated = "Deprecated in favor of WindowEvent::ModifiersChanged"]
-        modifiers: ModifiersState,
    },

    /// Touchpad magnification event with two-finger pinch gesture.
@@ -560,28 +580,24 @@ impl Clone for WindowEvent<'static> {
            DroppedFile(file) => DroppedFile(file.clone()),
            HoveredFile(file) => HoveredFile(file.clone()),
            HoveredFileCancelled => HoveredFileCancelled,
-            ReceivedCharacter(c) => ReceivedCharacter(*c),
            Focused(f) => Focused(*f),
            KeyboardInput {
                device_id,
-                input,
+                event,
                is_synthetic,
            } => KeyboardInput {
                device_id: *device_id,
-                input: *input,
+                event: event.clone(),
                is_synthetic: *is_synthetic,
            },
            Ime(preedit_state) => Ime(preedit_state.clone()),
            ModifiersChanged(modifiers) => ModifiersChanged(*modifiers),
-            #[allow(deprecated)]
            CursorMoved {
                device_id,
                position,
-                modifiers,
            } => CursorMoved {
                device_id: *device_id,
                position: *position,
-                modifiers: *modifiers,
            },
            CursorEntered { device_id } => CursorEntered {
                device_id: *device_id,
@@ -589,29 +605,23 @@ impl Clone for WindowEvent<'static> {
            CursorLeft { device_id } => CursorLeft {
                device_id: *device_id,
            },
-            #[allow(deprecated)]
            MouseWheel {
                device_id,
                delta,
                phase,
-                modifiers,
            } => MouseWheel {
                device_id: *device_id,
                delta: *delta,
                phase: *phase,
-                modifiers: *modifiers,
            },
-            #[allow(deprecated)]
            MouseInput {
                device_id,
                state,
                button,
-                modifiers,
            } => MouseInput {
                device_id: *device_id,
                state: *state,
                button: *button,
-                modifiers: *modifiers,
            },
            TouchpadMagnify {
                device_id,
@@ -673,54 +683,44 @@ impl<'a> WindowEvent<'a> {
            DroppedFile(file) => Some(DroppedFile(file)),
            HoveredFile(file) => Some(HoveredFile(file)),
            HoveredFileCancelled => Some(HoveredFileCancelled),
-            ReceivedCharacter(c) => Some(ReceivedCharacter(c)),
            Focused(focused) => Some(Focused(focused)),
            KeyboardInput {
                device_id,
-                input,
+                event,
                is_synthetic,
            } => Some(KeyboardInput {
                device_id,
-                input,
+                event,
                is_synthetic,
            }),
-            ModifiersChanged(modifiers) => Some(ModifiersChanged(modifiers)),
+            ModifiersChanged(modifers) => Some(ModifiersChanged(modifers)),
            Ime(event) => Some(Ime(event)),
-            #[allow(deprecated)]
            CursorMoved {
                device_id,
                position,
-                modifiers,
            } => Some(CursorMoved {
                device_id,
                position,
-                modifiers,
            }),
            CursorEntered { device_id } => Some(CursorEntered { device_id }),
            CursorLeft { device_id } => Some(CursorLeft { device_id }),
-            #[allow(deprecated)]
            MouseWheel {
                device_id,
                delta,
                phase,
-                modifiers,
            } => Some(MouseWheel {
                device_id,
                delta,
                phase,
-                modifiers,
            }),
-            #[allow(deprecated)]
            MouseInput {
                device_id,
                state,
                button,
-                modifiers,
            } => Some(MouseInput {
                device_id,
                state,
                button,
-                modifiers,
            }),
            TouchpadMagnify {
                device_id,
@@ -831,50 +831,224 @@ pub enum DeviceEvent {
        state: ElementState,
    },

-    Key(KeyboardInput),
+    Key(RawKeyEvent),

    Text {
        codepoint: char,
    },
 }

-/// Describes a keyboard input event.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+/// Describes a keyboard input as a raw device event.
+///
+/// Note that holding down a key may produce repeated `RawKeyEvent`s. The
+/// operating system doesn't provide information whether such an event is a
+/// repeat or the initial keypress. An application may emulate this by, for
+/// example keeping a Map/Set of pressed keys and determining whether a keypress
+/// corresponds to an already pressed key.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct KeyboardInput {
-    /// Identifies the physical key pressed
-    ///
-    /// This should not change if the user adjusts the host's keyboard map. Use when the physical location of the
-    /// key is more important than the key's host GUI semantics, such as for movement controls in a first-person
-    /// game.
-    pub scancode: ScanCode,
+pub struct RawKeyEvent {
+    pub physical_key: keyboard::KeyCode,
+    pub state: ElementState,
+}

+/// Describes a keyboard input targeting a window.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct KeyEvent {
+    /// Represents the position of a key independent of the currently active layout.
+    ///
+    /// It also uniquely identifies the physical key (i.e. it's mostly synonymous with a scancode).
+    /// The most prevalent use case for this is games. For example the default keys for the player
+    /// to move around might be the W, A, S, and D keys on a US layout. The position of these keys
+    /// is more important than their label, so they should map to Z, Q, S, and D on an "AZERTY"
+    /// layout. (This value is `KeyCode::KeyW` for the Z key on an AZERTY layout.)
+    ///
+    /// ## Caveats
+    ///
+    /// - Certain niche hardware will shuffle around physical key positions, e.g. a keyboard that
+    /// implements DVORAK in hardware (or firmware)
+    /// - Your application will likely have to handle keyboards which are missing keys that your
+    /// own keyboard has.
+    /// - Certain `KeyCode`s will move between a couple of different positions depending on what
+    /// layout the keyboard was manufactured to support.
+    ///
+    ///  **Because of these caveats, it is important that you provide users with a way to configure
+    ///  most (if not all) keybinds in your application.**
+    ///
+    /// ## `Fn` and `FnLock`
+    ///
+    /// `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::KeyCode,
+
+    // Allowing `broken_intra_doc_links` for `logical_key`, because
+    // `key_without_modifiers` is not available on all platforms
+    #[cfg_attr(
+        not(any(target_os = "macos", target_os = "windows", target_os = "linux")),
+        allow(rustdoc::broken_intra_doc_links)
+    )]
+    /// This value is affected by all modifiers except <kbd>Ctrl</kbd>.
+    ///
+    /// This has two use cases:
+    /// - Allows querying whether the current input is a Dead key.
+    /// - Allows handling key-bindings on platforms which don't
+    /// support [`key_without_modifiers`].
+    ///
+    /// If you use this field (or [`key_without_modifiers`] for that matter) for keyboard
+    /// shortcuts, **it is important that you provide users with a way to configure your
+    /// application's shortcuts so you don't render your application unusable for users with an
+    /// incompatible keyboard layout.**
+    ///
+    /// ## Platform-specific
+    /// - **Web:** Dead keys might be reported as the real key instead
+    /// of `Dead` depending on the browser/OS.
+    ///
+    /// [`key_without_modifiers`]: crate::platform::modifier_supplement::KeyEventExtModifierSupplement::key_without_modifiers
+    pub logical_key: keyboard::Key,
+
+    /// Contains the text produced by this keypress.
+    ///
+    /// In most cases this is identical to the content
+    /// of the `Character` variant of `logical_key`.
+    /// However, on Windows when a dead key was pressed earlier
+    /// but cannot be combined with the character from this
+    /// keypress, the produced text will consist of two characters:
+    /// the dead-key-character followed by the character resulting
+    /// from this keypress.
+    ///
+    /// 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::Enter`, this field is `Some("\r")`.
+    ///
+    /// This is `None` if the current keypress cannot
+    /// be interpreted as text.
+    ///
+    /// See also: `text_with_all_modifiers()`
+    pub text: Option<SmolStr>,
+
+    /// Contains the location of this key on the keyboard.
+    ///
+    /// Certain keys on the keyboard may appear in more than once place. For example, the "Shift" key
+    /// appears on the left side of the QWERTY keyboard as well as the right side. However, both keys
+    /// have the same symbolic value. Another example of this phenomenon is the "1" key, which appears
+    /// both above the "Q" key and as the "Keypad 1" key.
+    ///
+    /// This field allows the user to differentiate between keys like this that have the same symbolic
+    /// value but different locations on the keyboard.
+    ///
+    /// See the [`KeyLocation`] type for more details.
+    ///
+    /// [`KeyLocation`]: crate::keyboard::KeyLocation
+    pub location: keyboard::KeyLocation,
+
+    /// Whether the key is being pressed or released.
+    ///
+    /// See the [`ElementState`] type for more details.
    pub state: ElementState,

-    /// Identifies the semantic meaning of the key
+    /// Whether or not this key is a key repeat event.
    ///
-    /// Use when the semantics of the key are more important than the physical location of the key, such as when
-    /// implementing appropriate behavior for "page up."
-    pub virtual_keycode: Option<VirtualKeyCode>,
+    /// On some systems, holding down a key for some period of time causes that key to be repeated
+    /// as though it were being pressed and released repeatedly. This field is `true` if and only if
+    /// this event is the result of one of those repeats.
+    pub repeat: bool,

-    /// Modifier keys active at the time of this input.
+    /// Platform-specific key event information.
    ///
-    /// This is tracked internally to avoid tracking errors arising from modifier key state changes when events from
-    /// this device are not being delivered to the application, e.g. due to keyboard focus being elsewhere.
-    #[deprecated = "Deprecated in favor of WindowEvent::ModifiersChanged"]
-    pub modifiers: ModifiersState,
+    /// On Windows, Linux and macOS, this type contains the key without modifiers and the text with all
+    /// modifiers applied.
+    ///
+    /// On Android, iOS, Redox and Web, this type is a no-op.
+    pub(crate) platform_specific: platform_impl::KeyEventExtra,
+}
+
+/// Describes keyboard modifiers event.
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub struct Modifiers {
+    pub(crate) state: ModifiersState,
+
+    // NOTE: Currently pressed modifiers keys.
+    //
+    // The field providing a metadata, it shouldn't be used as a source of truth.
+    pub(crate) pressed_mods: ModifiersKeys,
+}
+
+impl Modifiers {
+    /// The state of the modifiers.
+    pub fn state(&self) -> ModifiersState {
+        self.state
+    }
+
+    /// The state of the left shift key.
+    pub fn lshift_state(&self) -> ModifiersKeyState {
+        self.mod_state(ModifiersKeys::LSHIFT)
+    }
+
+    /// The state of the right shift key.
+    pub fn rshift_state(&self) -> ModifiersKeyState {
+        self.mod_state(ModifiersKeys::RSHIFT)
+    }
+
+    /// The state of the left alt key.
+    pub fn lalt_state(&self) -> ModifiersKeyState {
+        self.mod_state(ModifiersKeys::LALT)
+    }
+
+    /// The state of the right alt key.
+    pub fn ralt_state(&self) -> ModifiersKeyState {
+        self.mod_state(ModifiersKeys::RALT)
+    }
+
+    /// The state of the left control key.
+    pub fn lcontrol_state(&self) -> ModifiersKeyState {
+        self.mod_state(ModifiersKeys::LCONTROL)
+    }
+
+    /// The state of the right control key.
+    pub fn rcontrol_state(&self) -> ModifiersKeyState {
+        self.mod_state(ModifiersKeys::RCONTROL)
+    }
+
+    /// The state of the left super key.
+    pub fn lsuper_state(&self) -> ModifiersKeyState {
+        self.mod_state(ModifiersKeys::LSUPER)
+    }
+
+    /// The state of the right super key.
+    pub fn rsuper_state(&self) -> ModifiersKeyState {
+        self.mod_state(ModifiersKeys::RSUPER)
+    }
+
+    fn mod_state(&self, modifier: ModifiersKeys) -> ModifiersKeyState {
+        if self.pressed_mods.contains(modifier) {
+            ModifiersKeyState::Pressed
+        } else {
+            ModifiersKeyState::Unknown
+        }
+    }
+}
+
+impl From<ModifiersState> for Modifiers {
+    fn from(value: ModifiersState) -> Self {
+        Self {
+            state: value,
+            pressed_mods: Default::default(),
+        }
+    }
 }

 /// Describes [input method](https://en.wikipedia.org/wiki/Input_method) events.
 ///
 /// This is also called a "composition event".
 ///
-/// Most keypresses using a latin-like keyboard layout simply generate a [`WindowEvent::ReceivedCharacter`].
+/// Most keypresses using a latin-like keyboard layout simply generate a [`WindowEvent::KeyboardInput`].
 /// However, one couldn't possibly have a key for every single unicode character that the user might want to type
 /// - so the solution operating systems employ is to allow the user to type these using _a sequence of keypresses_ instead.
 ///
 /// A prominent example of this is accents - many keyboard layouts allow you to first click the "accent key", and then
-/// the character you want to apply the accent to. This will generate the following event sequence:
+/// the character you want to apply the accent to. In this case, some platforms will generate the following event sequence:
 /// ```ignore
 /// // Press "`" key
 /// Ime::Preedit("`", Some((0, 0)))
@@ -884,9 +1058,9 @@ pub struct KeyboardInput {
 /// ```
 ///
 /// Additionally, certain input devices are configured to display a candidate box that allow the user to select the
-/// desired character interactively. (To properly position this box, you must use [`Window::set_ime_position`].)
+/// desired character interactively. (To properly position this box, you must use [`Window::set_ime_cursor_area`].)
 ///
-/// An example of a keyboard layout which uses candidate boxes is pinyin. On a latin keybaord the following event
+/// An example of a keyboard layout which uses candidate boxes is pinyin. On a latin keyboard the following event
 /// sequence could be obtained:
 /// ```ignore
 /// // Press "A" key
@@ -908,7 +1082,7 @@ pub enum Ime {
    ///
    /// After getting this event you could receive [`Preedit`](Self::Preedit) and
    /// [`Commit`](Self::Commit) events. You should also start performing IME related requests
-    /// like [`Window::set_ime_position`].
+    /// like [`Window::set_ime_cursor_area`].
    Enabled,

    /// Notifies when a new composing text should be set at the cursor position.
@@ -929,7 +1103,7 @@ pub enum Ime {
    ///
    /// After receiving this event you won't get any more [`Preedit`](Self::Preedit) or
    /// [`Commit`](Self::Commit) events until the next [`Enabled`](Self::Enabled) event. You should
-    /// also stop issuing IME related requests like [`Window::set_ime_position`] and clear pending
+    /// also stop issuing IME related requests like [`Window::set_ime_cursor_area`] and clear pending
    /// preedit text.
    Disabled,
 }
@@ -1037,9 +1211,6 @@ impl Force {
    }
 }

-/// Hardware-dependent keyboard scan code.
-pub type ScanCode = u32;
-
 /// Identifier for a specific analog axis on some device.
 pub type AxisId = u32;

@@ -1055,12 +1226,19 @@ pub enum ElementState {
 }

 /// Describes a button of a mouse controller.
+///
+/// ## Platform-specific
+///
+/// **macOS:** `Back` and `Forward` might not work with all hardware.
+/// **Orbital:** `Back` and `Forward` are unsupported due to orbital not supporting them.
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum MouseButton {
    Left,
    Right,
    Middle,
+    Back,
+    Forward,
    Other(u16),
 }

@@ -1090,303 +1268,3 @@ pub enum MouseScrollDelta {
    /// and move the content right and down (to reveal more things left and up).
    PixelDelta(PhysicalPosition<f64>),
 }
-
-/// Symbolic name for a keyboard key.
-#[derive(Debug, Hash, Ord, PartialOrd, PartialEq, Eq, Clone, Copy)]
-#[repr(u32)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum VirtualKeyCode {
-    /// The '1' key over the letters.
-    Key1,
-    /// The '2' key over the letters.
-    Key2,
-    /// The '3' key over the letters.
-    Key3,
-    /// The '4' key over the letters.
-    Key4,
-    /// The '5' key over the letters.
-    Key5,
-    /// The '6' key over the letters.
-    Key6,
-    /// The '7' key over the letters.
-    Key7,
-    /// The '8' key over the letters.
-    Key8,
-    /// The '9' key over the letters.
-    Key9,
-    /// The '0' key over the 'O' and 'P' keys.
-    Key0,
-
-    A,
-    B,
-    C,
-    D,
-    E,
-    F,
-    G,
-    H,
-    I,
-    J,
-    K,
-    L,
-    M,
-    N,
-    O,
-    P,
-    Q,
-    R,
-    S,
-    T,
-    U,
-    V,
-    W,
-    X,
-    Y,
-    Z,
-
-    /// The Escape key, next to F1.
-    Escape,
-
-    F1,
-    F2,
-    F3,
-    F4,
-    F5,
-    F6,
-    F7,
-    F8,
-    F9,
-    F10,
-    F11,
-    F12,
-    F13,
-    F14,
-    F15,
-    F16,
-    F17,
-    F18,
-    F19,
-    F20,
-    F21,
-    F22,
-    F23,
-    F24,
-
-    /// Print Screen/SysRq.
-    Snapshot,
-    /// Scroll Lock.
-    Scroll,
-    /// Pause/Break key, next to Scroll lock.
-    Pause,
-
-    /// `Insert`, next to Backspace.
-    Insert,
-    Home,
-    Delete,
-    End,
-    PageDown,
-    PageUp,
-
-    Left,
-    Up,
-    Right,
-    Down,
-
-    /// The Backspace key, right over Enter.
-    // TODO: rename
-    Back,
-    /// The Enter key.
-    Return,
-    /// The space bar.
-    Space,
-
-    /// The "Compose" key on Linux.
-    Compose,
-
-    Caret,
-
-    Numlock,
-    Numpad0,
-    Numpad1,
-    Numpad2,
-    Numpad3,
-    Numpad4,
-    Numpad5,
-    Numpad6,
-    Numpad7,
-    Numpad8,
-    Numpad9,
-    NumpadAdd,
-    NumpadDivide,
-    NumpadDecimal,
-    NumpadComma,
-    NumpadEnter,
-    NumpadEquals,
-    NumpadMultiply,
-    NumpadSubtract,
-
-    AbntC1,
-    AbntC2,
-    Apostrophe,
-    Apps,
-    Asterisk,
-    At,
-    Ax,
-    Backslash,
-    Calculator,
-    Capital,
-    Colon,
-    Comma,
-    Convert,
-    Equals,
-    Grave,
-    Kana,
-    Kanji,
-    LAlt,
-    LBracket,
-    LControl,
-    LShift,
-    LWin,
-    Mail,
-    MediaSelect,
-    MediaStop,
-    Minus,
-    Mute,
-    MyComputer,
-    // also called "Next"
-    NavigateForward,
-    // also called "Prior"
-    NavigateBackward,
-    NextTrack,
-    NoConvert,
-    OEM102,
-    Period,
-    PlayPause,
-    Plus,
-    Power,
-    PrevTrack,
-    RAlt,
-    RBracket,
-    RControl,
-    RShift,
-    RWin,
-    Semicolon,
-    Slash,
-    Sleep,
-    Stop,
-    Sysrq,
-    Tab,
-    Underline,
-    Unlabeled,
-    VolumeDown,
-    VolumeUp,
-    Wake,
-    WebBack,
-    WebFavorites,
-    WebForward,
-    WebHome,
-    WebRefresh,
-    WebSearch,
-    WebStop,
-    Yen,
-    Copy,
-    Paste,
-    Cut,
-}
-
-impl ModifiersState {
-    /// Returns `true` if the shift key is pressed.
-    pub fn shift(&self) -> bool {
-        self.intersects(Self::SHIFT)
-    }
-    /// Returns `true` if the control key is pressed.
-    pub fn ctrl(&self) -> bool {
-        self.intersects(Self::CTRL)
-    }
-    /// Returns `true` if the alt key is pressed.
-    pub fn alt(&self) -> bool {
-        self.intersects(Self::ALT)
-    }
-    /// Returns `true` if the logo key is pressed.
-    pub fn logo(&self) -> bool {
-        self.intersects(Self::LOGO)
-    }
-}
-
-bitflags! {
-    /// Represents the current state of the keyboard modifiers
-    ///
-    /// Each flag represents a modifier and is set if this modifier is active.
-    #[derive(Default)]
-    pub struct ModifiersState: u32 {
-        // left and right modifiers are currently commented out, but we should be able to support
-        // them in a future release
-        /// The "shift" key.
-        const SHIFT = 0b100;
-        // const LSHIFT = 0b010;
-        // const RSHIFT = 0b001;
-        /// The "control" key.
-        const CTRL = 0b100 << 3;
-        // const LCTRL = 0b010 << 3;
-        // const RCTRL = 0b001 << 3;
-        /// The "alt" key.
-        const ALT = 0b100 << 6;
-        // const LALT = 0b010 << 6;
-        // const RALT = 0b001 << 6;
-        /// This is the "windows" key on PC and "command" key on Mac.
-        const LOGO = 0b100 << 9;
-        // const LLOGO = 0b010 << 9;
-        // const RLOGO = 0b001 << 9;
-    }
-}
-
-#[cfg(feature = "serde")]
-mod modifiers_serde {
-    use super::ModifiersState;
-    use serde::{Deserialize, Deserializer, Serialize, Serializer};
-
-    #[derive(Default, Serialize, Deserialize)]
-    #[serde(default)]
-    #[serde(rename = "ModifiersState")]
-    pub struct ModifiersStateSerialize {
-        pub shift: bool,
-        pub ctrl: bool,
-        pub alt: bool,
-        pub logo: bool,
-    }
-
-    impl Serialize for ModifiersState {
-        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer,
-        {
-            let s = ModifiersStateSerialize {
-                shift: self.shift(),
-                ctrl: self.ctrl(),
-                alt: self.alt(),
-                logo: self.logo(),
-            };
-            s.serialize(serializer)
-        }
-    }
-
-    impl<'de> Deserialize<'de> for ModifiersState {
-        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>,
-        {
-            let ModifiersStateSerialize {
-                shift,
-                ctrl,
-                alt,
-                logo,
-            } = ModifiersStateSerialize::deserialize(deserializer)?;
-            let mut m = ModifiersState::empty();
-            m.set(ModifiersState::SHIFT, shift);
-            m.set(ModifiersState::CTRL, ctrl);
-            m.set(ModifiersState::ALT, alt);
-            m.set(ModifiersState::LOGO, logo);
-            Ok(m)
-        }
-    }
-}
--- a/src/event_loop.rs
+++ b/src/event_loop.rs
@@ -9,11 +9,14 @@
 //! handle events.
 use std::marker::PhantomData;
 use std::ops::Deref;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::{error, fmt};

-use instant::{Duration, Instant};
-use once_cell::sync::OnceCell;
 use raw_window_handle::{HasRawDisplayHandle, RawDisplayHandle};
+#[cfg(not(wasm_platform))]
+use std::time::{Duration, Instant};
+#[cfg(wasm_platform)]
+use web_time::{Duration, Instant};

 use crate::{event::Event, monitor::MonitorHandle, platform_impl};

@@ -66,6 +69,8 @@ impl EventLoopBuilder<()> {
    }
 }

+static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
+
 impl<T> EventLoopBuilder<T> {
    /// Start building a new event loop, with the given type as the user event
    /// type.
@@ -111,10 +116,10 @@ impl<T> EventLoopBuilder<T> {
    )]
    #[inline]
    pub fn build(&mut self) -> EventLoop<T> {
-        static EVENT_LOOP_CREATED: OnceCell<()> = OnceCell::new();
-        if EVENT_LOOP_CREATED.set(()).is_err() {
+        if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
            panic!("Creating EventLoop multiple times is not supported.");
        }
+
        // Certain platforms accept a mutable reference in their API.
        #[allow(clippy::unnecessary_mut_passed)]
        EventLoop {
@@ -122,6 +127,11 @@ impl<T> EventLoopBuilder<T> {
            _marker: PhantomData,
        }
    }
+
+    #[cfg(wasm_platform)]
+    pub(crate) fn allow_event_loop_recreation() {
+        EVENT_LOOP_CREATED.store(false, Ordering::Relaxed);
+    }
 }

 impl<T> fmt::Debug for EventLoop<T> {
@@ -155,13 +165,6 @@ impl<T> fmt::Debug for EventLoopWindowTarget<T> {
 pub enum ControlFlow {
    /// When the current loop iteration finishes, immediately begin a new iteration regardless of
    /// whether or not new events are available to process.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Web:** Events are queued and usually sent when `requestAnimationFrame` fires but sometimes
-    ///   the events in the queue may be sent before the next `requestAnimationFrame` callback, for
-    ///   example when the scaling of the page has changed. This should be treated as an implementation
-    ///   detail which should not be relied on.
    Poll,

    /// When the current loop iteration finishes, suspend the thread until another event arrives.
@@ -313,6 +316,13 @@ impl<T> EventLoop<T> {
    }
 }

+unsafe impl<T> HasRawDisplayHandle for EventLoop<T> {
+    /// Returns a [`raw_window_handle::RawDisplayHandle`] for the event loop.
+    fn raw_display_handle(&self) -> RawDisplayHandle {
+        self.event_loop.window_target().p.raw_display_handle()
+    }
+}
+
 impl<T> Deref for EventLoop<T> {
    type Target = EventLoopWindowTarget<T>;
    fn deref(&self) -> &EventLoopWindowTarget<T> {
@@ -324,6 +334,7 @@ impl<T> EventLoopWindowTarget<T> {
    /// Returns the list of all the monitors available on the system.
    #[inline]
    pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
+        #[allow(clippy::useless_conversion)] // false positive on some platforms
        self.p
            .available_monitors()
            .into_iter()
@@ -344,20 +355,20 @@ impl<T> EventLoopWindowTarget<T> {
            .map(|inner| MonitorHandle { inner })
    }

-    /// Change [`DeviceEvent`] filter mode.
+    /// Change if or when [`DeviceEvent`]s are captured.
    ///
    /// Since the [`DeviceEvent`] capture can lead to high CPU usage for unfocused windows, winit
    /// will ignore them by default for unfocused windows on Linux/BSD. This method allows changing
-    /// this filter at runtime to explicitly capture them again.
+    /// this at runtime to explicitly capture them again.
    ///
    /// ## Platform-specific
    ///
-    /// - **Wayland / macOS / iOS / Android / Web / Orbital:** Unsupported.
+    /// - **Wayland / macOS / iOS / Android / Orbital:** Unsupported.
    ///
    /// [`DeviceEvent`]: crate::event::DeviceEvent
-    pub fn set_device_event_filter(&self, _filter: DeviceEventFilter) {
-        #[cfg(any(x11_platform, wayland_platform, windows))]
-        self.p.set_device_event_filter(_filter);
+    pub fn listen_device_events(&self, _allowed: DeviceEvents) {
+        #[cfg(any(x11_platform, wasm_platform, wayland_platform, windows))]
+        self.p.listen_device_events(_allowed);
    }
 }

@@ -415,19 +426,14 @@ impl<T> fmt::Display for EventLoopClosed<T> {

 impl<T: fmt::Debug> error::Error for EventLoopClosed<T> {}

-/// Filter controlling the propagation of device events.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-pub enum DeviceEventFilter {
-    /// Always filter out device events.
+/// Control when device events are captured.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
+pub enum DeviceEvents {
+    /// Report device events regardless of window focus.
    Always,
-    /// Filter out device events while the window is not focused.
-    Unfocused,
-    /// Report all device events regardless of window focus.
+    /// Only capture device events while the window is focused.
+    #[default]
+    WhenFocused,
+    /// Never capture device events.
    Never,
 }
-
-impl Default for DeviceEventFilter {
-    fn default() -> Self {
-        Self::Unfocused
-    }
-}
--- a/src/keyboard.rs
+++ b/src/keyboard.rs
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -154,6 +154,7 @@ pub mod error;
 pub mod event;
 pub mod event_loop;
 mod icon;
+pub mod keyboard;
 pub mod monitor;
 mod platform_impl;
 pub mod window;
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -32,12 +32,9 @@ impl PartialOrd for VideoMode {

 impl Ord for VideoMode {
    fn cmp(&self, other: &VideoMode) -> std::cmp::Ordering {
-        // TODO: we can impl `Ord` for `PhysicalSize` once we switch from `f32`
-        // to `u32` there
-        let size: (u32, u32) = self.size().into();
-        let other_size: (u32, u32) = other.size().into();
        self.monitor().cmp(&other.monitor()).then(
-            size.cmp(&other_size)
+            self.size()
+                .cmp(&other.size())
                .then(
                    self.refresh_rate_millihertz()
                        .cmp(&other.refresh_rate_millihertz())
--- a/src/platform/android.rs
+++ b/src/platform/android.rs
@@ -42,6 +42,11 @@ pub trait EventLoopBuilderExtAndroid {
    ///
    /// This must be called on Android since the `AndroidApp` is not global state.
    fn with_android_app(&mut self, app: AndroidApp) -> &mut Self;
+
+    /// Calling this will mark the volume keys to be manually handled by the application
+    ///
+    /// Default is to let the operating system handle the volume keys
+    fn handle_volume_keys(&mut self) -> &mut Self;
 }

 impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
@@ -49,6 +54,11 @@ impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
        self.platform_specific.android_app = Some(app);
        self
    }
+
+    fn handle_volume_keys(&mut self) -> &mut Self {
+        self.platform_specific.ignore_volume_keys = false;
+        self
+    }
 }

 /// Re-export of the `android_activity` API
--- a/src/platform/ios.rs
+++ b/src/platform/ios.rs
@@ -253,9 +253,10 @@ impl MonitorHandleExtIOS for MonitorHandle {
 }

 /// Valid orientations for a particular [`Window`].
-#[derive(Clone, Copy, Debug)]
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ValidOrientations {
    /// Excludes `PortraitUpsideDown` on iphone
+    #[default]
    LandscapeAndPortrait,

    Landscape,
@@ -264,17 +265,10 @@ pub enum ValidOrientations {
    Portrait,
 }

-impl Default for ValidOrientations {
-    #[inline]
-    fn default() -> ValidOrientations {
-        ValidOrientations::LandscapeAndPortrait
-    }
-}
-
 /// The device [idiom].
 ///
 /// [idiom]: https://developer.apple.com/documentation/uikit/uidevice/1620037-userinterfaceidiom?language=objc
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum Idiom {
    Unspecified,

@@ -293,14 +287,14 @@ bitflags! {
    /// The [edges] of a screen.
    ///
    /// [edges]: https://developer.apple.com/documentation/uikit/uirectedge?language=objc
-    #[derive(Default)]
+    #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
    pub struct ScreenEdge: u8 {
        const NONE   = 0;
        const TOP    = 1 << 0;
        const LEFT   = 1 << 1;
        const BOTTOM = 1 << 2;
        const RIGHT  = 1 << 3;
-        const ALL = ScreenEdge::TOP.bits | ScreenEdge::LEFT.bits
-            | ScreenEdge::BOTTOM.bits | ScreenEdge::RIGHT.bits;
+        const ALL = ScreenEdge::TOP.bits() | ScreenEdge::LEFT.bits()
+            | ScreenEdge::BOTTOM.bits() | ScreenEdge::RIGHT.bits();
    }
 }
--- a/src/platform/macos.rs
+++ b/src/platform/macos.rs
@@ -122,22 +122,19 @@ impl WindowExtMacOS for Window {
 }

 /// Corresponds to `NSApplicationActivationPolicy`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ActivationPolicy {
    /// Corresponds to `NSApplicationActivationPolicyRegular`.
+    #[default]
    Regular,
+
    /// Corresponds to `NSApplicationActivationPolicyAccessory`.
    Accessory,
+
    /// Corresponds to `NSApplicationActivationPolicyProhibited`.
    Prohibited,
 }

-impl Default for ActivationPolicy {
-    fn default() -> Self {
-        ActivationPolicy::Regular
-    }
-}
-
 /// Additional methods on [`WindowBuilder`] that are specific to MacOS.
 ///
 /// **Note:** Properties dealing with the titlebar will be overwritten by the [`WindowBuilder::with_decorations`] method:
@@ -164,8 +161,7 @@ pub trait WindowBuilderExtMacOS {
    fn with_has_shadow(self, has_shadow: bool) -> WindowBuilder;
    /// Window accepts click-through mouse events.
    fn with_accepts_first_mouse(self, accepts_first_mouse: bool) -> WindowBuilder;
-
-    /// Set whether the `OptionAsAlt` key is interpreted as the `Alt` modifier.
+    /// Set how the <kbd>Option</kbd> keys are interpreted.
    ///
    /// See [`WindowExtMacOS::set_option_as_alt`] for details on what this means if set.
    fn with_option_as_alt(self, option_as_alt: OptionAsAlt) -> WindowBuilder;
@@ -348,7 +344,7 @@ impl<T> EventLoopWindowTargetExtMacOS for EventLoopWindowTarget<T> {
 /// Option as alt behavior.
 ///
 /// The default is `None`.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum OptionAsAlt {
    /// The left `Option` key is treated as `Alt`.
@@ -361,11 +357,6 @@ pub enum OptionAsAlt {
    Both,

    /// No special handling is applied for `Option` key.
+    #[default]
    None,
 }
-
-impl Default for OptionAsAlt {
-    fn default() -> Self {
-        OptionAsAlt::None
-    }
-}
--- a/src/platform/mod.rs
+++ b/src/platform/mod.rs
@@ -32,6 +32,7 @@ pub mod windows;
 #[cfg(x11_platform)]
 pub mod x11;

+pub mod modifier_supplement;
 #[cfg(any(
    windows_platform,
    macos_platform,
@@ -41,3 +42,4 @@ pub mod x11;
    orbital_platform
 ))]
 pub mod run_return;
+pub mod scancode;
--- a/src/platform/modifier_supplement.rs
+++ b/src/platform/modifier_supplement.rs
@@ -0,0 +1,24 @@
+#![cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform))]
+
+use crate::keyboard::Key;
+
+/// Additional methods for the `KeyEvent` which cannot be implemented on all
+/// platforms.
+pub trait KeyEventExtModifierSupplement {
+    /// Identical to `KeyEvent::text` but this is affected by <kbd>Ctrl</kbd>.
+    ///
+    /// For example, pressing <kbd>Ctrl</kbd>+<kbd>a</kbd> produces `Some("\x01")`.
+    fn text_with_all_modifiers(&self) -> Option<&str>;
+
+    /// This value ignores all modifiers including,
+    /// but not limited to <kbd>Shift</kbd>, <kbd>Caps Lock</kbd>,
+    /// and <kbd>Ctrl</kbd>. In most cases this means that the
+    /// unicode character in the resulting string is lowercase.
+    ///
+    /// This is useful for key-bindings / shortcut key combinations.
+    ///
+    /// In case `logical_key` reports `Dead`, this will still report the
+    /// key as `Character` according to the current keyboard layout. This value
+    /// cannot be `Dead`.
+    fn key_without_modifiers(&self) -> Key;
+}
--- a/src/platform/scancode.rs
+++ b/src/platform/scancode.rs
@@ -0,0 +1,30 @@
+#![cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform))]
+
+use crate::keyboard::KeyCode;
+
+// TODO: Describe what this value contains for each platform
+
+/// Additional methods for the [`KeyCode`] type that allow the user to access the platform-specific
+/// scancode.
+///
+/// [`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.
+    ///
+    /// ## Platform-specific
+    /// - **Windows:** A 16bit extended scancode
+    /// - **Wayland/X11**: A 32-bit linux scancode, which is X11/Wayland keycode subtracted by 8.
+    fn to_scancode(self) -> Option<u32>;
+
+    /// Constructs a `KeyCode` from a platform-specific physical key identifier.
+    ///
+    /// 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) -> KeyCode;
+}
--- a/src/platform/wayland.rs
+++ b/src/platform/wayland.rs
@@ -1,5 +1,7 @@
 use std::os::raw;

+use sctk::reexports::client::Proxy;
+
 use crate::{
    event_loop::{EventLoopBuilder, EventLoopWindowTarget},
    monitor::MonitorHandle,
@@ -39,7 +41,7 @@ impl<T> EventLoopWindowTargetExtWayland for EventLoopWindowTarget<T> {
    fn wayland_display(&self) -> Option<*mut raw::c_void> {
        match self.p {
            LinuxEventLoopWindowTarget::Wayland(ref p) => {
-                Some(p.display().get_display_ptr() as *mut _)
+                Some(p.connection.display().id().as_ptr() as *mut _)
            }
            #[cfg(x11_platform)]
            _ => None,
@@ -94,7 +96,7 @@ impl WindowExtWayland for Window {
    #[inline]
    fn wayland_surface(&self) -> Option<*mut raw::c_void> {
        match self.window {
-            LinuxWindow::Wayland(ref w) => Some(w.surface().as_ref().c_ptr() as *mut _),
+            LinuxWindow::Wayland(ref w) => Some(w.surface().id().as_ptr() as *mut _),
            #[cfg(x11_platform)]
            _ => None,
        }
@@ -103,7 +105,7 @@ impl WindowExtWayland for Window {
    #[inline]
    fn wayland_display(&self) -> Option<*mut raw::c_void> {
        match self.window {
-            LinuxWindow::Wayland(ref w) => Some(w.display().get_display_ptr() as *mut _),
+            LinuxWindow::Wayland(ref w) => Some(w.display().id().as_ptr() as *mut _),
            #[cfg(x11_platform)]
            _ => None,
        }
--- a/src/platform/web.rs
+++ b/src/platform/web.rs
@@ -12,7 +12,8 @@ use crate::window::WindowBuilder;
 use web_sys::HtmlCanvasElement;

 pub trait WindowExtWebSys {
-    fn canvas(&self) -> HtmlCanvasElement;
+    /// Only returns the canvas if called from inside the window.
+    fn canvas(&self) -> Option<HtmlCanvasElement>;

    /// Whether the browser reports the preferred color scheme to be "dark".
    fn is_dark_mode(&self) -> bool;
@@ -26,6 +27,9 @@ pub trait WindowBuilderExtWebSys {
    ///
    /// For example, mouse wheel events are only handled by the canvas by default. This avoids
    /// the default behavior of scrolling the page.
+    ///
+    /// Some events are impossible to prevent. E.g. Firefox allows to access the native browser
+    /// context menu with Shift+Rightclick.
    fn with_prevent_default(self, prevent_default: bool) -> Self;

    /// Whether the canvas should be focusable using the tab key. This is necessary to capture
@@ -62,6 +66,11 @@ pub trait EventLoopExtWebSys {
    ///
    /// Unlike `run`, this returns immediately, and doesn't throw an exception in order to
    /// satisfy its `!` return type.
+    ///
+    /// Once the event loop has been destroyed, it's possible to reinitialize another event loop
+    /// by calling this function again. This can be useful if you want to recreate the event loop
+    /// while the WebAssembly module is still loaded. For example, this can be used to recreate the
+    /// event loop when switching between tabs on a single page application.
    fn spawn<F>(self, event_handler: F)
    where
        F: 'static
--- a/src/platform/windows.rs
+++ b/src/platform/windows.rs
@@ -2,9 +2,11 @@ use std::{ffi::c_void, path::Path};

 use crate::{
    dpi::PhysicalSize,
-    event::DeviceId,
+    event::{DeviceId, KeyEvent},
    event_loop::EventLoopBuilder,
+    keyboard::Key,
    monitor::MonitorHandle,
+    platform::modifier_supplement::KeyEventExtModifierSupplement,
    platform_impl::WinIcon,
    window::{BadIcon, Icon, Window, WindowBuilder},
 };
@@ -344,3 +346,18 @@ impl IconExtWindows for Icon {
        Ok(Icon { inner: win_icon })
    }
 }
+
+impl KeyEventExtModifierSupplement for KeyEvent {
+    #[inline]
+    fn text_with_all_modifiers(&self) -> Option<&str> {
+        self.platform_specific
+            .text_with_all_modifers
+            .as_ref()
+            .map(|s| s.as_str())
+    }
+
+    #[inline]
+    fn key_without_modifiers(&self) -> Key {
+        self.platform_specific.key_without_modifiers.clone()
+    }
+}
--- a/src/platform_impl/android/keycodes.rs
+++ b/src/platform_impl/android/keycodes.rs
@@ -0,0 +1,521 @@
+use android_activity::input::Keycode;
+
+use crate::keyboard::{Key, KeyCode, KeyLocation, NativeKey, NativeKeyCode};
+
+pub fn to_physical_keycode(keycode: Keycode) -> KeyCode {
+    match keycode {
+        Keycode::A => KeyCode::KeyA,
+        Keycode::B => KeyCode::KeyB,
+        Keycode::C => KeyCode::KeyC,
+        Keycode::D => KeyCode::KeyD,
+        Keycode::E => KeyCode::KeyE,
+        Keycode::F => KeyCode::KeyF,
+        Keycode::G => KeyCode::KeyG,
+        Keycode::H => KeyCode::KeyH,
+        Keycode::I => KeyCode::KeyI,
+        Keycode::J => KeyCode::KeyJ,
+        Keycode::K => KeyCode::KeyK,
+        Keycode::L => KeyCode::KeyL,
+        Keycode::M => KeyCode::KeyM,
+        Keycode::N => KeyCode::KeyN,
+        Keycode::O => KeyCode::KeyO,
+        Keycode::P => KeyCode::KeyP,
+        Keycode::Q => KeyCode::KeyQ,
+        Keycode::R => KeyCode::KeyR,
+        Keycode::S => KeyCode::KeyS,
+        Keycode::T => KeyCode::KeyT,
+        Keycode::U => KeyCode::KeyU,
+        Keycode::V => KeyCode::KeyV,
+        Keycode::W => KeyCode::KeyW,
+        Keycode::X => KeyCode::KeyX,
+        Keycode::Y => KeyCode::KeyY,
+        Keycode::Z => KeyCode::KeyZ,
+
+        Keycode::Keycode0 => KeyCode::Digit0,
+        Keycode::Keycode1 => KeyCode::Digit1,
+        Keycode::Keycode2 => KeyCode::Digit2,
+        Keycode::Keycode3 => KeyCode::Digit3,
+        Keycode::Keycode4 => KeyCode::Digit4,
+        Keycode::Keycode5 => KeyCode::Digit5,
+        Keycode::Keycode6 => KeyCode::Digit6,
+        Keycode::Keycode7 => KeyCode::Digit7,
+        Keycode::Keycode8 => KeyCode::Digit8,
+        Keycode::Keycode9 => KeyCode::Digit9,
+
+        Keycode::Numpad0 => KeyCode::Numpad0,
+        Keycode::Numpad1 => KeyCode::Numpad1,
+        Keycode::Numpad2 => KeyCode::Numpad2,
+        Keycode::Numpad3 => KeyCode::Numpad3,
+        Keycode::Numpad4 => KeyCode::Numpad4,
+        Keycode::Numpad5 => KeyCode::Numpad5,
+        Keycode::Numpad6 => KeyCode::Numpad6,
+        Keycode::Numpad7 => KeyCode::Numpad7,
+        Keycode::Numpad8 => KeyCode::Numpad8,
+        Keycode::Numpad9 => KeyCode::Numpad9,
+
+        Keycode::NumpadAdd => KeyCode::NumpadAdd,
+        Keycode::NumpadSubtract => KeyCode::NumpadSubtract,
+        Keycode::NumpadMultiply => KeyCode::NumpadMultiply,
+        Keycode::NumpadDivide => KeyCode::NumpadDivide,
+        Keycode::NumpadEnter => KeyCode::NumpadEnter,
+        Keycode::NumpadEquals => KeyCode::NumpadEqual,
+        Keycode::NumpadComma => KeyCode::NumpadComma,
+        Keycode::NumpadDot => KeyCode::NumpadDecimal,
+        Keycode::NumLock => KeyCode::NumLock,
+
+        Keycode::DpadLeft => KeyCode::ArrowLeft,
+        Keycode::DpadRight => KeyCode::ArrowRight,
+        Keycode::DpadUp => KeyCode::ArrowUp,
+        Keycode::DpadDown => KeyCode::ArrowDown,
+
+        Keycode::F1 => KeyCode::F1,
+        Keycode::F2 => KeyCode::F2,
+        Keycode::F3 => KeyCode::F3,
+        Keycode::F4 => KeyCode::F4,
+        Keycode::F5 => KeyCode::F5,
+        Keycode::F6 => KeyCode::F6,
+        Keycode::F7 => KeyCode::F7,
+        Keycode::F8 => KeyCode::F8,
+        Keycode::F9 => KeyCode::F9,
+        Keycode::F10 => KeyCode::F10,
+        Keycode::F11 => KeyCode::F11,
+        Keycode::F12 => KeyCode::F12,
+
+        Keycode::Space => KeyCode::Space,
+        Keycode::Escape => KeyCode::Escape,
+        Keycode::Enter => KeyCode::Enter, // not on the Numpad
+        Keycode::Tab => KeyCode::Tab,
+
+        Keycode::PageUp => KeyCode::PageUp,
+        Keycode::PageDown => KeyCode::PageDown,
+        Keycode::MoveHome => KeyCode::Home,
+        Keycode::MoveEnd => KeyCode::End,
+        Keycode::Insert => KeyCode::Insert,
+
+        Keycode::Del => KeyCode::Backspace, // Backspace (above Enter)
+        Keycode::ForwardDel => KeyCode::Delete, // Delete (below Insert)
+
+        Keycode::Copy => KeyCode::Copy,
+        Keycode::Paste => KeyCode::Paste,
+        Keycode::Cut => KeyCode::Cut,
+
+        Keycode::VolumeUp => KeyCode::AudioVolumeUp,
+        Keycode::VolumeDown => KeyCode::AudioVolumeDown,
+        Keycode::VolumeMute => KeyCode::AudioVolumeMute,
+        //Keycode::Mute => None, // Microphone mute
+        Keycode::MediaPlayPause => KeyCode::MediaPlayPause,
+        Keycode::MediaStop => KeyCode::MediaStop,
+        Keycode::MediaNext => KeyCode::MediaTrackNext,
+        Keycode::MediaPrevious => KeyCode::MediaTrackPrevious,
+
+        Keycode::Plus => KeyCode::Equal,
+        Keycode::Minus => KeyCode::Minus,
+        // Winit doesn't differentiate both '+' and '=', considering they are usually
+        // on the same physical key
+        Keycode::Equals => KeyCode::Equal,
+        Keycode::Semicolon => KeyCode::Semicolon,
+        Keycode::Slash => KeyCode::Slash,
+        Keycode::Backslash => KeyCode::Backslash,
+        Keycode::Comma => KeyCode::Comma,
+        Keycode::Period => KeyCode::Period,
+        Keycode::Apostrophe => KeyCode::Quote,
+        Keycode::Grave => KeyCode::Backquote,
+
+        // Winit doesn't expose a SysRq code, so map to PrintScreen since it's
+        // usually the same physical key
+        Keycode::Sysrq => KeyCode::PrintScreen,
+        // These are usually the same (Pause/Break)
+        Keycode::Break => KeyCode::Pause,
+        // These are exactly the same
+        Keycode::ScrollLock => KeyCode::ScrollLock,
+
+        Keycode::Yen => KeyCode::IntlYen,
+        Keycode::Kana => KeyCode::Lang1,
+        Keycode::KatakanaHiragana => KeyCode::KanaMode,
+
+        Keycode::CtrlLeft => KeyCode::ControlLeft,
+        Keycode::CtrlRight => KeyCode::ControlRight,
+
+        Keycode::ShiftLeft => KeyCode::ShiftLeft,
+        Keycode::ShiftRight => KeyCode::ShiftRight,
+
+        Keycode::AltLeft => KeyCode::AltLeft,
+        Keycode::AltRight => KeyCode::AltRight,
+
+        Keycode::MetaLeft => KeyCode::SuperLeft,
+        Keycode::MetaRight => KeyCode::SuperRight,
+
+        Keycode::LeftBracket => KeyCode::BracketLeft,
+        Keycode::RightBracket => KeyCode::BracketRight,
+
+        Keycode::Power => KeyCode::Power,
+        Keycode::Sleep => KeyCode::Sleep, // what about SoftSleep?
+        Keycode::Wakeup => KeyCode::WakeUp,
+
+        keycode => KeyCode::Unidentified(NativeKeyCode::Android(keycode.into())),
+    }
+}
+
+// TODO: We need to expose getUnicodeChar via android-activity instead of having
+// a fixed mapping from key codes
+pub fn to_logical(keycode: Keycode, native: NativeKey) -> Key {
+    use android_activity::input::Keycode::*;
+
+    match keycode {
+        Unknown => Key::Unidentified(native),
+
+        // Can be added on demand
+        SoftLeft => Key::Unidentified(native),
+        SoftRight => Key::Unidentified(native),
+
+        // Using `BrowserHome` instead of `GoHome` according to
+        // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
+        Home => Key::BrowserHome,
+        Back => Key::BrowserBack,
+        Call => Key::Call,
+        Endcall => Key::EndCall,
+
+        //-------------------------------------------------------------------------------
+        // Reporting unidentified, because the specific character is layout dependent.
+        // (I'm not sure though)
+        Keycode0 => Key::Character("0".into()),
+        Keycode1 => Key::Character("1".into()),
+        Keycode2 => Key::Character("2".into()),
+        Keycode3 => Key::Character("3".into()),
+        Keycode4 => Key::Character("4".into()),
+        Keycode5 => Key::Character("5".into()),
+        Keycode6 => Key::Character("6".into()),
+        Keycode7 => Key::Character("7".into()),
+        Keycode8 => Key::Character("8".into()),
+        Keycode9 => Key::Character("9".into()),
+        Star => Key::Character("*".into()),
+        Pound => Key::Character("#".into()),
+        A => Key::Character("a".into()),
+        B => Key::Character("b".into()),
+        C => Key::Character("c".into()),
+        D => Key::Character("d".into()),
+        E => Key::Character("e".into()),
+        F => Key::Character("f".into()),
+        G => Key::Character("g".into()),
+        H => Key::Character("h".into()),
+        I => Key::Character("i".into()),
+        J => Key::Character("j".into()),
+        K => Key::Character("k".into()),
+        L => Key::Character("l".into()),
+        M => Key::Character("m".into()),
+        N => Key::Character("n".into()),
+        O => Key::Character("o".into()),
+        P => Key::Character("p".into()),
+        Q => Key::Character("q".into()),
+        R => Key::Character("r".into()),
+        S => Key::Character("s".into()),
+        T => Key::Character("t".into()),
+        U => Key::Character("u".into()),
+        V => Key::Character("v".into()),
+        W => Key::Character("w".into()),
+        X => Key::Character("x".into()),
+        Y => Key::Character("y".into()),
+        Z => Key::Character("z".into()),
+        Comma => Key::Character(",".into()),
+        Period => Key::Character(".".into()),
+        Grave => Key::Character("`".into()),
+        Minus => Key::Character("-".into()),
+        Equals => Key::Character("=".into()),
+        LeftBracket => Key::Character("[".into()),
+        RightBracket => Key::Character("]".into()),
+        Backslash => Key::Character("\\".into()),
+        Semicolon => Key::Character(";".into()),
+        Apostrophe => Key::Character("'".into()),
+        Slash => Key::Character("/".into()),
+        At => Key::Character("@".into()),
+        Plus => Key::Character("+".into()),
+        //-------------------------------------------------------------------------------
+        DpadUp => Key::ArrowUp,
+        DpadDown => Key::ArrowDown,
+        DpadLeft => Key::ArrowLeft,
+        DpadRight => Key::ArrowRight,
+        DpadCenter => Key::Enter,
+
+        VolumeUp => Key::AudioVolumeUp,
+        VolumeDown => Key::AudioVolumeDown,
+        Power => Key::Power,
+        Camera => Key::Camera,
+        Clear => Key::Clear,
+
+        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::Alt,
+
+        Headsethook => Key::HeadsetHook,
+        Focus => Key::CameraFocus,
+
+        Menu => Key::Unidentified(native),
+
+        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,
+        Pictsymbols => Key::Unidentified(native),
+        SwitchCharset => Key::Unidentified(native),
+
+        // -----------------------------------------------------------------
+        // Gamepad events should be exposed through a separate API, not
+        // keyboard events
+        ButtonA => Key::Unidentified(native),
+        ButtonB => Key::Unidentified(native),
+        ButtonC => Key::Unidentified(native),
+        ButtonX => Key::Unidentified(native),
+        ButtonY => Key::Unidentified(native),
+        ButtonZ => Key::Unidentified(native),
+        ButtonL1 => Key::Unidentified(native),
+        ButtonR1 => Key::Unidentified(native),
+        ButtonL2 => Key::Unidentified(native),
+        ButtonR2 => Key::Unidentified(native),
+        ButtonThumbl => Key::Unidentified(native),
+        ButtonThumbr => Key::Unidentified(native),
+        ButtonStart => Key::Unidentified(native),
+        ButtonSelect => Key::Unidentified(native),
+        ButtonMode => Key::Unidentified(native),
+        // -----------------------------------------------------------------
+        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()),
+        Numpad3 => Key::Character("3".into()),
+        Numpad4 => Key::Character("4".into()),
+        Numpad5 => Key::Character("5".into()),
+        Numpad6 => Key::Character("6".into()),
+        Numpad7 => Key::Character("7".into()),
+        Numpad8 => Key::Character("8".into()),
+        Numpad9 => Key::Character("9".into()),
+        NumpadDivide => Key::Character("/".into()),
+        NumpadMultiply => Key::Character("*".into()),
+        NumpadSubtract => Key::Character("-".into()),
+        NumpadAdd => Key::Character("+".into()),
+        NumpadDot => Key::Character(".".into()),
+        NumpadComma => Key::Character(",".into()),
+        NumpadEnter => Key::Enter,
+        NumpadEquals => Key::Character("=".into()),
+        NumpadLeftParen => Key::Character("(".into()),
+        NumpadRightParen => Key::Character(")".into()),
+
+        VolumeMute => Key::AudioVolumeMute,
+        Info => Key::Info,
+        ChannelUp => Key::ChannelUp,
+        ChannelDown => Key::ChannelDown,
+        ZoomIn => Key::ZoomIn,
+        ZoomOut => Key::ZoomOut,
+        Tv => Key::TV,
+        Window => Key::Unidentified(native),
+        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,
+        Button1 => Key::Unidentified(native),
+        Button2 => Key::Unidentified(native),
+        Button3 => Key::Unidentified(native),
+        Button4 => Key::Unidentified(native),
+        Button5 => Key::Unidentified(native),
+        Button6 => Key::Unidentified(native),
+        Button7 => Key::Unidentified(native),
+        Button8 => Key::Unidentified(native),
+        Button9 => Key::Unidentified(native),
+        Button10 => Key::Unidentified(native),
+        Button11 => Key::Unidentified(native),
+        Button12 => Key::Unidentified(native),
+        Button13 => Key::Unidentified(native),
+        Button14 => Key::Unidentified(native),
+        Button15 => Key::Unidentified(native),
+        Button16 => Key::Unidentified(native),
+        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,
+        Yen => Key::Unidentified(native),
+        Ro => Key::Unidentified(native),
+        Kana => Key::KanjiMode,
+        Assist => Key::Unidentified(native),
+        BrightnessDown => Key::BrightnessDown,
+        BrightnessUp => Key::BrightnessUp,
+        MediaAudioTrack => Key::MediaAudioTrack,
+        Sleep => Key::Standby,
+        Wakeup => Key::WakeUp,
+        Pairing => Key::Pairing,
+        MediaTopMenu => Key::MediaTopMenu,
+        Keycode11 => Key::Unidentified(native),
+        Keycode12 => Key::Unidentified(native),
+        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,
+        StemPrimary => Key::Unidentified(native),
+        Stem1 => Key::Unidentified(native),
+        Stem2 => Key::Unidentified(native),
+        Stem3 => Key::Unidentified(native),
+        DpadUpLeft => Key::Unidentified(native),
+        DpadDownLeft => Key::Unidentified(native),
+        DpadUpRight => Key::Unidentified(native),
+        DpadDownRight => Key::Unidentified(native),
+        MediaSkipForward => Key::MediaSkipForward,
+        MediaSkipBackward => Key::MediaSkipBackward,
+        MediaStepForward => Key::MediaStepForward,
+        MediaStepBackward => Key::MediaStepBackward,
+        SoftSleep => Key::Unidentified(native),
+        Cut => Key::Cut,
+        Copy => Key::Copy,
+        Paste => Key::Paste,
+        SystemNavigationUp => Key::Unidentified(native),
+        SystemNavigationDown => Key::Unidentified(native),
+        SystemNavigationLeft => Key::Unidentified(native),
+        SystemNavigationRight => Key::Unidentified(native),
+        AllApps => Key::Unidentified(native),
+        Refresh => Key::BrowserRefresh,
+        ThumbsUp => Key::Unidentified(native),
+        ThumbsDown => Key::Unidentified(native),
+        ProfileSwitch => Key::Unidentified(native),
+    }
+}
+
+pub fn to_location(keycode: Keycode) -> KeyLocation {
+    use android_activity::input::Keycode::*;
+
+    match keycode {
+        AltLeft => KeyLocation::Left,
+        AltRight => KeyLocation::Right,
+        ShiftLeft => KeyLocation::Left,
+        ShiftRight => KeyLocation::Right,
+
+        // According to https://developer.android.com/reference/android/view/KeyEvent#KEYCODE_NUM
+        Num => KeyLocation::Left,
+
+        CtrlLeft => KeyLocation::Left,
+        CtrlRight => KeyLocation::Right,
+        MetaLeft => KeyLocation::Left,
+        MetaRight => KeyLocation::Right,
+
+        NumLock => KeyLocation::Numpad,
+        Numpad0 => KeyLocation::Numpad,
+        Numpad1 => KeyLocation::Numpad,
+        Numpad2 => KeyLocation::Numpad,
+        Numpad3 => KeyLocation::Numpad,
+        Numpad4 => KeyLocation::Numpad,
+        Numpad5 => KeyLocation::Numpad,
+        Numpad6 => KeyLocation::Numpad,
+        Numpad7 => KeyLocation::Numpad,
+        Numpad8 => KeyLocation::Numpad,
+        Numpad9 => KeyLocation::Numpad,
+        NumpadDivide => KeyLocation::Numpad,
+        NumpadMultiply => KeyLocation::Numpad,
+        NumpadSubtract => KeyLocation::Numpad,
+        NumpadAdd => KeyLocation::Numpad,
+        NumpadDot => KeyLocation::Numpad,
+        NumpadComma => KeyLocation::Numpad,
+        NumpadEnter => KeyLocation::Numpad,
+        NumpadEquals => KeyLocation::Numpad,
+        NumpadLeftParen => KeyLocation::Numpad,
+        NumpadRightParen => KeyLocation::Numpad,
+
+        _ => KeyLocation::Standard,
+    }
+}
--- a/src/platform_impl/android/mod.rs
+++ b/src/platform_impl/android/mod.rs
@@ -23,179 +23,18 @@ use crate::platform_impl::Fullscreen;
 use crate::{
    dpi::{PhysicalPosition, PhysicalSize, Position, Size},
    error,
-    event::{self, StartCause, VirtualKeyCode},
+    event::{self, StartCause},
    event_loop::{self, ControlFlow, EventLoopWindowTarget as RootELW},
+    keyboard::NativeKey,
    window::{
        self, CursorGrabMode, ImePurpose, ResizeDirection, Theme, WindowButtons, WindowLevel,
    },
 };

+mod keycodes;
+
 static HAS_FOCUS: Lazy<RwLock<bool>> = Lazy::new(|| RwLock::new(true));

-fn ndk_keycode_to_virtualkeycode(keycode: Keycode) -> Option<event::VirtualKeyCode> {
-    match keycode {
-        Keycode::A => Some(VirtualKeyCode::A),
-        Keycode::B => Some(VirtualKeyCode::B),
-        Keycode::C => Some(VirtualKeyCode::C),
-        Keycode::D => Some(VirtualKeyCode::D),
-        Keycode::E => Some(VirtualKeyCode::E),
-        Keycode::F => Some(VirtualKeyCode::F),
-        Keycode::G => Some(VirtualKeyCode::G),
-        Keycode::H => Some(VirtualKeyCode::H),
-        Keycode::I => Some(VirtualKeyCode::I),
-        Keycode::J => Some(VirtualKeyCode::J),
-        Keycode::K => Some(VirtualKeyCode::K),
-        Keycode::L => Some(VirtualKeyCode::L),
-        Keycode::M => Some(VirtualKeyCode::M),
-        Keycode::N => Some(VirtualKeyCode::N),
-        Keycode::O => Some(VirtualKeyCode::O),
-        Keycode::P => Some(VirtualKeyCode::P),
-        Keycode::Q => Some(VirtualKeyCode::Q),
-        Keycode::R => Some(VirtualKeyCode::R),
-        Keycode::S => Some(VirtualKeyCode::S),
-        Keycode::T => Some(VirtualKeyCode::T),
-        Keycode::U => Some(VirtualKeyCode::U),
-        Keycode::V => Some(VirtualKeyCode::V),
-        Keycode::W => Some(VirtualKeyCode::W),
-        Keycode::X => Some(VirtualKeyCode::X),
-        Keycode::Y => Some(VirtualKeyCode::Y),
-        Keycode::Z => Some(VirtualKeyCode::Z),
-
-        Keycode::Keycode0 => Some(VirtualKeyCode::Key0),
-        Keycode::Keycode1 => Some(VirtualKeyCode::Key1),
-        Keycode::Keycode2 => Some(VirtualKeyCode::Key2),
-        Keycode::Keycode3 => Some(VirtualKeyCode::Key3),
-        Keycode::Keycode4 => Some(VirtualKeyCode::Key4),
-        Keycode::Keycode5 => Some(VirtualKeyCode::Key5),
-        Keycode::Keycode6 => Some(VirtualKeyCode::Key6),
-        Keycode::Keycode7 => Some(VirtualKeyCode::Key7),
-        Keycode::Keycode8 => Some(VirtualKeyCode::Key8),
-        Keycode::Keycode9 => Some(VirtualKeyCode::Key9),
-
-        Keycode::Numpad0 => Some(VirtualKeyCode::Numpad0),
-        Keycode::Numpad1 => Some(VirtualKeyCode::Numpad1),
-        Keycode::Numpad2 => Some(VirtualKeyCode::Numpad2),
-        Keycode::Numpad3 => Some(VirtualKeyCode::Numpad3),
-        Keycode::Numpad4 => Some(VirtualKeyCode::Numpad4),
-        Keycode::Numpad5 => Some(VirtualKeyCode::Numpad5),
-        Keycode::Numpad6 => Some(VirtualKeyCode::Numpad6),
-        Keycode::Numpad7 => Some(VirtualKeyCode::Numpad7),
-        Keycode::Numpad8 => Some(VirtualKeyCode::Numpad8),
-        Keycode::Numpad9 => Some(VirtualKeyCode::Numpad9),
-
-        Keycode::NumpadAdd => Some(VirtualKeyCode::NumpadAdd),
-        Keycode::NumpadSubtract => Some(VirtualKeyCode::NumpadSubtract),
-        Keycode::NumpadMultiply => Some(VirtualKeyCode::NumpadMultiply),
-        Keycode::NumpadDivide => Some(VirtualKeyCode::NumpadDivide),
-        Keycode::NumpadEnter => Some(VirtualKeyCode::NumpadEnter),
-        Keycode::NumpadEquals => Some(VirtualKeyCode::NumpadEquals),
-        Keycode::NumpadComma => Some(VirtualKeyCode::NumpadComma),
-        Keycode::NumpadDot => Some(VirtualKeyCode::NumpadDecimal),
-        Keycode::NumLock => Some(VirtualKeyCode::Numlock),
-
-        Keycode::DpadLeft => Some(VirtualKeyCode::Left),
-        Keycode::DpadRight => Some(VirtualKeyCode::Right),
-        Keycode::DpadUp => Some(VirtualKeyCode::Up),
-        Keycode::DpadDown => Some(VirtualKeyCode::Down),
-
-        Keycode::F1 => Some(VirtualKeyCode::F1),
-        Keycode::F2 => Some(VirtualKeyCode::F2),
-        Keycode::F3 => Some(VirtualKeyCode::F3),
-        Keycode::F4 => Some(VirtualKeyCode::F4),
-        Keycode::F5 => Some(VirtualKeyCode::F5),
-        Keycode::F6 => Some(VirtualKeyCode::F6),
-        Keycode::F7 => Some(VirtualKeyCode::F7),
-        Keycode::F8 => Some(VirtualKeyCode::F8),
-        Keycode::F9 => Some(VirtualKeyCode::F9),
-        Keycode::F10 => Some(VirtualKeyCode::F10),
-        Keycode::F11 => Some(VirtualKeyCode::F11),
-        Keycode::F12 => Some(VirtualKeyCode::F12),
-
-        Keycode::Space => Some(VirtualKeyCode::Space),
-        Keycode::Escape => Some(VirtualKeyCode::Escape),
-        Keycode::Enter => Some(VirtualKeyCode::Return), // not on the Numpad
-        Keycode::Tab => Some(VirtualKeyCode::Tab),
-
-        Keycode::PageUp => Some(VirtualKeyCode::PageUp),
-        Keycode::PageDown => Some(VirtualKeyCode::PageDown),
-        Keycode::MoveHome => Some(VirtualKeyCode::Home),
-        Keycode::MoveEnd => Some(VirtualKeyCode::End),
-        Keycode::Insert => Some(VirtualKeyCode::Insert),
-
-        Keycode::Del => Some(VirtualKeyCode::Back), // Backspace (above Enter)
-        Keycode::ForwardDel => Some(VirtualKeyCode::Delete), // Delete (below Insert)
-
-        Keycode::Copy => Some(VirtualKeyCode::Copy),
-        Keycode::Paste => Some(VirtualKeyCode::Paste),
-        Keycode::Cut => Some(VirtualKeyCode::Cut),
-
-        Keycode::VolumeUp => Some(VirtualKeyCode::VolumeUp),
-        Keycode::VolumeDown => Some(VirtualKeyCode::VolumeDown),
-        Keycode::VolumeMute => Some(VirtualKeyCode::Mute), // ???
-        Keycode::Mute => Some(VirtualKeyCode::Mute),       // ???
-        Keycode::MediaPlayPause => Some(VirtualKeyCode::PlayPause),
-        Keycode::MediaStop => Some(VirtualKeyCode::MediaStop), // ??? simple "Stop"?
-        Keycode::MediaNext => Some(VirtualKeyCode::NextTrack),
-        Keycode::MediaPrevious => Some(VirtualKeyCode::PrevTrack),
-
-        Keycode::Plus => Some(VirtualKeyCode::Plus),
-        Keycode::Minus => Some(VirtualKeyCode::Minus),
-        Keycode::Equals => Some(VirtualKeyCode::Equals),
-        Keycode::Semicolon => Some(VirtualKeyCode::Semicolon),
-        Keycode::Slash => Some(VirtualKeyCode::Slash),
-        Keycode::Backslash => Some(VirtualKeyCode::Backslash),
-        Keycode::Comma => Some(VirtualKeyCode::Comma),
-        Keycode::Period => Some(VirtualKeyCode::Period),
-        Keycode::Apostrophe => Some(VirtualKeyCode::Apostrophe),
-        Keycode::Grave => Some(VirtualKeyCode::Grave),
-        Keycode::At => Some(VirtualKeyCode::At),
-
-        // TODO: Maybe mapping this to Snapshot makes more sense? See: "PrtScr/SysRq"
-        Keycode::Sysrq => Some(VirtualKeyCode::Sysrq),
-        // These are usually the same (Pause/Break)
-        Keycode::Break => Some(VirtualKeyCode::Pause),
-        // These are exactly the same
-        Keycode::ScrollLock => Some(VirtualKeyCode::Scroll),
-
-        Keycode::Yen => Some(VirtualKeyCode::Yen),
-        Keycode::Kana => Some(VirtualKeyCode::Kana),
-
-        Keycode::CtrlLeft => Some(VirtualKeyCode::LControl),
-        Keycode::CtrlRight => Some(VirtualKeyCode::RControl),
-
-        Keycode::ShiftLeft => Some(VirtualKeyCode::LShift),
-        Keycode::ShiftRight => Some(VirtualKeyCode::RShift),
-
-        Keycode::AltLeft => Some(VirtualKeyCode::LAlt),
-        Keycode::AltRight => Some(VirtualKeyCode::RAlt),
-
-        // Different names for the same keys
-        Keycode::MetaLeft => Some(VirtualKeyCode::LWin),
-        Keycode::MetaRight => Some(VirtualKeyCode::RWin),
-
-        Keycode::LeftBracket => Some(VirtualKeyCode::LBracket),
-        Keycode::RightBracket => Some(VirtualKeyCode::RBracket),
-
-        Keycode::Power => Some(VirtualKeyCode::Power),
-        Keycode::Sleep => Some(VirtualKeyCode::Sleep), // what about SoftSleep?
-        Keycode::Wakeup => Some(VirtualKeyCode::Wake),
-
-        Keycode::NavigateNext => Some(VirtualKeyCode::NavigateForward),
-        Keycode::NavigatePrevious => Some(VirtualKeyCode::NavigateBackward),
-
-        Keycode::Calculator => Some(VirtualKeyCode::Calculator),
-        Keycode::Explorer => Some(VirtualKeyCode::MyComputer), // "close enough"
-        Keycode::Envelope => Some(VirtualKeyCode::Mail),       // "close enough"
-
-        Keycode::Star => Some(VirtualKeyCode::Asterisk), // ???
-        Keycode::AllApps => Some(VirtualKeyCode::Apps),  // ???
-        Keycode::AppSwitch => Some(VirtualKeyCode::Apps), // ???
-        Keycode::Refresh => Some(VirtualKeyCode::WebRefresh), // ???
-
-        _ => None,
-    }
-}
-
 struct PeekableReceiver<T> {
    recv: mpsc::Receiver<T>,
    first: Option<T>,
@@ -287,6 +126,9 @@ impl RedrawRequester {
    }
 }

+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct KeyEventExtra {}
+
 pub struct EventLoop<T: 'static> {
    android_app: AndroidApp,
    window_target: event_loop::EventLoopWindowTarget<T>,
@@ -294,11 +136,22 @@ pub struct EventLoop<T: 'static> {
    user_events_sender: mpsc::Sender<T>,
    user_events_receiver: PeekableReceiver<T>, //must wake looper whenever something gets sent
    running: bool,
+    ignore_volume_keys: bool,
 }

-#[derive(Default, Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub(crate) struct PlatformSpecificEventLoopAttributes {
    pub(crate) android_app: Option<AndroidApp>,
+    pub(crate) ignore_volume_keys: bool,
+}
+
+impl Default for PlatformSpecificEventLoopAttributes {
+    fn default() -> Self {
+        Self {
+            android_app: Default::default(),
+            ignore_volume_keys: true,
+        }
+    }
 }

 fn sticky_exit_callback<T, F>(
@@ -348,6 +201,7 @@ impl<T: 'static> EventLoop<T> {
            user_events_sender,
            user_events_receiver: PeekableReceiver::from_recv(user_events_receiver),
            running: false,
+            ignore_volume_keys: attributes.ignore_volume_keys,
        }
    }

@@ -483,8 +337,8 @@ impl<T: 'static> EventLoop<T> {
        }

        // Process input events
-
        self.android_app.input_events(|event| {
+            let mut input_status = InputStatus::Handled;
            match event {
                InputEvent::MotionEvent(motion_event) => {
                    let window_id = window::WindowId(WindowId);
@@ -551,44 +405,58 @@ impl<T: 'static> EventLoop<T> {
                    }
                }
                InputEvent::KeyEvent(key) => {
-                    let device_id = event::DeviceId(DeviceId);
-
-                    let state = match key.action() {
-                        KeyAction::Down => event::ElementState::Pressed,
-                        KeyAction::Up => event::ElementState::Released,
-                        _ => event::ElementState::Released,
-                    };
-                    #[allow(deprecated)]
-                    let event = event::Event::WindowEvent {
-                        window_id: window::WindowId(WindowId),
-                        event: event::WindowEvent::KeyboardInput {
-                            device_id,
-                            input: event::KeyboardInput {
-                                scancode: key.scan_code() as u32,
-                                state,
-                                virtual_keycode: ndk_keycode_to_virtualkeycode(
-                                    key.key_code(),
-                                ),
-                                modifiers: event::ModifiersState::default(),
-                            },
-                            is_synthetic: false,
+                    match key.key_code() {
+                        // Flag keys related to volume as unhandled. While winit does not have a way for applications
+                        // to configure what keys to flag as handled, this appears to be a good default until winit
+                        // can be configured.
+                        Keycode::VolumeUp |
+                        Keycode::VolumeDown |
+                        Keycode::VolumeMute => {
+                            if self.ignore_volume_keys {
+                                input_status = InputStatus::Unhandled
+                            }
                        },
-                    };
-                    sticky_exit_callback(
-                        event,
-                        self.window_target(),
-                        control_flow,
-                        callback
-                    );
+                        keycode => {
+                            let state = match key.action() {
+                                KeyAction::Down => event::ElementState::Pressed,
+                                KeyAction::Up => event::ElementState::Released,
+                                _ => event::ElementState::Released,
+                            };
+
+                            let native = NativeKey::Android(keycode.into());
+                            let logical_key = keycodes::to_logical(keycode, native);
+                            // TODO: maybe use getUnicodeChar to get the logical key
+
+                            let event = event::Event::WindowEvent {
+                                window_id: window::WindowId(WindowId),
+                                event: event::WindowEvent::KeyboardInput {
+                                    device_id: event::DeviceId(DeviceId),
+                                    event: event::KeyEvent {
+                                        state,
+                                        physical_key: keycodes::to_physical_keycode(keycode),
+                                        logical_key,
+                                        location: keycodes::to_location(keycode),
+                                        repeat: key.repeat_count() > 0,
+                                        text: None,
+                                        platform_specific: KeyEventExtra {},
+                                    },
+                                    is_synthetic: false,
+                                },
+                            };
+                            sticky_exit_callback(
+                                event,
+                                self.window_target(),
+                                control_flow,
+                                callback,
+                            );
+                        }
+                    }
                }
                _ => {
                    warn!("Unknown android_activity input event {event:?}")
                }
            }
-
-            // Assume all events are handled, while Winit doesn't currently give a way for
-            // applications to report whether they handled an input event.
-            InputStatus::Handled
+            input_status
        });

        // Empty the user event buffer
@@ -1004,7 +872,7 @@ impl Window {

    pub fn set_window_icon(&self, _window_icon: Option<crate::icon::Icon>) {}

-    pub fn set_ime_position(&self, _position: Position) {}
+    pub fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}

    pub fn set_ime_allowed(&self, _allowed: bool) {}

@@ -1084,6 +952,8 @@ impl Window {
    pub fn title(&self) -> String {
        String::new()
    }
+
+    pub fn reset_dead_keys(&self) {}
 }

 #[derive(Default, Clone, Debug)]
--- a/src/platform_impl/ios/mod.rs
+++ b/src/platform_impl/ios/mod.rs
@@ -107,6 +107,9 @@ impl DeviceId {
 unsafe impl Send for DeviceId {}
 unsafe impl Sync for DeviceId {}

+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct KeyEventExtra {}
+
 #[derive(Debug)]
 pub enum OsError {}

--- a/src/platform_impl/ios/uikit/view_controller.rs
+++ b/src/platform_impl/ios/uikit/view_controller.rs
@@ -39,6 +39,7 @@ extern_methods!(
 );

 bitflags! {
+    #[derive(Clone, Copy)]
    pub struct UIInterfaceOrientationMask: NSUInteger {
        const Portrait = 1 << 1;
        const PortraitUpsideDown = 1 << 2;
--- a/src/platform_impl/ios/window.rs
+++ b/src/platform_impl/ios/window.rs
@@ -295,8 +295,8 @@ impl Inner {
        warn!("`Window::set_window_icon` is ignored on iOS")
    }

-    pub fn set_ime_position(&self, _position: Position) {
-        warn!("`Window::set_ime_position` is ignored on iOS")
+    pub fn set_ime_cursor_area(&self, _position: Position, _size: Size) {
+        warn!("`Window::set_ime_cursor_area` is ignored on iOS")
    }

    pub fn set_ime_allowed(&self, _allowed: bool) {
@@ -368,6 +368,10 @@ impl Inner {
        warn!("`Window::title` is ignored on iOS");
        String::new()
    }
+
+    pub fn reset_dead_keys(&self) {
+        // Noop
+    }
 }

 pub struct Window {
--- a/src/platform_impl/linux/common/keymap.rs
+++ b/src/platform_impl/linux/common/keymap.rs
@@ -0,0 +1,887 @@
+//! Convert XKB keys to Winit keys.
+
+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_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) -> 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,
+    // I can only hope they agree on what the keycodes mean.
+    //
+    // 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.
+    match scancode {
+        0 => KeyCode::Unidentified(NativeKeyCode::Xkb(0)),
+        1 => KeyCode::Escape,
+        2 => KeyCode::Digit1,
+        3 => KeyCode::Digit2,
+        4 => KeyCode::Digit3,
+        5 => KeyCode::Digit4,
+        6 => KeyCode::Digit5,
+        7 => KeyCode::Digit6,
+        8 => KeyCode::Digit7,
+        9 => KeyCode::Digit8,
+        10 => KeyCode::Digit9,
+        11 => KeyCode::Digit0,
+        12 => KeyCode::Minus,
+        13 => KeyCode::Equal,
+        14 => KeyCode::Backspace,
+        15 => KeyCode::Tab,
+        16 => KeyCode::KeyQ,
+        17 => KeyCode::KeyW,
+        18 => KeyCode::KeyE,
+        19 => KeyCode::KeyR,
+        20 => KeyCode::KeyT,
+        21 => KeyCode::KeyY,
+        22 => KeyCode::KeyU,
+        23 => KeyCode::KeyI,
+        24 => KeyCode::KeyO,
+        25 => KeyCode::KeyP,
+        26 => KeyCode::BracketLeft,
+        27 => KeyCode::BracketRight,
+        28 => KeyCode::Enter,
+        29 => KeyCode::ControlLeft,
+        30 => KeyCode::KeyA,
+        31 => KeyCode::KeyS,
+        32 => KeyCode::KeyD,
+        33 => KeyCode::KeyF,
+        34 => KeyCode::KeyG,
+        35 => KeyCode::KeyH,
+        36 => KeyCode::KeyJ,
+        37 => KeyCode::KeyK,
+        38 => KeyCode::KeyL,
+        39 => KeyCode::Semicolon,
+        40 => KeyCode::Quote,
+        41 => KeyCode::Backquote,
+        42 => KeyCode::ShiftLeft,
+        43 => KeyCode::Backslash,
+        44 => KeyCode::KeyZ,
+        45 => KeyCode::KeyX,
+        46 => KeyCode::KeyC,
+        47 => KeyCode::KeyV,
+        48 => KeyCode::KeyB,
+        49 => KeyCode::KeyN,
+        50 => KeyCode::KeyM,
+        51 => KeyCode::Comma,
+        52 => KeyCode::Period,
+        53 => KeyCode::Slash,
+        54 => KeyCode::ShiftRight,
+        55 => KeyCode::NumpadMultiply,
+        56 => KeyCode::AltLeft,
+        57 => KeyCode::Space,
+        58 => KeyCode::CapsLock,
+        59 => KeyCode::F1,
+        60 => KeyCode::F2,
+        61 => KeyCode::F3,
+        62 => KeyCode::F4,
+        63 => KeyCode::F5,
+        64 => KeyCode::F6,
+        65 => KeyCode::F7,
+        66 => KeyCode::F8,
+        67 => KeyCode::F9,
+        68 => KeyCode::F10,
+        69 => KeyCode::NumLock,
+        70 => KeyCode::ScrollLock,
+        71 => KeyCode::Numpad7,
+        72 => KeyCode::Numpad8,
+        73 => KeyCode::Numpad9,
+        74 => KeyCode::NumpadSubtract,
+        75 => KeyCode::Numpad4,
+        76 => KeyCode::Numpad5,
+        77 => KeyCode::Numpad6,
+        78 => KeyCode::NumpadAdd,
+        79 => KeyCode::Numpad1,
+        80 => KeyCode::Numpad2,
+        81 => KeyCode::Numpad3,
+        82 => KeyCode::Numpad0,
+        83 => KeyCode::NumpadDecimal,
+        85 => KeyCode::Lang5,
+        86 => KeyCode::IntlBackslash,
+        87 => KeyCode::F11,
+        88 => KeyCode::F12,
+        89 => KeyCode::IntlRo,
+        90 => KeyCode::Lang3,
+        91 => KeyCode::Lang4,
+        92 => KeyCode::Convert,
+        93 => KeyCode::KanaMode,
+        94 => KeyCode::NonConvert,
+        // 95 => KeyCode::KPJPCOMMA,
+        96 => KeyCode::NumpadEnter,
+        97 => KeyCode::ControlRight,
+        98 => KeyCode::NumpadDivide,
+        99 => KeyCode::PrintScreen,
+        100 => KeyCode::AltRight,
+        // 101 => KeyCode::LINEFEED,
+        102 => KeyCode::Home,
+        103 => KeyCode::ArrowUp,
+        104 => KeyCode::PageUp,
+        105 => KeyCode::ArrowLeft,
+        106 => KeyCode::ArrowRight,
+        107 => KeyCode::End,
+        108 => KeyCode::ArrowDown,
+        109 => KeyCode::PageDown,
+        110 => KeyCode::Insert,
+        111 => KeyCode::Delete,
+        // 112 => KeyCode::MACRO,
+        113 => KeyCode::AudioVolumeMute,
+        114 => KeyCode::AudioVolumeDown,
+        115 => KeyCode::AudioVolumeUp,
+        // 116 => KeyCode::POWER,
+        117 => KeyCode::NumpadEqual,
+        // 118 => KeyCode::KPPLUSMINUS,
+        119 => KeyCode::Pause,
+        // 120 => KeyCode::SCALE,
+        121 => KeyCode::NumpadComma,
+        122 => KeyCode::Lang1,
+        123 => KeyCode::Lang2,
+        124 => KeyCode::IntlYen,
+        125 => KeyCode::SuperLeft,
+        126 => KeyCode::SuperRight,
+        127 => KeyCode::ContextMenu,
+        // 128 => KeyCode::STOP,
+        // 129 => KeyCode::AGAIN,
+        // 130 => KeyCode::PROPS,
+        // 131 => KeyCode::UNDO,
+        // 132 => KeyCode::FRONT,
+        // 133 => KeyCode::COPY,
+        // 134 => KeyCode::OPEN,
+        // 135 => KeyCode::PASTE,
+        // 136 => KeyCode::FIND,
+        // 137 => KeyCode::CUT,
+        // 138 => KeyCode::HELP,
+        // 139 => KeyCode::MENU,
+        // 140 => KeyCode::CALC,
+        // 141 => KeyCode::SETUP,
+        // 142 => KeyCode::SLEEP,
+        // 143 => KeyCode::WAKEUP,
+        // 144 => KeyCode::FILE,
+        // 145 => KeyCode::SENDFILE,
+        // 146 => KeyCode::DELETEFILE,
+        // 147 => KeyCode::XFER,
+        // 148 => KeyCode::PROG1,
+        // 149 => KeyCode::PROG2,
+        // 150 => KeyCode::WWW,
+        // 151 => KeyCode::MSDOS,
+        // 152 => KeyCode::COFFEE,
+        // 153 => KeyCode::ROTATE_DISPLAY,
+        // 154 => KeyCode::CYCLEWINDOWS,
+        // 155 => KeyCode::MAIL,
+        // 156 => KeyCode::BOOKMARKS,
+        // 157 => KeyCode::COMPUTER,
+        // 158 => KeyCode::BACK,
+        // 159 => KeyCode::FORWARD,
+        // 160 => KeyCode::CLOSECD,
+        // 161 => KeyCode::EJECTCD,
+        // 162 => KeyCode::EJECTCLOSECD,
+        163 => KeyCode::MediaTrackNext,
+        164 => KeyCode::MediaPlayPause,
+        165 => KeyCode::MediaTrackPrevious,
+        166 => KeyCode::MediaStop,
+        // 167 => KeyCode::RECORD,
+        // 168 => KeyCode::REWIND,
+        // 169 => KeyCode::PHONE,
+        // 170 => KeyCode::ISO,
+        // 171 => KeyCode::CONFIG,
+        // 172 => KeyCode::HOMEPAGE,
+        // 173 => KeyCode::REFRESH,
+        // 174 => KeyCode::EXIT,
+        // 175 => KeyCode::MOVE,
+        // 176 => KeyCode::EDIT,
+        // 177 => KeyCode::SCROLLUP,
+        // 178 => KeyCode::SCROLLDOWN,
+        // 179 => KeyCode::KPLEFTPAREN,
+        // 180 => KeyCode::KPRIGHTPAREN,
+        // 181 => KeyCode::NEW,
+        // 182 => KeyCode::REDO,
+        183 => KeyCode::F13,
+        184 => KeyCode::F14,
+        185 => KeyCode::F15,
+        186 => KeyCode::F16,
+        187 => KeyCode::F17,
+        188 => KeyCode::F18,
+        189 => KeyCode::F19,
+        190 => KeyCode::F20,
+        191 => KeyCode::F21,
+        192 => KeyCode::F22,
+        193 => KeyCode::F23,
+        194 => KeyCode::F24,
+        // 200 => KeyCode::PLAYCD,
+        // 201 => KeyCode::PAUSECD,
+        // 202 => KeyCode::PROG3,
+        // 203 => KeyCode::PROG4,
+        // 204 => KeyCode::DASHBOARD,
+        // 205 => KeyCode::SUSPEND,
+        // 206 => KeyCode::CLOSE,
+        // 207 => KeyCode::PLAY,
+        // 208 => KeyCode::FASTFORWARD,
+        // 209 => KeyCode::BASSBOOST,
+        // 210 => KeyCode::PRINT,
+        // 211 => KeyCode::HP,
+        // 212 => KeyCode::CAMERA,
+        // 213 => KeyCode::SOUND,
+        // 214 => KeyCode::QUESTION,
+        // 215 => KeyCode::EMAIL,
+        // 216 => KeyCode::CHAT,
+        // 217 => KeyCode::SEARCH,
+        // 218 => KeyCode::CONNECT,
+        // 219 => KeyCode::FINANCE,
+        // 220 => KeyCode::SPORT,
+        // 221 => KeyCode::SHOP,
+        // 222 => KeyCode::ALTERASE,
+        // 223 => KeyCode::CANCEL,
+        // 224 => KeyCode::BRIGHTNESSDOW,
+        // 225 => KeyCode::BRIGHTNESSU,
+        // 226 => KeyCode::MEDIA,
+        // 227 => KeyCode::SWITCHVIDEOMODE,
+        // 228 => KeyCode::KBDILLUMTOGGLE,
+        // 229 => KeyCode::KBDILLUMDOWN,
+        // 230 => KeyCode::KBDILLUMUP,
+        // 231 => KeyCode::SEND,
+        // 232 => KeyCode::REPLY,
+        // 233 => KeyCode::FORWARDMAIL,
+        // 234 => KeyCode::SAVE,
+        // 235 => KeyCode::DOCUMENTS,
+        // 236 => KeyCode::BATTERY,
+        // 237 => KeyCode::BLUETOOTH,
+        // 238 => KeyCode::WLAN,
+        // 239 => KeyCode::UWB,
+        240 => KeyCode::Unidentified(NativeKeyCode::Unidentified),
+        // 241 => KeyCode::VIDEO_NEXT,
+        // 242 => KeyCode::VIDEO_PREV,
+        // 243 => KeyCode::BRIGHTNESS_CYCLE,
+        // 244 => KeyCode::BRIGHTNESS_AUTO,
+        // 245 => KeyCode::DISPLAY_OFF,
+        // 246 => KeyCode::WWAN,
+        // 247 => KeyCode::RFKILL,
+        // 248 => KeyCode::KEY_MICMUTE,
+        _ => KeyCode::Unidentified(NativeKeyCode::Xkb(scancode)),
+    }
+}
+
+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),
+        KeyCode::Digit3 => Some(4),
+        KeyCode::Digit4 => Some(5),
+        KeyCode::Digit5 => Some(6),
+        KeyCode::Digit6 => Some(7),
+        KeyCode::Digit7 => Some(8),
+        KeyCode::Digit8 => Some(9),
+        KeyCode::Digit9 => Some(10),
+        KeyCode::Digit0 => Some(11),
+        KeyCode::Minus => Some(12),
+        KeyCode::Equal => Some(13),
+        KeyCode::Backspace => Some(14),
+        KeyCode::Tab => Some(15),
+        KeyCode::KeyQ => Some(16),
+        KeyCode::KeyW => Some(17),
+        KeyCode::KeyE => Some(18),
+        KeyCode::KeyR => Some(19),
+        KeyCode::KeyT => Some(20),
+        KeyCode::KeyY => Some(21),
+        KeyCode::KeyU => Some(22),
+        KeyCode::KeyI => Some(23),
+        KeyCode::KeyO => Some(24),
+        KeyCode::KeyP => Some(25),
+        KeyCode::BracketLeft => Some(26),
+        KeyCode::BracketRight => Some(27),
+        KeyCode::Enter => Some(28),
+        KeyCode::ControlLeft => Some(29),
+        KeyCode::KeyA => Some(30),
+        KeyCode::KeyS => Some(31),
+        KeyCode::KeyD => Some(32),
+        KeyCode::KeyF => Some(33),
+        KeyCode::KeyG => Some(34),
+        KeyCode::KeyH => Some(35),
+        KeyCode::KeyJ => Some(36),
+        KeyCode::KeyK => Some(37),
+        KeyCode::KeyL => Some(38),
+        KeyCode::Semicolon => Some(39),
+        KeyCode::Quote => Some(40),
+        KeyCode::Backquote => Some(41),
+        KeyCode::ShiftLeft => Some(42),
+        KeyCode::Backslash => Some(43),
+        KeyCode::KeyZ => Some(44),
+        KeyCode::KeyX => Some(45),
+        KeyCode::KeyC => Some(46),
+        KeyCode::KeyV => Some(47),
+        KeyCode::KeyB => Some(48),
+        KeyCode::KeyN => Some(49),
+        KeyCode::KeyM => Some(50),
+        KeyCode::Comma => Some(51),
+        KeyCode::Period => Some(52),
+        KeyCode::Slash => Some(53),
+        KeyCode::ShiftRight => Some(54),
+        KeyCode::NumpadMultiply => Some(55),
+        KeyCode::AltLeft => Some(56),
+        KeyCode::Space => Some(57),
+        KeyCode::CapsLock => Some(58),
+        KeyCode::F1 => Some(59),
+        KeyCode::F2 => Some(60),
+        KeyCode::F3 => Some(61),
+        KeyCode::F4 => Some(62),
+        KeyCode::F5 => Some(63),
+        KeyCode::F6 => Some(64),
+        KeyCode::F7 => Some(65),
+        KeyCode::F8 => Some(66),
+        KeyCode::F9 => Some(67),
+        KeyCode::F10 => Some(68),
+        KeyCode::NumLock => Some(69),
+        KeyCode::ScrollLock => Some(70),
+        KeyCode::Numpad7 => Some(71),
+        KeyCode::Numpad8 => Some(72),
+        KeyCode::Numpad9 => Some(73),
+        KeyCode::NumpadSubtract => Some(74),
+        KeyCode::Numpad4 => Some(75),
+        KeyCode::Numpad5 => Some(76),
+        KeyCode::Numpad6 => Some(77),
+        KeyCode::NumpadAdd => Some(78),
+        KeyCode::Numpad1 => Some(79),
+        KeyCode::Numpad2 => Some(80),
+        KeyCode::Numpad3 => Some(81),
+        KeyCode::Numpad0 => Some(82),
+        KeyCode::NumpadDecimal => Some(83),
+        KeyCode::Lang5 => Some(85),
+        KeyCode::IntlBackslash => Some(86),
+        KeyCode::F11 => Some(87),
+        KeyCode::F12 => Some(88),
+        KeyCode::IntlRo => Some(89),
+        KeyCode::Lang3 => Some(90),
+        KeyCode::Lang4 => Some(91),
+        KeyCode::Convert => Some(92),
+        KeyCode::KanaMode => Some(93),
+        KeyCode::NonConvert => Some(94),
+        KeyCode::NumpadEnter => Some(96),
+        KeyCode::ControlRight => Some(97),
+        KeyCode::NumpadDivide => Some(98),
+        KeyCode::PrintScreen => Some(99),
+        KeyCode::AltRight => Some(100),
+        KeyCode::Home => Some(102),
+        KeyCode::ArrowUp => Some(103),
+        KeyCode::PageUp => Some(104),
+        KeyCode::ArrowLeft => Some(105),
+        KeyCode::ArrowRight => Some(106),
+        KeyCode::End => Some(107),
+        KeyCode::ArrowDown => Some(108),
+        KeyCode::PageDown => Some(109),
+        KeyCode::Insert => Some(110),
+        KeyCode::Delete => Some(111),
+        KeyCode::AudioVolumeMute => Some(113),
+        KeyCode::AudioVolumeDown => Some(114),
+        KeyCode::AudioVolumeUp => Some(115),
+        KeyCode::NumpadEqual => Some(117),
+        KeyCode::Pause => Some(119),
+        KeyCode::NumpadComma => Some(121),
+        KeyCode::Lang1 => Some(122),
+        KeyCode::Lang2 => Some(123),
+        KeyCode::IntlYen => Some(124),
+        KeyCode::SuperLeft => Some(125),
+        KeyCode::SuperRight => Some(126),
+        KeyCode::ContextMenu => Some(127),
+        KeyCode::MediaTrackNext => Some(163),
+        KeyCode::MediaPlayPause => Some(164),
+        KeyCode::MediaTrackPrevious => Some(165),
+        KeyCode::MediaStop => Some(166),
+        KeyCode::F13 => Some(183),
+        KeyCode::F14 => Some(184),
+        KeyCode::F15 => Some(185),
+        KeyCode::F16 => Some(186),
+        KeyCode::F17 => Some(187),
+        KeyCode::F18 => Some(188),
+        KeyCode::F19 => Some(189),
+        KeyCode::F20 => Some(190),
+        KeyCode::F21 => Some(191),
+        KeyCode::F22 => Some(192),
+        KeyCode::F23 => Some(193),
+        KeyCode::F24 => Some(194),
+        _ => None,
+    }
+}
+
+pub fn keysym_to_key(keysym: u32) -> Key {
+    use xkbcommon_dl::keysyms;
+    match keysym {
+        // TTY function keys
+        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 => Key::Compose,
+        keysyms::Codeinput => Key::CodeInput,
+        keysyms::SingleCandidate => Key::SingleCandidate,
+        keysyms::MultipleCandidate => Key::AllCandidates,
+        keysyms::PreviousCandidate => Key::PreviousCandidate,
+
+        // Japanese keys
+        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 => Key::CodeInput,
+        // keysyms::Zen_Koho => Key::AllCandidates,
+        // keysyms::Mae_Koho => Key::PreviousCandidate,
+
+        // Cursor control & motion
+        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 => 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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
+
+        // dead_lowline..dead_longsolidusoverlay
+
+        // dead_a..dead_capital_schwa
+
+        // dead_greek
+
+        // First_Virtual_Screen..Terminate_Server
+
+        // AccessX_Enable..AudibleBell_Enable
+
+        // Pointer_Left..Pointer_Drag5
+
+        // Pointer_EnableKeys..Pointer_DfltBtnPrev
+
+        // ch..C_H
+
+        // 3270 terminal keys
+        // 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 => Key::Space,
+        // exclam..Sinh_kunddaliya
+
+        // XFree86
+        // keysyms::XF86_ModeLock => Key::ModeLock,
+
+        // XFree86 - Backlight controls
+        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 => 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 => 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 => 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 => Key::LaunchApplication2, // Nice typo, libxkbcommon :)
+        // XF86_Clear
+        keysyms::XF86_Close => Key::Close,
+        keysyms::XF86_Copy => Key::Copy,
+        keysyms::XF86_Cut => Key::Cut,
+        // XF86_Display..XF86_Documents
+        keysyms::XF86_Excel => Key::LaunchSpreadsheet,
+        // XF86_Explorer..XF86iTouch
+        keysyms::XF86_LogOff => Key::LogOff,
+        // XF86_Market..XF86_MenuPB
+        keysyms::XF86_MySites => Key::BrowserFavorites,
+        keysyms::XF86_New => Key::New,
+        // XF86_News..XF86_OfficeHome
+        keysyms::XF86_Open => Key::Open,
+        // XF86_Option
+        keysyms::XF86_Paste => Key::Paste,
+        keysyms::XF86_Phone => Key::LaunchPhone,
+        // XF86_Q
+        keysyms::XF86_Reply => Key::MailReply,
+        keysyms::XF86_Reload => Key::BrowserRefresh,
+        // XF86_RotateWindows..XF86_RotationKB
+        keysyms::XF86_Save => Key::Save,
+        // XF86_ScrollUp..XF86_ScrollClick
+        keysyms::XF86_Send => Key::MailSend,
+        keysyms::XF86_Spell => Key::SpellCheck,
+        keysyms::XF86_SplitScreen => Key::SplitScreenToggle,
+        // XF86_Support..XF86_User2KB
+        keysyms::XF86_Video => Key::LaunchMediaPlayer,
+        // XF86_WheelButton
+        keysyms::XF86_Word => Key::LaunchWordProcessor,
+        // XF86_Xfer
+        keysyms::XF86_ZoomIn => Key::ZoomIn,
+        keysyms::XF86_ZoomOut => Key::ZoomOut,
+
+        // XF86_Away..XF86_Messenger
+        keysyms::XF86_WebCam => Key::LaunchWebCam,
+        keysyms::XF86_MailForward => Key::MailForward,
+        // XF86_Pictures
+        keysyms::XF86_Music => Key::LaunchMusicPlayer,
+
+        // XF86_Battery..XF86_UWB
+        //
+        keysyms::XF86_AudioForward => Key::MediaFastForward,
+        // XF86_AudioRepeat
+        keysyms::XF86_AudioRandomPlay => Key::RandomToggle,
+        keysyms::XF86_Subtitle => Key::Subtitle,
+        keysyms::XF86_AudioCycleTrack => Key::MediaAudioTrack,
+        // XF86_CycleAngle..XF86_Blue
+        //
+        keysyms::XF86_Suspend => Key::Standby,
+        keysyms::XF86_Hibernate => Key::Hibernate,
+        // XF86_TouchpadToggle..XF86_TouchpadOff
+        //
+        keysyms::XF86_AudioMute => Key::AudioVolumeMute,
+
+        // XF86_Switch_VT_1..XF86_Switch_VT_12
+
+        // XF86_Ungrab..XF86_ClearGrab
+        keysyms::XF86_Next_VMode => Key::VideoModeNext,
+        // keysyms::XF86_Prev_VMode => Key::VideoModePrevious,
+        // XF86_LogWindowTree..XF86_LogGrabInfo
+
+        // SunFA_Grave..SunFA_Cedilla
+
+        // keysyms::SunF36 => Key::F36 | Key::F11,
+        // keysyms::SunF37 => Key::F37 | Key::F12,
+
+        // keysyms::SunSys_Req => Key::PrintScreen,
+        // The next couple of xkb (until SunStop) are already handled.
+        // SunPrint_Screen..SunPageDown
+
+        // SunUndo..SunFront
+        keysyms::SUN_Copy => Key::Copy,
+        keysyms::SUN_Open => Key::Open,
+        keysyms::SUN_Paste => Key::Paste,
+        keysyms::SUN_Cut => Key::Cut,
+
+        // SunPowerSwitch
+        keysyms::SUN_AudioLowerVolume => Key::AudioVolumeDown,
+        keysyms::SUN_AudioMute => Key::AudioVolumeMute,
+        keysyms::SUN_AudioRaiseVolume => Key::AudioVolumeUp,
+        // SUN_VideoDegauss
+        keysyms::SUN_VideoLowerBrightness => Key::BrightnessDown,
+        keysyms::SUN_VideoRaiseBrightness => Key::BrightnessUp,
+        // SunPowerSwitchShift
+        //
+        0 => Key::Unidentified(NativeKey::Unidentified),
+        _ => Key::Unidentified(NativeKey::Xkb(keysym)),
+    }
+}
+
+pub fn keysym_location(keysym: u32) -> KeyLocation {
+    use xkbcommon_dl::keysyms;
+    match keysym {
+        keysyms::Shift_L
+        | keysyms::Control_L
+        | keysyms::Meta_L
+        | keysyms::Alt_L
+        | keysyms::Super_L
+        | keysyms::Hyper_L => KeyLocation::Left,
+        keysyms::Shift_R
+        | keysyms::Control_R
+        | keysyms::Meta_R
+        | keysyms::Alt_R
+        | keysyms::Super_R
+        | keysyms::Hyper_R => KeyLocation::Right,
+        keysyms::KP_0
+        | keysyms::KP_1
+        | keysyms::KP_2
+        | keysyms::KP_3
+        | keysyms::KP_4
+        | keysyms::KP_5
+        | keysyms::KP_6
+        | keysyms::KP_7
+        | keysyms::KP_8
+        | keysyms::KP_9
+        | keysyms::KP_Space
+        | keysyms::KP_Tab
+        | keysyms::KP_Enter
+        | keysyms::KP_F1
+        | keysyms::KP_F2
+        | keysyms::KP_F3
+        | keysyms::KP_F4
+        | keysyms::KP_Home
+        | keysyms::KP_Left
+        | keysyms::KP_Up
+        | keysyms::KP_Right
+        | keysyms::KP_Down
+        | keysyms::KP_Page_Up
+        | keysyms::KP_Page_Down
+        | keysyms::KP_End
+        | keysyms::KP_Begin
+        | keysyms::KP_Insert
+        | keysyms::KP_Delete
+        | keysyms::KP_Equal
+        | keysyms::KP_Multiply
+        | keysyms::KP_Add
+        | keysyms::KP_Separator
+        | keysyms::KP_Subtract
+        | keysyms::KP_Decimal
+        | keysyms::KP_Divide => KeyLocation::Numpad,
+        _ => KeyLocation::Standard,
+    }
+}
--- a/src/platform_impl/linux/common/mod.rs
+++ b/src/platform_impl/linux/common/mod.rs
@@ -0,0 +1,2 @@
+pub mod keymap;
+pub mod xkb_state;
--- a/src/platform_impl/linux/common/xkb_state.rs
+++ b/src/platform_impl/linux/common/xkb_state.rs
@@ -0,0 +1,677 @@
+use std::convert::TryInto;
+use std::env;
+use std::ffi::CString;
+use std::os::raw::c_char;
+use std::os::unix::ffi::OsStringExt;
+use std::ptr;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use once_cell::sync::Lazy;
+use smol_str::SmolStr;
+use xkbcommon_dl::{
+    self as ffi, xkb_state_component, xkbcommon_compose_handle, xkbcommon_handle, XkbCommon,
+    XkbCommonCompose,
+};
+#[cfg(feature = "wayland")]
+use {memmap2::MmapOptions, wayland_backend::io_lifetimes::OwnedFd};
+#[cfg(feature = "x11")]
+use {x11_dl::xlib_xcb::xcb_connection_t, xkbcommon_dl::x11::xkbcommon_x11_handle};
+
+use crate::event::KeyEvent;
+use crate::platform_impl::common::keymap;
+use crate::platform_impl::KeyEventExtra;
+use crate::{
+    event::ElementState,
+    keyboard::{Key, KeyCode, KeyLocation},
+};
+
+// TODO: Wire this up without using a static `AtomicBool`.
+static RESET_DEAD_KEYS: AtomicBool = AtomicBool::new(false);
+
+#[inline(always)]
+pub fn reset_dead_keys() {
+    RESET_DEAD_KEYS.store(true, Ordering::SeqCst);
+}
+
+static XKBH: Lazy<&'static XkbCommon> = Lazy::new(xkbcommon_handle);
+static XKBCH: Lazy<&'static XkbCommonCompose> = Lazy::new(xkbcommon_compose_handle);
+#[cfg(feature = "x11")]
+static XKBXH: Lazy<&'static ffi::x11::XkbCommonX11> = Lazy::new(xkbcommon_x11_handle);
+
+#[derive(Debug)]
+pub struct KbdState {
+    #[cfg(feature = "x11")]
+    xcb_connection: *mut xcb_connection_t,
+    xkb_context: *mut ffi::xkb_context,
+    xkb_keymap: *mut ffi::xkb_keymap,
+    xkb_state: *mut ffi::xkb_state,
+    xkb_compose_table: *mut ffi::xkb_compose_table,
+    xkb_compose_state: *mut ffi::xkb_compose_state,
+    xkb_compose_state_2: *mut ffi::xkb_compose_state,
+    mods_state: ModifiersState,
+    #[cfg(feature = "x11")]
+    pub core_keyboard_id: i32,
+    scratch_buffer: Vec<u8>,
+}
+
+impl KbdState {
+    pub fn update_modifiers(
+        &mut self,
+        mods_depressed: u32,
+        mods_latched: u32,
+        mods_locked: u32,
+        depressed_group: u32,
+        latched_group: u32,
+        locked_group: u32,
+    ) {
+        if !self.ready() {
+            return;
+        }
+        let mask = unsafe {
+            (XKBH.xkb_state_update_mask)(
+                self.xkb_state,
+                mods_depressed,
+                mods_latched,
+                mods_locked,
+                depressed_group,
+                latched_group,
+                locked_group,
+            )
+        };
+        if mask.contains(xkb_state_component::XKB_STATE_MODS_EFFECTIVE) {
+            // effective value of mods have changed, we need to update our state
+            self.mods_state.update_with(self.xkb_state);
+        }
+    }
+
+    pub fn get_one_sym_raw(&mut self, keycode: u32) -> u32 {
+        if !self.ready() {
+            return 0;
+        }
+        unsafe { (XKBH.xkb_state_key_get_one_sym)(self.xkb_state, keycode) }
+    }
+
+    pub fn get_utf8_raw(&mut self, keycode: u32) -> Option<SmolStr> {
+        if !self.ready() {
+            return None;
+        }
+        let xkb_state = self.xkb_state;
+        self.make_string_with({
+            |ptr, len| unsafe { (XKBH.xkb_state_key_get_utf8)(xkb_state, keycode, ptr, len) }
+        })
+    }
+
+    fn compose_feed_normal(&mut self, keysym: u32) -> Option<ffi::xkb_compose_feed_result> {
+        self.compose_feed(self.xkb_compose_state, keysym)
+    }
+
+    fn compose_feed_2(&mut self, keysym: u32) -> Option<ffi::xkb_compose_feed_result> {
+        self.compose_feed(self.xkb_compose_state_2, keysym)
+    }
+
+    fn compose_feed(
+        &mut self,
+        xkb_compose_state: *mut ffi::xkb_compose_state,
+        keysym: u32,
+    ) -> Option<ffi::xkb_compose_feed_result> {
+        if !self.ready() || self.xkb_compose_state.is_null() {
+            return None;
+        }
+        if RESET_DEAD_KEYS.swap(false, Ordering::SeqCst) {
+            unsafe { self.init_compose() };
+        }
+        Some(unsafe { (XKBCH.xkb_compose_state_feed)(xkb_compose_state, keysym) })
+    }
+
+    fn compose_status_normal(&mut self) -> Option<ffi::xkb_compose_status> {
+        self.compose_status(self.xkb_compose_state)
+    }
+
+    fn compose_status(
+        &mut self,
+        xkb_compose_state: *mut ffi::xkb_compose_state,
+    ) -> Option<ffi::xkb_compose_status> {
+        if !self.ready() || xkb_compose_state.is_null() {
+            return None;
+        }
+        Some(unsafe { (XKBCH.xkb_compose_state_get_status)(xkb_compose_state) })
+    }
+
+    fn compose_get_utf8_normal(&mut self) -> Option<SmolStr> {
+        self.compose_get_utf8(self.xkb_compose_state)
+    }
+
+    fn compose_get_utf8_2(&mut self) -> Option<SmolStr> {
+        self.compose_get_utf8(self.xkb_compose_state_2)
+    }
+
+    fn compose_get_utf8(
+        &mut self,
+        xkb_compose_state: *mut ffi::xkb_compose_state,
+    ) -> Option<SmolStr> {
+        if !self.ready() || xkb_compose_state.is_null() {
+            return None;
+        }
+        self.make_string_with(|ptr, len| unsafe {
+            (XKBCH.xkb_compose_state_get_utf8)(xkb_compose_state, ptr, len)
+        })
+    }
+
+    /// Shared logic for constructing a string with `xkb_compose_state_get_utf8` and
+    /// `xkb_state_key_get_utf8`.
+    fn make_string_with<F>(&mut self, mut f: F) -> Option<SmolStr>
+    where
+        F: FnMut(*mut c_char, usize) -> i32,
+    {
+        let size = f(ptr::null_mut(), 0);
+        if size == 0 {
+            return None;
+        }
+        let size = usize::try_from(size).unwrap();
+        self.scratch_buffer.clear();
+        // The allocated buffer must include space for the null-terminator
+        self.scratch_buffer.reserve(size + 1);
+        unsafe {
+            let written = f(
+                self.scratch_buffer.as_mut_ptr().cast(),
+                self.scratch_buffer.capacity(),
+            );
+            if usize::try_from(written).unwrap() != size {
+                // This will likely never happen
+                return None;
+            }
+            self.scratch_buffer.set_len(size);
+        };
+        byte_slice_to_smol_str(&self.scratch_buffer)
+    }
+
+    pub fn new() -> Result<Self, Error> {
+        if ffi::xkbcommon_option().is_none() {
+            return Err(Error::XKBNotFound);
+        }
+
+        let context =
+            unsafe { (XKBH.xkb_context_new)(ffi::xkb_context_flags::XKB_CONTEXT_NO_FLAGS) };
+        if context.is_null() {
+            return Err(Error::XKBNotFound);
+        }
+
+        let mut me = Self {
+            #[cfg(feature = "x11")]
+            xcb_connection: ptr::null_mut(),
+            xkb_context: context,
+            xkb_keymap: ptr::null_mut(),
+            xkb_state: ptr::null_mut(),
+            xkb_compose_table: ptr::null_mut(),
+            xkb_compose_state: ptr::null_mut(),
+            xkb_compose_state_2: ptr::null_mut(),
+            mods_state: ModifiersState::new(),
+            #[cfg(feature = "x11")]
+            core_keyboard_id: 0,
+            scratch_buffer: Vec::new(),
+        };
+
+        unsafe { me.init_compose() };
+
+        Ok(me)
+    }
+
+    #[cfg(feature = "x11")]
+    pub fn from_x11_xkb(connection: *mut xcb_connection_t) -> Result<Self, Error> {
+        let mut me = Self::new()?;
+        me.xcb_connection = connection;
+
+        let result = unsafe {
+            (XKBXH.xkb_x11_setup_xkb_extension)(
+                connection,
+                1,
+                2,
+                xkbcommon_dl::x11::xkb_x11_setup_xkb_extension_flags::XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS,
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+            )
+        };
+        assert_eq!(result, 1, "Failed to initialize libxkbcommon");
+
+        unsafe { me.init_with_x11_keymap() };
+
+        Ok(me)
+    }
+
+    unsafe fn init_compose(&mut self) {
+        let locale = env::var_os("LC_ALL")
+            .and_then(|v| if v.is_empty() { None } else { Some(v) })
+            .or_else(|| env::var_os("LC_CTYPE"))
+            .and_then(|v| if v.is_empty() { None } else { Some(v) })
+            .or_else(|| env::var_os("LANG"))
+            .and_then(|v| if v.is_empty() { None } else { Some(v) })
+            .unwrap_or_else(|| "C".into());
+        let locale = CString::new(locale.into_vec()).unwrap();
+
+        let compose_table = (XKBCH.xkb_compose_table_new_from_locale)(
+            self.xkb_context,
+            locale.as_ptr(),
+            ffi::xkb_compose_compile_flags::XKB_COMPOSE_COMPILE_NO_FLAGS,
+        );
+
+        if compose_table.is_null() {
+            // init of compose table failed, continue without compose
+            return;
+        }
+
+        let compose_state = (XKBCH.xkb_compose_state_new)(
+            compose_table,
+            ffi::xkb_compose_state_flags::XKB_COMPOSE_STATE_NO_FLAGS,
+        );
+
+        if compose_state.is_null() {
+            // init of compose state failed, continue without compose
+            (XKBCH.xkb_compose_table_unref)(compose_table);
+            return;
+        }
+
+        let compose_state_2 = (XKBCH.xkb_compose_state_new)(
+            compose_table,
+            ffi::xkb_compose_state_flags::XKB_COMPOSE_STATE_NO_FLAGS,
+        );
+
+        if compose_state_2.is_null() {
+            // init of compose state failed, continue without compose
+            (XKBCH.xkb_compose_table_unref)(compose_table);
+            (XKBCH.xkb_compose_state_unref)(compose_state);
+            return;
+        }
+
+        self.xkb_compose_table = compose_table;
+        self.xkb_compose_state = compose_state;
+        self.xkb_compose_state_2 = compose_state_2;
+    }
+
+    unsafe fn post_init(&mut self, state: *mut ffi::xkb_state, keymap: *mut ffi::xkb_keymap) {
+        self.xkb_keymap = keymap;
+        self.xkb_state = state;
+        self.mods_state.update_with(state);
+    }
+
+    unsafe fn de_init(&mut self) {
+        (XKBH.xkb_state_unref)(self.xkb_state);
+        self.xkb_state = ptr::null_mut();
+        (XKBH.xkb_keymap_unref)(self.xkb_keymap);
+        self.xkb_keymap = ptr::null_mut();
+    }
+
+    #[cfg(feature = "x11")]
+    pub unsafe fn init_with_x11_keymap(&mut self) {
+        if !self.xkb_keymap.is_null() {
+            self.de_init();
+        }
+
+        // TODO: Support keyboards other than the "virtual core keyboard device".
+        self.core_keyboard_id = (XKBXH.xkb_x11_get_core_keyboard_device_id)(self.xcb_connection);
+        let keymap = (XKBXH.xkb_x11_keymap_new_from_device)(
+            self.xkb_context,
+            self.xcb_connection,
+            self.core_keyboard_id,
+            xkbcommon_dl::xkb_keymap_compile_flags::XKB_KEYMAP_COMPILE_NO_FLAGS,
+        );
+        if keymap.is_null() {
+            panic!("Failed to get keymap from X11 server.");
+        }
+
+        let state = (XKBXH.xkb_x11_state_new_from_device)(
+            keymap,
+            self.xcb_connection,
+            self.core_keyboard_id,
+        );
+        self.post_init(state, keymap);
+    }
+
+    #[cfg(feature = "wayland")]
+    pub unsafe fn init_with_fd(&mut self, fd: OwnedFd, size: usize) {
+        if !self.xkb_keymap.is_null() {
+            self.de_init();
+        }
+
+        let map = MmapOptions::new()
+            .len(size)
+            .map_copy_read_only(&fd)
+            .unwrap();
+
+        let keymap = (XKBH.xkb_keymap_new_from_string)(
+            self.xkb_context,
+            map.as_ptr() as *const _,
+            ffi::xkb_keymap_format::XKB_KEYMAP_FORMAT_TEXT_V1,
+            ffi::xkb_keymap_compile_flags::XKB_KEYMAP_COMPILE_NO_FLAGS,
+        );
+
+        if keymap.is_null() {
+            panic!("Received invalid keymap from compositor.");
+        }
+
+        let state = (XKBH.xkb_state_new)(keymap);
+        self.post_init(state, keymap);
+    }
+
+    #[cfg(feature = "wayland")]
+    pub fn key_repeats(&mut self, keycode: ffi::xkb_keycode_t) -> bool {
+        unsafe { (XKBH.xkb_keymap_key_repeats)(self.xkb_keymap, keycode) == 1 }
+    }
+
+    #[inline]
+    pub fn ready(&self) -> bool {
+        !self.xkb_state.is_null()
+    }
+
+    #[inline]
+    pub fn mods_state(&self) -> ModifiersState {
+        self.mods_state
+    }
+
+    pub fn process_key_event(
+        &mut self,
+        keycode: u32,
+        state: ElementState,
+        repeat: bool,
+    ) -> KeyEvent {
+        let mut event =
+            KeyEventResults::new(self, keycode, !repeat && state == ElementState::Pressed);
+        let physical_key = event.keycode();
+        let (logical_key, location) = event.key();
+        let text = event.text();
+        let (key_without_modifiers, _) = event.key_without_modifiers();
+        let text_with_all_modifiers = event.text_with_all_modifiers();
+
+        let platform_specific = KeyEventExtra {
+            key_without_modifiers,
+            text_with_all_modifiers,
+        };
+
+        KeyEvent {
+            physical_key,
+            logical_key,
+            text,
+            location,
+            state,
+            repeat,
+            platform_specific,
+        }
+    }
+
+    fn keysym_to_utf8_raw(&mut self, keysym: u32) -> Option<SmolStr> {
+        self.scratch_buffer.clear();
+        self.scratch_buffer.reserve(8);
+        loop {
+            let bytes_written = unsafe {
+                (XKBH.xkb_keysym_to_utf8)(
+                    keysym,
+                    self.scratch_buffer.as_mut_ptr().cast(),
+                    self.scratch_buffer.capacity(),
+                )
+            };
+            if bytes_written == 0 {
+                return None;
+            } else if bytes_written == -1 {
+                self.scratch_buffer.reserve(8);
+            } else {
+                unsafe {
+                    self.scratch_buffer
+                        .set_len(bytes_written.try_into().unwrap())
+                };
+                break;
+            }
+        }
+
+        // Remove the null-terminator
+        self.scratch_buffer.pop();
+        byte_slice_to_smol_str(&self.scratch_buffer)
+    }
+}
+
+impl Drop for KbdState {
+    fn drop(&mut self) {
+        unsafe {
+            if !self.xkb_compose_state.is_null() {
+                (XKBCH.xkb_compose_state_unref)(self.xkb_compose_state);
+            }
+            if !self.xkb_compose_state_2.is_null() {
+                (XKBCH.xkb_compose_state_unref)(self.xkb_compose_state_2);
+            }
+            if !self.xkb_compose_table.is_null() {
+                (XKBCH.xkb_compose_table_unref)(self.xkb_compose_table);
+            }
+            if !self.xkb_state.is_null() {
+                (XKBH.xkb_state_unref)(self.xkb_state);
+            }
+            if !self.xkb_keymap.is_null() {
+                (XKBH.xkb_keymap_unref)(self.xkb_keymap);
+            }
+            (XKBH.xkb_context_unref)(self.xkb_context);
+        }
+    }
+}
+
+struct KeyEventResults<'a> {
+    state: &'a mut KbdState,
+    keycode: u32,
+    keysym: u32,
+    compose: Option<XkbCompose>,
+}
+
+impl<'a> KeyEventResults<'a> {
+    fn new(state: &'a mut KbdState, keycode: u32, compose: bool) -> Self {
+        let keysym = state.get_one_sym_raw(keycode);
+
+        let compose = if compose {
+            Some(match state.compose_feed_normal(keysym) {
+                Some(ffi::xkb_compose_feed_result::XKB_COMPOSE_FEED_ACCEPTED) => {
+                    // Unwrapping is safe here, as `compose_feed` returns `None` when composition is uninitialized.
+                    XkbCompose::Accepted(state.compose_status_normal().unwrap())
+                }
+                Some(ffi::xkb_compose_feed_result::XKB_COMPOSE_FEED_IGNORED) => XkbCompose::Ignored,
+                None => XkbCompose::Uninitialized,
+            })
+        } else {
+            None
+        };
+
+        KeyEventResults {
+            state,
+            keycode,
+            keysym,
+            compose,
+        }
+    }
+
+    fn keycode(&mut self) -> KeyCode {
+        keymap::raw_keycode_to_keycode(self.keycode)
+    }
+
+    pub fn key(&mut self) -> (Key, KeyLocation) {
+        self.keysym_to_key(self.keysym)
+            .unwrap_or_else(|(key, location)| match self.compose {
+                Some(XkbCompose::Accepted(ffi::xkb_compose_status::XKB_COMPOSE_COMPOSING)) => {
+                    // When pressing a dead key twice, the non-combining variant of that character will be
+                    // produced. Since this function only concerns itself with a single keypress, we simulate
+                    // this double press here by feeding the keysym to the compose state twice.
+                    self.state.compose_feed_2(self.keysym);
+                    match self.state.compose_feed_2(self.keysym) {
+                        Some(ffi::xkb_compose_feed_result::XKB_COMPOSE_FEED_ACCEPTED) => (
+                            // Extracting only a single `char` here *should* be fine, assuming that no dead
+                            // key's non-combining variant ever occupies more than one `char`.
+                            Key::Dead(
+                                self.state
+                                    .compose_get_utf8_2()
+                                    .map(|s| s.chars().next().unwrap()),
+                            ),
+                            location,
+                        ),
+                        _ => (key, location),
+                    }
+                }
+                _ => (
+                    self.composed_text()
+                        .unwrap_or_else(|_| self.state.keysym_to_utf8_raw(self.keysym))
+                        .map(Key::Character)
+                        .unwrap_or(key),
+                    location,
+                ),
+            })
+    }
+
+    pub fn key_without_modifiers(&mut self) -> (Key, KeyLocation) {
+        // This will become a pointer to an array which libxkbcommon owns, so we don't need to deallocate it.
+        let mut keysyms = ptr::null();
+        let keysym_count = unsafe {
+            let layout = (XKBH.xkb_state_key_get_layout)(self.state.xkb_state, self.keycode);
+            (XKBH.xkb_keymap_key_get_syms_by_level)(
+                self.state.xkb_keymap,
+                self.keycode,
+                layout,
+                // NOTE: The level should be zero to ignore modifiers.
+                0,
+                &mut keysyms,
+            )
+        };
+        let keysym = if keysym_count == 1 {
+            unsafe { *keysyms }
+        } else {
+            0
+        };
+        self.keysym_to_key(keysym)
+            .unwrap_or_else(|(key, location)| {
+                (
+                    self.state
+                        .keysym_to_utf8_raw(keysym)
+                        .map(Key::Character)
+                        .unwrap_or(key),
+                    location,
+                )
+            })
+    }
+
+    fn keysym_to_key(&mut self, keysym: u32) -> Result<(Key, KeyLocation), (Key, KeyLocation)> {
+        let location = super::keymap::keysym_location(keysym);
+        let key = super::keymap::keysym_to_key(keysym);
+        if matches!(key, Key::Unidentified(_)) {
+            Err((key, location))
+        } else {
+            Ok((key, location))
+        }
+    }
+
+    pub fn text(&mut self) -> Option<SmolStr> {
+        self.composed_text()
+            .unwrap_or_else(|_| self.state.keysym_to_utf8_raw(self.keysym))
+    }
+
+    pub fn text_with_all_modifiers(&mut self) -> Option<SmolStr> {
+        // The current behaviour makes it so composing a character overrides attempts to input a
+        // control character with the `Ctrl` key. We can potentially add a configuration option
+        // if someone specifically wants the oppsite behaviour.
+        self.composed_text()
+            .unwrap_or_else(|_| self.state.get_utf8_raw(self.keycode))
+    }
+
+    fn composed_text(&mut self) -> Result<Option<SmolStr>, ()> {
+        if let Some(compose) = &self.compose {
+            match compose {
+                XkbCompose::Accepted(status) => match status {
+                    ffi::xkb_compose_status::XKB_COMPOSE_COMPOSED => {
+                        Ok(self.state.compose_get_utf8_normal())
+                    }
+                    ffi::xkb_compose_status::XKB_COMPOSE_NOTHING => Err(()),
+                    _ => Ok(None),
+                },
+                XkbCompose::Ignored | XkbCompose::Uninitialized => Err(()),
+            }
+        } else {
+            Err(())
+        }
+    }
+}
+
+/// Represents the current state of the keyboard modifiers
+///
+/// Each field of this struct represents a modifier and is `true` if this modifier is active.
+///
+/// For some modifiers, this means that the key is currently pressed, others are toggled
+/// (like caps lock).
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
+pub struct ModifiersState {
+    /// The "control" key
+    pub ctrl: bool,
+    /// The "alt" key
+    pub alt: bool,
+    /// The "shift" key
+    pub shift: bool,
+    /// The "Caps lock" key
+    pub caps_lock: bool,
+    /// The "logo" key
+    ///
+    /// Also known as the "windows" key on most keyboards
+    pub logo: bool,
+    /// The "Num lock" key
+    pub num_lock: bool,
+}
+
+impl ModifiersState {
+    fn new() -> Self {
+        Self::default()
+    }
+
+    fn update_with(&mut self, state: *mut ffi::xkb_state) {
+        let mod_name_is_active = |mod_name: &[u8]| unsafe {
+            (XKBH.xkb_state_mod_name_is_active)(
+                state,
+                mod_name.as_ptr() as *const c_char,
+                xkb_state_component::XKB_STATE_MODS_EFFECTIVE,
+            ) > 0
+        };
+        self.ctrl = mod_name_is_active(ffi::XKB_MOD_NAME_CTRL);
+        self.alt = mod_name_is_active(ffi::XKB_MOD_NAME_ALT);
+        self.shift = mod_name_is_active(ffi::XKB_MOD_NAME_SHIFT);
+        self.caps_lock = mod_name_is_active(ffi::XKB_MOD_NAME_CAPS);
+        self.logo = mod_name_is_active(ffi::XKB_MOD_NAME_LOGO);
+        self.num_lock = mod_name_is_active(ffi::XKB_MOD_NAME_NUM);
+    }
+}
+
+impl From<ModifiersState> for crate::keyboard::ModifiersState {
+    fn from(mods: ModifiersState) -> crate::keyboard::ModifiersState {
+        let mut to_mods = crate::keyboard::ModifiersState::empty();
+        to_mods.set(crate::keyboard::ModifiersState::SHIFT, mods.shift);
+        to_mods.set(crate::keyboard::ModifiersState::CONTROL, mods.ctrl);
+        to_mods.set(crate::keyboard::ModifiersState::ALT, mods.alt);
+        to_mods.set(crate::keyboard::ModifiersState::SUPER, mods.logo);
+        to_mods
+    }
+}
+
+#[derive(Debug)]
+pub enum Error {
+    /// libxkbcommon is not available
+    XKBNotFound,
+}
+
+#[derive(Copy, Clone, Debug)]
+enum XkbCompose {
+    Accepted(ffi::xkb_compose_status),
+    Ignored,
+    Uninitialized,
+}
+
+// Note: This is track_caller so we can have more informative line numbers when logging
+#[track_caller]
+fn byte_slice_to_smol_str(bytes: &[u8]) -> Option<SmolStr> {
+    std::str::from_utf8(bytes)
+        .map(SmolStr::new)
+        .map_err(|e| {
+            warn!(
+                "UTF-8 received from libxkbcommon ({:?}) was invalid: {e}",
+                bytes
+            )
+        })
+        .ok()
+}
--- a/src/platform_impl/linux/mod.rs
+++ b/src/platform_impl/linux/mod.rs
@@ -18,6 +18,7 @@ use std::{
 #[cfg(x11_platform)]
 use once_cell::sync::Lazy;
 use raw_window_handle::{RawDisplayHandle, RawWindowHandle};
+use smol_str::SmolStr;

 #[cfg(x11_platform)]
 pub use self::x11::XNotSupported;
@@ -28,11 +29,11 @@ use crate::platform::x11::XlibErrorHook;
 use crate::{
    dpi::{PhysicalPosition, PhysicalSize, Position, Size},
    error::{ExternalError, NotSupportedError, OsError as RootOsError},
-    event::Event,
-    event_loop::{
-        ControlFlow, DeviceEventFilter, EventLoopClosed, EventLoopWindowTarget as RootELW,
-    },
+    event::{Event, KeyEvent},
+    event_loop::{ControlFlow, DeviceEvents, EventLoopClosed, EventLoopWindowTarget as RootELW},
    icon::Icon,
+    keyboard::{Key, KeyCode},
+    platform::{modifier_supplement::KeyEventExtModifierSupplement, scancode::KeyCodeExtScancode},
    window::{
        CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
        WindowAttributes, WindowButtons, WindowLevel,
@@ -42,6 +43,7 @@ use crate::{
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
 pub(self) use crate::platform_impl::Fullscreen;

+pub mod common;
 #[cfg(wayland_platform)]
 pub mod wayland;
 #[cfg(x11_platform)]
@@ -510,8 +512,13 @@ impl Window {
    }

    #[inline]
-    pub fn set_ime_position(&self, position: Position) {
-        x11_or_wayland!(match self; Window(w) => w.set_ime_position(position))
+    pub fn set_ime_cursor_area(&self, position: Position, size: Size) {
+        x11_or_wayland!(match self; Window(w) => w.set_ime_cursor_area(position, size))
+    }
+
+    #[inline]
+    pub fn reset_dead_keys(&self) {
+        common::xkb_state::reset_dead_keys()
    }

    #[inline]
@@ -624,6 +631,37 @@ impl Window {
    }
 }

+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct KeyEventExtra {
+    pub key_without_modifiers: Key,
+    pub text_with_all_modifiers: Option<SmolStr>,
+}
+
+impl KeyEventExtModifierSupplement for KeyEvent {
+    #[inline]
+    fn text_with_all_modifiers(&self) -> Option<&str> {
+        self.platform_specific
+            .text_with_all_modifiers
+            .as_ref()
+            .map(|s| s.as_str())
+    }
+
+    #[inline]
+    fn key_without_modifiers(&self) -> Key {
+        self.platform_specific.key_without_modifiers.clone()
+    }
+}
+
+impl KeyCodeExtScancode for KeyCode {
+    fn from_scancode(scancode: u32) -> KeyCode {
+        common::keymap::scancode_to_keycode(scancode)
+    }
+
+    fn to_scancode(self) -> Option<u32> {
+        common::keymap::keycode_to_scancode(self)
+    }
+}
+
 /// Hooks for X11 errors.
 #[cfg(x11_platform)]
 pub(crate) static mut XLIB_ERROR_HOOKS: Lazy<Mutex<Vec<XlibErrorHook>>> =
@@ -854,12 +892,12 @@ impl<T> EventLoopWindowTarget<T> {
    }

    #[inline]
-    pub fn set_device_event_filter(&self, _filter: DeviceEventFilter) {
+    pub fn listen_device_events(&self, _allowed: DeviceEvents) {
        match *self {
            #[cfg(wayland_platform)]
            EventLoopWindowTarget::Wayland(_) => (),
            #[cfg(x11_platform)]
-            EventLoopWindowTarget::X(ref evlp) => evlp.set_device_event_filter(_filter),
+            EventLoopWindowTarget::X(ref evlp) => evlp.set_listen_device_events(_allowed),
        }
    }

--- a/src/platform_impl/linux/wayland/env.rs
+++ b/src/platform_impl/linux/wayland/env.rs
@@ -1,183 +0,0 @@
-//! SCTK environment setup.
-
-use sctk::reexports::client::protocol::wl_compositor::WlCompositor;
-use sctk::reexports::client::protocol::wl_output::WlOutput;
-use sctk::reexports::protocols::unstable::xdg_shell::v6::client::zxdg_shell_v6::ZxdgShellV6;
-use sctk::reexports::client::protocol::wl_seat::WlSeat;
-use sctk::reexports::protocols::unstable::xdg_decoration::v1::client::zxdg_decoration_manager_v1::ZxdgDecorationManagerV1;
-use sctk::reexports::client::protocol::wl_shell::WlShell;
-use sctk::reexports::client::protocol::wl_subcompositor::WlSubcompositor;
-use sctk::reexports::client::{Attached, DispatchData};
-use sctk::reexports::client::protocol::wl_shm::WlShm;
-use sctk::reexports::protocols::xdg_shell::client::xdg_wm_base::XdgWmBase;
-use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1;
-use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1;
-use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
-use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_v1::XdgActivationV1;
-use sctk::reexports::protocols::viewporter::client::wp_viewporter::WpViewporter;
-
-use sctk::environment::{Environment, SimpleGlobal};
-use sctk::output::{OutputHandler, OutputHandling, OutputInfo, OutputStatusListener};
-use sctk::seat::{SeatData, SeatHandler, SeatHandling, SeatListener};
-use sctk::shell::{Shell, ShellHandler, ShellHandling};
-use sctk::shm::ShmHandler;
-
-use crate::platform_impl::wayland::protocols::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1;
-
-/// Set of extra features that are supported by the compositor.
-#[derive(Debug, Clone, Copy)]
-pub struct WindowingFeatures {
-    pointer_constraints: bool,
-    xdg_activation: bool,
-}
-
-impl WindowingFeatures {
-    /// Create `WindowingFeatures` based on the presented interfaces.
-    pub fn new(env: &Environment<WinitEnv>) -> Self {
-        let pointer_constraints = env.get_global::<ZwpPointerConstraintsV1>().is_some();
-        let xdg_activation = env.get_global::<XdgActivationV1>().is_some();
-        Self {
-            pointer_constraints,
-            xdg_activation,
-        }
-    }
-
-    pub fn pointer_constraints(&self) -> bool {
-        self.pointer_constraints
-    }
-
-    pub fn xdg_activation(&self) -> bool {
-        self.xdg_activation
-    }
-}
-
-sctk::environment!(WinitEnv,
-    singles = [
-        WlShm => shm,
-        WlCompositor => compositor,
-        WlSubcompositor => subcompositor,
-        WlShell => shell,
-        XdgWmBase => shell,
-        ZxdgShellV6 => shell,
-        ZxdgDecorationManagerV1 => decoration_manager,
-        ZwpRelativePointerManagerV1 => relative_pointer_manager,
-        ZwpPointerConstraintsV1 => pointer_constraints,
-        ZwpTextInputManagerV3 => text_input_manager,
-        XdgActivationV1 => xdg_activation,
-        WpFractionalScaleManagerV1 => fractional_scale_manager,
-        WpViewporter => viewporter,
-    ],
-    multis = [
-        WlSeat => seats,
-        WlOutput => outputs,
-    ]
-);
-
-/// The environment that we utilize.
-pub struct WinitEnv {
-    seats: SeatHandler,
-
-    outputs: OutputHandler,
-
-    shm: ShmHandler,
-
-    compositor: SimpleGlobal<WlCompositor>,
-
-    subcompositor: SimpleGlobal<WlSubcompositor>,
-
-    shell: ShellHandler,
-
-    relative_pointer_manager: SimpleGlobal<ZwpRelativePointerManagerV1>,
-
-    pointer_constraints: SimpleGlobal<ZwpPointerConstraintsV1>,
-
-    text_input_manager: SimpleGlobal<ZwpTextInputManagerV3>,
-
-    decoration_manager: SimpleGlobal<ZxdgDecorationManagerV1>,
-
-    xdg_activation: SimpleGlobal<XdgActivationV1>,
-
-    fractional_scale_manager: SimpleGlobal<WpFractionalScaleManagerV1>,
-
-    viewporter: SimpleGlobal<WpViewporter>,
-}
-
-impl WinitEnv {
-    pub fn new() -> Self {
-        // Output tracking for available_monitors, etc.
-        let outputs = OutputHandler::new();
-
-        // Keyboard/Pointer/Touch input.
-        let seats = SeatHandler::new();
-
-        // Essential globals.
-        let shm = ShmHandler::new();
-        let compositor = SimpleGlobal::new();
-        let subcompositor = SimpleGlobal::new();
-
-        // Gracefully handle shell picking, since SCTK automatically supports multiple
-        // backends.
-        let shell = ShellHandler::new();
-
-        // Server side decorations.
-        let decoration_manager = SimpleGlobal::new();
-
-        // Device events for pointer.
-        let relative_pointer_manager = SimpleGlobal::new();
-
-        // Pointer grab functionality.
-        let pointer_constraints = SimpleGlobal::new();
-
-        // IME handling.
-        let text_input_manager = SimpleGlobal::new();
-
-        // Surface activation.
-        let xdg_activation = SimpleGlobal::new();
-
-        // Fractional surface scaling.
-        let fractional_scale_manager = SimpleGlobal::new();
-
-        // Surface resizing (used for fractional scaling).
-        let viewporter = SimpleGlobal::new();
-
-        Self {
-            seats,
-            outputs,
-            shm,
-            compositor,
-            subcompositor,
-            shell,
-            decoration_manager,
-            relative_pointer_manager,
-            pointer_constraints,
-            text_input_manager,
-            xdg_activation,
-            fractional_scale_manager,
-            viewporter,
-        }
-    }
-}
-
-impl ShellHandling for WinitEnv {
-    fn get_shell(&self) -> Option<Shell> {
-        self.shell.get_shell()
-    }
-}
-
-impl SeatHandling for WinitEnv {
-    fn listen<F: FnMut(Attached<WlSeat>, &SeatData, DispatchData<'_>) + 'static>(
-        &mut self,
-        f: F,
-    ) -> SeatListener {
-        self.seats.listen(f)
-    }
-}
-
-impl OutputHandling for WinitEnv {
-    fn listen<F: FnMut(WlOutput, &OutputInfo, DispatchData<'_>) + 'static>(
-        &mut self,
-        f: F,
-    ) -> OutputStatusListener {
-        self.outputs.listen(f)
-    }
-}
--- a/src/platform_impl/linux/wayland/event_loop/mod.rs
+++ b/src/platform_impl/linux/wayland/event_loop/mod.rs
@@ -1,158 +1,93 @@
+//! The event-loop routines.
+
 use std::cell::RefCell;
-use std::collections::HashMap;
 use std::error::Error;
 use std::io::Result as IOResult;
+use std::marker::PhantomData;
 use std::mem;
 use std::process;
 use std::rc::Rc;
+use std::sync::atomic::Ordering;
 use std::time::{Duration, Instant};

 use raw_window_handle::{RawDisplayHandle, WaylandDisplayHandle};

-use sctk::reexports::client::protocol::wl_compositor::WlCompositor;
-use sctk::reexports::client::protocol::wl_shm::WlShm;
-use sctk::reexports::client::Display;
-
 use sctk::reexports::calloop;
+use sctk::reexports::client::globals;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle, WaylandSource};

-use sctk::environment::Environment;
-use sctk::seat::pointer::{ThemeManager, ThemeSpec};
-use sctk::WaylandSource;
-
+use crate::dpi::{LogicalSize, PhysicalSize};
 use crate::event::{Event, StartCause, WindowEvent};
 use crate::event_loop::{ControlFlow, EventLoopWindowTarget as RootEventLoopWindowTarget};
 use crate::platform_impl::platform::sticky_exit_callback;
 use crate::platform_impl::EventLoopWindowTarget as PlatformEventLoopWindowTarget;

-use super::env::{WindowingFeatures, WinitEnv};
-use super::output::OutputManager;
-use super::seat::SeatManager;
-use super::window::shim::{self, WindowCompositorUpdate, WindowUserRequest};
-use super::{DeviceId, WindowId};
-
 mod proxy;
-mod sink;
-mod state;
+pub mod sink;

 pub use proxy::EventLoopProxy;
-pub use sink::EventSink;
-pub use state::WinitState;
+use sink::EventSink;

-type WinitDispatcher = calloop::Dispatcher<'static, WaylandSource, WinitState>;
+use super::state::{WindowCompositorUpdate, WinitState};
+use super::{DeviceId, WindowId};

-pub struct EventLoopWindowTarget<T> {
-    /// Wayland display.
-    pub display: Display,
-
-    /// Environment to handle object creation, etc.
-    pub env: Environment<WinitEnv>,
-
-    /// Event loop handle.
-    pub event_loop_handle: calloop::LoopHandle<'static, WinitState>,
-
-    /// Output manager.
-    pub output_manager: OutputManager,
-
-    /// State that we share across callbacks.
-    pub state: RefCell<WinitState>,
-
-    /// Dispatcher of Wayland events.
-    pub wayland_dispatcher: WinitDispatcher,
-
-    /// A proxy to wake up event loop.
-    pub event_loop_awakener: calloop::ping::Ping,
-
-    /// The available windowing features.
-    pub windowing_features: WindowingFeatures,
-
-    /// Theme manager to manage cursors.
-    ///
-    /// It's being shared between all windows to avoid loading
-    /// multiple similar themes.
-    pub theme_manager: ThemeManager,
-
-    _marker: std::marker::PhantomData<T>,
-}
-
-impl<T> EventLoopWindowTarget<T> {
-    pub fn raw_display_handle(&self) -> RawDisplayHandle {
-        let mut display_handle = WaylandDisplayHandle::empty();
-        display_handle.display = self.display.get_display_ptr() as *mut _;
-        RawDisplayHandle::Wayland(display_handle)
-    }
-}
+type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;

+/// The Wayland event loop.
 pub struct EventLoop<T: 'static> {
-    /// Dispatcher of Wayland events.
-    pub wayland_dispatcher: WinitDispatcher,
-
-    /// Event loop.
-    event_loop: calloop::EventLoop<'static, WinitState>,
-
-    /// Wayland display.
-    display: Display,
-
-    /// Pending user events.
-    pending_user_events: Rc<RefCell<Vec<T>>>,
-
    /// Sender of user events.
    user_events_sender: calloop::channel::Sender<T>,

-    /// Window target.
+    // XXX can't remove RefCell out of here, unless we can plumb generics into the `Window`, which
+    // we don't really want, since it'll break public API by a lot.
+    /// Pending events from the user.
+    pending_user_events: Rc<RefCell<Vec<T>>>,
+
+    /// The Wayland dispatcher to has raw access to the queue when needed, such as
+    /// when creating a new window.
+    wayland_dispatcher: WaylandDispatcher,
+
+    /// Connection to the wayland server.
+    connection: Connection,
+
+    /// Event loop window target.
    window_target: RootEventLoopWindowTarget<T>,

-    /// Output manager.
-    _seat_manager: SeatManager,
+    // XXX drop after everything else, just to be safe.
+    /// Calloop's event loop.
+    event_loop: calloop::EventLoop<'static, WinitState>,
 }

 impl<T: 'static> EventLoop<T> {
    pub fn new() -> Result<EventLoop<T>, Box<dyn Error>> {
-        // Connect to wayland server and setup event queue.
-        let display = Display::connect_to_env()?;
-        let mut event_queue = display.create_event_queue();
-        let display_proxy = display.attach(event_queue.token());
+        let connection = Connection::connect_to_env()?;

-        // Setup environment.
-        let env = Environment::new(&display_proxy, &mut event_queue, WinitEnv::new())?;
+        let (globals, mut event_queue) = globals::registry_queue_init(&connection)?;
+        let queue_handle = event_queue.handle();

-        // Create event loop.
-        let event_loop = calloop::EventLoop::<'static, WinitState>::try_new()?;
-        // Build windowing features.
-        let windowing_features = WindowingFeatures::new(&env);
+        let event_loop = calloop::EventLoop::<WinitState>::try_new()?;

-        // Create a theme manager.
-        let compositor = env.require_global::<WlCompositor>();
-        let shm = env.require_global::<WlShm>();
-        let theme_manager = ThemeManager::init(ThemeSpec::System, compositor, shm);
+        let mut winit_state = WinitState::new(&globals, &queue_handle, event_loop.handle())?;

-        // Setup theme seat and output managers.
-        let seat_manager = SeatManager::new(&env, event_loop.handle(), theme_manager.clone());
-        let output_manager = OutputManager::new(&env);
+        // NOTE: do a roundtrip after binding the globals to prevent potential
+        // races with the server.
+        event_queue.roundtrip(&mut winit_state)?;

-        // A source of events that we plug into our event loop.
-        let wayland_source = WaylandSource::new(event_queue);
+        // Register Wayland source.
+        let wayland_source = WaylandSource::new(event_queue)?;
        let wayland_dispatcher =
            calloop::Dispatcher::new(wayland_source, |_, queue, winit_state| {
-                queue.dispatch_pending(winit_state, |event, object, _| {
-                    panic!(
-                        "[calloop] Encountered an orphan event: {}@{} : {}",
-                        event.interface,
-                        object.as_ref().id(),
-                        event.name
-                    );
-                })
+                queue.dispatch_pending(winit_state)
            });

-        let _wayland_source_dispatcher = event_loop
+        event_loop
            .handle()
            .register_dispatcher(wayland_dispatcher.clone())?;

-        // A source of user events.
+        // Setup the user proxy.
        let pending_user_events = Rc::new(RefCell::new(Vec::new()));
        let pending_user_events_clone = pending_user_events.clone();
        let (user_events_sender, user_events_channel) = calloop::channel::channel();
-
-        // User events channel.
        event_loop
            .handle()
            .insert_source(user_events_channel, move |event, _, _| {
@@ -163,52 +98,30 @@ impl<T: 'static> EventLoop<T> {

        // An event's loop awakener to wake up for window events from winit's windows.
        let (event_loop_awakener, event_loop_awakener_source) = calloop::ping::make_ping()?;
-
-        // Handler of window requests.
        event_loop
            .handle()
-            .insert_source(event_loop_awakener_source, move |_, _, state| {
-                // Drain events here as well to account for application doing batch event processing
-                // on RedrawEventsCleared.
-                shim::handle_window_requests(state);
+            .insert_source(event_loop_awakener_source, move |_, _, _| {
+                // No extra handling is required, we just need to wake-up.
            })?;

-        let event_loop_handle = event_loop.handle();
-        let window_map = HashMap::new();
-        let event_sink = EventSink::new();
-        let window_user_requests = HashMap::new();
-        let window_compositor_updates = HashMap::new();
-
-        // Create event loop window target.
-        let event_loop_window_target = EventLoopWindowTarget {
-            display: display.clone(),
-            env,
-            state: RefCell::new(WinitState {
-                window_map,
-                event_sink,
-                window_user_requests,
-                window_compositor_updates,
-            }),
-            event_loop_handle,
-            output_manager,
-            event_loop_awakener,
+        let window_target = EventLoopWindowTarget {
+            connection: connection.clone(),
            wayland_dispatcher: wayland_dispatcher.clone(),
-            windowing_features,
-            theme_manager,
-            _marker: std::marker::PhantomData,
+            event_loop_awakener,
+            queue_handle,
+            state: RefCell::new(winit_state),
+            _marker: PhantomData,
        };

-        // Create event loop itself.
        let event_loop = Self {
-            event_loop,
-            display,
-            pending_user_events,
+            connection,
            wayland_dispatcher,
-            _seat_manager: seat_manager,
            user_events_sender,
+            pending_user_events,
+            event_loop,
            window_target: RootEventLoopWindowTarget {
-                p: PlatformEventLoopWindowTarget::Wayland(event_loop_window_target),
-                _marker: std::marker::PhantomData,
+                p: PlatformEventLoopWindowTarget::Wayland(window_target),
+                _marker: PhantomData,
            },
        };

@@ -228,7 +141,11 @@ impl<T: 'static> EventLoop<T> {
        F: FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
    {
        let mut control_flow = ControlFlow::Poll;
-        let pending_user_events = self.pending_user_events.clone();
+
+        // XXX preallocate certian structures to avoid allocating on each loop iteration.
+        let mut window_ids = Vec::<WindowId>::new();
+        let mut compositor_updates = Vec::<WindowCompositorUpdate>::new();
+        let mut buffer_sink = EventSink::new();

        callback(
            Event::NewEvents(StartCause::Init),
@@ -236,23 +153,19 @@ impl<T: 'static> EventLoop<T> {
            &mut control_flow,
        );

-        // NB: For consistency all platforms must emit a 'resumed' event even though Wayland
+        // XXX For consistency all platforms must emit a 'Resumed' event even though Wayland
        // applications don't themselves have a formal suspend/resume lifecycle.
        callback(Event::Resumed, &self.window_target, &mut control_flow);

-        let mut window_compositor_updates: Vec<(WindowId, WindowCompositorUpdate)> = Vec::new();
-        let mut window_user_requests: Vec<(WindowId, WindowUserRequest)> = Vec::new();
-        let mut event_sink_back_buffer = Vec::new();
-
-        // NOTE We break on errors from dispatches, since if we've got protocol error
+        // XXX We break on errors from dispatches, since if we've got protocol error
        // libwayland-client/wayland-rs will inform us anyway, but crashing downstream is not
        // really an option. Instead we inform that the event loop got destroyed. We may
        // communicate an error that something was terminated, but winit doesn't provide us
        // with an API to do that via some event.
        // Still, we set the exit code to the error's OS error code, or to 1 if not possible.
        let exit_code = loop {
-            // Send pending events to the server.
-            let _ = self.display.flush();
+            // Flush the connection.
+            let _ = self.connection.flush();

            // During the run of the user callback, some other code monitoring and reading the
            // Wayland socket may have been run (mesa for example does this with vsync), if that
@@ -272,9 +185,12 @@ impl<T: 'static> EventLoop<T> {
                    _ => unreachable!(),
                };

-                match queue.dispatch_pending(state, |_, _, _| unimplemented!()) {
+                match queue.dispatch_pending(state) {
                    Ok(dispatched) => dispatched > 0,
-                    Err(error) => break error.raw_os_error().unwrap_or(1),
+                    Err(error) => {
+                        error!("Error dispatching wayland queue: {}", error);
+                        break 1;
+                    }
                }
            };

@@ -282,7 +198,7 @@ impl<T: 'static> EventLoop<T> {
                ControlFlow::ExitWithCode(code) => break code,
                ControlFlow::Poll => {
                    // Non-blocking dispatch.
-                    let timeout = Duration::from_millis(0);
+                    let timeout = Duration::ZERO;
                    if let Err(error) = self.loop_dispatch(Some(timeout)) {
                        break error.raw_os_error().unwrap_or(1);
                    }
@@ -295,7 +211,7 @@ impl<T: 'static> EventLoop<T> {
                }
                ControlFlow::Wait => {
                    let timeout = if instant_wakeup {
-                        Some(Duration::from_millis(0))
+                        Some(Duration::ZERO)
                    } else {
                        None
                    };
@@ -320,7 +236,7 @@ impl<T: 'static> EventLoop<T> {
                    let duration = if deadline > start && !instant_wakeup {
                        deadline - start
                    } else {
-                        Duration::from_millis(0)
+                        Duration::ZERO
                    };

                    if let Err(error) = self.loop_dispatch(Some(duration)) {
@@ -353,7 +269,7 @@ impl<T: 'static> EventLoop<T> {

            // Handle pending user events. We don't need back buffer, since we can't dispatch
            // user events indirectly via callback to the user.
-            for user_event in pending_user_events.borrow_mut().drain(..) {
+            for user_event in self.pending_user_events.borrow_mut().drain(..) {
                sticky_exit_callback(
                    Event::UserEvent(user_event),
                    &self.window_target,
@@ -362,35 +278,30 @@ impl<T: 'static> EventLoop<T> {
                );
            }

-            // Process 'new' pending updates from compositor.
+            // Drain the pending compositor updates.
            self.with_state(|state| {
-                window_compositor_updates.clear();
-                window_compositor_updates.extend(
-                    state
-                        .window_compositor_updates
-                        .iter_mut()
-                        .map(|(wid, window_update)| (*wid, mem::take(window_update))),
-                );
+                compositor_updates.append(&mut state.window_compositor_updates)
            });

-            for (window_id, window_compositor_update) in window_compositor_updates.iter_mut() {
-                if let Some(scale_factor) = window_compositor_update.scale_factor {
+            for mut compositor_update in compositor_updates.drain(..) {
+                let window_id = compositor_update.window_id;
+                if let Some(scale_factor) = compositor_update.scale_factor {
                    let mut physical_size = self.with_state(|state| {
-                        let window_handle = state.window_map.get(window_id).unwrap();
-                        *window_handle.scale_factor.lock().unwrap() = scale_factor;
+                        let windows = state.windows.get_mut();
+                        let mut window = windows.get(&window_id).unwrap().lock().unwrap();

-                        let mut size = window_handle.size.lock().unwrap();
-
-                        // Update the new logical size if it was changed.
-                        let window_size = window_compositor_update.size.unwrap_or(*size);
-                        *size = window_size;
-
-                        window_size.to_physical(scale_factor)
+                        // Set the new scale factor.
+                        window.set_scale_factor(scale_factor);
+                        let window_size = compositor_update.size.unwrap_or(window.inner_size());
+                        logical_to_physical_rounded(window_size, scale_factor)
                    });

+                    // Stash the old window size.
+                    let old_physical_size = physical_size;
+
                    sticky_exit_callback(
                        Event::WindowEvent {
-                            window_id: crate::window::WindowId(*window_id),
+                            window_id: crate::window::WindowId(window_id),
                            event: WindowEvent::ScaleFactorChanged {
                                scale_factor,
                                new_inner_size: &mut physical_size,
@@ -401,83 +312,58 @@ impl<T: 'static> EventLoop<T> {
                        &mut callback,
                    );

-                    // We don't update size on a window handle since we'll do that later
-                    // when handling size update.
                    let new_logical_size = physical_size.to_logical(scale_factor);
-                    window_compositor_update.size = Some(new_logical_size);
+
+                    // Resize the window when user altered the size.
+                    if old_physical_size != physical_size {
+                        self.with_state(|state| {
+                            let windows = state.windows.get_mut();
+                            let mut window = windows.get(&window_id).unwrap().lock().unwrap();
+                            window.resize(new_logical_size);
+                        });
+                    }
+
+                    // Make it queue resize.
+                    compositor_update.size = Some(new_logical_size);
                }

-                if let Some(size) = window_compositor_update.size.take() {
+                if let Some(size) = compositor_update.size.take() {
                    let physical_size = self.with_state(|state| {
-                        let window_handle = state.window_map.get_mut(window_id).unwrap();
+                        let windows = state.windows.get_mut();
+                        let window = windows.get(&window_id).unwrap().lock().unwrap();

-                        if let Some(fs_state) = window_handle.fractional_scaling_state.as_ref() {
-                            // If we have a viewport then we support fractional scaling. As per the
-                            // protocol, we have to set the viewport size of the size prior scaling.
-                            fs_state
-                                .viewport
-                                .set_destination(size.width as _, size.height as _);
-                        }
+                        let scale_factor = window.scale_factor();
+                        let physical_size = logical_to_physical_rounded(size, scale_factor);

-                        let mut window_size = window_handle.size.lock().unwrap();
+                        // TODO could probably bring back size reporting optimization.

-                        // Always issue resize event on scale factor change.
-                        let physical_size = if window_compositor_update.scale_factor.is_none()
-                            && *window_size == size
-                        {
-                            // The size hasn't changed, don't inform downstream about that.
-                            None
-                        } else {
-                            *window_size = size;
-                            let scale_factor = window_handle.scale_factor();
-                            let physical_size = size.to_physical(scale_factor);
-                            Some(physical_size)
-                        };
-
-                        // We still perform all of those resize related logic even if the size
-                        // hasn't changed, since GNOME relies on `set_geometry` calls after
-                        // configures.
-                        window_handle.window.resize(size.width, size.height);
-                        window_handle.window.refresh();
-
-                        // Update the opaque region.
-                        window_handle.set_transparent(window_handle.transparent.get());
-
-                        // Mark that refresh isn't required, since we've done it right now.
+                        // Mark the window as needed a redraw.
                        state
-                            .window_user_requests
-                            .get_mut(window_id)
+                            .window_requests
+                            .get_mut()
+                            .get_mut(&window_id)
                            .unwrap()
-                            .refresh_frame = false;
-
-                        // Queue redraw requested.
-                        state
-                            .window_user_requests
-                            .get_mut(window_id)
-                            .unwrap()
-                            .redraw_requested = true;
+                            .redraw_requested
+                            .store(true, Ordering::Relaxed);

                        physical_size
                    });

-                    if let Some(physical_size) = physical_size {
-                        sticky_exit_callback(
-                            Event::WindowEvent {
-                                window_id: crate::window::WindowId(*window_id),
-                                event: WindowEvent::Resized(physical_size),
-                            },
-                            &self.window_target,
-                            &mut control_flow,
-                            &mut callback,
-                        );
-                    }
-                }
-
-                // If the close is requested, send it here.
-                if window_compositor_update.close_window {
                    sticky_exit_callback(
                        Event::WindowEvent {
-                            window_id: crate::window::WindowId(*window_id),
+                            window_id: crate::window::WindowId(window_id),
+                            event: WindowEvent::Resized(physical_size),
+                        },
+                        &self.window_target,
+                        &mut control_flow,
+                        &mut callback,
+                    );
+                }
+
+                if compositor_update.close_window {
+                    sticky_exit_callback(
+                        Event::WindowEvent {
+                            window_id: crate::window::WindowId(window_id),
                            event: WindowEvent::CloseRequested,
                        },
                        &self.window_target,
@@ -487,18 +373,20 @@ impl<T: 'static> EventLoop<T> {
                }
            }

-            // The purpose of the back buffer and that swap is to not hold borrow_mut when
-            // we're doing callback to the user, since we can double borrow if the user decides
-            // to create a window in one of those callbacks.
+            // Push the events directly from the window.
            self.with_state(|state| {
-                std::mem::swap(
-                    &mut event_sink_back_buffer,
-                    &mut state.event_sink.window_events,
-                )
+                buffer_sink.append(&mut state.window_events_sink.lock().unwrap());
            });
+            for event in buffer_sink.drain() {
+                let event = event.map_nonuser_event().unwrap();
+                sticky_exit_callback(event, &self.window_target, &mut control_flow, &mut callback);
+            }

-            // Handle pending window events.
-            for event in event_sink_back_buffer.drain(..) {
+            // Handle non-synthetic events.
+            self.with_state(|state| {
+                buffer_sink.append(&mut state.events_sink);
+            });
+            for event in buffer_sink.drain() {
                let event = event.map_nonuser_event().unwrap();
                sticky_exit_callback(event, &self.window_target, &mut control_flow, &mut callback);
            }
@@ -511,42 +399,41 @@ impl<T: 'static> EventLoop<T> {
                &mut callback,
            );

-            // Apply user requests, so every event required resize and latter surface commit will
-            // be applied right before drawing. This will also ensure that every `RedrawRequested`
-            // event will be delivered in time.
+            // Collect the window ids
            self.with_state(|state| {
-                shim::handle_window_requests(state);
+                window_ids.extend(state.window_requests.get_mut().keys());
            });

-            // Process 'new' pending updates from compositor.
-            self.with_state(|state| {
-                window_user_requests.clear();
-                window_user_requests.extend(
-                    state
-                        .window_user_requests
-                        .iter_mut()
-                        .map(|(wid, window_request)| (*wid, mem::take(window_request))),
-                );
-            });
+            for window_id in window_ids.drain(..) {
+                let request_redraw = self.with_state(|state| {
+                    let window_requests = state.window_requests.get_mut();
+                    if window_requests.get(&window_id).unwrap().take_closed() {
+                        mem::drop(window_requests.remove(&window_id));
+                        mem::drop(state.windows.get_mut().remove(&window_id));
+                        false
+                    } else {
+                        let mut redraw_requested = window_requests
+                            .get(&window_id)
+                            .unwrap()
+                            .take_redraw_requested();

-            // Handle RedrawRequested events.
-            for (window_id, mut window_request) in window_user_requests.iter() {
-                // Handle refresh of the frame.
-                if window_request.refresh_frame {
-                    self.with_state(|state| {
-                        let window_handle = state.window_map.get_mut(window_id).unwrap();
-                        window_handle.window.refresh();
-                    });
+                        // Redraw the frames while at it.
+                        redraw_requested |= state
+                            .windows
+                            .get_mut()
+                            .get_mut(&window_id)
+                            .unwrap()
+                            .lock()
+                            .unwrap()
+                            .refresh_frame();

-                    // In general refreshing the frame requires surface commit, those force user
-                    // to redraw.
-                    window_request.redraw_requested = true;
-                }
+                        redraw_requested
+                    }
+                });

-                // Handle redraw request.
-                if window_request.redraw_requested {
+                if request_redraw {
                    sticky_exit_callback(
-                        Event::RedrawRequested(crate::window::WindowId(*window_id)),
+                        Event::RedrawRequested(crate::window::WindowId(window_id)),
                        &self.window_target,
                        &mut control_flow,
                        &mut callback,
@@ -577,25 +464,61 @@ impl<T: 'static> EventLoop<T> {
        &self.window_target
    }

-    fn with_state<U, F: FnOnce(&mut WinitState) -> U>(&mut self, f: F) -> U {
+    fn with_state<'a, U: 'a, F: FnOnce(&'a mut WinitState) -> U>(&'a mut self, callback: F) -> U {
        let state = match &mut self.window_target.p {
            PlatformEventLoopWindowTarget::Wayland(window_target) => window_target.state.get_mut(),
            #[cfg(x11_platform)]
            _ => unreachable!(),
        };

-        f(state)
+        callback(state)
    }

    fn loop_dispatch<D: Into<Option<std::time::Duration>>>(&mut self, timeout: D) -> IOResult<()> {
        let state = match &mut self.window_target.p {
            PlatformEventLoopWindowTarget::Wayland(window_target) => window_target.state.get_mut(),
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
            _ => unreachable!(),
        };

-        self.event_loop
-            .dispatch(timeout, state)
-            .map_err(|error| error.into())
+        self.event_loop.dispatch(timeout, state).map_err(|error| {
+            error!("Error dispatching event loop: {}", error);
+            error.into()
+        })
    }
 }
+
+pub struct EventLoopWindowTarget<T> {
+    /// The event loop wakeup source.
+    pub event_loop_awakener: calloop::ping::Ping,
+
+    /// The main queue used by the event loop.
+    pub queue_handle: QueueHandle<WinitState>,
+
+    // TODO remove that RefCell once we can pass `&mut` in `Window::new`.
+    /// Winit state.
+    pub state: RefCell<WinitState>,
+
+    /// Dispatcher of Wayland events.
+    pub wayland_dispatcher: WaylandDispatcher,
+
+    /// Connection to the wayland server.
+    pub connection: Connection,
+
+    _marker: std::marker::PhantomData<T>,
+}
+
+impl<T> EventLoopWindowTarget<T> {
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        let mut display_handle = WaylandDisplayHandle::empty();
+        display_handle.display = self.connection.display().id().as_ptr() as *mut _;
+        RawDisplayHandle::Wayland(display_handle)
+    }
+}
+
+// The default routine does floor, but we need round on Wayland.
+fn logical_to_physical_rounded(size: LogicalSize<u32>, scale_factor: f64) -> PhysicalSize<u32> {
+    let width = size.width as f64 * scale_factor;
+    let height = size.height as f64 * scale_factor;
+    (width.round(), height.round()).into()
+}
--- a/src/platform_impl/linux/wayland/event_loop/sink.rs
+++ b/src/platform_impl/linux/wayland/event_loop/sink.rs
@@ -1,5 +1,7 @@
 //! An event loop's sink to deliver events from the Wayland event callbacks.

+use std::vec::Drain;
+
 use crate::event::{DeviceEvent, DeviceId as RootDeviceId, Event, WindowEvent};
 use crate::platform_impl::platform::DeviceId as PlatformDeviceId;
 use crate::window::WindowId as RootWindowId;
@@ -19,6 +21,7 @@ impl EventSink {
    }

    /// Add new device event to a queue.
+    #[inline]
    pub fn push_device_event(&mut self, event: DeviceEvent, device_id: DeviceId) {
        self.window_events.push(Event::DeviceEvent {
            event,
@@ -27,10 +30,21 @@ impl EventSink {
    }

    /// Add new window event to a queue.
+    #[inline]
    pub fn push_window_event(&mut self, event: WindowEvent<'static>, window_id: WindowId) {
        self.window_events.push(Event::WindowEvent {
            event,
            window_id: RootWindowId(window_id),
        });
    }
+
+    #[inline]
+    pub fn append(&mut self, other: &mut Self) {
+        self.window_events.append(&mut other.window_events);
+    }
+
+    #[inline]
+    pub fn drain(&mut self) -> Drain<'_, Event<'static, ()>> {
+        self.window_events.drain(..)
+    }
 }
--- a/src/platform_impl/linux/wayland/event_loop/state.rs
+++ b/src/platform_impl/linux/wayland/event_loop/state.rs
@@ -1,31 +0,0 @@
-//! A state that we pass around in a dispatch.
-
-use std::collections::HashMap;
-
-use super::EventSink;
-use crate::platform_impl::wayland::window::shim::{
-    WindowCompositorUpdate, WindowHandle, WindowUserRequest,
-};
-use crate::platform_impl::wayland::WindowId;
-
-/// Wrapper to carry winit's state.
-pub struct WinitState {
-    /// A sink for window and device events that is being filled during dispatching
-    /// event loop and forwarded downstream afterwards.
-    pub event_sink: EventSink,
-
-    /// Window updates comming from the user requests. Those are separatelly dispatched right after
-    /// `MainEventsCleared`.
-    pub window_user_requests: HashMap<WindowId, WindowUserRequest>,
-
-    /// Window updates, which are coming from SCTK or the compositor, which require
-    /// calling back to the winit's downstream. They are handled right in the event loop,
-    /// unlike the ones coming from buffers on the `WindowHandle`'s.
-    pub window_compositor_updates: HashMap<WindowId, WindowCompositorUpdate>,
-
-    /// Window map containing all SCTK windows. Since those windows aren't allowed
-    /// to be sent to other threads, they live on the event loop's thread
-    /// and requests from winit's windows are being forwarded to them either via
-    /// `WindowUpdate` or buffer on the associated with it `WindowHandle`.
-    pub window_map: HashMap<WindowId, WindowHandle>,
-}
--- a/src/platform_impl/linux/wayland/mod.rs
+++ b/src/platform_impl/linux/wayland/mod.rs
@@ -1,19 +1,23 @@
 #![cfg(wayland_platform)]

+//! Winit's Wayland backend.
+
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Proxy;

 pub use crate::platform_impl::platform::WindowId;
 pub use event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget};
 pub use output::{MonitorHandle, VideoMode};
 pub use window::Window;

-mod env;
 mod event_loop;
 mod output;
-mod protocols;
 mod seat;
+mod state;
+mod types;
 mod window;

+/// Dummy device id, since Wayland doesn't have device events.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId;

@@ -23,7 +27,8 @@ impl DeviceId {
    }
 }

+/// Get the WindowId out of the surface.
 #[inline]
 fn make_wid(surface: &WlSurface) -> WindowId {
-    WindowId(surface.as_ref().c_ptr() as u64)
+    WindowId(surface.id().as_ptr() as u64)
 }
--- a/src/platform_impl/linux/wayland/output.rs
+++ b/src/platform_impl/linux/wayland/output.rs
@@ -1,98 +1,30 @@
-use std::collections::VecDeque;
-use std::sync::{Arc, Mutex};
-
 use sctk::reexports::client::protocol::wl_output::WlOutput;
-use sctk::reexports::client::Display;
+use sctk::reexports::client::Proxy;

-use sctk::environment::Environment;
-use sctk::output::OutputStatusListener;
+use sctk::output::OutputData;

 use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::platform_impl::platform::{
    MonitorHandle as PlatformMonitorHandle, VideoMode as PlatformVideoMode,
 };

-use super::env::WinitEnv;
 use super::event_loop::EventLoopWindowTarget;

-/// Output manager.
-pub struct OutputManager {
-    /// A handle that actually performs all operations on outputs.
-    handle: OutputManagerHandle,
-
-    _output_listener: OutputStatusListener,
-}
-
-impl OutputManager {
-    pub fn new(env: &Environment<WinitEnv>) -> Self {
-        let handle = OutputManagerHandle::new();
-
-        // Handle existing outputs.
-        for output in env.get_all_outputs() {
-            match sctk::output::with_output_info(&output, |info| info.obsolete) {
-                Some(false) => (),
-                // The output is obsolete or we've failed to access its data, skipping.
-                _ => continue,
-            }
-
-            // The output is present and unusable, add it to the output manager manager.
-            handle.add_output(output);
-        }
-
-        let handle_for_listener = handle.clone();
-
-        let output_listener = env.listen_for_outputs(move |output, info, _| {
-            if info.obsolete {
-                handle_for_listener.remove_output(output)
-            } else {
-                handle_for_listener.add_output(output)
-            }
-        });
-
-        Self {
-            handle,
-            _output_listener: output_listener,
-        }
+impl<T> EventLoopWindowTarget<T> {
+    #[inline]
+    pub fn available_monitors(&self) -> Vec<MonitorHandle> {
+        self.state
+            .borrow()
+            .output_state
+            .outputs()
+            .map(MonitorHandle::new)
+            .collect()
    }

-    pub fn handle(&self) -> OutputManagerHandle {
-        self.handle.clone()
-    }
-}
-
-/// A handle to output manager.
-#[derive(Debug, Clone)]
-pub struct OutputManagerHandle {
-    outputs: Arc<Mutex<VecDeque<MonitorHandle>>>,
-}
-
-impl OutputManagerHandle {
-    fn new() -> Self {
-        let outputs = Arc::new(Mutex::new(VecDeque::new()));
-        Self { outputs }
-    }
-
-    /// Handle addition of the output.
-    fn add_output(&self, output: WlOutput) {
-        let mut outputs = self.outputs.lock().unwrap();
-        let position = outputs.iter().position(|handle| handle.proxy == output);
-        if position.is_none() {
-            outputs.push_back(MonitorHandle::new(output));
-        }
-    }
-
-    /// Handle removal of the output.
-    fn remove_output(&self, output: WlOutput) {
-        let mut outputs = self.outputs.lock().unwrap();
-        let position = outputs.iter().position(|handle| handle.proxy == output);
-        if let Some(position) = position {
-            outputs.remove(position);
-        }
-    }
-
-    /// Get all observed outputs.
-    pub fn available_outputs(&self) -> VecDeque<MonitorHandle> {
-        self.outputs.lock().unwrap().clone()
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<PlatformMonitorHandle> {
+        // There's no primary monitor on Wayland.
+        None
    }
 }

@@ -101,6 +33,80 @@ pub struct MonitorHandle {
    pub(crate) proxy: WlOutput,
 }

+impl MonitorHandle {
+    #[inline]
+    pub(crate) fn new(proxy: WlOutput) -> Self {
+        Self { proxy }
+    }
+
+    #[inline]
+    pub fn name(&self) -> Option<String> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.with_output_info(|info| info.name.clone())
+    }
+
+    #[inline]
+    pub fn native_identifier(&self) -> u32 {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.with_output_info(|info| info.id)
+    }
+
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        let dimensions = output_data.with_output_info(|info| {
+            info.modes
+                .iter()
+                .find_map(|mode| mode.current.then_some(mode.dimensions))
+        });
+
+        match dimensions {
+            Some((width, height)) => (width as u32, height as u32),
+            _ => (0, 0),
+        }
+        .into()
+    }
+
+    #[inline]
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.with_output_info(|info| info.location).into()
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.with_output_info(|info| {
+            info.modes
+                .iter()
+                .find_map(|mode| mode.current.then_some(mode.refresh_rate as u32))
+        })
+    }
+
+    #[inline]
+    pub fn scale_factor(&self) -> i32 {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.scale_factor()
+    }
+
+    #[inline]
+    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoMode> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        let modes = output_data.with_output_info(|info| info.modes.clone());
+
+        let monitor = self.clone();
+
+        modes.into_iter().map(move |mode| {
+            PlatformVideoMode::Wayland(VideoMode {
+                size: (mode.dimensions.0 as u32, mode.dimensions.1 as u32).into(),
+                refresh_rate_millihertz: mode.refresh_rate as u32,
+                bit_depth: 32,
+                monitor: monitor.clone(),
+            })
+        })
+    }
+}
+
 impl PartialEq for MonitorHandle {
    fn eq(&self, other: &Self) -> bool {
        self.native_identifier() == other.native_identifier()
@@ -127,78 +133,6 @@ impl std::hash::Hash for MonitorHandle {
    }
 }

-impl MonitorHandle {
-    #[inline]
-    pub(crate) fn new(proxy: WlOutput) -> Self {
-        Self { proxy }
-    }
-
-    #[inline]
-    pub fn name(&self) -> Option<String> {
-        sctk::output::with_output_info(&self.proxy, |info| {
-            format!("{} ({})", info.model, info.make)
-        })
-    }
-
-    #[inline]
-    pub fn native_identifier(&self) -> u32 {
-        sctk::output::with_output_info(&self.proxy, |info| info.id).unwrap_or(0)
-    }
-
-    #[inline]
-    pub fn size(&self) -> PhysicalSize<u32> {
-        match sctk::output::with_output_info(&self.proxy, |info| {
-            info.modes
-                .iter()
-                .find(|mode| mode.is_current)
-                .map(|mode| mode.dimensions)
-        }) {
-            Some(Some((w, h))) => (w as u32, h as u32),
-            _ => (0, 0),
-        }
-        .into()
-    }
-
-    #[inline]
-    pub fn position(&self) -> PhysicalPosition<i32> {
-        sctk::output::with_output_info(&self.proxy, |info| info.location)
-            .unwrap_or((0, 0))
-            .into()
-    }
-
-    #[inline]
-    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        sctk::output::with_output_info(&self.proxy, |info| {
-            info.modes
-                .iter()
-                .find_map(|mode| mode.is_current.then(|| mode.refresh_rate as u32))
-        })
-        .flatten()
-    }
-
-    #[inline]
-    pub fn scale_factor(&self) -> i32 {
-        sctk::output::with_output_info(&self.proxy, |info| info.scale_factor).unwrap_or(1)
-    }
-
-    #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoMode> {
-        let modes = sctk::output::with_output_info(&self.proxy, |info| info.modes.clone())
-            .unwrap_or_default();
-
-        let monitor = self.clone();
-
-        modes.into_iter().map(move |mode| {
-            PlatformVideoMode::Wayland(VideoMode {
-                size: (mode.dimensions.0 as u32, mode.dimensions.1 as u32).into(),
-                refresh_rate_millihertz: mode.refresh_rate as u32,
-                bit_depth: 32,
-                monitor: monitor.clone(),
-            })
-        })
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct VideoMode {
    pub(crate) size: PhysicalSize<u32>,
@@ -227,21 +161,3 @@ impl VideoMode {
        PlatformMonitorHandle::Wayland(self.monitor.clone())
    }
 }
-
-impl<T> EventLoopWindowTarget<T> {
-    #[inline]
-    pub fn display(&self) -> &Display {
-        &self.display
-    }
-
-    #[inline]
-    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        self.output_manager.handle.available_outputs()
-    }
-
-    #[inline]
-    pub fn primary_monitor(&self) -> Option<PlatformMonitorHandle> {
-        // There's no primary monitor on Wayland.
-        None
-    }
-}
--- a/src/platform_impl/linux/wayland/protocols.rs
+++ b/src/platform_impl/linux/wayland/protocols.rs
@@ -1,13 +0,0 @@
-#![allow(dead_code, non_camel_case_types, unused_unsafe, unused_variables)]
-#![allow(non_upper_case_globals, non_snake_case, unused_imports)]
-#![allow(missing_docs, clippy::all)]
-
-use wayland_client::protocol::wl_surface;
-use wayland_client::sys;
-use wayland_client::{AnonymousObject, Attached, Main, Proxy, ProxyMap};
-use wayland_commons::map::{Object, ObjectMetadata};
-use wayland_commons::smallvec;
-use wayland_commons::wire::{Argument, ArgumentType, Message, MessageDesc};
-use wayland_commons::{Interface, MessageGroup};
-
-include!(concat!(env!("OUT_DIR"), "/fractional_scale_v1.rs"));
--- a/src/platform_impl/linux/wayland/seat/keyboard/handlers.rs
+++ b/src/platform_impl/linux/wayland/seat/keyboard/handlers.rs
@@ -1,159 +0,0 @@
-//! Handling of various keyboard events.
-
-use std::sync::atomic::Ordering;
-
-use sctk::reexports::client::protocol::wl_keyboard::KeyState;
-
-use sctk::seat::keyboard::Event as KeyboardEvent;
-
-use crate::event::{ElementState, KeyboardInput, ModifiersState, WindowEvent};
-use crate::platform_impl::wayland::event_loop::WinitState;
-use crate::platform_impl::wayland::{self, DeviceId};
-
-use super::keymap;
-use super::KeyboardInner;
-
-#[inline]
-pub(super) fn handle_keyboard(
-    event: KeyboardEvent<'_>,
-    inner: &mut KeyboardInner,
-    winit_state: &mut WinitState,
-) {
-    let event_sink = &mut winit_state.event_sink;
-    match event {
-        KeyboardEvent::Enter { surface, .. } => {
-            let window_id = wayland::make_wid(&surface);
-
-            let window_handle = winit_state.window_map.get_mut(&window_id).unwrap();
-            window_handle.has_focus.store(true, Ordering::Relaxed);
-
-            // Window gained focus.
-            event_sink.push_window_event(WindowEvent::Focused(true), window_id);
-
-            // Dispatch modifers changes that we've received before getting `Enter` event.
-            if let Some(modifiers) = inner.pending_modifers_state.take() {
-                *inner.modifiers_state.borrow_mut() = modifiers;
-                event_sink.push_window_event(WindowEvent::ModifiersChanged(modifiers), window_id);
-            }
-
-            inner.target_window_id = Some(window_id);
-        }
-        KeyboardEvent::Leave { surface, .. } => {
-            let window_id = wayland::make_wid(&surface);
-
-            // Notify that no modifiers are being pressed.
-            if !inner.modifiers_state.borrow().is_empty() {
-                event_sink.push_window_event(
-                    WindowEvent::ModifiersChanged(ModifiersState::empty()),
-                    window_id,
-                );
-            }
-
-            let window_handle = winit_state.window_map.get_mut(&window_id).unwrap();
-            window_handle.has_focus.store(false, Ordering::Relaxed);
-
-            // Window lost focus.
-            event_sink.push_window_event(WindowEvent::Focused(false), window_id);
-
-            // Reset the id.
-            inner.target_window_id = None;
-        }
-        KeyboardEvent::Key {
-            rawkey,
-            keysym,
-            state,
-            utf8,
-            ..
-        } => {
-            let window_id = match inner.target_window_id {
-                Some(window_id) => window_id,
-                None => return,
-            };
-
-            let state = match state {
-                KeyState::Pressed => ElementState::Pressed,
-                KeyState::Released => ElementState::Released,
-                _ => unreachable!(),
-            };
-
-            let virtual_keycode = keymap::keysym_to_vkey(keysym);
-
-            event_sink.push_window_event(
-                #[allow(deprecated)]
-                WindowEvent::KeyboardInput {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    input: KeyboardInput {
-                        state,
-                        scancode: rawkey,
-                        virtual_keycode,
-                        modifiers: *inner.modifiers_state.borrow(),
-                    },
-                    is_synthetic: false,
-                },
-                window_id,
-            );
-
-            // Send ReceivedCharacter event only on ElementState::Pressed.
-            if ElementState::Released == state {
-                return;
-            }
-
-            if let Some(txt) = utf8 {
-                for ch in txt.chars() {
-                    event_sink.push_window_event(WindowEvent::ReceivedCharacter(ch), window_id);
-                }
-            }
-        }
-        KeyboardEvent::Repeat {
-            rawkey,
-            keysym,
-            utf8,
-            ..
-        } => {
-            let window_id = match inner.target_window_id {
-                Some(window_id) => window_id,
-                None => return,
-            };
-
-            let virtual_keycode = keymap::keysym_to_vkey(keysym);
-
-            event_sink.push_window_event(
-                #[allow(deprecated)]
-                WindowEvent::KeyboardInput {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    input: KeyboardInput {
-                        state: ElementState::Pressed,
-                        scancode: rawkey,
-                        virtual_keycode,
-                        modifiers: *inner.modifiers_state.borrow(),
-                    },
-                    is_synthetic: false,
-                },
-                window_id,
-            );
-
-            if let Some(txt) = utf8 {
-                for ch in txt.chars() {
-                    event_sink.push_window_event(WindowEvent::ReceivedCharacter(ch), window_id);
-                }
-            }
-        }
-        KeyboardEvent::Modifiers { modifiers } => {
-            let modifiers = ModifiersState::from(modifiers);
-            if let Some(window_id) = inner.target_window_id {
-                *inner.modifiers_state.borrow_mut() = modifiers;
-
-                event_sink.push_window_event(WindowEvent::ModifiersChanged(modifiers), window_id);
-            } else {
-                // Compositor must send modifiers after wl_keyboard::enter, however certain
-                // compositors are still sending it before, so stash such events and send
-                // them on wl_keyboard::enter.
-                inner.pending_modifers_state = Some(modifiers);
-            }
-        }
-    }
-}
--- a/src/platform_impl/linux/wayland/seat/keyboard/keymap.rs
+++ b/src/platform_impl/linux/wayland/seat/keyboard/keymap.rs
@@ -1,192 +0,0 @@
-//! Convert Wayland keys to winit keys.
-
-use crate::event::VirtualKeyCode;
-
-pub fn keysym_to_vkey(keysym: u32) -> Option<VirtualKeyCode> {
-    use sctk::seat::keyboard::keysyms;
-    match keysym {
-        // Numbers.
-        keysyms::XKB_KEY_1 => Some(VirtualKeyCode::Key1),
-        keysyms::XKB_KEY_2 => Some(VirtualKeyCode::Key2),
-        keysyms::XKB_KEY_3 => Some(VirtualKeyCode::Key3),
-        keysyms::XKB_KEY_4 => Some(VirtualKeyCode::Key4),
-        keysyms::XKB_KEY_5 => Some(VirtualKeyCode::Key5),
-        keysyms::XKB_KEY_6 => Some(VirtualKeyCode::Key6),
-        keysyms::XKB_KEY_7 => Some(VirtualKeyCode::Key7),
-        keysyms::XKB_KEY_8 => Some(VirtualKeyCode::Key8),
-        keysyms::XKB_KEY_9 => Some(VirtualKeyCode::Key9),
-        keysyms::XKB_KEY_0 => Some(VirtualKeyCode::Key0),
-        // Letters.
-        keysyms::XKB_KEY_A | keysyms::XKB_KEY_a => Some(VirtualKeyCode::A),
-        keysyms::XKB_KEY_B | keysyms::XKB_KEY_b => Some(VirtualKeyCode::B),
-        keysyms::XKB_KEY_C | keysyms::XKB_KEY_c => Some(VirtualKeyCode::C),
-        keysyms::XKB_KEY_D | keysyms::XKB_KEY_d => Some(VirtualKeyCode::D),
-        keysyms::XKB_KEY_E | keysyms::XKB_KEY_e => Some(VirtualKeyCode::E),
-        keysyms::XKB_KEY_F | keysyms::XKB_KEY_f => Some(VirtualKeyCode::F),
-        keysyms::XKB_KEY_G | keysyms::XKB_KEY_g => Some(VirtualKeyCode::G),
-        keysyms::XKB_KEY_H | keysyms::XKB_KEY_h => Some(VirtualKeyCode::H),
-        keysyms::XKB_KEY_I | keysyms::XKB_KEY_i => Some(VirtualKeyCode::I),
-        keysyms::XKB_KEY_J | keysyms::XKB_KEY_j => Some(VirtualKeyCode::J),
-        keysyms::XKB_KEY_K | keysyms::XKB_KEY_k => Some(VirtualKeyCode::K),
-        keysyms::XKB_KEY_L | keysyms::XKB_KEY_l => Some(VirtualKeyCode::L),
-        keysyms::XKB_KEY_M | keysyms::XKB_KEY_m => Some(VirtualKeyCode::M),
-        keysyms::XKB_KEY_N | keysyms::XKB_KEY_n => Some(VirtualKeyCode::N),
-        keysyms::XKB_KEY_O | keysyms::XKB_KEY_o => Some(VirtualKeyCode::O),
-        keysyms::XKB_KEY_P | keysyms::XKB_KEY_p => Some(VirtualKeyCode::P),
-        keysyms::XKB_KEY_Q | keysyms::XKB_KEY_q => Some(VirtualKeyCode::Q),
-        keysyms::XKB_KEY_R | keysyms::XKB_KEY_r => Some(VirtualKeyCode::R),
-        keysyms::XKB_KEY_S | keysyms::XKB_KEY_s => Some(VirtualKeyCode::S),
-        keysyms::XKB_KEY_T | keysyms::XKB_KEY_t => Some(VirtualKeyCode::T),
-        keysyms::XKB_KEY_U | keysyms::XKB_KEY_u => Some(VirtualKeyCode::U),
-        keysyms::XKB_KEY_V | keysyms::XKB_KEY_v => Some(VirtualKeyCode::V),
-        keysyms::XKB_KEY_W | keysyms::XKB_KEY_w => Some(VirtualKeyCode::W),
-        keysyms::XKB_KEY_X | keysyms::XKB_KEY_x => Some(VirtualKeyCode::X),
-        keysyms::XKB_KEY_Y | keysyms::XKB_KEY_y => Some(VirtualKeyCode::Y),
-        keysyms::XKB_KEY_Z | keysyms::XKB_KEY_z => Some(VirtualKeyCode::Z),
-        // Escape.
-        keysyms::XKB_KEY_Escape => Some(VirtualKeyCode::Escape),
-        // Function keys.
-        keysyms::XKB_KEY_F1 => Some(VirtualKeyCode::F1),
-        keysyms::XKB_KEY_F2 => Some(VirtualKeyCode::F2),
-        keysyms::XKB_KEY_F3 => Some(VirtualKeyCode::F3),
-        keysyms::XKB_KEY_F4 => Some(VirtualKeyCode::F4),
-        keysyms::XKB_KEY_F5 => Some(VirtualKeyCode::F5),
-        keysyms::XKB_KEY_F6 => Some(VirtualKeyCode::F6),
-        keysyms::XKB_KEY_F7 => Some(VirtualKeyCode::F7),
-        keysyms::XKB_KEY_F8 => Some(VirtualKeyCode::F8),
-        keysyms::XKB_KEY_F9 => Some(VirtualKeyCode::F9),
-        keysyms::XKB_KEY_F10 => Some(VirtualKeyCode::F10),
-        keysyms::XKB_KEY_F11 => Some(VirtualKeyCode::F11),
-        keysyms::XKB_KEY_F12 => Some(VirtualKeyCode::F12),
-        keysyms::XKB_KEY_F13 => Some(VirtualKeyCode::F13),
-        keysyms::XKB_KEY_F14 => Some(VirtualKeyCode::F14),
-        keysyms::XKB_KEY_F15 => Some(VirtualKeyCode::F15),
-        keysyms::XKB_KEY_F16 => Some(VirtualKeyCode::F16),
-        keysyms::XKB_KEY_F17 => Some(VirtualKeyCode::F17),
-        keysyms::XKB_KEY_F18 => Some(VirtualKeyCode::F18),
-        keysyms::XKB_KEY_F19 => Some(VirtualKeyCode::F19),
-        keysyms::XKB_KEY_F20 => Some(VirtualKeyCode::F20),
-        keysyms::XKB_KEY_F21 => Some(VirtualKeyCode::F21),
-        keysyms::XKB_KEY_F22 => Some(VirtualKeyCode::F22),
-        keysyms::XKB_KEY_F23 => Some(VirtualKeyCode::F23),
-        keysyms::XKB_KEY_F24 => Some(VirtualKeyCode::F24),
-        // Flow control.
-        keysyms::XKB_KEY_Print => Some(VirtualKeyCode::Snapshot),
-        keysyms::XKB_KEY_Scroll_Lock => Some(VirtualKeyCode::Scroll),
-        keysyms::XKB_KEY_Pause => Some(VirtualKeyCode::Pause),
-        keysyms::XKB_KEY_Insert => Some(VirtualKeyCode::Insert),
-        keysyms::XKB_KEY_Home => Some(VirtualKeyCode::Home),
-        keysyms::XKB_KEY_Delete => Some(VirtualKeyCode::Delete),
-        keysyms::XKB_KEY_End => Some(VirtualKeyCode::End),
-        keysyms::XKB_KEY_Page_Down => Some(VirtualKeyCode::PageDown),
-        keysyms::XKB_KEY_Page_Up => Some(VirtualKeyCode::PageUp),
-        // Arrows.
-        keysyms::XKB_KEY_Left => Some(VirtualKeyCode::Left),
-        keysyms::XKB_KEY_Up => Some(VirtualKeyCode::Up),
-        keysyms::XKB_KEY_Right => Some(VirtualKeyCode::Right),
-        keysyms::XKB_KEY_Down => Some(VirtualKeyCode::Down),
-
-        keysyms::XKB_KEY_BackSpace => Some(VirtualKeyCode::Back),
-        keysyms::XKB_KEY_Return => Some(VirtualKeyCode::Return),
-        keysyms::XKB_KEY_space => Some(VirtualKeyCode::Space),
-
-        keysyms::XKB_KEY_Multi_key => Some(VirtualKeyCode::Compose),
-        keysyms::XKB_KEY_caret => Some(VirtualKeyCode::Caret),
-
-        // Keypad.
-        keysyms::XKB_KEY_Num_Lock => Some(VirtualKeyCode::Numlock),
-        keysyms::XKB_KEY_KP_0 => Some(VirtualKeyCode::Numpad0),
-        keysyms::XKB_KEY_KP_1 => Some(VirtualKeyCode::Numpad1),
-        keysyms::XKB_KEY_KP_2 => Some(VirtualKeyCode::Numpad2),
-        keysyms::XKB_KEY_KP_3 => Some(VirtualKeyCode::Numpad3),
-        keysyms::XKB_KEY_KP_4 => Some(VirtualKeyCode::Numpad4),
-        keysyms::XKB_KEY_KP_5 => Some(VirtualKeyCode::Numpad5),
-        keysyms::XKB_KEY_KP_6 => Some(VirtualKeyCode::Numpad6),
-        keysyms::XKB_KEY_KP_7 => Some(VirtualKeyCode::Numpad7),
-        keysyms::XKB_KEY_KP_8 => Some(VirtualKeyCode::Numpad8),
-        keysyms::XKB_KEY_KP_9 => Some(VirtualKeyCode::Numpad9),
-        // Misc.
-        // => Some(VirtualKeyCode::AbntC1),
-        // => Some(VirtualKeyCode::AbntC2),
-        keysyms::XKB_KEY_plus => Some(VirtualKeyCode::Plus),
-        keysyms::XKB_KEY_apostrophe => Some(VirtualKeyCode::Apostrophe),
-        // => Some(VirtualKeyCode::Apps),
-        keysyms::XKB_KEY_at => Some(VirtualKeyCode::At),
-        // => Some(VirtualKeyCode::Ax),
-        keysyms::XKB_KEY_backslash => Some(VirtualKeyCode::Backslash),
-        keysyms::XKB_KEY_XF86Calculator => Some(VirtualKeyCode::Calculator),
-        // => Some(VirtualKeyCode::Capital),
-        keysyms::XKB_KEY_colon => Some(VirtualKeyCode::Colon),
-        keysyms::XKB_KEY_comma => Some(VirtualKeyCode::Comma),
-        // => Some(VirtualKeyCode::Convert),
-        keysyms::XKB_KEY_equal => Some(VirtualKeyCode::Equals),
-        keysyms::XKB_KEY_grave => Some(VirtualKeyCode::Grave),
-        // => Some(VirtualKeyCode::Kana),
-        keysyms::XKB_KEY_Kanji => Some(VirtualKeyCode::Kanji),
-        keysyms::XKB_KEY_Alt_L => Some(VirtualKeyCode::LAlt),
-        keysyms::XKB_KEY_bracketleft => Some(VirtualKeyCode::LBracket),
-        keysyms::XKB_KEY_Control_L => Some(VirtualKeyCode::LControl),
-        keysyms::XKB_KEY_Shift_L => Some(VirtualKeyCode::LShift),
-        keysyms::XKB_KEY_Super_L => Some(VirtualKeyCode::LWin),
-        keysyms::XKB_KEY_XF86Mail => Some(VirtualKeyCode::Mail),
-        // => Some(VirtualKeyCode::MediaSelect),
-        // => Some(VirtualKeyCode::MediaStop),
-        keysyms::XKB_KEY_minus => Some(VirtualKeyCode::Minus),
-        keysyms::XKB_KEY_asterisk => Some(VirtualKeyCode::Asterisk),
-        keysyms::XKB_KEY_XF86AudioMute => Some(VirtualKeyCode::Mute),
-        // => Some(VirtualKeyCode::MyComputer),
-        keysyms::XKB_KEY_XF86AudioNext => Some(VirtualKeyCode::NextTrack),
-        // => Some(VirtualKeyCode::NoConvert),
-        keysyms::XKB_KEY_KP_Separator => Some(VirtualKeyCode::NumpadComma),
-        keysyms::XKB_KEY_KP_Enter => Some(VirtualKeyCode::NumpadEnter),
-        keysyms::XKB_KEY_KP_Equal => Some(VirtualKeyCode::NumpadEquals),
-        keysyms::XKB_KEY_KP_Add => Some(VirtualKeyCode::NumpadAdd),
-        keysyms::XKB_KEY_KP_Subtract => Some(VirtualKeyCode::NumpadSubtract),
-        keysyms::XKB_KEY_KP_Multiply => Some(VirtualKeyCode::NumpadMultiply),
-        keysyms::XKB_KEY_KP_Divide => Some(VirtualKeyCode::NumpadDivide),
-        keysyms::XKB_KEY_KP_Decimal => Some(VirtualKeyCode::NumpadDecimal),
-        keysyms::XKB_KEY_KP_Page_Up => Some(VirtualKeyCode::PageUp),
-        keysyms::XKB_KEY_KP_Page_Down => Some(VirtualKeyCode::PageDown),
-        keysyms::XKB_KEY_KP_Home => Some(VirtualKeyCode::Home),
-        keysyms::XKB_KEY_KP_End => Some(VirtualKeyCode::End),
-        keysyms::XKB_KEY_KP_Left => Some(VirtualKeyCode::Left),
-        keysyms::XKB_KEY_KP_Up => Some(VirtualKeyCode::Up),
-        keysyms::XKB_KEY_KP_Right => Some(VirtualKeyCode::Right),
-        keysyms::XKB_KEY_KP_Down => Some(VirtualKeyCode::Down),
-        // => Some(VirtualKeyCode::OEM102),
-        keysyms::XKB_KEY_period => Some(VirtualKeyCode::Period),
-        // => Some(VirtualKeyCode::Playpause),
-        keysyms::XKB_KEY_XF86PowerOff => Some(VirtualKeyCode::Power),
-        keysyms::XKB_KEY_XF86AudioPrev => Some(VirtualKeyCode::PrevTrack),
-        keysyms::XKB_KEY_Alt_R => Some(VirtualKeyCode::RAlt),
-        keysyms::XKB_KEY_bracketright => Some(VirtualKeyCode::RBracket),
-        keysyms::XKB_KEY_Control_R => Some(VirtualKeyCode::RControl),
-        keysyms::XKB_KEY_Shift_R => Some(VirtualKeyCode::RShift),
-        keysyms::XKB_KEY_Super_R => Some(VirtualKeyCode::RWin),
-        keysyms::XKB_KEY_semicolon => Some(VirtualKeyCode::Semicolon),
-        keysyms::XKB_KEY_slash => Some(VirtualKeyCode::Slash),
-        keysyms::XKB_KEY_XF86Sleep => Some(VirtualKeyCode::Sleep),
-        // => Some(VirtualKeyCode::Stop),
-        // => Some(VirtualKeyCode::Sysrq),
-        keysyms::XKB_KEY_Tab => Some(VirtualKeyCode::Tab),
-        keysyms::XKB_KEY_ISO_Left_Tab => Some(VirtualKeyCode::Tab),
-        keysyms::XKB_KEY_underscore => Some(VirtualKeyCode::Underline),
-        // => Some(VirtualKeyCode::Unlabeled),
-        keysyms::XKB_KEY_XF86AudioLowerVolume => Some(VirtualKeyCode::VolumeDown),
-        keysyms::XKB_KEY_XF86AudioRaiseVolume => Some(VirtualKeyCode::VolumeUp),
-        // => Some(VirtualKeyCode::Wake),
-        // => Some(VirtualKeyCode::Webback),
-        // => Some(VirtualKeyCode::WebFavorites),
-        // => Some(VirtualKeyCode::WebForward),
-        // => Some(VirtualKeyCode::WebHome),
-        // => Some(VirtualKeyCode::WebRefresh),
-        // => Some(VirtualKeyCode::WebSearch),
-        // => Some(VirtualKeyCode::WebStop),
-        keysyms::XKB_KEY_yen => Some(VirtualKeyCode::Yen),
-        keysyms::XKB_KEY_XF86Copy => Some(VirtualKeyCode::Copy),
-        keysyms::XKB_KEY_XF86Paste => Some(VirtualKeyCode::Paste),
-        keysyms::XKB_KEY_XF86Cut => Some(VirtualKeyCode::Cut),
-        // Fallback.
-        _ => None,
-    }
-}
--- a/src/platform_impl/linux/wayland/seat/keyboard/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/keyboard/mod.rs
@@ -1,90 +1,373 @@
-//! Wayland keyboard handling.
+//! The keyboard input handling.

-use std::cell::RefCell;
-use std::rc::Rc;
+use std::sync::Mutex;
+use std::time::Duration;
+
+use calloop::timer::{TimeoutAction, Timer};
+use calloop::{LoopHandle, RegistrationToken};
+use log::warn;

 use sctk::reexports::client::protocol::wl_keyboard::WlKeyboard;
+use sctk::reexports::client::protocol::wl_keyboard::{
+    Event as WlKeyboardEvent, KeyState as WlKeyState, KeymapFormat as WlKeymapFormat,
+};
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
-use sctk::reexports::client::Attached;
+use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, WEnum};

-use sctk::reexports::calloop::LoopHandle;
+use crate::event::{ElementState, WindowEvent};
+use crate::keyboard::ModifiersState;

-use sctk::seat::keyboard;
+use crate::platform_impl::common::xkb_state::KbdState;
+use crate::platform_impl::wayland::event_loop::sink::EventSink;
+use crate::platform_impl::wayland::seat::WinitSeatState;
+use crate::platform_impl::wayland::state::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId, WindowId};

-use crate::event::ModifiersState;
-use crate::platform_impl::wayland::event_loop::WinitState;
-use crate::platform_impl::wayland::WindowId;
+impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
+    fn event(
+        state: &mut WinitState,
+        wl_keyboard: &WlKeyboard,
+        event: <WlKeyboard as Proxy>::Event,
+        data: &KeyboardData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        let seat_state = match state.seats.get_mut(&data.seat.id()) {
+            Some(seat_state) => seat_state,
+            None => return,
+        };

-mod handlers;
-mod keymap;
-
-pub(crate) struct Keyboard {
-    pub keyboard: WlKeyboard,
-}
-
-impl Keyboard {
-    pub fn new(
-        seat: &Attached<WlSeat>,
-        loop_handle: LoopHandle<'static, WinitState>,
-        modifiers_state: Rc<RefCell<ModifiersState>>,
-    ) -> Option<Self> {
-        let mut inner = KeyboardInner::new(modifiers_state);
-        let keyboard = keyboard::map_keyboard_repeat(
-            loop_handle.clone(),
-            seat,
-            None,
-            keyboard::RepeatKind::System,
-            move |event, _, mut dispatch_data| {
-                let winit_state = dispatch_data.get::<WinitState>().unwrap();
-                handlers::handle_keyboard(event, &mut inner, winit_state);
+        match event {
+            WlKeyboardEvent::Keymap { format, fd, size } => match format {
+                WEnum::Value(format) => match format {
+                    WlKeymapFormat::NoKeymap => {
+                        warn!("non-xkb compatible keymap")
+                    }
+                    WlKeymapFormat::XkbV1 => unsafe {
+                        seat_state
+                            .keyboard_state
+                            .as_mut()
+                            .unwrap()
+                            .xkb_state
+                            .init_with_fd(fd, size as usize);
+                    },
+                    _ => unreachable!(),
+                },
+                WEnum::Unknown(value) => {
+                    warn!("unknown keymap format 0x{:x}", value)
+                }
            },
-        )
-        .ok()?;
+            WlKeyboardEvent::Enter { surface, .. } => {
+                let window_id = wayland::make_wid(&surface);

-        Some(Self { keyboard })
+                // Mark the window as focused.
+                match state.windows.get_mut().get(&window_id) {
+                    Some(window) => window.lock().unwrap().set_has_focus(true),
+                    None => return,
+                };
+
+                // Drop the repeat, if there were any.
+                seat_state.keyboard_state.as_mut().unwrap().current_repeat = None;
+
+                // The keyboard focus is considered as general focus.
+                state
+                    .events_sink
+                    .push_window_event(WindowEvent::Focused(true), window_id);
+
+                *data.window_id.lock().unwrap() = Some(window_id);
+
+                // HACK: this is just for GNOME not fixing their ordering issue of modifiers.
+                if std::mem::take(&mut seat_state.modifiers_pending) {
+                    state.events_sink.push_window_event(
+                        WindowEvent::ModifiersChanged(seat_state.modifiers.into()),
+                        window_id,
+                    );
+                }
+            }
+            WlKeyboardEvent::Leave { surface, .. } => {
+                let window_id = wayland::make_wid(&surface);
+
+                // NOTE: we should drop the repeat regardless whethere it was for the present
+                // window of for the window which just went gone.
+                seat_state.keyboard_state.as_mut().unwrap().current_repeat = None;
+
+                // NOTE: The check whether the window exists is essential as we might get a
+                // nil surface, regardless of what protocol says.
+                match state.windows.get_mut().get(&window_id) {
+                    Some(window) => window.lock().unwrap().set_has_focus(false),
+                    None => return,
+                };
+
+                // Notify that no modifiers are being pressed.
+                state.events_sink.push_window_event(
+                    WindowEvent::ModifiersChanged(ModifiersState::empty().into()),
+                    window_id,
+                );
+
+                // We don't need to update it above, because the next `Enter` will overwrite
+                // anyway.
+                *data.window_id.lock().unwrap() = None;
+
+                state
+                    .events_sink
+                    .push_window_event(WindowEvent::Focused(false), window_id);
+            }
+            WlKeyboardEvent::Key {
+                key,
+                state: key_state,
+                ..
+            } if key_state == WEnum::Value(WlKeyState::Pressed) => {
+                let key = key + 8;
+
+                key_input(
+                    seat_state,
+                    &mut state.events_sink,
+                    data,
+                    key,
+                    ElementState::Pressed,
+                    false,
+                );
+
+                let keyboard_state = seat_state.keyboard_state.as_mut().unwrap();
+                let delay = match keyboard_state.repeat_info {
+                    RepeatInfo::Repeat { delay, .. } => delay,
+                    RepeatInfo::Disable => return,
+                };
+
+                if !keyboard_state.xkb_state.key_repeats(key) {
+                    return;
+                }
+
+                keyboard_state.current_repeat = Some(key);
+
+                // NOTE terminate ongoing timer and start a new timer.
+
+                if let Some(token) = keyboard_state.repeat_token.take() {
+                    keyboard_state.loop_handle.remove(token);
+                }
+
+                let timer = Timer::from_duration(delay);
+                let wl_keyboard = wl_keyboard.clone();
+                keyboard_state.repeat_token = keyboard_state
+                    .loop_handle
+                    .insert_source(timer, move |_, _, state| {
+                        let data = wl_keyboard.data::<KeyboardData>().unwrap();
+                        let seat_state = state.seats.get_mut(&data.seat.id()).unwrap();
+
+                        // NOTE: The removed on event source is batched, but key change to
+                        // `None` is instant.
+                        let repeat_keycode =
+                            match seat_state.keyboard_state.as_ref().unwrap().current_repeat {
+                                Some(repeat_keycode) => repeat_keycode,
+                                None => return TimeoutAction::Drop,
+                            };
+
+                        key_input(
+                            seat_state,
+                            &mut state.events_sink,
+                            data,
+                            repeat_keycode,
+                            ElementState::Pressed,
+                            true,
+                        );
+
+                        // NOTE: the gap could change dynamically while repeat is going.
+                        match seat_state.keyboard_state.as_ref().unwrap().repeat_info {
+                            RepeatInfo::Repeat { gap, .. } => TimeoutAction::ToDuration(gap),
+                            RepeatInfo::Disable => TimeoutAction::Drop,
+                        }
+                    })
+                    .ok();
+            }
+            WlKeyboardEvent::Key {
+                key,
+                state: key_state,
+                ..
+            } if key_state == WEnum::Value(WlKeyState::Released) => {
+                let key = key + 8;
+
+                key_input(
+                    seat_state,
+                    &mut state.events_sink,
+                    data,
+                    key,
+                    ElementState::Released,
+                    false,
+                );
+
+                let keyboard_state = seat_state.keyboard_state.as_mut().unwrap();
+                if keyboard_state.repeat_info != RepeatInfo::Disable
+                    && keyboard_state.xkb_state.key_repeats(key)
+                    && Some(key) == keyboard_state.current_repeat
+                {
+                    keyboard_state.current_repeat = None;
+                }
+            }
+            WlKeyboardEvent::Modifiers {
+                mods_depressed,
+                mods_latched,
+                mods_locked,
+                group,
+                ..
+            } => {
+                let xkb_state = &mut seat_state.keyboard_state.as_mut().unwrap().xkb_state;
+                xkb_state.update_modifiers(mods_depressed, mods_latched, mods_locked, 0, 0, group);
+                seat_state.modifiers = xkb_state.mods_state().into();
+
+                // HACK: part of the workaround from `WlKeyboardEvent::Enter`.
+                let window_id = match *data.window_id.lock().unwrap() {
+                    Some(window_id) => window_id,
+                    None => {
+                        seat_state.modifiers_pending = true;
+                        return;
+                    }
+                };
+
+                state.events_sink.push_window_event(
+                    WindowEvent::ModifiersChanged(seat_state.modifiers.into()),
+                    window_id,
+                );
+            }
+            WlKeyboardEvent::RepeatInfo { rate, delay } => {
+                let keyboard_state = seat_state.keyboard_state.as_mut().unwrap();
+                keyboard_state.repeat_info = if rate == 0 {
+                    // Stop the repeat once we get a disable event.
+                    keyboard_state.current_repeat = None;
+                    if let Some(repeat_token) = keyboard_state.repeat_token.take() {
+                        keyboard_state.loop_handle.remove(repeat_token);
+                    }
+                    RepeatInfo::Disable
+                } else {
+                    let gap = Duration::from_micros(1_000_000 / rate as u64);
+                    let delay = Duration::from_millis(delay as u64);
+                    RepeatInfo::Repeat { gap, delay }
+                };
+            }
+            _ => unreachable!(),
+        }
    }
 }

-impl Drop for Keyboard {
+/// The state of the keyboard on the current seat.
+#[derive(Debug)]
+pub struct KeyboardState {
+    /// The underlying WlKeyboard.
+    pub keyboard: WlKeyboard,
+
+    /// Loop handle to handle key repeat.
+    pub loop_handle: LoopHandle<'static, WinitState>,
+
+    /// The state of the keyboard.
+    pub xkb_state: KbdState,
+
+    /// The information about the repeat rate obtained from the compositor.
+    pub repeat_info: RepeatInfo,
+
+    /// The token of the current handle inside the calloop's event loop.
+    pub repeat_token: Option<RegistrationToken>,
+
+    /// The current repeat raw key.
+    pub current_repeat: Option<u32>,
+}
+
+impl KeyboardState {
+    pub fn new(keyboard: WlKeyboard, loop_handle: LoopHandle<'static, WinitState>) -> Self {
+        Self {
+            keyboard,
+            loop_handle,
+            xkb_state: KbdState::new().unwrap(),
+            repeat_info: RepeatInfo::default(),
+            repeat_token: None,
+            current_repeat: None,
+        }
+    }
+}
+
+impl Drop for KeyboardState {
    fn drop(&mut self) {
-        if self.keyboard.as_ref().version() >= 3 {
+        if self.keyboard.version() >= 3 {
            self.keyboard.release();
        }
-    }
-}

-struct KeyboardInner {
-    /// Currently focused surface.
-    target_window_id: Option<WindowId>,
-
-    /// A pending state of modifiers.
-    ///
-    /// This state is getting set if we've got a modifiers update
-    /// before `Enter` event, which shouldn't happen in general, however
-    /// some compositors are still doing so.
-    pending_modifers_state: Option<ModifiersState>,
-
-    /// Current state of modifiers keys.
-    modifiers_state: Rc<RefCell<ModifiersState>>,
-}
-
-impl KeyboardInner {
-    fn new(modifiers_state: Rc<RefCell<ModifiersState>>) -> Self {
-        Self {
-            target_window_id: None,
-            pending_modifers_state: None,
-            modifiers_state,
+        if let Some(token) = self.repeat_token.take() {
+            self.loop_handle.remove(token);
        }
    }
 }

-impl From<keyboard::ModifiersState> for ModifiersState {
-    fn from(mods: keyboard::ModifiersState) -> ModifiersState {
-        let mut wl_mods = ModifiersState::empty();
-        wl_mods.set(ModifiersState::SHIFT, mods.shift);
-        wl_mods.set(ModifiersState::CTRL, mods.ctrl);
-        wl_mods.set(ModifiersState::ALT, mods.alt);
-        wl_mods.set(ModifiersState::LOGO, mods.logo);
-        wl_mods
+/// The rate at which a pressed key is repeated.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RepeatInfo {
+    /// Keys will be repeated at the specified rate and delay.
+    Repeat {
+        /// The time between the key repeats.
+        gap: Duration,
+
+        /// Delay (in milliseconds) between a key press and the start of repetition.
+        delay: Duration,
+    },
+
+    /// Keys should not be repeated.
+    Disable,
+}
+
+impl Default for RepeatInfo {
+    /// The default repeat rate is 25 keys per second with the delay of 200ms.
+    ///
+    /// The values are picked based on the default in various compositors and Xorg.
+    fn default() -> Self {
+        Self::Repeat {
+            gap: Duration::from_millis(40),
+            delay: Duration::from_millis(200),
+        }
    }
 }
+
+/// Keyboard user data.
+#[derive(Debug)]
+pub struct KeyboardData {
+    /// The currently focused window surface. Could be `None` on bugged compositors, like mutter.
+    window_id: Mutex<Option<WindowId>>,
+
+    /// The seat used to create this keyboard.
+    seat: WlSeat,
+}
+
+impl KeyboardData {
+    pub fn new(seat: WlSeat) -> Self {
+        Self {
+            window_id: Default::default(),
+            seat,
+        }
+    }
+}
+
+fn key_input(
+    seat_state: &mut WinitSeatState,
+    event_sink: &mut EventSink,
+    data: &KeyboardData,
+    keycode: u32,
+    state: ElementState,
+    repeat: bool,
+) {
+    let window_id = match *data.window_id.lock().unwrap() {
+        Some(window_id) => window_id,
+        None => return,
+    };
+
+    let keyboard_state = seat_state.keyboard_state.as_mut().unwrap();
+
+    let device_id = crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId));
+    let event = keyboard_state
+        .xkb_state
+        .process_key_event(keycode, state, repeat);
+
+    event_sink.push_window_event(
+        WindowEvent::KeyboardInput {
+            device_id,
+            event,
+            is_synthetic: false,
+        },
+        window_id,
+    );
+}
--- a/src/platform_impl/linux/wayland/seat/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/mod.rs
@@ -1,208 +1,212 @@
-//! Seat handling and managing.
+//! Seat handling.

-use std::cell::RefCell;
-use std::rc::Rc;
+use std::sync::Arc;

-use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1;
-use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1;
-use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
+use fnv::FnvHashMap;

 use sctk::reexports::client::protocol::wl_seat::WlSeat;
-use sctk::reexports::client::Attached;
+use sctk::reexports::client::protocol::wl_touch::WlTouch;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+use sctk::reexports::protocols::wp::relative_pointer::zv1::client::zwp_relative_pointer_v1::ZwpRelativePointerV1;
+use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::ZwpTextInputV3;

-use sctk::environment::Environment;
-use sctk::reexports::calloop::LoopHandle;
-use sctk::seat::pointer::ThemeManager;
-use sctk::seat::{SeatData, SeatListener};
+use sctk::seat::pointer::{ThemeSpec, ThemedPointer};
+use sctk::seat::{Capability as SeatCapability, SeatHandler, SeatState};

-use super::env::WinitEnv;
-use super::event_loop::WinitState;
-use crate::event::ModifiersState;
+use crate::keyboard::ModifiersState;
+use crate::platform_impl::wayland::state::WinitState;

 mod keyboard;
-pub mod pointer;
-pub mod text_input;
+mod pointer;
+mod text_input;
 mod touch;

-use keyboard::Keyboard;
-use pointer::Pointers;
-use text_input::TextInput;
-use touch::Touch;
+pub use pointer::relative_pointer::RelativePointerState;
+pub use pointer::{PointerConstraintsState, WinitPointerData, WinitPointerDataExt};
+pub use text_input::{TextInputState, ZwpTextInputV3Ext};

-pub struct SeatManager {
-    /// Listener for seats.
-    _seat_listener: SeatListener,
+use keyboard::{KeyboardData, KeyboardState};
+use text_input::TextInputData;
+use touch::TouchPoint;
+
+#[derive(Debug)]
+pub struct WinitSeatState {
+    /// The pointer bound on the seat.
+    pointer: Option<Arc<ThemedPointer<WinitPointerData>>>,
+
+    /// The touch bound on the seat.
+    touch: Option<WlTouch>,
+
+    /// The mapping from touched points to the surfaces they're present.
+    touch_map: FnvHashMap<i32, TouchPoint>,
+
+    /// The text input bound on the seat.
+    text_input: Option<Arc<ZwpTextInputV3>>,
+
+    /// The relative pointer bound on the seat.
+    relative_pointer: Option<ZwpRelativePointerV1>,
+
+    /// The keyboard bound on the seat.
+    keyboard_state: Option<KeyboardState>,
+
+    /// The current modifiers state on the seat.
+    modifiers: ModifiersState,
+
+    /// Wether we have pending modifiers.
+    modifiers_pending: bool,
 }

-impl SeatManager {
-    pub fn new(
-        env: &Environment<WinitEnv>,
-        loop_handle: LoopHandle<'static, WinitState>,
-        theme_manager: ThemeManager,
-    ) -> Self {
-        let relative_pointer_manager = env.get_global::<ZwpRelativePointerManagerV1>();
-        let pointer_constraints = env.get_global::<ZwpPointerConstraintsV1>();
-        let text_input_manager = env.get_global::<ZwpTextInputManagerV3>();
-
-        let mut inner = SeatManagerInner::new(
-            theme_manager,
-            relative_pointer_manager,
-            pointer_constraints,
-            text_input_manager,
-            loop_handle,
-        );
-
-        // Handle existing seats.
-        for seat in env.get_all_seats() {
-            let seat_data = match sctk::seat::clone_seat_data(&seat) {
-                Some(seat_data) => seat_data,
-                None => continue,
-            };
-
-            inner.process_seat_update(&seat, &seat_data);
-        }
-
-        let seat_listener = env.listen_for_seats(move |seat, seat_data, _| {
-            inner.process_seat_update(&seat, seat_data);
-        });
-
+impl WinitSeatState {
+    pub fn new() -> Self {
        Self {
-            _seat_listener: seat_listener,
-        }
-    }
-}
-
-/// Inner state of the seat manager.
-struct SeatManagerInner {
-    /// Currently observed seats.
-    seats: Vec<SeatInfo>,
-
-    /// Loop handle.
-    loop_handle: LoopHandle<'static, WinitState>,
-
-    /// Relative pointer manager.
-    relative_pointer_manager: Option<Attached<ZwpRelativePointerManagerV1>>,
-
-    /// Pointer constraints.
-    pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
-
-    /// Text input manager.
-    text_input_manager: Option<Attached<ZwpTextInputManagerV3>>,
-
-    /// A theme manager.
-    theme_manager: ThemeManager,
-}
-
-impl SeatManagerInner {
-    fn new(
-        theme_manager: ThemeManager,
-        relative_pointer_manager: Option<Attached<ZwpRelativePointerManagerV1>>,
-        pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
-        text_input_manager: Option<Attached<ZwpTextInputManagerV3>>,
-        loop_handle: LoopHandle<'static, WinitState>,
-    ) -> Self {
-        Self {
-            seats: Vec::new(),
-            loop_handle,
-            relative_pointer_manager,
-            pointer_constraints,
-            text_input_manager,
-            theme_manager,
-        }
-    }
-
-    /// Handle seats update from the `SeatListener`.
-    pub fn process_seat_update(&mut self, seat: &Attached<WlSeat>, seat_data: &SeatData) {
-        let detached_seat = seat.detach();
-
-        let position = self.seats.iter().position(|si| si.seat == detached_seat);
-        let index = position.unwrap_or_else(|| {
-            self.seats.push(SeatInfo::new(detached_seat));
-            self.seats.len() - 1
-        });
-
-        let seat_info = &mut self.seats[index];
-
-        // Pointer handling.
-        if seat_data.has_pointer && !seat_data.defunct {
-            if seat_info.pointer.is_none() {
-                seat_info.pointer = Some(Pointers::new(
-                    seat,
-                    &self.theme_manager,
-                    &self.relative_pointer_manager,
-                    &self.pointer_constraints,
-                    seat_info.modifiers_state.clone(),
-                ));
-            }
-        } else {
-            seat_info.pointer = None;
-        }
-
-        // Handle keyboard.
-        if seat_data.has_keyboard && !seat_data.defunct {
-            if seat_info.keyboard.is_none() {
-                seat_info.keyboard = Keyboard::new(
-                    seat,
-                    self.loop_handle.clone(),
-                    seat_info.modifiers_state.clone(),
-                );
-            }
-        } else {
-            seat_info.keyboard = None;
-        }
-
-        // Handle touch.
-        if seat_data.has_touch && !seat_data.defunct {
-            if seat_info.touch.is_none() {
-                seat_info.touch = Some(Touch::new(seat));
-            }
-        } else {
-            seat_info.touch = None;
-        }
-
-        // Handle text input.
-        if let Some(text_input_manager) = self.text_input_manager.as_ref() {
-            if seat_data.defunct {
-                seat_info.text_input = None;
-            } else if seat_info.text_input.is_none() {
-                seat_info.text_input = Some(TextInput::new(seat, text_input_manager));
-            }
-        }
-    }
-}
-
-/// Resources associtated with a given seat.
-struct SeatInfo {
-    /// Seat to which this `SeatInfo` belongs.
-    seat: WlSeat,
-
-    /// A keyboard handle with its repeat rate handling.
-    keyboard: Option<Keyboard>,
-
-    /// All pointers we're using on a seat.
-    pointer: Option<Pointers>,
-
-    /// Touch handling.
-    touch: Option<Touch>,
-
-    /// Text input handling aka IME.
-    text_input: Option<TextInput>,
-
-    /// The current state of modifiers observed in keyboard handler.
-    ///
-    /// We keep modifiers state on a seat, since it's being used by pointer events as well.
-    modifiers_state: Rc<RefCell<ModifiersState>>,
-}
-
-impl SeatInfo {
-    pub fn new(seat: WlSeat) -> Self {
-        Self {
-            seat,
-            keyboard: None,
            pointer: None,
            touch: None,
+            relative_pointer: None,
            text_input: None,
-            modifiers_state: Rc::new(RefCell::new(ModifiersState::default())),
+            touch_map: Default::default(),
+            keyboard_state: None,
+            modifiers: ModifiersState::empty(),
+            modifiers_pending: false,
        }
    }
 }
+
+impl SeatHandler for WinitState {
+    fn seat_state(&mut self) -> &mut SeatState {
+        &mut self.seat_state
+    }
+
+    fn new_capability(
+        &mut self,
+        _: &Connection,
+        queue_handle: &QueueHandle<Self>,
+        seat: WlSeat,
+        capability: SeatCapability,
+    ) {
+        let seat_state = self.seats.get_mut(&seat.id()).unwrap();
+
+        match capability {
+            SeatCapability::Touch if seat_state.touch.is_none() => {
+                seat_state.touch = self.seat_state.get_touch(queue_handle, &seat).ok();
+            }
+            SeatCapability::Keyboard if seat_state.keyboard_state.is_none() => {
+                let keyboard = seat.get_keyboard(queue_handle, KeyboardData::new(seat.clone()));
+                seat_state.keyboard_state =
+                    Some(KeyboardState::new(keyboard, self.loop_handle.clone()));
+            }
+            SeatCapability::Pointer if seat_state.pointer.is_none() => {
+                let surface = self.compositor_state.create_surface(queue_handle);
+                let surface_id = surface.id();
+                let pointer_data = WinitPointerData::new(seat.clone(), surface);
+                let themed_pointer = self
+                    .seat_state
+                    .get_pointer_with_theme_and_data(
+                        queue_handle,
+                        &seat,
+                        ThemeSpec::System,
+                        pointer_data,
+                    )
+                    .expect("failed to create pointer with present capability.");
+
+                seat_state.relative_pointer = self.relative_pointer.as_ref().map(|manager| {
+                    manager.get_relative_pointer(
+                        themed_pointer.pointer(),
+                        queue_handle,
+                        sctk::globals::GlobalData,
+                    )
+                });
+
+                let themed_pointer = Arc::new(themed_pointer);
+
+                // Register cursor surface.
+                self.pointer_surfaces
+                    .insert(surface_id, themed_pointer.clone());
+
+                seat_state.pointer = Some(themed_pointer);
+            }
+            _ => (),
+        }
+
+        if let Some(text_input_state) = seat_state
+            .text_input
+            .is_none()
+            .then_some(self.text_input_state.as_ref())
+            .flatten()
+        {
+            seat_state.text_input = Some(Arc::new(text_input_state.get_text_input(
+                &seat,
+                queue_handle,
+                TextInputData::default(),
+            )));
+        }
+    }
+
+    fn remove_capability(
+        &mut self,
+        _: &Connection,
+        _queue_handle: &QueueHandle<Self>,
+        seat: WlSeat,
+        capability: SeatCapability,
+    ) {
+        let seat_state = self.seats.get_mut(&seat.id()).unwrap();
+
+        match capability {
+            SeatCapability::Touch => {
+                if let Some(touch) = seat_state.touch.take() {
+                    if touch.version() >= 3 {
+                        touch.release();
+                    }
+                }
+            }
+            SeatCapability::Pointer => {
+                if let Some(relative_pointer) = seat_state.relative_pointer.take() {
+                    relative_pointer.destroy();
+                }
+
+                if let Some(pointer) = seat_state.pointer.take() {
+                    let pointer_data = pointer.pointer().winit_data();
+
+                    // Remove the cursor from the mapping.
+                    let surface_id = pointer_data.cursor_surface().id();
+                    let _ = self.pointer_surfaces.remove(&surface_id);
+
+                    // Remove the inner locks/confines before dropping the pointer.
+                    pointer_data.unlock_pointer();
+                    pointer_data.unconfine_pointer();
+
+                    if pointer.pointer().version() >= 3 {
+                        pointer.pointer().release();
+                    }
+                }
+            }
+            SeatCapability::Keyboard => {
+                seat_state.keyboard_state = None;
+            }
+            _ => (),
+        }
+
+        if let Some(text_input) = seat_state.text_input.take() {
+            text_input.destroy();
+        }
+    }
+
+    fn new_seat(
+        &mut self,
+        _connection: &Connection,
+        _queue_handle: &QueueHandle<Self>,
+        seat: WlSeat,
+    ) {
+        self.seats.insert(seat.id(), WinitSeatState::new());
+    }
+
+    fn remove_seat(
+        &mut self,
+        _connection: &Connection,
+        _queue_handle: &QueueHandle<Self>,
+        seat: WlSeat,
+    ) {
+        let _ = self.seats.remove(&seat.id());
+    }
+}
+
+sctk::delegate_seat!(WinitState);
--- a/src/platform_impl/linux/wayland/seat/pointer/data.rs
+++ b/src/platform_impl/linux/wayland/seat/pointer/data.rs
@@ -1,82 +0,0 @@
-//! Data which is used in pointer callbacks.
-
-use std::cell::{Cell, RefCell};
-use std::rc::Rc;
-
-use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::Attached;
-use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1;
-use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_confined_pointer_v1::ZwpConfinedPointerV1;
-use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_locked_pointer_v1::ZwpLockedPointerV1;
-
-use crate::event::{ModifiersState, TouchPhase};
-
-/// A data being used by pointer handlers.
-pub(super) struct PointerData {
-    /// Winit's surface the pointer is currently over.
-    pub surface: Option<WlSurface>,
-
-    /// Current modifiers state.
-    ///
-    /// This refers a state of modifiers from `WlKeyboard` on
-    /// the given seat.
-    pub modifiers_state: Rc<RefCell<ModifiersState>>,
-
-    /// Pointer constraints.
-    pub pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
-
-    pub confined_pointer: Rc<RefCell<Option<ZwpConfinedPointerV1>>>,
-    pub locked_pointer: Rc<RefCell<Option<ZwpLockedPointerV1>>>,
-
-    /// Latest observed serial in pointer events.
-    pub latest_serial: Rc<Cell<u32>>,
-
-    /// Latest observed serial in pointer enter events.
-    pub latest_enter_serial: Rc<Cell<u32>>,
-
-    /// The currently accumulated axis data on a pointer.
-    pub axis_data: AxisData,
-}
-
-impl PointerData {
-    pub fn new(
-        confined_pointer: Rc<RefCell<Option<ZwpConfinedPointerV1>>>,
-        locked_pointer: Rc<RefCell<Option<ZwpLockedPointerV1>>>,
-        pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
-        modifiers_state: Rc<RefCell<ModifiersState>>,
-    ) -> Self {
-        Self {
-            surface: None,
-            latest_serial: Rc::new(Cell::new(0)),
-            latest_enter_serial: Rc::new(Cell::new(0)),
-            confined_pointer,
-            locked_pointer,
-            modifiers_state,
-            pointer_constraints,
-            axis_data: AxisData::new(),
-        }
-    }
-}
-
-/// Axis data.
-#[derive(Clone, Copy)]
-pub(super) struct AxisData {
-    /// Current state of the axis.
-    pub axis_state: TouchPhase,
-
-    /// A buffer for `PixelDelta` event.
-    pub axis_buffer: Option<(f32, f32)>,
-
-    /// A buffer for `LineDelta` event.
-    pub axis_discrete_buffer: Option<(f32, f32)>,
-}
-
-impl AxisData {
-    pub fn new() -> Self {
-        Self {
-            axis_state: TouchPhase::Ended,
-            axis_buffer: None,
-            axis_discrete_buffer: None,
-        }
-    }
-}
--- a/src/platform_impl/linux/wayland/seat/pointer/handlers.rs
+++ b/src/platform_impl/linux/wayland/seat/pointer/handlers.rs
@@ -1,330 +0,0 @@
-//! Handlers for the pointers we're using.
-
-use std::cell::RefCell;
-use std::rc::Rc;
-
-use sctk::reexports::client::protocol::wl_pointer::{self, Event as PointerEvent};
-use sctk::reexports::client::protocol::wl_seat::WlSeat;
-use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_v1::Event as RelativePointerEvent;
-
-use sctk::seat::pointer::ThemedPointer;
-
-use crate::dpi::LogicalPosition;
-use crate::event::{
-    DeviceEvent, ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent,
-};
-use crate::platform_impl::wayland::event_loop::WinitState;
-use crate::platform_impl::wayland::{self, DeviceId};
-
-use super::{PointerData, WinitPointer};
-
-// These values are comming from <linux/input-event-codes.h>.
-const BTN_LEFT: u32 = 0x110;
-const BTN_RIGHT: u32 = 0x111;
-const BTN_MIDDLE: u32 = 0x112;
-
-#[inline]
-pub(super) fn handle_pointer(
-    pointer: ThemedPointer,
-    event: PointerEvent,
-    pointer_data: &Rc<RefCell<PointerData>>,
-    winit_state: &mut WinitState,
-    seat: WlSeat,
-) {
-    let event_sink = &mut winit_state.event_sink;
-    let mut pointer_data = pointer_data.borrow_mut();
-    match event {
-        PointerEvent::Enter {
-            surface,
-            surface_x,
-            surface_y,
-            serial,
-            ..
-        } => {
-            pointer_data.latest_serial.replace(serial);
-            pointer_data.latest_enter_serial.replace(serial);
-
-            let window_id = wayland::make_wid(&surface);
-            if !winit_state.window_map.contains_key(&window_id) {
-                return;
-            }
-            let window_handle = match winit_state.window_map.get_mut(&window_id) {
-                Some(window_handle) => window_handle,
-                None => return,
-            };
-
-            let scale_factor = window_handle.scale_factor();
-            pointer_data.surface = Some(surface);
-
-            // Notify window that pointer entered the surface.
-            let winit_pointer = WinitPointer {
-                pointer,
-                confined_pointer: Rc::downgrade(&pointer_data.confined_pointer),
-                locked_pointer: Rc::downgrade(&pointer_data.locked_pointer),
-                pointer_constraints: pointer_data.pointer_constraints.clone(),
-                latest_serial: pointer_data.latest_serial.clone(),
-                latest_enter_serial: pointer_data.latest_enter_serial.clone(),
-                seat,
-            };
-            window_handle.pointer_entered(winit_pointer);
-
-            event_sink.push_window_event(
-                WindowEvent::CursorEntered {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                },
-                window_id,
-            );
-
-            let position = LogicalPosition::new(surface_x, surface_y).to_physical(scale_factor);
-
-            event_sink.push_window_event(
-                WindowEvent::CursorMoved {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    position,
-                    modifiers: *pointer_data.modifiers_state.borrow(),
-                },
-                window_id,
-            );
-        }
-        PointerEvent::Leave { surface, serial } => {
-            pointer_data.surface = None;
-            pointer_data.latest_serial.replace(serial);
-
-            let window_id = wayland::make_wid(&surface);
-
-            let window_handle = match winit_state.window_map.get_mut(&window_id) {
-                Some(window_handle) => window_handle,
-                None => return,
-            };
-
-            // Notify a window that pointer is no longer observing it.
-            let winit_pointer = WinitPointer {
-                pointer,
-                confined_pointer: Rc::downgrade(&pointer_data.confined_pointer),
-                locked_pointer: Rc::downgrade(&pointer_data.locked_pointer),
-                pointer_constraints: pointer_data.pointer_constraints.clone(),
-                latest_serial: pointer_data.latest_serial.clone(),
-                latest_enter_serial: pointer_data.latest_enter_serial.clone(),
-                seat,
-            };
-            window_handle.pointer_left(winit_pointer);
-
-            event_sink.push_window_event(
-                WindowEvent::CursorLeft {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                },
-                window_id,
-            );
-        }
-        PointerEvent::Motion {
-            surface_x,
-            surface_y,
-            ..
-        } => {
-            let surface = match pointer_data.surface.as_ref() {
-                Some(surface) => surface,
-                None => return,
-            };
-
-            let window_id = wayland::make_wid(surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
-
-            let scale_factor = window_handle.scale_factor();
-            let position = LogicalPosition::new(surface_x, surface_y).to_physical(scale_factor);
-
-            event_sink.push_window_event(
-                WindowEvent::CursorMoved {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    position,
-                    modifiers: *pointer_data.modifiers_state.borrow(),
-                },
-                window_id,
-            );
-        }
-        PointerEvent::Button {
-            button,
-            state,
-            serial,
-            ..
-        } => {
-            pointer_data.latest_serial.replace(serial);
-            let window_id = match pointer_data.surface.as_ref().map(wayland::make_wid) {
-                Some(window_id) => window_id,
-                None => return,
-            };
-
-            let state = match state {
-                wl_pointer::ButtonState::Pressed => ElementState::Pressed,
-                wl_pointer::ButtonState::Released => ElementState::Released,
-                _ => unreachable!(),
-            };
-
-            let button = match button {
-                BTN_LEFT => MouseButton::Left,
-                BTN_RIGHT => MouseButton::Right,
-                BTN_MIDDLE => MouseButton::Middle,
-                button => MouseButton::Other(button as u16),
-            };
-
-            event_sink.push_window_event(
-                WindowEvent::MouseInput {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    state,
-                    button,
-                    modifiers: *pointer_data.modifiers_state.borrow(),
-                },
-                window_id,
-            );
-        }
-        PointerEvent::Axis { axis, value, .. } => {
-            let surface = match pointer_data.surface.as_ref() {
-                Some(surface) => surface,
-                None => return,
-            };
-
-            let window_id = wayland::make_wid(surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
-
-            if pointer.as_ref().version() < 5 {
-                let (mut x, mut y) = (0.0, 0.0);
-
-                // Old seat compatibility.
-                match axis {
-                    // Wayland sign convention is the inverse of winit.
-                    wl_pointer::Axis::VerticalScroll => y -= value as f32,
-                    wl_pointer::Axis::HorizontalScroll => x -= value as f32,
-                    _ => unreachable!(),
-                }
-
-                let scale_factor = window_handle.scale_factor();
-                let delta = LogicalPosition::new(x as f64, y as f64).to_physical(scale_factor);
-
-                event_sink.push_window_event(
-                    WindowEvent::MouseWheel {
-                        device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                            DeviceId,
-                        )),
-                        delta: MouseScrollDelta::PixelDelta(delta),
-                        phase: TouchPhase::Moved,
-                        modifiers: *pointer_data.modifiers_state.borrow(),
-                    },
-                    window_id,
-                );
-            } else {
-                let (mut x, mut y) = pointer_data.axis_data.axis_buffer.unwrap_or((0.0, 0.0));
-                match axis {
-                    // Wayland sign convention is the inverse of winit.
-                    wl_pointer::Axis::VerticalScroll => y -= value as f32,
-                    wl_pointer::Axis::HorizontalScroll => x -= value as f32,
-                    _ => unreachable!(),
-                }
-
-                pointer_data.axis_data.axis_buffer = Some((x, y));
-
-                pointer_data.axis_data.axis_state = match pointer_data.axis_data.axis_state {
-                    TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
-                    _ => TouchPhase::Started,
-                }
-            }
-        }
-        PointerEvent::AxisDiscrete { axis, discrete } => {
-            let (mut x, mut y) = pointer_data
-                .axis_data
-                .axis_discrete_buffer
-                .unwrap_or((0., 0.));
-
-            match axis {
-                // Wayland sign convention is the inverse of winit.
-                wl_pointer::Axis::VerticalScroll => y -= discrete as f32,
-                wl_pointer::Axis::HorizontalScroll => x -= discrete as f32,
-                _ => unreachable!(),
-            }
-
-            pointer_data.axis_data.axis_discrete_buffer = Some((x, y));
-
-            pointer_data.axis_data.axis_state = match pointer_data.axis_data.axis_state {
-                TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
-                _ => TouchPhase::Started,
-            }
-        }
-        PointerEvent::AxisSource { .. } => (),
-        PointerEvent::AxisStop { .. } => {
-            pointer_data.axis_data.axis_state = TouchPhase::Ended;
-        }
-        PointerEvent::Frame => {
-            let axis_buffer = pointer_data.axis_data.axis_buffer.take();
-            let axis_discrete_buffer = pointer_data.axis_data.axis_discrete_buffer.take();
-
-            let surface = match pointer_data.surface.as_ref() {
-                Some(surface) => surface,
-                None => return,
-            };
-            let window_id = wayland::make_wid(surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
-
-            let window_event = if let Some((x, y)) = axis_discrete_buffer {
-                WindowEvent::MouseWheel {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    delta: MouseScrollDelta::LineDelta(x, y),
-                    phase: pointer_data.axis_data.axis_state,
-                    modifiers: *pointer_data.modifiers_state.borrow(),
-                }
-            } else if let Some((x, y)) = axis_buffer {
-                let scale_factor = window_handle.scale_factor();
-                let delta = LogicalPosition::new(x, y).to_physical(scale_factor);
-
-                WindowEvent::MouseWheel {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    delta: MouseScrollDelta::PixelDelta(delta),
-                    phase: pointer_data.axis_data.axis_state,
-                    modifiers: *pointer_data.modifiers_state.borrow(),
-                }
-            } else {
-                return;
-            };
-
-            event_sink.push_window_event(window_event, window_id);
-        }
-        _ => (),
-    }
-}
-
-#[inline]
-pub(super) fn handle_relative_pointer(event: RelativePointerEvent, winit_state: &mut WinitState) {
-    if let RelativePointerEvent::RelativeMotion {
-        dx_unaccel,
-        dy_unaccel,
-        ..
-    } = event
-    {
-        winit_state.event_sink.push_device_event(
-            DeviceEvent::MouseMotion {
-                delta: (dx_unaccel, dy_unaccel),
-            },
-            DeviceId,
-        )
-    }
-}
--- a/src/platform_impl/linux/wayland/seat/pointer/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/pointer/mod.rs
@@ -1,343 +1,492 @@
-//! All pointer related handling.
+//! The pointer events.

-use std::cell::{Cell, RefCell};
-use std::rc::{Rc, Weak};
+use std::ops::Deref;
+use std::sync::{Arc, Mutex};

+use sctk::reexports::client::delegate_dispatch;
 use sctk::reexports::client::protocol::wl_pointer::WlPointer;
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::Attached;
-use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1;
-use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_v1::ZwpRelativePointerV1;
-use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::{ZwpPointerConstraintsV1, Lifetime};
-use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_confined_pointer_v1::ZwpConfinedPointerV1;
-use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_locked_pointer_v1::ZwpLockedPointerV1;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle, Dispatch};
+use sctk::reexports::protocols::wp::pointer_constraints::zv1::client::zwp_confined_pointer_v1::ZwpConfinedPointerV1;
+use sctk::reexports::protocols::wp::pointer_constraints::zv1::client::zwp_locked_pointer_v1::ZwpLockedPointerV1;
+use sctk::reexports::protocols::wp::pointer_constraints::zv1::client::zwp_pointer_constraints_v1::{Lifetime, ZwpPointerConstraintsV1};
+use sctk::reexports::client::globals::{BindError, GlobalList};

-use sctk::seat::pointer::{ThemeManager, ThemedPointer};
-use sctk::window::Window;
+use sctk::compositor::SurfaceData;
+use sctk::globals::GlobalData;
+use sctk::seat::pointer::{PointerData, PointerDataExt};
+use sctk::seat::pointer::{PointerEvent, PointerEventKind, PointerHandler};
+use sctk::seat::SeatState;
+use sctk::shell::xdg::frame::FrameClick;

-use crate::event::ModifiersState;
-use crate::platform_impl::wayland::event_loop::WinitState;
-use crate::platform_impl::wayland::window::WinitFrame;
-use crate::window::CursorIcon;
+use crate::dpi::{LogicalPosition, PhysicalPosition};
+use crate::event::{ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent};

-mod data;
-mod handlers;
+use crate::platform_impl::wayland::state::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId, WindowId};

-use data::PointerData;
+pub mod relative_pointer;

-/// A proxy to Wayland pointer, which serves requests from a `WindowHandle`.
-pub struct WinitPointer {
-    pointer: ThemedPointer,
+impl PointerHandler for WinitState {
+    fn pointer_frame(
+        &mut self,
+        connection: &Connection,
+        _: &QueueHandle<Self>,
+        pointer: &WlPointer,
+        events: &[PointerEvent],
+    ) {
+        let seat = pointer.winit_data().seat();
+        let seat_state = self.seats.get(&seat.id()).unwrap();

-    /// Create confined pointers.
-    pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
+        let device_id = crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId));

-    /// Cursor to handle confine requests.
-    confined_pointer: Weak<RefCell<Option<ZwpConfinedPointerV1>>>,
+        for event in events {
+            let surface = &event.surface;

-    /// Cursor to handle locked requests.
-    locked_pointer: Weak<RefCell<Option<ZwpLockedPointerV1>>>,
+            // The parent surface.
+            let parent_surface = match event.surface.data::<SurfaceData>() {
+                Some(data) => data.parent_surface().unwrap_or(surface),
+                None => continue,
+            };

-    /// Latest observed serial in pointer events.
-    /// used by Window::start_interactive_move()
-    latest_serial: Rc<Cell<u32>>,
+            let window_id = wayland::make_wid(parent_surface);

-    /// Latest observed serial in pointer enter events.
-    /// used by Window::set_cursor()
-    latest_enter_serial: Rc<Cell<u32>>,
+            // Ensure that window exists.
+            let mut window = match self.windows.get_mut().get_mut(&window_id) {
+                Some(window) => window.lock().unwrap(),
+                None => continue,
+            };

-    /// Seat.
-    seat: WlSeat,
-}
+            let scale_factor = window.scale_factor();
+            let position: PhysicalPosition<f64> =
+                LogicalPosition::new(event.position.0, event.position.1).to_physical(scale_factor);

-impl PartialEq for WinitPointer {
-    fn eq(&self, other: &Self) -> bool {
-        *self.pointer == *other.pointer
-    }
-}
+            match event.kind {
+                // Pointer movements on decorations.
+                PointerEventKind::Enter { .. } | PointerEventKind::Motion { .. }
+                    if parent_surface != surface =>
+                {
+                    if let Some(icon) =
+                        window.frame_point_moved(surface, event.position.0, event.position.1)
+                    {
+                        if let Some(pointer) = seat_state.pointer.as_ref() {
+                            let surface = pointer
+                                .pointer()
+                                .data::<WinitPointerData>()
+                                .unwrap()
+                                .cursor_surface();
+                            let scale_factor =
+                                surface.data::<SurfaceData>().unwrap().scale_factor();

-impl Eq for WinitPointer {}
+                            let _ = pointer.set_cursor(
+                                connection,
+                                icon,
+                                self.shm.wl_shm(),
+                                surface,
+                                scale_factor,
+                            );
+                        }
+                    }
+                }
+                PointerEventKind::Leave { .. } if parent_surface != surface => {
+                    window.frame_point_left();
+                }
+                ref kind @ PointerEventKind::Press { button, serial, .. }
+                | ref kind @ PointerEventKind::Release { button, serial, .. }
+                    if parent_surface != surface =>
+                {
+                    let click = match wayland_button_to_winit(button) {
+                        MouseButton::Left => FrameClick::Normal,
+                        MouseButton::Right => FrameClick::Alternate,
+                        _ => continue,
+                    };
+                    let pressed = matches!(kind, PointerEventKind::Press { .. });

-impl WinitPointer {
-    /// Set the cursor icon.
-    ///
-    /// Providing `None` will hide the cursor.
-    pub fn set_cursor(&self, cursor_icon: Option<CursorIcon>) {
-        let cursor_icon = match cursor_icon {
-            Some(cursor_icon) => cursor_icon,
-            None => {
-                // Hide the cursor.
-                // WlPointer::set_cursor() expects the serial of the last *enter*
-                // event (compare to to start_interactive_move()).
-                (*self.pointer).set_cursor(self.latest_enter_serial.get(), None, 0, 0);
-                return;
-            }
-        };
+                    // Emulate click on the frame.
+                    window.frame_click(
+                        click,
+                        pressed,
+                        seat,
+                        serial,
+                        window_id,
+                        &mut self.window_compositor_updates,
+                    );
+                }
+                // Regular events on the main surface.
+                PointerEventKind::Enter { .. } => {
+                    self.events_sink
+                        .push_window_event(WindowEvent::CursorEntered { device_id }, window_id);

-        let cursors: &[&str] = match cursor_icon {
-            CursorIcon::Alias => &["link"],
-            CursorIcon::Arrow => &["arrow"],
-            CursorIcon::Cell => &["plus"],
-            CursorIcon::Copy => &["copy"],
-            CursorIcon::Crosshair => &["crosshair"],
-            CursorIcon::Default => &["left_ptr"],
-            CursorIcon::Hand => &["hand2", "hand1"],
-            CursorIcon::Help => &["question_arrow"],
-            CursorIcon::Move => &["move"],
-            CursorIcon::Grab => &["openhand", "grab"],
-            CursorIcon::Grabbing => &["closedhand", "grabbing"],
-            CursorIcon::Progress => &["progress"],
-            CursorIcon::AllScroll => &["all-scroll"],
-            CursorIcon::ContextMenu => &["context-menu"],
+                    if let Some(pointer) = seat_state.pointer.as_ref().map(Arc::downgrade) {
+                        window.pointer_entered(pointer);
+                    }

-            CursorIcon::NoDrop => &["no-drop", "circle"],
-            CursorIcon::NotAllowed => &["crossed_circle"],
+                    // Set the currently focused surface.
+                    pointer.winit_data().inner.lock().unwrap().surface = Some(window_id);

-            // Resize cursors
-            CursorIcon::EResize => &["right_side"],
-            CursorIcon::NResize => &["top_side"],
-            CursorIcon::NeResize => &["top_right_corner"],
-            CursorIcon::NwResize => &["top_left_corner"],
-            CursorIcon::SResize => &["bottom_side"],
-            CursorIcon::SeResize => &["bottom_right_corner"],
-            CursorIcon::SwResize => &["bottom_left_corner"],
-            CursorIcon::WResize => &["left_side"],
-            CursorIcon::EwResize => &["h_double_arrow"],
-            CursorIcon::NsResize => &["v_double_arrow"],
-            CursorIcon::NwseResize => &["bd_double_arrow", "size_fdiag"],
-            CursorIcon::NeswResize => &["fd_double_arrow", "size_bdiag"],
-            CursorIcon::ColResize => &["split_h", "h_double_arrow"],
-            CursorIcon::RowResize => &["split_v", "v_double_arrow"],
-            CursorIcon::Text => &["text", "xterm"],
-            CursorIcon::VerticalText => &["vertical-text"],
+                    self.events_sink.push_window_event(
+                        WindowEvent::CursorMoved {
+                            device_id,
+                            position,
+                        },
+                        window_id,
+                    );
+                }
+                PointerEventKind::Leave { .. } => {
+                    if let Some(pointer) = seat_state.pointer.as_ref().map(Arc::downgrade) {
+                        window.pointer_left(pointer);
+                    }

-            CursorIcon::Wait => &["watch"],
+                    // Remove the active surface.
+                    pointer.winit_data().inner.lock().unwrap().surface = None;

-            CursorIcon::ZoomIn => &["zoom-in"],
-            CursorIcon::ZoomOut => &["zoom-out"],
-        };
+                    self.events_sink
+                        .push_window_event(WindowEvent::CursorLeft { device_id }, window_id);
+                }
+                PointerEventKind::Motion { .. } => {
+                    self.events_sink.push_window_event(
+                        WindowEvent::CursorMoved {
+                            device_id,
+                            position,
+                        },
+                        window_id,
+                    );
+                }
+                ref kind @ PointerEventKind::Press { button, serial, .. }
+                | ref kind @ PointerEventKind::Release { button, serial, .. } => {
+                    // Update the last button serial.
+                    pointer
+                        .winit_data()
+                        .inner
+                        .lock()
+                        .unwrap()
+                        .latest_button_serial = serial;

-        let serial = Some(self.latest_enter_serial.get());
-        for cursor in cursors {
-            if self.pointer.set_cursor(cursor, serial).is_ok() {
-                return;
+                    let button = wayland_button_to_winit(button);
+                    let state = if matches!(kind, PointerEventKind::Press { .. }) {
+                        ElementState::Pressed
+                    } else {
+                        ElementState::Released
+                    };
+                    self.events_sink.push_window_event(
+                        WindowEvent::MouseInput {
+                            device_id,
+                            state,
+                            button,
+                        },
+                        window_id,
+                    );
+                }
+                PointerEventKind::Axis {
+                    horizontal,
+                    vertical,
+                    ..
+                } => {
+                    // Get the current phase.
+                    let mut pointer_data = pointer.winit_data().inner.lock().unwrap();
+
+                    let has_discrete_scroll = horizontal.discrete != 0 || vertical.discrete != 0;
+
+                    // Figure out what to do about start/ended phases here.
+                    //
+                    // Figure out how to deal with `Started`. Also the `Ended` is not guaranteed
+                    // to be sent for mouse wheels.
+                    let phase = if horizontal.stop || vertical.stop {
+                        TouchPhase::Ended
+                    } else {
+                        match pointer_data.phase {
+                            // Descrete scroll only results in moved events.
+                            _ if has_discrete_scroll => TouchPhase::Moved,
+                            TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
+                            _ => TouchPhase::Started,
+                        }
+                    };
+
+                    // Update the phase.
+                    pointer_data.phase = phase;
+
+                    // Mice events have both pixel and discrete delta's at the same time. So prefer
+                    // the descrite values if they are present.
+                    let delta = if has_discrete_scroll {
+                        // XXX Wayland sign convention is the inverse of winit.
+                        MouseScrollDelta::LineDelta(
+                            (-horizontal.discrete) as f32,
+                            (-vertical.discrete) as f32,
+                        )
+                    } else {
+                        // XXX Wayland sign convention is the inverse of winit.
+                        MouseScrollDelta::PixelDelta(
+                            LogicalPosition::new(-horizontal.absolute, -vertical.absolute)
+                                .to_physical(scale_factor),
+                        )
+                    };
+
+                    self.events_sink.push_window_event(
+                        WindowEvent::MouseWheel {
+                            device_id,
+                            delta,
+                            phase,
+                        },
+                        window_id,
+                    )
+                }
            }
        }
-        warn!("Failed to set cursor to {:?}", cursor_icon);
-    }
-
-    /// Confine the pointer to a surface.
-    pub fn confine(&self, surface: &WlSurface) {
-        let pointer_constraints = match &self.pointer_constraints {
-            Some(pointer_constraints) => pointer_constraints,
-            None => return,
-        };
-
-        let confined_pointer = match self.confined_pointer.upgrade() {
-            Some(confined_pointer) => confined_pointer,
-            // A pointer is gone.
-            None => return,
-        };
-
-        *confined_pointer.borrow_mut() = Some(init_confined_pointer(
-            pointer_constraints,
-            surface,
-            &self.pointer,
-        ));
-    }
-
-    /// Tries to unconfine the pointer if the current pointer is confined.
-    pub fn unconfine(&self) {
-        let confined_pointer = match self.confined_pointer.upgrade() {
-            Some(confined_pointer) => confined_pointer,
-            // A pointer is gone.
-            None => return,
-        };
-
-        let mut confined_pointer = confined_pointer.borrow_mut();
-
-        if let Some(confined_pointer) = confined_pointer.take() {
-            confined_pointer.destroy();
-        }
-    }
-
-    pub fn lock(&self, surface: &WlSurface) {
-        let pointer_constraints = match &self.pointer_constraints {
-            Some(pointer_constraints) => pointer_constraints,
-            None => return,
-        };
-
-        let locked_pointer = match self.locked_pointer.upgrade() {
-            Some(locked_pointer) => locked_pointer,
-            // A pointer is gone.
-            None => return,
-        };
-
-        *locked_pointer.borrow_mut() = Some(init_locked_pointer(
-            pointer_constraints,
-            surface,
-            &self.pointer,
-        ));
-    }
-
-    pub fn unlock(&self) {
-        let locked_pointer = match self.locked_pointer.upgrade() {
-            Some(locked_pointer) => locked_pointer,
-            // A pointer is gone.
-            None => return,
-        };
-
-        let mut locked_pointer = locked_pointer.borrow_mut();
-
-        if let Some(locked_pointer) = locked_pointer.take() {
-            locked_pointer.destroy();
-        }
-    }
-
-    pub fn set_cursor_position(&self, surface_x: u32, surface_y: u32) {
-        let locked_pointer = match self.locked_pointer.upgrade() {
-            Some(locked_pointer) => locked_pointer,
-            // A pointer is gone.
-            None => return,
-        };
-
-        let locked_pointer = locked_pointer.borrow_mut();
-        if let Some(locked_pointer) = locked_pointer.as_ref() {
-            locked_pointer.set_cursor_position_hint(surface_x.into(), surface_y.into());
-        }
-    }
-
-    pub fn drag_window(&self, window: &Window<WinitFrame>) {
-        // WlPointer::setart_interactive_move() expects the last serial of *any*
-        // pointer event (compare to set_cursor()).
-        window.start_interactive_move(&self.seat, self.latest_serial.get());
    }
 }

-/// A pointer wrapper for easy releasing and managing pointers.
-pub(super) struct Pointers {
-    /// A pointer itself.
-    pointer: ThemedPointer,
+#[derive(Debug)]
+pub struct WinitPointerData {
+    /// The surface associated with this pointer, which is used for icons.
+    cursor_surface: WlSurface,

-    /// A relative pointer handler.
-    relative_pointer: Option<ZwpRelativePointerV1>,
+    /// The inner winit data associated with the pointer.
+    inner: Mutex<WinitPointerDataInner>,

-    /// Confined pointer.
-    confined_pointer: Rc<RefCell<Option<ZwpConfinedPointerV1>>>,
-
-    /// Locked pointer.
-    locked_pointer: Rc<RefCell<Option<ZwpLockedPointerV1>>>,
+    /// The data required by the sctk.
+    sctk_data: PointerData,
 }

-impl Pointers {
-    pub(super) fn new(
-        seat: &Attached<WlSeat>,
-        theme_manager: &ThemeManager,
-        relative_pointer_manager: &Option<Attached<ZwpRelativePointerManagerV1>>,
-        pointer_constraints: &Option<Attached<ZwpPointerConstraintsV1>>,
-        modifiers_state: Rc<RefCell<ModifiersState>>,
-    ) -> Self {
-        let confined_pointer = Rc::new(RefCell::new(None));
-        let locked_pointer = Rc::new(RefCell::new(None));
-
-        let pointer_data = Rc::new(RefCell::new(PointerData::new(
-            confined_pointer.clone(),
-            locked_pointer.clone(),
-            pointer_constraints.clone(),
-            modifiers_state,
-        )));
-
-        let pointer_seat = seat.detach();
-        let pointer = theme_manager.theme_pointer_with_impl(
-            seat,
-            move |event, pointer, mut dispatch_data| {
-                let winit_state = dispatch_data.get::<WinitState>().unwrap();
-                handlers::handle_pointer(
-                    pointer,
-                    event,
-                    &pointer_data,
-                    winit_state,
-                    pointer_seat.clone(),
-                );
-            },
-        );
-
-        // Setup relative_pointer if it's available.
-        let relative_pointer = relative_pointer_manager
-            .as_ref()
-            .map(|relative_pointer_manager| {
-                init_relative_pointer(relative_pointer_manager, &pointer)
-            });
-
+impl WinitPointerData {
+    pub fn new(seat: WlSeat, surface: WlSurface) -> Self {
        Self {
+            cursor_surface: surface,
+            inner: Mutex::new(WinitPointerDataInner::default()),
+            sctk_data: PointerData::new(seat),
+        }
+    }
+
+    pub fn lock_pointer(
+        &self,
+        pointer_constraints: &PointerConstraintsState,
+        surface: &WlSurface,
+        pointer: &WlPointer,
+        queue_handle: &QueueHandle<WinitState>,
+    ) {
+        let mut inner = self.inner.lock().unwrap();
+        if inner.locked_pointer.is_none() {
+            inner.locked_pointer = Some(pointer_constraints.lock_pointer(
+                surface,
+                pointer,
+                None,
+                Lifetime::Persistent,
+                queue_handle,
+                GlobalData,
+            ));
+        }
+    }
+
+    pub fn unlock_pointer(&self) {
+        let mut inner = self.inner.lock().unwrap();
+        if let Some(locked_pointer) = inner.locked_pointer.take() {
+            locked_pointer.destroy();
+        }
+    }
+
+    pub fn confine_pointer(
+        &self,
+        pointer_constraints: &PointerConstraintsState,
+        surface: &WlSurface,
+        pointer: &WlPointer,
+        queue_handle: &QueueHandle<WinitState>,
+    ) {
+        self.inner.lock().unwrap().confined_pointer = Some(pointer_constraints.confine_pointer(
+            surface,
            pointer,
-            relative_pointer,
-            confined_pointer,
-            locked_pointer,
+            None,
+            Lifetime::Persistent,
+            queue_handle,
+            GlobalData,
+        ));
+    }
+
+    pub fn unconfine_pointer(&self) {
+        let inner = self.inner.lock().unwrap();
+        if let Some(confined_pointer) = inner.confined_pointer.as_ref() {
+            confined_pointer.destroy();
+        }
+    }
+
+    /// Seat associated with this pointer.
+    pub fn seat(&self) -> &WlSeat {
+        self.sctk_data.seat()
+    }
+
+    /// The WlSurface used to set cursor theme.
+    pub fn cursor_surface(&self) -> &WlSurface {
+        &self.cursor_surface
+    }
+
+    /// Active window.
+    pub fn focused_window(&self) -> Option<WindowId> {
+        self.inner.lock().unwrap().surface
+    }
+
+    /// Last button serial.
+    pub fn latest_button_serial(&self) -> u32 {
+        self.inner.lock().unwrap().latest_button_serial
+    }
+
+    /// Last enter serial.
+    pub fn latest_enter_serial(&self) -> u32 {
+        self.sctk_data.latest_enter_serial().unwrap_or_default()
+    }
+
+    pub fn set_locked_cursor_position(&self, surface_x: f64, surface_y: f64) {
+        let inner = self.inner.lock().unwrap();
+        if let Some(locked_pointer) = inner.locked_pointer.as_ref() {
+            locked_pointer.set_cursor_position_hint(surface_x, surface_y);
        }
    }
 }

-impl Drop for Pointers {
+impl Drop for WinitPointerData {
    fn drop(&mut self) {
-        // Drop relative pointer.
-        if let Some(relative_pointer) = self.relative_pointer.take() {
-            relative_pointer.destroy();
-        }
+        self.cursor_surface.destroy();
+    }
+}

-        // Drop confined pointer.
-        if let Some(confined_pointer) = self.confined_pointer.borrow_mut().take() {
-            confined_pointer.destroy();
-        }
+impl PointerDataExt for WinitPointerData {
+    fn pointer_data(&self) -> &PointerData {
+        &self.sctk_data
+    }
+}

-        // Drop lock ponter.
-        if let Some(locked_pointer) = self.locked_pointer.borrow_mut().take() {
+#[derive(Debug)]
+pub struct WinitPointerDataInner {
+    /// The associated locked pointer.
+    locked_pointer: Option<ZwpLockedPointerV1>,
+
+    /// The associated confined pointer.
+    confined_pointer: Option<ZwpConfinedPointerV1>,
+
+    /// Serial of the last button event.
+    latest_button_serial: u32,
+
+    /// Currently focused window.
+    surface: Option<WindowId>,
+
+    /// Current axis phase.
+    phase: TouchPhase,
+}
+
+impl Drop for WinitPointerDataInner {
+    fn drop(&mut self) {
+        if let Some(locked_pointer) = self.locked_pointer.take() {
            locked_pointer.destroy();
        }

-        // Drop the pointer itself in case it's possible.
-        if self.pointer.as_ref().version() >= 3 {
-            self.pointer.release();
+        if let Some(confined_pointer) = self.confined_pointer.take() {
+            confined_pointer.destroy();
        }
    }
 }

-pub(super) fn init_relative_pointer(
-    relative_pointer_manager: &ZwpRelativePointerManagerV1,
-    pointer: &WlPointer,
-) -> ZwpRelativePointerV1 {
-    let relative_pointer = relative_pointer_manager.get_relative_pointer(pointer);
-    relative_pointer.quick_assign(move |_, event, mut dispatch_data| {
-        let winit_state = dispatch_data.get::<WinitState>().unwrap();
-        handlers::handle_relative_pointer(event, winit_state);
-    });
-
-    relative_pointer.detach()
+impl Default for WinitPointerDataInner {
+    fn default() -> Self {
+        Self {
+            surface: None,
+            locked_pointer: None,
+            confined_pointer: None,
+            latest_button_serial: 0,
+            phase: TouchPhase::Ended,
+        }
+    }
 }

-pub(super) fn init_confined_pointer(
-    pointer_constraints: &Attached<ZwpPointerConstraintsV1>,
-    surface: &WlSurface,
-    pointer: &WlPointer,
-) -> ZwpConfinedPointerV1 {
-    let confined_pointer =
-        pointer_constraints.confine_pointer(surface, pointer, None, Lifetime::Persistent);
+/// Convert the Wayland button into winit.
+fn wayland_button_to_winit(button: u32) -> MouseButton {
+    // These values are coming from <linux/input-event-codes.h>.
+    const BTN_LEFT: u32 = 0x110;
+    const BTN_RIGHT: u32 = 0x111;
+    const BTN_MIDDLE: u32 = 0x112;
+    const BTN_SIDE: u32 = 0x113;
+    const BTN_EXTRA: u32 = 0x114;
+    const BTN_FORWARD: u32 = 0x115;
+    const BTN_BACK: u32 = 0x116;

-    confined_pointer.quick_assign(move |_, _, _| {});
-
-    confined_pointer.detach()
+    match button {
+        BTN_LEFT => MouseButton::Left,
+        BTN_RIGHT => MouseButton::Right,
+        BTN_MIDDLE => MouseButton::Middle,
+        BTN_BACK | BTN_SIDE => MouseButton::Back,
+        BTN_FORWARD | BTN_EXTRA => MouseButton::Forward,
+        button => MouseButton::Other(button as u16),
+    }
 }

-pub(super) fn init_locked_pointer(
-    pointer_constraints: &Attached<ZwpPointerConstraintsV1>,
-    surface: &WlSurface,
-    pointer: &WlPointer,
-) -> ZwpLockedPointerV1 {
-    let locked_pointer =
-        pointer_constraints.lock_pointer(surface, pointer, None, Lifetime::Persistent);
-
-    locked_pointer.quick_assign(move |_, _, _| {});
-
-    locked_pointer.detach()
+pub trait WinitPointerDataExt {
+    fn winit_data(&self) -> &WinitPointerData;
 }
+
+impl WinitPointerDataExt for WlPointer {
+    fn winit_data(&self) -> &WinitPointerData {
+        self.data::<WinitPointerData>()
+            .expect("failed to get pointer data.")
+    }
+}
+
+pub struct PointerConstraintsState {
+    pointer_constraints: ZwpPointerConstraintsV1,
+}
+
+impl PointerConstraintsState {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let pointer_constraints = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self {
+            pointer_constraints,
+        })
+    }
+}
+
+impl Deref for PointerConstraintsState {
+    type Target = ZwpPointerConstraintsV1;
+    fn deref(&self) -> &Self::Target {
+        &self.pointer_constraints
+    }
+}
+
+impl Dispatch<ZwpPointerConstraintsV1, GlobalData, WinitState> for PointerConstraintsState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpPointerConstraintsV1,
+        _event: <ZwpPointerConstraintsV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpLockedPointerV1, GlobalData, WinitState> for PointerConstraintsState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpLockedPointerV1,
+        _event: <ZwpLockedPointerV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpConfinedPointerV1, GlobalData, WinitState> for PointerConstraintsState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpConfinedPointerV1,
+        _event: <ZwpConfinedPointerV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+delegate_dispatch!(WinitState: [ WlPointer: WinitPointerData] => SeatState);
+delegate_dispatch!(WinitState: [ZwpPointerConstraintsV1: GlobalData] => PointerConstraintsState);
+delegate_dispatch!(WinitState: [ZwpLockedPointerV1: GlobalData] => PointerConstraintsState);
+delegate_dispatch!(WinitState: [ZwpConfinedPointerV1: GlobalData] => PointerConstraintsState);
--- a/src/platform_impl/linux/wayland/seat/pointer/relative_pointer.rs
+++ b/src/platform_impl/linux/wayland/seat/pointer/relative_pointer.rs
@@ -0,0 +1,80 @@
+//! Relative pointer.
+
+use std::ops::Deref;
+
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::{delegate_dispatch, Dispatch};
+use sctk::reexports::client::{Connection, QueueHandle};
+use sctk::reexports::protocols::wp::relative_pointer::zv1::{
+    client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1,
+    client::zwp_relative_pointer_v1::{self, ZwpRelativePointerV1},
+};
+
+use sctk::globals::GlobalData;
+
+use crate::event::DeviceEvent;
+use crate::platform_impl::wayland::state::WinitState;
+
+/// Wrapper around the relative pointer.
+pub struct RelativePointerState {
+    manager: ZwpRelativePointerManagerV1,
+}
+
+impl RelativePointerState {
+    /// Create new relative pointer manager.
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { manager })
+    }
+}
+
+impl Deref for RelativePointerState {
+    type Target = ZwpRelativePointerManagerV1;
+
+    fn deref(&self) -> &Self::Target {
+        &self.manager
+    }
+}
+
+impl Dispatch<ZwpRelativePointerManagerV1, GlobalData, WinitState> for RelativePointerState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpRelativePointerManagerV1,
+        _event: <ZwpRelativePointerManagerV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpRelativePointerV1, GlobalData, WinitState> for RelativePointerState {
+    fn event(
+        state: &mut WinitState,
+        _proxy: &ZwpRelativePointerV1,
+        event: <ZwpRelativePointerV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+        if let zwp_relative_pointer_v1::Event::RelativeMotion {
+            dx_unaccel,
+            dy_unaccel,
+            ..
+        } = event
+        {
+            state.events_sink.push_device_event(
+                DeviceEvent::MouseMotion {
+                    delta: (dx_unaccel, dy_unaccel),
+                },
+                super::DeviceId,
+            );
+        }
+    }
+}
+
+delegate_dispatch!(WinitState: [ZwpRelativePointerV1: GlobalData] => RelativePointerState);
+delegate_dispatch!(WinitState: [ZwpRelativePointerManagerV1: GlobalData] => RelativePointerState);
--- a/src/platform_impl/linux/wayland/seat/text_input/handlers.rs
+++ b/src/platform_impl/linux/wayland/seat/text_input/handlers.rs
@@ -1,122 +0,0 @@
-//! Handling of IME events.
-
-use sctk::reexports::client::Main;
-use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_v3::{
-    Event as TextInputEvent, ZwpTextInputV3,
-};
-
-use crate::event::{Ime, WindowEvent};
-use crate::platform_impl::wayland;
-use crate::platform_impl::wayland::event_loop::WinitState;
-
-use super::{Preedit, TextInputHandler, TextInputInner, ZwpTextInputV3Ext};
-
-#[inline]
-pub(super) fn handle_text_input(
-    text_input: Main<ZwpTextInputV3>,
-    inner: &mut TextInputInner,
-    event: TextInputEvent,
-    winit_state: &mut WinitState,
-) {
-    let event_sink = &mut winit_state.event_sink;
-    match event {
-        TextInputEvent::Enter { surface } => {
-            let window_id = wayland::make_wid(&surface);
-
-            let window_handle = match winit_state.window_map.get_mut(&window_id) {
-                Some(window_handle) => window_handle,
-                None => return,
-            };
-            inner.target_window_id = Some(window_id);
-
-            // Enable text input on that surface.
-            if window_handle.ime_allowed.get() {
-                text_input.enable();
-                text_input.set_content_type_by_purpose(window_handle.ime_purpose.get());
-                text_input.commit();
-                event_sink.push_window_event(WindowEvent::Ime(Ime::Enabled), window_id);
-            }
-
-            // Notify a window we're currently over about text input handler.
-            let text_input_handler = TextInputHandler {
-                text_input: text_input.detach(),
-            };
-            window_handle.text_input_entered(text_input_handler);
-        }
-        TextInputEvent::Leave { surface } => {
-            // Always issue a disable.
-            text_input.disable();
-            text_input.commit();
-
-            let window_id = wayland::make_wid(&surface);
-
-            let window_handle = match winit_state.window_map.get_mut(&window_id) {
-                Some(window_handle) => window_handle,
-                None => return,
-            };
-
-            inner.target_window_id = None;
-
-            // Remove text input handler from the window we're leaving.
-            let text_input_handler = TextInputHandler {
-                text_input: text_input.detach(),
-            };
-            window_handle.text_input_left(text_input_handler);
-            event_sink.push_window_event(WindowEvent::Ime(Ime::Disabled), window_id);
-        }
-        TextInputEvent::PreeditString {
-            text,
-            cursor_begin,
-            cursor_end,
-        } => {
-            let text = text.unwrap_or_default();
-            let cursor_begin = usize::try_from(cursor_begin)
-                .ok()
-                .and_then(|idx| text.is_char_boundary(idx).then(|| idx));
-            let cursor_end = usize::try_from(cursor_end)
-                .ok()
-                .and_then(|idx| text.is_char_boundary(idx).then(|| idx));
-
-            inner.pending_preedit = Some(Preedit {
-                text,
-                cursor_begin,
-                cursor_end,
-            });
-        }
-        TextInputEvent::CommitString { text } => {
-            // Update currenly commited string and reset previous preedit.
-            inner.pending_preedit = None;
-            inner.pending_commit = Some(text.unwrap_or_default());
-        }
-        TextInputEvent::Done { .. } => {
-            let window_id = match inner.target_window_id {
-                Some(window_id) => window_id,
-                _ => return,
-            };
-
-            // Clear preedit at the start of `Done`.
-            event_sink.push_window_event(
-                WindowEvent::Ime(Ime::Preedit(String::new(), None)),
-                window_id,
-            );
-
-            // Send `Commit`.
-            if let Some(text) = inner.pending_commit.take() {
-                event_sink.push_window_event(WindowEvent::Ime(Ime::Commit(text)), window_id);
-            }
-
-            // Send preedit.
-            if let Some(preedit) = inner.pending_preedit.take() {
-                let cursor_range = preedit
-                    .cursor_begin
-                    .map(|b| (b, preedit.cursor_end.unwrap_or(b)));
-
-                event_sink.push_window_event(
-                    WindowEvent::Ime(Ime::Preedit(preedit.text, cursor_range)),
-                    window_id,
-                );
-            }
-        }
-        _ => (),
-    }
-}
--- a/src/platform_impl/linux/wayland/seat/text_input/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/text_input/mod.rs
@@ -1,23 +1,174 @@
-use sctk::reexports::client::protocol::wl_seat::WlSeat;
-use sctk::reexports::client::Attached;
-use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
-use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_v3::{
+use std::ops::Deref;
+
+use sctk::globals::GlobalData;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+
+use sctk::reexports::client::delegate_dispatch;
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Dispatch;
+use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
+use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::Event as TextInputEvent;
+use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::{
    ContentHint, ContentPurpose, ZwpTextInputV3,
 };

-use crate::platform_impl::wayland::event_loop::WinitState;
-use crate::platform_impl::wayland::WindowId;
+use crate::event::{Ime, WindowEvent};
+use crate::platform_impl::wayland;
+use crate::platform_impl::wayland::state::WinitState;
 use crate::window::ImePurpose;

-mod handlers;
-
-/// A handler for text input that we're advertising for `WindowHandle`.
-#[derive(Eq, PartialEq)]
-pub struct TextInputHandler {
-    text_input: ZwpTextInputV3,
+pub struct TextInputState {
+    text_input_manager: ZwpTextInputManagerV3,
 }

-trait ZwpTextInputV3Ext {
+impl TextInputState {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let text_input_manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { text_input_manager })
+    }
+}
+
+impl Deref for TextInputState {
+    type Target = ZwpTextInputManagerV3;
+
+    fn deref(&self) -> &Self::Target {
+        &self.text_input_manager
+    }
+}
+
+impl Dispatch<ZwpTextInputManagerV3, GlobalData, WinitState> for TextInputState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpTextInputManagerV3,
+        _event: <ZwpTextInputManagerV3 as Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
+    fn event(
+        state: &mut WinitState,
+        text_input: &ZwpTextInputV3,
+        event: <ZwpTextInputV3 as Proxy>::Event,
+        data: &TextInputData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+        let windows = state.windows.get_mut();
+        let mut text_input_data = data.inner.lock().unwrap();
+        match event {
+            TextInputEvent::Enter { surface } => {
+                let window_id = wayland::make_wid(&surface);
+                text_input_data.surface = Some(surface);
+
+                let mut window = match windows.get(&window_id) {
+                    Some(window) => window.lock().unwrap(),
+                    None => return,
+                };
+
+                if window.ime_allowed() {
+                    text_input.enable();
+                    text_input.set_content_type_by_purpose(window.ime_purpose());
+                    text_input.commit();
+                    state
+                        .events_sink
+                        .push_window_event(WindowEvent::Ime(Ime::Enabled), window_id);
+                }
+
+                window.text_input_entered(text_input);
+            }
+            TextInputEvent::Leave { surface } => {
+                text_input_data.surface = None;
+
+                // Always issue a disable.
+                text_input.disable();
+                text_input.commit();
+
+                let window_id = wayland::make_wid(&surface);
+
+                // XXX this check is essential, because `leave` could have a
+                // refence to nil surface...
+                let mut window = match windows.get(&window_id) {
+                    Some(window) => window.lock().unwrap(),
+                    None => return,
+                };
+
+                window.text_input_left(text_input);
+
+                state
+                    .events_sink
+                    .push_window_event(WindowEvent::Ime(Ime::Disabled), window_id);
+            }
+            TextInputEvent::PreeditString {
+                text,
+                cursor_begin,
+                cursor_end,
+            } => {
+                let text = text.unwrap_or_default();
+                let cursor_begin = usize::try_from(cursor_begin)
+                    .ok()
+                    .and_then(|idx| text.is_char_boundary(idx).then_some(idx));
+                let cursor_end = usize::try_from(cursor_end)
+                    .ok()
+                    .and_then(|idx| text.is_char_boundary(idx).then_some(idx));
+
+                text_input_data.pending_preedit = Some(Preedit {
+                    text,
+                    cursor_begin,
+                    cursor_end,
+                })
+            }
+            TextInputEvent::CommitString { text } => {
+                text_input_data.pending_preedit = None;
+                text_input_data.pending_commit = text;
+            }
+            TextInputEvent::Done { .. } => {
+                let window_id = match text_input_data.surface.as_ref() {
+                    Some(surface) => wayland::make_wid(surface),
+                    None => return,
+                };
+
+                // Clear preedit at the start of `Done`.
+                state.events_sink.push_window_event(
+                    WindowEvent::Ime(Ime::Preedit(String::new(), None)),
+                    window_id,
+                );
+
+                // Send `Commit`.
+                if let Some(text) = text_input_data.pending_commit.take() {
+                    state
+                        .events_sink
+                        .push_window_event(WindowEvent::Ime(Ime::Commit(text)), window_id);
+                }
+
+                // Send preedit.
+                if let Some(preedit) = text_input_data.pending_preedit.take() {
+                    let cursor_range = preedit
+                        .cursor_begin
+                        .map(|b| (b, preedit.cursor_end.unwrap_or(b)));
+
+                    state.events_sink.push_window_event(
+                        WindowEvent::Ime(Ime::Preedit(preedit.text, cursor_range)),
+                        window_id,
+                    );
+                }
+            }
+            TextInputEvent::DeleteSurroundingText { .. } => {
+                // Not handled.
+            }
+            _ => {}
+        }
+    }
+}
+
+pub trait ZwpTextInputV3Ext {
    fn set_content_type_by_purpose(&self, purpose: ImePurpose);
 }

@@ -32,81 +183,30 @@ impl ZwpTextInputV3Ext for ZwpTextInputV3 {
    }
 }

-impl TextInputHandler {
-    #[inline]
-    pub fn set_ime_position(&self, x: i32, y: i32) {
-        self.text_input.set_cursor_rectangle(x, y, 0, 0);
-        self.text_input.commit();
-    }
-
-    #[inline]
-    pub fn set_content_type_by_purpose(&self, purpose: ImePurpose) {
-        self.text_input.set_content_type_by_purpose(purpose);
-        self.text_input.commit();
-    }
-
-    #[inline]
-    pub fn set_input_allowed(&self, allowed: Option<ImePurpose>) {
-        if let Some(purpose) = allowed {
-            self.text_input.set_content_type_by_purpose(purpose);
-            self.text_input.enable();
-        } else {
-            self.text_input.disable();
-        }
-
-        self.text_input.commit();
-    }
+/// The Data associated with the text input.
+#[derive(Default)]
+pub struct TextInputData {
+    inner: std::sync::Mutex<TextInputDataInner>,
 }

-/// A wrapper around text input to automatically destroy the object on `Drop`.
-pub struct TextInput {
-    text_input: Attached<ZwpTextInputV3>,
-}
+#[derive(Default)]
+pub struct TextInputDataInner {
+    /// The `WlSurface` we're performing input to.
+    surface: Option<WlSurface>,

-impl TextInput {
-    pub fn new(seat: &Attached<WlSeat>, text_input_manager: &ZwpTextInputManagerV3) -> Self {
-        let text_input = text_input_manager.get_text_input(seat);
-        let mut text_input_inner = TextInputInner::new();
-        text_input.quick_assign(move |text_input, event, mut dispatch_data| {
-            let winit_state = dispatch_data.get::<WinitState>().unwrap();
-            handlers::handle_text_input(text_input, &mut text_input_inner, event, winit_state);
-        });
-
-        let text_input: Attached<ZwpTextInputV3> = text_input.into();
-
-        Self { text_input }
-    }
-}
-
-impl Drop for TextInput {
-    fn drop(&mut self) {
-        self.text_input.destroy();
-    }
-}
-
-struct TextInputInner {
-    /// Currently focused surface.
-    target_window_id: Option<WindowId>,
-
-    /// Pending commit event which will be dispatched on `text_input_v3::Done`.
+    /// The commit to submit on `done`.
    pending_commit: Option<String>,

-    /// Pending preedit event which will be dispatched on `text_input_v3::Done`.
+    /// The preedit to submit on `done`.
    pending_preedit: Option<Preedit>,
 }

+/// The state of the preedit.
 struct Preedit {
    text: String,
    cursor_begin: Option<usize>,
    cursor_end: Option<usize>,
 }

-impl TextInputInner {
-    fn new() -> Self {
-        Self {
-            target_window_id: None,
-            pending_commit: None,
-            pending_preedit: None,
-        }
-    }
-}
+delegate_dispatch!(WinitState: [ZwpTextInputManagerV3: GlobalData] => TextInputState);
+delegate_dispatch!(WinitState: [ZwpTextInputV3: TextInputData] => TextInputState);
--- a/src/platform_impl/linux/wayland/seat/touch/handlers.rs
+++ b/src/platform_impl/linux/wayland/seat/touch/handlers.rs
@@ -1,144 +0,0 @@
-//! Various handlers for touch events.
-
-use sctk::reexports::client::protocol::wl_touch::Event as TouchEvent;
-
-use crate::dpi::LogicalPosition;
-use crate::event::{TouchPhase, WindowEvent};
-
-use crate::platform_impl::wayland::event_loop::WinitState;
-use crate::platform_impl::wayland::{self, DeviceId};
-
-use super::{TouchInner, TouchPoint};
-
-/// Handle WlTouch events.
-#[inline]
-pub(super) fn handle_touch(
-    event: TouchEvent,
-    inner: &mut TouchInner,
-    winit_state: &mut WinitState,
-) {
-    let event_sink = &mut winit_state.event_sink;
-
-    match event {
-        TouchEvent::Down {
-            surface, id, x, y, ..
-        } => {
-            let window_id = wayland::make_wid(&surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
-
-            let scale_factor = window_handle.scale_factor();
-            let position = LogicalPosition::new(x, y);
-
-            event_sink.push_window_event(
-                WindowEvent::Touch(crate::event::Touch {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    phase: TouchPhase::Started,
-                    location: position.to_physical(scale_factor),
-                    force: None, // TODO
-                    id: id as u64,
-                }),
-                window_id,
-            );
-
-            // For `TouchEvent::Up` we don't receive a position, so we're tracking active
-            // touch points. Update either a known touch id or register a new one.
-            if let Some(i) = inner.touch_points.iter().position(|p| p.id == id) {
-                inner.touch_points[i].position = position;
-            } else {
-                inner
-                    .touch_points
-                    .push(TouchPoint::new(surface, position, id));
-            }
-        }
-        TouchEvent::Up { id, .. } => {
-            let touch_point = match inner.touch_points.iter().find(|p| p.id == id) {
-                Some(touch_point) => touch_point,
-                None => return,
-            };
-
-            let window_id = wayland::make_wid(&touch_point.surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
-            let scale_factor = window_handle.scale_factor();
-            let location = touch_point.position.to_physical(scale_factor);
-            let window_id = wayland::make_wid(&touch_point.surface);
-
-            event_sink.push_window_event(
-                WindowEvent::Touch(crate::event::Touch {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    phase: TouchPhase::Ended,
-                    location,
-                    force: None, // TODO
-                    id: id as u64,
-                }),
-                window_id,
-            );
-        }
-        TouchEvent::Motion { id, x, y, .. } => {
-            let touch_point = match inner.touch_points.iter_mut().find(|p| p.id == id) {
-                Some(touch_point) => touch_point,
-                None => return,
-            };
-            let window_id = wayland::make_wid(&touch_point.surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
-
-            touch_point.position = LogicalPosition::new(x, y);
-
-            let scale_factor = window_handle.scale_factor();
-            let location = touch_point.position.to_physical(scale_factor);
-            let window_id = wayland::make_wid(&touch_point.surface);
-
-            event_sink.push_window_event(
-                WindowEvent::Touch(crate::event::Touch {
-                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                        DeviceId,
-                    )),
-                    phase: TouchPhase::Moved,
-                    location,
-                    force: None, // TODO
-                    id: id as u64,
-                }),
-                window_id,
-            );
-        }
-        TouchEvent::Frame => (),
-        TouchEvent::Cancel => {
-            for touch_point in inner.touch_points.drain(..) {
-                let window_id = wayland::make_wid(&touch_point.surface);
-                let window_handle = match winit_state.window_map.get(&window_id) {
-                    Some(w) => w,
-                    _ => return,
-                };
-
-                let scale_factor = window_handle.scale_factor();
-                let location = touch_point.position.to_physical(scale_factor);
-
-                event_sink.push_window_event(
-                    WindowEvent::Touch(crate::event::Touch {
-                        device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
-                            DeviceId,
-                        )),
-                        phase: TouchPhase::Cancelled,
-                        location,
-                        force: None, // TODO
-                        id: touch_point.id as u64,
-                    }),
-                    window_id,
-                );
-            }
-        }
-        _ => (),
-    }
-}
--- a/src/platform_impl/linux/wayland/seat/touch/mod.rs
+++ b/src/platform_impl/linux/wayland/seat/touch/mod.rs
@@ -3,76 +3,197 @@
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::protocol::wl_touch::WlTouch;
-use sctk::reexports::client::Attached;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+
+use sctk::seat::touch::{TouchData, TouchHandler};

 use crate::dpi::LogicalPosition;
+use crate::event::{Touch, TouchPhase, WindowEvent};

-use crate::platform_impl::wayland::event_loop::WinitState;
+use crate::platform_impl::wayland::state::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId};

-mod handlers;
+impl TouchHandler for WinitState {
+    fn down(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        touch: &WlTouch,
+        _: u32,
+        _: u32,
+        surface: WlSurface,
+        id: i32,
+        position: (f64, f64),
+    ) {
+        let window_id = wayland::make_wid(&surface);
+        let scale_factor = match self.windows.get_mut().get(&window_id) {
+            Some(window) => window.lock().unwrap().scale_factor(),
+            None => return,
+        };

-/// Wrapper around touch to handle release.
-pub struct Touch {
-    /// Proxy to touch.
-    touch: WlTouch,
-}
+        let location = LogicalPosition::<f64>::from(position);

-impl Touch {
-    pub fn new(seat: &Attached<WlSeat>) -> Self {
-        let touch = seat.get_touch();
-        let mut inner = TouchInner::new();
+        let seat_state = self.seats.get_mut(&touch.seat().id()).unwrap();

-        touch.quick_assign(move |_, event, mut dispatch_data| {
-            let winit_state = dispatch_data.get::<WinitState>().unwrap();
-            handlers::handle_touch(event, &mut inner, winit_state);
-        });
+        // Update the state of the point.
+        seat_state
+            .touch_map
+            .insert(id, TouchPoint { surface, location });

-        Self {
-            touch: touch.detach(),
+        self.events_sink.push_window_event(
+            WindowEvent::Touch(Touch {
+                device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                    DeviceId,
+                )),
+                phase: TouchPhase::Started,
+                location: location.to_physical(scale_factor),
+                force: None,
+                id: id as u64,
+            }),
+            window_id,
+        );
+    }
+
+    fn up(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        touch: &WlTouch,
+        _: u32,
+        _: u32,
+        id: i32,
+    ) {
+        let seat_state = self.seats.get_mut(&touch.seat().id()).unwrap();
+
+        // Remove the touch point.
+        let touch_point = match seat_state.touch_map.remove(&id) {
+            Some(touch_point) => touch_point,
+            None => return,
+        };
+
+        let window_id = wayland::make_wid(&touch_point.surface);
+        let scale_factor = match self.windows.get_mut().get(&window_id) {
+            Some(window) => window.lock().unwrap().scale_factor(),
+            None => return,
+        };
+
+        self.events_sink.push_window_event(
+            WindowEvent::Touch(Touch {
+                device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                    DeviceId,
+                )),
+                phase: TouchPhase::Ended,
+                location: touch_point.location.to_physical(scale_factor),
+                force: None,
+                id: id as u64,
+            }),
+            window_id,
+        );
+    }
+
+    fn motion(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        touch: &WlTouch,
+        _: u32,
+        id: i32,
+        position: (f64, f64),
+    ) {
+        let seat_state = self.seats.get_mut(&touch.seat().id()).unwrap();
+
+        // Remove the touch point.
+        let touch_point = match seat_state.touch_map.get_mut(&id) {
+            Some(touch_point) => touch_point,
+            None => return,
+        };
+
+        let window_id = wayland::make_wid(&touch_point.surface);
+        let scale_factor = match self.windows.get_mut().get(&window_id) {
+            Some(window) => window.lock().unwrap().scale_factor(),
+            None => return,
+        };
+
+        touch_point.location = LogicalPosition::<f64>::from(position);
+
+        self.events_sink.push_window_event(
+            WindowEvent::Touch(Touch {
+                device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                    DeviceId,
+                )),
+                phase: TouchPhase::Cancelled,
+                location: touch_point.location.to_physical(scale_factor),
+                force: None,
+                id: id as u64,
+            }),
+            window_id,
+        );
+    }
+
+    fn cancel(&mut self, _: &Connection, _: &QueueHandle<Self>, touch: &WlTouch) {
+        let seat_state = self.seats.get_mut(&touch.seat().id()).unwrap();
+
+        for (id, touch_point) in seat_state.touch_map.drain() {
+            let window_id = wayland::make_wid(&touch_point.surface);
+            let scale_factor = match self.windows.get_mut().get(&window_id) {
+                Some(window) => window.lock().unwrap().scale_factor(),
+                None => return,
+            };
+
+            let location = touch_point.location.to_physical(scale_factor);
+
+            self.events_sink.push_window_event(
+                WindowEvent::Touch(Touch {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    phase: TouchPhase::Cancelled,
+                    location,
+                    force: None,
+                    id: id as u64,
+                }),
+                window_id,
+            );
        }
    }
+
+    fn shape(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &WlTouch,
+        _: i32,
+        _: f64,
+        _: f64,
+    ) {
+        // Blank.
+    }
+
+    fn orientation(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlTouch, _: i32, _: f64) {
+        // Blank.
+    }
 }

-impl Drop for Touch {
-    fn drop(&mut self) {
-        if self.touch.as_ref().version() >= 3 {
-            self.touch.release();
-        }
+/// The state of the touch point.
+#[derive(Debug)]
+pub struct TouchPoint {
+    /// The surface on which the point is present.
+    pub surface: WlSurface,
+
+    /// The location of the point on the surface.
+    pub location: LogicalPosition<f64>,
+}
+
+pub trait TouchDataExt {
+    fn seat(&self) -> &WlSeat;
+}
+
+impl TouchDataExt for WlTouch {
+    fn seat(&self) -> &WlSeat {
+        self.data::<TouchData>()
+            .expect("failed to get touch data.")
+            .seat()
    }
 }

-/// The data used by touch handlers.
-pub(super) struct TouchInner {
-    /// Current touch points.
-    touch_points: Vec<TouchPoint>,
-}
-
-impl TouchInner {
-    fn new() -> Self {
-        Self {
-            touch_points: Vec::new(),
-        }
-    }
-}
-
-/// Location of touch press.
-pub(super) struct TouchPoint {
-    /// A surface where the touch point is located.
-    surface: WlSurface,
-
-    /// Location of the touch point.
-    position: LogicalPosition<f64>,
-
-    /// Id.
-    id: i32,
-}
-
-impl TouchPoint {
-    pub fn new(surface: WlSurface, position: LogicalPosition<f64>, id: i32) -> Self {
-        Self {
-            surface,
-            position,
-            id,
-        }
-    }
-}
+sctk::delegate_touch!(WinitState);
--- a/src/platform_impl/linux/wayland/state.rs
+++ b/src/platform_impl/linux/wayland/state.rs
@@ -0,0 +1,368 @@
+use std::cell::RefCell;
+use std::error::Error;
+use std::sync::{Arc, Mutex};
+
+use fnv::FnvHashMap;
+
+use sctk::reexports::calloop::LoopHandle;
+use sctk::reexports::client::backend::ObjectId;
+use sctk::reexports::client::globals::GlobalList;
+use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+
+use sctk::compositor::{CompositorHandler, CompositorState};
+use sctk::output::{OutputHandler, OutputState};
+use sctk::registry::{ProvidesRegistryState, RegistryState};
+use sctk::seat::pointer::ThemedPointer;
+use sctk::seat::SeatState;
+use sctk::shell::xdg::window::{Window, WindowConfigure, WindowHandler};
+use sctk::shell::xdg::XdgShell;
+use sctk::shell::WaylandSurface;
+use sctk::shm::{Shm, ShmHandler};
+use sctk::subcompositor::SubcompositorState;
+
+use crate::dpi::LogicalSize;
+
+use super::event_loop::sink::EventSink;
+use super::output::MonitorHandle;
+use super::seat::{
+    PointerConstraintsState, RelativePointerState, TextInputState, WinitPointerData,
+    WinitPointerDataExt, WinitSeatState,
+};
+use super::types::wp_fractional_scaling::FractionalScalingManager;
+use super::types::wp_viewporter::ViewporterState;
+use super::types::xdg_activation::XdgActivationState;
+use super::window::{WindowRequests, WindowState};
+use super::WindowId;
+
+/// Winit's Wayland state.
+pub struct WinitState {
+    /// The WlRegistry.
+    pub registry_state: RegistryState,
+
+    /// The state of the WlOutput handling.
+    pub output_state: OutputState,
+
+    /// The compositor state which is used to create new windows and regions.
+    pub compositor_state: Arc<CompositorState>,
+
+    /// The state of the subcompositor.
+    pub subcompositor_state: Arc<SubcompositorState>,
+
+    /// The seat state responsible for all sorts of input.
+    pub seat_state: SeatState,
+
+    /// The shm for software buffers, such as cursors.
+    pub shm: Shm,
+
+    /// The XDG shell that is used for widnows.
+    pub xdg_shell: XdgShell,
+
+    /// The currently present windows.
+    pub windows: RefCell<FnvHashMap<WindowId, Arc<Mutex<WindowState>>>>,
+
+    /// The requests from the `Window` to EventLoop, such as close operations and redraw requests.
+    pub window_requests: RefCell<FnvHashMap<WindowId, Arc<WindowRequests>>>,
+
+    /// The events that were generated directly from the window.
+    pub window_events_sink: Arc<Mutex<EventSink>>,
+
+    /// The update for the `windows` comming from the compositor.
+    pub window_compositor_updates: Vec<WindowCompositorUpdate>,
+
+    /// Currently handled seats.
+    pub seats: FnvHashMap<ObjectId, WinitSeatState>,
+
+    /// Currently present cursor surfaces.
+    pub pointer_surfaces: FnvHashMap<ObjectId, Arc<ThemedPointer<WinitPointerData>>>,
+
+    /// The state of the text input on the client.
+    pub text_input_state: Option<TextInputState>,
+
+    /// Observed monitors.
+    pub monitors: Arc<Mutex<Vec<MonitorHandle>>>,
+
+    /// Sink to accumulate window events from the compositor, which is latter dispatched in
+    /// event loop run.
+    pub events_sink: EventSink,
+
+    /// Xdg activation.
+    pub xdg_activation: Option<XdgActivationState>,
+
+    /// Relative pointer.
+    pub relative_pointer: Option<RelativePointerState>,
+
+    /// Pointer constraints to handle pointer locking and confining.
+    pub pointer_constraints: Option<Arc<PointerConstraintsState>>,
+
+    /// Viewporter state on the given window.
+    pub viewporter_state: Option<ViewporterState>,
+
+    /// Fractional scaling manager.
+    pub fractional_scaling_manager: Option<FractionalScalingManager>,
+
+    /// Loop handle to re-register event sources, such as keyboard repeat.
+    pub loop_handle: LoopHandle<'static, Self>,
+}
+
+impl WinitState {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<Self>,
+        loop_handle: LoopHandle<'static, WinitState>,
+    ) -> Result<Self, Box<dyn Error>> {
+        let registry_state = RegistryState::new(globals);
+        let compositor_state = CompositorState::bind(globals, queue_handle)?;
+        let subcompositor_state = SubcompositorState::bind(
+            compositor_state.wl_compositor().clone(),
+            globals,
+            queue_handle,
+        )?;
+
+        let output_state = OutputState::new(globals, queue_handle);
+        let monitors = output_state.outputs().map(MonitorHandle::new).collect();
+
+        let seat_state = SeatState::new(globals, queue_handle);
+
+        let mut seats = FnvHashMap::default();
+        for seat in seat_state.seats() {
+            seats.insert(seat.id(), WinitSeatState::new());
+        }
+
+        let (viewporter_state, fractional_scaling_manager) =
+            if let Ok(fsm) = FractionalScalingManager::new(globals, queue_handle) {
+                (ViewporterState::new(globals, queue_handle).ok(), Some(fsm))
+            } else {
+                (None, None)
+            };
+
+        Ok(Self {
+            registry_state,
+            compositor_state: Arc::new(compositor_state),
+            subcompositor_state: Arc::new(subcompositor_state),
+            output_state,
+            seat_state,
+            shm: Shm::bind(globals, queue_handle)?,
+
+            xdg_shell: XdgShell::bind(globals, queue_handle)?,
+            xdg_activation: XdgActivationState::bind(globals, queue_handle).ok(),
+
+            windows: Default::default(),
+            window_requests: Default::default(),
+            window_compositor_updates: Vec::new(),
+            window_events_sink: Default::default(),
+            viewporter_state,
+            fractional_scaling_manager,
+
+            seats,
+            text_input_state: TextInputState::new(globals, queue_handle).ok(),
+
+            relative_pointer: RelativePointerState::new(globals, queue_handle).ok(),
+            pointer_constraints: PointerConstraintsState::new(globals, queue_handle)
+                .map(Arc::new)
+                .ok(),
+            pointer_surfaces: Default::default(),
+
+            monitors: Arc::new(Mutex::new(monitors)),
+            events_sink: EventSink::new(),
+            loop_handle,
+        })
+    }
+
+    pub fn scale_factor_changed(
+        &mut self,
+        surface: &WlSurface,
+        scale_factor: f64,
+        is_legacy: bool,
+    ) {
+        // Check if the cursor surface.
+        let window_id = super::make_wid(surface);
+
+        if let Some(window) = self.windows.get_mut().get(&window_id) {
+            // Don't update the scaling factor, when legacy method is used.
+            if is_legacy && self.fractional_scaling_manager.is_some() {
+                return;
+            }
+
+            // The scale factor change is for the window.
+            let pos = if let Some(pos) = self
+                .window_compositor_updates
+                .iter()
+                .position(|update| update.window_id == window_id)
+            {
+                pos
+            } else {
+                self.window_compositor_updates
+                    .push(WindowCompositorUpdate::new(window_id));
+                self.window_compositor_updates.len() - 1
+            };
+
+            // Update the scale factor right away.
+            window.lock().unwrap().set_scale_factor(scale_factor);
+            self.window_compositor_updates[pos].scale_factor = Some(scale_factor);
+        } else if let Some(pointer) = self.pointer_surfaces.get(&surface.id()) {
+            // Get the window, where the pointer resides right now.
+            let focused_window = match pointer.pointer().winit_data().focused_window() {
+                Some(focused_window) => focused_window,
+                None => return,
+            };
+
+            if let Some(window_state) = self.windows.get_mut().get(&focused_window) {
+                window_state.lock().unwrap().reload_cursor_style()
+            }
+        }
+    }
+
+    pub fn queue_close(updates: &mut Vec<WindowCompositorUpdate>, window_id: WindowId) {
+        let pos = if let Some(pos) = updates
+            .iter()
+            .position(|update| update.window_id == window_id)
+        {
+            pos
+        } else {
+            updates.push(WindowCompositorUpdate::new(window_id));
+            updates.len() - 1
+        };
+
+        updates[pos].close_window = true;
+    }
+}
+
+impl ShmHandler for WinitState {
+    fn shm_state(&mut self) -> &mut Shm {
+        &mut self.shm
+    }
+}
+
+impl WindowHandler for WinitState {
+    fn request_close(&mut self, _: &Connection, _: &QueueHandle<Self>, window: &Window) {
+        let window_id = super::make_wid(window.wl_surface());
+        Self::queue_close(&mut self.window_compositor_updates, window_id);
+    }
+
+    fn configure(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        window: &Window,
+        configure: WindowConfigure,
+        _serial: u32,
+    ) {
+        let window_id = super::make_wid(window.wl_surface());
+
+        let pos = if let Some(pos) = self
+            .window_compositor_updates
+            .iter()
+            .position(|update| update.window_id == window_id)
+        {
+            pos
+        } else {
+            self.window_compositor_updates
+                .push(WindowCompositorUpdate::new(window_id));
+            self.window_compositor_updates.len() - 1
+        };
+
+        // Populate the configure to the window.
+        //
+        // XXX the size on the window will be updated right before dispatching the size to the user.
+        let new_size = self
+            .windows
+            .get_mut()
+            .get_mut(&window_id)
+            .expect("got configure for dead window.")
+            .lock()
+            .unwrap()
+            .configure(configure, &self.shm, &self.subcompositor_state);
+
+        self.window_compositor_updates[pos].size = Some(new_size);
+    }
+}
+
+impl OutputHandler for WinitState {
+    fn output_state(&mut self) -> &mut OutputState {
+        &mut self.output_state
+    }
+
+    fn new_output(&mut self, _: &Connection, _: &QueueHandle<Self>, output: WlOutput) {
+        self.monitors
+            .lock()
+            .unwrap()
+            .push(MonitorHandle::new(output));
+    }
+
+    fn update_output(&mut self, _: &Connection, _: &QueueHandle<Self>, updated: WlOutput) {
+        let mut monitors = self.monitors.lock().unwrap();
+        let updated = MonitorHandle::new(updated);
+        if let Some(pos) = monitors.iter().position(|output| output == &updated) {
+            monitors[pos] = updated
+        } else {
+            monitors.push(updated)
+        }
+    }
+
+    fn output_destroyed(&mut self, _: &Connection, _: &QueueHandle<Self>, removed: WlOutput) {
+        let mut monitors = self.monitors.lock().unwrap();
+        let removed = MonitorHandle::new(removed);
+        if let Some(pos) = monitors.iter().position(|output| output == &removed) {
+            monitors.remove(pos);
+        }
+    }
+}
+
+impl CompositorHandler for WinitState {
+    fn scale_factor_changed(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        surface: &WlSurface,
+        scale_factor: i32,
+    ) {
+        self.scale_factor_changed(surface, scale_factor as f64, true)
+    }
+
+    fn frame(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlSurface, _: u32) {}
+}
+
+impl ProvidesRegistryState for WinitState {
+    fn registry(&mut self) -> &mut RegistryState {
+        &mut self.registry_state
+    }
+
+    sctk::registry_handlers![OutputState, SeatState];
+}
+
+// The window update comming from the compositor.
+#[derive(Debug, Clone, Copy)]
+pub struct WindowCompositorUpdate {
+    /// The id of the window this updates belongs to.
+    pub window_id: WindowId,
+
+    /// New window size.
+    pub size: Option<LogicalSize<u32>>,
+
+    /// New scale factor.
+    pub scale_factor: Option<f64>,
+
+    /// Close the window.
+    pub close_window: bool,
+}
+
+impl WindowCompositorUpdate {
+    fn new(window_id: WindowId) -> Self {
+        Self {
+            window_id,
+            size: None,
+            scale_factor: None,
+            close_window: false,
+        }
+    }
+}
+
+sctk::delegate_subcompositor!(WinitState);
+sctk::delegate_compositor!(WinitState);
+sctk::delegate_output!(WinitState);
+sctk::delegate_registry!(WinitState);
+sctk::delegate_shm!(WinitState);
+sctk::delegate_xdg_shell!(WinitState);
+sctk::delegate_xdg_window!(WinitState);
--- a/src/platform_impl/linux/wayland/types/mod.rs
+++ b/src/platform_impl/linux/wayland/types/mod.rs
@@ -0,0 +1,5 @@
+//! Wayland protocol implementation boilerplate.
+
+pub mod wp_fractional_scaling;
+pub mod wp_viewporter;
+pub mod xdg_activation;
--- a/src/platform_impl/linux/wayland/types/wp_fractional_scaling.rs
+++ b/src/platform_impl/linux/wayland/types/wp_fractional_scaling.rs
@@ -0,0 +1,81 @@
+//! Handling of the fractional scaling.
+
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Dispatch;
+use sctk::reexports::client::{delegate_dispatch, Connection, Proxy, QueueHandle};
+use sctk::reexports::protocols::wp::fractional_scale::v1::client::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1;
+use sctk::reexports::protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::Event as FractionalScalingEvent;
+use sctk::reexports::protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::WpFractionalScaleV1;
+
+use sctk::globals::GlobalData;
+
+use crate::platform_impl::wayland::state::WinitState;
+
+/// The scaling factor denominator.
+const SCALE_DENOMINATOR: f64 = 120.;
+
+/// Fractional scaling manager.
+#[derive(Debug)]
+pub struct FractionalScalingManager {
+    manager: WpFractionalScaleManagerV1,
+}
+
+pub struct FractionalScaling {
+    /// The surface used for scaling.
+    surface: WlSurface,
+}
+
+impl FractionalScalingManager {
+    /// Create new viewporter.
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { manager })
+    }
+
+    pub fn fractional_scaling(
+        &self,
+        surface: &WlSurface,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> WpFractionalScaleV1 {
+        let data = FractionalScaling {
+            surface: surface.clone(),
+        };
+        self.manager
+            .get_fractional_scale(surface, queue_handle, data)
+    }
+}
+
+impl Dispatch<WpFractionalScaleManagerV1, GlobalData, WinitState> for FractionalScalingManager {
+    fn event(
+        _: &mut WinitState,
+        _: &WpFractionalScaleManagerV1,
+        _: <WpFractionalScaleManagerV1 as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        // No events.
+    }
+}
+
+impl Dispatch<WpFractionalScaleV1, FractionalScaling, WinitState> for FractionalScalingManager {
+    fn event(
+        state: &mut WinitState,
+        _: &WpFractionalScaleV1,
+        event: <WpFractionalScaleV1 as Proxy>::Event,
+        data: &FractionalScaling,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        if let FractionalScalingEvent::PreferredScale { scale } = event {
+            state.scale_factor_changed(&data.surface, scale as f64 / SCALE_DENOMINATOR, false);
+        }
+    }
+}
+
+delegate_dispatch!(WinitState: [WpFractionalScaleManagerV1: GlobalData] => FractionalScalingManager);
+delegate_dispatch!(WinitState: [WpFractionalScaleV1: FractionalScaling] => FractionalScalingManager);
--- a/src/platform_impl/linux/wayland/types/wp_viewporter.rs
+++ b/src/platform_impl/linux/wayland/types/wp_viewporter.rs
@@ -0,0 +1,67 @@
+//! Handling of the wp-viewporter.
+
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Dispatch;
+use sctk::reexports::client::{delegate_dispatch, Connection, Proxy, QueueHandle};
+use sctk::reexports::protocols::wp::viewporter::client::wp_viewport::WpViewport;
+use sctk::reexports::protocols::wp::viewporter::client::wp_viewporter::WpViewporter;
+
+use sctk::globals::GlobalData;
+
+use crate::platform_impl::wayland::state::WinitState;
+
+/// Viewporter.
+#[derive(Debug)]
+pub struct ViewporterState {
+    viewporter: WpViewporter,
+}
+
+impl ViewporterState {
+    /// Create new viewporter.
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let viewporter = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { viewporter })
+    }
+
+    /// Get the viewport for the given object.
+    pub fn get_viewport(
+        &self,
+        surface: &WlSurface,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> WpViewport {
+        self.viewporter
+            .get_viewport(surface, queue_handle, GlobalData)
+    }
+}
+
+impl Dispatch<WpViewporter, GlobalData, WinitState> for ViewporterState {
+    fn event(
+        _: &mut WinitState,
+        _: &WpViewporter,
+        _: <WpViewporter as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        // No events.
+    }
+}
+impl Dispatch<WpViewport, GlobalData, WinitState> for ViewporterState {
+    fn event(
+        _: &mut WinitState,
+        _: &WpViewport,
+        _: <WpViewport as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        // No events.
+    }
+}
+
+delegate_dispatch!(WinitState: [WpViewporter: GlobalData] => ViewporterState);
+delegate_dispatch!(WinitState: [WpViewport: GlobalData] => ViewporterState);
--- a/src/platform_impl/linux/wayland/types/xdg_activation.rs
+++ b/src/platform_impl/linux/wayland/types/xdg_activation.rs
@@ -0,0 +1,103 @@
+//! Handling of xdg activation, which is used for user attention requests.
+
+use std::sync::atomic::AtomicBool;
+use std::sync::Weak;
+
+use sctk::reexports::client::delegate_dispatch;
+use sctk::reexports::client::globals::BindError;
+use sctk::reexports::client::globals::GlobalList;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Dispatch;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+use sctk::reexports::protocols::xdg::activation::v1::client::xdg_activation_token_v1::{
+    Event as ActivationTokenEvent, XdgActivationTokenV1,
+};
+use sctk::reexports::protocols::xdg::activation::v1::client::xdg_activation_v1::XdgActivationV1;
+
+use sctk::globals::GlobalData;
+
+use crate::platform_impl::wayland::state::WinitState;
+
+pub struct XdgActivationState {
+    xdg_activation: XdgActivationV1,
+}
+
+impl XdgActivationState {
+    pub fn bind(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let xdg_activation = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { xdg_activation })
+    }
+
+    pub fn global(&self) -> &XdgActivationV1 {
+        &self.xdg_activation
+    }
+}
+
+impl Dispatch<XdgActivationV1, GlobalData, WinitState> for XdgActivationState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &XdgActivationV1,
+        _event: <XdgActivationV1 as Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<XdgActivationTokenV1, XdgActivationTokenData, WinitState> for XdgActivationState {
+    fn event(
+        state: &mut WinitState,
+        proxy: &XdgActivationTokenV1,
+        event: <XdgActivationTokenV1 as Proxy>::Event,
+        data: &XdgActivationTokenData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        let token = match event {
+            ActivationTokenEvent::Done { token } => token,
+            _ => return,
+        };
+
+        state
+            .xdg_activation
+            .as_ref()
+            .expect("got xdg_activation event without global.")
+            .global()
+            .activate(token, &data.surface);
+
+        // Mark that no request attention is in process.
+        if let Some(attention_requested) = data.attention_requested.upgrade() {
+            attention_requested.store(false, std::sync::atomic::Ordering::Relaxed);
+        }
+
+        proxy.destroy();
+    }
+}
+
+/// The data associated with the activation request.
+pub struct XdgActivationTokenData {
+    /// The surface we're raising.
+    surface: WlSurface,
+
+    /// Flag to throttle attention requests.
+    attention_requested: Weak<AtomicBool>,
+}
+
+impl XdgActivationTokenData {
+    /// Create a new data.
+    ///
+    /// The `attenteion_requested` is marked as `false` on complition.
+    pub fn new(surface: WlSurface, attention_requested: Weak<AtomicBool>) -> Self {
+        Self {
+            surface,
+            attention_requested,
+        }
+    }
+}
+
+delegate_dispatch!(WinitState: [ XdgActivationV1: GlobalData] => XdgActivationState);
+delegate_dispatch!(WinitState: [ XdgActivationTokenV1: XdgActivationTokenData] => XdgActivationState);
--- a/src/platform_impl/linux/wayland/window/mod.rs
+++ b/src/platform_impl/linux/wayland/window/mod.rs
--- a/src/platform_impl/linux/wayland/window/shim.rs
+++ b/src/platform_impl/linux/wayland/window/shim.rs
@@ -1,666 +0,0 @@
-use std::cell::Cell;
-use std::mem::ManuallyDrop;
-use std::sync::atomic::AtomicBool;
-use std::sync::{Arc, Mutex};
-
-use sctk::reexports::client::protocol::wl_compositor::WlCompositor;
-use sctk::reexports::client::protocol::wl_output::WlOutput;
-use sctk::reexports::client::Attached;
-use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_token_v1;
-use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_v1::XdgActivationV1;
-
-use sctk::environment::Environment;
-use sctk::window::{Decorations, Window};
-use wayland_protocols::viewporter::client::wp_viewport::WpViewport;
-
-use crate::dpi::{LogicalPosition, LogicalSize};
-
-use crate::event::{Ime, WindowEvent};
-use crate::platform_impl::wayland;
-use crate::platform_impl::wayland::env::WinitEnv;
-use crate::platform_impl::wayland::event_loop::{EventSink, WinitState};
-use crate::platform_impl::wayland::protocols::wp_fractional_scale_v1::WpFractionalScaleV1;
-use crate::platform_impl::wayland::seat::pointer::WinitPointer;
-use crate::platform_impl::wayland::seat::text_input::TextInputHandler;
-use crate::platform_impl::wayland::WindowId;
-use crate::window::{CursorGrabMode, CursorIcon, ImePurpose, Theme, UserAttentionType};
-
-use super::WinitFrame;
-
-/// A request to SCTK window from Winit window.
-#[derive(Debug, Clone)]
-pub enum WindowRequest {
-    /// Set fullscreen.
-    ///
-    /// Passing `None` will set it on the current monitor.
-    Fullscreen(Option<WlOutput>),
-
-    /// Unset fullscreen.
-    UnsetFullscreen,
-
-    /// Show cursor for the certain window or not.
-    ShowCursor(bool),
-
-    /// Change the cursor icon.
-    NewCursorIcon(CursorIcon),
-
-    /// Change cursor grabbing mode.
-    SetCursorGrabMode(CursorGrabMode),
-
-    /// Set cursor position.
-    SetLockedCursorPosition(LogicalPosition<u32>),
-
-    /// Drag window.
-    DragWindow,
-
-    /// Maximize the window.
-    Maximize(bool),
-
-    /// Minimize the window.
-    Minimize,
-
-    /// Request decorations change.
-    Decorate(bool),
-
-    /// Make the window resizeable.
-    Resizeable(bool),
-
-    /// Set the title for window.
-    Title(String),
-
-    /// Min size.
-    MinSize(Option<LogicalSize<u32>>),
-
-    /// Max size.
-    MaxSize(Option<LogicalSize<u32>>),
-
-    /// New frame size.
-    FrameSize(LogicalSize<u32>),
-
-    /// Set IME window position.
-    ImePosition(LogicalPosition<u32>),
-
-    /// Enable IME on the given window.
-    AllowIme(bool),
-
-    /// Set the IME purpose.
-    ImePurpose(ImePurpose),
-
-    /// Mark the window as opaque.
-    Transparent(bool),
-
-    /// Request Attention.
-    ///
-    /// `None` unsets the attention request.
-    Attention(Option<UserAttentionType>),
-
-    /// Passthrough mouse input to underlying windows.
-    PassthroughMouseInput(bool),
-
-    /// Redraw was requested.
-    Redraw,
-
-    /// Window should be closed.
-    Close,
-
-    /// Change window theme.
-    Theme(Option<Theme>),
-}
-
-// The window update comming from the compositor.
-#[derive(Default, Debug, Clone, Copy)]
-pub struct WindowCompositorUpdate {
-    /// New window size.
-    pub size: Option<LogicalSize<u32>>,
-
-    /// New scale factor.
-    pub scale_factor: Option<f64>,
-
-    /// Close the window.
-    pub close_window: bool,
-}
-
-impl WindowCompositorUpdate {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-/// Pending update to a window requested by the user.
-#[derive(Default, Debug, Clone, Copy)]
-pub struct WindowUserRequest {
-    /// Whether `redraw` was requested.
-    pub redraw_requested: bool,
-
-    /// Wether the frame should be refreshed.
-    pub refresh_frame: bool,
-}
-
-impl WindowUserRequest {
-    pub fn new() -> Self {
-        Default::default()
-    }
-}
-
-/// A handle to perform operations on SCTK window
-/// and react to events.
-pub struct WindowHandle {
-    /// An actual window.
-    pub window: ManuallyDrop<Window<WinitFrame>>,
-
-    /// The state of the fractional scaling handlers for the window.
-    pub fractional_scaling_state: Option<FractionalScalingState>,
-
-    /// The scale factor of the window.
-    pub scale_factor: Arc<Mutex<f64>>,
-
-    /// The current size of the window.
-    pub size: Arc<Mutex<LogicalSize<u32>>>,
-
-    /// A pending requests to SCTK window.
-    pub pending_window_requests: Arc<Mutex<Vec<WindowRequest>>>,
-
-    /// Current cursor icon.
-    pub cursor_icon: Cell<CursorIcon>,
-
-    /// Whether the window is resizable.
-    pub is_resizable: Cell<bool>,
-
-    /// Whether the window has keyboard focus.
-    pub has_focus: Arc<AtomicBool>,
-
-    /// Allow IME events for that window.
-    pub ime_allowed: Cell<bool>,
-
-    /// IME purpose for that window.
-    pub ime_purpose: Cell<ImePurpose>,
-
-    /// Wether the window is transparent.
-    pub transparent: Cell<bool>,
-
-    /// Visible cursor or not.
-    cursor_visible: Cell<bool>,
-
-    /// Cursor confined to the surface.
-    cursor_grab_mode: Cell<CursorGrabMode>,
-
-    /// Pointers over the current surface.
-    pointers: Vec<WinitPointer>,
-
-    /// Text inputs on the current surface.
-    text_inputs: Vec<TextInputHandler>,
-
-    /// XdgActivation object.
-    xdg_activation: Option<Attached<XdgActivationV1>>,
-
-    /// Indicator whether user attention is requested.
-    attention_requested: Cell<bool>,
-
-    /// Compositor
-    compositor: Attached<WlCompositor>,
-}
-
-impl WindowHandle {
-    pub fn new(
-        env: &Environment<WinitEnv>,
-        window: Window<WinitFrame>,
-        size: Arc<Mutex<LogicalSize<u32>>>,
-        has_focus: Arc<AtomicBool>,
-        fractional_scaling_state: Option<FractionalScalingState>,
-        scale_factor: f64,
-        pending_window_requests: Arc<Mutex<Vec<WindowRequest>>>,
-    ) -> Self {
-        let xdg_activation = env.get_global::<XdgActivationV1>();
-        // Unwrap is safe, since we can't create window without compositor anyway and won't be
-        // here.
-        let compositor = env.get_global::<WlCompositor>().unwrap();
-
-        Self {
-            window: ManuallyDrop::new(window),
-            fractional_scaling_state,
-            scale_factor: Arc::new(Mutex::new(scale_factor)),
-            size,
-            pending_window_requests,
-            cursor_icon: Cell::new(CursorIcon::Default),
-            is_resizable: Cell::new(true),
-            transparent: Cell::new(false),
-            cursor_grab_mode: Cell::new(CursorGrabMode::None),
-            cursor_visible: Cell::new(true),
-            pointers: Vec::new(),
-            text_inputs: Vec::new(),
-            xdg_activation,
-            attention_requested: Cell::new(false),
-            compositor,
-            ime_allowed: Cell::new(false),
-            ime_purpose: Cell::new(ImePurpose::default()),
-            has_focus,
-        }
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        *self.scale_factor.lock().unwrap()
-    }
-
-    pub fn set_cursor_grab(&self, mode: CursorGrabMode) {
-        // The new requested state matches the current confine status, return.
-        let old_mode = self.cursor_grab_mode.replace(mode);
-        if old_mode == mode {
-            return;
-        }
-
-        // Clear old pointer data.
-        match old_mode {
-            CursorGrabMode::None => (),
-            CursorGrabMode::Confined => self.pointers.iter().for_each(|p| p.unconfine()),
-            CursorGrabMode::Locked => self.pointers.iter().for_each(|p| p.unlock()),
-        }
-
-        let surface = self.window.surface();
-        match mode {
-            CursorGrabMode::Locked => self.pointers.iter().for_each(|p| p.lock(surface)),
-            CursorGrabMode::Confined => self.pointers.iter().for_each(|p| p.confine(surface)),
-            CursorGrabMode::None => {
-                // Current lock/confine was already removed.
-            }
-        }
-    }
-
-    pub fn set_locked_cursor_position(&self, position: LogicalPosition<u32>) {
-        // XXX the cursor locking is ensured inside `Window`.
-        self.pointers
-            .iter()
-            .for_each(|p| p.set_cursor_position(position.x, position.y));
-    }
-
-    pub fn set_user_attention(&self, request_type: Option<UserAttentionType>) {
-        let xdg_activation = match self.xdg_activation.as_ref() {
-            None => return,
-            Some(xdg_activation) => xdg_activation,
-        };
-
-        //  Urgency is only removed by the compositor and there's no need to raise urgency when it
-        //  was already raised.
-        if request_type.is_none() || self.attention_requested.get() {
-            return;
-        }
-
-        let xdg_activation_token = xdg_activation.get_activation_token();
-        let surface = self.window.surface();
-        let window_id = wayland::make_wid(surface);
-        let xdg_activation = xdg_activation.clone();
-
-        xdg_activation_token.quick_assign(move |xdg_token, event, mut dispatch_data| {
-            let token = match event {
-                xdg_activation_token_v1::Event::Done { token } => token,
-                _ => return,
-            };
-
-            let winit_state = dispatch_data.get::<WinitState>().unwrap();
-            let window_handle = match winit_state.window_map.get_mut(&window_id) {
-                Some(window_handle) => window_handle,
-                None => return,
-            };
-
-            let surface = window_handle.window.surface();
-            xdg_activation.activate(token, surface);
-
-            // Mark that attention request was done and drop the token.
-            window_handle.attention_requested.replace(false);
-            xdg_token.destroy();
-        });
-
-        xdg_activation_token.set_surface(surface);
-        xdg_activation_token.commit();
-        self.attention_requested.replace(true);
-    }
-
-    /// Pointer appeared over the window.
-    pub fn pointer_entered(&mut self, pointer: WinitPointer) {
-        let position = self.pointers.iter().position(|p| *p == pointer);
-
-        if position.is_none() {
-            let surface = self.window.surface();
-            match self.cursor_grab_mode.get() {
-                CursorGrabMode::None => (),
-                CursorGrabMode::Locked => pointer.lock(surface),
-                CursorGrabMode::Confined => pointer.confine(surface),
-            }
-
-            self.pointers.push(pointer);
-        }
-
-        // Apply the current cursor style.
-        self.set_cursor_visible(self.cursor_visible.get());
-    }
-
-    /// Pointer left the window.
-    pub fn pointer_left(&mut self, pointer: WinitPointer) {
-        let position = self.pointers.iter().position(|p| *p == pointer);
-
-        if let Some(position) = position {
-            let pointer = self.pointers.remove(position);
-
-            // Drop the grabbing mode.
-            match self.cursor_grab_mode.get() {
-                CursorGrabMode::None => (),
-                CursorGrabMode::Locked => pointer.unlock(),
-                CursorGrabMode::Confined => pointer.unconfine(),
-            }
-        }
-    }
-
-    pub fn text_input_entered(&mut self, text_input: TextInputHandler) {
-        if !self.text_inputs.iter().any(|t| *t == text_input) {
-            self.text_inputs.push(text_input);
-        }
-    }
-
-    pub fn text_input_left(&mut self, text_input: TextInputHandler) {
-        if let Some(position) = self.text_inputs.iter().position(|t| *t == text_input) {
-            self.text_inputs.remove(position);
-        }
-    }
-
-    pub fn set_ime_position(&self, position: LogicalPosition<u32>) {
-        // XXX This won't fly unless user will have a way to request IME window per seat, since
-        // the ime windows will be overlapping, but winit doesn't expose API to specify for
-        // which seat we're setting IME position.
-        let (x, y) = (position.x as i32, position.y as i32);
-        for text_input in self.text_inputs.iter() {
-            text_input.set_ime_position(x, y);
-        }
-    }
-
-    pub fn passthrough_mouse_input(&self, passthrough_mouse_input: bool) {
-        if passthrough_mouse_input {
-            let region = self.compositor.create_region();
-            region.add(0, 0, 0, 0);
-            self.window
-                .surface()
-                .set_input_region(Some(&region.detach()));
-            region.destroy();
-        } else {
-            // Using `None` results in the entire window being clickable.
-            self.window.surface().set_input_region(None);
-        }
-    }
-
-    pub fn set_transparent(&self, transparent: bool) {
-        self.transparent.set(transparent);
-        let surface = self.window.surface();
-        if transparent {
-            surface.set_opaque_region(None);
-        } else {
-            let region = self.compositor.create_region();
-            region.add(0, 0, i32::MAX, i32::MAX);
-            surface.set_opaque_region(Some(&region.detach()));
-            region.destroy();
-        }
-    }
-
-    pub fn set_ime_allowed(&self, allowed: bool, event_sink: &mut EventSink) {
-        if self.ime_allowed.get() == allowed {
-            return;
-        }
-
-        self.ime_allowed.replace(allowed);
-        let window_id = wayland::make_wid(self.window.surface());
-
-        let purpose = allowed.then(|| self.ime_purpose.get());
-        for text_input in self.text_inputs.iter() {
-            text_input.set_input_allowed(purpose);
-        }
-
-        let event = if allowed {
-            WindowEvent::Ime(Ime::Enabled)
-        } else {
-            WindowEvent::Ime(Ime::Disabled)
-        };
-
-        event_sink.push_window_event(event, window_id);
-    }
-
-    pub fn set_ime_purpose(&self, purpose: ImePurpose) {
-        if self.ime_purpose.get() == purpose {
-            return;
-        }
-
-        self.ime_purpose.replace(purpose);
-
-        if self.ime_allowed.get() {
-            for text_input in self.text_inputs.iter() {
-                text_input.set_content_type_by_purpose(purpose);
-            }
-        }
-    }
-
-    pub fn set_cursor_visible(&self, visible: bool) {
-        self.cursor_visible.replace(visible);
-        let cursor_icon = match visible {
-            true => Some(self.cursor_icon.get()),
-            false => None,
-        };
-
-        for pointer in self.pointers.iter() {
-            pointer.set_cursor(cursor_icon)
-        }
-    }
-
-    pub fn set_cursor_icon(&self, cursor_icon: CursorIcon) {
-        self.cursor_icon.replace(cursor_icon);
-
-        if !self.cursor_visible.get() {
-            return;
-        }
-
-        for pointer in self.pointers.iter() {
-            pointer.set_cursor(Some(cursor_icon));
-        }
-    }
-
-    pub fn drag_window(&self) {
-        for pointer in self.pointers.iter() {
-            pointer.drag_window(&self.window);
-        }
-    }
-}
-
-#[inline]
-pub fn handle_window_requests(winit_state: &mut WinitState) {
-    let window_map = &mut winit_state.window_map;
-    let window_user_requests = &mut winit_state.window_user_requests;
-    let window_compositor_updates = &mut winit_state.window_compositor_updates;
-    let mut windows_to_close: Vec<WindowId> = Vec::new();
-
-    // Process the rest of the events.
-    for (window_id, window_handle) in window_map.iter_mut() {
-        let mut requests = window_handle.pending_window_requests.lock().unwrap();
-        let requests = requests.drain(..);
-        for request in requests {
-            match request {
-                WindowRequest::Fullscreen(fullscreen) => {
-                    window_handle.window.set_fullscreen(fullscreen.as_ref());
-                }
-                WindowRequest::UnsetFullscreen => {
-                    window_handle.window.unset_fullscreen();
-                }
-                WindowRequest::ShowCursor(show_cursor) => {
-                    window_handle.set_cursor_visible(show_cursor);
-                }
-                WindowRequest::NewCursorIcon(cursor_icon) => {
-                    window_handle.set_cursor_icon(cursor_icon);
-                }
-                WindowRequest::ImePosition(position) => {
-                    window_handle.set_ime_position(position);
-                }
-                WindowRequest::AllowIme(allow) => {
-                    let event_sink = &mut winit_state.event_sink;
-                    window_handle.set_ime_allowed(allow, event_sink);
-                }
-                WindowRequest::ImePurpose(purpose) => {
-                    window_handle.set_ime_purpose(purpose);
-                }
-                WindowRequest::SetCursorGrabMode(mode) => {
-                    window_handle.set_cursor_grab(mode);
-                }
-                WindowRequest::SetLockedCursorPosition(position) => {
-                    window_handle.set_locked_cursor_position(position);
-                }
-                WindowRequest::DragWindow => {
-                    window_handle.drag_window();
-                }
-                WindowRequest::Maximize(maximize) => {
-                    if maximize {
-                        window_handle.window.set_maximized();
-                    } else {
-                        window_handle.window.unset_maximized();
-                    }
-                }
-                WindowRequest::Minimize => {
-                    window_handle.window.set_minimized();
-                }
-                WindowRequest::Transparent(transparent) => {
-                    window_handle.set_transparent(transparent);
-
-                    // This requires surface commit.
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.redraw_requested = true;
-                }
-                WindowRequest::Decorate(decorate) => {
-                    let decorations = match decorate {
-                        true => Decorations::FollowServer,
-                        false => Decorations::None,
-                    };
-
-                    window_handle.window.set_decorate(decorations);
-
-                    // We should refresh the frame to apply decorations change.
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.refresh_frame = true;
-                }
-                WindowRequest::Resizeable(resizeable) => {
-                    window_handle.window.set_resizable(resizeable);
-
-                    // We should refresh the frame to update button state.
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.refresh_frame = true;
-                }
-                WindowRequest::Title(title) => {
-                    window_handle.window.set_title(title);
-
-                    // We should refresh the frame to draw new title.
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.refresh_frame = true;
-                }
-                WindowRequest::MinSize(size) => {
-                    let size = size.map(|size| (size.width, size.height));
-                    window_handle.window.set_min_size(size);
-
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.refresh_frame = true;
-                }
-                WindowRequest::MaxSize(size) => {
-                    let size = size.map(|size| (size.width, size.height));
-                    window_handle.window.set_max_size(size);
-
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.refresh_frame = true;
-                }
-                WindowRequest::FrameSize(size) => {
-                    if !window_handle.is_resizable.get() {
-                        // On Wayland non-resizable window is achieved by setting both min and max
-                        // size of the window to the same value.
-                        let size = Some((size.width, size.height));
-                        window_handle.window.set_max_size(size);
-                        window_handle.window.set_min_size(size);
-                    }
-
-                    window_handle.window.resize(size.width, size.height);
-
-                    // We should refresh the frame after resize.
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.refresh_frame = true;
-                }
-                WindowRequest::PassthroughMouseInput(passthrough) => {
-                    window_handle.passthrough_mouse_input(passthrough);
-
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.refresh_frame = true;
-                }
-                WindowRequest::Attention(request_type) => {
-                    window_handle.set_user_attention(request_type);
-                }
-                WindowRequest::Redraw => {
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.redraw_requested = true;
-                }
-                WindowRequest::Close => {
-                    // The window was requested to be closed.
-                    windows_to_close.push(*window_id);
-
-                    // Send event that the window was destroyed.
-                    let event_sink = &mut winit_state.event_sink;
-                    event_sink.push_window_event(WindowEvent::Destroyed, *window_id);
-                }
-                WindowRequest::Theme(_theme) => {
-                    #[cfg(feature = "sctk-adwaita")]
-                    {
-                        window_handle.window.set_frame_config(match _theme {
-                            Some(theme) => theme.into(),
-                            None => sctk_adwaita::FrameConfig::auto(),
-                        });
-
-                        let window_requst = window_user_requests.get_mut(window_id).unwrap();
-                        window_requst.refresh_frame = true;
-                    }
-                }
-            };
-        }
-    }
-
-    // Close the windows.
-    for window in windows_to_close {
-        let _ = window_map.remove(&window);
-        let _ = window_user_requests.remove(&window);
-        let _ = window_compositor_updates.remove(&window);
-    }
-}
-
-impl Drop for WindowHandle {
-    fn drop(&mut self) {
-        // Drop the fractional scaling before the surface.
-        let _ = self.fractional_scaling_state.take();
-
-        unsafe {
-            let surface = self.window.surface().clone();
-            // The window must be destroyed before wl_surface.
-            ManuallyDrop::drop(&mut self.window);
-            surface.destroy();
-        }
-    }
-}
-
-/// Fractional scaling objects.
-pub struct FractionalScalingState {
-    /// The wp-viewport of the window.
-    pub viewport: WpViewport,
-
-    /// The wp-fractional-scale of the window surface.
-    pub fractional_scale: WpFractionalScaleV1,
-}
-
-impl FractionalScalingState {
-    pub fn new(viewport: WpViewport, fractional_scale: WpFractionalScaleV1) -> Self {
-        Self {
-            viewport,
-            fractional_scale,
-        }
-    }
-}
-
-impl Drop for FractionalScalingState {
-    fn drop(&mut self) {
-        self.viewport.destroy();
-        self.fractional_scale.destroy();
-    }
-}
--- a/src/platform_impl/linux/wayland/window/state.rs
+++ b/src/platform_impl/linux/wayland/window/state.rs
@@ -0,0 +1,895 @@
+//! The state of the window, which is shared with the event-loop.
+
+use std::mem::ManuallyDrop;
+use std::num::NonZeroU32;
+use std::sync::{Arc, Weak};
+
+use log::warn;
+
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::protocol::wl_shm::WlShm;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+use sctk::reexports::protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::WpFractionalScaleV1;
+use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::ZwpTextInputV3;
+use sctk::reexports::protocols::wp::viewporter::client::wp_viewport::WpViewport;
+use sctk::reexports::protocols::xdg::shell::client::xdg_toplevel::ResizeEdge;
+
+use sctk::compositor::{CompositorState, Region, SurfaceData};
+use sctk::seat::pointer::ThemedPointer;
+use sctk::shell::xdg::frame::{DecorationsFrame, FrameAction, FrameClick};
+use sctk::shell::xdg::window::{DecorationMode, Window, WindowConfigure};
+use sctk::shell::xdg::XdgSurface;
+use sctk::shell::WaylandSurface;
+use sctk::shm::Shm;
+use sctk::subcompositor::SubcompositorState;
+
+use crate::dpi::{LogicalPosition, LogicalSize};
+use crate::error::{ExternalError, NotSupportedError};
+use crate::platform_impl::WindowId;
+use crate::window::{CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme};
+
+use crate::platform_impl::wayland::seat::{
+    PointerConstraintsState, WinitPointerData, WinitPointerDataExt, ZwpTextInputV3Ext,
+};
+use crate::platform_impl::wayland::state::{WindowCompositorUpdate, WinitState};
+
+#[cfg(feature = "sctk-adwaita")]
+pub type WinitFrame = sctk_adwaita::AdwaitaFrame<WinitState>;
+#[cfg(not(feature = "sctk-adwaita"))]
+pub type WinitFrame = sctk::shell::xdg::frame::fallback_frame::FallbackFrame<WinitState>;
+
+// Minimum window inner size.
+const MIN_WINDOW_SIZE: LogicalSize<u32> = LogicalSize::new(2, 1);
+
+/// The state of the window which is being updated from the [`WinitState`].
+pub struct WindowState {
+    /// The connection to Wayland server.
+    pub connection: Connection,
+
+    /// The underlying SCTK window.
+    pub window: ManuallyDrop<Window>,
+
+    /// The window frame, which is created from the configure request.
+    frame: Option<WinitFrame>,
+
+    /// The `Shm` to set cursor.
+    pub shm: WlShm,
+
+    /// The last received configure.
+    pub last_configure: Option<WindowConfigure>,
+
+    /// The pointers observed on the window.
+    pub pointers: Vec<Weak<ThemedPointer<WinitPointerData>>>,
+
+    /// Cursor icon.
+    pub cursor_icon: CursorIcon,
+
+    /// Wether the cursor is visible.
+    pub cursor_visible: bool,
+
+    /// Pointer constraints to lock/confine pointer.
+    pub pointer_constraints: Option<Arc<PointerConstraintsState>>,
+
+    /// Queue handle.
+    pub queue_handle: QueueHandle<WinitState>,
+
+    /// Theme varaint.
+    theme: Option<Theme>,
+
+    /// The current window title.
+    title: String,
+
+    /// Whether the frame is resizable.
+    resizable: bool,
+
+    /// Whether the window has focus.
+    has_focus: bool,
+
+    /// The scale factor of the window.
+    scale_factor: f64,
+
+    /// Whether the window is transparent.
+    transparent: bool,
+
+    /// The state of the compositor to create WlRegions.
+    compositor: Arc<CompositorState>,
+
+    /// The current cursor grabbing mode.
+    cursor_grab_mode: GrabState,
+
+    /// Whether the IME input is allowed for that window.
+    ime_allowed: bool,
+
+    /// The current IME purpose.
+    ime_purpose: ImePurpose,
+
+    /// The text inputs observed on the window.
+    text_inputs: Vec<ZwpTextInputV3>,
+
+    /// The inner size of the window, as in without client side decorations.
+    size: LogicalSize<u32>,
+
+    /// Whether the CSD fail to create, so we don't try to create them on each iteration.
+    csd_fails: bool,
+
+    /// Whether we should decorate the frame.
+    decorate: bool,
+
+    /// Min size.
+    min_inner_size: LogicalSize<u32>,
+    max_inner_size: Option<LogicalSize<u32>>,
+
+    /// The size of the window when no states were applied to it. The primary use for it
+    /// is to fallback to original window size, before it was maximized, if the compositor
+    /// sends `None` for the new size in the configure.
+    stateless_size: LogicalSize<u32>,
+
+    viewport: Option<WpViewport>,
+    fractional_scale: Option<WpFractionalScaleV1>,
+}
+
+/// The state of the cursor grabs.
+#[derive(Clone, Copy)]
+struct GrabState {
+    /// The grab mode requested by the user.
+    user_grab_mode: CursorGrabMode,
+
+    /// The current grab mode.
+    current_grab_mode: CursorGrabMode,
+}
+
+impl GrabState {
+    fn new() -> Self {
+        Self {
+            user_grab_mode: CursorGrabMode::None,
+            current_grab_mode: CursorGrabMode::None,
+        }
+    }
+}
+
+impl WindowState {
+    /// Apply closure on the given pointer.
+    fn apply_on_poiner<F: Fn(&ThemedPointer<WinitPointerData>, &WinitPointerData)>(
+        &self,
+        callback: F,
+    ) {
+        self.pointers
+            .iter()
+            .filter_map(Weak::upgrade)
+            .for_each(|pointer| {
+                let data = pointer.pointer().winit_data();
+                callback(pointer.as_ref(), data);
+            })
+    }
+
+    pub fn configure(
+        &mut self,
+        configure: WindowConfigure,
+        shm: &Shm,
+        subcompositor: &Arc<SubcompositorState>,
+    ) -> LogicalSize<u32> {
+        if configure.decoration_mode == DecorationMode::Client
+            && self.frame.is_none()
+            && !self.csd_fails
+        {
+            match WinitFrame::new(
+                &*self.window,
+                shm,
+                subcompositor.clone(),
+                self.queue_handle.clone(),
+                #[cfg(feature = "sctk-adwaita")]
+                into_sctk_adwaita_config(self.theme),
+            ) {
+                Ok(mut frame) => {
+                    frame.set_title(&self.title);
+                    // Hide the frame if we were asked to not decorate.
+                    frame.set_hidden(!self.decorate);
+                    self.frame = Some(frame);
+                }
+                Err(err) => {
+                    warn!("Failed to create client side decorations frame: {err}");
+                    self.csd_fails = true;
+                }
+            }
+        } else if configure.decoration_mode == DecorationMode::Server {
+            // Drop the frame for server side decorations to save resources.
+            self.frame = None;
+        }
+
+        let stateless = Self::is_stateless(&configure);
+
+        let new_size = if let Some(frame) = self.frame.as_mut() {
+            // Configure the window states.
+            frame.update_state(configure.state);
+
+            match configure.new_size {
+                (Some(width), Some(height)) => {
+                    let (width, height) = frame.subtract_borders(width, height);
+                    (
+                        width.map(|w| w.get()).unwrap_or(1),
+                        height.map(|h| h.get()).unwrap_or(1),
+                    )
+                        .into()
+                }
+                (_, _) if stateless => self.stateless_size,
+                _ => self.size,
+            }
+        } else {
+            match configure.new_size {
+                (Some(width), Some(height)) => (width.get(), height.get()).into(),
+                _ if stateless => self.stateless_size,
+                _ => self.size,
+            }
+        };
+
+        // XXX Set the configure before doing a resize.
+        self.last_configure = Some(configure);
+
+        // XXX Update the new size right away.
+        self.resize(new_size);
+
+        new_size
+    }
+
+    #[inline]
+    fn is_stateless(configure: &WindowConfigure) -> bool {
+        !(configure.is_maximized() || configure.is_fullscreen() || configure.is_tiled())
+    }
+
+    /// Start interacting drag resize.
+    pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), ExternalError> {
+        let xdg_toplevel = self.window.xdg_toplevel();
+
+        // TODO(kchibisov) handle touch serials.
+        self.apply_on_poiner(|_, data| {
+            let serial = data.latest_button_serial();
+            let seat = data.seat();
+            xdg_toplevel.resize(seat, serial, direction.into());
+        });
+
+        Ok(())
+    }
+
+    /// Start the window drag.
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        let xdg_toplevel = self.window.xdg_toplevel();
+        // TODO(kchibisov) handle touch serials.
+        self.apply_on_poiner(|_, data| {
+            let serial = data.latest_button_serial();
+            let seat = data.seat();
+            xdg_toplevel._move(seat, serial);
+        });
+
+        Ok(())
+    }
+
+    /// Tells whether the window should be closed.
+    pub fn frame_click(
+        &mut self,
+        click: FrameClick,
+        pressed: bool,
+        seat: &WlSeat,
+        serial: u32,
+        window_id: WindowId,
+        updates: &mut Vec<WindowCompositorUpdate>,
+    ) -> Option<bool> {
+        match self.frame.as_mut()?.on_click(click, pressed)? {
+            FrameAction::Minimize => self.window.set_minimized(),
+            FrameAction::Maximize => self.window.set_maximized(),
+            FrameAction::UnMaximize => self.window.unset_maximized(),
+            FrameAction::Close => WinitState::queue_close(updates, window_id),
+            FrameAction::Move => self.window.move_(seat, serial),
+            FrameAction::Resize(edge) => self.window.resize(seat, serial, edge),
+            FrameAction::ShowMenu(x, y) => self.window.show_window_menu(seat, serial, (x, y)),
+        };
+
+        Some(false)
+    }
+
+    pub fn frame_point_left(&mut self) {
+        if let Some(frame) = self.frame.as_mut() {
+            frame.click_point_left();
+        }
+    }
+
+    // Move the point over decorations.
+    pub fn frame_point_moved(&mut self, surface: &WlSurface, x: f64, y: f64) -> Option<&str> {
+        if let Some(frame) = self.frame.as_mut() {
+            frame.click_point_moved(surface, x, y)
+        } else {
+            None
+        }
+    }
+
+    /// Get the stored resizable state.
+    #[inline]
+    pub fn resizable(&self) -> bool {
+        self.resizable
+    }
+
+    /// Set the resizable state on the window.
+    #[inline]
+    pub fn set_resizable(&mut self, resizable: bool) {
+        if self.resizable == resizable {
+            return;
+        }
+
+        self.resizable = resizable;
+        if resizable {
+            // Restore min/max sizes of the window.
+            self.reload_min_max_hints();
+        } else {
+            self.set_min_inner_size(Some(self.size));
+            self.set_max_inner_size(Some(self.size));
+        }
+
+        // Reload the state on the frame as well.
+        if let Some(frame) = self.frame.as_mut() {
+            frame.set_resizable(resizable);
+        }
+    }
+
+    /// Whether the window is focused.
+    #[inline]
+    pub fn has_focus(&self) -> bool {
+        self.has_focus
+    }
+
+    /// Whether the IME is allowed.
+    #[inline]
+    pub fn ime_allowed(&self) -> bool {
+        self.ime_allowed
+    }
+
+    /// Get the size of the window.
+    #[inline]
+    pub fn inner_size(&self) -> LogicalSize<u32> {
+        self.size
+    }
+
+    /// Whether the window received initial configure event from the compositor.
+    #[inline]
+    pub fn is_configured(&self) -> bool {
+        self.last_configure.is_some()
+    }
+
+    #[inline]
+    pub fn is_decorated(&mut self) -> bool {
+        let csd = self
+            .last_configure
+            .as_ref()
+            .map(|configure| configure.decoration_mode == DecorationMode::Client)
+            .unwrap_or(false);
+        if let Some(frame) = csd.then_some(self.frame.as_ref()).flatten() {
+            frame.is_hidden()
+        } else {
+            // Server side decorations.
+            true
+        }
+    }
+
+    /// Create new window state.
+    pub fn new(
+        connection: Connection,
+        queue_handle: &QueueHandle<WinitState>,
+        winit_state: &WinitState,
+        size: LogicalSize<u32>,
+        window: Window,
+        theme: Option<Theme>,
+    ) -> Self {
+        let compositor = winit_state.compositor_state.clone();
+        let pointer_constraints = winit_state.pointer_constraints.clone();
+        let viewport = winit_state
+            .viewporter_state
+            .as_ref()
+            .map(|state| state.get_viewport(window.wl_surface(), queue_handle));
+        let fractional_scale = winit_state
+            .fractional_scaling_manager
+            .as_ref()
+            .map(|fsm| fsm.fractional_scaling(window.wl_surface(), queue_handle));
+
+        Self {
+            compositor,
+            connection,
+            theme,
+            csd_fails: false,
+            decorate: true,
+            cursor_grab_mode: GrabState::new(),
+            cursor_icon: CursorIcon::Default,
+            cursor_visible: true,
+            fractional_scale,
+            frame: None,
+            has_focus: false,
+            ime_allowed: false,
+            ime_purpose: ImePurpose::Normal,
+            last_configure: None,
+            max_inner_size: None,
+            min_inner_size: MIN_WINDOW_SIZE,
+            pointer_constraints,
+            pointers: Default::default(),
+            queue_handle: queue_handle.clone(),
+            scale_factor: 1.,
+            shm: winit_state.shm.wl_shm().clone(),
+            size,
+            stateless_size: size,
+            text_inputs: Vec::new(),
+            title: String::default(),
+            transparent: false,
+            resizable: true,
+            viewport,
+            window: ManuallyDrop::new(window),
+        }
+    }
+
+    /// Get the outer size of the window.
+    #[inline]
+    pub fn outer_size(&self) -> LogicalSize<u32> {
+        self.frame
+            .as_ref()
+            .map(|frame| frame.add_borders(self.size.width, self.size.height).into())
+            .unwrap_or(self.size)
+    }
+
+    /// Register pointer on the top-level.
+    pub fn pointer_entered(&mut self, added: Weak<ThemedPointer<WinitPointerData>>) {
+        self.pointers.push(added);
+        self.reload_cursor_style();
+
+        let mode = self.cursor_grab_mode.user_grab_mode;
+        let _ = self.set_cursor_grab_inner(mode);
+    }
+
+    /// Pointer has left the top-level.
+    pub fn pointer_left(&mut self, removed: Weak<ThemedPointer<WinitPointerData>>) {
+        let mut new_pointers = Vec::new();
+        for pointer in self.pointers.drain(..) {
+            if let Some(pointer) = pointer.upgrade() {
+                if pointer.pointer() != removed.upgrade().unwrap().pointer() {
+                    new_pointers.push(Arc::downgrade(&pointer));
+                }
+            }
+        }
+
+        self.pointers = new_pointers;
+    }
+
+    /// Refresh the decorations frame if it's present returning whether the client should redraw.
+    pub fn refresh_frame(&mut self) -> bool {
+        if let Some(frame) = self.frame.as_mut() {
+            let dirty = frame.is_dirty();
+            if dirty {
+                frame.draw();
+            }
+            dirty
+        } else {
+            false
+        }
+    }
+
+    /// Reload the cursor style on the given window.
+    pub fn reload_cursor_style(&mut self) {
+        if self.cursor_visible {
+            self.set_cursor(self.cursor_icon);
+        } else {
+            self.set_cursor_visible(self.cursor_visible);
+        }
+    }
+
+    /// Reissue the transparency hint to the compositor.
+    pub fn reload_transparency_hint(&self) {
+        let surface = self.window.wl_surface();
+
+        if self.transparent {
+            surface.set_opaque_region(None);
+        } else if let Ok(region) = Region::new(&*self.compositor) {
+            region.add(0, 0, i32::MAX, i32::MAX);
+            surface.set_opaque_region(Some(region.wl_region()));
+        } else {
+            warn!("Failed to mark window opaque.");
+        }
+    }
+
+    /// Resize the window to the new inner size.
+    pub fn resize(&mut self, inner_size: LogicalSize<u32>) {
+        self.size = inner_size;
+
+        // Update the stateless size.
+        if Some(true) == self.last_configure.as_ref().map(Self::is_stateless) {
+            self.stateless_size = inner_size;
+        }
+
+        // Update the inner frame.
+        let ((x, y), outer_size) = if let Some(frame) = self.frame.as_mut() {
+            // Resize only visible frame.
+            if !frame.is_hidden() {
+                frame.resize(
+                    NonZeroU32::new(self.size.width).unwrap(),
+                    NonZeroU32::new(self.size.height).unwrap(),
+                );
+            }
+
+            (
+                frame.location(),
+                frame.add_borders(self.size.width, self.size.height).into(),
+            )
+        } else {
+            ((0, 0), self.size)
+        };
+
+        // Reload the hint.
+        self.reload_transparency_hint();
+
+        // Set the window geometry.
+        self.window.xdg_surface().set_window_geometry(
+            x,
+            y,
+            outer_size.width as i32,
+            outer_size.height as i32,
+        );
+
+        // Update the target viewport, this is used if and only if fractional scaling is in use.
+        if let Some(viewport) = self.viewport.as_ref() {
+            // Set inner size without the borders.
+            viewport.set_destination(self.size.width as _, self.size.height as _);
+        }
+    }
+
+    /// Get the scale factor of the window.
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        self.scale_factor
+    }
+
+    /// Set the cursor icon.
+    ///
+    /// Providing `None` will hide the cursor.
+    pub fn set_cursor(&mut self, cursor_icon: CursorIcon) {
+        self.cursor_icon = cursor_icon;
+
+        if !self.cursor_visible {
+            return;
+        }
+
+        self.apply_on_poiner(|pointer, data| {
+            let surface = data.cursor_surface();
+            let scale_factor = surface.data::<SurfaceData>().unwrap().scale_factor();
+
+            if pointer
+                .set_cursor(
+                    &self.connection,
+                    cursor_icon.name(),
+                    &self.shm,
+                    surface,
+                    scale_factor,
+                )
+                .is_err()
+            {
+                warn!("Failed to set cursor to {:?}", cursor_icon);
+            }
+        })
+    }
+
+    /// Set maximum inner window size.
+    pub fn set_min_inner_size(&mut self, size: Option<LogicalSize<u32>>) {
+        // Ensure that the window has the right minimum size.
+        let mut size = size.unwrap_or(MIN_WINDOW_SIZE);
+        size.width = size.width.max(MIN_WINDOW_SIZE.width);
+        size.height = size.height.max(MIN_WINDOW_SIZE.height);
+
+        // Add the borders.
+        let size = self
+            .frame
+            .as_ref()
+            .map(|frame| frame.add_borders(size.width, size.height).into())
+            .unwrap_or(size);
+
+        self.min_inner_size = size;
+        self.window.set_min_size(Some(size.into()));
+    }
+
+    /// Set maximum inner window size.
+    pub fn set_max_inner_size(&mut self, size: Option<LogicalSize<u32>>) {
+        let size = size.map(|size| {
+            self.frame
+                .as_ref()
+                .map(|frame| frame.add_borders(size.width, size.height).into())
+                .unwrap_or(size)
+        });
+
+        self.max_inner_size = size;
+        self.window.set_max_size(size.map(Into::into));
+    }
+
+    /// Set the CSD theme.
+    pub fn set_theme(&mut self, theme: Option<Theme>) {
+        self.theme = theme;
+        #[cfg(feature = "sctk-adwaita")]
+        if let Some(frame) = self.frame.as_mut() {
+            frame.set_config(into_sctk_adwaita_config(theme))
+        }
+    }
+
+    /// The current theme for CSD decorations.
+    #[inline]
+    pub fn theme(&self) -> Option<Theme> {
+        self.theme
+    }
+
+    /// Set the cursor grabbing state on the top-level.
+    pub fn set_cursor_grab(&mut self, mode: CursorGrabMode) -> Result<(), ExternalError> {
+        // Replace the user grabbing mode.
+        self.cursor_grab_mode.user_grab_mode = mode;
+        self.set_cursor_grab_inner(mode)
+    }
+
+    /// Reload the hints for minimum and maximum sizes.
+    pub fn reload_min_max_hints(&mut self) {
+        self.set_min_inner_size(Some(self.min_inner_size));
+        self.set_max_inner_size(self.max_inner_size);
+    }
+
+    /// Set the grabbing state on the surface.
+    fn set_cursor_grab_inner(&mut self, mode: CursorGrabMode) -> Result<(), ExternalError> {
+        let pointer_constraints = match self.pointer_constraints.as_ref() {
+            Some(pointer_constraints) => pointer_constraints,
+            None if mode == CursorGrabMode::None => return Ok(()),
+            None => return Err(ExternalError::NotSupported(NotSupportedError::new())),
+        };
+
+        // Replace the current mode.
+        let old_mode = std::mem::replace(&mut self.cursor_grab_mode.current_grab_mode, mode);
+
+        match old_mode {
+            CursorGrabMode::None => (),
+            CursorGrabMode::Confined => self.apply_on_poiner(|_, data| {
+                data.unconfine_pointer();
+            }),
+            CursorGrabMode::Locked => {
+                self.apply_on_poiner(|_, data| data.unlock_pointer());
+            }
+        }
+
+        let surface = self.window.wl_surface();
+        match mode {
+            CursorGrabMode::Locked => self.apply_on_poiner(|pointer, data| {
+                let pointer = pointer.pointer();
+                data.lock_pointer(pointer_constraints, surface, pointer, &self.queue_handle)
+            }),
+            CursorGrabMode::Confined => self.apply_on_poiner(|pointer, data| {
+                let pointer = pointer.pointer();
+                data.confine_pointer(pointer_constraints, surface, pointer, &self.queue_handle)
+            }),
+            CursorGrabMode::None => {
+                // Current lock/confine was already removed.
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Set the position of the cursor.
+    pub fn set_cursor_position(&self, position: LogicalPosition<f64>) -> Result<(), ExternalError> {
+        if self.pointer_constraints.is_none() {
+            return Err(ExternalError::NotSupported(NotSupportedError::new()));
+        }
+
+        // Positon can be set only for locked cursor.
+        if self.cursor_grab_mode.current_grab_mode != CursorGrabMode::Locked {
+            return Err(ExternalError::Os(os_error!(
+                crate::platform_impl::OsError::WaylandMisc(
+                    "cursor position can be set only for locked cursor."
+                )
+            )));
+        }
+
+        self.apply_on_poiner(|_, data| {
+            data.set_locked_cursor_position(position.x, position.y);
+        });
+
+        Ok(())
+    }
+
+    /// Set the visibility state of the cursor.
+    pub fn set_cursor_visible(&mut self, cursor_visible: bool) {
+        self.cursor_visible = cursor_visible;
+
+        if self.cursor_visible {
+            self.set_cursor(self.cursor_icon);
+        } else {
+            for pointer in self.pointers.iter().filter_map(|pointer| pointer.upgrade()) {
+                let latest_enter_serial = pointer.pointer().winit_data().latest_enter_serial();
+
+                pointer
+                    .pointer()
+                    .set_cursor(latest_enter_serial, None, 0, 0);
+            }
+        }
+    }
+
+    /// Whether show or hide client side decorations.
+    #[inline]
+    pub fn set_decorate(&mut self, decorate: bool) {
+        if decorate == self.decorate {
+            return;
+        }
+
+        self.decorate = decorate;
+
+        match self
+            .last_configure
+            .as_ref()
+            .map(|configure| configure.decoration_mode)
+        {
+            Some(DecorationMode::Server) if !self.decorate => {
+                // To disable decorations we should request client and hide the frame.
+                self.window
+                    .request_decoration_mode(Some(DecorationMode::Client))
+            }
+            _ if self.decorate => self
+                .window
+                .request_decoration_mode(Some(DecorationMode::Server)),
+            _ => (),
+        }
+
+        if let Some(frame) = self.frame.as_mut() {
+            frame.set_hidden(!decorate);
+            // Force the resize.
+            self.resize(self.size);
+        }
+    }
+
+    /// Mark that the window has focus.
+    ///
+    /// Should be used from routine that sends focused event.
+    #[inline]
+    pub fn set_has_focus(&mut self, has_focus: bool) {
+        self.has_focus = has_focus;
+    }
+
+    /// Returns `true` if the requested state was applied.
+    pub fn set_ime_allowed(&mut self, allowed: bool) -> bool {
+        self.ime_allowed = allowed;
+
+        let mut applied = false;
+        for text_input in &self.text_inputs {
+            applied = true;
+            if allowed {
+                text_input.enable();
+                text_input.set_content_type_by_purpose(self.ime_purpose);
+            } else {
+                text_input.disable();
+            }
+            text_input.commit();
+        }
+
+        applied
+    }
+
+    /// Set the IME position.
+    pub fn set_ime_cursor_area(&self, position: LogicalPosition<u32>, size: LogicalSize<u32>) {
+        // XXX This won't fly unless user will have a way to request IME window per seat, since
+        // the ime windows will be overlapping, but winit doesn't expose API to specify for
+        // which seat we're setting IME position.
+        let (x, y) = (position.x as i32, position.y as i32);
+        let (width, height) = (size.width as i32, size.height as i32);
+        for text_input in self.text_inputs.iter() {
+            text_input.set_cursor_rectangle(x, y, width, height);
+            text_input.commit();
+        }
+    }
+
+    /// Set the IME purpose.
+    pub fn set_ime_purpose(&mut self, purpose: ImePurpose) {
+        self.ime_purpose = purpose;
+
+        for text_input in &self.text_inputs {
+            text_input.set_content_type_by_purpose(purpose);
+            text_input.commit();
+        }
+    }
+
+    /// Get the IME purpose.
+    pub fn ime_purpose(&self) -> ImePurpose {
+        self.ime_purpose
+    }
+
+    /// Set the scale factor for the given window.
+    #[inline]
+    pub fn set_scale_factor(&mut self, scale_factor: f64) {
+        self.scale_factor = scale_factor;
+
+        // XXX when fractional scaling is not used update the buffer scale.
+        if self.fractional_scale.is_none() {
+            let _ = self.window.set_buffer_scale(self.scale_factor as _);
+        }
+    }
+
+    /// Set the window title to a new value.
+    ///
+    /// This will autmatically truncate the title to something meaningfull.
+    pub fn set_title(&mut self, mut title: String) {
+        // Truncate the title to at most 1024 bytes, so that it does not blow up the protocol
+        // messages
+        if title.len() > 1024 {
+            let mut new_len = 1024;
+            while !title.is_char_boundary(new_len) {
+                new_len -= 1;
+            }
+            title.truncate(new_len);
+        }
+
+        // Update the CSD title.
+        if let Some(frame) = self.frame.as_mut() {
+            frame.set_title(&title);
+        }
+
+        self.window.set_title(&title);
+        self.title = title;
+    }
+
+    /// Mark the window as transparent.
+    #[inline]
+    pub fn set_transparent(&mut self, transparent: bool) {
+        self.transparent = transparent;
+        self.reload_transparency_hint();
+    }
+
+    /// Register text input on the top-level.
+    #[inline]
+    pub fn text_input_entered(&mut self, text_input: &ZwpTextInputV3) {
+        if !self.text_inputs.iter().any(|t| t == text_input) {
+            self.text_inputs.push(text_input.clone());
+        }
+    }
+
+    /// The text input left the top-level.
+    #[inline]
+    pub fn text_input_left(&mut self, text_input: &ZwpTextInputV3) {
+        if let Some(position) = self.text_inputs.iter().position(|t| t == text_input) {
+            self.text_inputs.remove(position);
+        }
+    }
+
+    /// Get the cached title.
+    #[inline]
+    pub fn title(&self) -> &str {
+        &self.title
+    }
+}
+
+impl Drop for WindowState {
+    fn drop(&mut self) {
+        let surface = self.window.wl_surface().clone();
+        unsafe {
+            ManuallyDrop::drop(&mut self.window);
+        }
+
+        surface.destroy();
+    }
+}
+
+impl From<ResizeDirection> for ResizeEdge {
+    fn from(value: ResizeDirection) -> Self {
+        match value {
+            ResizeDirection::North => ResizeEdge::Top,
+            ResizeDirection::West => ResizeEdge::Left,
+            ResizeDirection::NorthWest => ResizeEdge::TopLeft,
+            ResizeDirection::NorthEast => ResizeEdge::TopRight,
+            ResizeDirection::East => ResizeEdge::Right,
+            ResizeDirection::SouthWest => ResizeEdge::BottomLeft,
+            ResizeDirection::SouthEast => ResizeEdge::BottomRight,
+            ResizeDirection::South => ResizeEdge::Bottom,
+        }
+    }
+}
+
+// XXX rust doesn't allow from `Option`.
+#[cfg(feature = "sctk-adwaita")]
+fn into_sctk_adwaita_config(theme: Option<Theme>) -> sctk_adwaita::FrameConfig {
+    match theme {
+        Some(Theme::Light) => sctk_adwaita::FrameConfig::light(),
+        Some(Theme::Dark) => sctk_adwaita::FrameConfig::dark(),
+        None => sctk_adwaita::FrameConfig::auto(),
+    }
+}
--- a/src/platform_impl/linux/x11/event_processor.rs
+++ b/src/platform_impl/linux/x11/event_processor.rs
@@ -1,23 +1,19 @@
 use std::{cell::RefCell, collections::HashMap, rc::Rc, slice, sync::Arc};

-use libc::{c_char, c_int, c_long, c_uint, c_ulong};
+use libc::{c_char, c_int, c_long, c_ulong};

 use super::{
-    events, ffi, get_xtarget, mkdid, mkwid, monitor, util, Device, DeviceId, DeviceInfo, Dnd,
-    DndState, GenericEventCookie, ImeReceiver, ScrollOrientation, UnownedWindow, WindowId,
-    XExtension,
+    ffi, get_xtarget, mkdid, mkwid, monitor, util, Device, DeviceId, DeviceInfo, Dnd, DndState,
+    GenericEventCookie, ImeReceiver, ScrollOrientation, UnownedWindow, WindowId, XExtension,
 };

-use util::modifiers::{ModifierKeyState, ModifierKeymap};
-
 use crate::platform_impl::platform::x11::ime::{ImeEvent, ImeEventReceiver, ImeRequest};
 use crate::{
    dpi::{PhysicalPosition, PhysicalSize},
-    event::{
-        DeviceEvent, ElementState, Event, Ime, KeyboardInput, ModifiersState, TouchPhase,
-        WindowEvent,
-    },
+    event::{DeviceEvent, ElementState, Event, Ime, RawKeyEvent, TouchPhase, WindowEvent},
    event_loop::EventLoopWindowTarget as RootELW,
+    keyboard::ModifiersState,
+    platform_impl::platform::common::{keymap, xkb_state::KbdState},
 };

 /// The X11 documentation states: "Keycodes lie in the inclusive range `[8, 255]`".
@@ -30,11 +26,13 @@ pub(super) struct EventProcessor<T: 'static> {
    pub(super) randr_event_offset: c_int,
    pub(super) devices: RefCell<HashMap<DeviceId, Device>>,
    pub(super) xi2ext: XExtension,
+    pub(super) xkbext: XExtension,
    pub(super) target: Rc<RootELW<T>>,
-    pub(super) mod_keymap: ModifierKeymap,
-    pub(super) device_mod_state: ModifierKeyState,
+    pub(super) kb_state: KbdState,
    // Number of touch events currently in progress
    pub(super) num_touch: u32,
+    // Whether we've got a key release for the key press.
+    pub(super) got_key_release: bool,
    pub(super) first_touch: Option<u64>,
    // Currently focused window belonging to this process
    pub(super) active_window: Option<ffi::Window>,
@@ -134,47 +132,8 @@ impl<T: 'static> EventProcessor<T> {
            return;
        }

-        // We can't call a `&mut self` method because of the above borrow,
-        // so we use this macro for repeated modifier state updates.
-        macro_rules! update_modifiers {
-            ( $state:expr , $modifier:expr ) => {{
-                match ($state, $modifier) {
-                    (state, modifier) => {
-                        if let Some(modifiers) =
-                            self.device_mod_state.update_state(&state, modifier)
-                        {
-                            if let Some(window_id) = self.active_window {
-                                callback(Event::WindowEvent {
-                                    window_id: mkwid(window_id),
-                                    event: WindowEvent::ModifiersChanged(modifiers),
-                                });
-                            }
-                        }
-                    }
-                }
-            }};
-        }
-
        let event_type = xev.get_type();
        match event_type {
-            ffi::MappingNotify => {
-                let mapping: &ffi::XMappingEvent = xev.as_ref();
-
-                if mapping.request == ffi::MappingModifier
-                    || mapping.request == ffi::MappingKeyboard
-                {
-                    unsafe {
-                        (wt.xconn.xlib.XRefreshKeyboardMapping)(xev.as_mut());
-                    }
-                    wt.xconn
-                        .check_errors()
-                        .expect("Failed to call XRefreshKeyboardMapping");
-
-                    self.mod_keymap.reset_from_x_connection(&wt.xconn);
-                    self.device_mod_state.update_keymap(&self.mod_keymap);
-                }
-            }
-
            ffi::ClientMessage => {
                let client_msg: &ffi::XClientMessageEvent = xev.as_ref();

@@ -577,67 +536,41 @@ impl<T: 'static> EventProcessor<T> {
                }
            }

-            ffi::KeyPress | ffi::KeyRelease => {
-                use crate::event::ElementState::{Pressed, Released};
-
-                // Note that in compose/pre-edit sequences, this will always be Released.
-                let state = if xev.get_type() == ffi::KeyPress {
-                    Pressed
-                } else {
-                    Released
+            // Note that in compose/pre-edit sequences, we'll always receive KeyRelease events
+            ty @ ffi::KeyPress | ty @ ffi::KeyRelease => {
+                let xkev: &mut ffi::XKeyEvent = xev.as_mut();
+                let window = match self.active_window {
+                    Some(window) => window,
+                    None => return,
                };

-                let xkev: &mut ffi::XKeyEvent = xev.as_mut();
-
-                let window = xkev.window;
                let window_id = mkwid(window);
+                let device_id = mkdid(util::VIRTUAL_CORE_KEYBOARD);

-                // Standard virtual core keyboard ID. XInput2 needs to be used to get a reliable
-                // value, though this should only be an issue under multiseat configurations.
-                let device = util::VIRTUAL_CORE_KEYBOARD;
-                let device_id = mkdid(device);
-                let keycode = xkev.keycode;
+                let keycode = xkev.keycode as _;
+                let repeat = ty == ffi::KeyPress && !self.got_key_release;
+                // Update state after the repeat setting.
+                let state = if ty == ffi::KeyPress {
+                    self.got_key_release = false;
+                    ElementState::Pressed
+                } else {
+                    self.got_key_release = true;
+                    ElementState::Released
+                };

-                // When a compose sequence or IME pre-edit is finished, it ends in a KeyPress with
-                // a keycode of 0.
                if keycode != 0 && !self.is_composing {
-                    let scancode = keycode - KEYCODE_OFFSET as u32;
-                    let keysym = wt.xconn.lookup_keysym(xkev);
-                    let virtual_keycode = events::keysym_to_element(keysym as c_uint);
-
-                    update_modifiers!(
-                        ModifiersState::from_x11_mask(xkev.state),
-                        self.mod_keymap.get_modifier(xkev.keycode as ffi::KeyCode)
-                    );
-
-                    let modifiers = self.device_mod_state.modifiers();
-
-                    #[allow(deprecated)]
+                    let event = self.kb_state.process_key_event(keycode, state, repeat);
                    callback(Event::WindowEvent {
                        window_id,
                        event: WindowEvent::KeyboardInput {
                            device_id,
-                            input: KeyboardInput {
-                                state,
-                                scancode,
-                                virtual_keycode,
-                                modifiers,
-                            },
+                            event,
                            is_synthetic: false,
                        },
                    });
-                }
-
-                if state == Pressed {
-                    let written = if let Some(ic) = wt.ime.borrow().get_context(window) {
-                        wt.xconn.lookup_utf8(ic, xkev)
-                    } else {
-                        return;
-                    };
-
-                    // If we're composing right now, send the string we've got from X11 via
-                    // Ime::Commit.
-                    if self.is_composing && keycode == 0 && !written.is_empty() {
+                } else if let Some(ic) = wt.ime.borrow().get_context(window) {
+                    let written = wt.xconn.lookup_utf8(ic, xkev);
+                    if !written.is_empty() {
                        let event = Event::WindowEvent {
                            window_id,
                            event: WindowEvent::Ime(Ime::Preedit(String::new(), None)),
@@ -651,15 +584,6 @@ impl<T: 'static> EventProcessor<T> {

                        self.is_composing = false;
                        callback(event);
-                    } else {
-                        for chr in written.chars() {
-                            let event = Event::WindowEvent {
-                                window_id,
-                                event: WindowEvent::ReceivedCharacter(chr),
-                            };
-
-                            callback(event);
-                        }
                    }
                }
            }
@@ -677,7 +601,7 @@ impl<T: 'static> EventProcessor<T> {

                use crate::event::{
                    ElementState::{Pressed, Released},
-                    MouseButton::{Left, Middle, Other, Right},
+                    MouseButton::{Back, Forward, Left, Middle, Other, Right},
                    MouseScrollDelta::LineDelta,
                    Touch,
                    WindowEvent::{
@@ -696,9 +620,6 @@ impl<T: 'static> EventProcessor<T> {
                            return;
                        }

-                        let modifiers = ModifiersState::from_x11(&xev.mods);
-                        update_modifiers!(modifiers, None);
-
                        let state = if xev.evtype == ffi::XI_ButtonPress {
                            Pressed
                        } else {
@@ -711,7 +632,6 @@ impl<T: 'static> EventProcessor<T> {
                                    device_id,
                                    state,
                                    button: Left,
-                                    modifiers,
                                },
                            }),
                            ffi::Button2 => callback(Event::WindowEvent {
@@ -720,7 +640,6 @@ impl<T: 'static> EventProcessor<T> {
                                    device_id,
                                    state,
                                    button: Middle,
-                                    modifiers,
                                },
                            }),
                            ffi::Button3 => callback(Event::WindowEvent {
@@ -729,7 +648,6 @@ impl<T: 'static> EventProcessor<T> {
                                    device_id,
                                    state,
                                    button: Right,
-                                    modifiers,
                                },
                            }),

@@ -750,19 +668,34 @@ impl<T: 'static> EventProcessor<T> {
                                                _ => unreachable!(),
                                            },
                                            phase: TouchPhase::Moved,
-                                            modifiers,
                                        },
                                    });
                                }
                            }

+                            8 => callback(Event::WindowEvent {
+                                window_id,
+                                event: MouseInput {
+                                    device_id,
+                                    state,
+                                    button: Back,
+                                },
+                            }),
+                            9 => callback(Event::WindowEvent {
+                                window_id,
+                                event: MouseInput {
+                                    device_id,
+                                    state,
+                                    button: Forward,
+                                },
+                            }),
+
                            x => callback(Event::WindowEvent {
                                window_id,
                                event: MouseInput {
                                    device_id,
                                    state,
                                    button: Other(x as u16),
-                                    modifiers,
                                },
                            }),
                        }
@@ -773,9 +706,6 @@ impl<T: 'static> EventProcessor<T> {
                        let window_id = mkwid(xev.event);
                        let new_cursor_pos = (xev.event_x, xev.event_y);

-                        let modifiers = ModifiersState::from_x11(&xev.mods);
-                        update_modifiers!(modifiers, None);
-
                        let cursor_moved = self.with_window(xev.event, |window| {
                            let mut shared_state_lock = window.shared_state_lock();
                            util::maybe_change(&mut shared_state_lock.cursor_pos, new_cursor_pos)
@@ -788,7 +718,6 @@ impl<T: 'static> EventProcessor<T> {
                                event: CursorMoved {
                                    device_id,
                                    position,
-                                    modifiers,
                                },
                            });
                        } else if cursor_moved.is_none() {
@@ -835,7 +764,6 @@ impl<T: 'static> EventProcessor<T> {
                                                    }
                                                },
                                                phase: TouchPhase::Moved,
-                                                modifiers,
                                            },
                                        });
                                    } else {
@@ -889,25 +817,11 @@ impl<T: 'static> EventProcessor<T> {

                            let position = PhysicalPosition::new(xev.event_x, xev.event_y);

-                            // The mods field on this event isn't actually populated, so query the
-                            // pointer device. In the future, we can likely remove this round-trip by
-                            // relying on `Xkb` for modifier values.
-                            //
-                            // This needs to only be done after confirming the window still exists,
-                            // since otherwise we risk getting a `BadWindow` error if the window was
-                            // dropped with queued events.
-                            let modifiers = wt
-                                .xconn
-                                .query_pointer(xev.event, xev.deviceid)
-                                .expect("Failed to query pointer device")
-                                .get_modifier_state();
-
                            callback(Event::WindowEvent {
                                window_id,
                                event: CursorMoved {
                                    device_id,
                                    position,
-                                    modifiers,
                                },
                            });
                        }
@@ -935,14 +849,10 @@ impl<T: 'static> EventProcessor<T> {
                            .focus(xev.event)
                            .expect("Failed to focus input context");

-                        let modifiers = ModifiersState::from_x11(&xev.mods);
-
-                        self.device_mod_state.update_state(&modifiers, None);
-
                        if self.active_window != Some(xev.event) {
                            self.active_window = Some(xev.event);

-                            wt.update_device_event_filter(true);
+                            wt.update_listen_device_events(true);

                            let window_id = mkwid(xev.event);
                            let position = PhysicalPosition::new(xev.event_x, xev.event_y);
@@ -956,10 +866,12 @@ impl<T: 'static> EventProcessor<T> {
                                event: Focused(true),
                            });

+                            let modifiers: crate::keyboard::ModifiersState =
+                                self.kb_state.mods_state().into();
                            if !modifiers.is_empty() {
                                callback(Event::WindowEvent {
                                    window_id,
-                                    event: WindowEvent::ModifiersChanged(modifiers),
+                                    event: WindowEvent::ModifiersChanged(modifiers.into()),
                                });
                            }

@@ -977,7 +889,6 @@ impl<T: 'static> EventProcessor<T> {
                                event: CursorMoved {
                                    device_id: mkdid(pointer_id),
                                    position,
-                                    modifiers,
                                },
                            });

@@ -986,8 +897,7 @@ impl<T: 'static> EventProcessor<T> {
                                wt,
                                window_id,
                                ElementState::Pressed,
-                                &self.mod_keymap,
-                                &mut self.device_mod_state,
+                                &mut self.kb_state,
                                &mut callback,
                            );
                        }
@@ -1006,21 +916,22 @@ impl<T: 'static> EventProcessor<T> {
                        if self.active_window.take() == Some(xev.event) {
                            let window_id = mkwid(xev.event);

-                            wt.update_device_event_filter(false);
+                            wt.update_listen_device_events(false);

                            // Issue key release events for all pressed keys
                            Self::handle_pressed_keys(
                                wt,
                                window_id,
                                ElementState::Released,
-                                &self.mod_keymap,
-                                &mut self.device_mod_state,
+                                &mut self.kb_state,
                                &mut callback,
                            );

                            callback(Event::WindowEvent {
                                window_id,
-                                event: WindowEvent::ModifiersChanged(ModifiersState::empty()),
+                                event: WindowEvent::ModifiersChanged(
+                                    ModifiersState::empty().into(),
+                                ),
                            });

                            if let Some(window) = self.with_window(xev.event, Arc::clone) {
@@ -1045,7 +956,6 @@ impl<T: 'static> EventProcessor<T> {
                        };
                        if self.window_exists(xev.event) {
                            let id = xev.detail as u64;
-                            let modifiers = self.device_mod_state.modifiers();
                            let location = PhysicalPosition::new(xev.event_x, xev.event_y);

                            // Mouse cursor position changes when touch events are received.
@@ -1057,7 +967,6 @@ impl<T: 'static> EventProcessor<T> {
                                    event: WindowEvent::CursorMoved {
                                        device_id: mkdid(util::VIRTUAL_CORE_POINTER),
                                        position: location.cast(),
-                                        modifiers,
                                    },
                                });
                            }
@@ -1142,7 +1051,6 @@ impl<T: 'static> EventProcessor<T> {
                            });
                        }
                    }
-
                    ffi::XI_RawKeyPress | ffi::XI_RawKeyRelease => {
                        let xev: &ffi::XIRawEvent = unsafe { &*(xev.data as *const _) };

@@ -1153,46 +1061,19 @@ impl<T: 'static> EventProcessor<T> {
                        };

                        let device_id = mkdid(xev.sourceid);
-                        let keycode = xev.detail;
-                        let scancode = keycode - KEYCODE_OFFSET as i32;
-                        if scancode < 0 {
+                        let keycode = xev.detail as u32;
+                        if keycode < KEYCODE_OFFSET as u32 {
                            return;
                        }
-                        let keysym = wt.xconn.keycode_to_keysym(keycode as ffi::KeyCode);
-                        let virtual_keycode = events::keysym_to_element(keysym as c_uint);
-                        let modifiers = self.device_mod_state.modifiers();
+                        let physical_key = keymap::raw_keycode_to_keycode(keycode);

-                        #[allow(deprecated)]
                        callback(Event::DeviceEvent {
                            device_id,
-                            event: DeviceEvent::Key(KeyboardInput {
-                                scancode: scancode as u32,
-                                virtual_keycode,
+                            event: DeviceEvent::Key(RawKeyEvent {
+                                physical_key,
                                state,
-                                modifiers,
                            }),
                        });
-
-                        if let Some(modifier) =
-                            self.mod_keymap.get_modifier(keycode as ffi::KeyCode)
-                        {
-                            self.device_mod_state.key_event(
-                                state,
-                                keycode as ffi::KeyCode,
-                                modifier,
-                            );
-
-                            let new_modifiers = self.device_mod_state.modifiers();
-
-                            if modifiers != new_modifiers {
-                                if let Some(window_id) = self.active_window {
-                                    callback(Event::WindowEvent {
-                                        window_id: mkwid(window_id),
-                                        event: WindowEvent::ModifiersChanged(new_modifiers),
-                                    });
-                                }
-                            }
-                        }
                    }

                    ffi::XI_HierarchyChanged => {
@@ -1222,6 +1103,55 @@ impl<T: 'static> EventProcessor<T> {
                }
            }
            _ => {
+                if event_type == self.xkbext.first_event_id {
+                    let xev = unsafe { &*(xev as *const _ as *const ffi::XkbAnyEvent) };
+                    match xev.xkb_type {
+                        ffi::XkbNewKeyboardNotify => {
+                            let xev = unsafe {
+                                &*(xev as *const _ as *const ffi::XkbNewKeyboardNotifyEvent)
+                            };
+                            let keycodes_changed_flag = 0x1;
+                            let geometry_changed_flag = 0x1 << 1;
+
+                            let keycodes_changed =
+                                util::has_flag(xev.changed, keycodes_changed_flag);
+                            let geometry_changed =
+                                util::has_flag(xev.changed, geometry_changed_flag);
+
+                            if xev.device == self.kb_state.core_keyboard_id
+                                && (keycodes_changed || geometry_changed)
+                            {
+                                unsafe { self.kb_state.init_with_x11_keymap() };
+                            }
+                        }
+                        ffi::XkbStateNotify => {
+                            let xev =
+                                unsafe { &*(xev as *const _ as *const ffi::XkbStateNotifyEvent) };
+
+                            let prev_mods = self.kb_state.mods_state();
+                            self.kb_state.update_modifiers(
+                                xev.base_mods,
+                                xev.latched_mods,
+                                xev.locked_mods,
+                                xev.base_group as u32,
+                                xev.latched_group as u32,
+                                xev.locked_group as u32,
+                            );
+                            let new_mods = self.kb_state.mods_state();
+                            if prev_mods != new_mods {
+                                if let Some(window) = self.active_window {
+                                    callback(Event::WindowEvent {
+                                        window_id: mkwid(window),
+                                        event: WindowEvent::ModifiersChanged(
+                                            Into::<ModifiersState>::into(new_mods).into(),
+                                        ),
+                                    });
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
                if event_type == self.randr_event_offset {
                    // In the future, it would be quite easy to emit monitor hotplug events.
                    let prev_list = monitor::invalidate_cached_monitor_list();
@@ -1345,14 +1275,12 @@ impl<T: 'static> EventProcessor<T> {
        wt: &super::EventLoopWindowTarget<T>,
        window_id: crate::window::WindowId,
        state: ElementState,
-        mod_keymap: &ModifierKeymap,
-        device_mod_state: &mut ModifierKeyState,
+        kb_state: &mut KbdState,
        callback: &mut F,
    ) where
        F: FnMut(Event<'_, T>),
    {
        let device_id = mkdid(util::VIRTUAL_CORE_KEYBOARD);
-        let modifiers = device_mod_state.modifiers();

        // Update modifiers state and emit key events based on which keys are currently pressed.
        for keycode in wt
@@ -1361,29 +1289,13 @@ impl<T: 'static> EventProcessor<T> {
            .into_iter()
            .filter(|k| *k >= KEYCODE_OFFSET)
        {
-            let scancode = (keycode - KEYCODE_OFFSET) as u32;
-            let keysym = wt.xconn.keycode_to_keysym(keycode);
-            let virtual_keycode = events::keysym_to_element(keysym as c_uint);
-
-            if let Some(modifier) = mod_keymap.get_modifier(keycode as ffi::KeyCode) {
-                device_mod_state.key_event(
-                    ElementState::Pressed,
-                    keycode as ffi::KeyCode,
-                    modifier,
-                );
-            }
-
-            #[allow(deprecated)]
+            let keycode = keycode as u32;
+            let event = kb_state.process_key_event(keycode, state, false);
            callback(Event::WindowEvent {
                window_id,
                event: WindowEvent::KeyboardInput {
                    device_id,
-                    input: KeyboardInput {
-                        scancode,
-                        state,
-                        virtual_keycode,
-                        modifiers,
-                    },
+                    event,
                    is_synthetic: true,
                },
            });
--- a/src/platform_impl/linux/x11/ime/context.rs
+++ b/src/platform_impl/linux/x11/ime/context.rs
@@ -263,7 +263,7 @@ impl ImeContext {
            ptr::null_mut::<()>(),
        );

-        (!ic.is_null()).then(|| ic)
+        (!ic.is_null()).then_some(ic)
    }

    unsafe fn create_preedit_ic(
@@ -302,7 +302,7 @@ impl ImeContext {
            ptr::null_mut::<()>(),
        );

-        (!ic.is_null()).then(|| ic)
+        (!ic.is_null()).then_some(ic)
    }

    unsafe fn create_nothing_ic(
@@ -320,7 +320,7 @@ impl ImeContext {
            ptr::null_mut::<()>(),
        );

-        (!ic.is_null()).then(|| ic)
+        (!ic.is_null()).then_some(ic)
    }

    pub(crate) fn focus(&self, xconn: &Arc<XConnection>) -> Result<(), XError> {
--- a/src/platform_impl/linux/x11/mod.rs
+++ b/src/platform_impl/linux/x11/mod.rs
@@ -2,7 +2,6 @@

 mod dnd;
 mod event_processor;
-mod events;
 pub mod ffi;
 mod ime;
 mod monitor;
@@ -18,38 +17,38 @@ pub(crate) use self::{

 pub use self::xdisplay::{XError, XNotSupported};

+use calloop::channel::{channel, Channel, Event as ChanResult, Sender};
+use calloop::generic::Generic;
+use calloop::{Dispatcher, EventLoop as Loop};
+
 use std::{
    cell::{Cell, RefCell},
-    collections::{HashMap, HashSet},
+    collections::{HashMap, HashSet, VecDeque},
    ffi::CStr,
    mem::{self, MaybeUninit},
    ops::Deref,
    os::raw::*,
+    os::unix::io::RawFd,
    ptr,
    rc::Rc,
    slice,
-    sync::mpsc::{Receiver, Sender, TryRecvError},
    sync::{mpsc, Arc, Weak},
    time::{Duration, Instant},
 };

 use libc::{self, setlocale, LC_CTYPE};
-
-use mio::{unix::SourceFd, Events, Interest, Poll, Token, Waker};
 use raw_window_handle::{RawDisplayHandle, XlibDisplayHandle};

 use self::{
    dnd::{Dnd, DndState},
    event_processor::EventProcessor,
    ime::{Ime, ImeCreationError, ImeReceiver, ImeRequest, ImeSender},
-    util::modifiers::ModifierKeymap,
 };
+use super::common::xkb_state::KbdState;
 use crate::{
    error::OsError as RootOsError,
    event::{Event, StartCause},
-    event_loop::{
-        ControlFlow, DeviceEventFilter, EventLoopClosed, EventLoopWindowTarget as RootELW,
-    },
+    event_loop::{ControlFlow, DeviceEvents, EventLoopClosed, EventLoopWindowTarget as RootELW},
    platform_impl::{
        platform::{sticky_exit_callback, WindowId},
        PlatformSpecificWindowBuilderAttributes,
@@ -57,47 +56,7 @@ use crate::{
    window::WindowAttributes,
 };

-const X_TOKEN: Token = Token(0);
-const USER_REDRAW_TOKEN: Token = Token(1);
-
-struct WakeSender<T> {
-    sender: Sender<T>,
-    waker: Arc<Waker>,
-}
-
-struct PeekableReceiver<T> {
-    recv: Receiver<T>,
-    first: Option<T>,
-}
-
-impl<T> PeekableReceiver<T> {
-    pub fn from_recv(recv: Receiver<T>) -> Self {
-        Self { recv, first: None }
-    }
-    pub fn has_incoming(&mut self) -> bool {
-        if self.first.is_some() {
-            return true;
-        }
-
-        match self.recv.try_recv() {
-            Ok(v) => {
-                self.first = Some(v);
-                true
-            }
-            Err(TryRecvError::Empty) => false,
-            Err(TryRecvError::Disconnected) => {
-                warn!("Channel was disconnected when checking incoming");
-                false
-            }
-        }
-    }
-    pub fn try_recv(&mut self) -> Result<T, TryRecvError> {
-        if let Some(first) = self.first.take() {
-            return Ok(first);
-        }
-        self.recv.try_recv()
-    }
-}
+type X11Source = Generic<RawFd>;

 pub struct EventLoopWindowTarget<T> {
    xconn: Arc<XConnection>,
@@ -107,31 +66,40 @@ pub struct EventLoopWindowTarget<T> {
    root: ffi::Window,
    ime: RefCell<Ime>,
    windows: RefCell<HashMap<WindowId, Weak<UnownedWindow>>>,
-    redraw_sender: WakeSender<WindowId>,
-    device_event_filter: Cell<DeviceEventFilter>,
+    redraw_sender: Sender<WindowId>,
+    device_events: Cell<DeviceEvents>,
    _marker: ::std::marker::PhantomData<T>,
 }

 pub struct EventLoop<T: 'static> {
-    poll: Poll,
-    waker: Arc<Waker>,
+    event_loop: Loop<'static, EventLoopState<T>>,
    event_processor: EventProcessor<T>,
-    redraw_receiver: PeekableReceiver<WindowId>,
-    user_receiver: PeekableReceiver<T>, //waker.wake needs to be called whenever something gets sent
    user_sender: Sender<T>,
    target: Rc<RootELW<T>>,
+
+    /// The current state of the event loop.
+    state: EventLoopState<T>,
+
+    /// Dispatcher for redraw events.
+    redraw_dispatcher: Dispatcher<'static, Channel<WindowId>, EventLoopState<T>>,
+}
+
+struct EventLoopState<T> {
+    /// Incoming user events.
+    user_events: VecDeque<T>,
+
+    /// Incoming redraw events.
+    redraw_events: VecDeque<WindowId>,
 }

 pub struct EventLoopProxy<T: 'static> {
    user_sender: Sender<T>,
-    waker: Arc<Waker>,
 }

 impl<T: 'static> Clone for EventLoopProxy<T> {
    fn clone(&self) -> Self {
        EventLoopProxy {
            user_sender: self.user_sender.clone(),
-            waker: self.waker.clone(),
        }
    }
 }
@@ -202,6 +170,36 @@ impl<T: 'static> EventLoop<T> {
            ext
        };

+        let xkbext = {
+            let mut ext = XExtension::default();
+
+            let res = unsafe {
+                (xconn.xlib.XkbQueryExtension)(
+                    xconn.display,
+                    &mut ext.opcode,
+                    &mut ext.first_event_id,
+                    &mut ext.first_error_id,
+                    &mut 1,
+                    &mut 0,
+                )
+            };
+
+            if res == ffi::False {
+                panic!("X server missing XKB extension");
+            }
+
+            // Enable detectable auto repeat.
+            let mut supported = 0;
+            unsafe {
+                (xconn.xlib.XkbSetDetectableAutoRepeat)(xconn.display, 1, &mut supported);
+            }
+            if supported == 0 {
+                warn!("Detectable auto repeart is not supported");
+            }
+
+            ext
+        };
+
        unsafe {
            let mut xinput_major_ver = ffi::XI_2_Major;
            let mut xinput_minor_ver = ffi::XI_2_Minor;
@@ -219,18 +217,45 @@ impl<T: 'static> EventLoop<T> {

        xconn.update_cached_wm_info(root);

-        let mut mod_keymap = ModifierKeymap::new();
-        mod_keymap.reset_from_x_connection(&xconn);
+        // Create an event loop.
+        let event_loop =
+            Loop::<EventLoopState<T>>::try_new().expect("Failed to initialize the event loop");
+        let handle = event_loop.handle();

-        let poll = Poll::new().unwrap();
-        let waker = Arc::new(Waker::new(poll.registry(), USER_REDRAW_TOKEN).unwrap());
+        // Create the X11 event dispatcher.
+        let source = X11Source::new(xconn.x11_fd, calloop::Interest::READ, calloop::Mode::Level);
+        handle
+            .insert_source(source, |_, _, _| Ok(calloop::PostAction::Continue))
+            .expect("Failed to register the X11 event dispatcher");

-        poll.registry()
-            .register(&mut SourceFd(&xconn.x11_fd), X_TOKEN, Interest::READABLE)
-            .unwrap();
+        // Create a channel for sending user events.
+        let (user_sender, user_channel) = channel();
+        handle
+            .insert_source(user_channel, |ev, _, state| {
+                if let ChanResult::Msg(user) = ev {
+                    state.user_events.push_back(user);
+                }
+            })
+            .expect("Failed to register the user event channel with the event loop");

-        let (user_sender, user_channel) = std::sync::mpsc::channel();
-        let (redraw_sender, redraw_channel) = std::sync::mpsc::channel();
+        // Create a channel for handling redraw requests.
+        let (redraw_sender, redraw_channel) = channel();
+
+        // Create a dispatcher for the redraw channel such that we can dispatch it independent of the
+        // event loop.
+        let redraw_dispatcher =
+            Dispatcher::<_, EventLoopState<T>>::new(redraw_channel, |ev, _, state| {
+                if let ChanResult::Msg(window_id) = ev {
+                    state.redraw_events.push_back(window_id);
+                }
+            });
+        handle
+            .register_dispatcher(redraw_dispatcher.clone())
+            .expect("Failed to register the redraw event channel with the event loop");
+
+        let kb_state =
+            KbdState::from_x11_xkb(unsafe { (xconn.xlib_xcb.XGetXCBConnection)(xconn.display) })
+                .unwrap();

        let window_target = EventLoopWindowTarget {
            ime,
@@ -241,15 +266,12 @@ impl<T: 'static> EventLoop<T> {
            xconn,
            wm_delete_window,
            net_wm_ping,
-            redraw_sender: WakeSender {
-                sender: redraw_sender, // not used again so no clone
-                waker: waker.clone(),
-            },
-            device_event_filter: Default::default(),
+            redraw_sender,
+            device_events: Default::default(),
        };

        // Set initial device event filter.
-        window_target.update_device_event_filter(true);
+        window_target.update_listen_device_events(true);

        let target = Rc::new(RootELW {
            p: super::EventLoopWindowTarget::X(window_target),
@@ -264,12 +286,13 @@ impl<T: 'static> EventLoop<T> {
            ime_receiver,
            ime_event_receiver,
            xi2ext,
-            mod_keymap,
-            device_mod_state: Default::default(),
+            xkbext,
+            kb_state,
            num_touch: 0,
            first_touch: None,
            active_window: None,
            is_composing: false,
+            got_key_release: true,
        };

        // Register for device hotplug events
@@ -279,23 +302,33 @@ impl<T: 'static> EventLoop<T> {
            .select_xinput_events(root, ffi::XIAllDevices, ffi::XI_HierarchyChangedMask)
            .queue();

+        get_xtarget(&target)
+            .xconn
+            .select_xkb_events(
+                0x100, // Use the "core keyboard device"
+                ffi::XkbNewKeyboardNotifyMask | ffi::XkbStateNotifyMask,
+            )
+            .unwrap()
+            .queue();
+
        event_processor.init_device(ffi::XIAllDevices);

        EventLoop {
-            poll,
-            waker,
+            event_loop,
            event_processor,
-            redraw_receiver: PeekableReceiver::from_recv(redraw_channel),
-            user_receiver: PeekableReceiver::from_recv(user_channel),
            user_sender,
            target,
+            redraw_dispatcher,
+            state: EventLoopState {
+                user_events: VecDeque::new(),
+                redraw_events: VecDeque::new(),
+            },
        }
    }

    pub fn create_proxy(&self) -> EventLoopProxy<T> {
        EventLoopProxy {
            user_sender: self.user_sender.clone(),
-            waker: self.waker.clone(),
        }
    }

@@ -344,7 +377,7 @@ impl<T: 'static> EventLoop<T> {

            // Empty the user event buffer
            {
-                while let Ok(event) = this.user_receiver.try_recv() {
+                while let Some(event) = this.state.user_events.pop_front() {
                    sticky_exit_callback(
                        crate::event::Event::UserEvent(event),
                        &this.target,
@@ -362,11 +395,19 @@ impl<T: 'static> EventLoop<T> {
                    callback,
                );
            }
+
+            // Quickly dispatch all redraw events to avoid buffering them.
+            while let Ok(event) = this.redraw_dispatcher.as_source_mut().try_recv() {
+                this.state.redraw_events.push_back(event);
+            }
+
            // Empty the redraw requests
            {
                let mut windows = HashSet::new();

-                while let Ok(window_id) = this.redraw_receiver.try_recv() {
+                // Empty the channel.
+
+                while let Some(window_id) = this.state.redraw_events.pop_front() {
                    windows.insert(window_id);
                }

@@ -436,7 +477,6 @@ impl<T: 'static> EventLoop<T> {
        }

        let mut control_flow = ControlFlow::default();
-        let mut events = Events::with_capacity(8);
        let mut cause = StartCause::Init;

        // run the initial loop iteration
@@ -447,22 +487,23 @@ impl<T: 'static> EventLoop<T> {
                break code;
            }
            let has_pending = self.event_processor.poll()
-                || self.user_receiver.has_incoming()
-                || self.redraw_receiver.has_incoming();
+                || !self.state.user_events.is_empty()
+                || !self.state.redraw_events.is_empty();
            if !has_pending {
                // Wait until
-                if let Err(e) = self.poll.poll(&mut events, iter_result.timeout) {
-                    if e.raw_os_error() != Some(libc::EINTR) {
-                        panic!("epoll returned an error: {e:?}");
-                    }
+                if let Err(error) = self
+                    .event_loop
+                    .dispatch(iter_result.timeout, &mut self.state)
+                    .map_err(std::io::Error::from)
+                {
+                    break error.raw_os_error().unwrap_or(1);
                }
-                events.clear();

                if control_flow == ControlFlow::Wait {
                    // We don't go straight into executing the event loop iteration, we instead go
                    // to the start of this loop and check again if there's any pending event. We
                    // must do this because during the execution of the iteration we sometimes wake
-                    // the mio waker, and if the waker is already awaken before we call poll(),
+                    // the calloop waker, and if the waker is already awaken before we call poll(),
                    // then poll doesn't block, but it returns immediately. This caused the event
                    // loop to run continuously even if the control_flow was `Wait`
                    continue;
@@ -516,8 +557,7 @@ impl<T: 'static> EventLoop<T> {
                    control_flow,
                    &mut |event, window_target, control_flow| {
                        if let Event::RedrawRequested(crate::window::WindowId(wid)) = event {
-                            wt.redraw_sender.sender.send(wid).unwrap();
-                            wt.redraw_sender.waker.wake().unwrap();
+                            wt.redraw_sender.send(wid).unwrap();
                        } else {
                            callback(event, window_target, control_flow);
                        }
@@ -543,17 +583,17 @@ impl<T> EventLoopWindowTarget<T> {
        &self.xconn
    }

-    pub fn set_device_event_filter(&self, filter: DeviceEventFilter) {
-        self.device_event_filter.set(filter);
+    pub fn set_listen_device_events(&self, allowed: DeviceEvents) {
+        self.device_events.set(allowed);
    }

-    /// Update the device event filter based on window focus.
-    pub fn update_device_event_filter(&self, focus: bool) {
-        let filter_events = self.device_event_filter.get() == DeviceEventFilter::Never
-            || (self.device_event_filter.get() == DeviceEventFilter::Unfocused && !focus);
+    /// Update the device event based on window focus.
+    pub fn update_listen_device_events(&self, focus: bool) {
+        let device_events = self.device_events.get() == DeviceEvents::Always
+            || (focus && self.device_events.get() == DeviceEvents::WhenFocused);

        let mut mask = 0;
-        if !filter_events {
+        if device_events {
            mask = ffi::XI_RawMotionMask
                | ffi::XI_RawButtonPressMask
                | ffi::XI_RawButtonReleaseMask
@@ -580,7 +620,6 @@ impl<T: 'static> EventLoopProxy<T> {
        self.user_sender
            .send(event)
            .map_err(|e| EventLoopClosed(e.0))
-            .map(|_| self.waker.wake().unwrap())
    }
 }

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Kirill Chibisov	84ef89eb1c	Winit version 0.29.0-beta.0	2023-06-30 23:33:29 +04:00
Kirill Chibisov	a320702a71	On X11, fix IME not working The change to xinput2 completely disabled IME support, thus we've got a dead keys reporting, because nothing was eating the key events anymore, however that's not what we really need, given that not working IME makes it impossible for some users to type. The proper solution is to not use Xlib at all for that and rely on xcb and its tooling around the XIM and text compose stuff, so we'll have full control over what is getting sent to the XIM/IC or not. Fixes #2888.	2023-06-30 19:59:24 +04:00
dAxpeDDa	b0106898f7	Don't allow event loops to run in parallel	2023-06-29 15:53:58 +02:00
Fredrik Fornwall	924f3323b5	On Web, map bfcache load/unload to suspend/resume	2023-06-28 15:38:49 +02:00
Kirill Chibisov	b97df599c5	On Linux, fix wrong layout for key_without_modifiers The layout was hardcoded to zero, so the keys were sent for whatever user configured first.	2023-06-28 14:48:35 +04:00
Kirill Chibisov	0defd747c8	Update xkbcommon-dl to 0.4.0 Most things were simply renamed due to migration to xkeysym.	2023-06-28 14:48:35 +04:00
Kirill Chibisov	e23186db8e	Disallow cleanup for TLS in examples Fixes issue on Wayland due to drop order, since TLS is being dropped after the event loop, while it shouldn't. In particular it fixes the crash in the window_run_return example.	2023-06-26 01:04:38 +04:00
Kirill Chibisov	059abb06fc	On Wayland, handle `none` decorations During the migration some logic wrt `none` decorations was lost along the way, however we also now try to ask for client side decorations if the user wants to disable server side decorations. Fixes #2902.	2023-06-25 14:12:12 +04:00
Josh Groves	bc216b8f67	Allow recreating wasm event loop with `spawn` (#2897 )	2023-06-23 19:31:42 +02:00
Josh Groves	864a1d5924	Fix some typos (#2901 )	2023-06-23 10:10:36 +03:00
Kirill Chibisov	05444628e6	Provide a way to set cursor area for IME cursor Rename `Window::set_ime_position` to `Window::set_ime_cursor_area` adding a way to create cursor exclusive zone. Fixes #2886.	2023-06-22 19:12:14 +00:00
Kirill Chibisov	66ff52b012	On Wayland, fix transparency hint not set in new Fixes #2894.	2023-06-22 00:21:43 +00:00
Robert Bragg	7929999c1c	Android: rework keycode handling (#2890 ) The recent overhaul of the keyboard API broke keyboard input on Android. The recent keyboard changes also broke building against the game-activity backend of android-activity because it was assumed that the backend is based on the NDK input API which isn't the case with with game-activity since it doesn't use the InputQueue API from the NDK. Any alphanumeric keycodes were being mapped to `Unidentified` Keys which meant even crude keyboard input support was broken. We do need to expose `getUnicodeChar` (or the ability to look up characters based on the current character map and modifiers) but for now we should at least map alphanumeric keycodes to `Key::Character` for basic interim support of virtual keyboards. This moves all the keycode mapping into a separate `keycodes.rs` file to reduce clutter. This adds back the mapping from Android key codes to Winit key codes that we had before the keyboard API overhaul. Android activity does expose scan codes but key codes currently seem like the more appropriate mapping to Winit physical key codes. This removes the gnarly, unsafe cfg() guarded digging into 'native-activity' and 'game-activity' specific implementation details. I never intended to expose these details in the public API and really hope to avoid there being a release of Winit that would depend on this. I'm also hoping/considering if I can get away with sealing this without necessarily requiring a semver breaking release of android_activity since this absolutely should never have been possible, and can probably safely assume this was the only code in the wild that has briefly done this. I'm also a bit unclear as to what led to doing this. There is a `.key_code()` and `.scan_code()` getter and we even already accessed the keycode in the Android backend so I'm not sure how those APIs were missed.	2023-06-21 19:49:44 +02:00
Kirill Chibisov	7094a223af	Bring `OptionAsAlt` back for macOS The correct handling of this setting requires to change the events we're getting from the macOS on the fly and call `interpretKeyEvents`, which could affect handling of the next events, meaning that we can't provide them on `KeyEvent`.	2023-06-20 19:07:49 +00:00
John Nunley	b2a46d0439	Fill the windows in the examples with a solid color Fixes #776.	2023-06-19 18:46:38 +00:00
bbb651	4748890935	Add MouseButton::{Back, Forward} to `MouseInput` Add named variants for physical back and forward keys which could be found on some mice. The macOS bits may not work on all the hardware given that apple doesn't directly support such a thing. Co-authored-by: daxpedda <daxpedda@gmail.com>	2023-06-16 08:51:09 +00:00
daxpedda	6300cf915e	On Web, implement `DeviceEvent`s (#2871 )	2023-06-14 10:26:26 +02:00
daxpedda	9a9c9b15ba	Implement `ResizeObserver` (#2859 ) Co-authored-by: Liam Murphy <43807659+Liamolucko@users.noreply.github.com>	2023-06-14 09:43:53 +02:00
dAxpeDDa	7ce86c3d2a	Use `Window.requestIdleCallback()`	2023-06-14 00:03:23 +02:00
daxpedda	a444637b18	Revert "Send modifiers first" This reverts commit `e17977d7c7`.	2023-06-14 00:01:37 +02:00
daxpedda	f0d88c52a3	Fix pointer deltas on Firefox and send coalesced events together (#2878 )	2023-06-13 15:49:27 +02:00
dAxpeDDa	e17977d7c7	Send modifiers first	2023-06-13 14:33:08 +02:00
dAxpeDDa	a7a8ff0bbb	Drop `pointerrawupdate` support	2023-06-13 10:23:48 +02:00
dAxpeDDa	fc046add78	Resume propagation of events	2023-06-12 00:48:14 +02:00
dAxpeDDa	ab4a4a89e6	Remove unused `EventListenerOptions`	2023-06-11 19:44:52 +02:00
dAxpeDDa	f7a400ddf6	Improve media queries take 2	2023-06-09 20:38:54 +02:00
Xiaopeng Li	07d39abddd	Fix panic when destroying window (#2773 ) * Fix crash when destroying window * Add a comment to draw_rect --------- Co-authored-by: Xiaopeng Li <lixiaopeng.jetspark@bytedance.com>	2023-06-09 16:20:27 +03:00
Imbris	0c8bf25ae4	Fix compilation on aarch64-linux aarch64 defines `c_char` as `u8` and not `i8`. Use `c_char` alias directly.	2023-06-09 11:46:01 +00:00
dAxpeDDa	b5785ba785	Revert "Fix `Window::set_inner_size()`" This reverts commit `e220a75556`.	2023-06-08 09:09:46 +02:00
dAxpeDDa	9797ed86f0	Fix unable to ignore scale factor resize suggestion	2023-06-07 22:46:14 +02:00
dAxpeDDa	e220a75556	Fix `Window::set_inner_size()`	2023-06-07 14:53:59 +02:00
dAxpeDDa	29d3729ac8	Disallow more methods	2023-06-07 12:53:47 +02:00
Robin Thunström	4a36741f9c	On Android, change default implementation to ignore volume keys and let operating system handle them (#2748 )	2023-06-06 23:04:51 +02:00
dAxpeDDa	ab46aa5b79	Replace `beforeunload` with `pagehide`	2023-06-05 16:40:53 +02:00
dAxpeDDa	12fb37d827	Make media queries more robust	2023-06-05 16:11:22 +02:00
dAxpeDDa	c88a4ab221	Use correct canvas size for scale factor change	2023-06-05 15:39:17 +02:00
daxpedda	8f7f3efc0d	On Web, implement `Send` and `Sync` where appropriate (#2834 )	2023-06-05 02:44:54 +02:00
dAxpeDDa	eb2d3894ef	Document unpreventable events	2023-06-05 02:04:37 +02:00
dAxpeDDa	3f4f580181	Add `pointerrawupdate` support	2023-06-05 02:04:37 +02:00
dAxpeDDa	d3aeff8838	Remove unnecessary `preventDefault()` calls	2023-06-05 02:04:37 +02:00
dAxpeDDa	0786d534f4	Take `IntoIterator` in `send_events()`	2023-06-05 02:04:37 +02:00
dAxpeDDa	b4b2389d0a	Split modifier handling in all pointer events	2023-06-05 02:04:37 +02:00
dAxpeDDa	964e342f69	Prevent text selection	2023-06-05 02:04:37 +02:00
dAxpeDDa	a134a59917	Remove `MouseEvent` fallback support	2023-06-05 02:04:37 +02:00
dAxpeDDa	fbba203c4a	Focus window on touch press	2023-06-05 02:04:37 +02:00
dAxpeDDa	61bd8b8254	Send position on button release	2023-06-05 02:04:37 +02:00
dAxpeDDa	587fa67571	Split cursor move handlers	2023-06-05 02:04:37 +02:00
dAxpeDDa	7500a88230	Fix up changelog	2023-06-04 13:45:43 +02:00
dAxpeDDa	82d0380ea6	Ignore pen input on Web	2023-06-04 00:23:47 +02:00
John Nunley	642ce2bfa7	Port to windows-sys v0.48.0 (#2842 )	2023-06-04 00:02:37 +02:00
dAxpeDDa	5bbe87960e	Replace `instant` with `web-time`	2023-06-03 16:05:44 +02:00
Kirill Chibisov	cf77f82ae3	Update remaining actions to v3 This somehow was left unnoticed.	2023-06-03 17:00:55 +03:00
Kirill Chibisov	72cf4e577f	Add missing `Hash` impls on bitflags Some bitflags in public API lost their `Hash` implementations. Fixes: `31ebc5caf` (Update `bitflags` to `2.0`)	2023-06-03 16:44:52 +03:00
dAxpeDDa	4f3eacf01e	On Web, handle coalesced events	2023-06-02 18:48:34 +02:00
George Burton	31ebc5caf4	Update `bitflags` to `2.0` Co-authored-by: dAxpeDDa <daxpedda@gmail.com>	2023-06-02 17:44:36 +03:00
dAxpeDDa	d273518ce9	Process pointer button events	2023-06-02 12:41:35 +02:00
dAxpeDDa	2ade772ab0	Bump `console_log` to v1	2023-06-01 17:19:30 +02:00
John Nunley	4ac2006cbc	Replace mio with calloop in the X11 backend	2023-05-31 19:44:42 +03:00
dAxpeDDa	ba5ad3be13	On Web, fix no-op for `Window::set_fullscreen`	2023-05-31 15:25:15 +02:00
dAxpeDDa	8092fa2440	Fix changelog	2023-05-31 13:47:34 +02:00
Toniman575	8bb004a1d9	Rename `DeviceEventFilter` to `DeviceEvents` The use of `Filter` was confusing so it was removed inverting the behavior of the enum and methods using it. Co-authored-by: Kirill Chibisov <contact@kchibisov.com>	2023-05-30 22:32:31 +03:00
Simon Hausmann	de5327477a	web: Fix position of touch events to be relative to the canvas Use the same logic as for mouse events when not captured.	2023-05-30 21:21:41 +02:00
Nicola Papale	8f959714cc	Fix `Window::set_theme` doc string Fix #2814.	2023-05-30 12:22:19 +03:00
Kirill Chibisov	035eebb19a	Use linux scancode values for KeyCodeExtScancode Old winit was using linux scancodes, so this should make it backward compatible with itself.	2023-05-29 13:48:12 +03:00
Kirill Chibisov	b5af6bb266	Use xkbcommon-dl 0.3.0	2023-05-29 00:55:54 +03:00
dAxpeDDa	1805124c54	On Web, wake event loop on `request_redraw()`	2023-05-28 23:22:08 +02:00
dAxpeDDa	0f64589dba	Don't change the internal canvas size	2023-05-28 23:10:33 +02:00
Kirill Chibisov	5438a2a524	Add @daxpedda as web maintainer Fixes #1777.	2023-05-28 23:48:28 +03:00
Markus Røyset	918430979f	Overhaul the Keyboard API Overhaul the keyboard API in winit to mimic the W3C specification to achieve better crossplatform parity. The `KeyboardInput` event is now uses `KeyEvent` which consists of: - `physical_key` - a cross platform way to refer to scancodes; - `logical_key` - keysym value, which shows your key respecting the layout; - `text` - the text produced by this keypress; - `location` - the location of the key on the keyboard; - `repeat` - whether the key was produced by the repeat. And also a `platform_specific` field which encapsulates extra information on desktop platforms, like key without modifiers and text with all modifiers. The `Modifiers` were also slightly reworked as in, the information whether the left or right modifier is pressed is now also exposed on platforms where it could be queried reliably. The support was also added for the web and orbital platforms finishing the API change. This change made the `OptionAsAlt` API on macOS redundant thus it was removed all together. Co-authored-by: Artúr Kovács <kovacs.artur.barnabas@gmail.com> Co-authored-by: Kirill Chibisov <contact@kchibisov.com> Co-authored-by: daxpedda <daxpedda@gmail.com> Fixes: #2631. Fixes: #2055. Fixes: #2032. Fixes: #1904. Fixes: #1810. Fixes: #1700. Fixes: #1443. Fixes: #1343. Fixes: #1208. Fixes: #1151. Fixes: #812. Fixes: #600. Fixes: #361. Fixes: #343.	2023-05-28 21:02:59 +03:00
Kirill Chibisov	f3f46cb3f6	On Wayland, fix Window::set_cursor_visible(true) Making the cursor back visible was simply forgotten and it was always hiding instead. Fixes: `2496098890` (Update wayland-rs to 0.30.0) Fixes: #2820.	2023-05-26 09:26:22 +03:00
John Nunley	3c3be71a77	Implement PartialOrd/Ord for dpi module types	2023-05-16 05:11:43 +03:00
Kirill Chibisov	a7986b077f	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2023-05-14 20:36:23 +03:00
Kirill Chibisov	8a0edde5c8	Bump github actions to v3	2023-05-14 20:35:58 +03:00
Kirill Chibisov	a9e168e10d	On macOS, fix backspace emission on preedit clear Fixes: `d15feb5cfa` (On macOS, fix empty marked text)	2023-05-13 03:02:05 +03:00
Kirill Chibisov	bd9cc2a9da	Use `cursor-icon` crate for `CursorIcon` This crate is aimed to simplify handling of cursor icon across various crates and be used in the public API.	2023-05-09 20:19:35 +03:00
Kirill Chibisov	596c0edf0f	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2023-05-09 18:28:20 +03:00
Xiaopeng Li	92592ec605	Fix device description leak (#2758 ) * Fix device description leak * Update CHANGELOG.md --------- Co-authored-by: Xiaopeng Li <lixiaopeng.jetspark@bytedance.com>	2023-05-08 17:58:34 +03:00
Kirill Chibisov	25c4e2e451	On macOS, fix `key_up` being ignored without IME Fixes: `d15feb5cfa` (On macOS, fix empty marked text)	2023-05-06 14:05:28 +03:00
Kirill Chibisov	ad52c72e41	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2023-05-05 13:27:22 +03:00
Kirill Chibisov	d15feb5cfa	On macOS, fix empty marked text blocking input Fixes #2775.	2023-05-04 00:24:02 +03:00
Kirill Chibisov	9938327066	On Wayland, fix nightly warnings The new analysis suggests that we can remove mut.	2023-05-04 00:24:02 +03:00
Kirill Chibisov	f980ed7b83	On X11, fix nightly warnings The new analysis suggests that we can remove mut.	2023-05-04 00:24:02 +03:00
Kirill Chibisov	2496098890	Update wayland-rs to 0.30.0 This update rewrites the winit's Wayland backend using new wayland-rs 0.30 API. This fixes long standing issue with the forward compatibility of the wayland backend, meaning that future updates to the wayland protocol won't break rust code anymore. like it was before when adding new shm/enum variants into the protocol. Fixes #2560. Fixes #2164. Fixes #2128. Fixes #1760. Fixes #725.	2023-04-19 00:56:29 +03:00
Amandus Søve Thorsrud	60e91b187a	Run `Window::set_ime_position` on main thread on macOS Fixes #2756.	2023-04-15 02:58:36 +03:00
Xiaopeng Li	2486f0f1a1	Fix potential panic (#2755 ) * Fix potential panic * Update CHANGELOG.md * Use checked_div --------- Co-authored-by: Xiaopeng Li <lixiaopeng.jetspark@bytedance.com>	2023-04-03 21:46:09 +03:00
Emil Ernerfeldt	fbea75d31f	Add cargo-deny check to CI	2023-03-16 23:05:41 +03:00
Kirill Chibisov	d4c9535af9	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2023-03-16 23:05:17 +03:00
daxpedda	f0fcb346b0	On Web, use `target_family = "wasm"`	2023-03-16 22:49:59 +03:00
Mads Marquart	77f8e511e9	Fix macos memory leaks (#2739 ) * Use a weak reference from WinitView to WinitWindow * Allow patched objc2 version * Add changelog entry	2023-03-14 13:27:41 +03:00
Emil Ernerfeldt	3217eaa416	Fix 1.68 clippy warnings	2023-03-12 20:02:49 +03:00
Kirill Chibisov	b18295a1ce	Bump MSRV to 1.64	2023-03-08 19:34:10 +03:00
esdevver	fb9695d56d	Changed 'an' to 'a' in documentation (#2715 )	2023-03-04 10:37:15 +01:00
Kirill Chibisov	08bdca19b1	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2023-03-02 17:15:48 +03:00
Dylan Scott	79ac236721	On macOS, resize simple fullscreen on window move Fixes #1118.	2023-03-02 01:47:45 +03:00
Nicolas Mazzon	b870a11a99	On Windows, check whether CoCreateInstance succeeds	2023-03-02 01:24:04 +03:00
Kirill Chibisov	2af1550bbb	On macOS, fix initial focused state The synthetic focused event was queued after the real event was send leading to focused issues on startup. Fixes #2695.	2023-02-27 20:46:00 +03:00
John Nunley	ed796dcd15	Update FEATURES.md	2023-02-26 09:53:45 +03:00
Kirill Chibisov	a006cd7dc8	On Wayland, fix rounding issue in resizes	2023-02-21 11:44:22 +03:00
Simon Hausmann	a31f71ee07	Add support for `Window::theme` on the web (#2687 )	2023-02-20 08:51:21 +01:00
Kirill Chibisov	0f89aac9f6	On Wayland, fix rare crash on DPI change While I don't understand the root cause for this issue, we can dirty fix like that for now.	2023-02-19 17:39:39 +03:00
Kirill Chibisov	82df9531f4	On macOS, set resize increments only for live resize Closes #2684 for macOS.	2023-02-15 03:32:55 +03:00
Sludge	265152355e	Implement `HasRawDisplayHandle` for `EventLoop` (#2677 ) * Implement `HasRawDisplayHandle` for `EventLoop` * Add changelog entry	2023-02-10 16:25:22 +01:00
John Nunley	37c0f615cf	On Windows, name the waiter thread (#2672 )	2023-02-08 21:39:01 +01:00
John Nunley	5ba6bdef49	Replace lazy window message ids with a slimmer version (#2598 )	2023-02-04 15:38:21 +01:00
Kirill Chibisov	69d6076310	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2023-02-04 14:47:31 +03:00
Kirill Chibisov	7029ce6ecd	Fix window drop on Wayland In some scenarious of window dropping the callback for keyboard may run after the window was dropped.	2023-02-02 14:42:34 +03:00
Kirill Chibisov	1eb1a13a77	Bump version on master This commit does not represent a release and only synchronizes CHANGELOG from the latest release.	2023-02-02 10:55:59 +03:00