Winit version 0.28.3

* Use a weak reference from WinitView to WinitWindow

* Allow patched objc2 version

* Add changelog entry

.github/CODEOWNERS

@@ -28,8 +28,8 @@
 /src/platform_impl/macos            @madsmtm
 
 # Web (no maintainer)
-/src/platform/web.rs                @daxpedda
-/src/platform_impl/web              @daxpedda
+/src/platform/web.rs
+/src/platform_impl/web
 
 # Windows
 /src/platform/windows.rs            @msiglreith

.github/workflows/ci.yml

@@ -9,50 +9,20 @@ jobs:
   Check_Formatting:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2
     - 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.65.0', stable, nightly]
+        rust_version: ['1.60.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,  }
@@ -83,7 +53,7 @@ jobs:
 
     runs-on: ${{ matrix.platform.os }}
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v2
     # Used to cache cargo-web
     - name: Cache cargo folder
       uses: actions/cache@v1
@@ -116,7 +86,7 @@ jobs:
       shell: bash
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.rust_version != '1.65.0'
+        matrix.rust_version != '1.60.0'
       run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
 
     - name: Run tests
@@ -126,7 +96,7 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.rust_version != '1.65.0'
+        matrix.rust_version != '1.60.0'
       run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
 
     - name: Lint with clippy
@@ -138,7 +108,7 @@ jobs:
       shell: bash
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.rust_version != '1.65.0'
+        matrix.rust_version != '1.60.0'
       run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES
     - name: Run tests with serde enabled
       shell: bash
@@ -147,5 +117,5 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.rust_version != '1.65.0'
+        matrix.rust_version != '1.60.0'
       run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES

CHANGELOG.md

@@ -8,167 +8,6 @@ And please only add new entries to the top of this list, right below the `# Unre
 
 # Unreleased
 
-# 0.29.0-beta.1
-
-- **Breaking:** Bump `ndk` version to `0.8.0-beta.0`, ndk-sys to `v0.5.0-beta.0`, `android-activity` to `0.5.0-beta.1`.
-- **Breaking:** Bump MSRV from `1.64` to `1.65`.
-- Make iOS windows usable from other threads.
-- Reexport `raw-window-handle` in `window` module.
-- **Breaking:** `WINIT_UNIX_BACKEND` was removed in favor of standard `WAYLAND_DISPLAY` and `DISPLAY` variables.
-- **Breaking:** `EventLoop::new` and `EventLoopBuilder::build` now return `Result<Self, EventLoopError>`
-- On X11, set `visual_id` in returned `raw-window-handle`.
-- **Breaking:** on Wayland, dispatching user created wayland queue won't wake up the loop unless winit has event to send back.
-- Removed platform-specific extensions that should be retrieved through `raw-window-handle` trait implementations instead:
-  - `platform::windows::HINSTANCE`.
-  - `WindowExtWindows::hinstance`.
-  - `WindowExtWindows::hwnd`.
-  - `WindowExtIOS::ui_window`.
-  - `WindowExtIOS::ui_view_controller`.
-  - `WindowExtIOS::ui_view`.
-  - `WindowExtMacOS::ns_window`.
-  - `WindowExtMacOS::ns_view`.
-  - `EventLoopWindowTargetExtWayland::wayland_display`.
-  - `WindowExtWayland::wayland_surface`.
-  - `WindowExtWayland::wayland_display`.
-  - `WindowExtX11::xlib_window`.
-  - `WindowExtX11::xlib_display`.
-  - `WindowExtX11::xlib_screen_id`.
-  - `WindowExtX11::xcb_connection`.
-- On Web, use `Window.requestAnimationFrame()` to throttle `RedrawRequested` events.
-- On Wayland, use frame callbacks to throttle `RedrawRequested` events so redraws will align with compositor.
-- Add `Window::pre_present_notify` to notify winit before presenting to the windowing system.
-- On Windows, added `WindowBuilderExtWindows::with_class_name` to customize the internal class name.
-- **Breaking:** Remove lifetime parameter from `Event` and `WindowEvent`.
-- **Breaking:** `ScaleFactorChanged` now contains a writer instead of a reference to update inner size.
-- On iOS, always wake the event loop when transitioning from `ControlFlow::Poll` to `ControlFlow::Poll`.
-- **Breaking:** `ActivationTokenDone` event which could be requested with the new `startup_notify` module, see its docs for more.
-- On Wayland, make double clicking and moving the CSD frame more reliable.
-- On macOS, add tabbing APIs on `WindowExtMacOS` and `EventLoopWindowTargetExtMacOS`.
-- **Breaking:** Rename `Window::set_inner_size` to `Window::request_inner_size` and indicate if the size was applied immediately.
-- On X11, fix false positive flagging of key repeats when pressing different keys with no release between presses.
-- Implement `PartialOrd` and `Ord` for `Key`, `KeyCode`, `NativeKey`, and `NativeKeyCode`.
-- Add `ElementState::is_pressed`.
-- On Web, implement `WindowEvent::Occluded`.
-- On Web, fix touch location to be as accurate as mouse position.
-- On Web, account for CSS `padding`, `border`, and `margin` when getting or setting the canvas position.
-- On Web, add Fullscreen API compatibility for Safari.
-- On Web, implement `Window::set_(min|max)_inner_size()`.
-- On Web, fix some `Window` methods using incorrect HTML attributes instead of CSS properties.
-- On Web, fix some `WindowBuilder` methods doing nothing.
-- On Web, implement `Window::focus_window()`.
-- On Web, remove unnecessary `Window::is_dark_mode()`, which was replaced with `Window::theme()`.
-- On Web, add `WindowBuilderExtWebSys::with_append()` to append the canvas element to the web page on creation.
-- On Windows, add `drag_resize_window` method support.
-- **Breaking** `run() ->!` has been replaced by `run() -> Result<(), EventLoopError>` for returning errors without calling `std::process::exit()` ([#2767](https://github.com/rust-windowing/winit/pull/2767))
-- **Breaking** Removed `EventLoopExtRunReturn` / `run_return` in favor of `EventLoopExtPumpEvents` / `pump_events` and `EventLoopExtRunOnDemand` / `run_ondemand` ([#2767](https://github.com/rust-windowing/winit/pull/2767))
-- `RedrawRequested` is no longer guaranteed to be emitted after `MainEventsCleared`, it is now platform-specific when the event is emitted after being requested via `redraw_request()`.
-  - On Windows, `RedrawRequested` is now driven by `WM_PAINT` messages which are requested via `redraw_request()`
-- **Breaking** `LoopDestroyed` renamed to `LoopExiting` ([#2900](https://github.com/rust-windowing/winit/issues/2900))
-- **Breaking** `RedrawEventsCleared` removed ([#2900](https://github.com/rust-windowing/winit/issues/2900))
-- **Breaking** `MainEventsCleared` removed ([#2900](https://github.com/rust-windowing/winit/issues/2900))
-- Added `AboutToWait` event which is emitted when the event loop is about to block and wait for new events ([#2900](https://github.com/rust-windowing/winit/issues/2900))
-- **Breaking:** `with_x11_visual` now takes the visual ID instead of the bare pointer.
-- On X11, add a `with_embedded_parent_window` function to the window builder to allow embedding a window into another window.
-- On iOS, add force data to touch events when using the Apple Pencil.
-
-# 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.
@@ -459,7 +298,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 Hierarchy" feature in Xcode.
+- On iOS, fixed support for the "Debug View Heirarchy" 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`.

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.65.
+- your patch builds with Winit's minimal supported rust version - Rust 1.60.
 - 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

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.29.0-beta.1"
+version = "0.28.3"
 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.65.0"
+rust-version = "1.60.0"
 
 [package.metadata.docs.rs]
 features = ["serde"]
@@ -36,82 +36,46 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
 default = ["x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
-x11 = ["x11-dl", "bytemuck", "percent-encoding", "xkbcommon-dl/x11", "x11rb"]
-wayland = ["wayland-client", "wayland-backend", "wayland-protocols", "sctk", "fnv", "memmap2"]
-wayland-dlopen = ["wayland-backend/dlopen"]
+x11 = ["x11-dl", "mio", "percent-encoding"]
+wayland = ["wayland-client", "wayland-protocols", "sctk", "wayland-commons"]
+wayland-dlopen = ["sctk/dlopen", "wayland-client/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"]
-serde = ["dep:serde", "cursor-icon/serde", "smol_str/serde"]
+android-native-activity = [ "android-activity/native-activity" ]
+android-game-activity = [ "android-activity/game-activity" ]
 
 [build-dependencies]
 cfg_aliases = "0.1.1"
 
 [dependencies]
-bitflags = "2"
-cursor-icon = "1.0.0"
+bitflags = "1"
+instant = { version = "0.1", features = ["wasm-bindgen"] }
 log = "0.4"
 mint = { version = "0.5.6", optional = true }
 once_cell = "1.12"
-raw_window_handle = { package = "raw-window-handle", version = "0.5", features = ["std"] }
+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 android-activity 0.5 release
-android-activity = "0.5.0-beta.1"
-ndk = "0.8.0-beta.0"
-ndk-sys = "0.5.0-beta.0"
+# 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"
 
 [target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
 core-foundation = "0.9.3"
-objc2 = "0.4.1"
+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"
-
-[target.'cfg(target_os = "macos")'.dependencies.icrate]
-version = "0.0.4"
-features = [
-    "dispatch",
-    "Foundation",
-    "Foundation_NSArray",
-    "Foundation_NSAttributedString",
-    "Foundation_NSMutableAttributedString",
-    "Foundation_NSData",
-    "Foundation_NSDictionary",
-    "Foundation_NSString",
-    "Foundation_NSProcessInfo",
-    "Foundation_NSThread",
-    "Foundation_NSNumber",
-]
-
-[target.'cfg(target_os = "ios")'.dependencies.icrate]
-version = "0.0.4"
-features = [
-    "dispatch",
-    "Foundation",
-    "Foundation_NSArray",
-    "Foundation_NSString",
-    "Foundation_NSProcessInfo",
-    "Foundation_NSThread",
-    "Foundation_NSSet",
-]
-
-[target.'cfg(target_os = "windows")'.dependencies]
-unicode-segmentation = "1.7.1"
+dispatch = "0.2.0"
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
-version = "0.48"
+version = "0.45"
 features = [
     "Win32_Devices_HumanInterfaceDevice",
     "Win32_Foundation",
@@ -139,68 +103,56 @@ features = [
     "Win32_UI_WindowsAndMessaging",
 ]
 
-[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies]
-bytemuck = { version = "1.13.1", default-features = false, optional = true }
+[target.'cfg(all(unix, not(any(target_os = "redox", target_arch = "wasm32", 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 }
-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"
-rustix = { version = "0.38.4", default-features = false, features = ["std", "system", "thread", "process"] }
+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 }
 x11-dl = { version = "2.18.5", optional = true }
-x11rb = { version = "0.12.0", default-features = false, features = ["allow-unsafe-code", "dl-libxcb", "xinput", "xkb"], 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(target_family = "wasm")'.dependencies.web_sys]
+[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]
 package = "web-sys"
-version = "0.3.64"
+version = "0.3.22"
 features = [
     'console',
+    "AddEventListenerOptions",
     'CssStyleDeclaration',
+    'BeforeUnloadEvent',
     'Document',
     'DomRect',
-    'DomRectReadOnly',
     'Element',
     'Event',
+    "EventListenerOptions",
     'EventTarget',
     'FocusEvent',
     'HtmlCanvasElement',
     'HtmlElement',
-    'IntersectionObserver',
-    'IntersectionObserverEntry',
     'KeyboardEvent',
     'MediaQueryList',
+    'MediaQueryListEvent',
+    'MouseEvent',
     'Node',
-    'PageTransitionEvent',
     'PointerEvent',
-    'ResizeObserver',
-    'ResizeObserverBoxOptions',
-    'ResizeObserverEntry',
-    'ResizeObserverOptions',
-    'ResizeObserverSize',
-    'VisibilityState',
     'Window',
     'WheelEvent'
 ]
 
-[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")'.dependencies.wasm-bindgen]
+version = "0.2.45"
 
-[target.'cfg(target_family = "wasm")'.dev-dependencies]
-console_log = "1"
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+console_log = "0.2"
 web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }
 
 [workspace]

FEATURES.md

@@ -13,9 +13,7 @@ be used to create both games and applications. It supports the following main gr
   - iOS
   - Android
 - Web
-  - Chrome
-  - Firefox
-  - Safari 13.1+
+  - via WASM
 
 Most platforms expose capabilities that cannot be meaningfully transposed onto others. Winit does not
 aim to support every single feature of every platform, but rather to abstract over the common features
@@ -119,7 +117,6 @@ If your PR makes notable changes to Winit's features, please update this section
 
 ## Platform
 ### Windows
-* Setting the name of the internal window class
 * Setting the taskbar icon
 * Setting the parent window
 * Setting a menu bar
@@ -146,6 +143,9 @@ If your PR makes notable changes to Winit's features, please update this section
 
 ### iOS
 * `winit` has a minimum OS requirement of iOS 8
+* Get the `UIWindow` object pointer
+* Get the `UIViewController` object pointer
+* Get the `UIView` object pointer
 * Get the `UIScreen` object pointer
 * Setting the `UIView` hidpi factor
 * Valid orientations
@@ -172,7 +172,7 @@ Legend:
 - ❓: Unknown status
 
 ### Windowing
-|Feature                          |Windows|MacOS   |Linux x11   |Linux Wayland  |Android|iOS    |Web      |Redox OS|
+|Feature                          |Windows|MacOS   |Linux x11   |Linux Wayland  |Android|iOS    |WASM      |Redox OS|
 |-------------------------------- | ----- | ----   | -------    | -----------   | ----- | ----- | -------- | ------ |
 |Window initialization            |✔️     |✔️     |▢[#5]      |✔️             |▢[#33]|▢[#33] |✔️        |✔️      |
 |Providing pointer to init OpenGL |✔️     |✔️     |✔️         |✔️             |✔️     |✔️    |**N/A**|✔️      |
@@ -192,13 +192,13 @@ Legend:
 |Popup windows                    |❌     |❌     |❌         |❌             |❌    |❌     |**N/A**|**N/A** |
 
 ### System information
-|Feature          |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS      |Web      |Redox OS|
+|Feature          |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS      |WASM      |Redox OS|
 |---------------- | ----- | ---- | ------- | ----------- | ----- | ------- | -------- | ------ |
 |Monitor list     |✔️    |✔️    |✔️       |✔️          |✔️     |✔️      |**N/A**|❌      |
 |Video mode query |✔️    |✔️    |✔️       |✔️          |✔️     |✔️      |**N/A**|❌      |
 
 ### Input handling
-|Feature                 |Windows   |MacOS   |Linux x11|Linux Wayland|Android|iOS    |Web      |Redox OS|
+|Feature                 |Windows   |MacOS   |Linux x11|Linux Wayland|Android|iOS    |WASM      |Redox OS|
 |----------------------- | -----    | ----   | ------- | ----------- | ----- | ----- | -------- | ------ |
 |Mouse events            |✔️       |▢[#63]  |✔️       |✔️          |**N/A**|**N/A**|✔️        |✔️      |
 |Mouse set location      |✔️       |✔️      |✔️       |✔️(when locked)  |**N/A**|**N/A**|**N/A**|**N/A** |
@@ -215,19 +215,19 @@ Legend:
 |Gamepad/Joystick events |❌[#804] |❌      |❌       |❌          |❌    |❌     |❓        |**N/A** |
 |Device movement events  |❓        |❓       |❓       |❓           |❌    |❌     |❓        |**N/A** |
 |Drag window with cursor |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|**N/A**   |**N/A** |
-|Resize with cursor      |✔️       |❌       |✔️       |✔️       |**N/A**|**N/A**|**N/A**   |**N/A** |
+|Resize with cursor      |❌         |❌       |✔️       |❌       |**N/A**|**N/A**|**N/A**   |**N/A** |
 
 ### Pending API Reworks
 Changes in the API that have been agreed upon but aren't implemented across all platforms.
 
-|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |Web      |Redox OS|
+|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 2.0 ([#753])         |✔️      |✔️     |✔️        |✔️            |✔️      |❌     |✔️         |✔️       |
+|New API for HiDPI ([#315] [#319])   |✔️    |✔️    |✔️       |✔️          |✔️     |✔️    |❓        |❓      |
+|Event Loop 2.0 ([#459])             |✔️    |✔️    |✔️       |✔️          |✔️     |✔️    |❓        |❓      |
+|Keyboard Input ([#812])             |❌    |❌    |❌       |❌          |❌     |❌    |❓        |❓      |
 
 ### Completed API Reworks
-|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |Web      |Redox OS|
+|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |WASM      |Redox OS|
 |------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- | ------ |
 
 [#165]: https://github.com/rust-windowing/winit/issues/165
@@ -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

README.md

@@ -6,7 +6,7 @@
 
 ```toml
 [dependencies]
-winit = "0.29.0-beta.1"
+winit = "0.28.3"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -73,6 +73,10 @@ 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`

build.rs

@@ -1,19 +1,46 @@
 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: { all(target_family = "wasm", not(target_os = "emscripten")) },
+        wasm_platform: { target_arch = "wasm32" },
         macos_platform: { target_os = "macos" },
         ios_platform: { target_os = "ios" },
         windows_platform: { target_os = "windows" },
         apple: { any(target_os = "ios", target_os = "macos") },
-        free_unix: { all(unix, not(apple), not(android_platform), not(target_os = "emscripten")) },
+        free_unix: { all(unix, not(apple), not(android_platform)) },
         redox: { target_os = "redox" },
 
         // Native displays.
@@ -21,4 +48,17 @@ 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();
 }

clippy.toml

@@ -1,12 +0,0 @@
-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" },
-    { path = "web_sys::Window::document", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::Window::get_computed_style", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::Element::request_fullscreen", reason = "Doesn't account for compatibility with Safari" },
-    { path = "web_sys::Document::exit_fullscreen", reason = "Doesn't account for compatibility with Safari" },
-    { path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },
-]

deny.toml

@@ -1,70 +0,0 @@
-# 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)
-]

docs/res/ATTRIBUTION.md

@@ -1,11 +0,0 @@
-# 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.

examples/child_window.rs

@@ -1,16 +1,12 @@
 #[cfg(any(x11_platform, macos_platform, windows_platform))]
-#[path = "util/fill.rs"]
-mod fill;
-
-#[cfg(any(x11_platform, macos_platform, windows_platform))]
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     use std::collections::HashMap;
 
+    use raw_window_handle::HasRawWindowHandle;
     use winit::{
         dpi::{LogicalPosition, LogicalSize, Position},
-        event::{ElementState, Event, KeyEvent, WindowEvent},
+        event::{ElementState, Event, KeyboardInput, WindowEvent},
         event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
-        window::raw_window_handle::HasRawWindowHandle,
         window::{Window, WindowBuilder, WindowId},
     };
 
@@ -36,7 +32,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let mut windows = HashMap::new();
 
-    let event_loop: EventLoop<()> = EventLoop::new().unwrap();
+    let event_loop: EventLoop<()> = EventLoop::new();
     let parent_window = WindowBuilder::new()
         .with_title("parent window")
         .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
@@ -46,7 +42,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     println!("parent window: {parent_window:?})");
 
-    event_loop.run(move |event: Event<()>, event_loop, control_flow| {
+    event_loop.run(move |event: Event<'_, ()>, event_loop, control_flow| {
         *control_flow = ControlFlow::Wait;
 
         if let Event::WindowEvent { event, window_id } = event {
@@ -63,8 +59,8 @@ fn main() -> Result<(), impl std::error::Error> {
                     println!("cursor entered in the window {window_id:?}");
                 }
                 WindowEvent::KeyboardInput {
-                    event:
-                        KeyEvent {
+                    input:
+                        KeyboardInput {
                             state: ElementState::Pressed,
                             ..
                         },
@@ -74,10 +70,6 @@ fn main() -> Result<(), impl std::error::Error> {
                 }
                 _ => (),
             }
-        } else if let Event::RedrawRequested(wid) = event {
-            if let Some(window) = windows.get(&wid) {
-                fill::fill_window(window);
-            }
         }
     })
 }

examples/control_flow.rs

@@ -1,22 +1,14 @@
 #![allow(clippy::single_match)]
 
-use std::thread;
-#[cfg(not(wasm_platform))]
-use std::time;
-#[cfg(wasm_platform)]
-use web_time as time;
+use std::{thread, time};
 
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event::{Event, KeyboardInput, WindowEvent},
     event_loop::EventLoop,
-    keyboard::Key,
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum Mode {
     Wait,
@@ -27,7 +19,7 @@ enum Mode {
 const WAIT_TIME: time::Duration = time::Duration::from_millis(100);
 const POLL_SLEEP_TIME: time::Duration = time::Duration::from_millis(100);
 
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
 
     println!("Press '1' to switch to Wait mode.");
@@ -36,7 +28,7 @@ fn main() -> Result<(), impl std::error::Error> {
     println!("Press 'R' to toggle request_redraw() calls.");
     println!("Press 'Esc' to close the window.");
 
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
     let window = WindowBuilder::new()
         .with_title("Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.")
         .build(&event_loop)
@@ -48,7 +40,7 @@ fn main() -> Result<(), impl std::error::Error> {
     let mut close_requested = false;
 
     event_loop.run(move |event, _, control_flow| {
-        use winit::event::StartCause;
+        use winit::event::{ElementState, StartCause, VirtualKeyCode};
         println!("{event:?}");
         match event {
             Event::NewEvents(start_cause) => {
@@ -62,49 +54,52 @@ fn main() -> Result<(), impl std::error::Error> {
                     close_requested = true;
                 }
                 WindowEvent::KeyboardInput {
-                    event:
-                        KeyEvent {
-                            logical_key: key,
+                    input:
+                        KeyboardInput {
+                            virtual_keycode: Some(virtual_code),
                             state: ElementState::Pressed,
                             ..
                         },
                     ..
-                } => match key.as_ref() {
-                    // WARNING: Consider using `key_without_modifers()` if available on your platform.
-                    // See the `key_binding` example
-                    Key::Character("1") => {
+                } => match virtual_code {
+                    VirtualKeyCode::Key1 => {
                         mode = Mode::Wait;
                         println!("\nmode: {mode:?}\n");
                     }
-                    Key::Character("2") => {
+                    VirtualKeyCode::Key2 => {
                         mode = Mode::WaitUntil;
                         println!("\nmode: {mode:?}\n");
                     }
-                    Key::Character("3") => {
+                    VirtualKeyCode::Key3 => {
                         mode = Mode::Poll;
                         println!("\nmode: {mode:?}\n");
                     }
-                    Key::Character("r") => {
+                    VirtualKeyCode::R => {
                         request_redraw = !request_redraw;
                         println!("\nrequest_redraw: {request_redraw}\n");
                     }
-                    Key::Escape => {
+                    VirtualKeyCode::Escape => {
                         close_requested = true;
                     }
                     _ => (),
                 },
                 _ => (),
             },
-            Event::AboutToWait => {
+            Event::MainEventsCleared => {
                 if request_redraw && !wait_cancelled && !close_requested {
                     window.request_redraw();
                 }
-
+                if close_requested {
+                    control_flow.set_exit();
+                }
+            }
+            Event::RedrawRequested(_window_id) => {}
+            Event::RedrawEventsCleared => {
                 match mode {
                     Mode::Wait => control_flow.set_wait(),
                     Mode::WaitUntil => {
                         if !wait_cancelled {
-                            control_flow.set_wait_until(time::Instant::now() + WAIT_TIME);
+                            control_flow.set_wait_until(instant::Instant::now() + WAIT_TIME);
                         }
                     }
                     Mode::Poll => {
@@ -112,15 +107,8 @@ fn main() -> Result<(), impl std::error::Error> {
                         control_flow.set_poll();
                     }
                 };
-
-                if close_requested {
-                    control_flow.set_exit();
-                }
-            }
-            Event::RedrawRequested(_window_id) => {
-                fill::fill_window(&window);
             }
             _ => (),
         }
-    })
+    });
 }

examples/cursor.rs

@@ -2,17 +2,14 @@
 
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event::{ElementState, Event, KeyboardInput, WindowEvent},
     event_loop::EventLoop,
     window::{CursorIcon, WindowBuilder},
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new().build(&event_loop).unwrap();
     window.set_title("A fantastic window!");
@@ -26,8 +23,8 @@ fn main() -> Result<(), impl std::error::Error> {
             Event::WindowEvent {
                 event:
                     WindowEvent::KeyboardInput {
-                        event:
-                            KeyEvent {
+                        input:
+                            KeyboardInput {
                                 state: ElementState::Pressed,
                                 ..
                             },
@@ -49,18 +46,16 @@ fn main() -> Result<(), impl std::error::Error> {
             } => {
                 control_flow.set_exit();
             }
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }
 
 const CURSORS: &[CursorIcon] = &[
     CursorIcon::Default,
     CursorIcon::Crosshair,
-    CursorIcon::Pointer,
+    CursorIcon::Hand,
+    CursorIcon::Arrow,
     CursorIcon::Move,
     CursorIcon::Text,
     CursorIcon::Wait,

examples/cursor_grab.rs

@@ -2,18 +2,14 @@
 
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{DeviceEvent, ElementState, Event, KeyEvent, WindowEvent},
+    event::{DeviceEvent, ElementState, Event, KeyboardInput, ModifiersState, WindowEvent},
     event_loop::EventLoop,
-    keyboard::{Key, ModifiersState},
     window::{CursorGrabMode, WindowBuilder},
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("Super Cursor Grab'n'Hide Simulator 9000")
@@ -29,29 +25,27 @@ fn main() -> Result<(), impl std::error::Error> {
             Event::WindowEvent { event, .. } => match event {
                 WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
-                    event:
-                        KeyEvent {
-                            logical_key: key,
+                    input:
+                        KeyboardInput {
                             state: ElementState::Released,
+                            virtual_keycode: Some(key),
                             ..
                         },
                     ..
                 } => {
+                    use winit::event::VirtualKeyCode::*;
                     let result = match key {
-                        Key::Escape => {
+                        Escape => {
                             control_flow.set_exit();
                             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(()),
-                        },
+                        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(())
+                        }
                         _ => Ok(()),
                     };
 
@@ -59,7 +53,7 @@ fn main() -> Result<(), impl std::error::Error> {
                         println!("error: {err}");
                     }
                 }
-                WindowEvent::ModifiersChanged(new) => modifiers = new.state(),
+                WindowEvent::ModifiersChanged(m) => modifiers = m,
                 _ => (),
             },
             Event::DeviceEvent { event, .. } => match event {
@@ -70,8 +64,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 },
                 _ => (),
             },
-            Event::RedrawRequested(_) => fill::fill_window(&window),
             _ => (),
         }
-    })
+    });
 }

examples/custom_events.rs

@@ -1,7 +1,7 @@
 #![allow(clippy::single_match)]
 
 #[cfg(not(wasm_platform))]
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
@@ -9,20 +9,15 @@ fn main() -> Result<(), impl std::error::Error> {
         window::WindowBuilder,
     };
 
-    #[path = "util/fill.rs"]
-    mod fill;
-
     #[derive(Debug, Clone, Copy)]
     enum CustomEvent {
         Timer,
     }
 
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoopBuilder::<CustomEvent>::with_user_event()
-        .build()
-        .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();
@@ -49,12 +44,9 @@ fn main() -> Result<(), impl std::error::Error> {
                 event: WindowEvent::CloseRequested,
                 ..
             } => control_flow.set_exit(),
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }
 
 #[cfg(wasm_platform)]

examples/drag_window.rs

@@ -2,18 +2,16 @@
 
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyEvent, MouseButton, StartCause, WindowEvent},
+    event::{
+        ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
+    },
     event_loop::EventLoop,
-    keyboard::Key,
     window::{Window, WindowBuilder, WindowId},
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window_1 = WindowBuilder::new().build(&event_loop).unwrap();
     let window_2 = WindowBuilder::new().build(&event_loop).unwrap();
@@ -47,29 +45,22 @@ fn main() -> Result<(), impl std::error::Error> {
                 name_windows(entered_id, switched, &window_1, &window_2)
             }
             WindowEvent::KeyboardInput {
-                event:
-                    KeyEvent {
+                input:
+                    KeyboardInput {
                         state: ElementState::Released,
-                        logical_key: Key::Character(c),
+                        virtual_keycode: Some(VirtualKeyCode::X),
                         ..
                     },
                 ..
-            } 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);
-            }
-        }
         _ => (),
-    })
+    });
 }
 
 fn name_windows(window_id: WindowId, switched: bool, window_1: &Window, window_2: &Window) {

examples/fullscreen.rs

@@ -1,26 +1,19 @@
 #![allow(clippy::single_match)]
 
 use simple_logger::SimpleLogger;
-use winit::dpi::PhysicalSize;
-use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
+use winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, 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() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let mut decorations = true;
     let mut minimized = false;
-    let mut with_min_size = false;
-    let mut with_max_size = false;
 
     let window = WindowBuilder::new()
         .with_title("Hello world!")
@@ -49,8 +42,6 @@ fn main() -> Result<(), impl std::error::Error> {
     println!("- D\tToggle window decorations");
     println!("- X\tMaximize window");
     println!("- Z\tMinimize window");
-    println!("- I\tToggle mIn size limit");
-    println!("- A\tToggle mAx size limit");
 
     event_loop.run(move |event, elwt, control_flow| {
         control_flow.set_wait();
@@ -59,108 +50,73 @@ fn main() -> Result<(), impl std::error::Error> {
             Event::WindowEvent { event, .. } => match event {
                 WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
-                    event:
-                        KeyEvent {
-                            logical_key: key,
+                    input:
+                        KeyboardInput {
+                            virtual_keycode: Some(virtual_code),
                             state: ElementState::Pressed,
                             ..
                         },
                     ..
-                } => 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);
+                } => 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);
+                    }
+                    #[cfg(target_os = "macos")]
+                    VirtualKeyCode::C => {
+                        window.set_simple_fullscreen(!window.simple_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!");
                         }
-                        "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());
+                        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}");
                         }
-                        "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);
-                        }
-                        "i" => {
-                            with_min_size = !with_min_size;
-                            let min_size = if with_min_size {
-                                Some(PhysicalSize::new(100, 100))
-                            } else {
-                                None
-                            };
-                            window.set_min_inner_size(min_size);
-                            eprintln!(
-                                "Min: {with_min_size}: {min_size:?} => {:?}",
-                                window.inner_size()
-                            );
-                        }
-                        "a" => {
-                            with_max_size = !with_max_size;
-                            let max_size = if with_max_size {
-                                Some(PhysicalSize::new(200, 200))
-                            } else {
-                                None
-                            };
-                            window.set_max_inner_size(max_size);
-                            eprintln!(
-                                "Max: {with_max_size}: {max_size:?} => {:?}",
-                                window.inner_size()
-                            );
-                        }
-                        _ => (),
-                    },
+                        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);
+                    }
                     _ => (),
                 },
                 _ => (),
             },
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => {}
         }
-    })
+    });
 }

examples/handling_close.rs

@@ -2,20 +2,16 @@
 
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event::{Event, KeyboardInput, WindowEvent},
     event_loop::EventLoop,
-    keyboard::Key,
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
+    let _window = WindowBuilder::new()
         .with_title("Your faithful window")
         .build(&event_loop)
         .unwrap();
@@ -23,6 +19,10 @@ fn main() -> Result<(), impl std::error::Error> {
     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,18 +46,16 @@ fn main() -> Result<(), impl std::error::Error> {
                         // the Y key.
                     }
                     WindowEvent::KeyboardInput {
-                        event:
-                            KeyEvent {
-                                logical_key: key,
-                                state: ElementState::Released,
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(virtual_code),
+                                state: Released,
                                 ..
                             },
                         ..
                     } => {
-                        // WARNING: Consider using `key_without_modifers()` if available on your platform.
-                        // See the `key_binding` example
-                        match key.as_ref() {
-                            Key::Character("y") => {
+                        match virtual_code {
+                            Y => {
                                 if close_requested {
                                     // This is where you'll want to do any cleanup you need.
                                     println!("Buh-bye!");
@@ -70,7 +68,7 @@ fn main() -> Result<(), impl std::error::Error> {
                                     control_flow.set_exit();
                                 }
                             }
-                            Key::Character("n") => {
+                            N => {
                                 if close_requested {
                                     println!("Your window will continue to stay by your side.");
                                     close_requested = false;
@@ -82,10 +80,7 @@ fn main() -> Result<(), impl std::error::Error> {
                     _ => (),
                 }
             }
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }

examples/ime.rs

@@ -3,17 +3,13 @@
 use log::LevelFilter;
 use simple_logger::SimpleLogger;
 use winit::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    event::{ElementState, Event, Ime, WindowEvent},
+    dpi::PhysicalPosition,
+    event::{ElementState, Event, Ime, VirtualKeyCode, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
-    keyboard::{Key, KeyCode},
     window::{ImePurpose, WindowBuilder},
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new()
         .with_level(LevelFilter::Trace)
         .init()
@@ -24,7 +20,7 @@ fn main() -> Result<(), impl std::error::Error> {
     println!("Press F2 to toggle IME. See the documentation of `set_ime_allowed` for more info");
     println!("Press F3 to cycle through IME purposes.");
 
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_inner_size(winit::dpi::LogicalSize::new(256f64, 128f64))
@@ -66,7 +62,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 );
                 ime_pos = cursor_position;
                 if may_show_ime {
-                    window.set_ime_cursor_area(ime_pos, PhysicalSize::new(10, 10));
+                    window.set_ime_position(ime_pos);
                 }
             }
             Event::WindowEvent {
@@ -76,21 +72,31 @@ fn main() -> Result<(), impl std::error::Error> {
                 println!("{event:?}");
                 may_show_ime = event != Ime::Disabled;
                 if may_show_ime {
-                    window.set_ime_cursor_area(ime_pos, PhysicalSize::new(10, 10));
+                    window.set_ime_position(ime_pos);
                 }
             }
             Event::WindowEvent {
-                event: WindowEvent::KeyboardInput { event, .. },
+                event: WindowEvent::ReceivedCharacter(ch),
                 ..
             } => {
-                println!("key: {event:?}");
+                println!("ch: {ch:?}");
+            }
+            Event::WindowEvent {
+                event: WindowEvent::KeyboardInput { input, .. },
+                ..
+            } => {
+                println!("key: {input:?}");
 
-                if event.state == ElementState::Pressed && event.physical_key == KeyCode::F2 {
+                if input.state == ElementState::Pressed
+                    && input.virtual_keycode == Some(VirtualKeyCode::F2)
+                {
                     ime_allowed = !ime_allowed;
                     window.set_ime_allowed(ime_allowed);
                     println!("\nIME allowed: {ime_allowed}\n");
                 }
-                if event.state == ElementState::Pressed && event.logical_key == Key::F3 {
+                if input.state == ElementState::Pressed
+                    && input.virtual_keycode == Some(VirtualKeyCode::F3)
+                {
                     ime_purpose = match ime_purpose {
                         ImePurpose::Normal => ImePurpose::Password,
                         ImePurpose::Password => ImePurpose::Terminal,
@@ -100,10 +106,7 @@ fn main() -> Result<(), impl std::error::Error> {
                     println!("\nIME purpose: {ime_purpose:?}\n");
                 }
             }
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }

examples/key_binding.rs

@@ -1,65 +0,0 @@
-#![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() -> Result<(), impl std::error::Error> {
-    #[path = "util/fill.rs"]
-    mod fill;
-
-    simple_logger::SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
-
-    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);
-            }
-            _ => (),
-        };
-    })
-}

examples/monitor_list.rs

@@ -7,7 +7,7 @@ use winit::{event_loop::EventLoop, window::WindowBuilder};
 
 fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
     let window = WindowBuilder::new().build(&event_loop).unwrap();
 
     if let Some(mon) = window.primary_monitor() {

examples/mouse_wheel.rs

@@ -7,12 +7,9 @@ use winit::{
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("Mouse Wheel events")
@@ -59,10 +56,7 @@ In other words, the deltas indicate the direction in which to move the content (
                 },
                 _ => (),
             },
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }

examples/multithreaded.rs

@@ -1,15 +1,14 @@
 #![allow(clippy::single_match)]
 
 #[cfg(not(wasm_platform))]
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     use std::{collections::HashMap, sync::mpsc, thread, time::Duration};
 
     use simple_logger::SimpleLogger;
     use winit::{
         dpi::{PhysicalPosition, PhysicalSize, Position, Size},
-        event::{ElementState, Event, KeyEvent, WindowEvent},
+        event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
         event_loop::EventLoop,
-        keyboard::{Key, ModifiersState},
         window::{CursorGrabMode, CursorIcon, Fullscreen, WindowBuilder, WindowLevel},
     };
 
@@ -17,7 +16,7 @@ fn main() -> Result<(), impl std::error::Error> {
     const WINDOW_SIZE: PhysicalSize<u32> = PhysicalSize::new(600, 400);
 
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
     let mut window_senders = HashMap::with_capacity(WINDOW_COUNT);
     for _ in 0..WINDOW_COUNT {
         let window = WindowBuilder::new()
@@ -30,7 +29,6 @@ fn main() -> Result<(), impl std::error::Error> {
 
         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 {
@@ -53,118 +51,107 @@ fn main() -> Result<(), impl std::error::Error> {
                             );
                         }
                     }
-                    WindowEvent::ModifiersChanged(new) => {
-                        modifiers = new.state();
-                    }
+                    #[allow(deprecated)]
                     WindowEvent::KeyboardInput {
-                        event:
-                            KeyEvent {
+                        input:
+                            KeyboardInput {
                                 state: ElementState::Released,
-                                logical_key: key,
+                                virtual_keycode: Some(key),
+                                modifiers,
                                 ..
                             },
                         ..
                     } => {
-                        use Key::{ArrowLeft, ArrowRight};
                         window.set_title(&format!("{key:?}"));
-                        let state = !modifiers.shift_key();
+                        let state = !modifiers.shift();
+                        use VirtualKeyCode::*;
                         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
-                            Key::ArrowRight | Key::ArrowLeft => {
+                            Right | Left => {
                                 video_mode_id = match key {
-                                    ArrowLeft => video_mode_id.saturating_sub(1),
-                                    ArrowRight => (video_modes.len() - 1).min(video_mode_id + 1),
+                                    Left => video_mode_id.saturating_sub(1),
+                                    Right => (video_modes.len() - 1).min(video_mode_id + 1),
                                     _ => unreachable!(),
                                 };
                                 println!("Picking video mode: {}", video_modes[video_mode_id]);
                             }
-                            // WARNING: Consider using `key_without_modifers()` if available on your platform.
-                            // 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}");
-                                    }
+                            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()))
                                 }
-                                "g" if state => {
-                                    if let Err(err) =
-                                        window.set_cursor_grab(CursorGrabMode::Confined)
-                                    {
-                                        println!("error: {err}");
-                                    }
+                                (false, _) => None,
+                            }),
+                            L if state => {
+                                if let Err(err) = window.set_cursor_grab(CursorGrabMode::Locked) {
+                                    println!("error: {err}");
                                 }
-                                "g" | "l" if !state => {
-                                    if let Err(err) = window.set_cursor_grab(CursorGrabMode::None) {
-                                        println!("error: {err}");
-                                    }
+                            }
+                            G if state => {
+                                if let Err(err) = window.set_cursor_grab(CursorGrabMode::Confined) {
+                                    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());
+                            }
+                            G | L if !state => {
+                                if let Err(err) = window.set_cursor_grab(CursorGrabMode::None) {
+                                    println!("error: {err}");
                                 }
-                                "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" => {
-                                    let _ = window.request_inner_size(match state {
-                                        true => PhysicalSize::new(
-                                            WINDOW_SIZE.width + 100,
-                                            WINDOW_SIZE.height + 100,
-                                        ),
-                                        false => WINDOW_SIZE,
-                                    });
+                            }
+                            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()
                                 }
-                                "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);
+                            }
                             _ => (),
                         }
                     }
@@ -183,10 +170,10 @@ fn main() -> Result<(), impl std::error::Error> {
                 WindowEvent::CloseRequested
                 | WindowEvent::Destroyed
                 | WindowEvent::KeyboardInput {
-                    event:
-                        KeyEvent {
+                    input:
+                        KeyboardInput {
                             state: ElementState::Released,
-                            logical_key: Key::Escape,
+                            virtual_keycode: Some(VirtualKeyCode::Escape),
                             ..
                         },
                     ..
@@ -195,7 +182,9 @@ fn main() -> Result<(), impl std::error::Error> {
                 }
                 _ => {
                     if let Some(tx) = window_senders.get(&window_id) {
-                        tx.send(event).unwrap();
+                        if let Some(event) = event.to_static() {
+                            tx.send(event).unwrap();
+                        }
                     }
                 }
             },

examples/multiwindow.rs

@@ -4,18 +4,14 @@ use std::collections::HashMap;
 
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
     event_loop::EventLoop,
-    keyboard::Key,
     window::Window,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let mut windows = HashMap::new();
     for _ in 0..3 {
@@ -43,15 +39,15 @@ fn main() -> Result<(), impl std::error::Error> {
                         }
                     }
                     WindowEvent::KeyboardInput {
-                        event:
-                            KeyEvent {
+                        input:
+                            KeyboardInput {
                                 state: ElementState::Pressed,
-                                logical_key: Key::Character(c),
+                                virtual_keycode: Some(VirtualKeyCode::N),
                                 ..
                             },
                         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);
@@ -59,11 +55,6 @@ fn main() -> Result<(), impl std::error::Error> {
                     _ => (),
                 }
             }
-            Event::RedrawRequested(window_id) => {
-                if let Some(window) = windows.get(&window_id) {
-                    fill::fill_window(window);
-                }
-            }
             _ => (),
         }
     })

examples/request_redraw.rs

@@ -7,12 +7,9 @@ use winit::{
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
@@ -37,9 +34,8 @@ fn main() -> Result<(), impl std::error::Error> {
             },
             Event::RedrawRequested(_) => {
                 println!("\nredrawing!\n");
-                fill::fill_window(&window);
             }
             _ => (),
         }
-    })
+    });
 }

examples/request_redraw_threaded.rs

@@ -1,8 +1,8 @@
 #![allow(clippy::single_match)]
 
 #[cfg(not(wasm_platform))]
-fn main() -> Result<(), impl std::error::Error> {
-    use std::{sync::Arc, thread, time};
+fn main() {
+    use std::{thread, time};
 
     use simple_logger::SimpleLogger;
     use winit::{
@@ -11,26 +11,17 @@ fn main() -> Result<(), impl std::error::Error> {
         window::WindowBuilder,
     };
 
-    #[path = "util/fill.rs"]
-    mod fill;
-
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
-    let window = {
-        let window = WindowBuilder::new()
-            .with_title("A fantastic window!")
-            .build(&event_loop)
-            .unwrap();
-        Arc::new(window)
-    };
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .build(&event_loop)
+        .unwrap();
 
-    thread::spawn({
-        let window = window.clone();
-        move || loop {
-            thread::sleep(time::Duration::from_secs(1));
-            window.request_redraw();
-        }
+    thread::spawn(move || loop {
+        thread::sleep(time::Duration::from_secs(1));
+        window.request_redraw();
     });
 
     event_loop.run(move |event, _, control_flow| {
@@ -45,11 +36,10 @@ fn main() -> Result<(), impl std::error::Error> {
             } => control_flow.set_exit(),
             Event::RedrawRequested(_) => {
                 println!("\nredrawing!\n");
-                fill::fill_window(&window);
             }
             _ => (),
         }
-    })
+    });
 }
 
 #[cfg(wasm_platform)]

examples/resizable.rs

@@ -3,18 +3,14 @@
 use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,
-    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
     event_loop::EventLoop,
-    keyboard::KeyCode,
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let mut resizable = false;
 
@@ -34,9 +30,9 @@ fn main() -> Result<(), impl std::error::Error> {
             Event::WindowEvent { event, .. } => match event {
                 WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
-                    event:
-                        KeyEvent {
-                            physical_key: KeyCode::Space,
+                    input:
+                        KeyboardInput {
+                            virtual_keycode: Some(VirtualKeyCode::Space),
                             state: ElementState::Released,
                             ..
                         },
@@ -48,10 +44,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 }
                 _ => (),
             },
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         };
-    })
+    });
 }

examples/startup_notification.rs

@@ -1,126 +0,0 @@
-//! Demonstrates the use of startup notifications on Linux.
-
-#[cfg(any(x11_platform, wayland_platform))]
-#[path = "./util/fill.rs"]
-mod fill;
-
-#[cfg(any(x11_platform, wayland_platform))]
-mod example {
-    use std::collections::HashMap;
-    use std::rc::Rc;
-
-    use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
-    use winit::event_loop::EventLoop;
-    use winit::keyboard::Key;
-    use winit::platform::startup_notify::{
-        EventLoopExtStartupNotify, WindowBuilderExtStartupNotify, WindowExtStartupNotify,
-    };
-    use winit::window::{Window, WindowBuilder, WindowId};
-
-    pub(super) fn main() -> Result<(), impl std::error::Error> {
-        // Create the event loop and get the activation token.
-        let event_loop = EventLoop::new().unwrap();
-        let mut current_token = match event_loop.read_token_from_env() {
-            Some(token) => Some(token),
-            None => {
-                println!("No startup notification token found in environment.");
-                None
-            }
-        };
-
-        let mut windows: HashMap<WindowId, Rc<Window>> = HashMap::new();
-        let mut counter = 0;
-        let mut create_first_window = false;
-
-        event_loop.run(move |event, elwt, flow| {
-            match event {
-                Event::Resumed => create_first_window = true,
-
-                Event::WindowEvent {
-                    window_id,
-                    event:
-                        WindowEvent::KeyboardInput {
-                            event:
-                                KeyEvent {
-                                    logical_key,
-                                    state: ElementState::Pressed,
-                                    ..
-                                },
-                            ..
-                        },
-                } => {
-                    if logical_key == Key::Character("n".into()) {
-                        if let Some(window) = windows.get(&window_id) {
-                            // Request a new activation token on this window.
-                            // Once we get it we will use it to create a window.
-                            window
-                                .request_activation_token()
-                                .expect("Failed to request activation token.");
-                        }
-                    }
-                }
-
-                Event::WindowEvent {
-                    window_id,
-                    event: WindowEvent::CloseRequested,
-                } => {
-                    // Remove the window from the map.
-                    windows.remove(&window_id);
-                    if windows.is_empty() {
-                        flow.set_exit();
-                        return;
-                    }
-                }
-
-                Event::WindowEvent {
-                    event: WindowEvent::ActivationTokenDone { token, .. },
-                    ..
-                } => {
-                    current_token = Some(token);
-                }
-
-                Event::RedrawRequested(id) => {
-                    if let Some(window) = windows.get(&id) {
-                        super::fill::fill_window(window);
-                    }
-                }
-
-                _ => {}
-            }
-
-            // See if we've passed the deadline.
-            if current_token.is_some() || create_first_window {
-                // Create the initial window.
-                let window = {
-                    let mut builder =
-                        WindowBuilder::new().with_title(format!("Window {}", counter));
-
-                    if let Some(token) = current_token.take() {
-                        println!("Creating a window with token {token:?}");
-                        builder = builder.with_activation_token(token);
-                    }
-
-                    Rc::new(builder.build(elwt).unwrap())
-                };
-
-                // Add the window to the map.
-                windows.insert(window.id(), window.clone());
-
-                counter += 1;
-                create_first_window = false;
-            }
-
-            flow.set_wait();
-        })
-    }
-}
-
-#[cfg(any(x11_platform, wayland_platform))]
-fn main() -> Result<(), impl std::error::Error> {
-    example::main()
-}
-
-#[cfg(not(any(x11_platform, wayland_platform)))]
-fn main() {
-    println!("This example is only supported on X11 and Wayland platforms.");
-}

examples/theme.rs

@@ -2,18 +2,14 @@
 
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
-    keyboard::Key,
     window::{Theme, WindowBuilder},
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
@@ -45,35 +41,31 @@ fn main() -> Result<(), impl std::error::Error> {
             Event::WindowEvent {
                 event:
                     WindowEvent::KeyboardInput {
-                        event:
-                            KeyEvent {
-                                logical_key: key,
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(key),
                                 state: ElementState::Pressed,
                                 ..
                             },
                         ..
                     },
                 ..
-            } => match key.as_ref() {
-                Key::Character("A" | "a") => {
+            } => match key {
+                VirtualKeyCode::A => {
                     println!("Theme was: {:?}", window.theme());
                     window.set_theme(None);
                 }
-                Key::Character("L" | "l") => {
+                VirtualKeyCode::L => {
                     println!("Theme was: {:?}", window.theme());
                     window.set_theme(Some(Theme::Light));
                 }
-                Key::Character("D" | "d") => {
+                VirtualKeyCode::D => {
                     println!("Theme was: {:?}", window.theme());
                     window.set_theme(Some(Theme::Dark));
                 }
                 _ => (),
             },
-            Event::RedrawRequested(_) => {
-                println!("\nredrawing!\n");
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }

examples/timer.rs

@@ -1,10 +1,7 @@
 #![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::{
@@ -13,14 +10,11 @@ use winit::{
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
+    let _window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .build(&event_loop)
         .unwrap();
@@ -42,10 +36,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 event: WindowEvent::CloseRequested,
                 ..
             } => control_flow.set_exit(),
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }

examples/touchpad_gestures.rs

@@ -5,14 +5,11 @@ use winit::{
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
+    let _window = WindowBuilder::new()
         .with_title("Touchpad gestures")
         .build(&event_loop)
         .unwrap();
@@ -44,8 +41,6 @@ fn main() -> Result<(), impl std::error::Error> {
                 }
                 _ => (),
             }
-        } else if let Event::RedrawRequested(_) = event {
-            fill::fill_window(&window);
         }
-    })
+    });
 }

examples/transparent.rs

@@ -7,12 +7,9 @@ use winit::{
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_decorations(false)
@@ -31,10 +28,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 event: WindowEvent::CloseRequested,
                 ..
             } => control_flow.set_exit(),
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }

examples/util/fill.rs

@@ -1,86 +0,0 @@
-//! 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.
-}

examples/video_modes.rs

@@ -5,7 +5,7 @@ use winit::event_loop::EventLoop;
 
 fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
     let monitor = match event_loop.primary_monitor() {
         Some(monitor) => monitor,
         None => {

examples/web.rs

@@ -1,22 +1,18 @@
-#![allow(clippy::disallowed_methods, clippy::single_match)]
+#![allow(clippy::single_match)]
 
 use winit::{
-    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event::{Event, WindowEvent},
     event_loop::EventLoop,
-    keyboard::KeyCode,
-    window::{Fullscreen, WindowBuilder},
+    window::WindowBuilder,
 };
 
-pub fn main() -> Result<(), impl std::error::Error> {
-    let event_loop = EventLoop::new().unwrap();
+pub fn main() {
+    let event_loop = EventLoop::new();
 
-    let builder = WindowBuilder::new().with_title("A fantastic window!");
-    #[cfg(wasm_platform)]
-    let builder = {
-        use winit::platform::web::WindowBuilderExtWebSys;
-        builder.with_append(true)
-    };
-    let window = builder.build(&event_loop).unwrap();
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .build(&event_loop)
+        .unwrap();
 
     #[cfg(wasm_platform)]
     let log_list = wasm::insert_canvas_and_create_log_list(&window);
@@ -32,38 +28,16 @@ pub fn main() -> Result<(), impl std::error::Error> {
                 event: WindowEvent::CloseRequested,
                 window_id,
             } if window_id == window.id() => control_flow.set_exit(),
-            Event::AboutToWait => {
+            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)));
-                }
-            }
             _ => (),
         }
-    })
+    });
 }
 
 #[cfg(wasm_platform)]
 mod wasm {
-    use std::num::NonZeroU32;
-
-    use softbuffer::{Surface, SurfaceExtWeb};
     use wasm_bindgen::prelude::*;
     use winit::{event::Event, window::Window};
 
@@ -72,33 +46,21 @@ mod wasm {
         console_log::init_with_level(log::Level::Debug).expect("error initializing logger");
 
         #[allow(clippy::main_recursion)]
-        let _ = super::main();
+        super::main();
     }
 
     pub fn insert_canvas_and_create_log_list(window: &Window) -> web_sys::Element {
         use winit::platform::web::WindowExtWebSys;
 
-        let canvas = window.canvas().unwrap();
-        let mut surface = Surface::from_canvas(canvas.clone()).unwrap();
-        surface
-            .resize(
-                NonZeroU32::new(canvas.width()).unwrap(),
-                NonZeroU32::new(canvas.height()).unwrap(),
-            )
-            .unwrap();
-        let mut buffer = surface.buffer_mut().unwrap();
-        buffer.fill(0xFFF0000);
-        buffer.present().unwrap();
+        let canvas = window.canvas();
 
         let window = web_sys::window().unwrap();
         let document = window.document().unwrap();
         let body = document.body().unwrap();
 
-        let style = &canvas.style();
-        style.set_property("margin", "50px").unwrap();
-        // Use to test interactions with border and padding.
-        //style.set_property("border", "50px solid black").unwrap();
-        //style.set_property("padding", "50px").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;");
+        body.append_child(&canvas).unwrap();
 
         let log_header = document.create_element("h2").unwrap();
         log_header.set_text_content(Some("Event Log"));
@@ -115,25 +77,11 @@ mod wasm {
         // Getting access to browser logs requires a lot of setup on mobile devices.
         // So we implement this basic logging system into the page to give developers an easy alternative.
         // As a bonus its also kind of handy on desktop.
-        let event = match event {
-            Event::WindowEvent { event, .. } => Some(format!("{event:?}")),
-            Event::Resumed | Event::Suspended => Some(format!("{event:?}")),
-            _ => None,
-        };
-        if let Some(event) = event {
+        if let Event::WindowEvent { event, .. } = &event {
             let window = web_sys::window().unwrap();
             let document = window.document().unwrap();
             let log = document.create_element("li").unwrap();
-
-            let date = js_sys::Date::new_0();
-            log.set_text_content(Some(&format!(
-                "{:02}:{:02}:{:02}.{:03}: {event}",
-                date.get_hours(),
-                date.get_minutes(),
-                date.get_seconds(),
-                date.get_milliseconds(),
-            )));
-
+            log.set_text_content(Some(&format!("{event:?}")));
             log_list
                 .insert_before(&log, log_list.first_child().as_ref())
                 .unwrap();

examples/web_aspect_ratio.rs

@@ -1,5 +1,3 @@
-#![allow(clippy::disallowed_methods)]
-
 pub fn main() {
     println!("This example must be run with cargo run-wasm --example web_aspect_ratio")
 }
@@ -13,7 +11,6 @@ mod wasm {
         dpi::PhysicalSize,
         event::{Event, WindowEvent},
         event_loop::{ControlFlow, EventLoop},
-        platform::web::WindowBuilderExtWebSys,
         window::{Window, WindowBuilder},
     };
 
@@ -31,14 +28,13 @@ This example demonstrates the desired future functionality which will possibly b
     #[wasm_bindgen(start)]
     pub fn run() {
         console_log::init_with_level(log::Level::Debug).expect("error initializing logger");
-        let event_loop = EventLoop::new().unwrap();
+        let event_loop = EventLoop::new();
 
         let window = WindowBuilder::new()
             .with_title("A fantastic window!")
             // When running in a non-wasm environment this would set the window size to 100x100.
             // However in this example it just sets a default initial size of 100x100 that is immediately overwritten due to the layout + styling of the page.
             .with_inner_size(PhysicalSize::new(100, 100))
-            .with_append(true)
             .build(&event_loop)
             .unwrap();
 
@@ -47,7 +43,7 @@ This example demonstrates the desired future functionality which will possibly b
         // Render once with the size info we currently have
         render_circle(&canvas, window.inner_size());
 
-        let _ = event_loop.run(move |event, _, control_flow| {
+        event_loop.run(move |event, _, control_flow| {
             *control_flow = ControlFlow::Wait;
 
             match event {
@@ -70,10 +66,11 @@ 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().unwrap();
+        let canvas = window.canvas();
         canvas
             .style()
             .set_css_text("display: block; background-color: crimson; margin: auto; width: 50%; aspect-ratio: 4 / 1;");
+        body.append_child(&canvas).unwrap();
 
         let explanation = document.create_element("pre").unwrap();
         explanation.set_text_content(Some(EXPLANATION));

examples/window.rs

@@ -7,12 +7,9 @@ use winit::{
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
@@ -29,15 +26,10 @@ fn main() -> Result<(), impl std::error::Error> {
                 event: WindowEvent::CloseRequested,
                 window_id,
             } if window_id == window.id() => control_flow.set_exit(),
-            Event::AboutToWait => {
+            Event::MainEventsCleared => {
                 window.request_redraw();
             }
-            Event::RedrawRequested(_) => {
-                // Notify the windowing system that we'll be presenting to the window.
-                window.pre_present_notify();
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }

examples/window_buttons.rs

@@ -5,18 +5,14 @@
 use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,
-    event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::{DeviceEvents, EventLoop},
-    keyboard::Key,
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::{DeviceEventFilter, EventLoop},
     window::{WindowBuilder, WindowButtons},
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
@@ -29,7 +25,7 @@ fn main() -> Result<(), impl std::error::Error> {
     eprintln!("  (G) Toggle maximize button");
     eprintln!("  (H) Toggle minimize button");
 
-    event_loop.listen_device_events(DeviceEvents::Always);
+    event_loop.set_device_event_filter(DeviceEventFilter::Never);
 
     event_loop.run(move |event, _, control_flow| {
         control_flow.set_wait();
@@ -38,25 +34,25 @@ fn main() -> Result<(), impl std::error::Error> {
             Event::WindowEvent {
                 event:
                     WindowEvent::KeyboardInput {
-                        event:
-                            KeyEvent {
-                                logical_key: key,
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(key),
                                 state: ElementState::Pressed,
                                 ..
                             },
                         ..
                     },
                 ..
-            } => match key.as_ref() {
-                Key::Character("F" | "f") => {
+            } => match key {
+                VirtualKeyCode::F => {
                     let buttons = window.enabled_buttons();
                     window.set_enabled_buttons(buttons ^ WindowButtons::CLOSE);
                 }
-                Key::Character("G" | "g") => {
+                VirtualKeyCode::G => {
                     let buttons = window.enabled_buttons();
                     window.set_enabled_buttons(buttons ^ WindowButtons::MAXIMIZE);
                 }
-                Key::Character("H" | "h") => {
+                VirtualKeyCode::H => {
                     let buttons = window.enabled_buttons();
                     window.set_enabled_buttons(buttons ^ WindowButtons::MINIMIZE);
                 }
@@ -66,10 +62,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 event: WindowEvent::CloseRequested,
                 window_id,
             } if window_id == window.id() => control_flow.set_exit(),
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }

examples/window_debug.rs

@@ -5,18 +5,14 @@
 use simple_logger::SimpleLogger;
 use winit::{
     dpi::{LogicalSize, PhysicalSize},
-    event::{DeviceEvent, ElementState, Event, KeyEvent, RawKeyEvent, WindowEvent},
-    event_loop::{DeviceEvents, EventLoop},
-    keyboard::{Key, KeyCode},
+    event::{DeviceEvent, ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::{DeviceEventFilter, EventLoop},
     window::{Fullscreen, WindowBuilder},
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
@@ -36,31 +32,29 @@ fn main() -> Result<(), impl std::error::Error> {
     let mut minimized = false;
     let mut visible = true;
 
-    event_loop.listen_device_events(DeviceEvents::Always);
+    event_loop.set_device_event_filter(DeviceEventFilter::Never);
 
     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(RawKeyEvent {
-                        physical_key,
-                        state: ElementState::Released,
+                    DeviceEvent::Key(KeyboardInput {
+                        virtual_keycode: Some(key),
+                        state: ElementState::Pressed,
                         ..
                     }),
                 ..
-            } => match physical_key {
-                KeyCode::KeyM => {
+            } => match key {
+                VirtualKeyCode::M => {
                     if minimized {
                         minimized = !minimized;
                         window.set_minimized(minimized);
                         window.focus_window();
                     }
                 }
-                KeyCode::KeyV => {
+                VirtualKeyCode::V => {
                     if !visible {
                         visible = !visible;
                         window.set_visible(visible);
@@ -71,19 +65,17 @@ fn main() -> Result<(), impl std::error::Error> {
             Event::WindowEvent {
                 event:
                     WindowEvent::KeyboardInput {
-                        event:
-                            KeyEvent {
-                                logical_key: Key::Character(key_str),
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(key),
                                 state: ElementState::Pressed,
                                 ..
                             },
                         ..
                     },
                 ..
-            } => match key_str.as_ref() {
-                // WARNING: Consider using `key_without_modifers()` if available on your platform.
-                // See the `key_binding` example
-                "e" => {
+            } => match key {
+                VirtualKeyCode::E => {
                     fn area(size: PhysicalSize<u32>) -> u32 {
                         size.width * size.height
                     }
@@ -98,7 +90,7 @@ fn main() -> Result<(), impl std::error::Error> {
                         eprintln!("no video modes available");
                     }
                 }
-                "f" => {
+                VirtualKeyCode::F => {
                     if window.fullscreen().is_some() {
                         window.set_fullscreen(None);
                     } else {
@@ -106,25 +98,25 @@ fn main() -> Result<(), impl std::error::Error> {
                         window.set_fullscreen(Some(Fullscreen::Borderless(monitor)));
                     }
                 }
-                "p" => {
+                VirtualKeyCode::P => {
                     if window.fullscreen().is_some() {
                         window.set_fullscreen(None);
                     } else {
                         window.set_fullscreen(Some(Fullscreen::Borderless(None)));
                     }
                 }
-                "m" => {
+                VirtualKeyCode::M => {
                     minimized = !minimized;
                     window.set_minimized(minimized);
                 }
-                "q" => {
+                VirtualKeyCode::Q => {
                     control_flow.set_exit();
                 }
-                "v" => {
+                VirtualKeyCode::V => {
                     visible = !visible;
                     window.set_visible(visible);
                 }
-                "x" => {
+                VirtualKeyCode::X => {
                     let is_maximized = window.is_maximized();
                     window.set_maximized(!is_maximized);
                 }
@@ -134,10 +126,7 @@ fn main() -> Result<(), impl std::error::Error> {
                 event: WindowEvent::CloseRequested,
                 window_id,
             } if window_id == window.id() => control_flow.set_exit(),
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }

examples/window_drag_resize.rs

@@ -2,20 +2,18 @@
 
 use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyEvent, MouseButton, StartCause, WindowEvent},
+    event::{
+        ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
+    },
     event_loop::{ControlFlow, EventLoop},
-    keyboard::Key,
     window::{CursorIcon, ResizeDirection, WindowBuilder},
 };
 
 const BORDER: f64 = 8.0;
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_inner_size(winit::dpi::LogicalSize::new(600.0, 400.0))
@@ -52,29 +50,24 @@ fn main() -> Result<(), impl std::error::Error> {
             } => {
                 if let Some(dir) = cursor_location {
                     let _res = window.drag_resize_window(dir);
-                } else if !window.is_decorated() {
-                    let _res = window.drag_window();
                 }
             }
             WindowEvent::KeyboardInput {
-                event:
-                    KeyEvent {
+                input:
+                    KeyboardInput {
                         state: ElementState::Released,
-                        logical_key: Key::Character(c),
+                        virtual_keycode: Some(VirtualKeyCode::B),
                         ..
                     },
                 ..
-            } if matches!(c.as_ref(), "B" | "b") => {
+            } => {
                 border = !border;
                 window.set_decorations(border);
             }
             _ => (),
         },
-        Event::RedrawRequested(_) => {
-            fill::fill_window(&window);
-        }
         _ => (),
-    })
+    });
 }
 
 fn cursor_direction_icon(resize_direction: Option<ResizeDirection>) -> CursorIcon {

examples/window_icon.rs

@@ -9,10 +9,7 @@ use winit::{
     window::{Icon, WindowBuilder},
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
 
     // You'll have to choose an icon size at your own discretion. On X11, the desired size varies
@@ -23,7 +20,7 @@ fn main() -> Result<(), impl std::error::Error> {
 
     let icon = load_icon(Path::new(path));
 
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("An iconic window!")
@@ -45,10 +42,8 @@ fn main() -> Result<(), impl std::error::Error> {
                 }
                 _ => (),
             }
-        } else if let Event::RedrawRequested(_) = event {
-            fill::fill_window(&window);
         }
-    })
+    });
 }
 
 fn load_icon(path: &Path) -> Icon {

examples/window_ondemand.rs

@@ -1,90 +0,0 @@
-#![allow(clippy::single_match)]
-
-// Limit this example to only compatible platforms.
-#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform,))]
-fn main() -> Result<(), impl std::error::Error> {
-    use std::time::Duration;
-
-    use simple_logger::SimpleLogger;
-
-    use winit::{
-        error::EventLoopError,
-        event::{Event, WindowEvent},
-        event_loop::EventLoop,
-        platform::run_ondemand::EventLoopExtRunOnDemand,
-        window::{Window, WindowBuilder, WindowId},
-    };
-
-    #[path = "util/fill.rs"]
-    mod fill;
-
-    #[derive(Default)]
-    struct App {
-        window_id: Option<WindowId>,
-        window: Option<Window>,
-    }
-
-    SimpleLogger::new().init().unwrap();
-    let mut event_loop = EventLoop::new().unwrap();
-
-    fn run_app(event_loop: &mut EventLoop<()>, idx: usize) -> Result<(), EventLoopError> {
-        let mut app = App::default();
-
-        event_loop.run_ondemand(move |event, event_loop, control_flow| {
-            control_flow.set_wait();
-            println!("Run {idx}: {:?}", event);
-
-            if let Some(window) = &app.window {
-                match event {
-                    Event::WindowEvent {
-                        event: WindowEvent::CloseRequested,
-                        window_id,
-                    } if window.id() == window_id => {
-                        println!("--------------------------------------------------------- Window {idx} CloseRequested");
-                        app.window = None;
-                    }
-                    Event::AboutToWait => window.request_redraw(),
-                    Event::RedrawRequested(_) => {
-                        fill::fill_window(window);
-                    }
-                    _ => (),
-                }
-            } else if let Some(id) = app.window_id {
-                match event {
-                    Event::WindowEvent {
-                        event: WindowEvent::Destroyed,
-                        window_id,
-                    } if id == window_id => {
-                        println!("--------------------------------------------------------- Window {idx} Destroyed");
-                        app.window_id = None;
-                        control_flow.set_exit();
-                    }
-                    _ => (),
-                }
-            } else if let Event::Resumed = event {
-                let window = WindowBuilder::new()
-                        .with_title("Fantastic window number one!")
-                        .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
-                        .build(event_loop)
-                        .unwrap();
-                app.window_id = Some(window.id());
-                app.window = Some(window);
-            }
-        })
-    }
-
-    run_app(&mut event_loop, 1)?;
-
-    println!("--------------------------------------------------------- Finished first loop");
-    println!("--------------------------------------------------------- Waiting 5 seconds");
-    std::thread::sleep(Duration::from_secs(5));
-
-    let ret = run_app(&mut event_loop, 2);
-    println!("--------------------------------------------------------- Finished second loop");
-    ret
-}
-
-#[cfg(not(any(windows_platform, macos_platform, x11_platform, wayland_platform,)))]
-fn main() {
-    println!("This example is not supported on this platform");
-}

examples/window_option_as_alt.rs

@@ -11,15 +11,11 @@ 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")]
-fn main() -> Result<(), impl std::error::Error> {
-    let event_loop = EventLoop::new().unwrap();
+fn main() {
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
@@ -27,8 +23,6 @@ fn main() -> Result<(), impl std::error::Error> {
         .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| {
@@ -55,18 +49,16 @@ fn main() -> Result<(), impl std::error::Error> {
                     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::AboutToWait => {
+            Event::MainEventsCleared => {
                 window.request_redraw();
             }
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
             _ => (),
         }
-    })
+    });
 }
 
 #[cfg(not(target_os = "macos"))]

examples/window_pump_events.rs

@@ -1,73 +0,0 @@
-#![allow(clippy::single_match)]
-
-// Limit this example to only compatible platforms.
-#[cfg(any(
-    windows_platform,
-    macos_platform,
-    x11_platform,
-    wayland_platform,
-    android_platform,
-))]
-fn main() -> std::process::ExitCode {
-    use std::{process::ExitCode, thread::sleep, time::Duration};
-
-    use simple_logger::SimpleLogger;
-    use winit::{
-        event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
-        platform::pump_events::{EventLoopExtPumpEvents, PumpStatus},
-        window::WindowBuilder,
-    };
-
-    #[path = "util/fill.rs"]
-    mod fill;
-
-    let mut event_loop = EventLoop::new().unwrap();
-
-    SimpleLogger::new().init().unwrap();
-    let window = WindowBuilder::new()
-        .with_title("A fantastic window!")
-        .build(&event_loop)
-        .unwrap();
-
-    'main: loop {
-        let timeout = Some(Duration::ZERO);
-        let status = event_loop.pump_events(timeout, |event, _, control_flow| {
-            *control_flow = ControlFlow::Wait;
-
-            if let Event::WindowEvent { event, .. } = &event {
-                // Print only Window events to reduce noise
-                println!("{event:?}");
-            }
-
-            match event {
-                Event::WindowEvent {
-                    event: WindowEvent::CloseRequested,
-                    window_id,
-                } if window_id == window.id() => control_flow.set_exit(),
-                Event::AboutToWait => {
-                    window.request_redraw();
-                }
-                Event::RedrawRequested(_) => {
-                    fill::fill_window(&window);
-                }
-                _ => (),
-            }
-        });
-        if let PumpStatus::Exit(exit_code) = status {
-            break 'main ExitCode::from(exit_code as u8);
-        }
-
-        // Sleep for 1/60 second to simulate application work
-        //
-        // Since `pump_events` doesn't block it will be important to
-        // throttle the loop in the app somehow.
-        println!("Update()");
-        sleep(Duration::from_millis(16));
-    }
-}
-
-#[cfg(any(ios_platform, wasm_platform, orbital_platform))]
-fn main() {
-    println!("This platform doesn't support pump_events.");
-}

examples/window_resize_increments.rs

@@ -2,18 +2,14 @@ use log::debug;
 use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,
-    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
     event_loop::EventLoop,
-    keyboard::Key,
     window::WindowBuilder,
 };
 
-#[path = "util/fill.rs"]
-mod fill;
-
-fn main() -> Result<(), impl std::error::Error> {
+fn main() {
     SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
@@ -35,9 +31,9 @@ fn main() -> Result<(), impl std::error::Error> {
             Event::WindowEvent {
                 event:
                     WindowEvent::KeyboardInput {
-                        event:
-                            KeyEvent {
-                                logical_key: Key::Space,
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(VirtualKeyCode::Space),
                                 state: ElementState::Released,
                                 ..
                             },
@@ -54,11 +50,8 @@ fn main() -> Result<(), impl std::error::Error> {
                 debug!("Had increments: {}", new_increments.is_none());
                 window.set_resize_increments(new_increments);
             }
-            Event::AboutToWait => window.request_redraw(),
-            Event::RedrawRequested(_) => {
-                fill::fill_window(&window);
-            }
+            Event::MainEventsCleared => window.request_redraw(),
             _ => (),
         }
-    })
+    });
 }

examples/window_run_return.rs

@@ -0,0 +1,64 @@
+#![allow(clippy::single_match)]
+
+// Limit this example to only compatible platforms.
+#[cfg(any(
+    windows_platform,
+    macos_platform,
+    x11_platform,
+    wayland_platform,
+    android_platform,
+    orbital_platform,
+))]
+fn main() {
+    use std::{thread::sleep, time::Duration};
+
+    use simple_logger::SimpleLogger;
+    use winit::{
+        event::{Event, WindowEvent},
+        event_loop::EventLoop,
+        platform::run_return::EventLoopExtRunReturn,
+        window::WindowBuilder,
+    };
+    let mut event_loop = EventLoop::new();
+
+    SimpleLogger::new().init().unwrap();
+    let _window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .build(&event_loop)
+        .unwrap();
+
+    let mut quit = false;
+
+    while !quit {
+        event_loop.run_return(|event, _, control_flow| {
+            control_flow.set_wait();
+
+            if let Event::WindowEvent { event, .. } = &event {
+                // Print only Window events to reduce noise
+                println!("{event:?}");
+            }
+
+            match event {
+                Event::WindowEvent {
+                    event: WindowEvent::CloseRequested,
+                    ..
+                } => {
+                    quit = true;
+                }
+                Event::MainEventsCleared => {
+                    control_flow.set_exit();
+                }
+                _ => (),
+            }
+        });
+
+        // Sleep for 1/60 second to simulate rendering
+        println!("rendering");
+        sleep(Duration::from_millis(16));
+    }
+}
+
+#[cfg(any(ios_platform, wasm_platform))]
+fn main() {
+    println!("This platform doesn't support run_return.");
+}

examples/window_tabbing.rs

@@ -1,112 +0,0 @@
-#![allow(clippy::single_match)]
-
-#[cfg(target_os = "macos")]
-use std::{collections::HashMap, num::NonZeroUsize};
-
-#[cfg(target_os = "macos")]
-use simple_logger::SimpleLogger;
-#[cfg(target_os = "macos")]
-use winit::{
-    event::{ElementState, Event, KeyEvent, WindowEvent},
-    event_loop::EventLoop,
-    keyboard::Key,
-    platform::macos::{WindowBuilderExtMacOS, WindowExtMacOS},
-    window::{Window, WindowBuilder},
-};
-
-#[cfg(target_os = "macos")]
-#[path = "util/fill.rs"]
-mod fill;
-
-#[cfg(target_os = "macos")]
-fn main() -> Result<(), impl std::error::Error> {
-    SimpleLogger::new().init().unwrap();
-    let event_loop = EventLoop::new().unwrap();
-
-    let mut windows = HashMap::new();
-    let window = Window::new(&event_loop).unwrap();
-    println!("Opened a new window: {:?}", window.id());
-    windows.insert(window.id(), window);
-
-    println!("Press N to open a new window.");
-
-    event_loop.run(move |event, event_loop, control_flow| {
-        control_flow.set_wait();
-
-        match event {
-            Event::WindowEvent { event, window_id } => {
-                match event {
-                    WindowEvent::CloseRequested => {
-                        println!("Window {window_id:?} has received the signal to close");
-
-                        // This drops the window, causing it to close.
-                        windows.remove(&window_id);
-
-                        if windows.is_empty() {
-                            control_flow.set_exit();
-                        }
-                    }
-                    WindowEvent::Resized(_) => {
-                        if let Some(window) = windows.get(&window_id) {
-                            window.request_redraw();
-                        }
-                    }
-                    WindowEvent::KeyboardInput {
-                        event:
-                            KeyEvent {
-                                state: ElementState::Pressed,
-                                logical_key,
-                                ..
-                            },
-                        is_synthetic: false,
-                        ..
-                    } => match logical_key.as_ref() {
-                        Key::Character("t") => {
-                            let tabbing_id = windows.get(&window_id).unwrap().tabbing_identifier();
-                            let window = WindowBuilder::new()
-                                .with_tabbing_identifier(&tabbing_id)
-                                .build(event_loop)
-                                .unwrap();
-                            println!("Added a new tab: {:?}", window.id());
-                            windows.insert(window.id(), window);
-                        }
-                        Key::Character("w") => {
-                            let _ = windows.remove(&window_id);
-                        }
-                        Key::ArrowRight => {
-                            windows.get(&window_id).unwrap().select_next_tab();
-                        }
-                        Key::ArrowLeft => {
-                            windows.get(&window_id).unwrap().select_previous_tab();
-                        }
-                        Key::Character(ch) => {
-                            if let Ok(index) = ch.parse::<NonZeroUsize>() {
-                                let index = index.get();
-                                // Select the last tab when pressing `9`.
-                                let window = windows.get(&window_id).unwrap();
-                                if index == 9 {
-                                    window.select_tab_at_index(window.num_tabs() - 1)
-                                } else {
-                                    window.select_tab_at_index(index - 1);
-                                }
-                            }
-                        }
-                        _ => (),
-                    },
-                    _ => (),
-                }
-            }
-            Event::RedrawRequested(window_id) => {
-                if let Some(window) = windows.get(&window_id) {
-                    fill::fill_window(window);
-                }
-            }
-            _ => (),
-        }
-    })
-}
-
-#[cfg(not(target_os = "macos"))]
-fn main() {
-    println!("This example is only supported on MacOS");
-}

examples/x11_embed.rs

@@ -1,69 +0,0 @@
-//! A demonstration of embedding a winit window in an existing X11 application.
-
-#[cfg(x11_platform)]
-#[path = "util/fill.rs"]
-mod fill;
-
-#[cfg(x11_platform)]
-mod imple {
-    use super::fill;
-    use simple_logger::SimpleLogger;
-    use winit::{
-        event::{Event, WindowEvent},
-        event_loop::EventLoop,
-        platform::x11::WindowBuilderExtX11,
-        window::WindowBuilder,
-    };
-
-    pub(super) fn entry() -> Result<(), Box<dyn std::error::Error>> {
-        // First argument should be a 32-bit X11 window ID.
-        let parent_window_id = std::env::args()
-            .nth(1)
-            .ok_or("Expected a 32-bit X11 window ID as the first argument.")?
-            .parse::<u32>()?;
-
-        SimpleLogger::new().init().unwrap();
-        let event_loop = EventLoop::new()?;
-
-        let window = WindowBuilder::new()
-            .with_title("An embedded window!")
-            .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
-            .with_embed_parent_window(parent_window_id)
-            .build(&event_loop)
-            .unwrap();
-
-        event_loop.run(move |event, _, control_flow| {
-            control_flow.set_wait();
-
-            match event {
-                Event::WindowEvent {
-                    event: WindowEvent::CloseRequested,
-                    window_id,
-                } if window_id == window.id() => control_flow.set_exit(),
-                Event::AboutToWait => {
-                    window.request_redraw();
-                }
-                Event::RedrawRequested(_) => {
-                    // Notify the windowing system that we'll be presenting to the window.
-                    window.pre_present_notify();
-                    fill::fill_window(&window);
-                }
-                _ => (),
-            }
-        })?;
-
-        Ok(())
-    }
-}
-
-#[cfg(not(x11_platform))]
-mod imple {
-    pub(super) fn entry() -> Result<(), Box<dyn std::error::Error>> {
-        println!("This example is only supported on X11 platforms.");
-        Ok(())
-    }
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    imple::entry()
-}

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, Ord, PartialOrd, Default, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, 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, Ord, PartialOrd, Default, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, 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, Ord, PartialOrd, Default, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, 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, Ord, PartialOrd, Default, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PhysicalSize<P> {
     pub width: P,
@@ -581,421 +581,3 @@ impl<P: Pixel> From<LogicalPosition<P>> for Position {
         Position::Logical(position.cast())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::dpi;
-    use std::collections::HashSet;
-
-    macro_rules! test_pixel_int_impl {
-        ($($name:ident => $ty:ty),*) => {$(
-            #[test]
-            fn $name() {
-                use dpi::Pixel;
-
-                assert_eq!(
-                    <$ty as Pixel>::from_f64(37.0),
-                    37,
-                );
-                assert_eq!(
-                    <$ty as Pixel>::from_f64(37.4),
-                    37,
-                );
-                assert_eq!(
-                    <$ty as Pixel>::from_f64(37.5),
-                    38,
-                );
-                assert_eq!(
-                    <$ty as Pixel>::from_f64(37.9),
-                    38,
-                );
-
-                assert_eq!(
-                    <$ty as Pixel>::cast::<u8>(37),
-                    37,
-                );
-                assert_eq!(
-                    <$ty as Pixel>::cast::<u16>(37),
-                    37,
-                );
-                assert_eq!(
-                    <$ty as Pixel>::cast::<u32>(37),
-                    37,
-                );
-                assert_eq!(
-                    <$ty as Pixel>::cast::<i8>(37),
-                    37,
-                );
-                assert_eq!(
-                    <$ty as Pixel>::cast::<i16>(37),
-                    37,
-                );
-                assert_eq!(
-                    <$ty as Pixel>::cast::<i32>(37),
-                    37,
-                );
-            }
-        )*};
-    }
-
-    test_pixel_int_impl! {
-        test_pixel_int_u8 => u8,
-        test_pixel_int_u16 => u16,
-        test_pixel_int_u32 => u32,
-        test_pixel_int_i8 => i8,
-        test_pixel_int_i16 => i16
-    }
-
-    macro_rules! assert_approx_eq {
-        ($a:expr, $b:expr $(,)?) => {
-            assert!(
-                ($a - $b).abs() < 0.001,
-                "{} is not approximately equal to {}",
-                $a,
-                $b
-            );
-        };
-    }
-
-    macro_rules! test_pixel_float_impl {
-    ($($name:ident => $ty:ty),*) => {$(
-        #[test]
-        fn $name() {
-            use dpi::Pixel;
-
-            assert_approx_eq!(
-                <$ty as Pixel>::from_f64(37.0),
-                37.0,
-            );
-            assert_approx_eq!(
-                <$ty as Pixel>::from_f64(37.4),
-                37.4,
-            );
-            assert_approx_eq!(
-                <$ty as Pixel>::from_f64(37.5),
-                37.5,
-            );
-            assert_approx_eq!(
-                <$ty as Pixel>::from_f64(37.9),
-                37.9,
-            );
-
-            assert_eq!(
-                <$ty as Pixel>::cast::<u8>(37.0),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<u8>(37.4),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<u8>(37.5),
-                38,
-            );
-
-            assert_eq!(
-                <$ty as Pixel>::cast::<u16>(37.0),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<u16>(37.4),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<u16>(37.5),
-                38,
-            );
-
-            assert_eq!(
-                <$ty as Pixel>::cast::<u32>(37.0),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<u32>(37.4),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<u32>(37.5),
-                38,
-            );
-
-            assert_eq!(
-                <$ty as Pixel>::cast::<i8>(37.0),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<i8>(37.4),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<i8>(37.5),
-                38,
-            );
-
-            assert_eq!(
-                <$ty as Pixel>::cast::<i16>(37.0),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<i16>(37.4),
-                37,
-            );
-            assert_eq!(
-                <$ty as Pixel>::cast::<i16>(37.5),
-                38,
-            );
-        }
-    )*};
-}
-
-    test_pixel_float_impl! {
-        test_pixel_float_f32 => f32,
-        test_pixel_float_f64 => f64
-    }
-
-    #[test]
-    fn test_validate_scale_factor() {
-        assert!(dpi::validate_scale_factor(1.0));
-        assert!(dpi::validate_scale_factor(2.0));
-        assert!(dpi::validate_scale_factor(3.0));
-        assert!(dpi::validate_scale_factor(1.5));
-        assert!(dpi::validate_scale_factor(0.5));
-
-        assert!(!dpi::validate_scale_factor(0.0));
-        assert!(!dpi::validate_scale_factor(-1.0));
-        assert!(!dpi::validate_scale_factor(f64::INFINITY));
-        assert!(!dpi::validate_scale_factor(f64::NAN));
-        assert!(!dpi::validate_scale_factor(f64::NEG_INFINITY));
-    }
-
-    #[test]
-    fn test_logical_position() {
-        let log_pos = dpi::LogicalPosition::new(1.0, 2.0);
-        assert_eq!(
-            log_pos.to_physical::<u32>(1.0),
-            dpi::PhysicalPosition::new(1, 2)
-        );
-        assert_eq!(
-            log_pos.to_physical::<u32>(2.0),
-            dpi::PhysicalPosition::new(2, 4)
-        );
-        assert_eq!(log_pos.cast::<u32>(), dpi::LogicalPosition::new(1, 2));
-        assert_eq!(
-            log_pos,
-            dpi::LogicalPosition::from_physical(dpi::PhysicalPosition::new(1.0, 2.0), 1.0)
-        );
-        assert_eq!(
-            log_pos,
-            dpi::LogicalPosition::from_physical(dpi::PhysicalPosition::new(2.0, 4.0), 2.0)
-        );
-        assert_eq!(
-            dpi::LogicalPosition::from((2.0, 2.0)),
-            dpi::LogicalPosition::new(2.0, 2.0)
-        );
-        assert_eq!(
-            dpi::LogicalPosition::from([2.0, 3.0]),
-            dpi::LogicalPosition::new(2.0, 3.0)
-        );
-
-        let x: (f64, f64) = log_pos.into();
-        assert_eq!(x, (1.0, 2.0));
-        let x: [f64; 2] = log_pos.into();
-        assert_eq!(x, [1.0, 2.0]);
-    }
-
-    #[test]
-    fn test_physical_position() {
-        assert_eq!(
-            dpi::PhysicalPosition::from_logical(dpi::LogicalPosition::new(1.0, 2.0), 1.0),
-            dpi::PhysicalPosition::new(1, 2)
-        );
-        assert_eq!(
-            dpi::PhysicalPosition::from_logical(dpi::LogicalPosition::new(2.0, 4.0), 0.5),
-            dpi::PhysicalPosition::new(1, 2)
-        );
-        assert_eq!(
-            dpi::PhysicalPosition::from((2.0, 2.0)),
-            dpi::PhysicalPosition::new(2.0, 2.0)
-        );
-        assert_eq!(
-            dpi::PhysicalPosition::from([2.0, 3.0]),
-            dpi::PhysicalPosition::new(2.0, 3.0)
-        );
-
-        let x: (f64, f64) = dpi::PhysicalPosition::new(1, 2).into();
-        assert_eq!(x, (1.0, 2.0));
-        let x: [f64; 2] = dpi::PhysicalPosition::new(1, 2).into();
-        assert_eq!(x, [1.0, 2.0]);
-    }
-
-    #[test]
-    fn test_logical_size() {
-        let log_size = dpi::LogicalSize::new(1.0, 2.0);
-        assert_eq!(
-            log_size.to_physical::<u32>(1.0),
-            dpi::PhysicalSize::new(1, 2)
-        );
-        assert_eq!(
-            log_size.to_physical::<u32>(2.0),
-            dpi::PhysicalSize::new(2, 4)
-        );
-        assert_eq!(log_size.cast::<u32>(), dpi::LogicalSize::new(1, 2));
-        assert_eq!(
-            log_size,
-            dpi::LogicalSize::from_physical(dpi::PhysicalSize::new(1.0, 2.0), 1.0)
-        );
-        assert_eq!(
-            log_size,
-            dpi::LogicalSize::from_physical(dpi::PhysicalSize::new(2.0, 4.0), 2.0)
-        );
-        assert_eq!(
-            dpi::LogicalSize::from((2.0, 2.0)),
-            dpi::LogicalSize::new(2.0, 2.0)
-        );
-        assert_eq!(
-            dpi::LogicalSize::from([2.0, 3.0]),
-            dpi::LogicalSize::new(2.0, 3.0)
-        );
-
-        let x: (f64, f64) = log_size.into();
-        assert_eq!(x, (1.0, 2.0));
-        let x: [f64; 2] = log_size.into();
-        assert_eq!(x, [1.0, 2.0]);
-    }
-
-    #[test]
-    fn test_physical_size() {
-        assert_eq!(
-            dpi::PhysicalSize::from_logical(dpi::LogicalSize::new(1.0, 2.0), 1.0),
-            dpi::PhysicalSize::new(1, 2)
-        );
-        assert_eq!(
-            dpi::PhysicalSize::from_logical(dpi::LogicalSize::new(2.0, 4.0), 0.5),
-            dpi::PhysicalSize::new(1, 2)
-        );
-        assert_eq!(
-            dpi::PhysicalSize::from((2.0, 2.0)),
-            dpi::PhysicalSize::new(2.0, 2.0)
-        );
-        assert_eq!(
-            dpi::PhysicalSize::from([2.0, 3.0]),
-            dpi::PhysicalSize::new(2.0, 3.0)
-        );
-
-        let x: (f64, f64) = dpi::PhysicalSize::new(1, 2).into();
-        assert_eq!(x, (1.0, 2.0));
-        let x: [f64; 2] = dpi::PhysicalSize::new(1, 2).into();
-        assert_eq!(x, [1.0, 2.0]);
-    }
-
-    #[test]
-    fn test_size() {
-        assert_eq!(
-            dpi::Size::new(dpi::PhysicalSize::new(1, 2)),
-            dpi::Size::Physical(dpi::PhysicalSize::new(1, 2))
-        );
-        assert_eq!(
-            dpi::Size::new(dpi::LogicalSize::new(1.0, 2.0)),
-            dpi::Size::Logical(dpi::LogicalSize::new(1.0, 2.0))
-        );
-
-        assert_eq!(
-            dpi::Size::new(dpi::PhysicalSize::new(1, 2)).to_logical::<f64>(1.0),
-            dpi::LogicalSize::new(1.0, 2.0)
-        );
-        assert_eq!(
-            dpi::Size::new(dpi::PhysicalSize::new(1, 2)).to_logical::<f64>(2.0),
-            dpi::LogicalSize::new(0.5, 1.0)
-        );
-        assert_eq!(
-            dpi::Size::new(dpi::LogicalSize::new(1.0, 2.0)).to_logical::<f64>(1.0),
-            dpi::LogicalSize::new(1.0, 2.0)
-        );
-
-        assert_eq!(
-            dpi::Size::new(dpi::PhysicalSize::new(1, 2)).to_physical::<u32>(1.0),
-            dpi::PhysicalSize::new(1, 2)
-        );
-        assert_eq!(
-            dpi::Size::new(dpi::PhysicalSize::new(1, 2)).to_physical::<u32>(2.0),
-            dpi::PhysicalSize::new(1, 2)
-        );
-        assert_eq!(
-            dpi::Size::new(dpi::LogicalSize::new(1.0, 2.0)).to_physical::<u32>(1.0),
-            dpi::PhysicalSize::new(1, 2)
-        );
-        assert_eq!(
-            dpi::Size::new(dpi::LogicalSize::new(1.0, 2.0)).to_physical::<u32>(2.0),
-            dpi::PhysicalSize::new(2, 4)
-        );
-
-        let small = dpi::Size::Physical((1, 2).into());
-        let medium = dpi::Size::Logical((3, 4).into());
-        let medium_physical = dpi::Size::new(medium.to_physical::<u32>(1.0));
-        let large = dpi::Size::Physical((5, 6).into());
-        assert_eq!(dpi::Size::clamp(medium, small, large, 1.0), medium_physical);
-        assert_eq!(dpi::Size::clamp(small, medium, large, 1.0), medium_physical);
-        assert_eq!(dpi::Size::clamp(large, small, medium, 1.0), medium_physical);
-    }
-
-    #[test]
-    fn test_position() {
-        assert_eq!(
-            dpi::Position::new(dpi::PhysicalPosition::new(1, 2)),
-            dpi::Position::Physical(dpi::PhysicalPosition::new(1, 2))
-        );
-        assert_eq!(
-            dpi::Position::new(dpi::LogicalPosition::new(1.0, 2.0)),
-            dpi::Position::Logical(dpi::LogicalPosition::new(1.0, 2.0))
-        );
-
-        assert_eq!(
-            dpi::Position::new(dpi::PhysicalPosition::new(1, 2)).to_logical::<f64>(1.0),
-            dpi::LogicalPosition::new(1.0, 2.0)
-        );
-        assert_eq!(
-            dpi::Position::new(dpi::PhysicalPosition::new(1, 2)).to_logical::<f64>(2.0),
-            dpi::LogicalPosition::new(0.5, 1.0)
-        );
-        assert_eq!(
-            dpi::Position::new(dpi::LogicalPosition::new(1.0, 2.0)).to_logical::<f64>(1.0),
-            dpi::LogicalPosition::new(1.0, 2.0)
-        );
-
-        assert_eq!(
-            dpi::Position::new(dpi::PhysicalPosition::new(1, 2)).to_physical::<u32>(1.0),
-            dpi::PhysicalPosition::new(1, 2)
-        );
-        assert_eq!(
-            dpi::Position::new(dpi::PhysicalPosition::new(1, 2)).to_physical::<u32>(2.0),
-            dpi::PhysicalPosition::new(1, 2)
-        );
-        assert_eq!(
-            dpi::Position::new(dpi::LogicalPosition::new(1.0, 2.0)).to_physical::<u32>(1.0),
-            dpi::PhysicalPosition::new(1, 2)
-        );
-        assert_eq!(
-            dpi::Position::new(dpi::LogicalPosition::new(1.0, 2.0)).to_physical::<u32>(2.0),
-            dpi::PhysicalPosition::new(2, 4)
-        );
-    }
-
-    // Eat coverage for the Debug impls et al
-    #[test]
-    fn ensure_attrs_do_not_panic() {
-        let _ = format!("{:?}", dpi::LogicalPosition::<u32>::default().clone());
-        HashSet::new().insert(dpi::LogicalPosition::<u32>::default());
-
-        let _ = format!("{:?}", dpi::PhysicalPosition::<u32>::default().clone());
-        HashSet::new().insert(dpi::PhysicalPosition::<u32>::default());
-
-        let _ = format!("{:?}", dpi::LogicalSize::<u32>::default().clone());
-        HashSet::new().insert(dpi::LogicalSize::<u32>::default());
-
-        let _ = format!("{:?}", dpi::PhysicalSize::<u32>::default().clone());
-        HashSet::new().insert(dpi::PhysicalSize::<u32>::default());
-
-        let _ = format!("{:?}", dpi::Size::Physical((1, 2).into()).clone());
-        let _ = format!("{:?}", dpi::Position::Physical((1, 2).into()).clone());
-    }
-}

src/error.rs

@@ -2,14 +2,11 @@ use std::{error, fmt};
 
 use crate::platform_impl;
 
-// TODO: Rename
-/// An error that may be generated when requesting Winit state
+/// An error whose cause it outside Winit's control.
 #[derive(Debug)]
 pub enum ExternalError {
     /// The operation is not supported by the backend.
     NotSupported(NotSupportedError),
-    /// The operation was ignored.
-    Ignored,
     /// The OS cannot perform the operation.
     Os(OsError),
 }
@@ -28,27 +25,6 @@ pub struct OsError {
     error: platform_impl::OsError,
 }
 
-/// A general error that may occur while running the Winit event loop
-#[derive(Debug)]
-pub enum EventLoopError {
-    /// The operation is not supported by the backend.
-    NotSupported(NotSupportedError),
-    /// The OS cannot perform the operation.
-    Os(OsError),
-    /// The event loop can't be re-run while it's already running
-    AlreadyRunning,
-    /// The event loop can't be re-created.
-    RecreationAttempt,
-    /// Application has exit with an error status.
-    ExitFailure(i32),
-}
-
-impl From<OsError> for EventLoopError {
-    fn from(value: OsError) -> Self {
-        Self::Os(value)
-    }
-}
-
 impl NotSupportedError {
     #[inline]
     #[allow(dead_code)]
@@ -84,7 +60,6 @@ impl fmt::Display for ExternalError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match self {
             ExternalError::NotSupported(e) => e.fmt(f),
-            ExternalError::Ignored => write!(f, "Operation was ignored"),
             ExternalError::Os(e) => e.fmt(f),
         }
     }
@@ -102,41 +77,6 @@ impl fmt::Display for NotSupportedError {
     }
 }
 
-impl fmt::Display for EventLoopError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        match self {
-            EventLoopError::AlreadyRunning => write!(f, "EventLoop is already running"),
-            EventLoopError::RecreationAttempt => write!(f, "EventLoop can't be recreated"),
-            EventLoopError::NotSupported(e) => e.fmt(f),
-            EventLoopError::Os(e) => e.fmt(f),
-            EventLoopError::ExitFailure(status) => write!(f, "Exit Failure: {status}"),
-        }
-    }
-}
-
 impl error::Error for OsError {}
 impl error::Error for ExternalError {}
 impl error::Error for NotSupportedError {}
-impl error::Error for EventLoopError {}
-
-#[cfg(test)]
-mod tests {
-    #![allow(clippy::redundant_clone)]
-
-    use super::*;
-
-    // Eat attributes for testing
-    #[test]
-    fn ensure_fmt_does_not_panic() {
-        let _ = format!(
-            "{:?}, {}",
-            NotSupportedError::new(),
-            NotSupportedError::new().clone()
-        );
-        let _ = format!(
-            "{:?}, {}",
-            ExternalError::NotSupported(NotSupportedError::new()),
-            ExternalError::NotSupported(NotSupportedError::new())
-        );
-    }
-}

src/event_loop.rs

@@ -9,16 +9,12 @@
 //! handle events.
 use std::marker::PhantomData;
 use std::ops::Deref;
-use std::sync::atomic::{AtomicBool, AtomicU64, 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::error::EventLoopError;
 use crate::{event::Event, monitor::MonitorHandle, platform_impl};
 
 /// Provides a way to retrieve events from the system and from the windows that were registered to
@@ -70,8 +66,6 @@ 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.
@@ -88,23 +82,23 @@ impl<T> EventLoopBuilder<T> {
     /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
     /// and only once per application.***
     ///
+    /// Attempting to create the event loop on a different thread, or multiple event loops in
+    /// the same application, will panic. This restriction isn't
+    /// strictly necessary on all platforms, but is imposed to eliminate any nasty surprises when
+    /// porting to platforms that require it. `EventLoopBuilderExt::any_thread` functions are exposed
+    /// in the relevant [`platform`] module if the target platform supports creating an event loop on
+    /// any thread.
+    ///
     /// Calling this function will result in display backend initialisation.
     ///
-    /// ## Panics
-    ///
-    /// Attempting to create the event loop off the main thread will panic. This
-    /// restriction isn't strictly necessary on all platforms, but is imposed to
-    /// eliminate any nasty surprises when porting to platforms that require it.
-    /// `EventLoopBuilderExt::any_thread` functions are exposed in the relevant
-    /// [`platform`] module if the target platform supports creating an event
-    /// loop on any thread.
-    ///
     /// ## Platform-specific
     ///
-    /// - **Wayland/X11:** to prevent running under `Wayland` or `X11` unset `WAYLAND_DISPLAY`
-    ///                    or `DISPLAY` respectively when building the event loop.
-    /// - **Android:** must be configured with an `AndroidApp` from `android_main()` by calling
-    ///     [`.with_android_app(app)`] before calling `.build()`, otherwise it'll panic.
+    /// - **Linux:** Backend type can be controlled using an environment variable
+    ///   `WINIT_UNIX_BACKEND`. Legal values are `x11` and `wayland`.
+    ///   If it is not set, winit will try to connect to a Wayland connection, and if that fails,
+    ///   will fall back on X11. If this variable is set with any other value, winit will panic.
+    /// - **Android:** Must be configured with an `AndroidApp` from `android_main()` by calling
+    ///     [`.with_android_app(app)`] before calling `.build()`.
     ///
     /// [`platform`]: crate::platform
     #[cfg_attr(
@@ -116,22 +110,17 @@ impl<T> EventLoopBuilder<T> {
         doc = "[`.with_android_app(app)`]: #only-available-on-android"
     )]
     #[inline]
-    pub fn build(&mut self) -> Result<EventLoop<T>, EventLoopError> {
-        if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
-            return Err(EventLoopError::RecreationAttempt);
+    pub fn build(&mut self) -> EventLoop<T> {
+        static EVENT_LOOP_CREATED: OnceCell<()> = OnceCell::new();
+        if EVENT_LOOP_CREATED.set(()).is_err() {
+            panic!("Creating EventLoop multiple times is not supported.");
         }
-
         // Certain platforms accept a mutable reference in their API.
         #[allow(clippy::unnecessary_mut_passed)]
-        Ok(EventLoop {
-            event_loop: platform_impl::EventLoop::new(&mut self.platform_specific)?,
+        EventLoop {
+            event_loop: platform_impl::EventLoop::new(&mut self.platform_specific),
             _marker: PhantomData,
-        })
-    }
-
-    #[cfg(wasm_platform)]
-    pub(crate) fn allow_event_loop_recreation() {
-        EVENT_LOOP_CREATED.store(false, Ordering::Relaxed);
+        }
     }
 }
 
@@ -149,7 +138,7 @@ impl<T> fmt::Debug for EventLoopWindowTarget<T> {
 
 /// Set by the user callback given to the [`EventLoop::run`] method.
 ///
-/// Indicates the desired behavior of the event loop after [`Event::AboutToWait`] is emitted.
+/// Indicates the desired behavior of the event loop after [`Event::RedrawEventsCleared`] is emitted.
 ///
 /// Defaults to [`Poll`].
 ///
@@ -157,7 +146,7 @@ impl<T> fmt::Debug for EventLoopWindowTarget<T> {
 ///
 /// Almost every change is persistent between multiple calls to the event loop closure within a
 /// given run loop. The only exception to this is [`ExitWithCode`] which, once set, cannot be unset.
-/// Changes are **not** persistent between multiple calls to `run_ondemand` - issuing a new call will
+/// Changes are **not** persistent between multiple calls to `run_return` - issuing a new call will
 /// reset the control flow to [`Poll`].
 ///
 /// [`ExitWithCode`]: Self::ExitWithCode
@@ -166,6 +155,13 @@ 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.
@@ -181,7 +177,7 @@ pub enum ControlFlow {
     /// [`Poll`]: Self::Poll
     WaitUntil(Instant),
 
-    /// Send a [`LoopExiting`] event and stop the event loop. This variant is *sticky* - once set,
+    /// Send a [`LoopDestroyed`] event and stop the event loop. This variant is *sticky* - once set,
     /// `control_flow` cannot be changed from `ExitWithCode`, and any future attempts to do so will
     /// result in the `control_flow` parameter being reset to `ExitWithCode`.
     ///
@@ -190,12 +186,12 @@ pub enum ControlFlow {
     ///
     /// ## Platform-specific
     ///
-    /// - **Android / iOS / Web:** The supplied exit code is unused.
+    /// - **Android / iOS / WASM:** The supplied exit code is unused.
     /// - **Unix:** On most Unix-like platforms, only the 8 least significant bits will be used,
     ///   which can cause surprises with negative exit values (`-42` would end up as `214`). See
     ///   [`std::process::exit`].
     ///
-    /// [`LoopExiting`]: Event::LoopExiting
+    /// [`LoopDestroyed`]: Event::LoopDestroyed
     /// [`Exit`]: ControlFlow::Exit
     ExitWithCode(i32),
 }
@@ -269,49 +265,42 @@ impl EventLoop<()> {
     ///
     /// [`EventLoopBuilder::new().build()`]: EventLoopBuilder::build
     #[inline]
-    pub fn new() -> Result<EventLoop<()>, EventLoopError> {
+    pub fn new() -> EventLoop<()> {
         EventLoopBuilder::new().build()
     }
 }
 
+impl Default for EventLoop<()> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T> EventLoop<T> {
     #[deprecated = "Use `EventLoopBuilder::<T>::with_user_event().build()` instead."]
-    pub fn with_user_event() -> Result<EventLoop<T>, EventLoopError> {
+    pub fn with_user_event() -> EventLoop<T> {
         EventLoopBuilder::<T>::with_user_event().build()
     }
 
-    /// Runs the event loop in the calling thread and calls the given `event_handler` closure
-    /// to dispatch any pending events.
-    ///
-    /// Since the closure is `'static`, it must be a `move` closure if it needs to
+    /// Hijacks the calling thread and initializes the winit event loop with the provided
+    /// closure. Since the closure is `'static`, it must be a `move` closure if it needs to
     /// access any data from the calling context.
     ///
     /// See the [`ControlFlow`] docs for information on how changes to `&mut ControlFlow` impact the
     /// event loop's behavior.
     ///
+    /// Any values not passed to this function will *not* be dropped.
+    ///
     /// ## Platform-specific
     ///
     /// - **X11 / Wayland:** The program terminates with exit code 1 if the display server
     ///   disconnects.
-    /// - **iOS:** Will never return to the caller and so values not passed to this function will
-    ///   *not* be dropped before the process exits.
-    /// - **Web:** Will _act_ as if it never returns to the caller by throwing a Javascript exception
-    ///   (that Rust doesn't see) that will also mean that the rest of the function is never executed
-    ///   and any values not passed to this function will *not* be dropped.
-    ///
-    ///   Web applications are recommended to use `spawn()` instead of `run()` to avoid the need
-    ///   for the Javascript exception trick, and to make it clearer that the event loop runs
-    ///   asynchronously (via the browser's own, internal, event loop) and doesn't block the
-    ///   current thread of execution like it does on other platforms.
-    ///
-    ///   This function won't be available with `target_feature = "exception-handling"`.
     ///
     /// [`ControlFlow`]: crate::event_loop::ControlFlow
     #[inline]
-    #[cfg(not(all(wasm_platform, target_feature = "exception-handling")))]
-    pub fn run<F>(self, event_handler: F) -> Result<(), EventLoopError>
+    pub fn run<F>(self, event_handler: F) -> !
     where
-        F: FnMut(Event<T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<'_, T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
     {
         self.event_loop.run(event_handler)
     }
@@ -342,7 +331,6 @@ 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()
@@ -363,20 +351,20 @@ impl<T> EventLoopWindowTarget<T> {
             .map(|inner| MonitorHandle { inner })
     }
 
-    /// Change if or when [`DeviceEvent`]s are captured.
+    /// Change [`DeviceEvent`] filter mode.
     ///
     /// 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 at runtime to explicitly capture them again.
+    /// this filter at runtime to explicitly capture them again.
     ///
     /// ## Platform-specific
     ///
-    /// - **Wayland / macOS / iOS / Android / Orbital:** Unsupported.
+    /// - **Wayland / macOS / iOS / Android / Web / Orbital:** Unsupported.
     ///
     /// [`DeviceEvent`]: crate::event::DeviceEvent
-    pub fn listen_device_events(&self, _allowed: DeviceEvents) {
-        #[cfg(any(x11_platform, wasm_platform, wayland_platform, windows))]
-        self.p.listen_device_events(_allowed);
+    pub fn set_device_event_filter(&self, _filter: DeviceEventFilter) {
+        #[cfg(any(x11_platform, wayland_platform, windows))]
+        self.p.set_device_event_filter(_filter);
     }
 }
 
@@ -434,40 +422,19 @@ impl<T> fmt::Display for EventLoopClosed<T> {
 
 impl<T: fmt::Debug> error::Error for EventLoopClosed<T> {}
 
-/// 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.
+/// Filter controlling the propagation of device events.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum DeviceEventFilter {
+    /// Always filter out device events.
     Always,
-    /// Only capture device events while the window is focused.
-    #[default]
-    WhenFocused,
-    /// Never capture device events.
+    /// Filter out device events while the window is not focused.
+    Unfocused,
+    /// Report all device events regardless of window focus.
     Never,
 }
 
-/// A unique identifier of the winit's async request.
-///
-/// This could be used to identify the async request once it's done
-/// and a specific action must be taken.
-///
-/// One of the handling scenarious could be to maintain a working list
-/// containing [`AsyncRequestSerial`] and some closure associated with it.
-/// Then once event is arriving the working list is being traversed and a job
-/// executed and removed from the list.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct AsyncRequestSerial {
-    serial: u64,
-}
-
-impl AsyncRequestSerial {
-    // TODO(kchibisov) remove `cfg` when the clipboard will be added.
-    #[allow(dead_code)]
-    pub(crate) fn get() -> Self {
-        static CURRENT_SERIAL: AtomicU64 = AtomicU64::new(0);
-        // NOTE: we rely on wrap around here, while the user may just request
-        // in the loop u64::MAX times that's issue is considered on them.
-        let serial = CURRENT_SERIAL.fetch_add(1, Ordering::Relaxed);
-        Self { serial }
+impl Default for DeviceEventFilter {
+    fn default() -> Self {
+        Self::Unfocused
     }
 }

src/lib.rs

@@ -7,7 +7,7 @@
 //!
 //! ```no_run
 //! use winit::event_loop::EventLoop;
-//! let event_loop = EventLoop::new().unwrap();
+//! let event_loop = EventLoop::new();
 //! ```
 //!
 //! Once this is done there are two ways to create a [`Window`]:
@@ -32,12 +32,12 @@
 //! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
 //! will run until the `control_flow` argument given to the closure is set to
 //! [`ControlFlow`]`::`[`ExitWithCode`] (which [`ControlFlow`]`::`[`Exit`] aliases to), at which
-//! point [`Event`]`::`[`LoopExiting`] is emitted and the entire program terminates.
+//! point [`Event`]`::`[`LoopDestroyed`] is emitted and the entire program terminates.
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
 //! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works poorly on
 //! most other platforms. However, this model can be re-implemented to an extent with
-//! [`EventLoopExtPumpEvents::pump_events`]. See that method's documentation for more reasons about why
+//! [`EventLoopExtRunReturn::run_return`]. See that method's documentation for more reasons about why
 //! it's discouraged, beyond compatibility reasons.
 //!
 //!
@@ -48,7 +48,7 @@
 //!     window::WindowBuilder,
 //! };
 //!
-//! let event_loop = EventLoop::new().unwrap();
+//! let event_loop = EventLoop::new();
 //! let window = WindowBuilder::new().build(&event_loop).unwrap();
 //!
 //! event_loop.run(move |event, _, control_flow| {
@@ -69,7 +69,7 @@
 //!             println!("The close button was pressed; stopping");
 //!             control_flow.set_exit();
 //!         },
-//!         Event::AboutToWait => {
+//!         Event::MainEventsCleared => {
 //!             // Application update code.
 //!
 //!             // Queue a RedrawRequested event.
@@ -83,7 +83,7 @@
 //!             // Redraw the application.
 //!             //
 //!             // It's preferable for applications that do not render continuously to render in
-//!             // this event rather than in AboutToWait, since rendering in here allows
+//!             // this event rather than in MainEventsCleared, since rendering in here allows
 //!             // the program to gracefully handle redraws requested by the OS.
 //!         },
 //!         _ => ()
@@ -109,7 +109,7 @@
 //! window visible only once you're ready to render into it.
 //!
 //! [`EventLoop`]: event_loop::EventLoop
-//! [`EventLoopExtPumpEvents::pump_events`]: ./platform/pump_events/trait.EventLoopExtPumpEvents.html#tymethod.pump_events
+//! [`EventLoopExtRunReturn::run_return`]: ./platform/run_return/trait.EventLoopExtRunReturn.html#tymethod.run_return
 //! [`EventLoop::new()`]: event_loop::EventLoop::new
 //! [event_loop_run]: event_loop::EventLoop::run
 //! [`ControlFlow`]: event_loop::ControlFlow
@@ -126,7 +126,7 @@
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
 //! [`UserEvent`]: event::Event::UserEvent
-//! [`LoopExiting`]: event::Event::LoopExiting
+//! [`LoopDestroyed`]: event::Event::LoopDestroyed
 //! [`platform`]: platform
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 //! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
@@ -154,7 +154,6 @@ pub mod error;
 pub mod event;
 pub mod event_loop;
 mod icon;
-pub mod keyboard;
 pub mod monitor;
 mod platform_impl;
 pub mod window;

src/monitor.rs

@@ -32,9 +32,12 @@ 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(
-            self.size()
-                .cmp(&other.size())
+            size.cmp(&other_size)
                 .then(
                     self.refresh_rate_millihertz()
                         .cmp(&other.refresh_rate_millihertz())

src/platform/android.rs

@@ -42,11 +42,6 @@ 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> {
@@ -54,11 +49,6 @@ 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

src/platform/ios.rs

@@ -22,6 +22,27 @@ impl<T: 'static> EventLoopExtIOS for EventLoop<T> {
 
 /// Additional methods on [`Window`] that are specific to iOS.
 pub trait WindowExtIOS {
+    /// Returns a pointer to the [`UIWindow`] that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    ///
+    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
+    fn ui_window(&self) -> *mut c_void;
+
+    /// Returns a pointer to the [`UIViewController`] that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    ///
+    /// [`UIViewController`]: https://developer.apple.com/documentation/uikit/uiviewcontroller?language=objc
+    fn ui_view_controller(&self) -> *mut c_void;
+
+    /// Returns a pointer to the [`UIView`] that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    ///
+    /// [`UIView`]: https://developer.apple.com/documentation/uikit/uiview?language=objc
+    fn ui_view(&self) -> *mut c_void;
+
     /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
     ///
     /// The default value is device dependent, and it's recommended GLES or Metal applications set
@@ -76,35 +97,45 @@ pub trait WindowExtIOS {
 }
 
 impl WindowExtIOS for Window {
+    #[inline]
+    fn ui_window(&self) -> *mut c_void {
+        self.window.ui_window()
+    }
+
+    #[inline]
+    fn ui_view_controller(&self) -> *mut c_void {
+        self.window.ui_view_controller()
+    }
+
+    #[inline]
+    fn ui_view(&self) -> *mut c_void {
+        self.window.ui_view()
+    }
+
     #[inline]
     fn set_scale_factor(&self, scale_factor: f64) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_scale_factor(scale_factor))
+        self.window.set_scale_factor(scale_factor)
     }
 
     #[inline]
     fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_valid_orientations(valid_orientations))
+        self.window.set_valid_orientations(valid_orientations)
     }
 
     #[inline]
     fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_prefers_home_indicator_hidden(hidden))
+        self.window.set_prefers_home_indicator_hidden(hidden)
     }
 
     #[inline]
     fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
-        self.window.maybe_queue_on_main(move |w| {
-            w.set_preferred_screen_edges_deferring_system_gestures(edges)
-        })
+        self.window
+            .set_preferred_screen_edges_deferring_system_gestures(edges)
     }
 
     #[inline]
     fn set_prefers_status_bar_hidden(&self, hidden: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_prefers_status_bar_hidden(hidden))
+        self.window.set_prefers_status_bar_hidden(hidden)
     }
 }
 
@@ -222,10 +253,9 @@ impl MonitorHandleExtIOS for MonitorHandle {
 }
 
 /// Valid orientations for a particular [`Window`].
-#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug)]
 pub enum ValidOrientations {
     /// Excludes `PortraitUpsideDown` on iphone
-    #[default]
     LandscapeAndPortrait,
 
     Landscape,
@@ -234,10 +264,17 @@ 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(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum Idiom {
     Unspecified,
 
@@ -256,14 +293,14 @@ bitflags! {
     /// The [edges] of a screen.
     ///
     /// [edges]: https://developer.apple.com/documentation/uikit/uirectedge?language=objc
-    #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+    #[derive(Default)]
     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;
     }
 }

src/platform/macos.rs

@@ -10,6 +10,16 @@ use crate::{
 
 /// Additional methods on [`Window`] that are specific to MacOS.
 pub trait WindowExtMacOS {
+    /// Returns a pointer to the cocoa `NSWindow` that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn ns_window(&self) -> *mut c_void;
+
+    /// Returns a pointer to the cocoa `NSView` that is used by this window.
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn ns_view(&self) -> *mut c_void;
+
     /// Returns whether or not the window is in simple fullscreen mode.
     fn simple_fullscreen(&self) -> bool;
 
@@ -28,28 +38,6 @@ pub trait WindowExtMacOS {
     /// Sets whether or not the window has shadow.
     fn set_has_shadow(&self, has_shadow: bool);
 
-    /// Group windows together by using the same tabbing identifier.
-    ///
-    /// <https://developer.apple.com/documentation/appkit/nswindow/1644704-tabbingidentifier>
-    fn set_tabbing_identifier(&self, identifier: &str);
-
-    /// Returns the window's tabbing identifier.
-    fn tabbing_identifier(&self) -> String;
-
-    /// Select next tab.
-    fn select_next_tab(&self);
-
-    /// Select previous tab.
-    fn select_previous_tab(&self);
-
-    /// Select the tab with the given index.
-    ///
-    /// Will no-op when the index is out of bounds.
-    fn select_tab_at_index(&self, index: usize);
-
-    /// Get the number of tabs in the window tab group.
-    fn num_tabs(&self) -> usize;
-
     /// Get the window's edit state.
     ///
     /// # Examples
@@ -82,97 +70,74 @@ pub trait WindowExtMacOS {
 }
 
 impl WindowExtMacOS for Window {
+    #[inline]
+    fn ns_window(&self) -> *mut c_void {
+        self.window.ns_window()
+    }
+
+    #[inline]
+    fn ns_view(&self) -> *mut c_void {
+        self.window.ns_view()
+    }
+
     #[inline]
     fn simple_fullscreen(&self) -> bool {
-        self.window.maybe_wait_on_main(|w| w.simple_fullscreen())
+        self.window.simple_fullscreen()
     }
 
     #[inline]
     fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
-        self.window
-            .maybe_wait_on_main(move |w| w.set_simple_fullscreen(fullscreen))
+        self.window.set_simple_fullscreen(fullscreen)
     }
 
     #[inline]
     fn has_shadow(&self) -> bool {
-        self.window.maybe_wait_on_main(|w| w.has_shadow())
+        self.window.has_shadow()
     }
 
     #[inline]
     fn set_has_shadow(&self, has_shadow: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_has_shadow(has_shadow))
-    }
-
-    #[inline]
-    fn set_tabbing_identifier(&self, identifier: &str) {
-        self.window
-            .maybe_wait_on_main(|w| w.set_tabbing_identifier(identifier))
-    }
-
-    #[inline]
-    fn tabbing_identifier(&self) -> String {
-        self.window.maybe_wait_on_main(|w| w.tabbing_identifier())
-    }
-
-    #[inline]
-    fn select_next_tab(&self) {
-        self.window.maybe_queue_on_main(|w| w.select_next_tab())
-    }
-
-    #[inline]
-    fn select_previous_tab(&self) {
-        self.window.maybe_queue_on_main(|w| w.select_previous_tab())
-    }
-
-    #[inline]
-    fn select_tab_at_index(&self, index: usize) {
-        self.window
-            .maybe_queue_on_main(move |w| w.select_tab_at_index(index))
-    }
-
-    #[inline]
-    fn num_tabs(&self) -> usize {
-        self.window.maybe_wait_on_main(|w| w.num_tabs())
+        self.window.set_has_shadow(has_shadow)
     }
 
     #[inline]
     fn is_document_edited(&self) -> bool {
-        self.window.maybe_wait_on_main(|w| w.is_document_edited())
+        self.window.is_document_edited()
     }
 
     #[inline]
     fn set_document_edited(&self, edited: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_document_edited(edited))
+        self.window.set_document_edited(edited)
     }
 
     #[inline]
     fn set_option_as_alt(&self, option_as_alt: OptionAsAlt) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_option_as_alt(option_as_alt))
+        self.window.set_option_as_alt(option_as_alt)
     }
 
     #[inline]
     fn option_as_alt(&self) -> OptionAsAlt {
-        self.window.maybe_wait_on_main(|w| w.option_as_alt())
+        self.window.option_as_alt()
     }
 }
 
 /// Corresponds to `NSApplicationActivationPolicy`.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, 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:
@@ -199,11 +164,8 @@ 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;
-    /// Defines the window tabbing identifier.
-    ///
-    /// <https://developer.apple.com/documentation/appkit/nswindow/1644704-tabbingidentifier>
-    fn with_tabbing_identifier(self, identifier: &str) -> WindowBuilder;
-    /// Set how the <kbd>Option</kbd> keys are interpreted.
+
+    /// Set whether the `OptionAsAlt` key is interpreted as the `Alt` modifier.
     ///
     /// 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;
@@ -267,14 +229,6 @@ impl WindowBuilderExtMacOS for WindowBuilder {
         self
     }
 
-    #[inline]
-    fn with_tabbing_identifier(mut self, tabbing_identifier: &str) -> WindowBuilder {
-        self.platform_specific
-            .tabbing_identifier
-            .replace(tabbing_identifier.to_string());
-        self
-    }
-
     #[inline]
     fn with_option_as_alt(mut self, option_as_alt: OptionAsAlt) -> WindowBuilder {
         self.platform_specific.option_as_alt = option_as_alt;
@@ -379,12 +333,6 @@ pub trait EventLoopWindowTargetExtMacOS {
     fn hide_application(&self);
     /// Hide the other applications. In most applications this is typically triggered with Command+Option-H.
     fn hide_other_applications(&self);
-    /// Set whether the system can automatically organize windows into tabs.
-    ///
-    /// <https://developer.apple.com/documentation/appkit/nswindow/1646657-allowsautomaticwindowtabbing>
-    fn set_allows_automatic_window_tabbing(&self, enabled: bool);
-    /// Returns whether the system can automatically organize windows into tabs.
-    fn allows_automatic_window_tabbing(&self) -> bool;
 }
 
 impl<T> EventLoopWindowTargetExtMacOS for EventLoopWindowTarget<T> {
@@ -395,20 +343,12 @@ impl<T> EventLoopWindowTargetExtMacOS for EventLoopWindowTarget<T> {
     fn hide_other_applications(&self) {
         self.p.hide_other_applications()
     }
-
-    fn set_allows_automatic_window_tabbing(&self, enabled: bool) {
-        self.p.set_allows_automatic_window_tabbing(enabled);
-    }
-
-    fn allows_automatic_window_tabbing(&self) -> bool {
-        self.p.allows_automatic_window_tabbing()
-    }
 }
 
 /// Option as alt behavior.
 ///
 /// The default is `None`.
-#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum OptionAsAlt {
     /// The left `Option` key is treated as `Alt`.
@@ -421,6 +361,11 @@ pub enum OptionAsAlt {
     Both,
 
     /// No special handling is applied for `Option` key.
-    #[default]
     None,
 }
+
+impl Default for OptionAsAlt {
+    fn default() -> Self {
+        OptionAsAlt::None
+    }
+}

src/platform/mod.rs

@@ -9,10 +9,9 @@
 //!  - `windows`
 //!  - `web`
 //!
-//! And the following platform-specific modules:
+//! And the following platform-specific module:
 //!
-//! - `run_ondemand` (available on `windows`, `unix`, `macos`, `android`)
-//! - `pump_events` (available on `windows`, `unix`, `macos`, `android`)
+//! - `run_return` (available on `windows`, `unix`, `macos`, and `android`)
 //!
 //! However only the module corresponding to the platform you're compiling to will be available.
 
@@ -24,8 +23,6 @@ pub mod ios;
 pub mod macos;
 #[cfg(orbital_platform)]
 pub mod orbital;
-#[cfg(any(x11_platform, wayland_platform))]
-pub mod startup_notify;
 #[cfg(wayland_platform)]
 pub mod wayland;
 #[cfg(wasm_platform)]
@@ -40,18 +37,7 @@ pub mod x11;
     macos_platform,
     android_platform,
     x11_platform,
-    wayland_platform
+    wayland_platform,
+    orbital_platform
 ))]
-pub mod run_ondemand;
-
-#[cfg(any(
-    windows_platform,
-    macos_platform,
-    android_platform,
-    x11_platform,
-    wayland_platform
-))]
-pub mod pump_events;
-
-pub mod modifier_supplement;
-pub mod scancode;
+pub mod run_return;

src/platform/modifier_supplement.rs

@@ -1,24 +0,0 @@
-#![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;
-}

src/platform/pump_events.rs

@@ -1,189 +0,0 @@
-use std::time::Duration;
-
-use crate::{
-    event::Event,
-    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
-};
-
-/// The return status for `pump_events`
-pub enum PumpStatus {
-    /// Continue running external loop.
-    Continue,
-    /// Exit external loop.
-    Exit(i32),
-}
-
-/// Additional methods on [`EventLoop`] for pumping events within an external event loop
-pub trait EventLoopExtPumpEvents {
-    /// A type provided by the user that can be passed through [`Event::UserEvent`].
-    type UserEvent;
-
-    /// Pump the `EventLoop` to check for and dispatch pending events.
-    ///
-    /// This API is designed to enable applications to integrate Winit into an
-    /// external event loop, for platforms that can support this.
-    ///
-    /// The given `timeout` limits how long it may block waiting for new events.
-    ///
-    /// Passing a `timeout` of `Some(Duration::ZERO)` would ensure your external
-    /// event loop is never blocked but you would likely need to consider how
-    /// to throttle your own external loop.
-    ///
-    /// Passing a `timeout` of `None` means that it may wait indefinitely for new
-    /// events before returning control back to the external loop.
-    ///
-    /// ## Example
-    ///
-    /// ```rust,no_run
-    /// # // Copied from examples/window_pump_events.rs
-    /// # #[cfg(any(
-    /// #     windows_platform,
-    /// #     macos_platform,
-    /// #     x11_platform,
-    /// #     wayland_platform,
-    /// #     android_platform,
-    /// # ))]
-    /// fn main() -> std::process::ExitCode {
-    /// #     use std::{process::ExitCode, thread::sleep, time::Duration};
-    /// #
-    /// #     use simple_logger::SimpleLogger;
-    /// #     use winit::{
-    /// #         event::{Event, WindowEvent},
-    /// #         event_loop::EventLoop,
-    /// #         platform::pump_events::{EventLoopExtPumpEvents, PumpStatus},
-    /// #         window::WindowBuilder,
-    /// #     };
-    ///     let mut event_loop = EventLoop::new().unwrap();
-    /// #
-    /// #   SimpleLogger::new().init().unwrap();
-    ///     let window = WindowBuilder::new()
-    ///         .with_title("A fantastic window!")
-    ///         .build(&event_loop)
-    ///         .unwrap();
-    ///
-    ///     'main: loop {
-    ///         let timeout = Some(Duration::ZERO);
-    ///         let status = event_loop.pump_events(timeout, |event, _, control_flow| {
-    /// #            if let Event::WindowEvent { event, .. } = &event {
-    /// #                // Print only Window events to reduce noise
-    /// #                println!("{event:?}");
-    /// #            }
-    /// #
-    ///             match event {
-    ///                 Event::WindowEvent {
-    ///                     event: WindowEvent::CloseRequested,
-    ///                     window_id,
-    ///                 } if window_id == window.id() => control_flow.set_exit(),
-    ///                 Event::AboutToWait => {
-    ///                     window.request_redraw();
-    ///                 }
-    ///                 _ => (),
-    ///             }
-    ///         });
-    ///         if let PumpStatus::Exit(exit_code) = status {
-    ///             break 'main ExitCode::from(exit_code as u8);
-    ///         }
-    ///
-    ///         // Sleep for 1/60 second to simulate application work
-    ///         //
-    ///         // Since `pump_events` doesn't block it will be important to
-    ///         // throttle the loop in the app somehow.
-    ///         println!("Update()");
-    ///         sleep(Duration::from_millis(16));
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// **Note:** This is not a portable API, and its usage involves a number of
-    /// caveats and trade offs that should be considered before using this API!
-    ///
-    /// You almost certainly shouldn't use this API, unless you absolutely know it's
-    /// the only practical option you have.
-    ///
-    /// ## Synchronous events
-    ///
-    /// Some events _must_ only be handled synchronously via the closure that
-    /// is passed to Winit so that the handler will also be synchronized with
-    /// the window system and operating system.
-    ///
-    /// This is because some events are driven by a window system callback
-    /// where the window systems expects the application to have handled the
-    /// event before returning.
-    ///
-    /// **These events can not be buffered and handled outside of the closure
-    /// passed to Winit.**
-    ///
-    /// As a general rule it is not recommended to ever buffer events to handle
-    /// them outside of the closure passed to Winit since it's difficult to
-    /// provide guarantees about which events are safe to buffer across all
-    /// operating systems.
-    ///
-    /// Notable events that will certainly create portability problems if
-    /// buffered and handled outside of Winit include:
-    /// - `RedrawRequested` events, used to schedule rendering.
-    ///
-    ///     macOS for example uses a `drawRect` callback to drive rendering
-    /// within applications and expects rendering to be finished before
-    /// the `drawRect` callback returns.
-    ///
-    ///     For portability it's strongly recommended that applications should
-    /// keep their rendering inside the closure provided to Winit.
-    /// - Any lifecycle events, such as `Suspended` / `Resumed`.
-    ///
-    ///     The handling of these events needs to be synchronized with the
-    /// operating system and it would never be appropriate to buffer a
-    /// notification that your application has been suspended or resumed and
-    /// then handled that later since there would always be a chance that
-    /// other lifecycle events occur while the event is buffered.
-    ///
-    /// ## Supported Platforms
-    /// - Windows
-    /// - Linux
-    /// - MacOS
-    /// - Android
-    ///
-    /// ## Unsupported Platforms
-    /// - **Web:**  This API is fundamentally incompatible with the event-based way in which
-    /// Web browsers work because it's not possible to have a long-running external
-    /// loop that would block the browser and there is nothing that can be
-    /// polled to ask for new new events. Events are delivered via callbacks based
-    /// on an event loop that is internal to the browser itself.
-    /// - **iOS:** It's not possible to stop and start an `NSApplication` repeatedly on iOS so
-    /// there's no way to support the same approach to polling as on MacOS.
-    ///
-    /// ## Platform-specific
-    /// - **Windows**: The implementation will use `PeekMessage` when checking for
-    ///   window messages to avoid blocking your external event loop.
-    ///
-    /// - **MacOS**: The implementation works in terms of stopping the global `NSApp`
-    ///   whenever the application `RunLoop` indicates that it is preparing to block
-    ///   and wait for new events.
-    ///
-    ///   This is very different to the polling APIs that are available on other
-    ///   platforms (the lower level polling primitives on MacOS are private
-    ///   implementation details for `NSApp` which aren't accessible to application
-    ///   developers)
-    ///
-    ///   It's likely this will be less efficient than polling on other OSs and
-    ///   it also means the `NSApp` is stopped while outside of the Winit
-    ///   event loop - and that's observable (for example to crates like `rfd`)
-    ///   because the `NSApp` is global state.
-    ///
-    ///   If you render outside of Winit you are likely to see window resizing artifacts
-    ///   since MacOS expects applications to render synchronously during any `drawRect`
-    ///   callback.
-    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow);
-}
-
-impl<T> EventLoopExtPumpEvents for EventLoop<T> {
-    type UserEvent = T;
-
-    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow),
-    {
-        self.event_loop.pump_events(timeout, event_handler)
-    }
-}

src/platform/run_ondemand.rs

@@ -1,74 +0,0 @@
-use crate::{
-    error::EventLoopError,
-    event::Event,
-    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
-};
-
-#[cfg(doc)]
-use crate::{platform::pump_events::EventLoopExtPumpEvents, window::Window};
-
-/// Additional methods on [`EventLoop`] to return control flow to the caller.
-pub trait EventLoopExtRunOnDemand {
-    /// A type provided by the user that can be passed through [`Event::UserEvent`].
-    type UserEvent;
-
-    /// Runs the event loop in the calling thread and calls the given `event_handler` closure
-    /// to dispatch any window system events.
-    ///
-    /// Unlike [`EventLoop::run`], this function accepts non-`'static` (i.e. non-`move`) closures
-    /// and it is possible to return control back to the caller without
-    /// consuming the `EventLoop` (by setting the `control_flow` to [`ControlFlow::Exit`]) and
-    /// so the event loop can be re-run after it has exit.
-    ///
-    /// It's expected that each run of the loop will be for orthogonal instantiations of your
-    /// Winit application, but internally each instantiation may re-use some common window
-    /// system resources, such as a display server connection.
-    ///
-    /// This API is not designed to run an event loop in bursts that you can exit from and return
-    /// to while maintaining the full state of your application. (If you need something like this
-    /// you can look at the [`EventLoopExtPumpEvents::pump_events()`] API)
-    ///
-    /// Each time `run_ondemand` is called the `event_handler` can expect to receive a
-    /// `NewEvents(Init)` and `Resumed` event (even on platforms that have no suspend/resume
-    /// lifecycle) - which can be used to consistently initialize application state.
-    ///
-    /// See the [`ControlFlow`] docs for information on how changes to `&mut ControlFlow` impact the
-    /// event loop's behavior.
-    ///
-    /// # Caveats
-    /// - This extension isn't available on all platforms, since it's not always possible to
-    ///   return to the caller (specifically this is impossible on iOS and Web - though with
-    ///   the Web backend it is possible to use `spawn()` more than once instead).
-    /// - No [`Window`] state can be carried between separate runs of the event loop.
-    ///
-    /// You are strongly encouraged to use [`EventLoop::run()`] for portability, unless you specifically need
-    /// the ability to re-run a single event loop more than once
-    ///
-    /// # Supported Platforms
-    /// - Windows
-    /// - Linux
-    /// - macOS
-    /// - Android
-    ///
-    /// # Unsupported Platforms
-    /// - **Web:**  This API is fundamentally incompatible with the event-based way in which
-    ///   Web browsers work because it's not possible to have a long-running external
-    ///   loop that would block the browser and there is nothing that can be
-    ///   polled to ask for new events. Events are delivered via callbacks based
-    ///   on an event loop that is internal to the browser itself.
-    /// - **iOS:** It's not possible to stop and start an `NSApplication` repeatedly on iOS.
-    fn run_ondemand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow);
-}
-
-impl<T> EventLoopExtRunOnDemand for EventLoop<T> {
-    type UserEvent = T;
-
-    fn run_ondemand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow),
-    {
-        self.event_loop.run_ondemand(event_handler)
-    }
-}

src/platform/run_return.rs

@@ -0,0 +1,53 @@
+use crate::{
+    event::Event,
+    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+};
+
+/// Additional methods on [`EventLoop`] to return control flow to the caller.
+pub trait EventLoopExtRunReturn {
+    /// A type provided by the user that can be passed through [`Event::UserEvent`].
+    type UserEvent;
+
+    /// Initializes the `winit` event loop.
+    ///
+    /// Unlike [`EventLoop::run`], this function accepts non-`'static` (i.e. non-`move`) closures
+    /// and returns control flow to the caller when `control_flow` is set to [`ControlFlow::Exit`].
+    ///
+    /// # Caveats
+    ///
+    /// Despite its appearance at first glance, this is *not* a perfect replacement for
+    /// `poll_events`. For example, this function will not return on Windows or macOS while a
+    /// window is getting resized, resulting in all application logic outside of the
+    /// `event_handler` closure not running until the resize operation ends. Other OS operations
+    /// may also result in such freezes. This behavior is caused by fundamental limitations in the
+    /// underlying OS APIs, which cannot be hidden by `winit` without severe stability repercussions.
+    ///
+    /// You are strongly encouraged to use `run`, unless the use of this is absolutely necessary.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11 / Wayland:** This function returns `1` upon disconnection from
+    ///   the display server.
+    fn run_return<F>(&mut self, event_handler: F) -> i32
+    where
+        F: FnMut(
+            Event<'_, Self::UserEvent>,
+            &EventLoopWindowTarget<Self::UserEvent>,
+            &mut ControlFlow,
+        );
+}
+
+impl<T> EventLoopExtRunReturn for EventLoop<T> {
+    type UserEvent = T;
+
+    fn run_return<F>(&mut self, event_handler: F) -> i32
+    where
+        F: FnMut(
+            Event<'_, Self::UserEvent>,
+            &EventLoopWindowTarget<Self::UserEvent>,
+            &mut ControlFlow,
+        ),
+    {
+        self.event_loop.run_return(event_handler)
+    }
+}

src/platform/scancode.rs

@@ -1,30 +0,0 @@
-#![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;
-}

src/platform/startup_notify.rs

@@ -1,109 +0,0 @@
-//! Window startup notification to handle window raising.
-//!
-//! The [`ActivationToken`] is essential to ensure that your newly
-//! created window will obtain the focus, otherwise the user could
-//! be requered to click on the window.
-//!
-//! Such token is usually delivered via the environment variable and
-//! could be read from it with the [`EventLoopExtStartupNotify::read_token_from_env`].
-//!
-//! Such token must also be reset after reading it from your environment with
-//! [`reset_activation_token_env`] otherwise child processes could inherit it.
-//!
-//! When starting a new child process with a newly obtained [`ActivationToken`] from
-//! [`WindowExtStartupNotify::request_activation_token`] the [`set_activation_token_env`]
-//! must be used to propagate it to the child
-//!
-//! To ensure the delivery of such token by other processes to you, the user should
-//! set `StartupNotify=true` inside the `.desktop` file of their application.
-//!
-//! The specification could be found [`here`].
-//!
-//! [`here`]: https://specifications.freedesktop.org/startup-notification-spec/startup-notification-latest.txt
-
-use std::env;
-
-use crate::error::NotSupportedError;
-use crate::event_loop::{AsyncRequestSerial, EventLoopWindowTarget};
-use crate::window::{ActivationToken, Window, WindowBuilder};
-
-/// The variable which is used mostly on X11.
-const X11_VAR: &str = "DESKTOP_STARTUP_ID";
-
-/// The variable which is used mostly on Wayland.
-const WAYLAND_VAR: &str = "XDG_ACTIVATION_TOKEN";
-
-pub trait EventLoopExtStartupNotify {
-    /// Read the token from the environment.
-    ///
-    /// It's recommended **to unset** this environment variable for child processes.
-    fn read_token_from_env(&self) -> Option<ActivationToken>;
-}
-
-pub trait WindowExtStartupNotify {
-    /// Request a new activation token.
-    ///
-    /// The token will be delivered inside
-    fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError>;
-}
-
-pub trait WindowBuilderExtStartupNotify {
-    /// Use this [`ActivationToken`] during window creation.
-    ///
-    /// Not using such a token upon a window could make your window not gaining
-    /// focus until the user clicks on the window.
-    fn with_activation_token(self, token: ActivationToken) -> Self;
-}
-
-impl<T> EventLoopExtStartupNotify for EventLoopWindowTarget<T> {
-    fn read_token_from_env(&self) -> Option<ActivationToken> {
-        match self.p {
-            #[cfg(wayland_platform)]
-            crate::platform_impl::EventLoopWindowTarget::Wayland(_) => env::var(WAYLAND_VAR),
-            #[cfg(x11_platform)]
-            crate::platform_impl::EventLoopWindowTarget::X(_) => env::var(X11_VAR),
-        }
-        .ok()
-        .map(ActivationToken::_new)
-    }
-}
-
-impl WindowExtStartupNotify for Window {
-    fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError> {
-        self.window.request_activation_token()
-    }
-}
-
-impl WindowBuilderExtStartupNotify for WindowBuilder {
-    fn with_activation_token(mut self, token: ActivationToken) -> Self {
-        self.platform_specific.activation_token = Some(token);
-        self
-    }
-}
-
-/// Remove the activation environment variables from the current process.
-///
-/// This is wise to do before running child processes,
-/// which may not to support the activation token.
-///
-/// # Safety
-///
-/// While the function is safe internally, it mutates the global environment
-/// state for the process, hence unsafe.
-pub unsafe fn reset_activation_token_env() {
-    env::remove_var(X11_VAR);
-    env::remove_var(WAYLAND_VAR);
-}
-
-/// Set environment variables responsible for activation token.
-///
-/// This could be used before running daemon processes.
-///
-/// # Safety
-///
-/// While the function is safe internally, it mutates the global environment
-/// state for the process, hence unsafe.
-pub unsafe fn set_activation_token_env(token: ActivationToken) {
-    env::set_var(X11_VAR, &token._token);
-    env::set_var(WAYLAND_VAR, token._token);
-}

src/platform/wayland.rs

@@ -1,10 +1,15 @@
+use std::os::raw;
+
 use crate::{
     event_loop::{EventLoopBuilder, EventLoopWindowTarget},
     monitor::MonitorHandle,
     window::{Window, WindowBuilder},
 };
 
-use crate::platform_impl::{ApplicationName, Backend};
+use crate::platform_impl::{
+    ApplicationName, Backend, EventLoopWindowTarget as LinuxEventLoopWindowTarget,
+    Window as LinuxWindow,
+};
 
 pub use crate::window::Theme;
 
@@ -12,6 +17,16 @@ pub use crate::window::Theme;
 pub trait EventLoopWindowTargetExtWayland {
     /// True if the [`EventLoopWindowTarget`] uses Wayland.
     fn is_wayland(&self) -> bool;
+
+    /// Returns a pointer to the `wl_display` object of wayland that is used by this
+    /// [`EventLoopWindowTarget`].
+    ///
+    /// Returns `None` if the [`EventLoop`] doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the winit [`EventLoop`] is destroyed.
+    ///
+    /// [`EventLoop`]: crate::event_loop::EventLoop
+    fn wayland_display(&self) -> Option<*mut raw::c_void>;
 }
 
 impl<T> EventLoopWindowTargetExtWayland for EventLoopWindowTarget<T> {
@@ -19,6 +34,17 @@ impl<T> EventLoopWindowTargetExtWayland for EventLoopWindowTarget<T> {
     fn is_wayland(&self) -> bool {
         self.p.is_wayland()
     }
+
+    #[inline]
+    fn wayland_display(&self) -> Option<*mut raw::c_void> {
+        match self.p {
+            LinuxEventLoopWindowTarget::Wayland(ref p) => {
+                Some(p.display().get_display_ptr() as *mut _)
+            }
+            #[cfg(x11_platform)]
+            _ => None,
+        }
+    }
 }
 
 /// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
@@ -48,9 +74,41 @@ impl<T> EventLoopBuilderExtWayland for EventLoopBuilder<T> {
 }
 
 /// Additional methods on [`Window`] that are specific to Wayland.
-pub trait WindowExtWayland {}
+pub trait WindowExtWayland {
+    /// Returns a pointer to the `wl_surface` object of wayland that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn wayland_surface(&self) -> Option<*mut raw::c_void>;
 
-impl WindowExtWayland for Window {}
+    /// Returns a pointer to the `wl_display` object of wayland that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn wayland_display(&self) -> Option<*mut raw::c_void>;
+}
+
+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 _),
+            #[cfg(x11_platform)]
+            _ => None,
+        }
+    }
+
+    #[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 _),
+            #[cfg(x11_platform)]
+            _ => None,
+        }
+    }
+}
 
 /// Additional methods on [`WindowBuilder`] that are specific to Wayland.
 pub trait WindowBuilderExtWayland {

src/platform/web.rs

@@ -2,58 +2,23 @@
 //! allow end users to determine how the page should be laid out. Use the [`WindowExtWebSys`] trait
 //! to retrieve the canvas from the Window. Alternatively, use the [`WindowBuilderExtWebSys`] trait
 //! to provide your own canvas.
-//!
-//! It is recommended **not** to apply certain CSS properties to the canvas:
-//! - [`transform`]
-//! - [`border`]
-//! - [`padding`]
-//!
-//! The following APIs can't take them into account and will therefore provide inaccurate results:
-//! - [`WindowEvent::Resized`] and [`Window::(set_)inner_size()`]
-//! - [`WindowEvent::Occluded`]
-//! - [`WindowEvent::CursorMoved`], [`WindowEvent::CursorEntered`], [`WindowEvent::CursorLeft`],
-//!   and [`WindowEvent::Touch`].
-//! - [`Window::set_outer_position()`]
-//!
-//! [`WindowEvent::Resized`]: crate::event::WindowEvent::Resized
-//! [`Window::(set_)inner_size()`]: crate::window::Window::inner_size()
-//! [`WindowEvent::Occluded`]: crate::event::WindowEvent::Occluded
-//! [`WindowEvent::CursorMoved`]: crate::event::WindowEvent::CursorMoved
-//! [`WindowEvent::CursorEntered`]: crate::event::WindowEvent::CursorEntered
-//! [`WindowEvent::CursorLeft`]: crate::event::WindowEvent::CursorLeft
-//! [`WindowEvent::Touch`]: crate::event::WindowEvent::Touch
-//! [`Window::set_outer_position()`]: crate::window::Window::set_outer_position()
-//! [`transform`]: https://developer.mozilla.org/en-US/docs/Web/CSS/transform
-//! [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
-//! [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
 
 use crate::event::Event;
 use crate::event_loop::ControlFlow;
 use crate::event_loop::EventLoop;
 use crate::event_loop::EventLoopWindowTarget;
-use crate::window::{Window, WindowBuilder};
+use crate::window::WindowBuilder;
 
 use web_sys::HtmlCanvasElement;
 
 pub trait WindowExtWebSys {
-    /// Only returns the canvas if called from inside the window.
-    fn canvas(&self) -> Option<HtmlCanvasElement>;
-}
+    fn canvas(&self) -> HtmlCanvasElement;
 
-impl WindowExtWebSys for Window {
-    #[inline]
-    fn canvas(&self) -> Option<HtmlCanvasElement> {
-        self.window.canvas()
-    }
+    /// Whether the browser reports the preferred color scheme to be "dark".
+    fn is_dark_mode(&self) -> bool;
 }
 
 pub trait WindowBuilderExtWebSys {
-    /// Pass an [`HtmlCanvasElement`] to be used for this [`Window`](crate::window::Window). If
-    /// [`None`], [`WindowBuilder::build()`] will create one.
-    ///
-    /// In any case, the canvas won't be automatically inserted into the web page.
-    ///
-    /// [`None`] by default.
     fn with_canvas(self, canvas: Option<HtmlCanvasElement>) -> Self;
 
     /// Whether `event.preventDefault` should be automatically called to prevent event propagation
@@ -61,23 +26,11 @@ 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.
-    ///
-    /// Enabled by default.
     fn with_prevent_default(self, prevent_default: bool) -> Self;
 
     /// Whether the canvas should be focusable using the tab key. This is necessary to capture
     /// canvas keyboard events.
-    ///
-    /// Enabled by default.
     fn with_focusable(self, focusable: bool) -> Self;
-
-    /// On window creation, append the canvas element to the web page if it isn't already.
-    ///
-    /// Disabled by default.
-    fn with_append(self, append: bool) -> Self;
 }
 
 impl WindowBuilderExtWebSys for WindowBuilder {
@@ -98,12 +51,6 @@ impl WindowBuilderExtWebSys for WindowBuilder {
 
         self
     }
-
-    fn with_append(mut self, append: bool) -> Self {
-        self.platform_specific.append = append;
-
-        self
-    }
 }
 
 /// Additional methods on `EventLoop` that are specific to the web.
@@ -115,15 +62,14 @@ 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
-            + FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow);
+            + FnMut(
+                Event<'_, Self::UserEvent>,
+                &EventLoopWindowTarget<Self::UserEvent>,
+                &mut ControlFlow,
+            );
 }
 
 impl<T> EventLoopExtWebSys for EventLoop<T> {
@@ -132,7 +78,11 @@ impl<T> EventLoopExtWebSys for EventLoop<T> {
     fn spawn<F>(self, event_handler: F)
     where
         F: 'static
-            + FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow),
+            + FnMut(
+                Event<'_, Self::UserEvent>,
+                &EventLoopWindowTarget<Self::UserEvent>,
+                &mut ControlFlow,
+            ),
     {
         self.event_loop.spawn(event_handler)
     }

src/platform/windows.rs

@@ -2,11 +2,9 @@ use std::{ffi::c_void, path::Path};
 
 use crate::{
     dpi::PhysicalSize,
-    event::{DeviceId, KeyEvent},
+    event::DeviceId,
     event_loop::EventLoopBuilder,
-    keyboard::Key,
     monitor::MonitorHandle,
-    platform::modifier_supplement::KeyEventExtModifierSupplement,
     platform_impl::WinIcon,
     window::{BadIcon, Icon, Window, WindowBuilder},
 };
@@ -17,6 +15,8 @@ pub type HWND = isize;
 pub type HMENU = isize;
 /// Monitor Handle type used by Win32 API
 pub type HMONITOR = isize;
+/// Instance Handle type used by Win32 API
+pub type HINSTANCE = isize;
 
 /// Additional methods on `EventLoop` that are specific to Windows.
 pub trait EventLoopBuilderExtWindows {
@@ -111,6 +111,13 @@ impl<T> EventLoopBuilderExtWindows for EventLoopBuilder<T> {
 
 /// Additional methods on `Window` that are specific to Windows.
 pub trait WindowExtWindows {
+    /// Returns the HINSTANCE of the window
+    fn hinstance(&self) -> HINSTANCE;
+    /// Returns the native handle that is used by this window.
+    ///
+    /// The pointer will become invalid when the native window was destroyed.
+    fn hwnd(&self) -> HWND;
+
     /// Enables or disables mouse and keyboard input to the specified window.
     ///
     /// A window must be enabled before it can be activated.
@@ -139,6 +146,16 @@ pub trait WindowExtWindows {
 }
 
 impl WindowExtWindows for Window {
+    #[inline]
+    fn hinstance(&self) -> HINSTANCE {
+        self.window.hinstance()
+    }
+
+    #[inline]
+    fn hwnd(&self) -> HWND {
+        self.window.hwnd()
+    }
+
     #[inline]
     fn set_enable(&self, enabled: bool) {
         self.window.set_enable(enabled)
@@ -204,9 +221,6 @@ pub trait WindowBuilderExtWindows {
     /// Whether show or hide the window icon in the taskbar.
     fn with_skip_taskbar(self, skip: bool) -> WindowBuilder;
 
-    /// Customize the window class name.
-    fn with_class_name<S: Into<String>>(self, class_name: S) -> WindowBuilder;
-
     /// Shows or hides the background drop shadow for undecorated windows.
     ///
     /// The shadow is hidden by default.
@@ -251,12 +265,6 @@ impl WindowBuilderExtWindows for WindowBuilder {
         self
     }
 
-    #[inline]
-    fn with_class_name<S: Into<String>>(mut self, class_name: S) -> WindowBuilder {
-        self.platform_specific.class_name = class_name.into();
-        self
-    }
-
     #[inline]
     fn with_undecorated_shadow(mut self, shadow: bool) -> WindowBuilder {
         self.platform_specific.decoration_shadow = shadow;
@@ -336,18 +344,3 @@ 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()
-    }
-}

src/platform/x11.rs

@@ -1,3 +1,6 @@
+use std::os::raw;
+use std::ptr;
+
 use crate::{
     event_loop::{EventLoopBuilder, EventLoopWindowTarget},
     monitor::MonitorHandle,
@@ -5,7 +8,9 @@ use crate::{
 };
 
 use crate::dpi::Size;
-use crate::platform_impl::{ApplicationName, Backend, XLIB_ERROR_HOOKS};
+use crate::platform_impl::{
+    x11::ffi::XVisualInfo, ApplicationName, Backend, Window as LinuxWindow, XLIB_ERROR_HOOKS,
+};
 
 pub use crate::platform_impl::{x11::util::WindowType as XWindowType, XNotSupported};
 
@@ -17,12 +22,6 @@ pub use crate::platform_impl::{x11::util::WindowType as XWindowType, XNotSupport
 pub type XlibErrorHook =
     Box<dyn Fn(*mut std::ffi::c_void, *mut std::ffi::c_void) -> bool + Send + Sync>;
 
-/// A unique identifer for an X11 visual.
-pub type XVisualID = u32;
-
-/// A unique identifier for an X11 window.
-pub type XWindow = u32;
-
 /// Hook to winit's xlib error handling callback.
 ///
 /// This method is provided as a safe way to handle the errors comming from X11
@@ -82,14 +81,70 @@ impl<T> EventLoopBuilderExtX11 for EventLoopBuilder<T> {
 }
 
 /// Additional methods on [`Window`] that are specific to X11.
-pub trait WindowExtX11 {}
+pub trait WindowExtX11 {
+    /// Returns the ID of the [`Window`] xlib object that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+    fn xlib_window(&self) -> Option<raw::c_ulong>;
 
-impl WindowExtX11 for Window {}
+    /// Returns a pointer to the `Display` object of xlib that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn xlib_display(&self) -> Option<*mut raw::c_void>;
+
+    fn xlib_screen_id(&self) -> Option<raw::c_int>;
+
+    /// This function returns the underlying `xcb_connection_t` of an xlib `Display`.
+    ///
+    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn xcb_connection(&self) -> Option<*mut raw::c_void>;
+}
+
+impl WindowExtX11 for Window {
+    #[inline]
+    fn xlib_window(&self) -> Option<raw::c_ulong> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_window()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn xlib_display(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_display()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn xlib_screen_id(&self) -> Option<raw::c_int> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_screen_id()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn xcb_connection(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xcb_connection()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+}
 
 /// Additional methods on [`WindowBuilder`] that are specific to X11.
 pub trait WindowBuilderExtX11 {
-    /// Create this window with a specific X11 visual.
-    fn with_x11_visual(self, visual_id: XVisualID) -> Self;
+    fn with_x11_visual<T>(self, visual_infos: *const T) -> Self;
 
     fn with_x11_screen(self, screen_id: i32) -> Self;
 
@@ -121,35 +176,21 @@ pub trait WindowBuilderExtX11 {
     /// WindowBuilder::new().with_base_size(PhysicalSize::new(400, 200));
     /// ```
     fn with_base_size<S: Into<Size>>(self, base_size: S) -> Self;
-
-    /// Embed this window into another parent window.
-    ///
-    /// # Example
-    ///
-    /// ```no_run
-    /// use winit::window::WindowBuilder;
-    /// use winit::platform::x11::{XWindow, WindowBuilderExtX11};
-    /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// let event_loop = winit::event_loop::EventLoop::new().unwrap();
-    /// let parent_window_id = std::env::args().nth(1).unwrap().parse::<XWindow>()?;
-    /// let window = WindowBuilder::new()
-    ///     .with_embed_parent_window(parent_window_id)
-    ///     .build(&event_loop)?;
-    /// # Ok(()) }
-    /// ```
-    fn with_embed_parent_window(self, parent_window_id: XWindow) -> Self;
 }
 
 impl WindowBuilderExtX11 for WindowBuilder {
     #[inline]
-    fn with_x11_visual(mut self, visual_id: XVisualID) -> Self {
-        self.platform_specific.x11.visual_id = Some(visual_id);
+    fn with_x11_visual<T>(mut self, visual_infos: *const T) -> Self {
+        {
+            self.platform_specific.visual_infos =
+                Some(unsafe { ptr::read(visual_infos as *const XVisualInfo) });
+        }
         self
     }
 
     #[inline]
     fn with_x11_screen(mut self, screen_id: i32) -> Self {
-        self.platform_specific.x11.screen_id = Some(screen_id);
+        self.platform_specific.screen_id = Some(screen_id);
         self
     }
 
@@ -161,25 +202,19 @@ impl WindowBuilderExtX11 for WindowBuilder {
 
     #[inline]
     fn with_override_redirect(mut self, override_redirect: bool) -> Self {
-        self.platform_specific.x11.override_redirect = override_redirect;
+        self.platform_specific.override_redirect = override_redirect;
         self
     }
 
     #[inline]
     fn with_x11_window_type(mut self, x11_window_types: Vec<XWindowType>) -> Self {
-        self.platform_specific.x11.x11_window_types = x11_window_types;
+        self.platform_specific.x11_window_types = x11_window_types;
         self
     }
 
     #[inline]
     fn with_base_size<S: Into<Size>>(mut self, base_size: S) -> Self {
-        self.platform_specific.x11.base_size = Some(base_size.into());
-        self
-    }
-
-    #[inline]
-    fn with_embed_parent_window(mut self, parent_window_id: XWindow) -> Self {
-        self.platform_specific.x11.embed_window = Some(parent_window_id);
+        self.platform_specific.base_size = Some(base_size.into());
         self
     }
 }

src/platform_impl/android/keycodes.rs

@@ -1,605 +0,0 @@
-use android_activity::{
-    input::{KeyAction, KeyEvent, KeyMapChar, Keycode},
-    AndroidApp,
-};
-
-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())),
-    }
-}
-
-/// Tries to map the `key_event` to a `KeyMapChar` containing a unicode character or dead key accent
-///
-/// This takes a `KeyEvent` and looks up its corresponding `KeyCharacterMap` and
-/// uses that to try and map the `key_code` + `meta_state` to a unicode
-/// character or a dead key that can be combined with the next key press.
-pub fn character_map_and_combine_key(
-    app: &AndroidApp,
-    key_event: &KeyEvent<'_>,
-    combining_accent: &mut Option<char>,
-) -> Option<KeyMapChar> {
-    let device_id = key_event.device_id();
-
-    let key_map = match app.device_key_character_map(device_id) {
-        Ok(key_map) => key_map,
-        Err(err) => {
-            log::warn!("Failed to look up `KeyCharacterMap` for device {device_id}: {err:?}");
-            return None;
-        }
-    };
-
-    match key_map.get(key_event.key_code(), key_event.meta_state()) {
-        Ok(KeyMapChar::Unicode(unicode)) => {
-            // Only do dead key combining on key down
-            if key_event.action() == KeyAction::Down {
-                let combined_unicode = if let Some(accent) = combining_accent {
-                    match key_map.get_dead_char(*accent, unicode) {
-                        Ok(Some(key)) => Some(key),
-                        Ok(None) => None,
-                        Err(err) => {
-                            log::warn!("KeyEvent: Failed to combine 'dead key' accent '{accent}' with '{unicode}': {err:?}");
-                            None
-                        }
-                    }
-                } else {
-                    Some(unicode)
-                };
-                *combining_accent = None;
-                combined_unicode.map(KeyMapChar::Unicode)
-            } else {
-                Some(KeyMapChar::Unicode(unicode))
-            }
-        }
-        Ok(KeyMapChar::CombiningAccent(accent)) => {
-            if key_event.action() == KeyAction::Down {
-                *combining_accent = Some(accent);
-            }
-            Some(KeyMapChar::CombiningAccent(accent))
-        }
-        Ok(KeyMapChar::None) => {
-            // Leave any combining_accent state in tact (seems to match how other
-            // Android apps work)
-            None
-        }
-        Err(err) => {
-            log::warn!("KeyEvent: Failed to get key map character: {err:?}");
-            *combining_accent = None;
-            None
-        }
-    }
-}
-
-pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
-    use android_activity::input::Keycode::*;
-
-    let native = NativeKey::Android(keycode.into());
-
-    match key_char {
-        Some(KeyMapChar::Unicode(c)) => {
-            Key::Character(smol_str::SmolStr::from_iter([c].into_iter()))
-        }
-        Some(KeyMapChar::CombiningAccent(c)) => Key::Dead(Some(c)),
-        None | Some(KeyMapChar::None) => match keycode {
-            // Using `BrowserHome` instead of `GoHome` according to
-            // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
-            Home => Key::BrowserHome,
-            Back => Key::BrowserBack,
-            Call => Key::Call,
-            Endcall => Key::EndCall,
-
-            //-------------------------------------------------------------------------------
-            // These should be redundant because they should have already been matched
-            // as `KeyMapChar::Unicode`, but also matched here as a fallback
-            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,
-
-            Notification => Key::Notification,
-            Search => Key::BrowserSearch,
-            MediaPlayPause => Key::MediaPlayPause,
-            MediaStop => Key::MediaStop,
-            MediaNext => Key::MediaTrackNext,
-            MediaPrevious => Key::MediaTrackPrevious,
-            MediaRewind => Key::MediaRewind,
-            MediaFastForward => Key::MediaFastForward,
-            Mute => Key::MicrophoneVolumeMute,
-            PageUp => Key::PageUp,
-            PageDown => Key::PageDown,
-
-            Escape => Key::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,
-            Guide => Key::Guide,
-            Dvr => Key::DVR,
-            Bookmark => Key::BrowserFavorites,
-            Captions => Key::ClosedCaptionToggle,
-            Settings => Key::Settings,
-            TvPower => Key::TVPower,
-            TvInput => Key::TVInput,
-            StbPower => Key::STBPower,
-            StbInput => Key::STBInput,
-            AvrPower => Key::AVRPower,
-            AvrInput => Key::AVRInput,
-            ProgRed => Key::ColorF0Red,
-            ProgGreen => Key::ColorF1Green,
-            ProgYellow => Key::ColorF2Yellow,
-            ProgBlue => Key::ColorF3Blue,
-            AppSwitch => Key::AppSwitch,
-            LanguageSwitch => Key::GroupNext,
-            MannerMode => Key::MannerMode,
-            Keycode3dMode => Key::TV3DMode,
-            Contacts => Key::LaunchContacts,
-            Calendar => Key::LaunchCalendar,
-            Music => Key::LaunchMusicPlayer,
-            Calculator => Key::LaunchApplication2,
-            ZenkakuHankaku => Key::ZenkakuHankaku,
-            Eisu => Key::Eisu,
-            Muhenkan => Key::NonConvert,
-            Henkan => Key::Convert,
-            KatakanaHiragana => Key::HiraganaKatakana,
-            Kana => Key::KanjiMode,
-            BrightnessDown => Key::BrightnessDown,
-            BrightnessUp => Key::BrightnessUp,
-            MediaAudioTrack => Key::MediaAudioTrack,
-            Sleep => Key::Standby,
-            Wakeup => Key::WakeUp,
-            Pairing => Key::Pairing,
-            MediaTopMenu => Key::MediaTopMenu,
-            LastChannel => Key::MediaLast,
-            TvDataService => Key::TVDataService,
-            VoiceAssist => Key::VoiceDial,
-            TvRadioService => Key::TVRadioService,
-            TvTeletext => Key::Teletext,
-            TvNumberEntry => Key::TVNumberEntry,
-            TvTerrestrialAnalog => Key::TVTerrestrialAnalog,
-            TvTerrestrialDigital => Key::TVTerrestrialDigital,
-            TvSatellite => Key::TVSatellite,
-            TvSatelliteBs => Key::TVSatelliteBS,
-            TvSatelliteCs => Key::TVSatelliteCS,
-            TvSatelliteService => Key::TVSatelliteToggle,
-            TvNetwork => Key::TVNetwork,
-            TvAntennaCable => Key::TVAntennaCable,
-            TvInputHdmi1 => Key::TVInputHDMI1,
-            TvInputHdmi2 => Key::TVInputHDMI2,
-            TvInputHdmi3 => Key::TVInputHDMI3,
-            TvInputHdmi4 => Key::TVInputHDMI4,
-            TvInputComposite1 => Key::TVInputComposite1,
-            TvInputComposite2 => Key::TVInputComposite2,
-            TvInputComponent1 => Key::TVInputComponent1,
-            TvInputComponent2 => Key::TVInputComponent2,
-            TvInputVga1 => Key::TVInputVGA1,
-            TvAudioDescription => Key::TVAudioDescription,
-            TvAudioDescriptionMixUp => Key::TVAudioDescriptionMixUp,
-            TvAudioDescriptionMixDown => Key::TVAudioDescriptionMixDown,
-            TvZoomMode => Key::ZoomToggle,
-            TvContentsMenu => Key::TVContentsMenu,
-            TvMediaContextMenu => Key::TVMediaContext,
-            TvTimerProgramming => Key::TVTimer,
-            Help => Key::Help,
-            NavigatePrevious => Key::NavigatePrevious,
-            NavigateNext => Key::NavigateNext,
-            NavigateIn => Key::NavigateIn,
-            NavigateOut => Key::NavigateOut,
-            MediaSkipForward => Key::MediaSkipForward,
-            MediaSkipBackward => Key::MediaSkipBackward,
-            MediaStepForward => Key::MediaStepForward,
-            MediaStepBackward => Key::MediaStepBackward,
-            Cut => Key::Cut,
-            Copy => Key::Copy,
-            Paste => Key::Paste,
-            Refresh => Key::BrowserRefresh,
-
-            // -----------------------------------------------------------------
-            // Keycodes that don't have a logical Key mapping
-            // -----------------------------------------------------------------
-            Unknown => Key::Unidentified(native),
-
-            // Can be added on demand
-            SoftLeft => Key::Unidentified(native),
-            SoftRight => Key::Unidentified(native),
-
-            Menu => Key::Unidentified(native),
-
-            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),
-            // -----------------------------------------------------------------
-            Window => Key::Unidentified(native),
-
-            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),
-
-            Yen => Key::Unidentified(native),
-            Ro => Key::Unidentified(native),
-
-            Assist => Key::Unidentified(native),
-
-            Keycode11 => Key::Unidentified(native),
-            Keycode12 => Key::Unidentified(native),
-
-            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),
-
-            SoftSleep => Key::Unidentified(native),
-
-            SystemNavigationUp => Key::Unidentified(native),
-            SystemNavigationDown => Key::Unidentified(native),
-            SystemNavigationLeft => Key::Unidentified(native),
-            SystemNavigationRight => Key::Unidentified(native),
-
-            AllApps => Key::Unidentified(native),
-            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,
-    }
-}

src/platform_impl/ios/app_state.rs

@@ -6,7 +6,6 @@ use std::{
     mem,
     os::raw::c_void,
     ptr,
-    sync::{Arc, Mutex},
     time::Instant,
 };
 
@@ -16,9 +15,9 @@ use core_foundation::runloop::{
     kCFRunLoopCommonModes, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
     CFRunLoopTimerInvalidate, CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate,
 };
-use icrate::Foundation::{CGRect, CGSize, NSInteger, NSOperatingSystemVersion, NSProcessInfo};
-use objc2::rc::Id;
-use objc2::runtime::AnyObject;
+use objc2::foundation::{CGRect, CGSize, NSInteger, NSProcessInfo};
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Object;
 use objc2::{msg_send, sel};
 use once_cell::sync::Lazy;
 
@@ -26,9 +25,12 @@ use super::uikit::UIView;
 use super::view::WinitUIWindow;
 use crate::{
     dpi::LogicalSize,
-    event::{Event, InnerSizeWriter, StartCause, WindowEvent},
+    event::{Event, StartCause, WindowEvent},
     event_loop::ControlFlow,
-    platform_impl::platform::event_loop::{EventHandler, EventProxy, EventWrapper, Never},
+    platform_impl::platform::{
+        event_loop::{EventHandler, EventProxy, EventWrapper, Never},
+        ffi::NSOperatingSystemVersion,
+    },
     window::WindowId as RootWindowId,
 };
 
@@ -55,7 +57,7 @@ enum UserCallbackTransitionResult<'a> {
     },
 }
 
-impl Event<Never> {
+impl Event<'static, Never> {
     fn is_redraw(&self) -> bool {
         matches!(self, Event::RedrawRequested(_))
     }
@@ -66,25 +68,25 @@ impl Event<Never> {
 #[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"]
 enum AppStateImpl {
     NotLaunched {
-        queued_windows: Vec<Id<WinitUIWindow>>,
+        queued_windows: Vec<Id<WinitUIWindow, Shared>>,
         queued_events: Vec<EventWrapper>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
     },
     Launching {
-        queued_windows: Vec<Id<WinitUIWindow>>,
+        queued_windows: Vec<Id<WinitUIWindow, Shared>>,
         queued_events: Vec<EventWrapper>,
         queued_event_handler: Box<dyn EventHandler>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
     },
     ProcessingEvents {
         event_handler: Box<dyn EventHandler>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
         active_control_flow: ControlFlow,
     },
     // special state to deal with reentrancy and prevent mutable aliasing.
     InUserCallback {
         queued_events: Vec<EventWrapper>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
     },
     ProcessingRedraws {
         event_handler: Box<dyn EventHandler>,
@@ -202,7 +204,9 @@ impl AppState {
         });
     }
 
-    fn did_finish_launching_transition(&mut self) -> (Vec<Id<WinitUIWindow>>, Vec<EventWrapper>) {
+    fn did_finish_launching_transition(
+        &mut self,
+    ) -> (Vec<Id<WinitUIWindow, Shared>>, Vec<EventWrapper>) {
         let (windows, events, event_handler, queued_gpu_redraws) = match self.take_state() {
             AppStateImpl::Launching {
                 queued_windows,
@@ -359,7 +363,7 @@ impl AppState {
         }
     }
 
-    fn main_events_cleared_transition(&mut self) -> HashSet<Id<WinitUIWindow>> {
+    fn main_events_cleared_transition(&mut self) -> HashSet<Id<WinitUIWindow, Shared>> {
         let (event_handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
             AppStateImpl::ProcessingEvents {
                 event_handler,
@@ -389,6 +393,9 @@ impl AppState {
 
         let new = self.control_flow;
         match (old, new) {
+            (ControlFlow::Poll, ControlFlow::Poll) => self.set_state(AppStateImpl::PollFinished {
+                waiting_event_handler,
+            }),
             (ControlFlow::Wait, ControlFlow::Wait) => {
                 let start = Instant::now();
                 self.set_state(AppStateImpl::Waiting {
@@ -421,7 +428,6 @@ impl AppState {
                 });
                 self.waker.start_at(new_instant)
             }
-            // Unlike on macOS, handle Poll to Poll transition here to call the waker
             (_, ControlFlow::Poll) => {
                 self.set_state(AppStateImpl::PollFinished {
                     waiting_event_handler,
@@ -440,14 +446,17 @@ impl AppState {
     fn terminated_transition(&mut self) -> Box<dyn EventHandler> {
         match self.replace_state(AppStateImpl::Terminated) {
             AppStateImpl::ProcessingEvents { event_handler, .. } => event_handler,
-            s => bug!("`LoopExiting` happened while not processing events {:?}", s),
+            s => bug!(
+                "`LoopDestroyed` happened while not processing events {:?}",
+                s
+            ),
         }
     }
 }
 
 // requires main thread and window is a UIWindow
 // retains window
-pub(crate) unsafe fn set_key_window(window: &Id<WinitUIWindow>) {
+pub(crate) unsafe fn set_key_window(window: &Id<WinitUIWindow, Shared>) {
     let mut this = AppState::get_mut();
     match this.state_mut() {
         &mut AppStateImpl::NotLaunched {
@@ -470,7 +479,7 @@ pub(crate) unsafe fn set_key_window(window: &Id<WinitUIWindow>) {
 
 // requires main thread and window is a UIWindow
 // retains window
-pub(crate) unsafe fn queue_gl_or_metal_redraw(window: Id<WinitUIWindow>) {
+pub(crate) unsafe fn queue_gl_or_metal_redraw(window: Id<WinitUIWindow, Shared>) {
     let mut this = AppState::get_mut();
     match this.state_mut() {
         &mut AppStateImpl::NotLaunched {
@@ -535,7 +544,7 @@ pub unsafe fn did_finish_launching() {
         // completed. This may result in incorrect visual appearance.
         // ```
         let screen = window.screen();
-        let _: () = msg_send![&window, setScreen: ptr::null::<AnyObject>()];
+        let _: () = msg_send![&window, setScreen: ptr::null::<Object>()];
         window.setScreen(&screen);
 
         let controller = window.rootViewController();
@@ -749,18 +758,21 @@ pub unsafe fn handle_main_events_cleared() {
     };
     drop(this);
 
+    // User events are always sent out at the end of the "MainEventLoop"
     handle_user_events();
+    handle_nonuser_event(EventWrapper::StaticEvent(Event::MainEventsCleared));
 
     let mut this = AppState::get_mut();
-    let redraw_events: Vec<EventWrapper> = this
+    let mut redraw_events: Vec<EventWrapper> = this
         .main_events_cleared_transition()
         .into_iter()
         .map(|window| EventWrapper::StaticEvent(Event::RedrawRequested(RootWindowId(window.id()))))
         .collect();
+
+    redraw_events.push(EventWrapper::StaticEvent(Event::RedrawEventsCleared));
     drop(this);
 
     handle_nonuser_events(redraw_events);
-    handle_nonuser_event(EventWrapper::StaticEvent(Event::AboutToWait));
 }
 
 // requires main thread
@@ -775,7 +787,7 @@ pub unsafe fn terminated() {
     let mut control_flow = this.control_flow;
     drop(this);
 
-    event_handler.handle_nonuser_event(Event::LoopExiting, &mut control_flow)
+    event_handler.handle_nonuser_event(Event::LoopDestroyed, &mut control_flow)
 }
 
 fn handle_event_proxy(
@@ -803,27 +815,27 @@ fn handle_hidpi_proxy(
     mut control_flow: ControlFlow,
     suggested_size: LogicalSize<f64>,
     scale_factor: f64,
-    window: Id<WinitUIWindow>,
+    window: Id<WinitUIWindow, Shared>,
 ) {
-    let new_inner_size = Arc::new(Mutex::new(suggested_size.to_physical(scale_factor)));
+    let mut size = suggested_size.to_physical(scale_factor);
+    let new_inner_size = &mut size;
     let event = Event::WindowEvent {
         window_id: RootWindowId(window.id()),
         event: WindowEvent::ScaleFactorChanged {
             scale_factor,
-            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
+            new_inner_size,
         },
     };
     event_handler.handle_nonuser_event(event, &mut control_flow);
     let (view, screen_frame) = get_view_and_screen_frame(&window);
-    let physical_size = *new_inner_size.lock().unwrap();
-    drop(new_inner_size);
+    let physical_size = *new_inner_size;
     let logical_size = physical_size.to_logical(scale_factor);
     let size = CGSize::new(logical_size.width, logical_size.height);
     let new_frame: CGRect = CGRect::new(screen_frame.origin, size);
     view.setFrame(new_frame);
 }
 
-fn get_view_and_screen_frame(window: &WinitUIWindow) -> (Id<UIView>, CGRect) {
+fn get_view_and_screen_frame(window: &WinitUIWindow) -> (Id<UIView, Shared>, CGRect) {
     let view_controller = window.rootViewController().unwrap();
     let view = view_controller.view().unwrap();
     let bounds = window.bounds();
@@ -912,7 +924,7 @@ macro_rules! os_capabilities {
 
         impl From<NSOperatingSystemVersion> for OSCapabilities {
             fn from(os_version: NSOperatingSystemVersion) -> OSCapabilities {
-                $(let $name = meets_requirements(os_version, $major, $minor);)*
+                $(let $name = os_version.meets_requirements($major, $minor);)*
                 OSCapabilities { $($name,)* os_version, }
             }
         }
@@ -922,7 +934,7 @@ macro_rules! os_capabilities {
             pub fn $error_name(&self, extra_msg: &str) {
                 log::warn!(
                     concat!("`", $objc_call, "` requires iOS {}.{}+. This device is running iOS {}.{}.{}. {}"),
-                    $major, $minor, self.os_version.majorVersion, self.os_version.minorVersion, self.os_version.patchVersion,
+                    $major, $minor, self.os_version.major, self.os_version.minor, self.os_version.patch,
                     extra_msg
                 )
             }
@@ -950,18 +962,16 @@ os_capabilities! {
     force_touch: 9-0,
 }
 
-fn meets_requirements(
-    version: NSOperatingSystemVersion,
-    required_major: NSInteger,
-    required_minor: NSInteger,
-) -> bool {
-    (version.majorVersion, version.minorVersion) >= (required_major, required_minor)
+impl NSOperatingSystemVersion {
+    fn meets_requirements(&self, required_major: NSInteger, required_minor: NSInteger) -> bool {
+        (self.major, self.minor) >= (required_major, required_minor)
+    }
 }
 
 pub fn os_capabilities() -> OSCapabilities {
     static OS_CAPABILITIES: Lazy<OSCapabilities> = Lazy::new(|| {
         let version: NSOperatingSystemVersion = unsafe {
-            let process_info = NSProcessInfo::processInfo();
+            let process_info = NSProcessInfo::process_info();
             let atleast_ios_8: bool = msg_send![
                 &process_info,
                 respondsToSelector: sel!(operatingSystemVersion)
@@ -974,7 +984,7 @@ pub fn os_capabilities() -> OSCapabilities {
             //
             // The minimum required iOS version is likely to grow in the future.
             assert!(atleast_ios_8, "`winit` requires iOS version 8 or greater");
-            process_info.operatingSystemVersion()
+            msg_send![&process_info, operatingSystemVersion]
         };
         version.into()
     });

src/platform_impl/ios/event_loop.rs

@@ -14,14 +14,16 @@ use core_foundation::runloop::{
     CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext, CFRunLoopSourceCreate,
     CFRunLoopSourceInvalidate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
 };
-use icrate::Foundation::{MainThreadMarker, NSString};
-use objc2::rc::Id;
+use objc2::foundation::{MainThreadMarker, NSString};
+use objc2::rc::{Id, Shared};
 use objc2::ClassType;
 use raw_window_handle::{RawDisplayHandle, UiKitDisplayHandle};
 
+use super::uikit::{UIApplication, UIApplicationMain, UIDevice, UIScreen};
+use super::view::WinitUIWindow;
+use super::{app_state, monitor, view, MonitorHandle};
 use crate::{
     dpi::LogicalSize,
-    error::EventLoopError,
     event::Event,
     event_loop::{
         ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootEventLoopWindowTarget,
@@ -29,20 +31,16 @@ use crate::{
     platform::ios::Idiom,
 };
 
-use super::uikit::{UIApplication, UIApplicationMain, UIDevice, UIScreen};
-use super::view::WinitUIWindow;
-use super::{app_state, monitor, view, MonitorHandle};
-
 #[derive(Debug)]
 pub(crate) enum EventWrapper {
-    StaticEvent(Event<Never>),
+    StaticEvent(Event<'static, Never>),
     EventProxy(EventProxy),
 }
 
 #[derive(Debug, PartialEq)]
 pub(crate) enum EventProxy {
     DpiChangedProxy {
-        window: Id<WinitUIWindow>,
+        window: Id<WinitUIWindow, Shared>,
         suggested_size: LogicalSize<f64>,
         scale_factor: f64,
     },
@@ -77,9 +75,7 @@ pub struct EventLoop<T: 'static> {
 pub(crate) struct PlatformSpecificEventLoopAttributes {}
 
 impl<T: 'static> EventLoop<T> {
-    pub(crate) fn new(
-        _: &PlatformSpecificEventLoopAttributes,
-    ) -> Result<EventLoop<T>, EventLoopError> {
+    pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> EventLoop<T> {
         assert_main_thread!("`EventLoop` can only be created on the main thread on iOS");
 
         static mut SINGLETON_INIT: bool = false;
@@ -97,7 +93,7 @@ impl<T: 'static> EventLoop<T> {
         // this line sets up the main run loop before `UIApplicationMain`
         setup_control_flow_observers();
 
-        Ok(EventLoop {
+        EventLoop {
             window_target: RootEventLoopWindowTarget {
                 p: EventLoopWindowTarget {
                     receiver,
@@ -105,12 +101,12 @@ impl<T: 'static> EventLoop<T> {
                 },
                 _marker: PhantomData,
             },
-        })
+        }
     }
 
     pub fn run<F>(self, event_handler: F) -> !
     where
-        F: FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     {
         unsafe {
             let application = UIApplication::shared(MainThreadMarker::new().unwrap());
@@ -120,18 +116,10 @@ impl<T: 'static> EventLoop<T> {
                 `EventLoop` cannot be `run` after a call to `UIApplicationMain` on iOS\n\
                  Note: `EventLoop::run` calls `UIApplicationMain` on iOS",
             );
-
-            let event_handler = std::mem::transmute::<
-                Box<dyn FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow)>,
-                Box<EventHandlerCallback<T>>,
-            >(Box::new(event_handler));
-
-            let handler = EventLoopHandler {
+            app_state::will_launch(Box::new(EventLoopHandler {
                 f: event_handler,
                 event_loop: self.window_target,
-            };
-
-            app_state::will_launch(Box::new(handler));
+            }));
 
             // Ensure application delegate is initialized
             view::WinitApplicationDelegate::class();
@@ -249,10 +237,10 @@ fn setup_control_flow_observers() {
 
         // Core Animation registers its `CFRunLoopObserver` that performs drawing operations in
         // `CA::Transaction::ensure_implicit` with a priority of `0x1e8480`. We set the main_end
-        // priority to be 0, in order to send AboutToWait before RedrawRequested. This value was
+        // priority to be 0, in order to send MainEventsCleared before RedrawRequested. This value was
         // chosen conservatively to guard against apple using different priorities for their redraw
         // observers in different OS's or on different devices. If it so happens that it's too
-        // conservative, the main symptom would be non-redraw events coming in after `AboutToWait`.
+        // conservative, the main symptom would be non-redraw events coming in after `MainEventsCleared`.
         //
         // The value of `0x1e8480` was determined by inspecting stack traces and the associated
         // registers for every `CFRunLoopAddObserver` call on an iPad Air 2 running iOS 11.4.
@@ -326,20 +314,17 @@ fn setup_control_flow_observers() {
 #[derive(Debug)]
 pub enum Never {}
 
-type EventHandlerCallback<T> =
-    dyn FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow) + 'static;
-
 pub trait EventHandler: Debug {
-    fn handle_nonuser_event(&mut self, event: Event<Never>, control_flow: &mut ControlFlow);
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
     fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
 }
 
-struct EventLoopHandler<T: 'static> {
-    f: Box<EventHandlerCallback<T>>,
+struct EventLoopHandler<F, T: 'static> {
+    f: F,
     event_loop: RootEventLoopWindowTarget<T>,
 }
 
-impl<T: 'static> Debug for EventLoopHandler<T> {
+impl<F, T: 'static> Debug for EventLoopHandler<F, T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("EventLoopHandler")
             .field("event_loop", &self.event_loop)
@@ -347,8 +332,12 @@ impl<T: 'static> Debug for EventLoopHandler<T> {
     }
 }
 
-impl<T: 'static> EventHandler for EventLoopHandler<T> {
-    fn handle_nonuser_event(&mut self, event: Event<Never>, control_flow: &mut ControlFlow) {
+impl<F, T> EventHandler for EventLoopHandler<F, T>
+where
+    F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+    T: 'static,
+{
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
         (self.f)(
             event.map_nonuser_event().unwrap(),
             &self.event_loop,

src/platform_impl/ios/ffi.rs

@@ -2,11 +2,30 @@
 
 use std::convert::TryInto;
 
-use icrate::Foundation::{NSInteger, NSUInteger};
 use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{NSInteger, NSUInteger};
 
 use crate::platform::ios::{Idiom, ScreenEdge};
 
+#[repr(C)]
+#[derive(Clone, Debug)]
+pub struct NSOperatingSystemVersion {
+    pub major: NSInteger,
+    pub minor: NSInteger,
+    pub patch: NSInteger,
+}
+
+unsafe impl Encode for NSOperatingSystemVersion {
+    const ENCODING: Encoding = Encoding::Struct(
+        "NSOperatingSystemVersion",
+        &[
+            NSInteger::ENCODING,
+            NSInteger::ENCODING,
+            NSInteger::ENCODING,
+        ],
+    );
+}
+
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct UIUserInterfaceIdiom(NSInteger);
@@ -51,10 +70,6 @@ impl From<UIUserInterfaceIdiom> for Idiom {
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct UIRectEdge(NSUInteger);
 
-impl UIRectEdge {
-    pub(crate) const NONE: Self = Self(0);
-}
-
 unsafe impl Encode for UIRectEdge {
     const ENCODING: Encoding = NSUInteger::ENCODING;
 }

src/platform_impl/ios/mod.rs

@@ -48,12 +48,12 @@
 //!
 //!  - applicationDidBecomeActive is Resumed
 //!  - applicationWillResignActive is Suspended
-//!  - applicationWillTerminate is LoopExiting
+//!  - applicationWillTerminate is LoopDestroyed
 //!
-//! Keep in mind that after LoopExiting event is received every attempt to draw with
+//! Keep in mind that after LoopDestroyed event is received every attempt to draw with
 //! opengl will result in segfault.
 //!
-//! Also note that app may not receive the LoopExiting event if suspended; it might be SIGKILL'ed.
+//! Also note that app may not receive the LoopDestroyed event if suspended; it might be SIGKILL'ed.
 
 #![cfg(ios_platform)]
 #![allow(clippy::let_unit_value)]
@@ -63,7 +63,7 @@
 // window size/position.
 macro_rules! assert_main_thread {
     ($($t:tt)*) => {
-        if !::icrate::Foundation::is_main_thread() {
+        if !::objc2::foundation::is_main_thread() {
             panic!($($t)*);
         }
     };
@@ -89,7 +89,7 @@ pub(crate) use self::{
 
 use self::uikit::UIScreen;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
-pub(crate) use crate::platform_impl::Fullscreen;
+pub(self) use crate::platform_impl::Fullscreen;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId {
@@ -107,9 +107,6 @@ 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 {}
 

src/platform_impl/ios/monitor.rs

@@ -6,8 +6,8 @@ use std::{
     ops::{Deref, DerefMut},
 };
 
-use icrate::Foundation::{MainThreadMarker, NSInteger};
-use objc2::rc::Id;
+use objc2::foundation::{MainThreadMarker, NSInteger};
+use objc2::rc::{Id, Shared};
 
 use super::uikit::{UIScreen, UIScreenMode};
 use crate::{
@@ -18,7 +18,7 @@ use crate::{
 
 // TODO(madsmtm): Remove or refactor this
 #[derive(Debug, PartialEq, Eq, Hash, Clone)]
-pub(crate) struct ScreenModeSendSync(pub(crate) Id<UIScreenMode>);
+pub(crate) struct ScreenModeSendSync(pub(crate) Id<UIScreenMode, Shared>);
 
 unsafe impl Send for ScreenModeSendSync {}
 unsafe impl Sync for ScreenModeSendSync {}
@@ -33,7 +33,7 @@ pub struct VideoMode {
 }
 
 impl VideoMode {
-    fn new(uiscreen: Id<UIScreen>, screen_mode: Id<UIScreenMode>) -> VideoMode {
+    fn new(uiscreen: Id<UIScreen, Shared>, screen_mode: Id<UIScreenMode, Shared>) -> VideoMode {
         assert_main_thread!("`VideoMode` can only be created on the main thread on iOS");
         let refresh_rate_millihertz = refresh_rate_millihertz(&uiscreen);
         let size = screen_mode.size();
@@ -65,7 +65,7 @@ impl VideoMode {
 
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct Inner {
-    uiscreen: Id<UIScreen>,
+    uiscreen: Id<UIScreen, Shared>,
 }
 
 #[derive(Clone, PartialEq, Eq, Hash)]
@@ -135,7 +135,7 @@ impl fmt::Debug for MonitorHandle {
 }
 
 impl MonitorHandle {
-    pub(crate) fn new(uiscreen: Id<UIScreen>) -> Self {
+    pub(crate) fn new(uiscreen: Id<UIScreen, Shared>) -> Self {
         assert_main_thread!("`MonitorHandle` can only be created on the main thread on iOS");
         Self {
             inner: Inner { uiscreen },
@@ -182,8 +182,13 @@ impl Inner {
             .uiscreen
             .availableModes()
             .into_iter()
-            .map(|mode| RootVideoMode {
-                video_mode: VideoMode::new(self.uiscreen.clone(), mode),
+            .map(|mode| {
+                let mode: *const UIScreenMode = mode;
+                let mode = unsafe { Id::retain(mode as *mut UIScreenMode).unwrap() };
+
+                RootVideoMode {
+                    video_mode: VideoMode::new(self.uiscreen.clone(), mode),
+                }
             })
             .collect();
 
@@ -217,7 +222,7 @@ fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
 
 // MonitorHandleExtIOS
 impl Inner {
-    pub(crate) fn ui_screen(&self) -> &Id<UIScreen> {
+    pub(crate) fn ui_screen(&self) -> &Id<UIScreen, Shared> {
         &self.uiscreen
     }
 
@@ -232,6 +237,10 @@ impl Inner {
 pub fn uiscreens(mtm: MainThreadMarker) -> VecDeque<MonitorHandle> {
     UIScreen::screens(mtm)
         .into_iter()
-        .map(MonitorHandle::new)
+        .map(|screen| {
+            let screen: *const UIScreen = screen;
+            let screen = unsafe { Id::retain(screen as *mut UIScreen).unwrap() };
+            MonitorHandle::new(screen)
+        })
         .collect()
 }

src/platform_impl/ios/uikit/application.rs

@@ -1,6 +1,6 @@
-use icrate::Foundation::{CGRect, MainThreadMarker, NSArray, NSObject};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
+use objc2::foundation::{CGRect, MainThreadMarker, NSArray, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
 
 use super::{UIResponder, UIWindow};
 
@@ -11,21 +11,20 @@ extern_class!(
     unsafe impl ClassType for UIApplication {
         #[inherits(NSObject)]
         type Super = UIResponder;
-        type Mutability = mutability::InteriorMutable;
     }
 );
 
 extern_methods!(
     unsafe impl UIApplication {
-        pub fn shared(_mtm: MainThreadMarker) -> Option<Id<Self>> {
+        pub fn shared(_mtm: MainThreadMarker) -> Option<Id<Self, Shared>> {
             unsafe { msg_send_id![Self::class(), sharedApplication] }
         }
 
-        pub fn windows(&self) -> Id<NSArray<UIWindow>> {
+        pub fn windows(&self) -> Id<NSArray<UIWindow, Shared>, Shared> {
             unsafe { msg_send_id![self, windows] }
         }
 
-        #[method(statusBarFrame)]
+        #[sel(statusBarFrame)]
         pub fn statusBarFrame(&self) -> CGRect;
     }
 );

src/platform_impl/ios/uikit/coordinate_space.rs

@@ -1,5 +1,5 @@
-use icrate::Foundation::NSObject;
-use objc2::{extern_class, mutability, ClassType};
+use objc2::foundation::NSObject;
+use objc2::{extern_class, ClassType};
 
 extern_class!(
     #[derive(Debug, PartialEq, Eq, Hash)]
@@ -7,6 +7,5 @@ extern_class!(
 
     unsafe impl ClassType for UICoordinateSpace {
         type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
     }
 );

src/platform_impl/ios/uikit/device.rs

@@ -1,6 +1,6 @@
-use icrate::Foundation::{MainThreadMarker, NSObject};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
+use objc2::foundation::{MainThreadMarker, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
 
 use super::super::ffi::UIUserInterfaceIdiom;
 
@@ -10,17 +10,16 @@ extern_class!(
 
     unsafe impl ClassType for UIDevice {
         type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
     }
 );
 
 extern_methods!(
     unsafe impl UIDevice {
-        pub fn current(_mtm: MainThreadMarker) -> Id<Self> {
+        pub fn current(_mtm: MainThreadMarker) -> Id<Self, Shared> {
             unsafe { msg_send_id![Self::class(), currentDevice] }
         }
 
-        #[method(userInterfaceIdiom)]
+        #[sel(userInterfaceIdiom)]
         pub fn userInterfaceIdiom(&self) -> UIUserInterfaceIdiom;
     }
 );

src/platform_impl/ios/uikit/event.rs

@@ -1,5 +1,5 @@
-use icrate::Foundation::NSObject;
-use objc2::{extern_class, mutability, ClassType};
+use objc2::foundation::NSObject;
+use objc2::{extern_class, ClassType};
 
 extern_class!(
     #[derive(Debug, PartialEq, Eq, Hash)]
@@ -7,6 +7,5 @@ extern_class!(
 
     unsafe impl ClassType for UIEvent {
         type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
     }
 );

src/platform_impl/ios/uikit/mod.rs

@@ -4,7 +4,7 @@
 
 use std::os::raw::{c_char, c_int};
 
-use icrate::Foundation::NSString;
+use objc2::foundation::NSString;
 
 mod application;
 mod coordinate_space;

src/platform_impl/ios/uikit/responder.rs

@@ -1,5 +1,5 @@
-use icrate::Foundation::NSObject;
-use objc2::{extern_class, mutability, ClassType};
+use objc2::foundation::NSObject;
+use objc2::{extern_class, ClassType};
 
 extern_class!(
     #[derive(Debug, PartialEq, Eq, Hash)]
@@ -7,6 +7,5 @@ extern_class!(
 
     unsafe impl ClassType for UIResponder {
         type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
     }
 );

src/platform_impl/ios/uikit/screen.rs

@@ -1,7 +1,7 @@
-use icrate::Foundation::{CGFloat, CGRect, MainThreadMarker, NSArray, NSInteger, NSObject};
 use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
+use objc2::foundation::{CGFloat, CGRect, MainThreadMarker, NSArray, NSInteger, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
 
 use super::{UICoordinateSpace, UIScreenMode};
 
@@ -11,54 +11,53 @@ extern_class!(
 
     unsafe impl ClassType for UIScreen {
         type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
     }
 );
 
 extern_methods!(
     unsafe impl UIScreen {
-        pub fn main(_mtm: MainThreadMarker) -> Id<Self> {
+        pub fn main(_mtm: MainThreadMarker) -> Id<Self, Shared> {
             unsafe { msg_send_id![Self::class(), mainScreen] }
         }
 
-        pub fn screens(_mtm: MainThreadMarker) -> Id<NSArray<Self>> {
+        pub fn screens(_mtm: MainThreadMarker) -> Id<NSArray<Self, Shared>, Shared> {
             unsafe { msg_send_id![Self::class(), screens] }
         }
 
-        #[method(bounds)]
+        #[sel(bounds)]
         pub fn bounds(&self) -> CGRect;
 
-        #[method(scale)]
+        #[sel(scale)]
         pub fn scale(&self) -> CGFloat;
 
-        #[method(nativeBounds)]
+        #[sel(nativeBounds)]
         pub fn nativeBounds(&self) -> CGRect;
 
-        #[method(nativeScale)]
+        #[sel(nativeScale)]
         pub fn nativeScale(&self) -> CGFloat;
 
-        #[method(maximumFramesPerSecond)]
+        #[sel(maximumFramesPerSecond)]
         pub fn maximumFramesPerSecond(&self) -> NSInteger;
 
-        pub fn mirroredScreen(&self) -> Id<Self> {
+        pub fn mirroredScreen(&self) -> Id<Self, Shared> {
             unsafe { msg_send_id![Self::class(), mirroredScreen] }
         }
 
-        pub fn preferredMode(&self) -> Option<Id<UIScreenMode>> {
+        pub fn preferredMode(&self) -> Option<Id<UIScreenMode, Shared>> {
             unsafe { msg_send_id![self, preferredMode] }
         }
 
-        #[method(setCurrentMode:)]
+        #[sel(setCurrentMode:)]
         pub fn setCurrentMode(&self, mode: Option<&UIScreenMode>);
 
-        pub fn availableModes(&self) -> Id<NSArray<UIScreenMode>> {
+        pub fn availableModes(&self) -> Id<NSArray<UIScreenMode, Shared>, Shared> {
             unsafe { msg_send_id![self, availableModes] }
         }
 
-        #[method(setOverscanCompensation:)]
+        #[sel(setOverscanCompensation:)]
         pub fn setOverscanCompensation(&self, overscanCompensation: UIScreenOverscanCompensation);
 
-        pub fn coordinateSpace(&self) -> Id<UICoordinateSpace> {
+        pub fn coordinateSpace(&self) -> Id<UICoordinateSpace, Shared> {
             unsafe { msg_send_id![self, coordinateSpace] }
         }
     }

src/platform_impl/ios/uikit/screen_mode.rs

@@ -1,5 +1,5 @@
-use icrate::Foundation::{CGSize, NSObject};
-use objc2::{extern_class, extern_methods, mutability, ClassType};
+use objc2::foundation::{CGSize, NSObject};
+use objc2::{extern_class, extern_methods, ClassType};
 
 extern_class!(
     #[derive(Debug, PartialEq, Eq, Hash)]
@@ -7,13 +7,12 @@ extern_class!(
 
     unsafe impl ClassType for UIScreenMode {
         type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
     }
 );
 
 extern_methods!(
     unsafe impl UIScreenMode {
-        #[method(size)]
+        #[sel(size)]
         pub fn size(&self) -> CGSize;
     }
 );

src/platform_impl/ios/uikit/touch.rs

@@ -1,6 +1,6 @@
-use icrate::Foundation::{CGFloat, CGPoint, NSInteger, NSObject};
 use objc2::encode::{Encode, Encoding};
-use objc2::{extern_class, extern_methods, mutability, ClassType};
+use objc2::foundation::{CGFloat, CGPoint, NSInteger, NSObject};
+use objc2::{extern_class, extern_methods, ClassType};
 
 use super::UIView;
 
@@ -10,28 +10,27 @@ extern_class!(
 
     unsafe impl ClassType for UITouch {
         type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
     }
 );
 
 extern_methods!(
     unsafe impl UITouch {
-        #[method(locationInView:)]
+        #[sel(locationInView:)]
         pub fn locationInView(&self, view: Option<&UIView>) -> CGPoint;
 
-        #[method(type)]
+        #[sel(type)]
         pub fn type_(&self) -> UITouchType;
 
-        #[method(force)]
+        #[sel(force)]
         pub fn force(&self) -> CGFloat;
 
-        #[method(maximumPossibleForce)]
+        #[sel(maximumPossibleForce)]
         pub fn maximumPossibleForce(&self) -> CGFloat;
 
-        #[method(altitudeAngle)]
+        #[sel(altitudeAngle)]
         pub fn altitudeAngle(&self) -> CGFloat;
 
-        #[method(phase)]
+        #[sel(phase)]
         pub fn phase(&self) -> UITouchPhase;
     }
 );

src/platform_impl/ios/uikit/trait_collection.rs

@@ -1,6 +1,6 @@
-use icrate::Foundation::{NSInteger, NSObject};
 use objc2::encode::{Encode, Encoding};
-use objc2::{extern_class, extern_methods, mutability, ClassType};
+use objc2::foundation::{NSInteger, NSObject};
+use objc2::{extern_class, extern_methods, ClassType};
 
 extern_class!(
     #[derive(Debug, PartialEq, Eq, Hash)]
@@ -8,13 +8,12 @@ extern_class!(
 
     unsafe impl ClassType for UITraitCollection {
         type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
     }
 );
 
 extern_methods!(
     unsafe impl UITraitCollection {
-        #[method(forceTouchCapability)]
+        #[sel(forceTouchCapability)]
         pub fn forceTouchCapability(&self) -> UIForceTouchCapability;
     }
 );

src/platform_impl/ios/uikit/view.rs

@@ -1,7 +1,7 @@
-use icrate::Foundation::{CGFloat, CGRect, NSObject};
 use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
+use objc2::foundation::{CGFloat, CGRect, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
 
 use super::{UICoordinateSpace, UIResponder, UIViewController};
 
@@ -12,58 +12,57 @@ extern_class!(
     unsafe impl ClassType for UIView {
         #[inherits(NSObject)]
         type Super = UIResponder;
-        type Mutability = mutability::InteriorMutable;
     }
 );
 
 extern_methods!(
     unsafe impl UIView {
-        #[method(bounds)]
+        #[sel(bounds)]
         pub fn bounds(&self) -> CGRect;
 
-        #[method(setBounds:)]
+        #[sel(setBounds:)]
         pub fn setBounds(&self, value: CGRect);
 
-        #[method(frame)]
+        #[sel(frame)]
         pub fn frame(&self) -> CGRect;
 
-        #[method(setFrame:)]
+        #[sel(setFrame:)]
         pub fn setFrame(&self, value: CGRect);
 
-        #[method(contentScaleFactor)]
+        #[sel(contentScaleFactor)]
         pub fn contentScaleFactor(&self) -> CGFloat;
 
-        #[method(setContentScaleFactor:)]
+        #[sel(setContentScaleFactor:)]
         pub fn setContentScaleFactor(&self, val: CGFloat);
 
-        #[method(setMultipleTouchEnabled:)]
+        #[sel(setMultipleTouchEnabled:)]
         pub fn setMultipleTouchEnabled(&self, val: bool);
 
-        pub fn rootViewController(&self) -> Option<Id<UIViewController>> {
+        pub fn rootViewController(&self) -> Option<Id<UIViewController, Shared>> {
             unsafe { msg_send_id![self, rootViewController] }
         }
 
-        #[method(setRootViewController:)]
+        #[sel(setRootViewController:)]
         pub fn setRootViewController(&self, rootViewController: Option<&UIViewController>);
 
-        #[method(convertRect:toCoordinateSpace:)]
+        #[sel(convertRect:toCoordinateSpace:)]
         pub fn convertRect_toCoordinateSpace(
             &self,
             rect: CGRect,
             coordinateSpace: &UICoordinateSpace,
         ) -> CGRect;
 
-        #[method(convertRect:fromCoordinateSpace:)]
+        #[sel(convertRect:fromCoordinateSpace:)]
         pub fn convertRect_fromCoordinateSpace(
             &self,
             rect: CGRect,
             coordinateSpace: &UICoordinateSpace,
         ) -> CGRect;
 
-        #[method(safeAreaInsets)]
+        #[sel(safeAreaInsets)]
         pub fn safeAreaInsets(&self) -> UIEdgeInsets;
 
-        #[method(setNeedsDisplay)]
+        #[sel(setNeedsDisplay)]
         pub fn setNeedsDisplay(&self);
     }
 );

src/platform_impl/ios/uikit/view_controller.rs

@@ -1,7 +1,7 @@
-use icrate::Foundation::{NSObject, NSUInteger};
 use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
+use objc2::foundation::{NSObject, NSUInteger};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
 
 use super::{UIResponder, UIView};
 
@@ -12,35 +12,33 @@ extern_class!(
     unsafe impl ClassType for UIViewController {
         #[inherits(NSObject)]
         type Super = UIResponder;
-        type Mutability = mutability::InteriorMutable;
     }
 );
 
 extern_methods!(
     unsafe impl UIViewController {
-        #[method(attemptRotationToDeviceOrientation)]
+        #[sel(attemptRotationToDeviceOrientation)]
         pub fn attemptRotationToDeviceOrientation();
 
-        #[method(setNeedsStatusBarAppearanceUpdate)]
+        #[sel(setNeedsStatusBarAppearanceUpdate)]
         pub fn setNeedsStatusBarAppearanceUpdate(&self);
 
-        #[method(setNeedsUpdateOfHomeIndicatorAutoHidden)]
+        #[sel(setNeedsUpdateOfHomeIndicatorAutoHidden)]
         pub fn setNeedsUpdateOfHomeIndicatorAutoHidden(&self);
 
-        #[method(setNeedsUpdateOfScreenEdgesDeferringSystemGestures)]
+        #[sel(setNeedsUpdateOfScreenEdgesDeferringSystemGestures)]
         pub fn setNeedsUpdateOfScreenEdgesDeferringSystemGestures(&self);
 
-        pub fn view(&self) -> Option<Id<UIView>> {
+        pub fn view(&self) -> Option<Id<UIView, Shared>> {
             unsafe { msg_send_id![self, view] }
         }
 
-        #[method(setView:)]
+        #[sel(setView:)]
         pub fn setView(&self, view: Option<&UIView>);
     }
 );
 
 bitflags! {
-    #[derive(Clone, Copy)]
     pub struct UIInterfaceOrientationMask: NSUInteger {
         const Portrait = 1 << 1;
         const PortraitUpsideDown = 1 << 2;

src/platform_impl/ios/uikit/window.rs

@@ -1,6 +1,6 @@
-use icrate::Foundation::NSObject;
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
+use objc2::foundation::NSObject;
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
 
 use super::{UIResponder, UIScreen, UIView};
 
@@ -11,26 +11,25 @@ extern_class!(
     unsafe impl ClassType for UIWindow {
         #[inherits(UIResponder, NSObject)]
         type Super = UIView;
-        type Mutability = mutability::InteriorMutable;
     }
 );
 
 extern_methods!(
     unsafe impl UIWindow {
-        pub fn screen(&self) -> Id<UIScreen> {
+        pub fn screen(&self) -> Id<UIScreen, Shared> {
             unsafe { msg_send_id![self, screen] }
         }
 
-        #[method(setScreen:)]
+        #[sel(setScreen:)]
         pub fn setScreen(&self, screen: &UIScreen);
 
-        #[method(setHidden:)]
+        #[sel(setHidden:)]
         pub fn setHidden(&self, flag: bool);
 
-        #[method(makeKeyAndVisible)]
+        #[sel(makeKeyAndVisible)]
         pub fn makeKeyAndVisible(&self);
 
-        #[method(isKeyWindow)]
+        #[sel(isKeyWindow)]
         pub fn isKeyWindow(&self) -> bool;
     }
 );

src/platform_impl/ios/view.rs

@@ -1,12 +1,9 @@
 #![allow(clippy::unnecessary_cast)]
-use std::cell::Cell;
-use std::ptr::NonNull;
 
-use icrate::Foundation::{CGFloat, CGRect, MainThreadMarker, NSObject, NSObjectProtocol, NSSet};
-use objc2::declare::{Ivar, IvarDrop};
-use objc2::rc::Id;
-use objc2::runtime::AnyClass;
-use objc2::{declare_class, extern_methods, msg_send, msg_send_id, mutability, ClassType};
+use objc2::foundation::{CGFloat, CGRect, MainThreadMarker, NSObject, NSSet};
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Class;
+use objc2::{declare_class, extern_methods, msg_send, msg_send_id, ClassType};
 
 use super::uikit::{
     UIApplication, UIDevice, UIEvent, UIForceTouchCapability, UIInterfaceOrientationMask,
@@ -29,28 +26,32 @@ use crate::{
 };
 
 declare_class!(
-    pub(crate) struct WinitView;
+    pub(crate) struct WinitView {}
 
     unsafe impl ClassType for WinitView {
         #[inherits(UIResponder, NSObject)]
         type Super = UIView;
-        type Mutability = mutability::InteriorMutable;
         const NAME: &'static str = "WinitUIView";
     }
 
     unsafe impl WinitView {
-        #[method(drawRect:)]
+        #[sel(drawRect:)]
         fn draw_rect(&self, rect: CGRect) {
             let window = self.window().unwrap();
             unsafe {
-                app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(
-                    RootWindowId(window.id()),
-                )));
+                app_state::handle_nonuser_events(
+                    std::iter::once(EventWrapper::StaticEvent(Event::RedrawRequested(
+                        RootWindowId(window.id()),
+                    )))
+                    .chain(std::iter::once(EventWrapper::StaticEvent(
+                        Event::RedrawEventsCleared,
+                    ))),
+                );
             }
             let _: () = unsafe { msg_send![super(self), drawRect: rect] };
         }
 
-        #[method(layoutSubviews)]
+        #[sel(layoutSubviews)]
         fn layout_subviews(&self) {
             let _: () = unsafe { msg_send![super(self), layoutSubviews] };
 
@@ -82,7 +83,7 @@ declare_class!(
             }
         }
 
-        #[method(setContentScaleFactor:)]
+        #[sel(setContentScaleFactor:)]
         fn set_content_scale_factor(&self, untrusted_scale_factor: CGFloat) {
             let _: () =
                 unsafe { msg_send![super(self), setContentScaleFactor: untrusted_scale_factor] };
@@ -132,22 +133,22 @@ declare_class!(
             }
         }
 
-        #[method(touchesBegan:withEvent:)]
+        #[sel(touchesBegan:withEvent:)]
         fn touches_began(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
             self.handle_touches(touches)
         }
 
-        #[method(touchesMoved:withEvent:)]
+        #[sel(touchesMoved:withEvent:)]
         fn touches_moved(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
             self.handle_touches(touches)
         }
 
-        #[method(touchesEnded:withEvent:)]
+        #[sel(touchesEnded:withEvent:)]
         fn touches_ended(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
             self.handle_touches(touches)
         }
 
-        #[method(touchesCancelled:withEvent:)]
+        #[sel(touchesCancelled:withEvent:)]
         fn touches_cancelled(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
             self.handle_touches(touches)
         }
@@ -157,17 +158,17 @@ declare_class!(
 extern_methods!(
     #[allow(non_snake_case)]
     unsafe impl WinitView {
-        fn window(&self) -> Option<Id<WinitUIWindow>> {
+        fn window(&self) -> Option<Id<WinitUIWindow, Shared>> {
             unsafe { msg_send_id![self, window] }
         }
 
-        unsafe fn traitCollection(&self) -> Id<UITraitCollection> {
+        unsafe fn traitCollection(&self) -> Id<UITraitCollection, Shared> {
             msg_send_id![self, traitCollection]
         }
 
         // TODO: Allow the user to customize this
-        #[method(layerClass)]
-        pub(crate) fn layerClass() -> &'static AnyClass;
+        #[sel(layerClass)]
+        pub(crate) fn layerClass() -> &'static Class;
     }
 );
 
@@ -177,8 +178,9 @@ impl WinitView {
         _window_attributes: &WindowAttributes,
         platform_attributes: &PlatformSpecificWindowBuilderAttributes,
         frame: CGRect,
-    ) -> Id<Self> {
-        let this: Id<Self> = unsafe { msg_send_id![Self::alloc(), initWithFrame: frame] };
+    ) -> Id<Self, Shared> {
+        let this: Id<Self, Shared> =
+            unsafe { msg_send_id![msg_send_id![Self::class(), alloc], initWithFrame: frame] };
 
         this.setMultipleTouchEnabled(true);
 
@@ -201,9 +203,7 @@ impl WinitView {
                 let trait_collection = unsafe { self.traitCollection() };
                 let touch_capability = trait_collection.forceTouchCapability();
                 // Both the OS _and_ the device need to be checked for force touch support.
-                if touch_capability == UIForceTouchCapability::Available
-                    || touch_type == UITouchType::Pencil
-                {
+                if touch_capability == UIForceTouchCapability::Available {
                     let force = touch.force();
                     let max_possible_force = touch.maximumPossibleForce();
                     let altitude_angle: Option<f64> = if touch_type == UITouchType::Pencil {
@@ -260,108 +260,102 @@ impl WinitView {
     }
 }
 
-pub struct ViewControllerState {
-    prefers_status_bar_hidden: Cell<bool>,
-    prefers_home_indicator_auto_hidden: Cell<bool>,
-    supported_orientations: Cell<UIInterfaceOrientationMask>,
-    preferred_screen_edges_deferring_system_gestures: Cell<UIRectEdge>,
-}
-
 declare_class!(
     pub(crate) struct WinitViewController {
-        state: IvarDrop<Box<ViewControllerState>, "_state">,
+        _prefers_status_bar_hidden: bool,
+        _prefers_home_indicator_auto_hidden: bool,
+        _supported_orientations: UIInterfaceOrientationMask,
+        _preferred_screen_edges_deferring_system_gestures: UIRectEdge,
     }
 
-    mod view_controller_ivars;
-
     unsafe impl ClassType for WinitViewController {
         #[inherits(UIResponder, NSObject)]
         type Super = UIViewController;
-        type Mutability = mutability::InteriorMutable;
         const NAME: &'static str = "WinitUIViewController";
     }
 
     unsafe impl WinitViewController {
-        #[method(init)]
-        unsafe fn init(this: *mut Self) -> Option<NonNull<Self>> {
-            let this: Option<&mut Self> = msg_send![super(this), init];
-            this.map(|this| {
-                // These are set in WinitViewController::new, it's just to set them
-                // to _something_.
-                Ivar::write(
-                    &mut this.state,
-                    Box::new(ViewControllerState {
-                        prefers_status_bar_hidden: Cell::new(false),
-                        prefers_home_indicator_auto_hidden: Cell::new(false),
-                        supported_orientations: Cell::new(UIInterfaceOrientationMask::All),
-                        preferred_screen_edges_deferring_system_gestures: Cell::new(
-                            UIRectEdge::NONE,
-                        ),
-                    }),
-                );
-                NonNull::from(this)
-            })
+        #[sel(shouldAutorotate)]
+        fn should_autorotate(&self) -> bool {
+            true
         }
     }
 
     unsafe impl WinitViewController {
-        #[method(shouldAutorotate)]
-        fn should_autorotate(&self) -> bool {
-            true
-        }
-
-        #[method(prefersStatusBarHidden)]
+        #[sel(prefersStatusBarHidden)]
         fn prefers_status_bar_hidden(&self) -> bool {
-            self.state.prefers_status_bar_hidden.get()
+            *self._prefers_status_bar_hidden
         }
 
-        #[method(prefersHomeIndicatorAutoHidden)]
+        #[sel(setPrefersStatusBarHidden:)]
+        fn set_prefers_status_bar_hidden(&mut self, val: bool) {
+            *self._prefers_status_bar_hidden = val;
+            self.setNeedsStatusBarAppearanceUpdate();
+        }
+
+        #[sel(prefersHomeIndicatorAutoHidden)]
         fn prefers_home_indicator_auto_hidden(&self) -> bool {
-            self.state.prefers_home_indicator_auto_hidden.get()
+            *self._prefers_home_indicator_auto_hidden
         }
 
-        #[method(supportedInterfaceOrientations)]
+        #[sel(setPrefersHomeIndicatorAutoHidden:)]
+        fn set_prefers_home_indicator_auto_hidden(&mut self, val: bool) {
+            *self._prefers_home_indicator_auto_hidden = val;
+            let os_capabilities = app_state::os_capabilities();
+            if os_capabilities.home_indicator_hidden {
+                self.setNeedsUpdateOfHomeIndicatorAutoHidden();
+            } else {
+                os_capabilities.home_indicator_hidden_err_msg("ignoring")
+            }
+        }
+
+        #[sel(supportedInterfaceOrientations)]
         fn supported_orientations(&self) -> UIInterfaceOrientationMask {
-            self.state.supported_orientations.get()
+            *self._supported_orientations
         }
 
-        #[method(preferredScreenEdgesDeferringSystemGestures)]
+        #[sel(setSupportedInterfaceOrientations:)]
+        fn set_supported_orientations(&mut self, val: UIInterfaceOrientationMask) {
+            *self._supported_orientations = val;
+            UIViewController::attemptRotationToDeviceOrientation();
+        }
+
+        #[sel(preferredScreenEdgesDeferringSystemGestures)]
         fn preferred_screen_edges_deferring_system_gestures(&self) -> UIRectEdge {
-            self.state
-                .preferred_screen_edges_deferring_system_gestures
-                .get()
+            *self._preferred_screen_edges_deferring_system_gestures
+        }
+
+        #[sel(setPreferredScreenEdgesDeferringSystemGestures:)]
+        fn set_preferred_screen_edges_deferring_system_gestures(&mut self, val: UIRectEdge) {
+            *self._preferred_screen_edges_deferring_system_gestures = val;
+            let os_capabilities = app_state::os_capabilities();
+            if os_capabilities.defer_system_gestures {
+                self.setNeedsUpdateOfScreenEdgesDeferringSystemGestures();
+            } else {
+                os_capabilities.defer_system_gestures_err_msg("ignoring")
+            }
         }
     }
 );
 
+extern_methods!(
+    #[allow(non_snake_case)]
+    unsafe impl WinitViewController {
+        #[sel(setPrefersStatusBarHidden:)]
+        pub(crate) fn setPrefersStatusBarHidden(&self, flag: bool);
+
+        #[sel(setSupportedInterfaceOrientations:)]
+        pub(crate) fn setSupportedInterfaceOrientations(&self, val: UIInterfaceOrientationMask);
+
+        #[sel(setPrefersHomeIndicatorAutoHidden:)]
+        pub(crate) fn setPrefersHomeIndicatorAutoHidden(&self, val: bool);
+
+        #[sel(setPreferredScreenEdgesDeferringSystemGestures:)]
+        pub(crate) fn setPreferredScreenEdgesDeferringSystemGestures(&self, val: UIRectEdge);
+    }
+);
+
 impl WinitViewController {
-    pub(crate) fn set_prefers_status_bar_hidden(&self, val: bool) {
-        self.state.prefers_status_bar_hidden.set(val);
-        self.setNeedsStatusBarAppearanceUpdate();
-    }
-
-    pub(crate) fn set_prefers_home_indicator_auto_hidden(&self, val: bool) {
-        self.state.prefers_home_indicator_auto_hidden.set(val);
-        let os_capabilities = app_state::os_capabilities();
-        if os_capabilities.home_indicator_hidden {
-            self.setNeedsUpdateOfHomeIndicatorAutoHidden();
-        } else {
-            os_capabilities.home_indicator_hidden_err_msg("ignoring")
-        }
-    }
-
-    pub(crate) fn set_preferred_screen_edges_deferring_system_gestures(&self, val: UIRectEdge) {
-        self.state
-            .preferred_screen_edges_deferring_system_gestures
-            .set(val);
-        let os_capabilities = app_state::os_capabilities();
-        if os_capabilities.defer_system_gestures {
-            self.setNeedsUpdateOfScreenEdgesDeferringSystemGestures();
-        } else {
-            os_capabilities.defer_system_gestures_err_msg("ignoring")
-        }
-    }
-
     pub(crate) fn set_supported_interface_orientations(
         &self,
         mtm: MainThreadMarker,
@@ -384,8 +378,7 @@ impl WinitViewController {
                     | UIInterfaceOrientationMask::PortraitUpsideDown
             }
         };
-        self.state.supported_orientations.set(mask);
-        UIViewController::attemptRotationToDeviceOrientation();
+        self.setSupportedInterfaceOrientations(mask);
     }
 
     pub(crate) fn new(
@@ -393,18 +386,17 @@ impl WinitViewController {
         _window_attributes: &WindowAttributes,
         platform_attributes: &PlatformSpecificWindowBuilderAttributes,
         view: &UIView,
-    ) -> Id<Self> {
-        let this: Id<Self> = unsafe { msg_send_id![Self::alloc(), init] };
+    ) -> Id<Self, Shared> {
+        let this: Id<Self, Shared> =
+            unsafe { msg_send_id![msg_send_id![Self::class(), alloc], init] };
 
-        this.set_prefers_status_bar_hidden(platform_attributes.prefers_status_bar_hidden);
+        this.setPrefersStatusBarHidden(platform_attributes.prefers_status_bar_hidden);
 
         this.set_supported_interface_orientations(mtm, platform_attributes.valid_orientations);
 
-        this.set_prefers_home_indicator_auto_hidden(
-            platform_attributes.prefers_home_indicator_hidden,
-        );
+        this.setPrefersHomeIndicatorAutoHidden(platform_attributes.prefers_home_indicator_hidden);
 
-        this.set_preferred_screen_edges_deferring_system_gestures(
+        this.setPreferredScreenEdgesDeferringSystemGestures(
             platform_attributes
                 .preferred_screen_edges_deferring_system_gestures
                 .into(),
@@ -418,17 +410,15 @@ impl WinitViewController {
 
 declare_class!(
     #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct WinitUIWindow;
+    pub(crate) struct WinitUIWindow {}
 
     unsafe impl ClassType for WinitUIWindow {
         #[inherits(UIResponder, NSObject)]
         type Super = UIWindow;
-        type Mutability = mutability::InteriorMutable;
-        const NAME: &'static str = "WinitUIWindow";
     }
 
     unsafe impl WinitUIWindow {
-        #[method(becomeKeyWindow)]
+        #[sel(becomeKeyWindow)]
         fn become_key_window(&self) {
             unsafe {
                 app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::WindowEvent {
@@ -439,7 +429,7 @@ declare_class!(
             let _: () = unsafe { msg_send![super(self), becomeKeyWindow] };
         }
 
-        #[method(resignKeyWindow)]
+        #[sel(resignKeyWindow)]
         fn resign_key_window(&self) {
             unsafe {
                 app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::WindowEvent {
@@ -459,8 +449,9 @@ impl WinitUIWindow {
         _platform_attributes: &PlatformSpecificWindowBuilderAttributes,
         frame: CGRect,
         view_controller: &UIViewController,
-    ) -> Id<Self> {
-        let this: Id<Self> = unsafe { msg_send_id![Self::alloc(), initWithFrame: frame] };
+    ) -> Id<Self, Shared> {
+        let this: Id<Self, Shared> =
+            unsafe { msg_send_id![msg_send_id![Self::class(), alloc], initWithFrame: frame] };
 
         this.setRootViewController(Some(view_controller));
 
@@ -487,17 +478,15 @@ impl WinitUIWindow {
 }
 
 declare_class!(
-    pub struct WinitApplicationDelegate;
+    pub struct WinitApplicationDelegate {}
 
     unsafe impl ClassType for WinitApplicationDelegate {
         type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-        const NAME: &'static str = "WinitApplicationDelegate";
     }
 
     // UIApplicationDelegate protocol
     unsafe impl WinitApplicationDelegate {
-        #[method(application:didFinishLaunchingWithOptions:)]
+        #[sel(application:didFinishLaunchingWithOptions:)]
         fn did_finish_launching(&self, _application: &UIApplication, _: *mut NSObject) -> bool {
             unsafe {
                 app_state::did_finish_launching();
@@ -505,23 +494,22 @@ declare_class!(
             true
         }
 
-        #[method(applicationDidBecomeActive:)]
+        #[sel(applicationDidBecomeActive:)]
         fn did_become_active(&self, _application: &UIApplication) {
             unsafe { app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::Resumed)) }
         }
 
-        #[method(applicationWillResignActive:)]
+        #[sel(applicationWillResignActive:)]
         fn will_resign_active(&self, _application: &UIApplication) {
             unsafe { app_state::handle_nonuser_event(EventWrapper::StaticEvent(Event::Suspended)) }
         }
 
-        #[method(applicationWillEnterForeground:)]
+        #[sel(applicationWillEnterForeground:)]
         fn will_enter_foreground(&self, _application: &UIApplication) {}
-
-        #[method(applicationDidEnterBackground:)]
+        #[sel(applicationDidEnterBackground:)]
         fn did_enter_background(&self, _application: &UIApplication) {}
 
-        #[method(applicationWillTerminate:)]
+        #[sel(applicationWillTerminate:)]
         fn will_terminate(&self, application: &UIApplication) {
             let mut events = Vec::new();
             for window in application.windows().iter() {

src/platform_impl/ios/window.rs

@@ -1,10 +1,14 @@
 #![allow(clippy::unnecessary_cast)]
 
-use std::collections::VecDeque;
+use std::{
+    collections::VecDeque,
+    ffi::c_void,
+    ops::{Deref, DerefMut},
+};
 
-use icrate::Foundation::{CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker};
-use objc2::rc::Id;
-use objc2::runtime::AnyObject;
+use objc2::foundation::{CGFloat, CGPoint, CGRect, CGSize, MainThreadMarker};
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Object;
 use objc2::{class, msg_send};
 use raw_window_handle::{RawDisplayHandle, RawWindowHandle, UiKitDisplayHandle, UiKitWindowHandle};
 
@@ -19,6 +23,7 @@ use crate::{
     platform_impl::platform::{
         app_state,
         event_loop::{EventProxy, EventWrapper},
+        ffi::UIRectEdge,
         monitor, EventLoopWindowTarget, Fullscreen, MonitorHandle,
     },
     window::{
@@ -28,9 +33,9 @@ use crate::{
 };
 
 pub struct Inner {
-    window: Id<WinitUIWindow>,
-    view_controller: Id<WinitViewController>,
-    view: Id<WinitView>,
+    pub(crate) window: Id<WinitUIWindow, Shared>,
+    pub(crate) view_controller: Id<WinitViewController, Shared>,
+    pub(crate) view: Id<WinitView, Shared>,
     gl_or_metal_backed: bool,
 }
 
@@ -70,65 +75,73 @@ impl Inner {
         }
     }
 
-    pub fn pre_present_notify(&self) {}
-
     pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        let safe_area = self.safe_area_screen_space();
-        let position = LogicalPosition {
-            x: safe_area.origin.x as f64,
-            y: safe_area.origin.y as f64,
-        };
-        let scale_factor = self.scale_factor();
-        Ok(position.to_physical(scale_factor))
+        unsafe {
+            let safe_area = self.safe_area_screen_space();
+            let position = LogicalPosition {
+                x: safe_area.origin.x as f64,
+                y: safe_area.origin.y as f64,
+            };
+            let scale_factor = self.scale_factor();
+            Ok(position.to_physical(scale_factor))
+        }
     }
 
     pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
-        let screen_frame = self.screen_frame();
-        let position = LogicalPosition {
-            x: screen_frame.origin.x as f64,
-            y: screen_frame.origin.y as f64,
-        };
-        let scale_factor = self.scale_factor();
-        Ok(position.to_physical(scale_factor))
+        unsafe {
+            let screen_frame = self.screen_frame();
+            let position = LogicalPosition {
+                x: screen_frame.origin.x as f64,
+                y: screen_frame.origin.y as f64,
+            };
+            let scale_factor = self.scale_factor();
+            Ok(position.to_physical(scale_factor))
+        }
     }
 
     pub fn set_outer_position(&self, physical_position: Position) {
-        let scale_factor = self.scale_factor();
-        let position = physical_position.to_logical::<f64>(scale_factor);
-        let screen_frame = self.screen_frame();
-        let new_screen_frame = CGRect {
-            origin: CGPoint {
-                x: position.x as _,
-                y: position.y as _,
-            },
-            size: screen_frame.size,
-        };
-        let bounds = self.rect_from_screen_space(new_screen_frame);
-        self.window.setBounds(bounds);
+        unsafe {
+            let scale_factor = self.scale_factor();
+            let position = physical_position.to_logical::<f64>(scale_factor);
+            let screen_frame = self.screen_frame();
+            let new_screen_frame = CGRect {
+                origin: CGPoint {
+                    x: position.x as _,
+                    y: position.y as _,
+                },
+                size: screen_frame.size,
+            };
+            let bounds = self.rect_from_screen_space(new_screen_frame);
+            self.window.setBounds(bounds);
+        }
     }
 
     pub fn inner_size(&self) -> PhysicalSize<u32> {
-        let scale_factor = self.scale_factor();
-        let safe_area = self.safe_area_screen_space();
-        let size = LogicalSize {
-            width: safe_area.size.width as f64,
-            height: safe_area.size.height as f64,
-        };
-        size.to_physical(scale_factor)
+        unsafe {
+            let scale_factor = self.scale_factor();
+            let safe_area = self.safe_area_screen_space();
+            let size = LogicalSize {
+                width: safe_area.size.width as f64,
+                height: safe_area.size.height as f64,
+            };
+            size.to_physical(scale_factor)
+        }
     }
 
     pub fn outer_size(&self) -> PhysicalSize<u32> {
-        let scale_factor = self.scale_factor();
-        let screen_frame = self.screen_frame();
-        let size = LogicalSize {
-            width: screen_frame.size.width as f64,
-            height: screen_frame.size.height as f64,
-        };
-        size.to_physical(scale_factor)
+        unsafe {
+            let scale_factor = self.scale_factor();
+            let screen_frame = self.screen_frame();
+            let size = LogicalSize {
+                width: screen_frame.size.width as f64,
+                height: screen_frame.size.height as f64,
+            };
+            size.to_physical(scale_factor)
+        }
     }
 
-    pub fn request_inner_size(&self, _size: Size) -> Option<PhysicalSize<u32>> {
-        Some(self.inner_size())
+    pub fn set_inner_size(&self, _size: Size) {
+        warn!("not clear what `Window::set_inner_size` means on iOS");
     }
 
     pub fn set_min_inner_size(&self, _dimensions: Option<Size>) {
@@ -249,20 +262,22 @@ impl Inner {
     }
 
     pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
-        let monitor = self.current_monitor_inner();
-        let uiscreen = monitor.ui_screen();
-        let screen_space_bounds = self.screen_frame();
-        let screen_bounds = uiscreen.bounds();
+        unsafe {
+            let monitor = self.current_monitor_inner();
+            let uiscreen = monitor.ui_screen();
+            let screen_space_bounds = self.screen_frame();
+            let screen_bounds = uiscreen.bounds();
 
-        // TODO: track fullscreen instead of relying on brittle float comparisons
-        if screen_space_bounds.origin.x == screen_bounds.origin.x
-            && screen_space_bounds.origin.y == screen_bounds.origin.y
-            && screen_space_bounds.size.width == screen_bounds.size.width
-            && screen_space_bounds.size.height == screen_bounds.size.height
-        {
-            Some(Fullscreen::Borderless(Some(monitor)))
-        } else {
-            None
+            // TODO: track fullscreen instead of relying on brittle float comparisons
+            if screen_space_bounds.origin.x == screen_bounds.origin.x
+                && screen_space_bounds.origin.y == screen_bounds.origin.y
+                && screen_space_bounds.size.width == screen_bounds.size.width
+                && screen_space_bounds.size.height == screen_bounds.size.height
+            {
+                Some(Fullscreen::Borderless(Some(monitor)))
+            } else {
+                None
+            }
         }
     }
 
@@ -280,8 +295,8 @@ impl Inner {
         warn!("`Window::set_window_icon` 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_position(&self, _position: Position) {
+        warn!("`Window::set_ime_position` is ignored on iOS")
     }
 
     pub fn set_ime_allowed(&self, _allowed: bool) {
@@ -353,14 +368,35 @@ impl Inner {
         warn!("`Window::title` is ignored on iOS");
         String::new()
     }
-
-    pub fn reset_dead_keys(&self) {
-        // Noop
-    }
 }
 
 pub struct Window {
-    inner: MainThreadBound<Inner>,
+    pub inner: Inner,
+}
+
+impl Drop for Window {
+    fn drop(&mut self) {
+        assert_main_thread!("`Window::drop` can only be run on the main thread on iOS");
+    }
+}
+
+unsafe impl Send for Window {}
+unsafe impl Sync for Window {}
+
+impl Deref for Window {
+    type Target = Inner;
+
+    fn deref(&self) -> &Inner {
+        assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
+        &self.inner
+    }
+}
+
+impl DerefMut for Window {
+    fn deref_mut(&mut self) -> &mut Inner {
+        assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
+        &mut self.inner
+    }
 }
 
 impl Window {
@@ -457,29 +493,29 @@ impl Window {
             }
         }
 
-        let inner = Inner {
-            window,
-            view_controller,
-            view,
-            gl_or_metal_backed,
-        };
         Ok(Window {
-            inner: MainThreadBound::new(inner, mtm),
+            inner: Inner {
+                window,
+                view_controller,
+                view,
+                gl_or_metal_backed,
+            },
         })
     }
-
-    pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Inner) + Send + 'static) {
-        // For now, don't actually do queuing, since it may be less predictable
-        self.maybe_wait_on_main(f)
-    }
-
-    pub(crate) fn maybe_wait_on_main<R: Send>(&self, f: impl FnOnce(&Inner) -> R + Send) -> R {
-        self.inner.get_on_main(|inner, _mtm| f(inner))
-    }
 }
 
 // WindowExtIOS
 impl Inner {
+    pub fn ui_window(&self) -> *mut c_void {
+        Id::as_ptr(&self.window) as *mut c_void
+    }
+    pub fn ui_view_controller(&self) -> *mut c_void {
+        Id::as_ptr(&self.view_controller) as *mut c_void
+    }
+    pub fn ui_view(&self) -> *mut c_void {
+        Id::as_ptr(&self.view) as *mut c_void
+    }
+
     pub fn set_scale_factor(&self, scale_factor: f64) {
         assert!(
             dpi::validate_scale_factor(scale_factor),
@@ -498,37 +534,42 @@ impl Inner {
 
     pub fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
         self.view_controller
-            .set_prefers_home_indicator_auto_hidden(hidden);
+            .setPrefersHomeIndicatorAutoHidden(hidden);
     }
 
     pub fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
+        let edges: UIRectEdge = edges.into();
         self.view_controller
-            .set_preferred_screen_edges_deferring_system_gestures(edges.into());
+            .setPreferredScreenEdgesDeferringSystemGestures(edges);
     }
 
     pub fn set_prefers_status_bar_hidden(&self, hidden: bool) {
-        self.view_controller.set_prefers_status_bar_hidden(hidden);
+        self.view_controller.setPrefersStatusBarHidden(hidden);
     }
 }
 
 impl Inner {
-    fn screen_frame(&self) -> CGRect {
+    // requires main thread
+    unsafe fn screen_frame(&self) -> CGRect {
         self.rect_to_screen_space(self.window.bounds())
     }
 
-    fn rect_to_screen_space(&self, rect: CGRect) -> CGRect {
+    // requires main thread
+    unsafe fn rect_to_screen_space(&self, rect: CGRect) -> CGRect {
         let screen_space = self.window.screen().coordinateSpace();
         self.window
             .convertRect_toCoordinateSpace(rect, &screen_space)
     }
 
-    fn rect_from_screen_space(&self, rect: CGRect) -> CGRect {
+    // requires main thread
+    unsafe fn rect_from_screen_space(&self, rect: CGRect) -> CGRect {
         let screen_space = self.window.screen().coordinateSpace();
         self.window
             .convertRect_fromCoordinateSpace(rect, &screen_space)
     }
 
-    fn safe_area_screen_space(&self) -> CGRect {
+    // requires main thread
+    unsafe fn safe_area_screen_space(&self) -> CGRect {
         let bounds = self.window.bounds();
         if app_state::os_capabilities().safe_area {
             let safe_area = self.window.safeAreaInsets();
@@ -546,7 +587,7 @@ impl Inner {
         } else {
             let screen_frame = self.rect_to_screen_space(bounds);
             let status_bar_frame = {
-                let app = UIApplication::shared(MainThreadMarker::new().unwrap()).expect(
+                let app = UIApplication::shared(MainThreadMarker::new().unwrap_unchecked()).expect(
                     "`Window::get_inner_position` cannot be called before `EventLoop::run` on iOS",
                 );
                 app.statusBarFrame()
@@ -603,8 +644,8 @@ impl From<u64> for WindowId {
 unsafe impl Send for WindowId {}
 unsafe impl Sync for WindowId {}
 
-impl From<&AnyObject> for WindowId {
-    fn from(window: &AnyObject) -> WindowId {
+impl From<&Object> for WindowId {
+    fn from(window: &Object) -> WindowId {
         WindowId {
             window: window as *const _ as _,
         }

src/platform_impl/linux/common/keymap.rs

@@ -1,887 +0,0 @@
-//! 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,
-    }
-}

src/platform_impl/linux/common/mod.rs

@@ -1,2 +0,0 @@
-pub mod keymap;
-pub mod xkb_state;

src/platform_impl/linux/common/xkb_state.rs

@@ -1,676 +0,0 @@
-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);
-    }
-
-    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()
-}

src/platform_impl/linux/mod.rs

@@ -3,52 +3,59 @@
 #[cfg(all(not(x11_platform), not(wayland_platform)))]
 compile_error!("Please select a feature to build for unix: `x11`, `wayland`");
 
-use std::sync::Arc;
-use std::time::Duration;
+#[cfg(wayland_platform)]
+use std::error::Error;
+
 use std::{collections::VecDeque, env, fmt};
 #[cfg(x11_platform)]
-use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Mutex};
+use std::{
+    ffi::CStr,
+    mem::MaybeUninit,
+    os::raw::*,
+    sync::{Arc, Mutex},
+};
 
 #[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;
+#[cfg(x11_platform)]
+use self::x11::{ffi::XVisualInfo, util::WindowType as XWindowType, XConnection, XError};
 #[cfg(x11_platform)]
 use crate::platform::x11::XlibErrorHook;
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize, Position, Size},
-    error::{EventLoopError, ExternalError, NotSupportedError, OsError as RootOsError},
-    event::{Event, KeyEvent},
+    error::{ExternalError, NotSupportedError, OsError as RootOsError},
+    event::Event,
     event_loop::{
-        AsyncRequestSerial, ControlFlow, DeviceEvents, EventLoopClosed,
-        EventLoopWindowTarget as RootELW,
+        ControlFlow, DeviceEventFilter, EventLoopClosed, EventLoopWindowTarget as RootELW,
     },
     icon::Icon,
-    keyboard::{Key, KeyCode},
-    platform::{
-        modifier_supplement::KeyEventExtModifierSupplement, pump_events::PumpStatus,
-        scancode::KeyCodeExtScancode,
-    },
     window::{
-        ActivationToken, CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme,
-        UserAttentionType, WindowAttributes, WindowButtons, WindowLevel,
+        CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
+        WindowAttributes, WindowButtons, WindowLevel,
     },
 };
-#[cfg(x11_platform)]
-pub use x11::XNotSupported;
-#[cfg(x11_platform)]
-use x11::{util::WindowType as XWindowType, X11Error, XConnection, XError};
 
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
-pub(crate) use crate::platform_impl::Fullscreen;
+pub(self) use crate::platform_impl::Fullscreen;
 
-pub mod common;
 #[cfg(wayland_platform)]
 pub mod wayland;
 #[cfg(x11_platform)]
 pub mod x11;
 
+/// Environment variable specifying which backend should be used on unix platform.
+///
+/// Legal values are x11 and wayland. If this variable is set only the named backend
+/// will be tried by winit. If it is not set, winit will try to connect to a wayland connection,
+/// and if it fails will fallback on x11.
+///
+/// If this variable is set with any other value, winit will panic.
+const BACKEND_PREFERENCE_ENV_VAR: &str = "WINIT_UNIX_BACKEND";
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) enum Backend {
     #[cfg(x11_platform)]
@@ -78,38 +85,32 @@ impl ApplicationName {
 #[derive(Clone)]
 pub struct PlatformSpecificWindowBuilderAttributes {
     pub name: Option<ApplicationName>,
-    pub activation_token: Option<ActivationToken>,
     #[cfg(x11_platform)]
-    pub x11: X11WindowBuilderAttributes,
-}
-
-#[derive(Clone)]
-#[cfg(x11_platform)]
-pub struct X11WindowBuilderAttributes {
-    pub visual_id: Option<x11rb::protocol::xproto::Visualid>,
+    pub visual_infos: Option<XVisualInfo>,
+    #[cfg(x11_platform)]
     pub screen_id: Option<i32>,
+    #[cfg(x11_platform)]
     pub base_size: Option<Size>,
+    #[cfg(x11_platform)]
     pub override_redirect: bool,
+    #[cfg(x11_platform)]
     pub x11_window_types: Vec<XWindowType>,
-
-    /// The parent window to embed this window into.
-    pub embed_window: Option<x11rb::protocol::xproto::Window>,
 }
 
 impl Default for PlatformSpecificWindowBuilderAttributes {
     fn default() -> Self {
         Self {
             name: None,
-            activation_token: None,
             #[cfg(x11_platform)]
-            x11: X11WindowBuilderAttributes {
-                visual_id: None,
-                screen_id: None,
-                base_size: None,
-                override_redirect: false,
-                x11_window_types: vec![XWindowType::Normal],
-                embed_window: None,
-            },
+            visual_infos: None,
+            #[cfg(x11_platform)]
+            screen_id: None,
+            #[cfg(x11_platform)]
+            base_size: None,
+            #[cfg(x11_platform)]
+            override_redirect: false,
+            #[cfg(x11_platform)]
+            x11_window_types: vec![XWindowType::Normal],
         }
     }
 }
@@ -120,21 +121,23 @@ pub(crate) static X11_BACKEND: Lazy<Mutex<Result<Arc<XConnection>, XNotSupported
 
 #[derive(Debug, Clone)]
 pub enum OsError {
-    Misc(&'static str),
     #[cfg(x11_platform)]
-    XError(Arc<X11Error>),
+    XError(XError),
+    #[cfg(x11_platform)]
+    XMisc(&'static str),
     #[cfg(wayland_platform)]
-    WaylandError(Arc<wayland::WaylandError>),
+    WaylandMisc(&'static str),
 }
 
 impl fmt::Display for OsError {
     fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
-            OsError::Misc(e) => _f.pad(e),
             #[cfg(x11_platform)]
-            OsError::XError(ref e) => fmt::Display::fmt(e, _f),
+            OsError::XError(ref e) => _f.pad(&e.description),
+            #[cfg(x11_platform)]
+            OsError::XMisc(e) => _f.pad(e),
             #[cfg(wayland_platform)]
-            OsError::WaylandError(ref e) => fmt::Display::fmt(e, _f),
+            OsError::WaylandMisc(e) => _f.pad(e),
         }
     }
 }
@@ -306,14 +309,6 @@ impl Window {
         }
     }
 
-    pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Self) + Send + 'static) {
-        f(self)
-    }
-
-    pub(crate) fn maybe_wait_on_main<R: Send>(&self, f: impl FnOnce(&Self) -> R + Send) -> R {
-        f(self)
-    }
-
     #[inline]
     pub fn id(&self) -> WindowId {
         match self {
@@ -370,13 +365,8 @@ impl Window {
     }
 
     #[inline]
-    pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
-        x11_or_wayland!(match self; Window(w) => w.request_inner_size(size))
-    }
-
-    #[inline]
-    pub(crate) fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError> {
-        x11_or_wayland!(match self; Window(w) => w.request_activation_token())
+    pub fn set_inner_size(&self, size: Size) {
+        x11_or_wayland!(match self; Window(w) => w.set_inner_size(size))
     }
 
     #[inline]
@@ -520,13 +510,8 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_ime_cursor_area(&self, position: Position, size: Size) {
-        x11_or_wayland!(match self; Window(w) => w.set_ime_cursor_area(position, size))
-    }
-
-    #[inline]
-    pub fn reset_dead_keys(&self) {
-        common::xkb_state::reset_dead_keys()
+    pub fn set_ime_position(&self, position: Position) {
+        x11_or_wayland!(match self; Window(w) => w.set_ime_position(position))
     }
 
     #[inline]
@@ -549,7 +534,12 @@ impl Window {
         }
     }
     pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
-        x11_or_wayland!(match self; Window(w) => w.request_user_attention(request_type))
+        match self {
+            #[cfg(x11_platform)]
+            Window::X(ref w) => w.request_user_attention(request_type),
+            #[cfg(wayland_platform)]
+            Window::Wayland(ref w) => w.request_user_attention(request_type),
+        }
     }
 
     #[inline]
@@ -557,11 +547,6 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.request_redraw())
     }
 
-    #[inline]
-    pub fn pre_present_notify(&self) {
-        x11_or_wayland!(match self; Window(w) => w.pre_present_notify())
-    }
-
     #[inline]
     pub fn current_monitor(&self) -> Option<MonitorHandle> {
         match self {
@@ -639,37 +624,6 @@ 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>>> =
@@ -738,9 +692,7 @@ impl<T: 'static> Clone for EventLoopProxy<T> {
 }
 
 impl<T: 'static> EventLoop<T> {
-    pub(crate) fn new(
-        attributes: &PlatformSpecificEventLoopAttributes,
-    ) -> Result<Self, EventLoopError> {
+    pub(crate) fn new(attributes: &PlatformSpecificEventLoopAttributes) -> Self {
         if !attributes.any_thread && !is_main_thread() {
             panic!(
                 "Initializing the event loop outside of the main thread is a significant \
@@ -750,26 +702,65 @@ impl<T: 'static> EventLoop<T> {
             );
         }
 
-        // NOTE: Wayland first because of X11 could be present under wayland as well.
-        #[cfg(wayland_platform)]
-        if attributes.forced_backend == Some(Backend::Wayland)
-            || env::var("WAYLAND_DISPLAY").is_ok()
-        {
-            return EventLoop::new_wayland_any_thread().map_err(Into::into);
+        #[cfg(x11_platform)]
+        if attributes.forced_backend == Some(Backend::X) {
+            // TODO: Propagate
+            return EventLoop::new_x11_any_thread().unwrap();
         }
 
+        #[cfg(wayland_platform)]
+        if attributes.forced_backend == Some(Backend::Wayland) {
+            // TODO: Propagate
+            return EventLoop::new_wayland_any_thread().expect("failed to open Wayland connection");
+        }
+
+        if let Ok(env_var) = env::var(BACKEND_PREFERENCE_ENV_VAR) {
+            match env_var.as_str() {
+                "x11" => {
+                    // TODO: propagate
+                    #[cfg(x11_platform)]
+                    return EventLoop::new_x11_any_thread()
+                        .expect("Failed to initialize X11 backend");
+                    #[cfg(not(x11_platform))]
+                    panic!("x11 feature is not enabled")
+                }
+                "wayland" => {
+                    #[cfg(wayland_platform)]
+                    return EventLoop::new_wayland_any_thread()
+                        .expect("Failed to initialize Wayland backend");
+                    #[cfg(not(wayland_platform))]
+                    panic!("wayland feature is not enabled");
+                }
+                _ => panic!(
+                    "Unknown environment variable value for {BACKEND_PREFERENCE_ENV_VAR}, try one of `x11`,`wayland`",
+                ),
+            }
+        }
+
+        #[cfg(wayland_platform)]
+        let wayland_err = match EventLoop::new_wayland_any_thread() {
+            Ok(event_loop) => return event_loop,
+            Err(err) => err,
+        };
+
         #[cfg(x11_platform)]
-        if attributes.forced_backend == Some(Backend::X) || env::var("DISPLAY").is_ok() {
-            return Ok(EventLoop::new_x11_any_thread().unwrap());
-        }
+        let x11_err = match EventLoop::new_x11_any_thread() {
+            Ok(event_loop) => return event_loop,
+            Err(err) => err,
+        };
 
-        Err(EventLoopError::Os(os_error!(OsError::Misc(
-            "neither WAYLAND_DISPLAY nor DISPLAY is set."
-        ))))
+        #[cfg(not(wayland_platform))]
+        let wayland_err = "backend disabled";
+        #[cfg(not(x11_platform))]
+        let x11_err = "backend disabled";
+
+        panic!(
+            "Failed to initialize any backend! Wayland status: {wayland_err:?} X11 status: {x11_err:?}",
+        );
     }
 
     #[cfg(wayland_platform)]
-    fn new_wayland_any_thread() -> Result<EventLoop<T>, EventLoopError> {
+    fn new_wayland_any_thread() -> Result<EventLoop<T>, Box<dyn Error>> {
         wayland::EventLoop::new().map(|evlp| EventLoop::Wayland(Box::new(evlp)))
     }
 
@@ -787,25 +778,18 @@ impl<T: 'static> EventLoop<T> {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.create_proxy(); as EventLoopProxy)
     }
 
-    pub fn run<F>(mut self, callback: F) -> Result<(), EventLoopError>
+    pub fn run_return<F>(&mut self, callback: F) -> i32
     where
-        F: FnMut(crate::event::Event<T>, &RootELW<T>, &mut ControlFlow),
+        F: FnMut(crate::event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),
     {
-        self.run_ondemand(callback)
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_return(callback))
     }
 
-    pub fn run_ondemand<F>(&mut self, callback: F) -> Result<(), EventLoopError>
+    pub fn run<F>(self, callback: F) -> !
     where
-        F: FnMut(crate::event::Event<T>, &RootELW<T>, &mut ControlFlow),
+        F: 'static + FnMut(crate::event::Event<'_, T>, &RootELW<T>, &mut ControlFlow),
     {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_ondemand(callback))
-    }
-
-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus
-    where
-        F: FnMut(crate::event::Event<T>, &RootELW<T>, &mut ControlFlow),
-    {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_events(timeout, callback))
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run(callback))
     }
 
     pub fn window_target(&self) -> &crate::event_loop::EventLoopWindowTarget<T> {
@@ -870,12 +854,12 @@ impl<T> EventLoopWindowTarget<T> {
     }
 
     #[inline]
-    pub fn listen_device_events(&self, _allowed: DeviceEvents) {
+    pub fn set_device_event_filter(&self, _filter: DeviceEventFilter) {
         match *self {
             #[cfg(wayland_platform)]
             EventLoopWindowTarget::Wayland(_) => (),
             #[cfg(x11_platform)]
-            EventLoopWindowTarget::X(ref evlp) => evlp.set_listen_device_events(_allowed),
+            EventLoopWindowTarget::X(ref evlp) => evlp.set_device_event_filter(_filter),
         }
     }
 
@@ -885,12 +869,12 @@ impl<T> EventLoopWindowTarget<T> {
 }
 
 fn sticky_exit_callback<T, F>(
-    evt: Event<T>,
+    evt: Event<'_, T>,
     target: &RootELW<T>,
     control_flow: &mut ControlFlow,
     callback: &mut F,
 ) where
-    F: FnMut(Event<T>, &RootELW<T>, &mut ControlFlow),
+    F: FnMut(Event<'_, T>, &RootELW<T>, &mut ControlFlow),
 {
     // make ControlFlow::ExitWithCode sticky by providing a dummy
     // control flow reference if it is already ExitWithCode.
@@ -901,18 +885,11 @@ fn sticky_exit_callback<T, F>(
     }
 }
 
-/// Returns the minimum `Option<Duration>`, taking into account that `None`
-/// equates to an infinite timeout, not a zero timeout (so can't just use
-/// `Option::min`)
-fn min_timeout(a: Option<Duration>, b: Option<Duration>) -> Option<Duration> {
-    a.map_or(b, |a_timeout| {
-        b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout)))
-    })
-}
-
 #[cfg(target_os = "linux")]
 fn is_main_thread() -> bool {
-    rustix::thread::gettid() == rustix::process::getpid()
+    use libc::{c_long, getpid, syscall, SYS_gettid};
+
+    unsafe { syscall(SYS_gettid) == getpid() as c_long }
 }
 
 #[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]