Vendor dependencies for 0.3.0 release

vendor/winit/Cargo.toml

@@ -0,0 +1,553 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2021"
+rust-version = "1.70.0"
+name = "winit"
+version = "0.30.12"
+authors = [
+    "The winit contributors",
+    "Pierre Krieger <pierre.krieger1708@gmail.com>",
+]
+build = "build.rs"
+include = [
+    "/build.rs",
+    "/docs",
+    "/examples",
+    "/FEATURES.md",
+    "/LICENSE",
+    "/src",
+    "!/src/platform_impl/web/script",
+    "/src/platform_impl/web/script/**/*.min.js",
+    "/tests",
+]
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Cross-platform window creation library."
+documentation = "https://docs.rs/winit"
+readme = "README.md"
+keywords = ["windowing"]
+categories = ["gui"]
+license = "Apache-2.0"
+repository = "https://github.com/rust-windowing/winit"
+
+[package.metadata.docs.rs]
+features = [
+    "rwh_04",
+    "rwh_05",
+    "rwh_06",
+    "serde",
+    "mint",
+    "android-native-activity",
+]
+rustdoc-args = [
+    "--cfg",
+    "docsrs",
+]
+targets = [
+    "i686-pc-windows-msvc",
+    "x86_64-pc-windows-msvc",
+    "x86_64-apple-darwin",
+    "i686-unknown-linux-gnu",
+    "x86_64-unknown-linux-gnu",
+    "x86_64-apple-ios",
+    "aarch64-linux-android",
+    "wasm32-unknown-unknown",
+]
+
+[features]
+android-game-activity = ["android-activity/game-activity"]
+android-native-activity = ["android-activity/native-activity"]
+default = [
+    "rwh_06",
+    "x11",
+    "wayland",
+    "wayland-dlopen",
+    "wayland-csd-adwaita",
+]
+mint = ["dpi/mint"]
+rwh_04 = [
+    "dep:rwh_04",
+    "ndk/rwh_04",
+]
+rwh_05 = [
+    "dep:rwh_05",
+    "ndk/rwh_05",
+]
+rwh_06 = [
+    "dep:rwh_06",
+    "ndk/rwh_06",
+]
+serde = [
+    "dep:serde",
+    "cursor-icon/serde",
+    "smol_str/serde",
+    "dpi/serde",
+]
+wayland = [
+    "wayland-client",
+    "wayland-backend",
+    "wayland-protocols",
+    "wayland-protocols-plasma",
+    "sctk",
+    "ahash",
+    "memmap2",
+]
+wayland-csd-adwaita = [
+    "sctk-adwaita",
+    "sctk-adwaita/ab_glyph",
+]
+wayland-csd-adwaita-crossfont = [
+    "sctk-adwaita",
+    "sctk-adwaita/crossfont",
+]
+wayland-csd-adwaita-notitle = ["sctk-adwaita"]
+wayland-dlopen = ["wayland-backend/dlopen"]
+x11 = [
+    "x11-dl",
+    "bytemuck",
+    "percent-encoding",
+    "xkbcommon-dl/x11",
+    "x11rb",
+]
+
+[lib]
+name = "winit"
+path = "src/lib.rs"
+
+[[example]]
+name = "child_window"
+path = "examples/child_window.rs"
+
+[[example]]
+name = "control_flow"
+path = "examples/control_flow.rs"
+
+[[example]]
+name = "pump_events"
+path = "examples/pump_events.rs"
+
+[[example]]
+name = "run_on_demand"
+path = "examples/run_on_demand.rs"
+
+[[example]]
+name = "window"
+path = "examples/window.rs"
+doc-scrape-examples = true
+
+[[example]]
+name = "x11_embed"
+path = "examples/x11_embed.rs"
+
+[[test]]
+name = "send_objects"
+path = "tests/send_objects.rs"
+
+[[test]]
+name = "serde_objects"
+path = "tests/serde_objects.rs"
+
+[[test]]
+name = "sync_object"
+path = "tests/sync_object.rs"
+
+[dependencies.bitflags]
+version = "2"
+
+[dependencies.cursor-icon]
+version = "1.1.0"
+
+[dependencies.dpi]
+version = "0.1.1"
+
+[dependencies.rwh_04]
+version = "0.4"
+optional = true
+package = "raw-window-handle"
+
+[dependencies.rwh_05]
+version = "0.5.2"
+features = ["std"]
+optional = true
+package = "raw-window-handle"
+
+[dependencies.rwh_06]
+version = "0.6"
+features = ["std"]
+optional = true
+package = "raw-window-handle"
+
+[dependencies.serde]
+version = "1"
+features = ["serde_derive"]
+optional = true
+
+[dependencies.smol_str]
+version = "0.2.0"
+
+[dependencies.tracing]
+version = "0.1.40"
+default-features = false
+
+[dev-dependencies.image]
+version = "0.25.0"
+features = ["png"]
+default-features = false
+
+[dev-dependencies.tracing]
+version = "0.1.40"
+features = ["log"]
+default-features = false
+
+[dev-dependencies.tracing-subscriber]
+version = "0.3.18"
+features = ["env-filter"]
+
+[build-dependencies.cfg_aliases]
+version = "0.2.1"
+
+[target.'cfg(all(target_family = "wasm", target_feature = "atomics"))'.dependencies.atomic-waker]
+version = "1"
+
+[target.'cfg(all(target_family = "wasm", target_feature = "atomics"))'.dependencies.concurrent-queue]
+version = "2"
+default-features = false
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.ahash]
+version = "0.8.7"
+features = ["no-rng"]
+optional = true
+
+[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"
+optional = true
+default-features = false
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.calloop]
+version = "0.13.0"
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.libc]
+version = "0.2.64"
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.memmap2]
+version = "0.9.0"
+optional = true
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.percent-encoding]
+version = "2.0"
+optional = true
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.rustix]
+version = "0.38.4"
+features = [
+    "std",
+    "system",
+    "thread",
+    "process",
+]
+default-features = false
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.sctk]
+version = "0.19.2"
+features = ["calloop"]
+optional = true
+default-features = false
+package = "smithay-client-toolkit"
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.sctk-adwaita]
+version = "0.10.1"
+optional = true
+default-features = false
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.wayland-backend]
+version = "0.3.10"
+features = ["client_system"]
+optional = true
+default-features = false
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.wayland-client]
+version = "0.31.10"
+optional = true
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.wayland-protocols]
+version = "0.32.8"
+features = ["staging"]
+optional = true
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.wayland-protocols-plasma]
+version = "0.3.8"
+features = ["client"]
+optional = true
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.x11-dl]
+version = "2.19.1"
+optional = true
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.x11rb]
+version = "0.13.0"
+features = [
+    "allow-unsafe-code",
+    "dl-libxcb",
+    "randr",
+    "resource_manager",
+    "xinput",
+    "xkb",
+]
+optional = true
+default-features = false
+
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies.xkbcommon-dl]
+version = "0.4.2"
+
+[target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies.block2]
+version = "0.5.1"
+
+[target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies.core-foundation]
+version = "0.9.3"
+
+[target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies.objc2]
+version = "0.5.2"
+features = ["relax-sign-encoding"]
+
+[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dev-dependencies.softbuffer]
+version = "0.4.0"
+features = [
+    "x11",
+    "x11-dlopen",
+    "wayland",
+    "wayland-dlopen",
+]
+default-features = false
+
+[target.'cfg(target_family = "wasm")'.dependencies.js-sys]
+version = "0.3.70"
+
+[target.'cfg(target_family = "wasm")'.dependencies.pin-project]
+version = "1"
+
+[target.'cfg(target_family = "wasm")'.dependencies.wasm-bindgen]
+version = "0.2.93"
+
+[target.'cfg(target_family = "wasm")'.dependencies.wasm-bindgen-futures]
+version = "0.4.43"
+
+[target.'cfg(target_family = "wasm")'.dependencies.web-time]
+version = "1"
+
+[target.'cfg(target_family = "wasm")'.dependencies.web_sys]
+version = "0.3.70"
+features = [
+    "AbortController",
+    "AbortSignal",
+    "Blob",
+    "BlobPropertyBag",
+    "console",
+    "CssStyleDeclaration",
+    "Document",
+    "DomException",
+    "DomRect",
+    "DomRectReadOnly",
+    "Element",
+    "Event",
+    "EventTarget",
+    "FocusEvent",
+    "HtmlCanvasElement",
+    "HtmlElement",
+    "HtmlImageElement",
+    "ImageBitmap",
+    "ImageBitmapOptions",
+    "ImageBitmapRenderingContext",
+    "ImageData",
+    "IntersectionObserver",
+    "IntersectionObserverEntry",
+    "KeyboardEvent",
+    "MediaQueryList",
+    "MessageChannel",
+    "MessagePort",
+    "Navigator",
+    "Node",
+    "OrientationLockType",
+    "OrientationType",
+    "PageTransitionEvent",
+    "Permissions",
+    "PermissionState",
+    "PermissionStatus",
+    "PointerEvent",
+    "PremultiplyAlpha",
+    "ResizeObserver",
+    "ResizeObserverBoxOptions",
+    "ResizeObserverEntry",
+    "ResizeObserverOptions",
+    "ResizeObserverSize",
+    "Screen",
+    "ScreenOrientation",
+    "Url",
+    "VisibilityState",
+    "WheelEvent",
+    "Window",
+    "Worker",
+]
+package = "web-sys"
+
+[target.'cfg(target_family = "wasm")'.dev-dependencies.console_error_panic_hook]
+version = "0.1"
+
+[target.'cfg(target_family = "wasm")'.dev-dependencies.tracing-web]
+version = "0.1"
+
+[target.'cfg(target_os = "android")'.dependencies.android-activity]
+version = "0.6.0"
+
+[target.'cfg(target_os = "android")'.dependencies.ndk]
+version = "0.9.0"
+default-features = false
+
+[target.'cfg(target_os = "ios")'.dependencies.objc2-foundation]
+version = "0.2.2"
+features = [
+    "block2",
+    "dispatch",
+    "NSArray",
+    "NSEnumerator",
+    "NSGeometry",
+    "NSObjCRuntime",
+    "NSOperation",
+    "NSString",
+    "NSProcessInfo",
+    "NSThread",
+    "NSSet",
+]
+
+[target.'cfg(target_os = "ios")'.dependencies.objc2-ui-kit]
+version = "0.2.2"
+features = [
+    "UIApplication",
+    "UIDevice",
+    "UIEvent",
+    "UIGeometry",
+    "UIGestureRecognizer",
+    "UITextInput",
+    "UITextInputTraits",
+    "UIOrientation",
+    "UIPanGestureRecognizer",
+    "UIPinchGestureRecognizer",
+    "UIResponder",
+    "UIRotationGestureRecognizer",
+    "UIScreen",
+    "UIScreenMode",
+    "UITapGestureRecognizer",
+    "UITouch",
+    "UITraitCollection",
+    "UIView",
+    "UIViewController",
+    "UIWindow",
+]
+
+[target.'cfg(target_os = "macos")'.dependencies.core-graphics]
+version = "0.23.1"
+
+[target.'cfg(target_os = "macos")'.dependencies.objc2-app-kit]
+version = "0.2.2"
+features = [
+    "NSAppearance",
+    "NSApplication",
+    "NSBitmapImageRep",
+    "NSButton",
+    "NSColor",
+    "NSControl",
+    "NSCursor",
+    "NSDragging",
+    "NSEvent",
+    "NSGraphics",
+    "NSGraphicsContext",
+    "NSImage",
+    "NSImageRep",
+    "NSMenu",
+    "NSMenuItem",
+    "NSOpenGLView",
+    "NSPasteboard",
+    "NSResponder",
+    "NSRunningApplication",
+    "NSScreen",
+    "NSTextInputClient",
+    "NSTextInputContext",
+    "NSView",
+    "NSWindow",
+    "NSWindowScripting",
+    "NSWindowTabGroup",
+]
+
+[target.'cfg(target_os = "macos")'.dependencies.objc2-foundation]
+version = "0.2.2"
+features = [
+    "block2",
+    "dispatch",
+    "NSArray",
+    "NSAttributedString",
+    "NSData",
+    "NSDictionary",
+    "NSDistributedNotificationCenter",
+    "NSEnumerator",
+    "NSKeyValueObserving",
+    "NSNotification",
+    "NSObjCRuntime",
+    "NSPathUtilities",
+    "NSProcessInfo",
+    "NSRunLoop",
+    "NSString",
+    "NSThread",
+    "NSValue",
+]
+
+[target.'cfg(target_os = "redox")'.dependencies.orbclient]
+version = "0.3.47"
+default-features = false
+
+[target.'cfg(target_os = "redox")'.dependencies.redox_syscall]
+version = "0.4.1"
+
+[target.'cfg(target_os = "windows")'.dependencies.unicode-segmentation]
+version = "1.7.1"
+
+[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
+version = "0.52.0"
+features = [
+    "Win32_Devices_HumanInterfaceDevice",
+    "Win32_Foundation",
+    "Win32_Globalization",
+    "Win32_Graphics_Dwm",
+    "Win32_Graphics_Gdi",
+    "Win32_Media",
+    "Win32_System_Com_StructuredStorage",
+    "Win32_System_Com",
+    "Win32_System_LibraryLoader",
+    "Win32_System_Ole",
+    "Win32_Security",
+    "Win32_System_SystemInformation",
+    "Win32_System_SystemServices",
+    "Win32_System_Threading",
+    "Win32_System_WindowsProgramming",
+    "Win32_UI_Accessibility",
+    "Win32_UI_Controls",
+    "Win32_UI_HiDpi",
+    "Win32_UI_Input_Ime",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Input_Pointer",
+    "Win32_UI_Input_Touch",
+    "Win32_UI_Shell",
+    "Win32_UI_TextServices",
+    "Win32_UI_WindowsAndMessaging",
+]

vendor/winit/FEATURES.md

@@ -0,0 +1,248 @@
+# Winit Scope
+
+Winit aims to expose an interface that abstracts over window creation and input handling and can
+be used to create both games and applications. It supports the following main graphical platforms:
+- Desktop
+  - Windows
+  - macOS
+  - Unix
+    - via X11
+    - via Wayland
+  - Redox OS, via Orbital
+- Mobile
+  - iOS
+  - Android
+- Web
+
+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
+available everywhere. In this context, APIs exposed in winit can be split into different "support tiers":
+
+- **Core:** Features that are essential to providing a well-formed abstraction over each platform's
+  windowing and input APIs.
+- **Platform:** Platform-specific features that can't be meaningfully exposed through a common API and
+  cannot be implemented outside of Winit without exposing a significant amount of Winit's internals
+  or interfering with Winit's abstractions.
+- **Usability:** Features that are not strictly essential to Winit's functionality, but provide meaningful
+  usability improvements and cannot be reasonably implemented in an external crate. These are
+  generally optional and exposed through Cargo features.
+
+Core features are taken care of by the core Winit maintainers. Platform features are not.
+When a platform feature is submitted, the submitter is considered the expert in the
+feature and may be asked to support the feature should it break in the future.
+
+Winit ***does not*** directly expose functionality for drawing inside windows or creating native
+menus, but ***does*** commit to providing APIs that higher-level crates can use to implement that
+functionality.
+
+## `1.0` and stability
+
+When all core features are implemented to the satisfaction of the Winit maintainers, Winit 1.0 will
+be released and the library will enter maintenance mode. For the most part, new core features will not
+be added past this point. New platform features may be accepted and exposed through point releases.
+
+### Tier upgrades
+Some platform features could, in theory, be exposed across multiple platforms, but have not gone
+through the implementation work necessary to function on all platforms. When one of these features
+gets implemented across all platforms, a PR can be opened to upgrade the feature to a core feature.
+If that gets accepted, the platform-specific functions get deprecated and become permanently
+exposed through the core, cross-platform API.
+
+# Features
+
+## Extending this section
+
+If your PR makes notable changes to Winit's features, please update this section as follows:
+
+- If your PR adds a new feature, add a brief description to the relevant section. If the feature is a core
+  feature, add a row to the feature matrix and describe what platforms the feature has been implemented on.
+
+- If your PR begins a new API rework, add a row to the `Pending API Reworks` table. If the PR implements the
+  API rework on all relevant platforms, please move it to the `Completed API Reworks` table.
+
+- If your PR implements an already-existing feature on a new platform, either mark the feature as *completed*,
+  or mark it as *mostly completed* and link to an issue describing the problems with the implementation.
+
+## Core
+
+### Windowing
+- **Window initialization**: Winit allows the creation of a window
+- **Providing pointer to init OpenGL**: Winit provides the necessary pointers to initialize a working opengl context
+- **Providing pointer to init Vulkan**: Same as OpenGL but for Vulkan
+- **Window decorations**: The windows created by winit are properly decorated, and the decorations can
+  be deactivated
+- **Window decorations toggle**: Decorations can be turned on or off after window creation
+- **Window resizing**: The windows created by winit can be resized and generate the appropriate events
+  when they are. The application can precisely control its window size if desired.
+- **Window resize increments**: When the window gets resized, the application can choose to snap the window's
+  size to specific values.
+- **Window transparency**: Winit allows the creation of windows with a transparent background.
+- **Window maximization**: The windows created by winit can be maximized upon creation.
+- **Window maximization toggle**: The windows created by winit can be maximized and unmaximized after
+  creation.
+- **Window minimization**: The windows created by winit can be minimized after creation.
+- **Fullscreen**: The windows created by winit can be put into fullscreen mode.
+- **Fullscreen toggle**: The windows created by winit can be switched to and from fullscreen after
+  creation.
+- **Exclusive fullscreen**: Winit allows changing the video mode of the monitor
+  for fullscreen windows and, if applicable, captures the monitor for exclusive
+  use by this application.
+- **HiDPI support**: Winit assists developers in appropriately scaling HiDPI content.
+- **Popup / modal windows**: Windows can be created relative to the client area of other windows, and parent
+  windows can be disabled in favor of popup windows. This feature also guarantees that popup windows
+  get drawn above their owner.
+
+
+### System Information
+- **Monitor list**: Retrieve the list of monitors and their metadata, including which one is primary.
+- **Video mode query**: Monitors can be queried for their supported fullscreen video modes (consisting of resolution, refresh rate, and bit depth).
+
+### Input Handling
+- **Mouse events**: Generating mouse events associated with pointer motion, click, and scrolling events.
+- **Mouse set location**: Forcibly changing the location of the pointer.
+- **Cursor locking**: Locking the cursor inside the window so it cannot move.
+- **Cursor confining**: Confining the cursor to the window bounds so it cannot leave them.
+- **Cursor icon**: Changing the cursor icon or hiding the cursor.
+- **Cursor image**: Changing the cursor to your own image.
+- **Cursor hittest**: Handle or ignore mouse events for a window.
+- **Touch events**: Single-touch events.
+- **Touch pressure**: Touch events contain information about the amount of force being applied.
+- **Multitouch**: Multi-touch events, including cancellation of a gesture.
+- **Keyboard events**: Properly processing keyboard events using the user-specified keymap and
+  translating keypresses into UTF-8 characters, handling dead keys and IMEs.
+- **Drag & Drop**: Dragging content into winit, detecting when content enters, drops, or if the drop is cancelled.
+- **Raw Device Events**: Capturing input from input devices without any OS filtering.
+- **Gamepad/Joystick events**: Capturing input from gamepads and joysticks.
+- **Device movement events**: Capturing input from the device gyroscope and accelerometer.
+
+## Platform
+### Windows
+* Setting the name of the internal window class
+* Setting the taskbar icon
+* Setting the parent window
+* Setting a menu bar
+* `WS_EX_NOREDIRECTIONBITMAP` support
+* Theme the title bar according to Windows 10 Dark Mode setting or set a preferred theme
+* Changing a system-drawn backdrop
+* Setting the window border color
+* Setting the title bar background color
+* Setting the title color
+* Setting the corner rounding preference
+
+### macOS
+* Window activation policy
+* Window movable by background
+* Transparent titlebar
+* Hidden titlebar
+* Hidden titlebar buttons
+* Full-size content view
+* Accepts first mouse
+* Set a preferred theme and get current theme.
+
+### Unix
+* Window urgency
+* X11 Window Class
+* X11 Override Redirect Flag
+* GTK Theme Variant
+* Base window size
+* Setting the X11 parent window
+
+### iOS
+* Get the `UIScreen` object pointer
+* Setting the `UIView` hidpi factor
+* Valid orientations
+* Home indicator visibility
+* Status bar visibility and style
+* Deferring system gestures
+* Getting the device idiom
+* Getting the preferred video mode
+
+### Web
+* Get if the systems preferred color scheme is "dark"
+
+## Compatibility Matrix
+
+Legend:
+
+- ✔️: Works as intended
+- ▢: Mostly works, but some bugs are known
+- ❌: Missing feature or large bugs making it unusable
+- **N/A**: Not applicable for this platform
+- ❓: Unknown status
+
+### Windowing
+|Feature                          |Windows|MacOS   |Linux x11   |Linux Wayland  |Android|iOS    |Web      |Redox OS|
+|-------------------------------- | ----- | ----   | -------    | -----------   | ----- | ----- | -------- | ------ |
+|Window initialization            |✔️     |✔️     |▢[#5]      |✔️             |▢[#33]|▢[#33] |✔️        |✔️      |
+|Providing pointer to init OpenGL |✔️     |✔️     |✔️         |✔️             |✔️     |✔️    |**N/A**|✔️      |
+|Providing pointer to init Vulkan |✔️     |✔️     |✔️         |✔️             |✔️     |❓     |**N/A**|**N/A** |
+|Window decorations               |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|✔️      |
+|Window decorations toggle        |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Window resizing                  |✔️     |✔️     |✔️         |✔️        |**N/A**|**N/A**|✔️        |✔️      |
+|Window resize increments         |✔️     |✔️     |✔️         |❌             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Window transparency              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|N/A        |✔️      |
+|Window blur                      |❌    |❌    |❌        |✔️             |**N/A**|**N/A**|N/A        |❌     |
+|Window maximization              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Window maximization toggle       |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Window minimization              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Fullscreen                       |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |**N/A** |
+|Fullscreen toggle                |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |**N/A** |
+|Exclusive fullscreen             |✔️     |✔️     |✔️         |**N/A**         |❌    |✔️     |**N/A**|**N/A** |
+|HiDPI support                    |✔️     |✔️     |✔️         |✔️             |✔️     |✔️    |✔️    |❌      |
+|Popup windows                    |❌     |❌     |❌         |❌             |❌    |❌     |**N/A**|**N/A** |
+
+### System information
+|Feature          |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS      |Web      |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|
+|----------------------- | -----    | ----   | ------- | ----------- | ----- | ----- | -------- | ------ |
+|Mouse events            |✔️       |▢[#63]  |✔️       |✔️          |**N/A**|**N/A**|✔️        |✔️      |
+|Mouse set location      |✔️       |✔️      |✔️       |✔️(when locked)  |**N/A**|**N/A**|**N/A**|**N/A** |
+|Cursor locking          |❌       |✔️      |❌       |✔️          |**N/A**|**N/A**|✔️        |❌      |
+|Cursor confining        |✔️       |❌      |✔️       |✔️          |**N/A**|**N/A**|❌       |❌      |
+|Cursor icon             |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|✔️        |**N/A** |
+|Cursor image            |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|✔️        |**N/A** |
+|Cursor hittest          |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|❌        |❌      |
+|Touch events            |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |✔️        |**N/A** |
+|Touch pressure          |✔️       |❌      |❌       |❌          |❌    |✔️     |✔️        |**N/A** |
+|Multitouch              |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |❌        |**N/A** |
+|Keyboard events         |✔️       |✔️      |✔️       |✔️          |✔️    |❌     |✔️        |✔️      |
+|Drag & Drop             |▢[#720]  |▢[#720] |▢[#720]  |▢[#720]   |**N/A**|**N/A**|❓        |**N/A** |
+|Raw Device Events       |▢[#750]  |▢[#750] |▢[#750]  |❌          |❌    |❌     |❓        |**N/A** |
+|Gamepad/Joystick events |❌[#804] |❌      |❌       |❌          |❌    |❌     |❓        |**N/A** |
+|Device movement events  |❓        |❓       |❓       |❓           |❌    |❌     |❓        |**N/A** |
+|Drag window 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|
+|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- | ------ |
+|New API for HiDPI ([#315] [#319])   |✔️      |✔️     |✔️        |✔️            |✔️      |✔️      |❓        |❓      |
+|Event Loop 2.0 ([#459])             |✔️      |✔️     |✔️        |✔️            |✔️      |✔️      |❓        |✔️       |
+|Keyboard Input 2.0 ([#753])         |✔️      |✔️     |✔️        |✔️            |✔️      |❌     |✔️         |✔️       |
+
+### Completed API Reworks
+|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |Web      |Redox OS|
+|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- | ------ |
+
+[#165]: https://github.com/rust-windowing/winit/issues/165
+[#219]: https://github.com/rust-windowing/winit/issues/219
+[#242]: https://github.com/rust-windowing/winit/issues/242
+[#306]: https://github.com/rust-windowing/winit/issues/306
+[#315]: https://github.com/rust-windowing/winit/issues/315
+[#319]: https://github.com/rust-windowing/winit/issues/319
+[#33]: https://github.com/rust-windowing/winit/issues/33
+[#459]: https://github.com/rust-windowing/winit/issues/459
+[#5]: https://github.com/rust-windowing/winit/issues/5
+[#63]: https://github.com/rust-windowing/winit/issues/63
+[#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

vendor/winit/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/winit/build.rs

@@ -0,0 +1,27 @@
+use cfg_aliases::cfg_aliases;
+
+fn main() {
+    // The script doesn't depend on our code.
+    println!("cargo:rerun-if-changed=build.rs");
+
+    // Setup cfg aliases.
+    cfg_aliases! {
+        // Systems.
+        android_platform: { target_os = "android" },
+        web_platform: { all(target_family = "wasm", target_os = "unknown") },
+        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")) },
+        redox: { target_os = "redox" },
+
+        // Native displays.
+        x11_platform: { all(feature = "x11", free_unix, not(redox)) },
+        wayland_platform: { all(feature = "wayland", free_unix, not(redox)) },
+        orbital_platform: { redox },
+    }
+
+    // Winit defined cfgs.
+    println!("cargo:rustc-check-cfg=cfg(unreleased_changelogs)");
+}

vendor/winit/docs/res/ATTRIBUTION.md

@@ -0,0 +1,11 @@
+# Image Attribution
+
+These images are used in the documentation of `winit`.
+
+## keyboard_*.svg
+
+These files are a modified version of "[ANSI US QWERTY (Windows)](https://commons.wikimedia.org/wiki/File:ANSI_US_QWERTY_(Windows).svg)"
+by [Tomiĉo] (https://commons.wikimedia.org/wiki/User:Tomi%C4%89o). It was
+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.

vendor/winit/examples/child_window.rs

@@ -0,0 +1,88 @@
+#[cfg(all(feature = "rwh_06", any(x11_platform, macos_platform, windows_platform)))]
+#[allow(deprecated)]
+fn main() -> Result<(), impl std::error::Error> {
+    use std::collections::HashMap;
+
+    use winit::dpi::{LogicalPosition, LogicalSize, Position};
+    use winit::event::{ElementState, Event, KeyEvent, WindowEvent};
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::raw_window_handle::HasRawWindowHandle;
+    use winit::window::Window;
+
+    #[path = "util/fill.rs"]
+    mod fill;
+
+    fn spawn_child_window(parent: &Window, event_loop: &ActiveEventLoop) -> Window {
+        let parent = parent.raw_window_handle().unwrap();
+        let mut window_attributes = Window::default_attributes()
+            .with_title("child window")
+            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
+            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
+            .with_visible(true);
+        // `with_parent_window` is unsafe. Parent window must be a valid window.
+        window_attributes = unsafe { window_attributes.with_parent_window(Some(parent)) };
+
+        event_loop.create_window(window_attributes).unwrap()
+    }
+
+    let mut windows = HashMap::new();
+
+    let event_loop: EventLoop<()> = EventLoop::new().unwrap();
+    let mut parent_window_id = None;
+
+    event_loop.run(move |event: Event<()>, event_loop| {
+        match event {
+            Event::Resumed => {
+                let attributes = Window::default_attributes()
+                    .with_title("parent window")
+                    .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
+                    .with_inner_size(LogicalSize::new(640.0f32, 480.0f32));
+                let window = event_loop.create_window(attributes).unwrap();
+
+                parent_window_id = Some(window.id());
+
+                println!("Parent window id: {parent_window_id:?})");
+                windows.insert(window.id(), window);
+            },
+            Event::WindowEvent { window_id, event } => match event {
+                WindowEvent::CloseRequested => {
+                    windows.clear();
+                    event_loop.exit();
+                },
+                WindowEvent::CursorEntered { device_id: _ } => {
+                    // On x11, println when the cursor entered in a window even if the child window
+                    // is created by some key inputs.
+                    // the child windows are always placed at (0, 0) with size (200, 200) in the
+                    // parent window, so we also can see this log when we move
+                    // the cursor around (200, 200) in parent window.
+                    println!("cursor entered in the window {window_id:?}");
+                },
+                WindowEvent::KeyboardInput {
+                    event: KeyEvent { state: ElementState::Pressed, .. },
+                    ..
+                } => {
+                    let parent_window = windows.get(&parent_window_id.unwrap()).unwrap();
+                    let child_window = spawn_child_window(parent_window, event_loop);
+                    let child_id = child_window.id();
+                    println!("Child window created with id: {child_id:?}");
+                    windows.insert(child_id, child_window);
+                },
+                WindowEvent::RedrawRequested => {
+                    if let Some(window) = windows.get(&window_id) {
+                        fill::fill_window(window);
+                    }
+                },
+                _ => (),
+            },
+            _ => (),
+        }
+    })
+}
+
+#[cfg(all(feature = "rwh_06", not(any(x11_platform, macos_platform, windows_platform))))]
+fn main() {
+    panic!(
+        "This example is supported only on x11, macOS, and Windows, with the `rwh_06` feature \
+         enabled."
+    );
+}

vendor/winit/examples/control_flow.rs

@@ -0,0 +1,148 @@
+#![allow(clippy::single_match)]
+
+use std::thread;
+#[cfg(not(web_platform))]
+use std::time;
+
+use ::tracing::{info, warn};
+#[cfg(web_platform)]
+use web_time as time;
+
+use winit::application::ApplicationHandler;
+use winit::event::{ElementState, KeyEvent, StartCause, WindowEvent};
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
+use winit::keyboard::{Key, NamedKey};
+use winit::window::{Window, WindowId};
+
+#[path = "util/fill.rs"]
+mod fill;
+#[path = "util/tracing.rs"]
+mod tracing;
+
+const WAIT_TIME: time::Duration = time::Duration::from_millis(100);
+const POLL_SLEEP_TIME: time::Duration = time::Duration::from_millis(100);
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+enum Mode {
+    #[default]
+    Wait,
+    WaitUntil,
+    Poll,
+}
+
+fn main() -> Result<(), impl std::error::Error> {
+    #[cfg(web_platform)]
+    console_error_panic_hook::set_once();
+
+    tracing::init();
+
+    info!("Press '1' to switch to Wait mode.");
+    info!("Press '2' to switch to WaitUntil mode.");
+    info!("Press '3' to switch to Poll mode.");
+    info!("Press 'R' to toggle request_redraw() calls.");
+    info!("Press 'Esc' to close the window.");
+
+    let event_loop = EventLoop::new().unwrap();
+
+    let mut app = ControlFlowDemo::default();
+    event_loop.run_app(&mut app)
+}
+
+#[derive(Default)]
+struct ControlFlowDemo {
+    mode: Mode,
+    request_redraw: bool,
+    wait_cancelled: bool,
+    close_requested: bool,
+    window: Option<Window>,
+}
+
+impl ApplicationHandler for ControlFlowDemo {
+    fn new_events(&mut self, _event_loop: &ActiveEventLoop, cause: StartCause) {
+        info!("new_events: {cause:?}");
+
+        self.wait_cancelled = match cause {
+            StartCause::WaitCancelled { .. } => self.mode == Mode::WaitUntil,
+            _ => false,
+        }
+    }
+
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        let window_attributes = Window::default_attributes().with_title(
+            "Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.",
+        );
+        self.window = Some(event_loop.create_window(window_attributes).unwrap());
+    }
+
+    fn window_event(
+        &mut self,
+        _event_loop: &ActiveEventLoop,
+        _window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        info!("{event:?}");
+
+        match event {
+            WindowEvent::CloseRequested => {
+                self.close_requested = true;
+            },
+            WindowEvent::KeyboardInput {
+                event: KeyEvent { logical_key: key, state: ElementState::Pressed, .. },
+                ..
+            } => match key.as_ref() {
+                // WARNING: Consider using `key_without_modifiers()` if available on your platform.
+                // See the `key_binding` example
+                Key::Character("1") => {
+                    self.mode = Mode::Wait;
+                    warn!("mode: {:?}", self.mode);
+                },
+                Key::Character("2") => {
+                    self.mode = Mode::WaitUntil;
+                    warn!("mode: {:?}", self.mode);
+                },
+                Key::Character("3") => {
+                    self.mode = Mode::Poll;
+                    warn!("mode: {:?}", self.mode);
+                },
+                Key::Character("r") => {
+                    self.request_redraw = !self.request_redraw;
+                    warn!("request_redraw: {}", self.request_redraw);
+                },
+                Key::Named(NamedKey::Escape) => {
+                    self.close_requested = true;
+                },
+                _ => (),
+            },
+            WindowEvent::RedrawRequested => {
+                let window = self.window.as_ref().unwrap();
+                window.pre_present_notify();
+                fill::fill_window(window);
+            },
+            _ => (),
+        }
+    }
+
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        if self.request_redraw && !self.wait_cancelled && !self.close_requested {
+            self.window.as_ref().unwrap().request_redraw();
+        }
+
+        match self.mode {
+            Mode::Wait => event_loop.set_control_flow(ControlFlow::Wait),
+            Mode::WaitUntil => {
+                if !self.wait_cancelled {
+                    event_loop
+                        .set_control_flow(ControlFlow::WaitUntil(time::Instant::now() + WAIT_TIME));
+                }
+            },
+            Mode::Poll => {
+                thread::sleep(POLL_SLEEP_TIME);
+                event_loop.set_control_flow(ControlFlow::Poll);
+            },
+        };
+
+        if self.close_requested {
+            event_loop.exit();
+        }
+    }
+}

vendor/winit/examples/pump_events.rs

@@ -0,0 +1,80 @@
+#![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;
+    use std::thread::sleep;
+    use std::time::Duration;
+
+    use winit::application::ApplicationHandler;
+    use winit::event::WindowEvent;
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::platform::pump_events::{EventLoopExtPumpEvents, PumpStatus};
+    use winit::window::{Window, WindowId};
+
+    #[path = "util/fill.rs"]
+    mod fill;
+
+    #[derive(Default)]
+    struct PumpDemo {
+        window: Option<Window>,
+    }
+
+    impl ApplicationHandler for PumpDemo {
+        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+            let window_attributes = Window::default_attributes().with_title("A fantastic window!");
+            self.window = Some(event_loop.create_window(window_attributes).unwrap());
+        }
+
+        fn window_event(
+            &mut self,
+            event_loop: &ActiveEventLoop,
+            _window_id: WindowId,
+            event: WindowEvent,
+        ) {
+            println!("{event:?}");
+
+            let window = match self.window.as_ref() {
+                Some(window) => window,
+                None => return,
+            };
+
+            match event {
+                WindowEvent::CloseRequested => event_loop.exit(),
+                WindowEvent::RedrawRequested => {
+                    fill::fill_window(window);
+                    window.request_redraw();
+                },
+                _ => (),
+            }
+        }
+    }
+
+    let mut event_loop = EventLoop::new().unwrap();
+
+    tracing_subscriber::fmt::init();
+
+    let mut app = PumpDemo::default();
+
+    loop {
+        let timeout = Some(Duration::ZERO);
+        let status = event_loop.pump_app_events(timeout, &mut app);
+
+        if let PumpStatus::Exit(exit_code) = status {
+            break 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, web_platform, orbital_platform))]
+fn main() {
+    println!("This platform doesn't support pump_events.");
+}

vendor/winit/examples/run_on_demand.rs

@@ -0,0 +1,99 @@
+#![allow(clippy::single_match)]
+
+// Limit this example to only compatible platforms.
+#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform,))]
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    use std::time::Duration;
+
+    use winit::application::ApplicationHandler;
+    use winit::event::WindowEvent;
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::platform::run_on_demand::EventLoopExtRunOnDemand;
+    use winit::window::{Window, WindowId};
+
+    #[path = "util/fill.rs"]
+    mod fill;
+
+    #[derive(Default)]
+    struct App {
+        idx: usize,
+        window_id: Option<WindowId>,
+        window: Option<Window>,
+    }
+
+    impl ApplicationHandler for App {
+        fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
+            if let Some(window) = self.window.as_ref() {
+                window.request_redraw();
+            }
+        }
+
+        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+            let window_attributes = Window::default_attributes()
+                .with_title("Fantastic window number one!")
+                .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0));
+            let window = event_loop.create_window(window_attributes).unwrap();
+            self.window_id = Some(window.id());
+            self.window = Some(window);
+        }
+
+        fn window_event(
+            &mut self,
+            event_loop: &ActiveEventLoop,
+            window_id: WindowId,
+            event: WindowEvent,
+        ) {
+            if event == WindowEvent::Destroyed && self.window_id == Some(window_id) {
+                println!(
+                    "--------------------------------------------------------- Window {} Destroyed",
+                    self.idx
+                );
+                self.window_id = None;
+                event_loop.exit();
+                return;
+            }
+
+            let window = match self.window.as_mut() {
+                Some(window) => window,
+                None => return,
+            };
+
+            match event {
+                WindowEvent::CloseRequested => {
+                    println!(
+                        "--------------------------------------------------------- Window {} \
+                         CloseRequested",
+                        self.idx
+                    );
+                    fill::cleanup_window(window);
+                    self.window = None;
+                },
+                WindowEvent::RedrawRequested => {
+                    fill::fill_window(window);
+                },
+                _ => (),
+            }
+        }
+    }
+
+    tracing_subscriber::fmt::init();
+
+    let mut event_loop = EventLoop::new().unwrap();
+
+    let mut app = App { idx: 1, ..Default::default() };
+    event_loop.run_app_on_demand(&mut app)?;
+
+    println!("--------------------------------------------------------- Finished first loop");
+    println!("--------------------------------------------------------- Waiting 5 seconds");
+    std::thread::sleep(Duration::from_secs(5));
+
+    app.idx += 1;
+    event_loop.run_app_on_demand(&mut app)?;
+    println!("--------------------------------------------------------- Finished second loop");
+    Ok(())
+}
+
+#[cfg(not(any(windows_platform, macos_platform, x11_platform, wayland_platform,)))]
+fn main() {
+    println!("This example is not supported on this platform");
+}

vendor/winit/examples/util/fill.rs

@@ -0,0 +1,117 @@
+//! 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.
+
+#[allow(unused_imports)]
+pub use platform::cleanup_window;
+pub use platform::fill_window;
+
+#[cfg(all(feature = "rwh_05", not(any(target_os = "android", target_os = "ios"))))]
+mod platform {
+    use std::cell::RefCell;
+    use std::collections::HashMap;
+    use std::mem;
+    use std::mem::ManuallyDrop;
+    use std::num::NonZeroU32;
+
+    use softbuffer::{Context, Surface};
+    use winit::window::{Window, WindowId};
+
+    thread_local! {
+        // NOTE: You should never do things like that, create context and drop it before
+        // you drop the event loop. We do this for brevity to not blow up examples. We use
+        // ManuallyDrop to prevent destructors from running.
+        //
+        // A static, thread-local map of graphics contexts to open windows.
+        static GC: ManuallyDrop<RefCell<Option<GraphicsContext>>> = const { ManuallyDrop::new(RefCell::new(None)) };
+    }
+
+    /// The graphics context used to draw to a window.
+    struct GraphicsContext {
+        /// The global softbuffer context.
+        context: RefCell<Context<&'static Window>>,
+
+        /// The hash map of window IDs to surfaces.
+        surfaces: HashMap<WindowId, Surface<&'static Window, &'static Window>>,
+    }
+
+    impl GraphicsContext {
+        fn new(w: &Window) -> Self {
+            Self {
+                context: RefCell::new(
+                    Context::new(unsafe { mem::transmute::<&'_ Window, &'static Window>(w) })
+                        .expect("Failed to create a softbuffer context"),
+                ),
+                surfaces: HashMap::new(),
+            }
+        }
+
+        fn create_surface(
+            &mut self,
+            window: &Window,
+        ) -> &mut Surface<&'static Window, &'static Window> {
+            self.surfaces.entry(window.id()).or_insert_with(|| {
+                Surface::new(&self.context.borrow(), unsafe {
+                    mem::transmute::<&'_ Window, &'static Window>(window)
+                })
+                .expect("Failed to create a softbuffer surface")
+            })
+        }
+
+        fn destroy_surface(&mut self, window: &Window) {
+            self.surfaces.remove(&window.id());
+        }
+    }
+
+    pub fn fill_window(window: &Window) {
+        GC.with(|gc| {
+            let size = window.inner_size();
+            let (Some(width), Some(height)) =
+                (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
+            else {
+                return;
+            };
+
+            // Either get the last context used or create a new one.
+            let mut gc = gc.borrow_mut();
+            let surface =
+                gc.get_or_insert_with(|| GraphicsContext::new(window)).create_surface(window);
+
+            // Fill a buffer with a solid color.
+            const DARK_GRAY: u32 = 0xff181818;
+
+            surface.resize(width, height).expect("Failed to resize the softbuffer surface");
+
+            let mut buffer = surface.buffer_mut().expect("Failed to get the softbuffer buffer");
+            buffer.fill(DARK_GRAY);
+            buffer.present().expect("Failed to present the softbuffer buffer");
+        })
+    }
+
+    #[allow(dead_code)]
+    pub fn cleanup_window(window: &Window) {
+        GC.with(|gc| {
+            let mut gc = gc.borrow_mut();
+            if let Some(context) = gc.as_mut() {
+                context.destroy_surface(window);
+            }
+        });
+    }
+}
+
+#[cfg(not(all(feature = "rwh_05", not(any(target_os = "android", target_os = "ios")))))]
+mod platform {
+    pub fn fill_window(_window: &winit::window::Window) {
+        // No-op on mobile platforms.
+    }
+
+    #[allow(dead_code)]
+    pub fn cleanup_window(_window: &winit::window::Window) {
+        // No-op on mobile platforms.
+    }
+}

vendor/winit/examples/util/tracing.rs

@@ -0,0 +1,25 @@
+#[cfg(not(web_platform))]
+pub fn init() {
+    use tracing_subscriber::filter::{EnvFilter, LevelFilter};
+
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            EnvFilter::builder().with_default_directive(LevelFilter::INFO.into()).from_env_lossy(),
+        )
+        .init();
+}
+
+#[cfg(web_platform)]
+pub fn init() {
+    use tracing_subscriber::layer::SubscriberExt;
+    use tracing_subscriber::util::SubscriberInitExt;
+
+    tracing_subscriber::registry()
+        .with(
+            tracing_subscriber::fmt::layer()
+                .with_ansi(false)
+                .without_time()
+                .with_writer(tracing_web::MakeWebConsoleWriter::new()),
+        )
+        .init();
+}

vendor/winit/examples/x11_embed.rs

@@ -0,0 +1,69 @@
+//! A demonstration of embedding a winit window in an existing X11 application.
+use std::error::Error;
+
+#[cfg(x11_platform)]
+fn main() -> Result<(), Box<dyn Error>> {
+    use winit::application::ApplicationHandler;
+    use winit::event::WindowEvent;
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::platform::x11::WindowAttributesExtX11;
+    use winit::window::{Window, WindowId};
+
+    #[path = "util/fill.rs"]
+    mod fill;
+
+    pub struct XEmbedDemo {
+        parent_window_id: u32,
+        window: Option<Window>,
+    }
+
+    impl ApplicationHandler for XEmbedDemo {
+        fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+            let window_attributes = Window::default_attributes()
+                .with_title("An embedded window!")
+                .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
+                .with_embed_parent_window(self.parent_window_id);
+
+            self.window = Some(event_loop.create_window(window_attributes).unwrap());
+        }
+
+        fn window_event(
+            &mut self,
+            event_loop: &ActiveEventLoop,
+            _window_id: WindowId,
+            event: WindowEvent,
+        ) {
+            let window = self.window.as_ref().unwrap();
+            match event {
+                WindowEvent::CloseRequested => event_loop.exit(),
+                WindowEvent::RedrawRequested => {
+                    window.pre_present_notify();
+                    fill::fill_window(window);
+                },
+                _ => (),
+            }
+        }
+
+        fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
+            self.window.as_ref().unwrap().request_redraw();
+        }
+    }
+
+    // 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>()?;
+
+    tracing_subscriber::fmt::init();
+    let event_loop = EventLoop::new()?;
+
+    let mut app = XEmbedDemo { parent_window_id, window: None };
+    event_loop.run_app(&mut app).map_err(Into::into)
+}
+
+#[cfg(not(x11_platform))]
+fn main() -> Result<(), Box<dyn Error>> {
+    println!("This example is only supported on X11 platforms.");
+    Ok(())
+}

vendor/winit/src/application.rs

@@ -0,0 +1,339 @@
+//! End user application handling.
+
+use crate::event::{DeviceEvent, DeviceId, StartCause, WindowEvent};
+use crate::event_loop::ActiveEventLoop;
+use crate::window::WindowId;
+
+/// The handler of the application events.
+pub trait ApplicationHandler<T: 'static = ()> {
+    /// Emitted when new events arrive from the OS to be processed.
+    ///
+    /// This is a useful place to put code that should be done before you start processing
+    /// events, such as updating frame timing information for benchmarking or checking the
+    /// [`StartCause`] to see if a timer set by
+    /// [`ControlFlow::WaitUntil`][crate::event_loop::ControlFlow::WaitUntil] has elapsed.
+    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
+        let _ = (event_loop, cause);
+    }
+
+    /// Emitted when the application has been resumed.
+    ///
+    /// For consistency, all platforms emit a `Resumed` event even if they don't themselves have a
+    /// formal suspend/resume lifecycle. For systems without a formal suspend/resume lifecycle
+    /// the `Resumed` event is always emitted after the
+    /// [`NewEvents(StartCause::Init)`][StartCause::Init] event.
+    ///
+    /// # Portability
+    ///
+    /// It's recommended that applications should only initialize their graphics context and create
+    /// a window after they have received their first `Resumed` event. Some systems
+    /// (specifically Android) won't allow applications to create a render surface until they are
+    /// resumed.
+    ///
+    /// Considering that the implementation of [`Suspended`] and `Resumed` events may be internally
+    /// driven by multiple platform-specific events, and that there may be subtle differences across
+    /// platforms with how these internal events are delivered, it's recommended that applications
+    /// be able to gracefully handle redundant (i.e. back-to-back) [`Suspended`] or `Resumed`
+    /// events.
+    ///
+    /// Also see [`Suspended`] notes.
+    ///
+    /// ## Android
+    ///
+    /// On Android, the `Resumed` event is sent when a new [`SurfaceView`] has been created. This is
+    /// expected to closely correlate with the [`onResume`] lifecycle event but there may
+    /// technically be a discrepancy.
+    ///
+    /// [`onResume`]: https://developer.android.com/reference/android/app/Activity#onResume()
+    ///
+    /// Applications that need to run on Android must wait until they have been `Resumed`
+    /// before they will be able to create a render surface (such as an `EGLSurface`,
+    /// [`VkSurfaceKHR`] or [`wgpu::Surface`]) which depend on having a
+    /// [`SurfaceView`]. Applications must also assume that if they are [`Suspended`], then their
+    /// render surfaces are invalid and should be dropped.
+    ///
+    /// Also see [`Suspended`] notes.
+    ///
+    /// [`SurfaceView`]: https://developer.android.com/reference/android/view/SurfaceView
+    /// [Activity lifecycle]: https://developer.android.com/guide/components/activities/activity-lifecycle
+    /// [`VkSurfaceKHR`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html
+    /// [`wgpu::Surface`]: https://docs.rs/wgpu/latest/wgpu/struct.Surface.html
+    ///
+    /// ## iOS
+    ///
+    /// On iOS, the `Resumed` event is emitted in response to an [`applicationDidBecomeActive`]
+    /// callback which means the application is "active" (according to the
+    /// [iOS application lifecycle]).
+    ///
+    /// [`applicationDidBecomeActive`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622956-applicationdidbecomeactive
+    /// [iOS application lifecycle]: https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle
+    ///
+    /// ## Web
+    ///
+    /// On Web, the `Resumed` event is emitted in response to a [`pageshow`] event
+    /// with the property [`persisted`] being true, which means that the page is being
+    /// restored from the [`bfcache`] (back/forward cache) - an in-memory cache that
+    /// stores a complete snapshot of a page (including the JavaScript heap) as the
+    /// user is navigating away.
+    ///
+    /// [`pageshow`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/pageshow_event
+    /// [`persisted`]: https://developer.mozilla.org/en-US/docs/Web/API/PageTransitionEvent/persisted
+    /// [`bfcache`]: https://web.dev/bfcache/
+    /// [`Suspended`]: Self::suspended
+    fn resumed(&mut self, event_loop: &ActiveEventLoop);
+
+    /// Emitted when an event is sent from [`EventLoopProxy::send_event`].
+    ///
+    /// [`EventLoopProxy::send_event`]: crate::event_loop::EventLoopProxy::send_event
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T) {
+        let _ = (event_loop, event);
+    }
+
+    /// Emitted when the OS sends an event to a winit window.
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        event: WindowEvent,
+    );
+
+    /// Emitted when the OS sends an event to a device.
+    fn device_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        device_id: DeviceId,
+        event: DeviceEvent,
+    ) {
+        let _ = (event_loop, device_id, event);
+    }
+
+    /// Emitted when the event loop is about to block and wait for new events.
+    ///
+    /// Most applications shouldn't need to hook into this event since there is no real relationship
+    /// between how often the event loop needs to wake up and the dispatching of any specific
+    /// events.
+    ///
+    /// High frequency event sources, such as input devices could potentially lead to lots of wake
+    /// ups and also lots of corresponding `AboutToWait` events.
+    ///
+    /// This is not an ideal event to drive application rendering from and instead applications
+    /// should render in response to [`WindowEvent::RedrawRequested`] events.
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        let _ = event_loop;
+    }
+
+    /// Emitted when the application has been suspended.
+    ///
+    /// # Portability
+    ///
+    /// Not all platforms support the notion of suspending applications, and there may be no
+    /// technical way to guarantee being able to emit a `Suspended` event if the OS has
+    /// no formal application lifecycle (currently only Android, iOS, and Web do). For this reason,
+    /// Winit does not currently try to emit pseudo `Suspended` events before the application
+    /// quits on platforms without an application lifecycle.
+    ///
+    /// Considering that the implementation of `Suspended` and [`Resumed`] events may be internally
+    /// driven by multiple platform-specific events, and that there may be subtle differences across
+    /// platforms with how these internal events are delivered, it's recommended that applications
+    /// be able to gracefully handle redundant (i.e. back-to-back) `Suspended` or [`Resumed`]
+    /// events.
+    ///
+    /// Also see [`Resumed`] notes.
+    ///
+    /// ## Android
+    ///
+    /// On Android, the `Suspended` event is only sent when the application's associated
+    /// [`SurfaceView`] is destroyed. This is expected to closely correlate with the [`onPause`]
+    /// lifecycle event but there may technically be a discrepancy.
+    ///
+    /// [`onPause`]: https://developer.android.com/reference/android/app/Activity#onPause()
+    ///
+    /// Applications that need to run on Android should assume their [`SurfaceView`] has been
+    /// destroyed, which indirectly invalidates any existing render surfaces that may have been
+    /// created outside of Winit (such as an `EGLSurface`, [`VkSurfaceKHR`] or [`wgpu::Surface`]).
+    ///
+    /// After being `Suspended` on Android applications must drop all render surfaces before
+    /// the event callback completes, which may be re-created when the application is next
+    /// [`Resumed`].
+    ///
+    /// [`SurfaceView`]: https://developer.android.com/reference/android/view/SurfaceView
+    /// [Activity lifecycle]: https://developer.android.com/guide/components/activities/activity-lifecycle
+    /// [`VkSurfaceKHR`]: https://www.khronos.org/registry/vulkan/specs/1.3-extensions/man/html/VkSurfaceKHR.html
+    /// [`wgpu::Surface`]: https://docs.rs/wgpu/latest/wgpu/struct.Surface.html
+    ///
+    /// ## iOS
+    ///
+    /// On iOS, the `Suspended` event is currently emitted in response to an
+    /// [`applicationWillResignActive`] callback which means that the application is
+    /// about to transition from the active to inactive state (according to the
+    /// [iOS application lifecycle]).
+    ///
+    /// [`applicationWillResignActive`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622950-applicationwillresignactive
+    /// [iOS application lifecycle]: https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle
+    ///
+    /// ## Web
+    ///
+    /// On Web, the `Suspended` event is emitted in response to a [`pagehide`] event
+    /// with the property [`persisted`] being true, which means that the page is being
+    /// put in the [`bfcache`] (back/forward cache) - an in-memory cache that stores a
+    /// complete snapshot of a page (including the JavaScript heap) as the user is
+    /// navigating away.
+    ///
+    /// [`pagehide`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/pagehide_event
+    /// [`persisted`]: https://developer.mozilla.org/en-US/docs/Web/API/PageTransitionEvent/persisted
+    /// [`bfcache`]: https://web.dev/bfcache/
+    /// [`Resumed`]: Self::resumed
+    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
+        let _ = event_loop;
+    }
+
+    /// Emitted when the event loop is being shut down.
+    ///
+    /// This is irreversible - if this method is called, it is guaranteed that the event loop
+    /// will exit right after.
+    fn exiting(&mut self, event_loop: &ActiveEventLoop) {
+        let _ = event_loop;
+    }
+
+    /// Emitted when the application has received a memory warning.
+    ///
+    /// ## Platform-specific
+    ///
+    /// ### Android
+    ///
+    /// On Android, the `MemoryWarning` event is sent when [`onLowMemory`] was called. The
+    /// application must [release memory] or risk being killed.
+    ///
+    /// [`onLowMemory`]: https://developer.android.com/reference/android/app/Application.html#onLowMemory()
+    /// [release memory]: https://developer.android.com/topic/performance/memory#release
+    ///
+    /// ### iOS
+    ///
+    /// On iOS, the `MemoryWarning` event is emitted in response to an
+    /// [`applicationDidReceiveMemoryWarning`] callback. The application must free as much
+    /// memory as possible or risk being terminated, see [how to respond to memory warnings].
+    ///
+    /// [`applicationDidReceiveMemoryWarning`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1623063-applicationdidreceivememorywarni
+    /// [how to respond to memory warnings]: https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle/responding_to_memory_warnings
+    ///
+    /// ### Others
+    ///
+    /// - **macOS / Orbital / Wayland / Web / Windows:** Unsupported.
+    fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
+        let _ = event_loop;
+    }
+}
+
+impl<A: ?Sized + ApplicationHandler<T>, T: 'static> ApplicationHandler<T> for &mut A {
+    #[inline]
+    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
+        (**self).new_events(event_loop, cause);
+    }
+
+    #[inline]
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).resumed(event_loop);
+    }
+
+    #[inline]
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T) {
+        (**self).user_event(event_loop, event);
+    }
+
+    #[inline]
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        (**self).window_event(event_loop, window_id, event);
+    }
+
+    #[inline]
+    fn device_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        device_id: DeviceId,
+        event: DeviceEvent,
+    ) {
+        (**self).device_event(event_loop, device_id, event);
+    }
+
+    #[inline]
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).about_to_wait(event_loop);
+    }
+
+    #[inline]
+    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).suspended(event_loop);
+    }
+
+    #[inline]
+    fn exiting(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).exiting(event_loop);
+    }
+
+    #[inline]
+    fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).memory_warning(event_loop);
+    }
+}
+
+impl<A: ?Sized + ApplicationHandler<T>, T: 'static> ApplicationHandler<T> for Box<A> {
+    #[inline]
+    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
+        (**self).new_events(event_loop, cause);
+    }
+
+    #[inline]
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).resumed(event_loop);
+    }
+
+    #[inline]
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T) {
+        (**self).user_event(event_loop, event);
+    }
+
+    #[inline]
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        (**self).window_event(event_loop, window_id, event);
+    }
+
+    #[inline]
+    fn device_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        device_id: DeviceId,
+        event: DeviceEvent,
+    ) {
+        (**self).device_event(event_loop, device_id, event);
+    }
+
+    #[inline]
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).about_to_wait(event_loop);
+    }
+
+    #[inline]
+    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).suspended(event_loop);
+    }
+
+    #[inline]
+    fn exiting(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).exiting(event_loop);
+    }
+
+    #[inline]
+    fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).memory_warning(event_loop);
+    }
+}

vendor/winit/src/changelog/mod.rs

@@ -0,0 +1,77 @@
+//! # Changelog and migrations
+//!
+//! All notable changes to this project will be documented in this module,
+//! along with migration instructions for larger changes.
+// Put the current entry at the top of this page, for discoverability.
+// See `.cargo/config.toml` for details about `unreleased_changelogs`.
+#![cfg_attr(unreleased_changelogs, doc = include_str!("unreleased.md"))]
+#![cfg_attr(not(unreleased_changelogs), doc = include_str!("v0.30.md"))]
+
+#[doc = include_str!("v0.30.md")]
+pub mod v0_30 {}
+
+#[doc = include_str!("v0.29.md")]
+pub mod v0_29 {}
+
+#[doc = include_str!("v0.28.md")]
+pub mod v0_28 {}
+
+#[doc = include_str!("v0.27.md")]
+pub mod v0_27 {}
+
+#[doc = include_str!("v0.26.md")]
+pub mod v0_26 {}
+
+#[doc = include_str!("v0.25.md")]
+pub mod v0_25 {}
+
+#[doc = include_str!("v0.24.md")]
+pub mod v0_24 {}
+
+#[doc = include_str!("v0.23.md")]
+pub mod v0_23 {}
+
+#[doc = include_str!("v0.22.md")]
+pub mod v0_22 {}
+
+#[doc = include_str!("v0.21.md")]
+pub mod v0_21 {}
+
+#[doc = include_str!("v0.20.md")]
+pub mod v0_20 {}
+
+#[doc = include_str!("v0.19.md")]
+pub mod v0_19 {}
+
+#[doc = include_str!("v0.18.md")]
+pub mod v0_18 {}
+
+#[doc = include_str!("v0.17.md")]
+pub mod v0_17 {}
+
+#[doc = include_str!("v0.16.md")]
+pub mod v0_16 {}
+
+#[doc = include_str!("v0.15.md")]
+pub mod v0_15 {}
+
+#[doc = include_str!("v0.14.md")]
+pub mod v0_14 {}
+
+#[doc = include_str!("v0.13.md")]
+pub mod v0_13 {}
+
+#[doc = include_str!("v0.12.md")]
+pub mod v0_12 {}
+
+#[doc = include_str!("v0.11.md")]
+pub mod v0_11 {}
+
+#[doc = include_str!("v0.10.md")]
+pub mod v0_10 {}
+
+#[doc = include_str!("v0.9.md")]
+pub mod v0_9 {}
+
+#[doc = include_str!("v0.8.md")]
+pub mod v0_8 {}

vendor/winit/src/changelog/unreleased.md

@@ -0,0 +1,45 @@
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+The sections should follow the order `Added`, `Changed`, `Deprecated`,
+`Removed`, and `Fixed`.
+
+Platform specific changed should be added to the end of the section and grouped
+by platform name. Common API additions should have `, implemented` at the end
+for platforms where the API was initially implemented. See the following example
+on how to add them:
+
+```md
+### Added
+
+- Add `Window::turbo()`, implemented on X11, Wayland, and Web.
+- On X11, add `Window::some_rare_api`.
+- On X11, add `Window::even_more_rare_api`.
+- On Wayland, add `Window::common_api`.
+- On Windows, add `Window::some_rare_api`.
+```
+
+When the change requires non-trivial amount of work for users to comply
+with it, the migration guide should be added below the entry, like:
+
+```md
+- Deprecate `Window` creation outside of `EventLoop::run`
+
+  This was done to simply migration in the future. Consider the
+  following code:
+
+  // Code snippet.
+
+  To migrate it we should do X, Y, and then Z, for example:
+
+  // Code snippet.
+
+```
+
+The migration guide could reference other migration examples in the current
+changelog entry.
+
+## Unreleased
+
+### Fixed
+
+- On macOS, fix crash on macOS 26 by using objc2's `relax-sign-encoding` feature.

vendor/winit/src/changelog/v0.10.md

@@ -0,0 +1,13 @@
+## 0.10.1
+
+_Yanked_
+
+## 0.10.0
+
+- Add support for `Touch` for emscripten backend.
+- Added support for `DroppedFile`, `HoveredFile`, and `HoveredFileCancelled` to X11 backend.
+- **Breaking:** `unix::WindowExt` no longer returns pointers for things that aren't actually pointers; `get_xlib_window` now returns `Option<std::os::raw::c_ulong>` and `get_xlib_screen_id` returns `Option<std::os::raw::c_int>`. Additionally, methods that previously returned `libc::c_void` have been changed to return `std::os::raw::c_void`, which are not interchangeable types, so users wanting the former will need to explicitly cast.
+- Added `set_decorations` method to `Window` to allow decorations to be toggled after the window is built. Presently only implemented on X11.
+- Raised the minimum supported version of Rust to 1.20 on MacOS due to usage of associated constants in new versions of cocoa and core-graphics.
+- Added `modifiers` field to `MouseInput`, `MouseWheel`, and `CursorMoved` events to track the modifiers state (`ModifiersState`).
+- Fixed the emscripten backend to return the size of the canvas instead of the size of the window.

vendor/winit/src/changelog/v0.11.md

@@ -0,0 +1,27 @@
+## 0.11.3
+
+- Added `set_min_dimensions` and `set_max_dimensions` methods to `Window`, and implemented on Windows, X11, Wayland, and OSX.
+- On X11, dropping a `Window` actually closes it now, and clicking the window's × button (or otherwise having the WM signal to close it) will result in the window closing.
+- Added `WindowBuilderExt` methods for macos: `with_titlebar_transparent`,
+  `with_title_hidden`, `with_titlebar_buttons_hidden`,
+  `with_fullsize_content_view`.
+- Mapped X11 numpad keycodes (arrows, Home, End, PageUp, PageDown, Insert and Delete) to corresponding virtual keycodes
+
+## 0.11.2
+
+- Impl `Hash`, `PartialEq`, and `Eq` for `events::ModifiersState`.
+- Implement `MonitorId::get_hidpi_factor` for MacOS.
+- Added method `os::macos::MonitorIdExt::get_nsscreen() -> *mut c_void` that gets a `NSScreen` object matching the monitor ID.
+- Send `Awakened` event on Android when event loop is woken up.
+
+## 0.11.1
+
+- Fixed windows not receiving mouse events when click-dragging the mouse outside the client area of a window, on Windows platforms.
+- Added method `os::android::EventsLoopExt:set_suspend_callback(Option<Box<Fn(bool) -> ()>>)` that allows glutin to register a callback when a suspend event happens
+
+## 0.11.0
+
+- Implement `MonitorId::get_dimensions` for Android.
+- Added method `os::macos::WindowBuilderExt::with_movable_by_window_background(bool)` that allows to move a window without a titlebar - `with_decorations(false)`
+- Implement `Window::set_fullscreen`, `Window::set_maximized` and `Window::set_decorations` for Wayland.
+- Added `Caret` as VirtualKeyCode and support OSX ^-Key with german input.

vendor/winit/src/changelog/v0.12.md

@@ -0,0 +1,8 @@
+## 0.12.0
+
+- Added subclass to macos windows so they can be made resizable even with no decorations.
+- Dead keys now work properly on X11, no longer resulting in a panic.
+- On X11, input method creation first tries to use the value from the user's `XMODIFIERS` environment variable, so application developers should no longer need to manually call `XSetLocaleModifiers`. If that fails, fallbacks are tried, which should prevent input method initialization from ever outright failing.
+- Fixed thread safety issues with input methods on X11.
+- Add support for `Touch` for win32 backend.
+- Fixed `Window::get_inner_size` and friends to return the size in pixels instead of points when using HIDPI displays on OSX.

vendor/winit/src/changelog/v0.13.md

@@ -0,0 +1,20 @@
+## 0.13.1
+
+- Ensure necessary `x11-dl` version is used.
+
+## 0.13.0
+
+- Implement `WindowBuilder::with_maximized`, `Window::set_fullscreen`, `Window::set_maximized` and `Window::set_decorations` for MacOS.
+- Implement `WindowBuilder::with_maximized`, `Window::set_fullscreen`, `Window::set_maximized` and `Window::set_decorations` for Windows.
+- On Windows, `WindowBuilder::with_fullscreen` no longer changing monitor display resolution.
+- Overhauled X11 window geometry calculations. `get_position` and `set_position` are more universally accurate across different window managers, and `get_outer_size` actually works now.
+- Fixed SIGSEGV/SIGILL crashes on macOS caused by stabilization of the `!` (never) type.
+- Implement `WindowEvent::HiDPIFactorChanged` for macOS
+- On X11, input methods now work completely out of the box, no longer requiring application developers to manually call `setlocale`. Additionally, when input methods are started, stopped, or restarted on the server end, it's correctly handled.
+- Implemented `Refresh` event on Windows.
+- Properly calculate the minimum and maximum window size on Windows, including window decorations.
+- Map more `MouseCursor` variants to cursor icons on Windows.
+- Corrected `get_position` on macOS to return outer frame position, not content area position.
+- Corrected `set_position` on macOS to set outer frame position, not content area position.
+- Added `get_inner_position` method to `Window`, which gets the position of the window's client area. This is implemented on all applicable platforms (all desktop platforms other than Wayland, where this isn't possible).
+- **Breaking:** the `Closed` event has been replaced by `CloseRequested` and `Destroyed`. To migrate, you typically just need to replace all usages of `Closed` with `CloseRequested`; see example programs for more info. The exception is iOS, where `Closed` must be replaced by `Destroyed`.

vendor/winit/src/changelog/v0.14.md

@@ -0,0 +1,21 @@
+## 0.14.0
+
+- Created the `Copy`, `Paste` and `Cut` `VirtualKeyCode`s and added support for them on X11 and Wayland
+- Fix `.with_decorations(false)` in macOS
+- On Mac, `NSWindow` and supporting objects might be alive long after they were `closed` which resulted in apps consuming more heap then needed. Mainly it was affecting multi window applications. Not expecting any user visible change of behaviour after the fix.
+- Fix regression of Window platform extensions for macOS where `NSFullSizeContentViewWindowMask` was not being correctly applied to `.fullsize_content_view`.
+- Corrected `get_position` on Windows to be relative to the screen rather than to the taskbar.
+- Corrected `Moved` event on Windows to use position values equivalent to those returned by `get_position`. It previously supplied client area positions instead of window positions, and would additionally interpret negative values as being very large (around `u16::MAX`).
+- Implemented `Moved` event on macOS.
+- On X11, the `Moved` event correctly use window positions rather than client area positions. Additionally, a stray `Moved` that unconditionally accompanied `Resized` with the client area position relative to the parent has been eliminated; `Moved` is still received alongside `Resized`, but now only once and always correctly.
+- On Windows, implemented all variants of `DeviceEvent` other than `Text`. Mouse `DeviceEvent`s are now received even if the window isn't in the foreground.
+- `DeviceId` on Windows is no longer a unit struct, and now contains a `u32`. For `WindowEvent`s, this will always be 0, but on `DeviceEvent`s it will be the handle to that device. `DeviceIdExt::get_persistent_identifier` can be used to acquire a unique identifier for that device that persists across replugs/reboots/etc.
+- Corrected `run_forever` on X11 to stop discarding `Awakened` events.
+- Various safety and correctness improvements to the X11 backend internals.
+- Fixed memory leak on X11 every time the mouse entered the window.
+- On X11, drag and drop now works reliably in release mode.
+- Added `WindowBuilderExt::with_resize_increments` and `WindowBuilderExt::with_base_size` to X11, allowing for more optional hints to be set.
+- Rework of the wayland backend, migrating it to use [Smithay's Client Toolkit](https://github.com/Smithay/client-toolkit).
+- Added `WindowBuilder::with_window_icon` and `Window::set_window_icon`, finally making it possible to set the window icon on Windows and X11. The `icon_loading` feature can be enabled to allow for icons to be easily loaded; see example program `window_icon.rs` for usage.
+- Windows additionally has `WindowBuilderExt::with_taskbar_icon` and `WindowExt::set_taskbar_icon`.
+- On Windows, fix panic when trying to call `set_fullscreen(None)` on a window that has not been fullscreened prior.

vendor/winit/src/changelog/v0.15.md

@@ -0,0 +1,42 @@
+## 0.15.1
+
+- On X11, the `Moved` event is no longer sent when the window is resized without changing position.
+- `MouseCursor` and `CursorState` now implement `Default`.
+- `WindowBuilder::with_resizable` implemented for Windows, X11, Wayland, and macOS.
+- `Window::set_resizable` implemented for Windows, X11, Wayland, and macOS.
+- On X11, if the monitor's width or height in millimeters is reported as 0, the DPI is now 1.0 instead of +inf.
+- On X11, the environment variable `WINIT_HIDPI_FACTOR` has been added for overriding DPI factor.
+- On X11, enabling transparency no longer causes the window contents to flicker when resizing.
+- On X11, `with_override_redirect` now actually enables override redirect.
+- macOS now generates `VirtualKeyCode::LAlt` and `VirtualKeyCode::RAlt` instead of `None` for both.
+- On macOS, `VirtualKeyCode::RWin` and `VirtualKeyCode::LWin` are no longer switched.
+- On macOS, windows without decorations can once again be resized.
+- Fixed race conditions when creating an `EventsLoop` on X11, most commonly manifesting as `"[xcb] Unknown sequence number while processing queue"`.
+- On macOS, `CursorMoved` and `MouseInput` events are only generated if they occurs within the window's client area.
+- On macOS, resizing the window no longer generates a spurious `MouseInput` event.
+
+## 0.15.0
+
+- `Icon::to_cardinals` is no longer public, since it was never supposed to be.
+- Wayland: improve diagnostics if initialization fails
+- Fix some system event key doesn't work when focused, do not block keyevent forward to system on macOS
+- On X11, the scroll wheel position is now correctly reset on i3 and other WMs that have the same quirk.
+- On X11, `Window::get_current_monitor` now reliably returns the correct monitor.
+- On X11, `Window::hidpi_factor` returns values from XRandR rather than the inaccurate values previously queried from the core protocol.
+- On X11, the primary monitor is detected correctly even when using versions of XRandR less than 1.5.
+- `MonitorId` now implements `Debug`.
+- Fixed bug on macOS where using `with_decorations(false)` would cause `set_decorations(true)` to produce a transparent titlebar with no title.
+- Implemented `MonitorId::get_position` on macOS.
+- On macOS, `Window::get_current_monitor` now returns accurate values.
+- Added `WindowBuilderExt::with_resize_increments` to macOS.
+- **Breaking:** On X11, `WindowBuilderExt::with_resize_increments` and `WindowBuilderExt::with_base_size` now take `u32` values rather than `i32`.
+- macOS keyboard handling has been overhauled, allowing for the use of dead keys, IME, etc. Right modifier keys are also no longer reported as being left.
+- Added the `Window::set_ime_spot(x: i32, y: i32)` method, which is implemented on X11 and macOS.
+- **Breaking**: `os::unix::WindowExt::send_xim_spot(x: i16, y: i16)` no longer exists. Switch to the new `Window::set_ime_spot(x: i32, y: i32)`, which has equivalent functionality.
+- Fixed detection of `Pause` and `Scroll` keys on Windows.
+- On Windows, alt-tabbing while the cursor is grabbed no longer makes it impossible to re-grab the cursor.
+- On Windows, using `CursorState::Hide` when the cursor is grabbed now ungrabs the cursor first.
+- Implemented `MouseCursor::NoneCursor` on Windows.
+- Added `WindowBuilder::with_always_on_top` and `Window::set_always_on_top`. Implemented on Windows, macOS, and X11.
+- On X11, `WindowBuilderExt` now has `with_class`, `with_override_redirect`, and `with_x11_window_type` to allow for more control over window creation. `WindowExt` additionally has `set_urgent`.
+- More hints are set by default on X11, including `_NET_WM_PID` and `WM_CLIENT_MACHINE`. Note that prior to this, the `WM_CLASS` hint was automatically set to whatever value was passed to `with_title`. It's now set to the executable name to better conform to expectations and the specification; if this is undesirable, you must explicitly use `WindowBuilderExt::with_class`.

vendor/winit/src/changelog/v0.16.md

@@ -0,0 +1,32 @@
+## 0.16.2
+
+- On Windows, non-resizable windows now have the maximization button disabled. This is consistent with behavior on macOS and popular X11 WMs.
+- Corrected incorrect `unreachable!` usage when guessing the DPI factor with no detected monitors.
+
+## 0.16.1
+
+- Added logging through `log`. Logging will become more extensive over time.
+- On X11 and Windows, the window's DPI factor is guessed before creating the window. This _greatly_ cuts back on unsightly auto-resizing that would occur immediately after window creation.
+- Fixed X11 backend compilation for environments where `c_char` is unsigned.
+
+## 0.16.0
+
+- Windows additionally has `WindowBuilderExt::with_no_redirection_bitmap`.
+- **Breaking:** Removed `VirtualKeyCode::LMenu` and `VirtualKeyCode::RMenu`; Windows now generates `VirtualKeyCode::LAlt` and `VirtualKeyCode::RAlt` instead.
+- On X11, exiting fullscreen no longer leaves the window in the monitor's top left corner.
+- **Breaking:** `Window::hidpi_factor` has been renamed to `Window::get_hidpi_factor` for better consistency. `WindowEvent::HiDPIFactorChanged` has been renamed to `WindowEvent::HiDpiFactorChanged`. DPI factors are always represented as `f64` instead of `f32` now.
+- The Windows backend is now DPI aware. `WindowEvent::HiDpiFactorChanged` is implemented, and `MonitorId::get_hidpi_factor` and `Window::hidpi_factor` return accurate values.
+- Implemented `WindowEvent::HiDpiFactorChanged` on X11.
+- On macOS, `Window::set_cursor_position` is now relative to the client area.
+- On macOS, setting the maximum and minimum dimensions now applies to the client area dimensions rather than to the window dimensions.
+- On iOS, `MonitorId::get_dimensions` has been implemented and both `MonitorId::get_hidpi_factor` and `Window::get_hidpi_factor` return accurate values.
+- On Emscripten, `MonitorId::get_hidpi_factor` now returns the same value as `Window::get_hidpi_factor` (it previously would always return 1.0).
+- **Breaking:** The entire API for sizes, positions, etc. has changed. In the majority of cases, winit produces and consumes positions and sizes as `LogicalPosition` and `LogicalSize`, respectively. The notable exception is `MonitorId` methods, which deal in `PhysicalPosition` and `PhysicalSize`. See the documentation for specifics and explanations of the types. Additionally, winit automatically conserves logical size when the DPI factor changes.
+- **Breaking:** All deprecated methods have been removed. For `Window::platform_display` and `Window::platform_window`, switch to the appropriate platform-specific `WindowExt` methods. For `Window::get_inner_size_points` and `Window::get_inner_size_pixels`, use the `LogicalSize` returned by `Window::get_inner_size` and convert as needed.
+- HiDPI support for Wayland.
+- `EventsLoop::get_available_monitors` and `EventsLoop::get_primary_monitor` now have identical counterparts on `Window`, so this information can be acquired without an `EventsLoop` borrow.
+- `AvailableMonitorsIter` now implements `Debug`.
+- Fixed quirk on macOS where certain keys would generate characters at twice the normal rate when held down.
+- On X11, all event loops now share the same `XConnection`.
+- **Breaking:** `Window::set_cursor_state` and `CursorState` enum removed in favor of the more composable `Window::grab_cursor` and `Window::hide_cursor`. As a result, grabbing the cursor no longer automatically hides it; you must call both methods to retain the old behavior on Windows and macOS. `Cursor::NoneCursor` has been removed, as it's no longer useful.
+- **Breaking:** `Window::set_cursor_position` now returns `Result<(), String>`, thus allowing for `Box<Error>` conversion via `?`.

vendor/winit/src/changelog/v0.17.md

@@ -0,0 +1,23 @@
+## 0.17.2
+
+- On macOS, fix `<C-Tab>` so applications receive the event.
+- On macOS, fix `<Cmd-{key}>` so applications receive the event.
+- On Wayland, key press events will now be repeated.
+
+## 0.17.1
+
+- On X11, prevent a compilation failure in release mode for versions of Rust greater than or equal to 1.30.
+- Fixed deadlock that broke fullscreen mode on Windows.
+
+## 0.17.0
+
+- Cocoa and core-graphics updates.
+- Fixed thread-safety issues in several `Window` functions on Windows.
+- On MacOS, the key state for modifiers key events is now properly set.
+- On iOS, the view is now set correctly. This makes it possible to render things (instead of being stuck on a black screen), and touch events work again.
+- Added NetBSD support.
+- **Breaking:** On iOS, `UIView` is now the default root view. `WindowBuilderExt::with_root_view_class` can be used to set the root view objective-c class to `GLKView` (OpenGLES) or `MTKView` (Metal/MoltenVK).
+- On iOS, the `UIApplication` is not started until `Window::new` is called.
+- Fixed thread unsafety with cursor hiding on macOS.
+- On iOS, fixed the size of the `JmpBuf` type used for `setjmp`/`longjmp` calls. Previously this was a buffer overflow on most architectures.
+- On Windows, use cached window DPI instead of repeatedly querying the system. This fixes sporadic crashes on Windows 7.

vendor/winit/src/changelog/v0.18.md

@@ -0,0 +1,52 @@
+## 0.18.1
+
+- On macOS, fix `Yen` (JIS) so applications receive the event.
+- On X11 with a tiling WM, fixed high CPU usage when moving windows across monitors.
+- On X11, fixed panic caused by dropping the window before running the event loop.
+- on macOS, added `WindowExt::set_simple_fullscreen` which does not require a separate space
+- Introduce `WindowBuilderExt::with_app_id` to allow setting the application ID on Wayland.
+- On Windows, catch panics in event loop child thread and forward them to the parent thread. This prevents an invocation of undefined behavior due to unwinding into foreign code.
+- On Windows, fix issue where resizing or moving window combined with grabbing the cursor would freeze program.
+- On Windows, fix issue where resizing or moving window would eat `Awakened` events.
+- On Windows, exiting fullscreen after entering fullscreen with disabled decorations no longer shrinks window.
+- On X11, fixed a segfault when using virtual monitors with XRandR.
+- Derive `Ord` and `PartialOrd` for `VirtualKeyCode` enum.
+- On Windows, fix issue where hovering or dropping a non file item would create a panic.
+- On Wayland, fix resizing and DPI calculation when a `wl_output` is removed without sending a `leave` event to the `wl_surface`, such as disconnecting a monitor from a laptop.
+- On Wayland, DPI calculation is handled by smithay-client-toolkit.
+- On X11, `WindowBuilder::with_min_dimensions` and `WindowBuilder::with_max_dimensions` now correctly account for DPI.
+- Added support for generating dummy `DeviceId`s and `WindowId`s to better support unit testing.
+- On macOS, fixed unsoundness in drag-and-drop that could result in drops being rejected.
+- On macOS, implemented `WindowEvent::Refresh`.
+- On macOS, all `MouseCursor` variants are now implemented and the cursor will no longer reset after unfocusing.
+- Removed minimum supported Rust version guarantee.
+
+## 0.18.0
+
+- **Breaking:** `image` crate upgraded to 0.20. This is exposed as part of the `icon_loading` API.
+- On Wayland, pointer events will now provide the current modifiers state.
+- On Wayland, titles will now be displayed in the window header decoration.
+- On Wayland, key repetition is now ended when keyboard loses focus.
+- On Wayland, windows will now use more stylish and modern client side decorations.
+- On Wayland, windows will use server-side decorations when available.
+- **Breaking:** Added support for F16-F24 keys (variants were added to the `VirtualKeyCode` enum).
+- Fixed graphical glitches when resizing on Wayland.
+- On Windows, fix freezes when performing certain actions after a window resize has been triggered. Reintroduces some visual artifacts when resizing.
+- Updated window manager hints under X11 to v1.5 of [Extended Window Manager Hints](https://specifications.freedesktop.org/wm-spec/wm-spec-1.5.html#idm140200472629520).
+- Added `WindowBuilderExt::with_gtk_theme_variant` to X11-specific `WindowBuilder` functions.
+- Fixed UTF8 handling bug in X11 `set_title` function.
+- On Windows, `Window::set_cursor` now applies immediately instead of requiring specific events to occur first.
+- On Windows, the `HoveredFile` and `HoveredFileCancelled` events are now implemented.
+- On Windows, fix `Window::set_maximized`.
+- On Windows 10, fix transparency (#260).
+- On macOS, fix modifiers during key repeat.
+- Implemented the `Debug` trait for `Window`, `EventsLoop`, `EventsLoopProxy` and `WindowBuilder`.
+- On X11, now a `Resized` event will always be generated after a DPI change to ensure the window's logical size is consistent with the new DPI.
+- Added further clarifications to the DPI docs.
+- On Linux, if neither X11 nor Wayland manage to initialize, the corresponding panic now consists of a single line only.
+- Add optional `serde` feature with implementations of `Serialize`/`Deserialize` for DPI types and various event types.
+- Add `PartialEq`, `Eq`, and `Hash` implementations on public types that could have them but were missing them.
+- On X11, drag-and-drop receiving an unsupported drop type can no longer cause the WM to freeze.
+- Fix issue whereby the OpenGL context would not appear at startup on macOS Mojave (#1069).
+- **Breaking:** Removed `From<NSApplicationActivationPolicy>` impl from `ActivationPolicy` on macOS.
+- On macOS, the application can request the user's attention with `WindowExt::request_user_attention`.

vendor/winit/src/changelog/v0.19.md

@@ -0,0 +1,27 @@
+## 0.19.1
+
+- On Wayland, added a `get_wayland_display` function to `EventsLoopExt`.
+- On Windows, fix `CursorMoved(0, 0)` getting dispatched on window focus.
+- On macOS, fix command key event left and right reverse.
+- On FreeBSD, NetBSD, and OpenBSD, fix build of X11 backend.
+- On Linux, the numpad's add, subtract and divide keys are now mapped to the `Add`, `Subtract` and `Divide` virtual key codes
+- On macOS, the numpad's subtract key has been added to the `Subtract` mapping
+- On Wayland, the numpad's home, end, page up and page down keys are now mapped to the `Home`, `End`, `PageUp` and `PageDown` virtual key codes
+- On Windows, fix icon not showing up in corner of window.
+- On X11, change DPI scaling factor behavior. First, winit tries to read it from "Xft.dpi" XResource, and uses DPI calculation from xrandr dimensions as fallback behavior.
+
+## 0.19.0
+
+- On X11, we will use the faster `XRRGetScreenResourcesCurrent` function instead of `XRRGetScreenResources` when available.
+- On macOS, fix keycodes being incorrect when using a non-US keyboard layout.
+- On Wayland, fix `with_title()` not setting the windows title
+- On Wayland, add `set_wayland_theme()` to control client decoration color theme
+- Added serde serialization to `os::unix::XWindowType`.
+- **Breaking:** Remove the `icon_loading` feature and the associated `image` dependency.
+- On X11, make event loop thread safe by replacing XNextEvent with select(2) and XCheckIfEvent
+- On Windows, fix malformed function pointer typecast that could invoke undefined behavior.
+- Refactored Windows state/flag-setting code.
+- On Windows, hiding the cursor no longer hides the cursor for all Winit windows - just the one `hide_cursor` was called on.
+- On Windows, cursor grabs used to get perpetually canceled when the grabbing window lost focus. Now, cursor grabs automatically get re-initialized when the window regains focus and the mouse moves over the client area.
+- On Windows, only vertical mouse wheel events were handled. Now, horizontal mouse wheel events are also handled.
+- On Windows, ignore the AltGr key when populating the `ModifiersState` type.

vendor/winit/src/changelog/v0.20.md

@@ -0,0 +1,200 @@
+## 0.20.0
+
+- On X11, fix `ModifiersChanged` emitting incorrect modifier change events
+- **Breaking**: Overhaul how Winit handles DPI:
+  - Window functions and events now return `PhysicalSize` instead of `LogicalSize`.
+  - Functions that take `Size` or `Position` types can now take either `Logical` or `Physical` types.
+  - `hidpi_factor` has been renamed to `scale_factor`.
+  - `HiDpiFactorChanged` has been renamed to `ScaleFactorChanged`, and lets you control how the OS
+    resizes the window in response to the change.
+  - On X11, deprecate `WINIT_HIDPI_FACTOR` environment variable in favor of `WINIT_X11_SCALE_FACTOR`.
+  - `Size` and `Position` types are now generic over their exact pixel type.
+
+## 0.20.0-alpha6
+
+- On macOS, fix `set_cursor_visible` hides cursor outside of window.
+- On macOS, fix `CursorEntered` and `CursorLeft` events fired at old window size.
+- On macOS, fix error when `set_fullscreen` is called during fullscreen transition.
+- On all platforms except mobile and WASM, implement `Window::set_minimized`.
+- On X11, fix `CursorEntered` event being generated for non-winit windows.
+- On macOS, fix crash when starting maximized without decorations.
+- On macOS, fix application not terminating on `run_return`.
+- On Wayland, fix cursor icon updates on window borders when using CSD.
+- On Wayland, under mutter(GNOME Wayland), fix CSD being behind the status bar, when starting window in maximized mode.
+- On Windows, theme the title bar according to whether the system theme is "Light" or "Dark".
+- Added `WindowEvent::ThemeChanged` variant to handle changes to the system theme. Currently only implemented on Windows.
+- **Breaking**: Changes to the `RedrawRequested` event (#1041):
+  - `RedrawRequested` has been moved from `WindowEvent` to `Event`.
+  - `EventsCleared` has been renamed to `MainEventsCleared`.
+  - `RedrawRequested` is now issued only after `MainEventsCleared`.
+  - `RedrawEventsCleared` is issued after each set of `RedrawRequested` events.
+- Implement synthetic window focus key events on Windows.
+- **Breaking**: Change `ModifiersState` to a `bitflags` struct.
+- On Windows, implement `VirtualKeyCode` translation for `LWin` and `RWin`.
+- On Windows, fix closing the last opened window causing `DeviceEvent`s to stop getting emitted.
+- On Windows, fix `Window::set_visible` not setting internal flags correctly. This resulted in some weird behavior.
+- Add `DeviceEvent::ModifiersChanged`.
+  - Deprecate `modifiers` fields in other events in favor of `ModifiersChanged`.
+- On X11, `WINIT_HIDPI_FACTOR` now dominates `Xft.dpi` when picking DPI factor for output.
+- On X11, add special value `randr` for `WINIT_HIDPI_FACTOR` to make winit use self computed DPI factor instead of the one from `Xft.dpi`.
+
+## 0.20.0-alpha5
+
+- On macOS, fix application termination on `ControlFlow::Exit`
+- On Windows, fix missing `ReceivedCharacter` events when Alt is held.
+- On macOS, stop emitting private corporate characters in `ReceivedCharacter` events.
+- On X11, fix misreporting DPI factor at startup.
+- On X11, fix events not being reported when using `run_return`.
+- On X11, fix key modifiers being incorrectly reported.
+- On X11, fix window creation hanging when another window is fullscreen.
+- On Windows, fix focusing unfocused windows when switching from fullscreen to windowed.
+- On X11, fix reporting incorrect DPI factor when waking from suspend.
+- Change `EventLoopClosed` to contain the original event.
+- **Breaking**: Add `is_synthetic` field to `WindowEvent` variant `KeyboardInput`,
+  indicating that the event is generated by winit.
+- On X11, generate synthetic key events for keys held when a window gains or loses focus.
+- On X11, issue a `CursorMoved` event when a `Touch` event occurs,
+  as X11 implicitly moves the cursor for such events.
+
+## 0.20.0-alpha4
+
+- Add web support via the 'stdweb' or 'web-sys' features
+- On Windows, implemented function to get HINSTANCE
+- On macOS, implement `run_return`.
+- On iOS, fix inverted parameter in `set_prefers_home_indicator_hidden`.
+- On X11, performance is improved when rapidly calling `Window::set_cursor_icon`.
+- On iOS, fix improper `msg_send` usage that was UB and/or would break if `!` is stabilized.
+- On Windows, unset `maximized` when manually changing the window's position or size.
+- On Windows, add touch pressure information for touch events.
+- On macOS, differentiate between `CursorIcon::Grab` and `CursorIcon::Grabbing`.
+- On Wayland, fix event processing sometimes stalling when using OpenGL with vsync.
+- Officially remove the Emscripten backend.
+- On Windows, fix handling of surrogate pairs when dispatching `ReceivedCharacter`.
+- On macOS 10.15, fix freeze upon exiting exclusive fullscreen mode.
+- On iOS, fix panic upon closing the app.
+- On X11, allow setting multiple `XWindowType`s.
+- On iOS, fix null window on initial `HiDpiFactorChanged` event.
+- On Windows, fix fullscreen window shrinking upon getting restored to a normal window.
+- On macOS, fix events not being emitted during modal loops, such as when windows are being resized
+  by the user.
+- On Windows, fix hovering the mouse over the active window creating an endless stream of CursorMoved events.
+- Always dispatch a `RedrawRequested` event after creating a new window.
+- On X11, return dummy monitor data to avoid panicking when no monitors exist.
+- On X11, prevent stealing input focus when creating a new window.
+  Only steal input focus when entering fullscreen mode.
+- On Wayland, fixed DeviceEvents for relative mouse movement is not always produced
+- On Wayland, add support for set_cursor_visible and set_cursor_grab.
+- On Wayland, fixed DeviceEvents for relative mouse movement is not always produced.
+- Removed `derivative` crate dependency.
+- On Wayland, add support for set_cursor_icon.
+- Use `impl Iterator<Item = MonitorHandle>` instead of `AvailableMonitorsIter` consistently.
+- On macOS, fix fullscreen state being updated after entering fullscreen instead of before,
+  resulting in `Window::fullscreen` returning the old state in `Resized` events instead of
+  reflecting the new fullscreen state
+- On X11, fix use-after-free during window creation
+- On Windows, disable monitor change keyboard shortcut while in exclusive fullscreen.
+- On Windows, ensure that changing a borderless fullscreen window's monitor via keyboard shortcuts keeps the window fullscreen on the new monitor.
+- Prevent `EventLoop::new` and `EventLoop::with_user_event` from getting called outside the main thread.
+  - This is because some platforms cannot run the event loop outside the main thread. Preventing this
+    reduces the potential for cross-platform compatibility gotchyas.
+- On Windows and Linux X11/Wayland, add platform-specific functions for creating an `EventLoop` outside the main thread.
+- On Wayland, drop resize events identical to the current window size.
+- On Windows, fix window rectangle not getting set correctly on high-DPI systems.
+
+## 0.20.0-alpha3
+
+- On macOS, drop the run closure on exit.
+- On Windows, location of `WindowEvent::Touch` are window client coordinates instead of screen coordinates.
+- On X11, fix delayed events after window redraw.
+- On macOS, add `WindowBuilderExt::with_disallow_hidpi` to have the option to turn off best resolution openGL surface.
+- On Windows, screen saver won't start if the window is in fullscreen mode.
+- Change all occurrences of the `new_user_event` method to `with_user_event`.
+- On macOS, the dock and the menu bar are now hidden in fullscreen mode.
+- `Window::set_fullscreen` now takes `Option<Fullscreen>` where `Fullscreen`
+  consists of `Fullscreen::Exclusive(VideoMode)` and
+  `Fullscreen::Borderless(MonitorHandle)` variants.
+  - Adds support for exclusive fullscreen mode.
+- On iOS, add support for hiding the home indicator.
+- On iOS, add support for deferring system gestures.
+- On iOS, fix a crash that occurred while acquiring a monitor's name.
+- On iOS, fix armv7-apple-ios compile target.
+- Removed the `T: Clone` requirement from the `Clone` impl of `EventLoopProxy<T>`.
+- On iOS, disable overscan compensation for external displays (removes black
+  bars surrounding the image).
+- On Linux, the functions `is_wayland`, `is_x11`, `xlib_xconnection` and `wayland_display` have been moved to a new `EventLoopWindowTargetExtUnix` trait.
+- On iOS, add `set_prefers_status_bar_hidden` extension function instead of
+  hijacking `set_decorations` for this purpose.
+- On macOS and iOS, corrected the auto trait impls of `EventLoopProxy`.
+- On iOS, add touch pressure information for touch events.
+- Implement `raw_window_handle::HasRawWindowHandle` for `Window` type on all supported platforms.
+- On macOS, fix the signature of `-[NSView drawRect:]`.
+- On iOS, fix the behavior of `ControlFlow::Poll`. It wasn't polling if that was the only mode ever used by the application.
+- On iOS, fix DPI sent out by views on creation was `0.0` - now it gives a reasonable number.
+- On iOS, RedrawRequested now works for gl/metal backed views.
+- On iOS, RedrawRequested is generally ordered after EventsCleared.
+
+## 0.20.0-alpha2
+
+- On X11, non-resizable windows now have maximize explicitly disabled.
+- On Windows, support paths longer than MAX_PATH (260 characters) in `WindowEvent::DroppedFile`
+  and `WindowEvent::HoveredFile`.
+- On Mac, implement `DeviceEvent::Button`.
+- Change `Event::Suspended(true / false)` to `Event::Suspended` and `Event::Resumed`.
+- On X11, fix sanity check which checks that a monitor's reported width and height (in millimeters) are non-zero when calculating the DPI factor.
+- Revert the use of invisible surfaces in Wayland, which introduced graphical glitches with OpenGL (#835)
+- On X11, implement `_NET_WM_PING` to allow desktop environment to kill unresponsive programs.
+- On Windows, when a window is initially invisible, it won't take focus from the existing visible windows.
+- On Windows, fix multiple calls to `request_redraw` during `EventsCleared` sending multiple `RedrawRequested events.`
+- On Windows, fix edge case where `RedrawRequested` could be dispatched before input events in event loop iteration.
+- On Windows, fix timing issue that could cause events to be improperly dispatched after `RedrawRequested` but before `EventsCleared`.
+- On macOS, drop unused Metal dependency.
+- On Windows, fix the trail effect happening on transparent decorated windows. Borderless (or un-decorated) windows were not affected.
+- On Windows, fix `with_maximized` not properly setting window size to entire window.
+- On macOS, change `WindowExtMacOS::request_user_attention()` to take an `enum` instead of a `bool`.
+
+## 0.20.0-alpha1
+
+- Changes below are considered **breaking**.
+- Change all occurrences of `EventsLoop` to `EventLoop`.
+- Previously flat API is now exposed through `event`, `event_loop`, `monitor`, and `window` modules.
+- `os` module changes:
+  - Renamed to `platform`.
+  - All traits now have platform-specific suffixes.
+  - Exposes new `desktop` module on Windows, Mac, and Linux.
+- Changes to event loop types:
+  - `EventLoopProxy::wakeup` has been removed in favor of `send_event`.
+  - **Major:** New `run` method drives winit event loop.
+    - Returns `!` to ensure API behaves identically across all supported platforms.
+      - This allows `emscripten` implementation to work without lying about the API.
+    - `ControlFlow`'s variants have been replaced with `Wait`, `WaitUntil(Instant)`, `Poll`, and `Exit`.
+      - Is read after `EventsCleared` is processed.
+      - `Wait` waits until new events are available.
+      - `WaitUntil` waits until either new events are available or the provided time has been reached.
+      - `Poll` instantly resumes the event loop.
+      - `Exit` aborts the event loop.
+    - Takes a closure that implements `'static + FnMut(Event<T>, &EventLoop<T>, &mut ControlFlow)`.
+      - `&EventLoop<T>` is provided to allow new `Window`s to be created.
+  - **Major:** `platform::desktop` module exposes `EventLoopExtDesktop` trait with `run_return` method.
+    - Behaves identically to `run`, but returns control flow to the calling context and can take non-`'static` closures.
+  - `EventLoop`'s `poll_events` and `run_forever` methods have been removed in favor of `run` and `run_return`.
+- Changes to events:
+  - Remove `Event::Awakened` in favor of `Event::UserEvent(T)`.
+    - Can be sent with `EventLoopProxy::send_event`.
+  - Rename `WindowEvent::Refresh` to `WindowEvent::RedrawRequested`.
+    - `RedrawRequested` can be sent by the user with the `Window::request_redraw` method.
+  - `EventLoop`, `EventLoopProxy`, and `Event` are now generic over `T`, for use in `UserEvent`.
+  - **Major:** Add `NewEvents(StartCause)`, `EventsCleared`, and `LoopDestroyed` variants to `Event`.
+    - `NewEvents` is emitted when new events are ready to be processed by event loop.
+      - `StartCause` describes why new events are available, with `ResumeTimeReached`, `Poll`, `WaitCancelled`, and `Init` (sent once at start of loop).
+    - `EventsCleared` is emitted when all available events have been processed.
+      - Can be used to perform logic that depends on all events being processed (e.g. an iteration of a game loop).
+    - `LoopDestroyed` is emitted when the `run` or `run_return` method is about to exit.
+- Rename `MonitorId` to `MonitorHandle`.
+- Removed `serde` implementations from `ControlFlow`.
+- Rename several functions to improve both internal consistency and compliance with Rust API guidelines.
+- Remove `WindowBuilder::multitouch` field, since it was only implemented on a few platforms. Multitouch is always enabled now.
+- **Breaking:** On macOS, change `ns` identifiers to use snake_case for consistency with iOS's `ui` identifiers.
+- Add `MonitorHandle::video_modes` method for retrieving supported video modes for the given monitor.
+- On Wayland, the window now exists even if nothing has been drawn.
+- On Windows, fix initial dimensions of a fullscreen window.
+- On Windows, Fix transparent borderless windows rendering wrong.

vendor/winit/src/changelog/v0.21.md

@@ -0,0 +1,16 @@
+## 0.21.0
+
+- On Windows, fixed "error: linking with `link.exe` failed: exit code: 1120" error on older versions of windows.
+- On macOS, fix set_minimized(true) works only with decorations.
+- On macOS, add `hide_application` to `EventLoopWindowTarget` via a new `EventLoopWindowTargetExtMacOS` trait. `hide_application` will hide the entire application by calling `-[NSApplication hide: nil]`.
+- On macOS, fix not sending ReceivedCharacter event for specific keys combinations.
+- On macOS, fix `CursorMoved` event reporting the cursor position using logical coordinates.
+- On macOS, fix issue where unbundled applications would sometimes open without being focused.
+- On macOS, fix `run_return` does not return unless it receives a message.
+- On Windows, fix bug where `RedrawRequested` would only get emitted every other iteration of the event loop.
+- On X11, fix deadlock on window state when handling certain window events.
+- `WindowBuilder` now implements `Default`.
+- **Breaking:** `WindowEvent::CursorMoved` changed to `f64` units, preserving high-precision data supplied by most backends
+- On Wayland, fix coordinates in mouse events when scale factor isn't 1
+- On Web, add the ability to provide a custom canvas
+- **Breaking:** On Wayland, the `WaylandTheme` struct has been replaced with a `Theme` trait, allowing for extra configuration

vendor/winit/src/changelog/v0.22.md

@@ -0,0 +1,37 @@
+## 0.22.2
+
+- Added Clone implementation for 'static events.
+- On Windows, fix window intermittently hanging when `ControlFlow` was set to `Poll`.
+- On Windows, fix `WindowBuilder::with_maximized` being ignored.
+- On Android, minimal platform support.
+- On iOS, touch positions are now properly converted to physical pixels.
+- On macOS, updated core-* dependencies and cocoa
+
+## 0.22.1
+
+- On X11, fix `ResumeTimeReached` being fired too early.
+- On Web, replaced zero timeout for `ControlFlow::Poll` with `requestAnimationFrame`
+- On Web, fix a possible panic during event handling
+- On macOS, fix `EventLoopProxy` leaking memory for every instance.
+
+## 0.22.0
+
+- On Windows, fix minor timing issue in wait_until_time_or_msg
+- On Windows, rework handling of request_redraw() to address panics.
+- On macOS, fix `set_simple_screen` to remember frame excluding title bar.
+- On Wayland, fix coordinates in touch events when scale factor isn't 1.
+- On Wayland, fix color from `close_button_icon_color` not applying.
+- Ignore locale if unsupported by X11 backend
+- On Wayland, Add HiDPI cursor support
+- On Web, add the ability to query "Light" or "Dark" system theme send `ThemeChanged` on change.
+- Fix `Event::to_static` returning `None` for user events.
+- On Wayland, Hide CSD for fullscreen windows.
+- On Windows, ignore spurious mouse move messages.
+- **Breaking:** Move `ModifiersChanged` variant from `DeviceEvent` to `WindowEvent`.
+- On Windows, add `IconExtWindows` trait which exposes creating an `Icon` from an external file or embedded resource
+- Add `BadIcon::OsError` variant for when OS icon functionality fails
+- On Windows, fix crash at startup on systems that do not properly support Windows' Dark Mode
+- Revert On macOS, fix not sending ReceivedCharacter event for specific keys combinations.
+- on macOS, fix incorrect ReceivedCharacter events for some key combinations.
+- **Breaking:** Use `i32` instead of `u32` for position type in `WindowEvent::Moved`.
+- On macOS, a mouse motion event is now generated before every mouse click.

vendor/winit/src/changelog/v0.23.md

@@ -0,0 +1,65 @@
+## 0.23.0
+
+- On iOS, fixed support for the "Debug View Hierarchy" feature in Xcode.
+- On all platforms, `available_monitors` and `primary_monitor` are now on `EventLoopWindowTarget` rather than `EventLoop` to list monitors event in the event loop.
+- On Unix, X11 and Wayland are now optional features (enabled by default)
+- On X11, fix deadlock when calling `set_fullscreen_inner`.
+- On Web, prevent the webpage from scrolling when the user is focused on a winit canvas
+- On Web, calling `window.set_cursor_icon` no longer breaks HiDPI scaling
+- On Windows, drag and drop is now optional (enabled by default) and can be disabled with `WindowBuilderExtWindows::with_drag_and_drop(false)`.
+- On Wayland, fix deadlock when calling to `set_inner_size` from a callback.
+- On macOS, add `hide__other_applications` to `EventLoopWindowTarget` via existing `EventLoopWindowTargetExtMacOS` trait. `hide_other_applications` will hide other applications by calling `-[NSApplication hideOtherApplications: nil]`.
+- On android added support for `run_return`.
+- On MacOS, Fixed fullscreen and dialog support for `run_return`.
+- On Windows, fix bug where we'd try to emit `MainEventsCleared` events during nested win32 event loops.
+- On Web, use mouse events if pointer events aren't supported. This affects Safari.
+- On Windows, `set_ime_position` is now a no-op instead of a runtime crash.
+- On Android, `set_fullscreen` is now a no-op instead of a runtime crash.
+- On iOS and Android, `set_inner_size` is now a no-op instead of a runtime crash.
+- On Android, fix `ControlFlow::Poll` not polling the Android event queue.
+- On macOS, add `NSWindow.hasShadow` support.
+- On Web, fix vertical mouse wheel scrolling being inverted.
+- On Web, implement mouse capturing for click-dragging out of the canvas.
+- On Web, fix `ControlFlow::Exit` not properly handled.
+- On Web (web-sys only), send `WindowEvent::ScaleFactorChanged` event when `window.devicePixelRatio` is changed.
+- **Breaking:** On Web, `set_cursor_position` and `set_cursor_grab` will now always return an error.
+- **Breaking:** `PixelDelta` scroll events now return a `PhysicalPosition`.
+- On NetBSD, fixed crash due to incorrect detection of the main thread.
+- **Breaking:** On X11, `-` key is mapped to the `Minus` virtual key code, instead of `Subtract`.
+- On macOS, fix inverted horizontal scroll.
+- **Breaking:** `current_monitor` now returns `Option<MonitorHandle>`.
+- **Breaking:** `primary_monitor` now returns `Option<MonitorHandle>`.
+- On macOS, updated core-* dependencies and cocoa.
+- Bump `parking_lot` to 0.11
+- On Android, bump `ndk`, `ndk-sys` and `ndk-glue` to 0.2. Checkout the new ndk-glue main proc attribute.
+- On iOS, fixed starting the app in landscape where the view still had portrait dimensions.
+- Deprecate the stdweb backend, to be removed in a future release
+- **Breaking:** Prefixed virtual key codes `Add`, `Multiply`, `Divide`, `Decimal`, and `Subtract` with `Numpad`.
+- Added `Asterisk` and `Plus` virtual key codes.
+- On Web (web-sys only), the `Event::LoopDestroyed` event is correctly emitted when leaving the page.
+- On Web, the `WindowEvent::Destroyed` event now gets emitted when a `Window` is dropped.
+- On Web (web-sys only), the event listeners are now removed when a `Window` is dropped or when the event loop is destroyed.
+- On Web, the event handler closure passed to `EventLoop::run` now gets dropped after the event loop is destroyed.
+- **Breaking:** On Web, the canvas element associated to a `Window` is no longer removed from the DOM when the `Window` is dropped.
+- On Web, `WindowEvent::Resized` is now emitted when `Window::set_inner_size` is called.
+- **Breaking:** `Fullscreen` enum now uses `Borderless(Option<MonitorHandle>)` instead of `Borderless(MonitorHandle)` to allow picking the current monitor.
+- On MacOS, fix `WindowEvent::Moved` ignoring the scale factor.
+- On Wayland, add missing virtual keycodes.
+- On Wayland, implement proper `set_cursor_grab`.
+- On Wayland, the cursor will use similar icons if the requested one isn't available.
+- On Wayland, right clicking on client side decorations will request application menu.
+- On Wayland, fix tracking of window size after state changes.
+- On Wayland, fix client side decorations not being hidden properly in fullscreen.
+- On Wayland, fix incorrect size event when entering fullscreen with client side decorations.
+- On Wayland, fix `resizable` attribute not being applied properly on startup.
+- On Wayland, fix disabled repeat rate not being handled.
+- On Wayland, fix decoration buttons not working after tty switch.
+- On Wayland, fix scaling not being applied on output re-enable.
+- On Wayland, fix crash when `XCURSOR_SIZE` is `0`.
+- On Wayland, fix pointer getting created in some cases without pointer capability.
+- On Wayland, on kwin, fix space between window and decorations on startup.
+- **Breaking:** On Wayland, `Theme` trait was reworked.
+- On Wayland, disable maximize button for non-resizable window.
+- On Wayland, added support for `set_ime_position`.
+- On Wayland, fix crash on startup since GNOME 3.37.90.
+- On X11, fix incorrect modifiers state on startup.

vendor/winit/src/changelog/v0.24.md

@@ -0,0 +1,28 @@
+## 0.24.0
+
+- On Windows, fix applications not exiting gracefully due to thread_event_target_callback accessing corrupted memory.
+- On Windows, implement `Window::set_ime_position`.
+- **Breaking:** On Windows, Renamed `WindowBuilderExtWindows`'s `is_dark_mode` to `theme`.
+- **Breaking:** On Windows, renamed `WindowBuilderExtWindows::is_dark_mode` to `theme`.
+- On Windows, add `WindowBuilderExtWindows::with_theme` to set a preferred theme.
+- On Windows, fix bug causing message boxes to appear delayed.
+- On Android, calling `WindowEvent::Focused` now works properly instead of always returning false.
+- On Windows, fix Alt-Tab behaviour by removing borderless fullscreen "always on top" flag.
+- On Windows, fix bug preventing windows with transparency enabled from having fully-opaque regions.
+- **Breaking:** On Windows, include prefix byte in scancodes.
+- On Wayland, fix window not being resizeable when using `WindowBuilder::with_min_inner_size`.
+- On Unix, fix cross-compiling to wasm32 without enabling X11 or Wayland.
+- On Windows, fix use-after-free crash during window destruction.
+- On Web, fix `WindowEvent::ReceivedCharacter` never being sent on key input.
+- On macOS, fix compilation when targeting aarch64.
+- On X11, fix `Window::request_redraw` not waking the event loop.
+- On Wayland, the keypad arrow keys are now recognized.
+- **Breaking** Rename `desktop::EventLoopExtDesktop` to `run_return::EventLoopExtRunReturn`.
+- Added `request_user_attention` method to `Window`.
+- **Breaking:** On macOS, removed `WindowExt::request_user_attention`, use `Window::request_user_attention`.
+- **Breaking:** On X11, removed `WindowExt::set_urgent`, use `Window::request_user_attention`.
+- On Wayland, default font size in CSD increased from 11 to 17.
+- On Windows, fix bug causing message boxes to appear delayed.
+- On Android, support multi-touch.
+- On Wayland, extra mouse buttons are not dropped anymore.
+- **Breaking**: `MouseButton::Other` now uses `u16`.

vendor/winit/src/changelog/v0.25.md

@@ -0,0 +1,31 @@
+## 0.25.0
+
+- **Breaking:** On macOS, replace `WindowBuilderExtMacOS::with_activation_policy` with `EventLoopExtMacOS::set_activation_policy`
+- On macOS, wait with activating the application until the application has initialized.
+- On macOS, fix creating new windows when the application has a main menu.
+- On Windows, fix fractional deltas for mouse wheel device events.
+- On macOS, fix segmentation fault after dropping the main window.
+- On Android, `InputEvent::KeyEvent` is partially implemented providing the key scancode.
+- Added `is_maximized` method to `Window`.
+- On Windows, fix bug where clicking the decoration bar would make the cursor blink.
+- On Windows, fix bug causing newly created windows to erroneously display the "wait" (spinning) cursor.
+- On macOS, wake up the event loop immediately when a redraw is requested.
+- On Windows, change the default window size (1024x768) to match the default on other desktop platforms (800x600).
+- On Windows, fix bug causing mouse capture to not be released.
+- On Windows, fix fullscreen not preserving minimized/maximized state.
+- On Android, unimplemented events are marked as unhandled on the native event loop.
+- On Windows, added `WindowBuilderExtWindows::with_menu` to set a custom menu at window creation time.
+- On Android, bump `ndk` and `ndk-glue` to 0.3: use predefined constants for event `ident`.
+- On macOS, fix objects captured by the event loop closure not being dropped on panic.
+- On Windows, fixed `WindowEvent::ThemeChanged` not properly firing and fixed `Window::theme` returning the wrong theme.
+- On Web, added support for `DeviceEvent::MouseMotion` to listen for relative mouse movements.
+- Added `WindowBuilder::with_position` to allow setting the position of a `Window` on creation. Supported on Windows, macOS and X11.
+- Added `Window::drag_window`. Implemented on Windows, macOS, X11 and Wayland.
+- On X11, bump `mio` to 0.7.
+- On Windows, added `WindowBuilderExtWindows::with_owner_window` to allow creating popup windows.
+- On Windows, added `WindowExtWindows::set_enable` to allow creating modal popup windows.
+- On macOS, emit `RedrawRequested` events immediately while the window is being resized.
+- Implement `Default`, `Hash`, and `Eq` for `LogicalPosition`, `PhysicalPosition`, `LogicalSize`, and `PhysicalSize`.
+- On macOS, initialize the Menu Bar with minimal defaults. (Can be prevented using `enable_default_menu_creation`)
+- On macOS, change the default behavior for first click when the window was unfocused. Now the window becomes focused and then emits a `MouseInput` event on a "first mouse click".
+- Implement mint (math interoperability standard types) conversions (under feature flag `mint`).

vendor/winit/src/changelog/v0.26.md

@@ -0,0 +1,36 @@
+## 0.26.1
+
+- Fix linking to the `ColorSync` framework on macOS 10.7, and in newer Rust versions.
+- On Web, implement cursor grabbing through the pointer lock API.
+- On X11, add mappings for numpad comma, numpad enter, numlock and pause.
+- On macOS, fix Pinyin IME input by reverting a change that intended to improve IME.
+- On Windows, fix a crash with transparent windows on Windows 11.
+
+## 0.26.0
+
+- Update `raw-window-handle` to `v0.4`. This is _not_ a breaking change, we still implement `HasRawWindowHandle` from `v0.3`, see [rust-windowing/raw-window-handle#74](https://github.com/rust-windowing/raw-window-handle/pull/74). Note that you might have to run `cargo update -p raw-window-handle` after upgrading.
+- On X11, bump `mio` to 0.8.
+- On Android, fixed `WindowExtAndroid::config` initially returning an empty `Configuration`.
+- On Android, fixed `Window::scale_factor` and `MonitorHandle::scale_factor` initially always returning 1.0.
+- On X11, select an appropriate visual for transparency if is requested
+- On Wayland and X11, fix diagonal window resize cursor orientation.
+- On macOS, drop the event callback before exiting.
+- On Android, implement `Window::request_redraw`
+- **Breaking:** On Web, remove the `stdweb` backend.
+- Added `Window::focus_window`to bring the window to the front and set input focus.
+- On Wayland and X11, implement `is_maximized` method on `Window`.
+- On Windows, prevent ghost window from showing up in the taskbar after either several hours of use or restarting `explorer.exe`.
+- On macOS, fix issue where `ReceivedCharacter` was not being emitted during some key repeat events.
+- On Wayland, load cursor icons `hand2` and `hand1` for `CursorIcon::Hand`.
+- **Breaking:** On Wayland, Theme trait and its support types are dropped.
+- On Wayland, bump `smithay-client-toolkit` to 0.15.1.
+- On Wayland, implement `request_user_attention` with `xdg_activation_v1`.
+- On X11, emit missing `WindowEvent::ScaleFactorChanged` when the only monitor gets reconnected.
+- On X11, if RANDR based scale factor is higher than 20 reset it to 1
+- On Wayland, add an enabled-by-default feature called `wayland-dlopen` so users can opt out of using `dlopen` to load system libraries.
+- **Breaking:** On Android, bump `ndk` and `ndk-glue` to 0.5.
+- On Windows, increase wait timer resolution for more accurate timing when using `WaitUntil`.
+- On macOS, fix native file dialogs hanging the event loop.
+- On Wayland, implement a workaround for wrong configure size when using `xdg_decoration` in `kwin_wayland`
+- On macOS, fix an issue that prevented the menu bar from showing in borderless fullscreen mode.
+- On X11, EINTR while polling for events no longer causes a panic. Instead it will be treated as a spurious wakeup.

vendor/winit/src/changelog/v0.27.md

@@ -0,0 +1,107 @@
+## 0.27.5
+
+- On Wayland, fix byte offset in `Ime::Preedit` pointing to invalid bytes.
+
+## 0.27.4
+
+- On Windows, emit `ReceivedCharacter` events on system keybindings.
+- On Windows, fixed focus event emission on minimize.
+- On X11, fixed IME crashing during reload.
+
+## 0.27.3
+
+- On Windows, added `WindowExtWindows::set_undecorated_shadow` and `WindowBuilderExtWindows::with_undecorated_shadow` to draw the drop shadow behind a borderless window.
+- On Windows, fixed default window features (ie snap, animations, shake, etc.) when decorations are disabled.
+- On Windows, fixed ALT+Space shortcut to open window menu.
+- On Wayland, fixed `Ime::Preedit` not being sent on IME reset.
+- Fixed unbound version specified for `raw-window-handle` leading to compilation failures.
+- Empty `Ime::Preedit` event will be sent before `Ime::Commit` to help clearing preedit.
+- On X11, fixed IME context picking by querying for supported styles beforehand.
+
+## 0.27.2
+
+- On macOS, fixed touch phase reporting when scrolling.
+- On X11, fix min, max and resize increment hints not persisting for resizable windows (e.g. on DPI change).
+- On Windows, respect min/max inner sizes when creating the window.
+- For backwards compatibility, `Window` now (additionally) implements the old version (`0.4`) of the `HasRawWindowHandle` trait
+- On Windows, added support for `EventLoopWindowTarget::set_device_event_filter`.
+- On Wayland, fix user requested `WindowEvent::RedrawRequested` being delayed by a frame.
+
+## 0.27.1
+
+- The minimum supported Rust version was lowered to `1.57.0` and now explicitly tested.
+- On X11, fix crash on start due to inability to create an IME context without any preedit.
+
+## 0.27.0
+
+- On Windows, fix hiding a maximized window.
+- On Android, `ndk-glue`'s `NativeWindow` lock is now held between `Event::Resumed` and `Event::Suspended`.
+- On Web, added `EventLoopExtWebSys` with a `spawn` method to start the event loop without throwing an exception.
+- Added `WindowEvent::Occluded(bool)`, currently implemented on macOS and X11.
+- On X11, fix events for caps lock key not being sent
+- Build docs on `docs.rs` for iOS and Android as well.
+- **Breaking:** Removed the `WindowAttributes` struct, since all its functionality is accessible from `WindowBuilder`.
+- Added `WindowBuilder::transparent` getter to check if the user set `transparent` attribute.
+- On macOS, Fix emitting `Event::LoopDestroyed` on CMD+Q.
+- On macOS, fixed an issue where having multiple windows would prevent run_return from ever returning.
+- On Wayland, fix bug where the cursor wouldn't hide in GNOME.
+- On macOS, Windows, and Wayland, add `set_cursor_hittest` to let the window ignore mouse events.
+- On Windows, added `WindowExtWindows::set_skip_taskbar` and `WindowBuilderExtWindows::with_skip_taskbar`.
+- On Windows, added `EventLoopBuilderExtWindows::with_msg_hook`.
+- On Windows, remove internally unique DC per window.
+- On macOS, remove the need to call `set_ime_position` after moving the window.
+- Added `Window::is_visible`.
+- Added `Window::is_resizable`.
+- Added `Window::is_decorated`.
+- On X11, fix for repeated event loop iteration when `ControlFlow` was `Wait`
+- On X11, fix scale factor calculation when the only monitor is reconnected
+- On Wayland, report unaccelerated mouse deltas in `DeviceEvent::MouseMotion`.
+- On Web, a focused event is manually generated when a click occurs to emulate behaviour of other backends.
+- **Breaking:** Bump `ndk` version to 0.6, ndk-sys to `v0.3`, `ndk-glue` to `0.6`.
+- Remove no longer needed `WINIT_LINK_COLORSYNC` environment variable.
+- **Breaking:** Rename the `Exit` variant of `ControlFlow` to `ExitWithCode`, which holds a value to control the exit code after running. Add an `Exit` constant which aliases to `ExitWithCode(0)` instead to avoid major breakage. This shouldn't affect most existing programs.
+- Add `EventLoopBuilder`, which allows you to create and tweak the settings of an event loop before creating it.
+- Deprecated `EventLoop::with_user_event`; use `EventLoopBuilder::with_user_event` instead.
+- **Breaking:** Replaced `EventLoopExtMacOS` with `EventLoopBuilderExtMacOS` (which also has renamed methods).
+- **Breaking:** Replaced `EventLoopExtWindows` with `EventLoopBuilderExtWindows` (which also has renamed methods).
+- **Breaking:** Replaced `EventLoopExtUnix` with `EventLoopBuilderExtUnix` (which also has renamed methods).
+- **Breaking:** The platform specific extensions for Windows `winit::platform::windows` have changed. All `HANDLE`-like types e.g. `HWND` and `HMENU` were converted from winapi types or `*mut c_void` to `isize`. This was done to be consistent with the type definitions in windows-sys and to not expose internal dependencies.
+- The internal bindings to the [Windows API](https://docs.microsoft.com/en-us/windows/) were changed from the unofficial [winapi](https://github.com/retep998/winapi-rs) bindings to the official Microsoft [windows-sys](https://github.com/microsoft/windows-rs) bindings.
+- On Wayland, fix polling during consecutive `EventLoop::run_return` invocations.
+- On Windows, fix race issue creating fullscreen windows with `WindowBuilder::with_fullscreen`
+- On Android, `virtual_keycode` for `KeyboardInput` events is now filled in where a suitable match is found.
+- Added helper methods on `ControlFlow` to set its value.
+- On Wayland, fix `TouchPhase::Ended` always reporting the location of the first touch down, unless the compositor
+  sent a cancel or frame event.
+- On iOS, send `RedrawEventsCleared` even if there are no redraw events, consistent with other platforms.
+- **Breaking:** Replaced `Window::with_app_id` and `Window::with_class` with `Window::with_name` on `WindowBuilderExtUnix`.
+- On Wayland, fallback CSD was replaced with proper one:
+  - `WindowBuilderExtUnix::with_wayland_csd_theme` to set color theme in builder.
+  - `WindowExtUnix::wayland_set_csd_theme` to set color theme when creating a window.
+  - `WINIT_WAYLAND_CSD_THEME` env variable was added, it can be used to set "dark"/"light" theme in apps that don't expose theme setting.
+  - `wayland-csd-adwaita` feature that enables proper CSD with title rendering using FreeType system library.
+  - `wayland-csd-adwaita-notitle` feature that enables CSD but without title rendering.
+- On Wayland and X11, fix window not resizing with `Window::set_inner_size` after calling `Window:set_resizable(false)`.
+- On Windows, fix wrong fullscreen monitors being recognized when handling WM_WINDOWPOSCHANGING messages
+- **Breaking:** Added new `WindowEvent::Ime` supported on desktop platforms.
+- Added `Window::set_ime_allowed` supported on desktop platforms.
+- **Breaking:** IME input on desktop platforms won't be received unless it's explicitly allowed via `Window::set_ime_allowed` and new `WindowEvent::Ime` events are handled.
+- On macOS, `WindowEvent::Resized` is now emitted in `frameDidChange` instead of `windowDidResize`.
+- **Breaking:** On X11, device events are now ignored for unfocused windows by default, use `EventLoopWindowTarget::set_device_event_filter` to set the filter level.
+- Implemented `Default` on `EventLoop<()>`.
+- Implemented `Eq` for `Fullscreen`, `Theme`, and `UserAttentionType`.
+- **Breaking:** `Window::set_cursor_grab` now accepts `CursorGrabMode` to control grabbing behavior.
+- On Wayland, add support for `Window::set_cursor_position`.
+- Fix on macOS `WindowBuilder::with_disallow_hidpi`, setting true or false by the user no matter the SO default value.
+- `EventLoopBuilder::build` will now panic when the `EventLoop` is being created more than once.
+- Added `From<u64>` for `WindowId` and `From<WindowId>` for `u64`.
+- Added `MonitorHandle::refresh_rate_millihertz` to get monitor's refresh rate.
+- **Breaking**, Replaced `VideoMode::refresh_rate` with `VideoMode::refresh_rate_millihertz` providing better precision.
+- On Web, add `with_prevent_default` and `with_focusable` to `WindowBuilderExtWebSys` to control whether events should be propagated.
+- On Windows, fix focus events being sent to inactive windows.
+- **Breaking**, update `raw-window-handle` to `v0.5` and implement `HasRawDisplayHandle` for `Window` and `EventLoopWindowTarget`.
+- On X11, add function `register_xlib_error_hook` into `winit::platform::unix` to subscribe for errors coming from Xlib.
+- On Android, upgrade `ndk` and `ndk-glue` dependencies to the recently released `0.7.0`.
+- All platforms can now be relied on to emit a `Resumed` event. Applications are recommended to lazily initialize graphics state and windows on first resume for portability.
+- **Breaking:**: Reverse horizontal scrolling sign in `MouseScrollDelta` to match the direction of vertical scrolling. A positive X value now means moving the content to the right. The meaning of vertical scrolling stays the same: a positive Y value means moving the content down.
+- On MacOS, fix deadlock when calling `set_maximized` from event loop.

vendor/winit/src/changelog/v0.28.md

@@ -0,0 +1,100 @@
+## 0.28.7
+
+- Fix window size sometimes being invalid when resizing on macOS 14 Sonoma.
+
+## 0.28.6
+
+- On macOS, fixed memory leak when getting monitor handle.
+- On macOS, fix `Backspace` being emitted when clearing preedit with it.
+
+## 0.28.5
+
+- On macOS, fix `key_up` being ignored when `Ime` is disabled.
+
+## 0.28.4
+
+- On macOS, fix empty marked text blocking regular input.
+- On macOS, fix potential panic when getting refresh rate.
+- On macOS, fix crash when calling `Window::set_ime_position` from another thread.
+
+## 0.28.3
+
+- Fix macOS memory leaks.
+
+## 0.28.2
+
+- Implement `HasRawDisplayHandle` for `EventLoop`.
+- On macOS, set resize increments only for live resizes.
+- On Wayland, fix rare crash on DPI change
+- Web: Added support for `Window::theme`.
+- On Wayland, fix rounding issues when doing resize.
+- On macOS, fix wrong focused state on startup.
+- On Windows, fix crash on setting taskbar when using Visual Studio debugger.
+- On macOS, resize simple fullscreen windows on windowDidChangeScreen events.
+
+## 0.28.1
+
+- On Wayland, fix crash when dropping a window in multi-window setup.
+
+## 0.28.0
+
+- On macOS, fixed `Ime::Commit` persisting for all input after interacting with `Ime`.
+- On macOS, added `WindowExtMacOS::option_as_alt` and `WindowExtMacOS::set_option_as_alt`.
+- On Windows, fix window size for maximized, undecorated windows.
+- On Windows and macOS, add `WindowBuilder::with_active`.
+- Add `Window::is_minimized`.
+- On X11, fix errors handled during `register_xlib_error_hook` invocation bleeding into winit.
+- Add `Window::has_focus`.
+- On Windows, fix `Window::set_minimized(false)` not working for windows minimized by `Win + D` hotkey.
+- **Breaking:** On Web, touch input no longer fires `WindowEvent::Cursor*`, `WindowEvent::MouseInput`, or `DeviceEvent::MouseMotion` like other platforms, but instead it fires `WindowEvent::Touch`.
+- **Breaking:** Removed platform specific `WindowBuilder::with_parent` API in favor of `WindowBuilder::with_parent_window`.
+- On Windows, retain `WS_MAXIMIZE` window style when un-minimizing a maximized window.
+- On Windows, fix left mouse button release event not being sent after `Window::drag_window`.
+- On macOS, run most actions on the main thread, which is strictly more correct, but might make multithreaded applications block slightly more.
+- On macOS, fix panic when getting current monitor without any monitor attached.
+- On Windows and MacOS, add API to enable/disable window buttons (close, minimize, ...etc).
+- On Windows, macOS, X11 and Wayland, add `Window::set_theme`.
+- **Breaking:** Remove `WindowExtWayland::wayland_set_csd_theme` and `WindowBuilderExtX11::with_gtk_theme_variant`.
+- On Windows, revert window background to an empty brush to avoid white flashes when changing scaling.
+- **Breaking:** Removed `Window::set_always_on_top` and related APIs in favor of `Window::set_window_level`.
+- On Windows, MacOS and X11, add always on bottom APIs.
+- On Windows, fix the value in `MouseButton::Other`.
+- On macOS, add `WindowExtMacOS::is_document_edited` and `WindowExtMacOS::set_document_edited` APIs.
+- **Breaking:** Removed `WindowBuilderExtIOS::with_root_view_class`; instead, you should use `[[view layer] addSublayer: ...]` to add an instance of the desired layer class (e.g. `CAEAGLLayer` or `CAMetalLayer`). See `vulkano-win` or `wgpu` for examples of this.
+- On MacOS and Windows, add `Window::set_content_protected`.
+- On MacOS, add `EventLoopBuilderExtMacOS::with_activate_ignoring_other_apps`.
+- On Windows, fix icons specified on `WindowBuilder` not taking effect for windows created after the first one.
+- On Windows and macOS, add `Window::title` to query the current window title.
+- On Windows, fix focusing menubar when pressing `Alt`.
+- On MacOS, made `accepts_first_mouse` configurable.
+- Migrated `WindowBuilderExtUnix::with_resize_increments` to `WindowBuilder`.
+- Added `Window::resize_increments`/`Window::set_resize_increments` to update resize increments at runtime for X11/macOS.
+- macOS/iOS: Use `objc2` instead of `objc` internally.
+- **Breaking:** Bump MSRV from `1.57` to `1.60`.
+- **Breaking:** Split the `platform::unix` module into `platform::x11` and `platform::wayland`. The extension types are similarly renamed.
+- **Breaking:**: Removed deprecated method `platform::unix::WindowExtUnix::is_ready`.
+- Removed `parking_lot` dependency.
+- **Breaking:** On macOS, add support for two-finger touchpad magnification and rotation gestures with new events `WindowEvent::TouchpadMagnify` and `WindowEvent::TouchpadRotate`. Also add support for touchpad smart-magnification gesture with a new event `WindowEvent::SmartMagnify`.
+- **Breaking:** On web, the `WindowBuilderExtWebSys::with_prevent_default` setting (enabled by default), now additionally prevents scrolling of the webpage in mobile browsers, previously it only disabled scrolling on desktop.
+- On Wayland, `wayland-csd-adwaita` now uses `ab_glyph` instead of `crossfont` to render the title for decorations.
+- On Wayland, a new `wayland-csd-adwaita-crossfont` feature was added to use `crossfont` instead of `ab_glyph` for decorations.
+- On Wayland, if not otherwise specified use upstream automatic CSD theme selection.
+- On X11, added `WindowExtX11::with_parent` to create child windows.
+- Added support for `WindowBuilder::with_theme` and `Window::theme` to support per-window dark/light/system theme configuration on macos, windows and wayland.
+- On macOS, added support for `WindowEvent::ThemeChanged`.
+- **Breaking:** Removed `WindowBuilderExtWindows::with_theme` and `WindowBuilderExtWayland::with_wayland_csd_theme` in favour of `WindowBuilder::with_theme`.
+- **Breaking:** Removed `WindowExtWindows::theme` in favour of `Window::theme`.
+- Enabled `doc_auto_cfg` when generating docs on docs.rs for feature labels.
+- **Breaking:** On Android, switched to using [`android-activity`](https://github.com/rib/android-activity) crate as a glue layer instead of [`ndk-glue`](https://github.com/rust-windowing/android-ndk-rs/tree/master/ndk-glue). See [README.md#Android](https://github.com/rust-windowing/winit#Android) for more details. ([#2444](https://github.com/rust-windowing/winit/pull/2444))
+- **Breaking:** Removed support for `raw-window-handle` version `0.4`
+- On Wayland, `RedrawRequested` not emitted during resize.
+- Add a `set_wait_timeout` function to `ControlFlow` to allow waiting for a `Duration`.
+- **Breaking:** Remove the unstable `xlib_xconnection()` function from the private interface.
+- Added Orbital support for Redox OS
+- On X11, added `drag_resize_window` method.
+- Added `Window::set_transparent` to provide a hint about transparency of the window on Wayland and macOS.
+- On macOS, fix the mouse buttons other than left/right/middle being reported as middle.
+- On Wayland, support fractional scaling via the wp-fractional-scale protocol.
+- On web, fix removal of mouse event listeners from the global object upon window destruction.
+- Add WindowAttributes getter to WindowBuilder to allow introspection of default values.
+- Added `Window::set_ime_purpose` for setting the IME purpose, currently implemented on Wayland only.

vendor/winit/src/changelog/v0.29.md

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

vendor/winit/src/changelog/v0.30.md

@@ -0,0 +1,398 @@
+## 0.30.12
+
+### Fixed
+
+- On macOS, fix crash on macOS 26 by using objc2's `relax-sign-encoding` feature.
+
+## 0.30.11
+
+### Fixed
+
+- On Windows, fixed crash in should_apps_use_dark_mode() for Windows versions < 17763.
+- On Wayland, fixed `pump_events` driven loop deadlocking when loop was not drained before exit.
+
+## 0.30.10
+
+### Added
+
+- On Windows, add `IconExtWindows::from_resource_name`.
+- On Windows, add `CursorGrabMode::Locked`.
+- On Wayland, add `WindowExtWayland::xdg_toplevel`.
+
+### Changed
+
+- On macOS, no longer need control of the main `NSApplication` class (which means you can now override it yourself).
+- On iOS, remove custom application delegates. You are now allowed to override the
+  application delegate yourself.
+- On iOS, no longer act as-if the application successfully open all URLs. Override
+  `application:didFinishLaunchingWithOptions:` and provide the desired behaviour yourself.
+
+### Fixed
+
+- On Windows, fixed ~500 ms pause when clicking the title bar during continuous redraw.
+- On macOS, `WindowExtMacOS::set_simple_fullscreen` now honors `WindowExtMacOS::set_borderless_game`
+- On X11 and Wayland, fixed pump_events with `Some(Duration::Zero)` blocking with `Wait` polling mode
+- On Wayland, fixed a crash when consequently calling `set_cursor_grab` without pointer focus.
+- On Wayland, ensure that external event loop is woken-up when using pump_events and integrating via `FD`.
+- On Wayland, apply fractional scaling to custom cursors.
+- On macOS, fixed `run_app_on_demand` returning without closing open windows.
+- On macOS, fixed `VideoMode::refresh_rate_millihertz` for fractional refresh rates.
+- On macOS, store monitor handle to avoid panics after going in/out of sleep.
+- On macOS, allow certain invalid monitor handles and return `None` instead of panicking.
+- On Windows, fixed `Ime::Preedit` cursor offset calculation.
+
+## 0.30.9
+
+### Changed
+
+- On Wayland, no longer send an explicit clearing `Ime::Preedit` just prior to a new `Ime::Preedit`.
+
+### Fixed
+
+- On X11, fix crash with uim.
+- On X11, fix modifiers for keys that were sent by the same X11 request.
+- On iOS, fix high CPU usage even when using `ControlFlow::Wait`.
+
+## 0.30.8
+
+### Added
+
+- `ActivationToken::from_raw` and `ActivationToken::into_raw`.
+- On X11, add a workaround for disabling IME on GNOME.
+
+### Fixed
+
+- On Windows, fixed the event loop not waking on accessibility requests.
+- On X11, fixed cursor grab mode state tracking on error.
+
+## 0.30.7
+
+### Fixed
+
+- On X11, fixed KeyboardInput delivered twice when IME enabled.
+
+## 0.30.6
+
+### Added
+
+- On macOS, add `WindowExtMacOS::set_borderless_game` and `WindowAttributesExtMacOS::with_borderless_game`
+  to fully disable the menu bar and dock in Borderless Fullscreen as commonly done in games.
+- On X11, the `window` example now understands the `X11_VISUAL_ID` and `X11_SCREEN_ID` env
+  variables to test the respective modifiers of window creation.
+- On Android, the soft keyboard can now be shown using `Window::set_ime_allowed`.
+- Add basic iOS IME support. The soft keyboard can now be shown using `Window::set_ime_allowed`.
+
+### Fixed
+
+- On macOS, fix `WindowEvent::Moved` sometimes being triggered unnecessarily on resize.
+- On macOS, package manifest definitions of `LSUIElement` will no longer be overridden with the
+  default activation policy, unless explicitly provided during initialization.
+- On macOS, fix crash when calling `drag_window()` without a left click present.
+- On X11, key events forward to IME anyway, even when it's disabled.
+- On Windows, make `ControlFlow::WaitUntil` work more precisely using `CREATE_WAITABLE_TIMER_HIGH_RESOLUTION`.
+- On X11, creating windows on screen that is not the first one (e.g. `DISPLAY=:0.1`) works again.
+- On X11, creating windows while passing `with_x11_screen(non_default_screen)` works again.
+- On X11, fix XInput handling that prevented a new window from getting the focus in some cases.
+- On macOS, fix crash when pressing Caps Lock in certain configurations.
+- On iOS, fixed `MonitorHandle`'s `PartialEq` and `Hash` implementations.
+- On macOS, fixed undocumented cursors (e.g. zoom, resize, help) always appearing to be invalid and falling back to the default cursor.
+
+## 0.30.5
+
+### Added
+
+- Add `ActiveEventLoop::system_theme()`, returning the current system theme.
+- On Web, implement `Error` for `platform::web::CustomCursorError`.
+- On Android, add `{Active,}EventLoopExtAndroid::android_app()` to access the app used to create the loop.
+
+### Fixed
+
+- On MacOS, fix building with `feature = "rwh_04"`.
+- On Web, pen events are now routed through to `WindowEvent::Cursor*`.
+- On macOS, fix panic when releasing not available monitor.
+- On MacOS, return the system theme in `Window::theme()` if no theme override is set.
+
+## 0.30.4
+
+### Changed
+
+- `DeviceId::dummy()` and `WindowId::dummy()` are no longer marked `unsafe`.
+
+### Fixed
+
+- On Wayland, avoid crashing when compositor is misbehaving.
+- On Web, fix `WindowEvent::Resized` not using `requestAnimationFrame` when sending
+  `WindowEvent::RedrawRequested` and also potentially causing `WindowEvent::RedrawRequested`
+  to not be de-duplicated.
+- Account for different browser engine implementations of pointer movement coordinate space.
+
+## 0.30.3
+
+### Added
+
+- On Web, add `EventLoopExtWebSys::(set_)poll_strategy()` to allow setting
+  control flow strategies before starting the event loop.
+- On Web, add `WaitUntilStrategy`, which allows to set different strategies for
+  `ControlFlow::WaitUntil`. By default the Prioritized Task Scheduling API is
+  used, with a fallback to `setTimeout()` with a trick to circumvent throttling
+  to 4ms. But an option to use a Web worker to schedule the timer is available
+  as well, which commonly prevents any throttling when the window is not focused.
+
+### Changed
+
+- On macOS, set the window theme on the `NSWindow` instead of application-wide.
+
+### Fixed
+
+- On X11, build on arm platforms.
+- On macOS, fixed `WindowBuilder::with_theme` not having any effect on the window.
+
+## 0.30.2
+
+### Fixed
+
+- On Web, fix `EventLoopProxy::send_event()` triggering event loop immediately
+  when not called from inside the event loop. Now queues a microtask instead.
+- On Web, stop overwriting default cursor with `CursorIcon::Default`.
+- On Web, prevent crash when using `InnerSizeWriter::request_inner_size()`.
+- On macOS, fix not working opacity for entire window.
+
+## 0.30.1
+
+### Added
+
+- Reexport `raw-window-handle` versions 0.4 and 0.5 as `raw_window_handle_04` and `raw_window_handle_05`.
+- Implement `ApplicationHandler` for `&mut` references and heap allocations to something that implements `ApplicationHandler`.
+
+### Fixed
+
+- On macOS, fix panic on exit when dropping windows outside the event loop.
+- On macOS, fix window dragging glitches when dragging across a monitor boundary with different scale factor.
+- On macOS, fix the range in `Ime::Preedit`.
+- On macOS, use the system's internal mechanisms for queuing events.
+- On macOS, handle events directly instead of queuing when possible.
+
+## 0.30.0
+
+### Added
+
+- Add `OwnedDisplayHandle` type for allowing safe display handle usage outside of
+  trivial cases.
+- Add `ApplicationHandler<T>` trait which mimics `Event<T>`.
+- Add `WindowBuilder::with_cursor` and `Window::set_cursor` which takes a
+  `CursorIcon` or `CustomCursor`.
+- Add `Sync` implementation for `EventLoopProxy<T: Send>`.
+- Add `Window::default_attributes` to get default `WindowAttributes`.
+- Add `EventLoop::builder` to get `EventLoopBuilder` without export.
+- Add `CustomCursor::from_rgba` to allow creating cursor images from RGBA data.
+- Add `CustomCursorExtWebSys::from_url` to allow loading cursor images from URLs.
+- Add `CustomCursorExtWebSys::from_animation` to allow creating animated
+  cursors from other `CustomCursor`s.
+- Add `{Active,}EventLoop::create_custom_cursor` to load custom cursor image sources.
+- Add `ActiveEventLoop::create_window` and `EventLoop::create_window`.
+- Add `CustomCursor` which could be set via `Window::set_cursor`, implemented on
+  Windows, macOS, X11, Wayland, and Web.
+- On Web, add to toggle calling `Event.preventDefault()` on `Window`.
+- On iOS, add `PinchGesture`, `DoubleTapGesture`, `PanGesture` and `RotationGesture`.
+- on iOS, use `UIGestureRecognizerDelegate` for fine grained control of gesture recognizers.
+- On macOS, add services menu.
+- On Windows, add `with_title_text_color`, and `with_corner_preference` on
+  `WindowAttributesExtWindows`.
+- On Windows, implement resize increments.
+- On Windows, add `AnyThread` API to access window handle off the main thread.
+
+### Changed
+
+- Bump MSRV from `1.65` to `1.70`.
+- On Wayland, bump `sctk-adwaita` to `0.9.0`, which changed system library
+  crates. This change is a **cascading breaking change**, you must do breaking
+  change as well, even if you don't expose winit.
+- Rename `TouchpadMagnify` to `PinchGesture`.
+- Rename `SmartMagnify` to `DoubleTapGesture`.
+- Rename `TouchpadRotate` to `RotationGesture`.
+- Rename `EventLoopWindowTarget` to `ActiveEventLoop`.
+- Rename `platform::x11::XWindowType` to `platform::x11::WindowType`.
+- Rename `VideoMode` to `VideoModeHandle` to represent that it doesn't hold
+  static data.
+- Make `Debug` formatting of `WindowId` more concise.
+- Move `dpi` types to its own crate, and re-export it from the root crate.
+- Replace `log` with `tracing`, use `log` feature on `tracing` to restore old
+  behavior.
+- `EventLoop::with_user_event` now returns `EventLoopBuilder`.
+- On Web, return `HandleError::Unavailable` when a window handle is not available.
+- On Web, return `RawWindowHandle::WebCanvas` instead of `RawWindowHandle::Web`.
+- On Web, remove queuing fullscreen request in absence of transient activation.
+- On iOS, return `HandleError::Unavailable` when a window handle is not available.
+- On macOS, return `HandleError::Unavailable` when a window handle is not available.
+- On Windows, remove `WS_CAPTION`, `WS_BORDER`, and `WS_EX_WINDOWEDGE` styles
+  for child windows without decorations.
+- On Android, bump `ndk` to `0.9.0` and `android-activity` to `0.6.0`,
+  and remove unused direct dependency on `ndk-sys`.
+
+### Deprecated
+
+- Deprecate `EventLoop::run`, use `EventLoop::run_app`.
+- Deprecate `EventLoopExtRunOnDemand::run_on_demand`, use `EventLoop::run_app_on_demand`.
+- Deprecate `EventLoopExtPumpEvents::pump_events`, use `EventLoopExtPumpEvents::pump_app_events`.
+
+  The new `app` APIs accept a newly added `ApplicationHandler<T>` instead of
+  `Fn`. The semantics are mostly the same, given that the capture list of the
+  closure is your new `State`. Consider the following code:
+
+  ```rust,no_run
+  use winit::event::Event;
+  use winit::event_loop::EventLoop;
+  use winit::window::Window;
+
+  struct MyUserEvent;
+
+  let event_loop = EventLoop::<MyUserEvent>::with_user_event().build().unwrap();
+  let window = event_loop.create_window(Window::default_attributes()).unwrap();
+  let mut counter = 0;
+
+  let _ = event_loop.run(move |event, event_loop| {
+      match event {
+          Event::AboutToWait => {
+              window.request_redraw();
+              counter += 1;
+          }
+          Event::WindowEvent { window_id, event } => {
+              // Handle window event.
+          }
+          Event::UserEvent(event) => {
+              // Handle user event.
+          }
+          Event::DeviceEvent { device_id, event } => {
+              // Handle device event.
+          }
+          _ => (),
+      }
+  });
+  ```
+
+  To migrate this code, you should move all the captured values into some
+  newtype `State` and implement `ApplicationHandler` for this type. Finally,
+  we move particular `match event` arms into methods on `ApplicationHandler`,
+  for example:
+
+  ```rust,no_run
+  use winit::application::ApplicationHandler;
+  use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
+  use winit::event_loop::{EventLoop, ActiveEventLoop};
+  use winit::window::{Window, WindowId};
+
+  struct MyUserEvent;
+
+  struct State {
+      window: Window,
+      counter: i32,
+  }
+
+  impl ApplicationHandler<MyUserEvent> for State {
+      fn user_event(&mut self, event_loop: &ActiveEventLoop, user_event: MyUserEvent) {
+          // Handle user event.
+      }
+
+      fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+          // Your application got resumed.
+      }
+
+      fn window_event(&mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent) {
+          // Handle window event.
+      }
+
+      fn device_event(&mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent) {
+          // Handle device event.
+      }
+
+      fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+          self.window.request_redraw();
+          self.counter += 1;
+      }
+  }
+
+  let event_loop = EventLoop::<MyUserEvent>::with_user_event().build().unwrap();
+  #[allow(deprecated)]
+  let window = event_loop.create_window(Window::default_attributes()).unwrap();
+  let mut state = State { window, counter: 0 };
+
+  let _ = event_loop.run_app(&mut state);
+  ```
+
+  Please submit your feedback after migrating in [this issue](https://github.com/rust-windowing/winit/issues/3626).
+
+- Deprecate `Window::set_cursor_icon`, use `Window::set_cursor`.
+
+### Removed
+
+- Remove `Window::new`, use `ActiveEventLoop::create_window` instead.
+
+  You now have to create your windows inside the actively running event loop
+  (usually the `new_events(cause: StartCause::Init)` or `resumed()` events),
+  and can no longer do it before the application has properly launched.
+  This change is done to fix many long-standing issues on iOS and macOS, and
+  will improve things on Wayland once fully implemented.
+
+  To ease migration, we provide the deprecated `EventLoop::create_window` that
+  will allow you to bypass this restriction in this release.
+
+  Using the migration example from above, you can change your code as follows:
+
+  ```rust,no_run
+  use winit::application::ApplicationHandler;
+  use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
+  use winit::event_loop::{EventLoop, ActiveEventLoop};
+  use winit::window::{Window, WindowId};
+
+  #[derive(Default)]
+  struct State {
+      // Use an `Option` to allow the window to not be available until the
+      // application is properly running.
+      window: Option<Window>,
+      counter: i32,
+  }
+
+  impl ApplicationHandler for State {
+      // This is a common indicator that you can create a window.
+      fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+          self.window = Some(event_loop.create_window(Window::default_attributes()).unwrap());
+      }
+      fn window_event(&mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent) {
+          // `unwrap` is fine, the window will always be available when
+          // receiving a window event.
+          let window = self.window.as_ref().unwrap();
+          // Handle window event.
+      }
+      fn device_event(&mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent) {
+          // Handle window event.
+      }
+      fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+          if let Some(window) = self.window.as_ref() {
+              window.request_redraw();
+              self.counter += 1;
+          }
+      }
+  }
+
+  let event_loop = EventLoop::new().unwrap();
+  let mut state = State::default();
+  let _ = event_loop.run_app(&mut state);
+  ```
+
+- Remove `Deref` implementation for `EventLoop` that gave `EventLoopWindowTarget`.
+- Remove `WindowBuilder` in favor of `WindowAttributes`.
+- Remove Generic parameter `T` from `ActiveEventLoop`.
+- Remove `EventLoopBuilder::with_user_event`, use `EventLoop::with_user_event`.
+- Remove Redundant `EventLoopError::AlreadyRunning`.
+- Remove `WindowAttributes::fullscreen` and expose as field directly.
+- On X11, remove `platform::x11::XNotSupported` export.
+
+### Fixed
+
+- On Web, fix setting cursor icon overriding cursor visibility.
+- On Windows, fix cursor not confined to center of window when grabbed and hidden.
+- On macOS, fix sequence of mouse events being out of order when dragging on the trackpad.
+- On Wayland, fix decoration glitch on close with some compositors.
+- On Android, fix a regression introduced in #2748 to allow volume key events to be received again.
+- On Windows, don't return a valid window handle outside of the GUI thread.
+- On macOS, don't set the background color when initializing a window with transparency.

vendor/winit/src/changelog/v0.8.md

@@ -0,0 +1,33 @@
+## 0.8.3
+
+- Fixed issue of calls to `set_inner_size` blocking on Windows.
+- Mapped `ISO_Left_Tab` to `VirtualKeyCode::Tab` to make the key work with modifiers
+- Fixed the X11 backed on 32bit targets
+
+## 0.8.2
+
+- Uniformize keyboard scancode values across Wayland and X11 (#297).
+- Internal rework of the wayland event loop
+- Added method `os::linux::WindowExt::is_ready`
+
+## 0.8.1
+
+- Added various methods to `os::linux::EventsLoopExt`, plus some hidden items necessary to make
+  glutin work.
+
+## 0.8.0
+
+- Added `Window::set_maximized`, `WindowAttributes::maximized` and `WindowBuilder::with_maximized`.
+- Added `Window::set_fullscreen`.
+- Changed `with_fullscreen` to take a `Option<MonitorId>` instead of a `MonitorId`.
+- Removed `MonitorId::get_native_identifier()` in favor of platform-specific traits in the `os`
+  module.
+- Changed `get_available_monitors()` and `get_primary_monitor()` to be methods of `EventsLoop`
+  instead of stand-alone methods.
+- Changed `EventsLoop` to be tied to a specific X11 or Wayland connection.
+- Added a `os::linux::EventsLoopExt` trait that makes it possible to configure the connection.
+- Fixed the emscripten code, which now compiles.
+- Changed the X11 fullscreen code to use `xrandr` instead of `xxf86vm`.
+- Fixed the Wayland backend to produce `Refresh` event after window creation.
+- Changed the `Suspended` event to be outside of `WindowEvent`.
+- Fixed the X11 backend sometimes reporting the wrong virtual key (#273).

vendor/winit/src/changelog/v0.9.md

@@ -0,0 +1,22 @@
+## 0.9.0
+
+- Added event `WindowEvent::HiDPIFactorChanged`.
+- Added method `MonitorId::get_hidpi_factor`.
+- Deprecated `get_inner_size_pixels` and `get_inner_size_points` methods of `Window` in favor of
+  `get_inner_size`.
+- **Breaking:** `EventsLoop` is `!Send` and `!Sync` because of platform-dependant constraints,
+  but `Window`, `WindowId`, `DeviceId` and `MonitorId` guaranteed to be `Send`.
+- `MonitorId::get_position` now returns `(i32, i32)` instead of `(u32, u32)`.
+- Rewrite of the wayland backend to use wayland-client-0.11
+- Support for dead keys on wayland for keyboard utf8 input
+- Monitor enumeration on Windows is now implemented using `EnumDisplayMonitors` instead of
+  `EnumDisplayDevices`. This changes the value returned by `MonitorId::get_name()`.
+- On Windows added `MonitorIdExt::hmonitor` method
+- Impl `Clone` for `EventsLoopProxy`
+- `EventsLoop::get_primary_monitor()` on X11 will fallback to any available monitor if no primary is found
+- Support for touch event on wayland
+- `WindowEvent`s `MouseMoved`, `MouseEntered`, and `MouseLeft` have been renamed to
+  `CursorMoved`, `CursorEntered`, and `CursorLeft`.
+- New `DeviceEvent`s added, `MouseMotion` and `MouseWheel`.
+- Send `CursorMoved` event after `CursorEntered` and `Focused` events.
+- Add support for `ModifiersState`, `MouseMove`, `MouseInput`, `MouseMotion` for emscripten backend.

vendor/winit/src/cursor.rs

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

vendor/winit/src/error.rs

@@ -0,0 +1,131 @@
+use std::{error, fmt};
+
+use crate::platform_impl;
+
+// TODO: Rename
+/// An error that may be generated when requesting Winit state
+#[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),
+}
+
+/// The error type for when the requested operation is not supported by the backend.
+#[derive(Clone)]
+pub struct NotSupportedError {
+    _marker: (),
+}
+
+/// The error type for when the OS cannot perform the requested operation.
+#[derive(Debug)]
+pub struct OsError {
+    line: u32,
+    file: &'static str,
+    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-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)]
+    pub(crate) fn new() -> NotSupportedError {
+        NotSupportedError { _marker: () }
+    }
+}
+
+impl OsError {
+    #[allow(dead_code)]
+    pub(crate) fn new(line: u32, file: &'static str, error: platform_impl::OsError) -> OsError {
+        OsError { line, file, error }
+    }
+}
+
+#[allow(unused_macros)]
+macro_rules! os_error {
+    ($error:expr) => {{
+        crate::error::OsError::new(line!(), file!(), $error)
+    }};
+}
+
+impl fmt::Display for OsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.pad(&format!("os error at {}:{}: {}", self.file, self.line, self.error))
+    }
+}
+
+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),
+        }
+    }
+}
+
+impl fmt::Debug for NotSupportedError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.debug_struct("NotSupportedError").finish()
+    }
+}
+
+impl fmt::Display for NotSupportedError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.pad("the requested operation is not supported by Winit")
+    }
+}
+
+impl fmt::Display for EventLoopError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        match self {
+            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)]
+#[allow(clippy::redundant_clone)]
+mod tests {
+    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())
+        );
+    }
+}

vendor/winit/src/event_loop.rs

@@ -0,0 +1,651 @@
+//! The [`EventLoop`] struct and assorted supporting types, including
+//! [`ControlFlow`].
+//!
+//! If you want to send custom events to the event loop, use
+//! [`EventLoop::create_proxy`] to acquire an [`EventLoopProxy`] and call its
+//! [`send_event`][EventLoopProxy::send_event] method.
+//!
+//! See the root-level documentation for information on how to create and use an event loop to
+//! handle events.
+use std::marker::PhantomData;
+#[cfg(any(x11_platform, wayland_platform))]
+use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::{error, fmt};
+
+#[cfg(not(web_platform))]
+use std::time::{Duration, Instant};
+#[cfg(web_platform)]
+use web_time::{Duration, Instant};
+
+use crate::application::ApplicationHandler;
+use crate::error::{EventLoopError, OsError};
+use crate::event::Event;
+use crate::monitor::MonitorHandle;
+use crate::platform_impl;
+use crate::window::{CustomCursor, CustomCursorSource, Theme, Window, WindowAttributes};
+
+/// Provides a way to retrieve events from the system and from the windows that were registered to
+/// the events loop.
+///
+/// An `EventLoop` can be seen more or less as a "context". Calling [`EventLoop::new`]
+/// initializes everything that will be required to create windows. For example on Linux creating
+/// an event loop opens a connection to the X or Wayland server.
+///
+/// To wake up an `EventLoop` from a another thread, see the [`EventLoopProxy`] docs.
+///
+/// Note that this cannot be shared across threads (due to platform-dependant logic
+/// forbidding it), as such it is neither [`Send`] nor [`Sync`]. If you need cross-thread access,
+/// the [`Window`] created from this _can_ be sent to an other thread, and the
+/// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread.
+///
+/// [`Window`]: crate::window::Window
+pub struct EventLoop<T: 'static> {
+    pub(crate) event_loop: platform_impl::EventLoop<T>,
+    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
+}
+
+/// Target that associates windows with an [`EventLoop`].
+///
+/// This type exists to allow you to create new windows while Winit executes
+/// your callback.
+pub struct ActiveEventLoop {
+    pub(crate) p: platform_impl::ActiveEventLoop,
+    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
+}
+
+/// Object that allows building the event loop.
+///
+/// This is used to make specifying options that affect the whole application
+/// easier. But note that constructing multiple event loops is not supported.
+///
+/// This can be created using [`EventLoop::new`] or [`EventLoop::with_user_event`].
+#[derive(Default)]
+pub struct EventLoopBuilder<T: 'static> {
+    pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
+    _p: PhantomData<T>,
+}
+
+static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
+
+impl EventLoopBuilder<()> {
+    /// Start building a new event loop.
+    #[inline]
+    #[deprecated = "use `EventLoop::builder` instead"]
+    pub fn new() -> Self {
+        EventLoop::builder()
+    }
+}
+
+impl<T> EventLoopBuilder<T> {
+    /// Builds a new event loop.
+    ///
+    /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
+    /// and only once per application.***
+    ///
+    /// 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.
+    ///
+    /// [`platform`]: crate::platform
+    #[cfg_attr(
+        android_platform,
+        doc = "[`.with_android_app(app)`]: \
+               crate::platform::android::EventLoopBuilderExtAndroid::with_android_app"
+    )]
+    #[cfg_attr(
+        not(android_platform),
+        doc = "[`.with_android_app(app)`]: #only-available-on-android"
+    )]
+    #[inline]
+    pub fn build(&mut self) -> Result<EventLoop<T>, EventLoopError> {
+        let _span = tracing::debug_span!("winit::EventLoopBuilder::build").entered();
+
+        if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
+            return Err(EventLoopError::RecreationAttempt);
+        }
+
+        // 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)?,
+            _marker: PhantomData,
+        })
+    }
+
+    #[cfg(web_platform)]
+    pub(crate) fn allow_event_loop_recreation() {
+        EVENT_LOOP_CREATED.store(false, Ordering::Relaxed);
+    }
+}
+
+impl<T> fmt::Debug for EventLoop<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("EventLoop { .. }")
+    }
+}
+
+impl fmt::Debug for ActiveEventLoop {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("ActiveEventLoop { .. }")
+    }
+}
+
+/// Set through [`ActiveEventLoop::set_control_flow()`].
+///
+/// Indicates the desired behavior of the event loop after [`Event::AboutToWait`] is emitted.
+///
+/// Defaults to [`Wait`].
+///
+/// [`Wait`]: Self::Wait
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
+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.
+    Poll,
+
+    /// When the current loop iteration finishes, suspend the thread until another event arrives.
+    #[default]
+    Wait,
+
+    /// When the current loop iteration finishes, suspend the thread until either another event
+    /// arrives or the given time is reached.
+    ///
+    /// Useful for implementing efficient timers. Applications which want to render at the
+    /// display's native refresh rate should instead use [`Poll`] and the VSync functionality
+    /// of a graphics API to reduce odds of missed frames.
+    ///
+    /// [`Poll`]: Self::Poll
+    WaitUntil(Instant),
+}
+
+impl ControlFlow {
+    /// Creates a [`ControlFlow`] that waits until a timeout has expired.
+    ///
+    /// In most cases, this is set to [`WaitUntil`]. However, if the timeout overflows, it is
+    /// instead set to [`Wait`].
+    ///
+    /// [`WaitUntil`]: Self::WaitUntil
+    /// [`Wait`]: Self::Wait
+    pub fn wait_duration(timeout: Duration) -> Self {
+        match Instant::now().checked_add(timeout) {
+            Some(instant) => Self::WaitUntil(instant),
+            None => Self::Wait,
+        }
+    }
+}
+
+impl EventLoop<()> {
+    /// Create the event loop.
+    ///
+    /// This is an alias of `EventLoop::builder().build()`.
+    #[inline]
+    pub fn new() -> Result<EventLoop<()>, EventLoopError> {
+        Self::builder().build()
+    }
+
+    /// Start building a new event loop.
+    ///
+    /// This returns an [`EventLoopBuilder`], to allow configuring the event loop before creation.
+    ///
+    /// To get the actual event loop, call [`build`][EventLoopBuilder::build] on that.
+    #[inline]
+    pub fn builder() -> EventLoopBuilder<()> {
+        Self::with_user_event()
+    }
+}
+
+impl<T> EventLoop<T> {
+    /// Start building a new event loop, with the given type as the user event
+    /// type.
+    pub fn with_user_event() -> EventLoopBuilder<T> {
+        EventLoopBuilder { platform_specific: Default::default(), _p: PhantomData }
+    }
+
+    /// See [`run_app`].
+    ///
+    /// [`run_app`]: Self::run_app
+    #[inline]
+    #[deprecated = "use `EventLoop::run_app` instead"]
+    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
+    pub fn run<F>(self, event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<T>, &ActiveEventLoop),
+    {
+        let _span = tracing::debug_span!("winit::EventLoop::run").entered();
+
+        self.event_loop.run(event_handler)
+    }
+
+    /// Run the application with the event loop on the calling thread.
+    ///
+    /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **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
+    #[cfg_attr(
+        web_platform,
+        doc = "[`EventLoopExtWebSys::spawn_app()`][crate::platform::web::EventLoopExtWebSys::spawn_app()]"
+    )]
+    #[cfg_attr(not(web_platform), doc = "`EventLoopExtWebSys::spawn()`")]
+    ///   [^1] instead of [`run_app()`] to avoid the need
+    ///   for the Javascript exception trick, and to make it clearer that the event loop runs
+    ///   asynchronously (via the browser's own, internal, event loop) and doesn't block the
+    ///   current thread of execution like it does on other platforms.
+    ///
+    ///   This function won't be available with `target_feature = "exception-handling"`.
+    ///
+    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
+    /// [`run_app()`]: Self::run_app()
+    /// [^1]: `EventLoopExtWebSys::spawn_app()` is only available on Web.
+    #[inline]
+    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
+    pub fn run_app<A: ApplicationHandler<T>>(self, app: &mut A) -> Result<(), EventLoopError> {
+        self.event_loop.run(|event, event_loop| dispatch_event_for_app(app, event_loop, event))
+    }
+
+    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
+    /// to the main event loop, possibly from another thread.
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy { event_loop_proxy: self.event_loop.create_proxy() }
+    }
+
+    /// Gets a persistent reference to the underlying platform display.
+    ///
+    /// See the [`OwnedDisplayHandle`] type for more information.
+    pub fn owned_display_handle(&self) -> OwnedDisplayHandle {
+        OwnedDisplayHandle { platform: self.event_loop.window_target().p.owned_display_handle() }
+    }
+
+    /// Change if or when [`DeviceEvent`]s are captured.
+    ///
+    /// See [`ActiveEventLoop::listen_device_events`] for details.
+    ///
+    /// [`DeviceEvent`]: crate::event::DeviceEvent
+    pub fn listen_device_events(&self, allowed: DeviceEvents) {
+        let _span = tracing::debug_span!(
+            "winit::EventLoop::listen_device_events",
+            allowed = ?allowed
+        )
+        .entered();
+
+        self.event_loop.window_target().p.listen_device_events(allowed);
+    }
+
+    /// Sets the [`ControlFlow`].
+    pub fn set_control_flow(&self, control_flow: ControlFlow) {
+        self.event_loop.window_target().p.set_control_flow(control_flow)
+    }
+
+    /// Create a window.
+    ///
+    /// Creating window without event loop running often leads to improper window creation;
+    /// use [`ActiveEventLoop::create_window`] instead.
+    #[deprecated = "use `ActiveEventLoop::create_window` instead"]
+    #[inline]
+    pub fn create_window(&self, window_attributes: WindowAttributes) -> Result<Window, OsError> {
+        let _span = tracing::debug_span!(
+            "winit::EventLoop::create_window",
+            window_attributes = ?window_attributes
+        )
+        .entered();
+
+        let window =
+            platform_impl::Window::new(&self.event_loop.window_target().p, window_attributes)?;
+        Ok(Window { window })
+    }
+
+    /// Create custom cursor.
+    pub fn create_custom_cursor(&self, custom_cursor: CustomCursorSource) -> CustomCursor {
+        self.event_loop.window_target().p.create_custom_cursor(custom_cursor)
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl<T> rwh_06::HasDisplayHandle for EventLoop<T> {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        rwh_06::HasDisplayHandle::display_handle(self.event_loop.window_target())
+    }
+}
+
+#[cfg(feature = "rwh_05")]
+unsafe impl<T> rwh_05::HasRawDisplayHandle for EventLoop<T> {
+    /// Returns a [`rwh_05::RawDisplayHandle`] for the event loop.
+    fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
+        rwh_05::HasRawDisplayHandle::raw_display_handle(self.event_loop.window_target())
+    }
+}
+
+#[cfg(any(x11_platform, wayland_platform))]
+impl<T> AsFd for EventLoop<T> {
+    /// Get the underlying [EventLoop]'s `fd` which you can register
+    /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
+    /// loop must be polled with the [`pump_app_events`] API.
+    ///
+    /// [`calloop`]: https://crates.io/crates/calloop
+    /// [`mio`]: https://crates.io/crates/mio
+    /// [`pump_app_events`]: crate::platform::pump_events::EventLoopExtPumpEvents::pump_app_events
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.event_loop.as_fd()
+    }
+}
+
+#[cfg(any(x11_platform, wayland_platform))]
+impl<T> AsRawFd for EventLoop<T> {
+    /// Get the underlying [EventLoop]'s raw `fd` which you can register
+    /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
+    /// loop must be polled with the [`pump_app_events`] API.
+    ///
+    /// [`calloop`]: https://crates.io/crates/calloop
+    /// [`mio`]: https://crates.io/crates/mio
+    /// [`pump_app_events`]: crate::platform::pump_events::EventLoopExtPumpEvents::pump_app_events
+    fn as_raw_fd(&self) -> RawFd {
+        self.event_loop.as_raw_fd()
+    }
+}
+
+impl ActiveEventLoop {
+    /// Create the window.
+    ///
+    /// Possible causes of error include denied permission, incompatible system, and lack of memory.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web:** The window is created but not inserted into the web page automatically. Please
+    ///   see the web platform module for more information.
+    #[inline]
+    pub fn create_window(&self, window_attributes: WindowAttributes) -> Result<Window, OsError> {
+        let _span = tracing::debug_span!(
+            "winit::ActiveEventLoop::create_window",
+            window_attributes = ?window_attributes
+        )
+        .entered();
+
+        let window = platform_impl::Window::new(&self.p, window_attributes)?;
+        Ok(Window { window })
+    }
+
+    /// Create custom cursor.
+    pub fn create_custom_cursor(&self, custom_cursor: CustomCursorSource) -> CustomCursor {
+        let _span = tracing::debug_span!("winit::ActiveEventLoop::create_custom_cursor",).entered();
+
+        self.p.create_custom_cursor(custom_cursor)
+    }
+
+    /// Returns the list of all the monitors available on the system.
+    #[inline]
+    pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
+        let _span = tracing::debug_span!("winit::ActiveEventLoop::available_monitors",).entered();
+
+        #[allow(clippy::useless_conversion)] // false positive on some platforms
+        self.p.available_monitors().into_iter().map(|inner| MonitorHandle { inner })
+    }
+
+    /// Returns the primary monitor of the system.
+    ///
+    /// Returns `None` if it can't identify any monitor as a primary one.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Wayland / Web:** Always returns `None`.
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        let _span = tracing::debug_span!("winit::ActiveEventLoop::primary_monitor",).entered();
+
+        self.p.primary_monitor().map(|inner| MonitorHandle { inner })
+    }
+
+    /// Change if or when [`DeviceEvent`]s are captured.
+    ///
+    /// Since the [`DeviceEvent`] capture can lead to high CPU usage for unfocused windows, winit
+    /// will ignore them by default for unfocused windows on Linux/BSD. This method allows changing
+    /// this at runtime to explicitly capture them again.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Wayland / macOS / iOS / Android / Orbital:** Unsupported.
+    ///
+    /// [`DeviceEvent`]: crate::event::DeviceEvent
+    pub fn listen_device_events(&self, allowed: DeviceEvents) {
+        let _span = tracing::debug_span!(
+            "winit::ActiveEventLoop::listen_device_events",
+            allowed = ?allowed
+        )
+        .entered();
+
+        self.p.listen_device_events(allowed);
+    }
+
+    /// Returns the current system theme.
+    ///
+    /// Returns `None` if it cannot be determined on the current platform.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Wayland / x11 / Orbital:** Unsupported.
+    pub fn system_theme(&self) -> Option<Theme> {
+        self.p.system_theme()
+    }
+
+    /// Sets the [`ControlFlow`].
+    pub fn set_control_flow(&self, control_flow: ControlFlow) {
+        self.p.set_control_flow(control_flow)
+    }
+
+    /// Gets the current [`ControlFlow`].
+    pub fn control_flow(&self) -> ControlFlow {
+        self.p.control_flow()
+    }
+
+    /// This exits the event loop.
+    ///
+    /// See [`LoopExiting`][Event::LoopExiting].
+    pub fn exit(&self) {
+        let _span = tracing::debug_span!("winit::ActiveEventLoop::exit",).entered();
+
+        self.p.exit()
+    }
+
+    /// Returns if the [`EventLoop`] is about to stop.
+    ///
+    /// See [`exit()`][Self::exit].
+    pub fn exiting(&self) -> bool {
+        self.p.exiting()
+    }
+
+    /// Gets a persistent reference to the underlying platform display.
+    ///
+    /// See the [`OwnedDisplayHandle`] type for more information.
+    pub fn owned_display_handle(&self) -> OwnedDisplayHandle {
+        OwnedDisplayHandle { platform: self.p.owned_display_handle() }
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for ActiveEventLoop {
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = self.p.raw_display_handle_rwh_06()?;
+        // SAFETY: The display will never be deallocated while the event loop is alive.
+        Ok(unsafe { rwh_06::DisplayHandle::borrow_raw(raw) })
+    }
+}
+
+#[cfg(feature = "rwh_05")]
+unsafe impl rwh_05::HasRawDisplayHandle for ActiveEventLoop {
+    /// Returns a [`rwh_05::RawDisplayHandle`] for the event loop.
+    fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
+        self.p.raw_display_handle_rwh_05()
+    }
+}
+
+/// A proxy for the underlying display handle.
+///
+/// The purpose of this type is to provide a cheaply cloneable handle to the underlying
+/// display handle. This is often used by graphics APIs to connect to the underlying APIs.
+/// It is difficult to keep a handle to the [`EventLoop`] type or the [`ActiveEventLoop`]
+/// type. In contrast, this type involves no lifetimes and can be persisted for as long as
+/// needed.
+///
+/// For all platforms, this is one of the following:
+///
+/// - A zero-sized type that is likely optimized out.
+/// - A reference-counted pointer to the underlying type.
+#[derive(Clone)]
+pub struct OwnedDisplayHandle {
+    #[cfg_attr(not(any(feature = "rwh_05", feature = "rwh_06")), allow(dead_code))]
+    platform: platform_impl::OwnedDisplayHandle,
+}
+
+impl fmt::Debug for OwnedDisplayHandle {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("OwnedDisplayHandle").finish_non_exhaustive()
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
+    #[inline]
+    fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
+        let raw = self.platform.raw_display_handle_rwh_06()?;
+
+        // SAFETY: The underlying display handle should be safe.
+        let handle = unsafe { rwh_06::DisplayHandle::borrow_raw(raw) };
+
+        Ok(handle)
+    }
+}
+
+#[cfg(feature = "rwh_05")]
+unsafe impl rwh_05::HasRawDisplayHandle for OwnedDisplayHandle {
+    #[inline]
+    fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
+        self.platform.raw_display_handle_rwh_05()
+    }
+}
+
+/// Used to send custom events to [`EventLoop`].
+pub struct EventLoopProxy<T: 'static> {
+    event_loop_proxy: platform_impl::EventLoopProxy<T>,
+}
+
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        Self { event_loop_proxy: self.event_loop_proxy.clone() }
+    }
+}
+
+impl<T: 'static> EventLoopProxy<T> {
+    /// Send an event to the [`EventLoop`] from which this proxy was created. This emits a
+    /// `UserEvent(event)` event in the event loop, where `event` is the value passed to this
+    /// function.
+    ///
+    /// Returns an `Err` if the associated [`EventLoop`] no longer exists.
+    ///
+    /// [`UserEvent(event)`]: Event::UserEvent
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        let _span = tracing::debug_span!("winit::EventLoopProxy::send_event",).entered();
+
+        self.event_loop_proxy.send_event(event)
+    }
+}
+
+impl<T: 'static> fmt::Debug for EventLoopProxy<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.pad("EventLoopProxy { .. }")
+    }
+}
+
+/// The error that is returned when an [`EventLoopProxy`] attempts to wake up an [`EventLoop`] that
+/// no longer exists.
+///
+/// Contains the original event given to [`EventLoopProxy::send_event`].
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventLoopClosed<T>(pub T);
+
+impl<T> fmt::Display for EventLoopClosed<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("Tried to wake up a closed `EventLoop`")
+    }
+}
+
+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.
+    Always,
+    /// Only capture device events while the window is focused.
+    #[default]
+    WhenFocused,
+    /// Never capture device events.
+    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 scenarios 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: usize,
+}
+
+impl AsyncRequestSerial {
+    // TODO(kchibisov): Remove `cfg` when the clipboard will be added.
+    #[allow(dead_code)]
+    pub(crate) fn get() -> Self {
+        static CURRENT_SERIAL: AtomicUsize = AtomicUsize::new(0);
+        // NOTE: We rely on wrap around here, while the user may just request
+        // in the loop usize::MAX times that's issue is considered on them.
+        let serial = CURRENT_SERIAL.fetch_add(1, Ordering::Relaxed);
+        Self { serial }
+    }
+}
+
+/// Shim for various run APIs.
+#[inline(always)]
+pub(crate) fn dispatch_event_for_app<T: 'static, A: ApplicationHandler<T>>(
+    app: &mut A,
+    event_loop: &ActiveEventLoop,
+    event: Event<T>,
+) {
+    match event {
+        Event::NewEvents(cause) => app.new_events(event_loop, cause),
+        Event::WindowEvent { window_id, event } => app.window_event(event_loop, window_id, event),
+        Event::DeviceEvent { device_id, event } => app.device_event(event_loop, device_id, event),
+        Event::UserEvent(event) => app.user_event(event_loop, event),
+        Event::Suspended => app.suspended(event_loop),
+        Event::Resumed => app.resumed(event_loop),
+        Event::AboutToWait => app.about_to_wait(event_loop),
+        Event::LoopExiting => app.exiting(event_loop),
+        Event::MemoryWarning => app.memory_warning(event_loop),
+    }
+}

vendor/winit/src/icon.rs

@@ -0,0 +1,117 @@
+use crate::platform_impl::PlatformIcon;
+use std::error::Error;
+use std::{fmt, io, mem};
+
+#[repr(C)]
+#[derive(Debug)]
+pub(crate) struct Pixel {
+    pub(crate) r: u8,
+    pub(crate) g: u8,
+    pub(crate) b: u8,
+    pub(crate) a: u8,
+}
+
+pub(crate) const PIXEL_SIZE: usize = mem::size_of::<Pixel>();
+
+#[derive(Debug)]
+/// An error produced when using [`Icon::from_rgba`] with invalid arguments.
+pub enum BadIcon {
+    /// Produced when the length of the `rgba` argument isn't divisible by 4, thus `rgba` can't be
+    /// safely interpreted as 32bpp RGBA pixels.
+    ByteCountNotDivisibleBy4 { byte_count: usize },
+    /// Produced when the number of pixels (`rgba.len() / 4`) isn't equal to `width * height`.
+    /// At least one of your arguments is incorrect.
+    DimensionsVsPixelCount { width: u32, height: u32, width_x_height: usize, pixel_count: usize },
+    /// Produced when underlying OS functionality failed to create the icon
+    OsError(io::Error),
+}
+
+impl fmt::Display for BadIcon {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BadIcon::ByteCountNotDivisibleBy4 { byte_count } => write!(
+                f,
+                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making \
+                 it impossible to interpret as 32bpp RGBA pixels.",
+            ),
+            BadIcon::DimensionsVsPixelCount { width, height, width_x_height, pixel_count } => {
+                write!(
+                    f,
+                    "The specified dimensions ({width:?}x{height:?}) don't match the number of \
+                     pixels supplied by the `rgba` argument ({pixel_count:?}). For those \
+                     dimensions, the expected pixel count is {width_x_height:?}.",
+                )
+            },
+            BadIcon::OsError(e) => write!(f, "OS error when instantiating the icon: {e:?}"),
+        }
+    }
+}
+
+impl Error for BadIcon {}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct RgbaIcon {
+    pub(crate) rgba: Vec<u8>,
+    pub(crate) width: u32,
+    pub(crate) height: u32,
+}
+
+/// For platforms which don't have window icons (e.g. web)
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct NoIcon;
+
+#[allow(dead_code)] // These are not used on every platform
+mod constructors {
+    use super::*;
+
+    impl RgbaIcon {
+        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+            if rgba.len() % PIXEL_SIZE != 0 {
+                return Err(BadIcon::ByteCountNotDivisibleBy4 { byte_count: rgba.len() });
+            }
+            let pixel_count = rgba.len() / PIXEL_SIZE;
+            if pixel_count != (width * height) as usize {
+                Err(BadIcon::DimensionsVsPixelCount {
+                    width,
+                    height,
+                    width_x_height: (width * height) as usize,
+                    pixel_count,
+                })
+            } else {
+                Ok(RgbaIcon { rgba, width, height })
+            }
+        }
+    }
+
+    impl NoIcon {
+        pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+            // Create the rgba icon anyway to validate the input
+            let _ = RgbaIcon::from_rgba(rgba, width, height)?;
+            Ok(NoIcon)
+        }
+    }
+}
+
+/// An icon used for the window titlebar, taskbar, etc.
+#[derive(Clone)]
+pub struct Icon {
+    pub(crate) inner: PlatformIcon,
+}
+
+impl fmt::Debug for Icon {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        fmt::Debug::fmt(&self.inner, formatter)
+    }
+}
+
+impl Icon {
+    /// Creates an icon from 32bpp RGBA data.
+    ///
+    /// The length of `rgba` must be divisible by 4, and `width * height` must equal
+    /// `rgba.len() / 4`. Otherwise, this will return a `BadIcon` error.
+    pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
+        let _span = tracing::debug_span!("winit::Icon::from_rgba", width, height).entered();
+
+        Ok(Icon { inner: PlatformIcon::from_rgba(rgba, width, height)? })
+    }
+}

vendor/winit/src/lib.rs

@@ -0,0 +1,217 @@
+//! Winit is a cross-platform window creation and event loop management library.
+//!
+//! # Building windows
+//!
+//! Before you can create a [`Window`], you first need to build an [`EventLoop`]. This is done with
+//! the [`EventLoop::new()`] function.
+//!
+//! ```no_run
+//! use winit::event_loop::EventLoop;
+//!
+//! # // Intentionally use `fn main` for clarity
+//! fn main() {
+//!     let event_loop = EventLoop::new().unwrap();
+//!     // ...
+//! }
+//! ```
+//!
+//! Then you create a [`Window`] with [`create_window`].
+//!
+//! # Event handling
+//!
+//! Once a [`Window`] has been created, it will generate different *events*. A [`Window`] object can
+//! generate [`WindowEvent`]s when certain input events occur, such as a cursor moving over the
+//! window or a key getting pressed while the window is focused. Devices can generate
+//! [`DeviceEvent`]s, which contain unfiltered event data that isn't specific to a certain window.
+//! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
+//! [`DeviceEvent`]. You can also create and handle your own custom [`Event::UserEvent`]s, if
+//! desired.
+//!
+//! You can retrieve events by calling [`EventLoop::run_app()`]. This function will
+//! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
+//! will run until [`exit()`] is used, at which point [`Event::LoopExiting`].
+//!
+//! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
+//! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works
+//! poorly on most other platforms. However, this model can be re-implemented to an extent with
+#![cfg_attr(
+    any(windows_platform, macos_platform, android_platform, x11_platform, wayland_platform),
+    doc = "[`EventLoopExtPumpEvents::pump_app_events()`][platform::pump_events::EventLoopExtPumpEvents::pump_app_events()]"
+)]
+#![cfg_attr(
+    not(any(windows_platform, macos_platform, android_platform, x11_platform, wayland_platform)),
+    doc = "`EventLoopExtPumpEvents::pump_app_events()`"
+)]
+//! [^1]. See that method's documentation for more reasons about why
+//! it's discouraged beyond compatibility reasons.
+//!
+//!
+//! ```no_run
+//! use winit::application::ApplicationHandler;
+//! use winit::event::WindowEvent;
+//! use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
+//! use winit::window::{Window, WindowId};
+//!
+//! #[derive(Default)]
+//! struct App {
+//!     window: Option<Window>,
+//! }
+//!
+//! impl ApplicationHandler for App {
+//!     fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+//!         self.window = Some(event_loop.create_window(Window::default_attributes()).unwrap());
+//!     }
+//!
+//!     fn window_event(&mut self, event_loop: &ActiveEventLoop, id: WindowId, event: WindowEvent) {
+//!         match event {
+//!             WindowEvent::CloseRequested => {
+//!                 println!("The close button was pressed; stopping");
+//!                 event_loop.exit();
+//!             },
+//!             WindowEvent::RedrawRequested => {
+//!                 // 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
+//!                 // the program to gracefully handle redraws requested by the OS.
+//!
+//!                 // Draw.
+//!
+//!                 // Queue a RedrawRequested event.
+//!                 //
+//!                 // You only need to call this if you've determined that you need to redraw in
+//!                 // applications which do not always need to. Applications that redraw continuously
+//!                 // can render here instead.
+//!                 self.window.as_ref().unwrap().request_redraw();
+//!             }
+//!             _ => (),
+//!         }
+//!     }
+//! }
+//!
+//! # // Intentionally use `fn main` for clarity
+//! fn main() {
+//!     let event_loop = EventLoop::new().unwrap();
+//!
+//!     // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
+//!     // dispatched any events. This is ideal for games and similar applications.
+//!     event_loop.set_control_flow(ControlFlow::Poll);
+//!
+//!     // ControlFlow::Wait pauses the event loop if no events are available to process.
+//!     // This is ideal for non-game applications that only update in response to user
+//!     // input, and uses significantly less power/CPU time than ControlFlow::Poll.
+//!     event_loop.set_control_flow(ControlFlow::Wait);
+//!
+//!     let mut app = App::default();
+//!     event_loop.run_app(&mut app);
+//! }
+//! ```
+//!
+//! [`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
+//! compared to the value returned by [`Window::id()`] to determine which [`Window`]
+//! dispatched the event.
+//!
+//! # Drawing on the window
+//!
+//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However, it allows you
+//! to retrieve the raw handle of the window and display (see the [`platform`] module and/or the
+//! [`raw_window_handle`] and [`raw_display_handle`] methods), which in turn allows
+//! you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
+//!
+//! Note that many platforms will display garbage data in the window's client area if the
+//! application doesn't render anything to the window by the time the desktop compositor is ready to
+//! display the window to the user. If you notice this happening, you should create the window with
+//! [`visible` set to `false`][crate::window::WindowAttributes::with_visible] and explicitly make
+//! the window visible only once you're ready to render into it.
+//!
+//! # UI scaling
+//!
+//! UI scaling is important, go read the docs for the [`dpi`] crate for an
+//! introduction.
+//!
+//! All of Winit's functions return physical types, but can take either logical or physical
+//! coordinates as input, allowing you to use the most convenient coordinate system for your
+//! particular application.
+//!
+//! Winit will dispatch a [`ScaleFactorChanged`] event whenever a window's scale factor has changed.
+//! This can happen if the user drags their window from a standard-resolution monitor to a high-DPI
+//! monitor or if the user changes their DPI settings. This allows you to rescale your application's
+//! UI elements and adjust how the platform changes the window's size to reflect the new scale
+//! factor. If a window hasn't received a [`ScaleFactorChanged`] event, its scale factor
+//! can be found by calling [`window.scale_factor()`].
+//!
+//! [`ScaleFactorChanged`]: event::WindowEvent::ScaleFactorChanged
+//! [`window.scale_factor()`]: window::Window::scale_factor
+//!
+//! # Cargo Features
+//!
+//! Winit provides the following Cargo features:
+//!
+//! * `x11` (enabled by default): On Unix platforms, enables the X11 backend.
+//! * `wayland` (enabled by default): On Unix platforms, enables the Wayland backend.
+//! * `rwh_04`: Implement `raw-window-handle v0.4` traits.
+//! * `rwh_05`: Implement `raw-window-handle v0.5` traits.
+//! * `rwh_06`: Implement `raw-window-handle v0.6` traits.
+//! * `serde`: Enables serialization/deserialization of certain types with [Serde](https://crates.io/crates/serde).
+//! * `mint`: Enables mint (math interoperability standard types) conversions.
+//!
+//! See the [`platform`] module for documentation on platform-specific cargo
+//! features.
+//!
+//! [`EventLoop`]: event_loop::EventLoop
+//! [`EventLoop::new()`]: event_loop::EventLoop::new
+//! [`EventLoop::run_app()`]: event_loop::EventLoop::run_app
+//! [`exit()`]: event_loop::ActiveEventLoop::exit
+//! [`Window`]: window::Window
+//! [`WindowId`]: window::WindowId
+//! [`WindowAttributes`]: window::WindowAttributes
+//! [`create_window`]: event_loop::ActiveEventLoop::create_window
+//! [`Window::id()`]: window::Window::id
+//! [`WindowEvent`]: event::WindowEvent
+//! [`DeviceEvent`]: event::DeviceEvent
+//! [`Event::UserEvent`]: event::Event::UserEvent
+//! [`Event::LoopExiting`]: event::Event::LoopExiting
+//! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
+//! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
+//! [^1]: `EventLoopExtPumpEvents::pump_app_events()` is only available on Windows, macOS, Android, X11 and Wayland.
+
+#![deny(rust_2018_idioms)]
+#![deny(rustdoc::broken_intra_doc_links)]
+#![deny(clippy::all)]
+#![deny(unsafe_op_in_unsafe_fn)]
+#![cfg_attr(clippy, deny(warnings))]
+// Doc feature labels can be tested locally by running RUSTDOCFLAGS="--cfg=docsrs" cargo +nightly
+// doc
+#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
+#![allow(clippy::missing_safety_doc)]
+#![warn(clippy::uninlined_format_args)]
+// TODO: wasm-binding needs to be updated for that to be resolved, for now just silence it.
+#![cfg_attr(web_platform, allow(unknown_lints, renamed_and_removed_lints, wasm_c_abi))]
+
+#[cfg(feature = "rwh_04")]
+pub use rwh_04 as raw_window_handle_04;
+#[cfg(feature = "rwh_05")]
+pub use rwh_05 as raw_window_handle_05;
+#[cfg(feature = "rwh_06")]
+pub use rwh_06 as raw_window_handle;
+
+// Re-export DPI types so that users don't have to put it in Cargo.toml.
+#[doc(inline)]
+pub use dpi;
+
+pub mod application;
+#[cfg(any(doc, doctest, test))]
+pub mod changelog;
+#[macro_use]
+pub mod error;
+mod cursor;
+pub mod event;
+pub mod event_loop;
+mod icon;
+pub mod keyboard;
+pub mod monitor;
+mod platform_impl;
+mod utils;
+pub mod window;
+
+pub mod platform;

vendor/winit/src/monitor.rs

@@ -0,0 +1,167 @@
+//! Types useful for interacting with a user's monitors.
+//!
+//! If you want to get basic information about a monitor, you can use the
+//! [`MonitorHandle`] type. This is retrieved from one of the following
+//! methods, which return an iterator of [`MonitorHandle`]:
+//! - [`ActiveEventLoop::available_monitors`][crate::event_loop::ActiveEventLoop::available_monitors].
+//! - [`Window::available_monitors`][crate::window::Window::available_monitors].
+use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::platform_impl;
+
+/// Deprecated! Use `VideoModeHandle` instead.
+#[deprecated = "Renamed to `VideoModeHandle`"]
+pub type VideoMode = VideoModeHandle;
+
+/// Describes a fullscreen video mode of a monitor.
+///
+/// Can be acquired with [`MonitorHandle::video_modes`].
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct VideoModeHandle {
+    pub(crate) video_mode: platform_impl::VideoModeHandle,
+}
+
+impl std::fmt::Debug for VideoModeHandle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.video_mode.fmt(f)
+    }
+}
+
+impl PartialOrd for VideoModeHandle {
+    fn partial_cmp(&self, other: &VideoModeHandle) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for VideoModeHandle {
+    fn cmp(&self, other: &VideoModeHandle) -> std::cmp::Ordering {
+        self.monitor().cmp(&other.monitor()).then(
+            self.size()
+                .cmp(&other.size())
+                .then(
+                    self.refresh_rate_millihertz()
+                        .cmp(&other.refresh_rate_millihertz())
+                        .then(self.bit_depth().cmp(&other.bit_depth())),
+                )
+                .reverse(),
+        )
+    }
+}
+
+impl VideoModeHandle {
+    /// Returns the resolution of this video mode.
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.video_mode.size()
+    }
+
+    /// Returns the bit depth of this video mode, as in how many bits you have
+    /// available per color. This is generally 24 bits or 32 bits on modern
+    /// systems, depending on whether the alpha channel is counted or not.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Wayland / Orbital:** Always returns 32.
+    /// - **iOS:** Always returns 32.
+    #[inline]
+    pub fn bit_depth(&self) -> u16 {
+        self.video_mode.bit_depth()
+    }
+
+    /// Returns the refresh rate of this video mode in mHz.
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.video_mode.refresh_rate_millihertz()
+    }
+
+    /// Returns the monitor that this video mode is valid for. Each monitor has
+    /// a separate set of valid video modes.
+    #[inline]
+    pub fn monitor(&self) -> MonitorHandle {
+        MonitorHandle { inner: self.video_mode.monitor() }
+    }
+}
+
+impl std::fmt::Display for VideoModeHandle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}x{} @ {} mHz ({} bpp)",
+            self.size().width,
+            self.size().height,
+            self.refresh_rate_millihertz(),
+            self.bit_depth()
+        )
+    }
+}
+
+/// Handle to a monitor.
+///
+/// Allows you to retrieve information about a given monitor and can be used in [`Window`] creation.
+///
+/// [`Window`]: crate::window::Window
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct MonitorHandle {
+    pub(crate) inner: platform_impl::MonitorHandle,
+}
+
+impl MonitorHandle {
+    /// Returns a human-readable name of the monitor.
+    ///
+    /// Returns `None` if the monitor doesn't exist anymore.
+    #[inline]
+    pub fn name(&self) -> Option<String> {
+        self.inner.name()
+    }
+
+    /// Returns the monitor's resolution.
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.inner.size()
+    }
+
+    /// Returns the top-left corner position of the monitor relative to the larger full
+    /// screen area.
+    #[inline]
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        self.inner.position()
+    }
+
+    /// The monitor refresh rate used by the system.
+    ///
+    /// Return `Some` if succeed, or `None` if failed, which usually happens when the monitor
+    /// the window is on is removed.
+    ///
+    /// When using exclusive fullscreen, the refresh rate of the [`VideoModeHandle`] that was
+    /// used to enter fullscreen should be used instead.
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        self.inner.refresh_rate_millihertz()
+    }
+
+    /// Returns the scale factor of the underlying monitor. To map logical pixels to physical
+    /// pixels and vice versa, use [`Window::scale_factor`].
+    ///
+    /// See the [`dpi`] module for more information.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
+    /// - **Wayland:** May differ from [`Window::scale_factor`].
+    /// - **Android:** Always returns 1.0.
+    ///
+    /// [`Window::scale_factor`]: crate::window::Window::scale_factor
+    #[inline]
+    pub fn scale_factor(&self) -> f64 {
+        self.inner.scale_factor()
+    }
+
+    /// Returns all fullscreen video modes supported by this monitor.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web:** Always returns an empty iterator
+    #[inline]
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
+        self.inner.video_modes().map(|video_mode| VideoModeHandle { video_mode })
+    }
+}

vendor/winit/src/platform/android.rs

@@ -0,0 +1,188 @@
+//! # Android
+//!
+//! The Android backend builds on (and exposes types from) the [`ndk`](https://docs.rs/ndk/) crate.
+//!
+//! Native Android applications need some form of "glue" crate that is responsible
+//! for defining the main entry point for your Rust application as well as tracking
+//! various life-cycle events and synchronizing with the main JVM thread.
+//!
+//! Winit uses the [android-activity](https://docs.rs/android-activity/) as a
+//! glue crate (prior to `0.28` it used
+//! [ndk-glue](https://github.com/rust-windowing/android-ndk-rs/tree/master/ndk-glue)).
+//!
+//! The version of the glue crate that your application depends on _must_ match the
+//! version that Winit depends on because the glue crate is responsible for your
+//! application's main entry point. If Cargo resolves multiple versions, they will
+//! clash.
+//!
+//! `winit` glue compatibility table:
+//!
+//! | winit |       ndk-glue               |
+//! | :---: | :--------------------------: |
+//! | 0.30  | `android-activity = "0.6"`   |
+//! | 0.29  | `android-activity = "0.5"`   |
+//! | 0.28  | `android-activity = "0.4"`   |
+//! | 0.27  | `ndk-glue = "0.7"`           |
+//! | 0.26  | `ndk-glue = "0.5"`           |
+//! | 0.25  | `ndk-glue = "0.3"`           |
+//! | 0.24  | `ndk-glue = "0.2"`           |
+//!
+//! The recommended way to avoid a conflict with the glue version is to avoid explicitly
+//! depending on the `android-activity` crate, and instead consume the API that
+//! is re-exported by Winit under `winit::platform::android::activity::*`
+//!
+//! Running on an Android device needs a dynamic system library. Add this to Cargo.toml:
+//!
+//! ```toml
+//! [lib]
+//! name = "main"
+//! crate-type = ["cdylib"]
+//! ```
+//!
+//! All Android applications are based on an `Activity` subclass, and the
+//! `android-activity` crate is designed to support different choices for this base
+//! class. Your application _must_ specify the base class it needs via a feature flag:
+//!
+//! | Base Class       | Feature Flag      |  Notes  |
+//! | :--------------: | :---------------: | :-----: |
+//! | `NativeActivity` | `android-native-activity` | Built-in to Android - it is possible to use without compiling any Java or Kotlin code. Java or Kotlin code may be needed to subclass `NativeActivity` to access some platform features. It does not derive from the [`AndroidAppCompat`] base class.|
+//! | [`GameActivity`] | `android-game-activity`   | Derives from [`AndroidAppCompat`], a defacto standard `Activity` base class that helps support a wider range of Android versions. Requires a build system that can compile Java or Kotlin and fetch Android dependencies from a [Maven repository][agdk_jetpack] (or link with an embedded [release][agdk_releases] of [`GameActivity`]) |
+//!
+//! [`GameActivity`]: https://developer.android.com/games/agdk/game-activity
+//! [`GameTextInput`]: https://developer.android.com/games/agdk/add-support-for-text-input
+//! [`AndroidAppCompat`]: https://developer.android.com/reference/androidx/appcompat/app/AppCompatActivity
+//! [agdk_jetpack]: https://developer.android.com/jetpack/androidx/releases/games
+//! [agdk_releases]: https://developer.android.com/games/agdk/download#agdk-libraries
+//! [Gradle]: https://developer.android.com/studio/build
+//!
+//! For more details, refer to these `android-activity` [example applications](https://github.com/rust-mobile/android-activity/tree/main/examples).
+//!
+//! ## Converting from `ndk-glue` to `android-activity`
+//!
+//! If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building
+//! with `cargo apk`, then the minimal changes would be:
+//! 1. Remove `ndk-glue` from your `Cargo.toml`
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.12",
+//!    features = [ "android-native-activity" ] }`
+//! 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc
+//!    macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize
+//!    logging as above).
+//! 4. Pass a clone of the `AndroidApp` that your application receives to Winit when building your
+//!    event loop (as shown above).
+
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
+use crate::window::{Window, WindowAttributes};
+
+use self::activity::{AndroidApp, ConfigurationRef, Rect};
+
+/// Additional methods on [`EventLoop`] that are specific to Android.
+pub trait EventLoopExtAndroid {
+    /// Get the [`AndroidApp`] which was used to create this event loop.
+    fn android_app(&self) -> &AndroidApp;
+}
+
+impl<T> EventLoopExtAndroid for EventLoop<T> {
+    fn android_app(&self) -> &AndroidApp {
+        &self.event_loop.android_app
+    }
+}
+
+/// Additional methods on [`ActiveEventLoop`] that are specific to Android.
+pub trait ActiveEventLoopExtAndroid {
+    /// Get the [`AndroidApp`] which was used to create this event loop.
+    fn android_app(&self) -> &AndroidApp;
+}
+
+/// Additional methods on [`Window`] that are specific to Android.
+pub trait WindowExtAndroid {
+    fn content_rect(&self) -> Rect;
+
+    fn config(&self) -> ConfigurationRef;
+}
+
+impl WindowExtAndroid for Window {
+    fn content_rect(&self) -> Rect {
+        self.window.content_rect()
+    }
+
+    fn config(&self) -> ConfigurationRef {
+        self.window.config()
+    }
+}
+
+impl ActiveEventLoopExtAndroid for ActiveEventLoop {
+    fn android_app(&self) -> &AndroidApp {
+        &self.p.app
+    }
+}
+
+/// Additional methods on [`WindowAttributes`] that are specific to Android.
+pub trait WindowAttributesExtAndroid {}
+
+impl WindowAttributesExtAndroid for WindowAttributes {}
+
+pub trait EventLoopBuilderExtAndroid {
+    /// Associates the [`AndroidApp`] that was passed to `android_main()` with the event loop
+    ///
+    /// 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> {
+    fn with_android_app(&mut self, app: AndroidApp) -> &mut Self {
+        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
+///
+/// Winit re-exports the `android_activity` API for convenience so that most
+/// applications can rely on the Winit crate to resolve the required version of
+/// `android_activity` and avoid any chance of a conflict between Winit and the
+/// application crate.
+///
+/// Unlike most libraries there can only be a single implementation
+/// of the `android_activity` glue crate linked with an application because
+/// it is responsible for the application's `android_main()` entry point.
+///
+/// Since Winit depends on a specific version of `android_activity` the simplest
+/// way to avoid creating a conflict is for applications to avoid explicitly
+/// depending on the `android_activity` crate, and instead consume the API that
+/// is re-exported by Winit.
+///
+/// For compatibility applications should then import the [`AndroidApp`] type for
+/// their `android_main(app: AndroidApp)` function like:
+/// ```rust
+/// #[cfg(target_os = "android")]
+/// use winit::platform::android::activity::AndroidApp;
+/// ```
+pub mod activity {
+    // We enable the `"native-activity"` feature just so that we can build the
+    // docs, but it'll be very confusing for users to see the docs with that
+    // feature enabled, so we avoid inlining it so that they're forced to view
+    // it on the crate's own docs.rs page.
+    #[doc(no_inline)]
+    #[cfg(android_platform)]
+    pub use android_activity::*;
+
+    #[cfg(not(android_platform))]
+    #[doc(hidden)]
+    pub struct Rect;
+    #[cfg(not(android_platform))]
+    #[doc(hidden)]
+    pub struct ConfigurationRef;
+    #[cfg(not(android_platform))]
+    #[doc(hidden)]
+    pub struct AndroidApp;
+}

vendor/winit/src/platform/ios.rs

@@ -0,0 +1,435 @@
+//! # iOS / UIKit
+//!
+//! Winit has an OS requirement of iOS 8 or higher, and is regularly tested on
+//! iOS 9.3.
+//!
+//! ## Window initialization
+//!
+//! iOS's main `UIApplicationMain` does some init work that's required by all
+//! UI-related code (see issue [#1705]). It is best to create your windows
+//! inside [`ApplicationHandler::resumed`].
+//!
+//! [#1705]: https://github.com/rust-windowing/winit/issues/1705
+//! [`ApplicationHandler::resumed`]: crate::application::ApplicationHandler::resumed
+//!
+//! ## Building app
+//!
+//! To build ios app you will need rustc built for this targets:
+//!
+//!  - armv7-apple-ios
+//!  - armv7s-apple-ios
+//!  - i386-apple-ios
+//!  - aarch64-apple-ios
+//!  - x86_64-apple-ios
+//!
+//! Then
+//!
+//! ```
+//! cargo build --target=...
+//! ```
+//! The simplest way to integrate your app into xcode environment is to build it
+//! as a static library. Wrap your main function and export it.
+//!
+//! ```rust, ignore
+//! #[no_mangle]
+//! pub extern fn start_winit_app() {
+//!     start_inner()
+//! }
+//!
+//! fn start_inner() {
+//!    ...
+//! }
+//! ```
+//!
+//! Compile project and then drag resulting .a into Xcode project. Add winit.h to xcode.
+//!
+//! ```ignore
+//! void start_winit_app();
+//! ```
+//!
+//! Use start_winit_app inside your xcode's main function.
+//!
+//!
+//! ## App lifecycle and events
+//!
+//! iOS environment is very different from other platforms and you must be very
+//! careful with it's events. Familiarize yourself with
+//! [app lifecycle](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UIApplicationDelegate_Protocol/).
+//!
+//! This is how those event are represented in winit:
+//!
+//!  - applicationDidBecomeActive is Resumed
+//!  - applicationWillResignActive is Suspended
+//!  - applicationWillTerminate is LoopExiting
+//!
+//! Keep in mind that after LoopExiting 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.
+//!
+//! ## Custom `UIApplicationDelegate`
+//!
+//! Winit usually handles everything related to the lifecycle events of the application. Sometimes,
+//! though, you might want to access some of the more niche stuff that [the application
+//! delegate][app-delegate] provides. This functionality is not exposed directly in Winit, since it
+//! would increase the API surface by quite a lot. Instead, Winit guarantees that it will not
+//! register an application delegate, so you can set up a custom one in a nib file instead.
+//!
+//! [app-delegate]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate?language=objc
+
+use std::os::raw::c_void;
+
+use crate::event_loop::EventLoop;
+use crate::monitor::{MonitorHandle, VideoModeHandle};
+use crate::window::{Window, WindowAttributes};
+
+/// Additional methods on [`EventLoop`] that are specific to iOS.
+pub trait EventLoopExtIOS {
+    /// Returns the [`Idiom`] (phone/tablet/tv/etc) for the current device.
+    fn idiom(&self) -> Idiom;
+}
+
+impl<T: 'static> EventLoopExtIOS for EventLoop<T> {
+    fn idiom(&self) -> Idiom {
+        self.event_loop.idiom()
+    }
+}
+
+/// Additional methods on [`Window`] that are specific to iOS.
+pub trait WindowExtIOS {
+    /// 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
+    /// this to [`MonitorHandle::scale_factor()`].
+    ///
+    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
+    /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
+    fn set_scale_factor(&self, scale_factor: f64);
+
+    /// Sets the valid orientations for the [`Window`].
+    ///
+    /// The default value is [`ValidOrientations::LandscapeAndPortrait`].
+    ///
+    /// This changes the value returned by
+    /// [`-[UIViewController supportedInterfaceOrientations]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations?language=objc),
+    /// and then calls
+    /// [`-[UIViewController attemptRotationToDeviceOrientation]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621400-attemptrotationtodeviceorientati?language=objc).
+    fn set_valid_orientations(&self, valid_orientations: ValidOrientations);
+
+    /// Sets whether the [`Window`] prefers the home indicator hidden.
+    ///
+    /// The default is to prefer showing the home indicator.
+    ///
+    /// This changes the value returned by
+    /// [`-[UIViewController prefersHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887510-prefershomeindicatorautohidden?language=objc),
+    /// and then calls
+    /// [`-[UIViewController setNeedsUpdateOfHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887509-setneedsupdateofhomeindicatoraut?language=objc).
+    ///
+    /// This only has an effect on iOS 11.0+.
+    fn set_prefers_home_indicator_hidden(&self, hidden: bool);
+
+    /// Sets the screen edges for which the system gestures will take a lower priority than the
+    /// application's touch handling.
+    ///
+    /// This changes the value returned by
+    /// [`-[UIViewController preferredScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887512-preferredscreenedgesdeferringsys?language=objc),
+    /// and then calls
+    /// [`-[UIViewController setNeedsUpdateOfScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887507-setneedsupdateofscreenedgesdefer?language=objc).
+    ///
+    /// This only has an effect on iOS 11.0+.
+    fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge);
+
+    /// Sets whether the [`Window`] prefers the status bar hidden.
+    ///
+    /// The default is to prefer showing the status bar.
+    ///
+    /// This sets the value of the
+    /// [`prefersStatusBarHidden`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc)
+    /// property.
+    ///
+    /// [`setNeedsStatusBarAppearanceUpdate()`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621354-setneedsstatusbarappearanceupdat?language=objc)
+    /// is also called for you.
+    fn set_prefers_status_bar_hidden(&self, hidden: bool);
+
+    /// Sets the preferred status bar style for the [`Window`].
+    ///
+    /// The default is system-defined.
+    ///
+    /// This sets the value of the
+    /// [`preferredStatusBarStyle`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621416-preferredstatusbarstyle?language=objc)
+    /// property.
+    ///
+    /// [`setNeedsStatusBarAppearanceUpdate()`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621354-setneedsstatusbarappearanceupdat?language=objc)
+    /// is also called for you.
+    fn set_preferred_status_bar_style(&self, status_bar_style: StatusBarStyle);
+
+    /// Sets whether the [`Window`] should recognize pinch gestures.
+    ///
+    /// The default is to not recognize gestures.
+    fn recognize_pinch_gesture(&self, should_recognize: bool);
+
+    /// Sets whether the [`Window`] should recognize pan gestures.
+    ///
+    /// The default is to not recognize gestures.
+    /// Installs [`UIPanGestureRecognizer`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer) onto view
+    ///
+    /// Set the minimum number of touches required: [`minimumNumberOfTouches`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer/1621208-minimumnumberoftouches)
+    ///
+    /// Set the maximum number of touches recognized: [`maximumNumberOfTouches`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer/1621208-maximumnumberoftouches)
+    fn recognize_pan_gesture(
+        &self,
+        should_recognize: bool,
+        minimum_number_of_touches: u8,
+        maximum_number_of_touches: u8,
+    );
+
+    /// Sets whether the [`Window`] should recognize double tap gestures.
+    ///
+    /// The default is to not recognize gestures.
+    fn recognize_doubletap_gesture(&self, should_recognize: bool);
+
+    /// Sets whether the [`Window`] should recognize rotation gestures.
+    ///
+    /// The default is to not recognize gestures.
+    fn recognize_rotation_gesture(&self, should_recognize: bool);
+}
+
+impl WindowExtIOS for Window {
+    #[inline]
+    fn set_scale_factor(&self, scale_factor: f64) {
+        self.window.maybe_queue_on_main(move |w| w.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))
+    }
+
+    #[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))
+    }
+
+    #[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)
+        })
+    }
+
+    #[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))
+    }
+
+    #[inline]
+    fn set_preferred_status_bar_style(&self, status_bar_style: StatusBarStyle) {
+        self.window.maybe_queue_on_main(move |w| w.set_preferred_status_bar_style(status_bar_style))
+    }
+
+    #[inline]
+    fn recognize_pinch_gesture(&self, should_recognize: bool) {
+        self.window.maybe_queue_on_main(move |w| w.recognize_pinch_gesture(should_recognize));
+    }
+
+    #[inline]
+    fn recognize_pan_gesture(
+        &self,
+        should_recognize: bool,
+        minimum_number_of_touches: u8,
+        maximum_number_of_touches: u8,
+    ) {
+        self.window.maybe_queue_on_main(move |w| {
+            w.recognize_pan_gesture(
+                should_recognize,
+                minimum_number_of_touches,
+                maximum_number_of_touches,
+            )
+        });
+    }
+
+    #[inline]
+    fn recognize_doubletap_gesture(&self, should_recognize: bool) {
+        self.window.maybe_queue_on_main(move |w| w.recognize_doubletap_gesture(should_recognize));
+    }
+
+    #[inline]
+    fn recognize_rotation_gesture(&self, should_recognize: bool) {
+        self.window.maybe_queue_on_main(move |w| w.recognize_rotation_gesture(should_recognize));
+    }
+}
+
+/// Additional methods on [`WindowAttributes`] that are specific to iOS.
+pub trait WindowAttributesExtIOS {
+    /// 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
+    /// this to [`MonitorHandle::scale_factor()`].
+    ///
+    /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
+    /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
+    fn with_scale_factor(self, scale_factor: f64) -> Self;
+
+    /// Sets the valid orientations for the [`Window`].
+    ///
+    /// The default value is [`ValidOrientations::LandscapeAndPortrait`].
+    ///
+    /// This sets the initial value returned by
+    /// [`-[UIViewController supportedInterfaceOrientations]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621435-supportedinterfaceorientations?language=objc).
+    fn with_valid_orientations(self, valid_orientations: ValidOrientations) -> Self;
+
+    /// Sets whether the [`Window`] prefers the home indicator hidden.
+    ///
+    /// The default is to prefer showing the home indicator.
+    ///
+    /// This sets the initial value returned by
+    /// [`-[UIViewController prefersHomeIndicatorAutoHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887510-prefershomeindicatorautohidden?language=objc).
+    ///
+    /// This only has an effect on iOS 11.0+.
+    fn with_prefers_home_indicator_hidden(self, hidden: bool) -> Self;
+
+    /// Sets the screen edges for which the system gestures will take a lower priority than the
+    /// application's touch handling.
+    ///
+    /// This sets the initial value returned by
+    /// [`-[UIViewController preferredScreenEdgesDeferringSystemGestures]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/2887512-preferredscreenedgesdeferringsys?language=objc).
+    ///
+    /// This only has an effect on iOS 11.0+.
+    fn with_preferred_screen_edges_deferring_system_gestures(self, edges: ScreenEdge) -> Self;
+
+    /// Sets whether the [`Window`] prefers the status bar hidden.
+    ///
+    /// The default is to prefer showing the status bar.
+    ///
+    /// This sets the initial value returned by
+    /// [`-[UIViewController prefersStatusBarHidden]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621440-prefersstatusbarhidden?language=objc).
+    fn with_prefers_status_bar_hidden(self, hidden: bool) -> Self;
+
+    /// Sets the style of the [`Window`]'s status bar.
+    ///
+    /// The default is system-defined.
+    ///
+    /// This sets the initial value returned by
+    /// [`-[UIViewController preferredStatusBarStyle]`](https://developer.apple.com/documentation/uikit/uiviewcontroller/1621416-preferredstatusbarstyle?language=objc),
+    fn with_preferred_status_bar_style(self, status_bar_style: StatusBarStyle) -> Self;
+}
+
+impl WindowAttributesExtIOS for WindowAttributes {
+    #[inline]
+    fn with_scale_factor(mut self, scale_factor: f64) -> Self {
+        self.platform_specific.scale_factor = Some(scale_factor);
+        self
+    }
+
+    #[inline]
+    fn with_valid_orientations(mut self, valid_orientations: ValidOrientations) -> Self {
+        self.platform_specific.valid_orientations = valid_orientations;
+        self
+    }
+
+    #[inline]
+    fn with_prefers_home_indicator_hidden(mut self, hidden: bool) -> Self {
+        self.platform_specific.prefers_home_indicator_hidden = hidden;
+        self
+    }
+
+    #[inline]
+    fn with_preferred_screen_edges_deferring_system_gestures(mut self, edges: ScreenEdge) -> Self {
+        self.platform_specific.preferred_screen_edges_deferring_system_gestures = edges;
+        self
+    }
+
+    #[inline]
+    fn with_prefers_status_bar_hidden(mut self, hidden: bool) -> Self {
+        self.platform_specific.prefers_status_bar_hidden = hidden;
+        self
+    }
+
+    #[inline]
+    fn with_preferred_status_bar_style(mut self, status_bar_style: StatusBarStyle) -> Self {
+        self.platform_specific.preferred_status_bar_style = status_bar_style;
+        self
+    }
+}
+
+/// Additional methods on [`MonitorHandle`] that are specific to iOS.
+pub trait MonitorHandleExtIOS {
+    /// Returns a pointer to the [`UIScreen`] that is used by this monitor.
+    ///
+    /// [`UIScreen`]: https://developer.apple.com/documentation/uikit/uiscreen?language=objc
+    fn ui_screen(&self) -> *mut c_void;
+
+    /// Returns the preferred [`VideoModeHandle`] for this monitor.
+    ///
+    /// This translates to a call to [`-[UIScreen preferredMode]`](https://developer.apple.com/documentation/uikit/uiscreen/1617823-preferredmode?language=objc).
+    fn preferred_video_mode(&self) -> VideoModeHandle;
+}
+
+impl MonitorHandleExtIOS for MonitorHandle {
+    #[inline]
+    fn ui_screen(&self) -> *mut c_void {
+        // SAFETY: The marker is only used to get the pointer of the screen
+        let mtm = unsafe { objc2_foundation::MainThreadMarker::new_unchecked() };
+        objc2::rc::Retained::as_ptr(self.inner.ui_screen(mtm)) as *mut c_void
+    }
+
+    #[inline]
+    fn preferred_video_mode(&self) -> VideoModeHandle {
+        VideoModeHandle { video_mode: self.inner.preferred_video_mode() }
+    }
+}
+
+/// Valid orientations for a particular [`Window`].
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ValidOrientations {
+    /// Excludes `PortraitUpsideDown` on iphone
+    #[default]
+    LandscapeAndPortrait,
+
+    Landscape,
+
+    /// Excludes `PortraitUpsideDown` on iphone
+    Portrait,
+}
+
+/// The device [idiom].
+///
+/// [idiom]: https://developer.apple.com/documentation/uikit/uidevice/1620037-userinterfaceidiom?language=objc
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Idiom {
+    Unspecified,
+
+    /// iPhone and iPod touch.
+    Phone,
+
+    /// iPad.
+    Pad,
+
+    /// tvOS and Apple TV.
+    TV,
+    CarPlay,
+}
+
+bitflags::bitflags! {
+    /// The [edges] of a screen.
+    ///
+    /// [edges]: https://developer.apple.com/documentation/uikit/uirectedge?language=objc
+    #[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+    pub struct ScreenEdge: u8 {
+        const NONE   = 0;
+        const TOP    = 1 << 0;
+        const LEFT   = 1 << 1;
+        const BOTTOM = 1 << 2;
+        const RIGHT  = 1 << 3;
+        const ALL = ScreenEdge::TOP.bits() | ScreenEdge::LEFT.bits()
+            | ScreenEdge::BOTTOM.bits() | ScreenEdge::RIGHT.bits();
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum StatusBarStyle {
+    #[default]
+    Default,
+    LightContent,
+    DarkContent,
+}

vendor/winit/src/platform/macos.rs

@@ -0,0 +1,531 @@
+//! # macOS / AppKit
+//!
+//! Winit has an OS requirement of macOS 10.11 or higher (same as Rust
+//! itself), and is regularly tested on macOS 10.14.
+//!
+//! ## Window initialization
+//!
+//! A lot of functionality expects the application to be ready before you
+//! start doing anything; this includes creating windows, fetching monitors,
+//! drawing, and so on, see issues [#2238], [#2051] and [#2087].
+//!
+//! If you encounter problems, you should try doing your initialization inside
+//! [`ApplicationHandler::resumed`].
+//!
+//! [#2238]: https://github.com/rust-windowing/winit/issues/2238
+//! [#2051]: https://github.com/rust-windowing/winit/issues/2051
+//! [#2087]: https://github.com/rust-windowing/winit/issues/2087
+//! [`ApplicationHandler::resumed`]: crate::application::ApplicationHandler::resumed
+//!
+//! ## Custom `NSApplicationDelegate`
+//!
+//! Winit usually handles everything related to the lifecycle events of the application. Sometimes,
+//! though, you might want to do more niche stuff, such as [handle when the user re-activates the
+//! application][reopen]. Such functionality is not exposed directly in Winit, since it would
+//! increase the API surface by quite a lot.
+//!
+//! [reopen]: https://developer.apple.com/documentation/appkit/nsapplicationdelegate/1428638-applicationshouldhandlereopen?language=objc
+//!
+//! Instead, Winit guarantees that it will not register an application delegate, so the solution is
+//! to register your own application delegate, as outlined in the following example (see
+//! `objc2-app-kit` for more detailed information).
+#![cfg_attr(target_os = "macos", doc = "```")]
+#![cfg_attr(not(target_os = "macos"), doc = "```ignore")]
+//! use objc2::rc::Retained;
+//! use objc2::runtime::ProtocolObject;
+//! use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
+//! use objc2_app_kit::{NSApplication, NSApplicationDelegate};
+//! use objc2_foundation::{NSArray, NSURL, MainThreadMarker, NSObject, NSObjectProtocol};
+//! use winit::event_loop::EventLoop;
+//!
+//! declare_class!(
+//!     struct AppDelegate;
+//!
+//!     unsafe impl ClassType for AppDelegate {
+//!         type Super = NSObject;
+//!         type Mutability = mutability::MainThreadOnly;
+//!         const NAME: &'static str = "MyAppDelegate";
+//!     }
+//!
+//!     impl DeclaredClass for AppDelegate {}
+//!
+//!     unsafe impl NSObjectProtocol for AppDelegate {}
+//!
+//!     unsafe impl NSApplicationDelegate for AppDelegate {
+//!         #[method(application:openURLs:)]
+//!         fn application_openURLs(&self, application: &NSApplication, urls: &NSArray<NSURL>) {
+//!             // Note: To specifically get `application:openURLs:` to work, you _might_
+//!             // have to bundle your application. This is not done in this example.
+//!             println!("open urls: {application:?}, {urls:?}");
+//!         }
+//!     }
+//! );
+//!
+//! impl AppDelegate {
+//!     fn new(mtm: MainThreadMarker) -> Retained<Self> {
+//!         unsafe { msg_send_id![super(mtm.alloc().set_ivars(())), init] }
+//!     }
+//! }
+//!
+//! fn main() -> Result<(), Box<dyn std::error::Error>> {
+//!     let event_loop = EventLoop::new()?;
+//!
+//!     let mtm = MainThreadMarker::new().unwrap();
+//!     let delegate = AppDelegate::new(mtm);
+//!     // Important: Call `sharedApplication` after `EventLoop::new`,
+//!     // doing it before is not yet supported.
+//!     let app = NSApplication::sharedApplication(mtm);
+//!     app.setDelegate(Some(ProtocolObject::from_ref(&*delegate)));
+//!
+//!     // event_loop.run_app(&mut my_app);
+//!     Ok(())
+//! }
+//! ```
+
+use std::os::raw::c_void;
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use crate::event_loop::{ActiveEventLoop, EventLoopBuilder};
+use crate::monitor::MonitorHandle;
+use crate::window::{Window, WindowAttributes};
+
+/// Additional methods on [`Window`] that are specific to MacOS.
+pub trait WindowExtMacOS {
+    /// Returns whether or not the window is in simple fullscreen mode.
+    fn simple_fullscreen(&self) -> bool;
+
+    /// Toggles a fullscreen mode that doesn't require a new macOS space.
+    /// Returns a boolean indicating whether the transition was successful (this
+    /// won't work if the window was already in the native fullscreen).
+    ///
+    /// This is how fullscreen used to work on macOS in versions before Lion.
+    /// And allows the user to have a fullscreen window without using another
+    /// space or taking control over the entire monitor.
+    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool;
+
+    /// Returns whether or not the window has shadow.
+    fn has_shadow(&self) -> bool;
+
+    /// 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
+    ///
+    /// ```ignore
+    /// WindowEvent::CloseRequested => {
+    ///     if window.is_document_edited() {
+    ///         // Show the user a save pop-up or similar
+    ///     } else {
+    ///         // Close the window
+    ///         drop(window);
+    ///     }
+    /// }
+    /// ```
+    fn is_document_edited(&self) -> bool;
+
+    /// Put the window in a state which indicates a file save is required.
+    fn set_document_edited(&self, edited: bool);
+
+    /// Set option as alt behavior as described in [`OptionAsAlt`].
+    ///
+    /// This will ignore diacritical marks and accent characters from
+    /// being processed as received characters. Instead, the input
+    /// device's raw character will be placed in event queues with the
+    /// Alt modifier set.
+    fn set_option_as_alt(&self, option_as_alt: OptionAsAlt);
+
+    /// Getter for the [`WindowExtMacOS::set_option_as_alt`].
+    fn option_as_alt(&self) -> OptionAsAlt;
+
+    /// Disable the Menu Bar and Dock in Simple or Borderless Fullscreen mode. Useful for games.
+    /// The effect is applied when [`WindowExtMacOS::set_simple_fullscreen`] or
+    /// [`Window::set_fullscreen`] is called.
+    fn set_borderless_game(&self, borderless_game: bool);
+
+    /// Getter for the [`WindowExtMacOS::set_borderless_game`].
+    fn is_borderless_game(&self) -> bool;
+}
+
+impl WindowExtMacOS for Window {
+    #[inline]
+    fn simple_fullscreen(&self) -> bool {
+        self.window.maybe_wait_on_main(|w| w.simple_fullscreen())
+    }
+
+    #[inline]
+    fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
+        self.window.maybe_wait_on_main(move |w| w.set_simple_fullscreen(fullscreen))
+    }
+
+    #[inline]
+    fn has_shadow(&self) -> bool {
+        self.window.maybe_wait_on_main(|w| w.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())
+    }
+
+    #[inline]
+    fn is_document_edited(&self) -> bool {
+        self.window.maybe_wait_on_main(|w| w.is_document_edited())
+    }
+
+    #[inline]
+    fn set_document_edited(&self, edited: bool) {
+        self.window.maybe_queue_on_main(move |w| w.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))
+    }
+
+    #[inline]
+    fn option_as_alt(&self) -> OptionAsAlt {
+        self.window.maybe_wait_on_main(|w| w.option_as_alt())
+    }
+
+    #[inline]
+    fn set_borderless_game(&self, borderless_game: bool) {
+        self.window.maybe_wait_on_main(|w| w.set_borderless_game(borderless_game))
+    }
+
+    #[inline]
+    fn is_borderless_game(&self) -> bool {
+        self.window.maybe_wait_on_main(|w| w.is_borderless_game())
+    }
+}
+
+/// Corresponds to `NSApplicationActivationPolicy`.
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum ActivationPolicy {
+    /// Corresponds to `NSApplicationActivationPolicyRegular`.
+    #[default]
+    Regular,
+
+    /// Corresponds to `NSApplicationActivationPolicyAccessory`.
+    Accessory,
+
+    /// Corresponds to `NSApplicationActivationPolicyProhibited`.
+    Prohibited,
+}
+
+/// Additional methods on [`WindowAttributes`] that are specific to MacOS.
+///
+/// **Note:** Properties dealing with the titlebar will be overwritten by the
+/// [`WindowAttributes::with_decorations`] method:
+/// - `with_titlebar_transparent`
+/// - `with_title_hidden`
+/// - `with_titlebar_hidden`
+/// - `with_titlebar_buttons_hidden`
+/// - `with_fullsize_content_view`
+pub trait WindowAttributesExtMacOS {
+    /// Enables click-and-drag behavior for the entire window, not just the titlebar.
+    fn with_movable_by_window_background(self, movable_by_window_background: bool) -> Self;
+    /// Makes the titlebar transparent and allows the content to appear behind it.
+    fn with_titlebar_transparent(self, titlebar_transparent: bool) -> Self;
+    /// Hides the window title.
+    fn with_title_hidden(self, title_hidden: bool) -> Self;
+    /// Hides the window titlebar.
+    fn with_titlebar_hidden(self, titlebar_hidden: bool) -> Self;
+    /// Hides the window titlebar buttons.
+    fn with_titlebar_buttons_hidden(self, titlebar_buttons_hidden: bool) -> Self;
+    /// Makes the window content appear behind the titlebar.
+    fn with_fullsize_content_view(self, fullsize_content_view: bool) -> Self;
+    fn with_disallow_hidpi(self, disallow_hidpi: bool) -> Self;
+    fn with_has_shadow(self, has_shadow: bool) -> Self;
+    /// Window accepts click-through mouse events.
+    fn with_accepts_first_mouse(self, accepts_first_mouse: bool) -> Self;
+    /// Defines the window tabbing identifier.
+    ///
+    /// <https://developer.apple.com/documentation/appkit/nswindow/1644704-tabbingidentifier>
+    fn with_tabbing_identifier(self, identifier: &str) -> Self;
+    /// Set how the <kbd>Option</kbd> keys are interpreted.
+    ///
+    /// See [`WindowExtMacOS::set_option_as_alt`] for details on what this means if set.
+    fn with_option_as_alt(self, option_as_alt: OptionAsAlt) -> Self;
+    /// See [`WindowExtMacOS::set_borderless_game`] for details on what this means if set.
+    fn with_borderless_game(self, borderless_game: bool) -> Self;
+}
+
+impl WindowAttributesExtMacOS for WindowAttributes {
+    #[inline]
+    fn with_movable_by_window_background(mut self, movable_by_window_background: bool) -> Self {
+        self.platform_specific.movable_by_window_background = movable_by_window_background;
+        self
+    }
+
+    #[inline]
+    fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> Self {
+        self.platform_specific.titlebar_transparent = titlebar_transparent;
+        self
+    }
+
+    #[inline]
+    fn with_titlebar_hidden(mut self, titlebar_hidden: bool) -> Self {
+        self.platform_specific.titlebar_hidden = titlebar_hidden;
+        self
+    }
+
+    #[inline]
+    fn with_titlebar_buttons_hidden(mut self, titlebar_buttons_hidden: bool) -> Self {
+        self.platform_specific.titlebar_buttons_hidden = titlebar_buttons_hidden;
+        self
+    }
+
+    #[inline]
+    fn with_title_hidden(mut self, title_hidden: bool) -> Self {
+        self.platform_specific.title_hidden = title_hidden;
+        self
+    }
+
+    #[inline]
+    fn with_fullsize_content_view(mut self, fullsize_content_view: bool) -> Self {
+        self.platform_specific.fullsize_content_view = fullsize_content_view;
+        self
+    }
+
+    #[inline]
+    fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> Self {
+        self.platform_specific.disallow_hidpi = disallow_hidpi;
+        self
+    }
+
+    #[inline]
+    fn with_has_shadow(mut self, has_shadow: bool) -> Self {
+        self.platform_specific.has_shadow = has_shadow;
+        self
+    }
+
+    #[inline]
+    fn with_accepts_first_mouse(mut self, accepts_first_mouse: bool) -> Self {
+        self.platform_specific.accepts_first_mouse = accepts_first_mouse;
+        self
+    }
+
+    #[inline]
+    fn with_tabbing_identifier(mut self, tabbing_identifier: &str) -> Self {
+        self.platform_specific.tabbing_identifier.replace(tabbing_identifier.to_string());
+        self
+    }
+
+    #[inline]
+    fn with_option_as_alt(mut self, option_as_alt: OptionAsAlt) -> Self {
+        self.platform_specific.option_as_alt = option_as_alt;
+        self
+    }
+
+    #[inline]
+    fn with_borderless_game(mut self, borderless_game: bool) -> Self {
+        self.platform_specific.borderless_game = borderless_game;
+        self
+    }
+}
+
+pub trait EventLoopBuilderExtMacOS {
+    /// Sets the activation policy for the application. If used, this will override
+    /// any relevant settings provided in the package manifest.
+    /// For instance, `with_activation_policy(ActivationPolicy::Regular)` will prevent
+    /// the application from running as an "agent", even if LSUIElement is set to true.
+    ///
+    /// If unused, the Winit will honor the package manifest.
+    ///
+    /// # Example
+    ///
+    /// Set the activation policy to "accessory".
+    ///
+    /// ```
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "macos")]
+    /// use winit::platform::macos::{ActivationPolicy, EventLoopBuilderExtMacOS};
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "macos")]
+    /// builder.with_activation_policy(ActivationPolicy::Accessory);
+    /// # if false { // We can't test this part
+    /// let event_loop = builder.build();
+    /// # }
+    /// ```
+    fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self;
+
+    /// Used to control whether a default menubar menu is created.
+    ///
+    /// Menu creation is enabled by default.
+    ///
+    /// # Example
+    ///
+    /// Disable creating a default menubar.
+    ///
+    /// ```
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "macos")]
+    /// use winit::platform::macos::EventLoopBuilderExtMacOS;
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "macos")]
+    /// builder.with_default_menu(false);
+    /// # if false { // We can't test this part
+    /// let event_loop = builder.build();
+    /// # }
+    /// ```
+    fn with_default_menu(&mut self, enable: bool) -> &mut Self;
+
+    /// Used to prevent the application from automatically activating when launched if
+    /// another application is already active.
+    ///
+    /// The default behavior is to ignore other applications and activate when launched.
+    fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtMacOS for EventLoopBuilder<T> {
+    #[inline]
+    fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self {
+        self.platform_specific.activation_policy = Some(activation_policy);
+        self
+    }
+
+    #[inline]
+    fn with_default_menu(&mut self, enable: bool) -> &mut Self {
+        self.platform_specific.default_menu = enable;
+        self
+    }
+
+    #[inline]
+    fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self {
+        self.platform_specific.activate_ignoring_other_apps = ignore;
+        self
+    }
+}
+
+/// Additional methods on [`MonitorHandle`] that are specific to MacOS.
+pub trait MonitorHandleExtMacOS {
+    /// Returns the identifier of the monitor for Cocoa.
+    fn native_id(&self) -> u32;
+    /// Returns a pointer to the NSScreen representing this monitor.
+    fn ns_screen(&self) -> Option<*mut c_void>;
+}
+
+impl MonitorHandleExtMacOS for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+
+    fn ns_screen(&self) -> Option<*mut c_void> {
+        // SAFETY: We only use the marker to get a pointer
+        let mtm = unsafe { objc2_foundation::MainThreadMarker::new_unchecked() };
+        self.inner.ns_screen(mtm).map(|s| objc2::rc::Retained::as_ptr(&s) as _)
+    }
+}
+
+/// Additional methods on [`ActiveEventLoop`] that are specific to macOS.
+pub trait ActiveEventLoopExtMacOS {
+    /// Hide the entire application. In most applications this is typically triggered with
+    /// Command-H.
+    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 ActiveEventLoopExtMacOS for ActiveEventLoop {
+    fn hide_application(&self) {
+        self.p.hide_application()
+    }
+
+    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)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum OptionAsAlt {
+    /// The left `Option` key is treated as `Alt`.
+    OnlyLeft,
+
+    /// The right `Option` key is treated as `Alt`.
+    OnlyRight,
+
+    /// Both `Option` keys are treated as `Alt`.
+    Both,
+
+    /// No special handling is applied for `Option` key.
+    #[default]
+    None,
+}

vendor/winit/src/platform/mod.rs

@@ -0,0 +1,55 @@
+//! Contains traits with platform-specific methods in them.
+//!
+//! Only the modules corresponding to the platform you're compiling to will be available.
+
+#[cfg(any(android_platform, docsrs))]
+pub mod android;
+#[cfg(any(ios_platform, docsrs))]
+pub mod ios;
+#[cfg(any(macos_platform, docsrs))]
+pub mod macos;
+#[cfg(any(orbital_platform, docsrs))]
+pub mod orbital;
+#[cfg(any(x11_platform, wayland_platform, docsrs))]
+pub mod startup_notify;
+#[cfg(any(wayland_platform, docsrs))]
+pub mod wayland;
+#[cfg(any(web_platform, docsrs))]
+pub mod web;
+#[cfg(any(windows_platform, docsrs))]
+pub mod windows;
+#[cfg(any(x11_platform, docsrs))]
+pub mod x11;
+
+#[cfg(any(
+    windows_platform,
+    macos_platform,
+    android_platform,
+    x11_platform,
+    wayland_platform,
+    docsrs,
+))]
+pub mod run_on_demand;
+
+#[cfg(any(
+    windows_platform,
+    macos_platform,
+    android_platform,
+    x11_platform,
+    wayland_platform,
+    docsrs,
+))]
+pub mod pump_events;
+
+#[cfg(any(
+    windows_platform,
+    macos_platform,
+    x11_platform,
+    wayland_platform,
+    orbital_platform,
+    docsrs
+))]
+pub mod modifier_supplement;
+
+#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform, docsrs))]
+pub mod scancode;

vendor/winit/src/platform/modifier_supplement.rs

@@ -0,0 +1,35 @@
+use crate::event::KeyEvent;
+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;
+}
+
+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()
+    }
+}

vendor/winit/src/platform/orbital.rs

@@ -0,0 +1,6 @@
+//! # Orbital / Redox OS
+//!
+//! Redox OS has some functionality not yet present that will be implemented
+//! when its orbital display server provides it.
+
+// There are no Orbital specific traits yet.

vendor/winit/src/platform/pump_events.rs

@@ -0,0 +1,143 @@
+use std::time::Duration;
+
+use crate::application::ApplicationHandler;
+use crate::event::Event;
+use crate::event_loop::{self, ActiveEventLoop, EventLoop};
+
+/// 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: 'static;
+
+    /// 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.
+    ///
+    /// **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 application whenever
+    ///   the application `RunLoop` indicates that it is preparing to block and wait for new events.
+    ///
+    ///   This is very different to the polling APIs that are available on other
+    ///   platforms (the lower level polling primitives on MacOS are private
+    ///   implementation details for `NSApplication` which aren't accessible to
+    ///   application developers)
+    ///
+    ///   It's likely this will be less efficient than polling on other OSs and
+    ///   it also means the `NSApplication` is stopped while outside of the Winit
+    ///   event loop - and that's observable (for example to crates like `rfd`)
+    ///   because the `NSApplication` 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_app_events<A: ApplicationHandler<Self::UserEvent>>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
+        #[allow(deprecated)]
+        self.pump_events(timeout, |event, event_loop| {
+            event_loop::dispatch_event_for_app(app, event_loop, event)
+        })
+    }
+
+    /// See [`pump_app_events`].
+    ///
+    /// [`pump_app_events`]: Self::pump_app_events
+    #[deprecated = "use EventLoopExtPumpEvents::pump_app_events"]
+    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
+    where
+        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
+}
+
+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>, &ActiveEventLoop),
+    {
+        self.event_loop.pump_events(timeout, event_handler)
+    }
+}
+
+/// The return status for `pump_events`
+pub enum PumpStatus {
+    /// Continue running external loop.
+    Continue,
+    /// Exit external loop.
+    Exit(i32),
+}

vendor/winit/src/platform/run_on_demand.rs

@@ -0,0 +1,111 @@
+use crate::application::ApplicationHandler;
+use crate::error::EventLoopError;
+use crate::event::Event;
+use crate::event_loop::{self, ActiveEventLoop, EventLoop};
+
+#[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: 'static;
+
+    /// See [`run_app_on_demand`].
+    ///
+    /// [`run_app_on_demand`]: Self::run_app_on_demand
+    #[deprecated = "use EventLoopExtRunOnDemand::run_app_on_demand"]
+    fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
+
+    /// Run the application with the event loop on the calling thread.
+    ///
+    /// Unlike [`EventLoop::run_app`], 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 using [`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_app_events()`] API)
+    ///
+    /// Each time `run_app_on_demand` is called the startup sequence of `init`, followed by
+    /// `resume` is being preserved.
+    ///
+    /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
+    ///
+    /// # Caveats
+    /// - This extension isn't available on all platforms, since it's not always possible to return
+    ///   to the caller (specifically this is impossible on iOS and Web - though with the Web
+    ///   backend it is possible to use `EventLoopExtWebSys::spawn()`
+    #[cfg_attr(not(web_platform), doc = "[^1]")]
+    ///   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_app()`] 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 `UIApplication` repeatedly on iOS.
+    #[cfg_attr(not(web_platform), doc = "[^1]: `spawn()` is only available on `wasm` platforms.")]
+    ///
+    #[rustfmt::skip]
+    /// [`exit()`]: ActiveEventLoop::exit()
+    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
+    fn run_app_on_demand<A: ApplicationHandler<Self::UserEvent>>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
+        #[allow(deprecated)]
+        self.run_on_demand(|event, event_loop| {
+            event_loop::dispatch_event_for_app(app, event_loop, event)
+        })
+    }
+}
+
+impl<T> EventLoopExtRunOnDemand for EventLoop<T> {
+    type UserEvent = T;
+
+    fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
+    {
+        self.event_loop.window_target().clear_exit();
+        self.event_loop.run_on_demand(event_handler)
+    }
+}
+
+impl ActiveEventLoop {
+    /// Clear exit status.
+    pub(crate) fn clear_exit(&self) {
+        self.p.clear_exit()
+    }
+}
+
+/// ```compile_fail
+/// use winit::event_loop::EventLoop;
+/// use winit::platform::run_on_demand::EventLoopExtRunOnDemand;
+///
+/// let mut event_loop = EventLoop::new().unwrap();
+/// event_loop.run_on_demand(|_, _| {
+///     // Attempt to run the event loop re-entrantly; this must fail.
+///     event_loop.run_on_demand(|_, _| {});
+/// });
+/// ```
+#[allow(dead_code)]
+fn test_run_on_demand_cannot_access_event_loop() {}

vendor/winit/src/platform/scancode.rs

@@ -0,0 +1,50 @@
+use crate::keyboard::{KeyCode, PhysicalKey};
+
+// TODO: Describe what this value contains for each platform
+
+/// Additional methods for the [`PhysicalKey`] type that allow the user to access the
+/// platform-specific scancode.
+///
+/// [`PhysicalKey`]: crate::keyboard::PhysicalKey
+pub trait PhysicalKeyExtScancode {
+    /// The raw value of the platform-specific physical key identifier.
+    ///
+    /// Returns `Some(key_id)` if the conversion was successful; 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 `PhysicalKey` from a platform-specific physical key identifier.
+    ///
+    /// Note that this conversion may be lossy, i.e. converting the returned `PhysicalKey` back
+    /// using `to_scancode` might not yield the original value.
+    ///
+    /// ## Platform-specific
+    /// - **Wayland/X11**: A 32-bit linux scancode. When building from X11/Wayland keycode subtract
+    ///   `8` to get the value you wanted.
+    fn from_scancode(scancode: u32) -> PhysicalKey;
+}
+
+impl PhysicalKeyExtScancode for PhysicalKey {
+    fn to_scancode(self) -> Option<u32> {
+        crate::platform_impl::physicalkey_to_scancode(self)
+    }
+
+    fn from_scancode(scancode: u32) -> PhysicalKey {
+        crate::platform_impl::scancode_to_physicalkey(scancode)
+    }
+}
+
+impl PhysicalKeyExtScancode for KeyCode {
+    #[inline]
+    fn to_scancode(self) -> Option<u32> {
+        <PhysicalKey as PhysicalKeyExtScancode>::to_scancode(PhysicalKey::Code(self))
+    }
+
+    #[inline]
+    fn from_scancode(scancode: u32) -> PhysicalKey {
+        <PhysicalKey as PhysicalKeyExtScancode>::from_scancode(scancode)
+    }
+}

vendor/winit/src/platform/startup_notify.rs

@@ -0,0 +1,99 @@
+//! 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::{ActiveEventLoop, AsyncRequestSerial};
+use crate::window::{ActivationToken, Window, WindowAttributes};
+
+/// 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 WindowAttributesExtStartupNotify {
+    /// 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 EventLoopExtStartupNotify for ActiveEventLoop {
+    fn read_token_from_env(&self) -> Option<ActivationToken> {
+        match self.p {
+            #[cfg(wayland_platform)]
+            crate::platform_impl::ActiveEventLoop::Wayland(_) => env::var(WAYLAND_VAR),
+            #[cfg(x11_platform)]
+            crate::platform_impl::ActiveEventLoop::X(_) => env::var(X11_VAR),
+        }
+        .ok()
+        .map(ActivationToken::from_raw)
+    }
+}
+
+impl WindowExtStartupNotify for Window {
+    fn request_activation_token(&self) -> Result<AsyncRequestSerial, NotSupportedError> {
+        self.window.request_activation_token()
+    }
+}
+
+impl WindowAttributesExtStartupNotify for WindowAttributes {
+    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.
+pub 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.
+pub fn set_activation_token_env(token: ActivationToken) {
+    env::set_var(X11_VAR, &token.token);
+    env::set_var(WAYLAND_VAR, token.token);
+}

vendor/winit/src/platform/wayland.rs

@@ -0,0 +1,131 @@
+//! # Wayland
+//!
+//! **Note:** Windows don't appear on Wayland until you draw/present to them.
+//!
+//! By default, Winit loads system libraries using `dlopen`. This can be
+//! disabled by disabling the `"wayland-dlopen"` cargo feature.
+//!
+//! ## Client-side decorations
+//!
+//! Winit provides client-side decorations by default, but the behaviour can
+//! be controlled with the following feature flags:
+//!
+//! * `wayland-csd-adwaita` (default).
+//! * `wayland-csd-adwaita-crossfont`.
+//! * `wayland-csd-adwaita-notitle`.
+
+use std::ffi::c_void;
+use std::ptr::NonNull;
+
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
+use crate::monitor::MonitorHandle;
+use crate::window::{Window, WindowAttributes};
+
+pub use crate::window::Theme;
+
+/// Additional methods on [`ActiveEventLoop`] that are specific to Wayland.
+pub trait ActiveEventLoopExtWayland {
+    /// True if the [`ActiveEventLoop`] uses Wayland.
+    fn is_wayland(&self) -> bool;
+}
+
+impl ActiveEventLoopExtWayland for ActiveEventLoop {
+    #[inline]
+    fn is_wayland(&self) -> bool {
+        self.p.is_wayland()
+    }
+}
+
+/// Additional methods on [`EventLoop`] that are specific to Wayland.
+pub trait EventLoopExtWayland {
+    /// True if the [`EventLoop`] uses Wayland.
+    fn is_wayland(&self) -> bool;
+}
+
+impl<T: 'static> EventLoopExtWayland for EventLoop<T> {
+    #[inline]
+    fn is_wayland(&self) -> bool {
+        self.event_loop.is_wayland()
+    }
+}
+
+/// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
+pub trait EventLoopBuilderExtWayland {
+    /// Force using Wayland.
+    fn with_wayland(&mut self) -> &mut Self;
+
+    /// Whether to allow the event loop to be created off of the main thread.
+    ///
+    /// By default, the window is only allowed to be created on the main
+    /// thread, to make platform compatibility easier.
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtWayland for EventLoopBuilder<T> {
+    #[inline]
+    fn with_wayland(&mut self) -> &mut Self {
+        self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::Wayland);
+        self
+    }
+
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+}
+
+/// Additional methods on [`Window`] that are specific to Wayland.
+///
+/// [`Window`]: crate::window::Window
+pub trait WindowExtWayland {
+    /// Returns `xdg_toplevel` of the window or [`None`] if the window is X11 window.
+    fn xdg_toplevel(&self) -> Option<NonNull<c_void>>;
+}
+
+impl WindowExtWayland for Window {
+    #[inline]
+    fn xdg_toplevel(&self) -> Option<NonNull<c_void>> {
+        #[allow(clippy::single_match)]
+        match &self.window {
+            #[cfg(x11_platform)]
+            crate::platform_impl::Window::X(_) => None,
+            #[cfg(wayland_platform)]
+            crate::platform_impl::Window::Wayland(window) => window.xdg_toplevel(),
+        }
+    }
+}
+
+/// Additional methods on [`WindowAttributes`] that are specific to Wayland.
+pub trait WindowAttributesExtWayland {
+    /// Build window with the given name.
+    ///
+    /// The `general` name sets an application ID, which should match the `.desktop`
+    /// file distributed with your program. The `instance` is a `no-op`.
+    ///
+    /// For details about application ID conventions, see the
+    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
+    fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;
+}
+
+impl WindowAttributesExtWayland for WindowAttributes {
+    #[inline]
+    fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
+        self.platform_specific.name =
+            Some(crate::platform_impl::ApplicationName::new(general.into(), instance.into()));
+        self
+    }
+}
+
+/// Additional methods on `MonitorHandle` that are specific to Wayland.
+pub trait MonitorHandleExtWayland {
+    /// Returns the inner identifier of the monitor.
+    fn native_id(&self) -> u32;
+}
+
+impl MonitorHandleExtWayland for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+}

vendor/winit/src/platform/web.rs

@@ -0,0 +1,465 @@
+//! # Web
+//!
+//! The officially supported browsers are Chrome, Firefox and Safari 13.1+,
+//! though forks of these should work fine.
+//!
+//! Winit supports compiling to the `wasm32-unknown-unknown` target with
+//! `web-sys`.
+//!
+//! On the web platform, a Winit window is backed by a `<canvas>` element. You
+//! can either [provide Winit with a `<canvas>` element][with_canvas], or
+//! [let Winit create a `<canvas>` element which you can then retrieve][get]
+//! and insert it into the DOM yourself.
+//!
+//! Currently, there is no example code using Winit on Web, see [#3473]. For
+//! information on using Rust on WebAssembly, check out the [Rust and
+//! WebAssembly book].
+//!
+//! [with_canvas]: WindowAttributesExtWebSys::with_canvas
+//! [get]: WindowExtWebSys::canvas
+//! [#3473]: https://github.com/rust-windowing/winit/issues/3473
+//! [Rust and WebAssembly book]: https://rustwasm.github.io/book/
+//!
+//! ## CSS properties
+//!
+//! It is recommended **not** to apply certain CSS properties to the canvas:
+//! - [`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)
+//!
+//! 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
+
+use std::error::Error;
+use std::fmt::{self, Display, Formatter};
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+use std::time::Duration;
+
+#[cfg(web_platform)]
+use web_sys::HtmlCanvasElement;
+
+use crate::application::ApplicationHandler;
+use crate::cursor::CustomCursorSource;
+use crate::event::Event;
+use crate::event_loop::{self, ActiveEventLoop, EventLoop};
+#[cfg(web_platform)]
+use crate::platform_impl::CustomCursorFuture as PlatformCustomCursorFuture;
+use crate::platform_impl::PlatformCustomCursorSource;
+use crate::window::{CustomCursor, Window, WindowAttributes};
+
+#[cfg(not(web_platform))]
+#[doc(hidden)]
+pub struct HtmlCanvasElement;
+
+pub trait WindowExtWebSys {
+    /// Only returns the canvas if called from inside the window context (the
+    /// main thread).
+    fn canvas(&self) -> Option<HtmlCanvasElement>;
+
+    /// Returns [`true`] if calling `event.preventDefault()` is enabled.
+    ///
+    /// See [`Window::set_prevent_default()`] for more details.
+    fn prevent_default(&self) -> bool;
+
+    /// Sets whether `event.preventDefault()` should be called on events on the
+    /// canvas that have side effects.
+    ///
+    /// For example, by default using the mouse wheel would cause the page to scroll, enabling this
+    /// would prevent that.
+    ///
+    /// Some events are impossible to prevent. E.g. Firefox allows to access the native browser
+    /// context menu with Shift+Rightclick.
+    fn set_prevent_default(&self, prevent_default: bool);
+}
+
+impl WindowExtWebSys for Window {
+    #[inline]
+    fn canvas(&self) -> Option<HtmlCanvasElement> {
+        self.window.canvas()
+    }
+
+    fn prevent_default(&self) -> bool {
+        self.window.prevent_default()
+    }
+
+    fn set_prevent_default(&self, prevent_default: bool) {
+        self.window.set_prevent_default(prevent_default)
+    }
+}
+
+pub trait WindowAttributesExtWebSys {
+    /// Pass an [`HtmlCanvasElement`] to be used for this [`Window`]. If [`None`],
+    /// [`WindowAttributes::default()`] will create one.
+    ///
+    /// In any case, the canvas won't be automatically inserted into the web page.
+    ///
+    /// [`None`] by default.
+    #[cfg_attr(not(web_platform), doc = "", doc = "[`HtmlCanvasElement`]: #only-available-on-wasm")]
+    fn with_canvas(self, canvas: Option<HtmlCanvasElement>) -> Self;
+
+    /// Sets whether `event.preventDefault()` should be called on events on the
+    /// canvas that have side effects.
+    ///
+    /// See [`Window::set_prevent_default()`] for more details.
+    ///
+    /// 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 WindowAttributesExtWebSys for WindowAttributes {
+    fn with_canvas(mut self, canvas: Option<HtmlCanvasElement>) -> Self {
+        self.platform_specific.set_canvas(canvas);
+        self
+    }
+
+    fn with_prevent_default(mut self, prevent_default: bool) -> Self {
+        self.platform_specific.prevent_default = prevent_default;
+        self
+    }
+
+    fn with_focusable(mut self, focusable: bool) -> Self {
+        self.platform_specific.focusable = focusable;
+        self
+    }
+
+    fn with_append(mut self, append: bool) -> Self {
+        self.platform_specific.append = append;
+        self
+    }
+}
+
+/// Additional methods on `EventLoop` that are specific to the web.
+pub trait EventLoopExtWebSys {
+    /// A type provided by the user that can be passed through `Event::UserEvent`.
+    type UserEvent: 'static;
+
+    /// Initializes the winit event loop.
+    ///
+    /// Unlike
+    #[cfg_attr(all(web_platform, target_feature = "exception-handling"), doc = "`run_app()`")]
+    #[cfg_attr(
+        not(all(web_platform, target_feature = "exception-handling")),
+        doc = "[`run_app()`]"
+    )]
+    /// [^1], 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.
+    #[rustfmt::skip]
+    ///
+    #[cfg_attr(
+        not(all(web_platform, target_feature = "exception-handling")),
+        doc = "[`run_app()`]: EventLoop::run_app()"
+    )]
+    /// [^1]: `run_app()` is _not_ available on WASM when the target supports `exception-handling`.
+    fn spawn_app<A: ApplicationHandler<Self::UserEvent> + 'static>(self, app: A);
+
+    /// See [`spawn_app`].
+    ///
+    /// [`spawn_app`]: Self::spawn_app
+    #[deprecated = "use EventLoopExtWebSys::spawn_app"]
+    fn spawn<F>(self, event_handler: F)
+    where
+        F: 'static + FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
+
+    /// Sets the strategy for [`ControlFlow::Poll`].
+    ///
+    /// See [`PollStrategy`].
+    ///
+    /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
+    fn set_poll_strategy(&self, strategy: PollStrategy);
+
+    /// Gets the strategy for [`ControlFlow::Poll`].
+    ///
+    /// See [`PollStrategy`].
+    ///
+    /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
+    fn poll_strategy(&self) -> PollStrategy;
+
+    /// Sets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy);
+
+    /// Gets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn wait_until_strategy(&self) -> WaitUntilStrategy;
+}
+
+impl<T> EventLoopExtWebSys for EventLoop<T> {
+    type UserEvent = T;
+
+    fn spawn_app<A: ApplicationHandler<Self::UserEvent> + 'static>(self, mut app: A) {
+        self.event_loop.spawn(move |event, event_loop| {
+            event_loop::dispatch_event_for_app(&mut app, event_loop, event)
+        });
+    }
+
+    fn spawn<F>(self, event_handler: F)
+    where
+        F: 'static + FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
+    {
+        self.event_loop.spawn(event_handler)
+    }
+
+    fn set_poll_strategy(&self, strategy: PollStrategy) {
+        self.event_loop.set_poll_strategy(strategy);
+    }
+
+    fn poll_strategy(&self) -> PollStrategy {
+        self.event_loop.poll_strategy()
+    }
+
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.event_loop.set_wait_until_strategy(strategy);
+    }
+
+    fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.event_loop.wait_until_strategy()
+    }
+}
+
+pub trait ActiveEventLoopExtWebSys {
+    /// Sets the strategy for [`ControlFlow::Poll`].
+    ///
+    /// See [`PollStrategy`].
+    ///
+    /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
+    fn set_poll_strategy(&self, strategy: PollStrategy);
+
+    /// Gets the strategy for [`ControlFlow::Poll`].
+    ///
+    /// See [`PollStrategy`].
+    ///
+    /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
+    fn poll_strategy(&self) -> PollStrategy;
+
+    /// Sets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy);
+
+    /// Gets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn wait_until_strategy(&self) -> WaitUntilStrategy;
+
+    /// Async version of [`ActiveEventLoop::create_custom_cursor()`] which waits until the
+    /// cursor has completely finished loading.
+    fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture;
+}
+
+impl ActiveEventLoopExtWebSys for ActiveEventLoop {
+    #[inline]
+    fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture {
+        self.p.create_custom_cursor_async(source)
+    }
+
+    #[inline]
+    fn set_poll_strategy(&self, strategy: PollStrategy) {
+        self.p.set_poll_strategy(strategy);
+    }
+
+    #[inline]
+    fn poll_strategy(&self) -> PollStrategy {
+        self.p.poll_strategy()
+    }
+
+    #[inline]
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.p.set_wait_until_strategy(strategy);
+    }
+
+    #[inline]
+    fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.p.wait_until_strategy()
+    }
+}
+
+/// Strategy used for [`ControlFlow::Poll`][crate::event_loop::ControlFlow::Poll].
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum PollStrategy {
+    /// Uses [`Window.requestIdleCallback()`] to queue the next event loop. If not available
+    /// this will fallback to [`setTimeout()`].
+    ///
+    /// This strategy will wait for the browser to enter an idle period before running and might
+    /// be affected by browser throttling.
+    ///
+    /// [`Window.requestIdleCallback()`]: https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback
+    /// [`setTimeout()`]: https://developer.mozilla.org/en-US/docs/Web/API/setTimeout
+    IdleCallback,
+    /// Uses the [Prioritized Task Scheduling API] to queue the next event loop. If not available
+    /// this will fallback to [`setTimeout()`].
+    ///
+    /// This strategy will run as fast as possible without disturbing users from interacting with
+    /// the page and is not affected by browser throttling.
+    ///
+    /// This is the default strategy.
+    ///
+    /// [Prioritized Task Scheduling API]: https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API
+    /// [`setTimeout()`]: https://developer.mozilla.org/en-US/docs/Web/API/setTimeout
+    #[default]
+    Scheduler,
+}
+
+/// Strategy used for [`ControlFlow::WaitUntil`][crate::event_loop::ControlFlow::WaitUntil].
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum WaitUntilStrategy {
+    /// Uses the [Prioritized Task Scheduling API] to queue the next event loop. If not available
+    /// this will fallback to [`setTimeout()`].
+    ///
+    /// This strategy is commonly not affected by browser throttling unless the window is not
+    /// focused.
+    ///
+    /// This is the default strategy.
+    ///
+    /// [Prioritized Task Scheduling API]: https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API
+    /// [`setTimeout()`]: https://developer.mozilla.org/en-US/docs/Web/API/setTimeout
+    #[default]
+    Scheduler,
+    /// Equal to [`Scheduler`][Self::Scheduler] but wakes up the event loop from a [worker].
+    ///
+    /// This strategy is commonly not affected by browser throttling regardless of window focus.
+    ///
+    /// [worker]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API
+    Worker,
+}
+
+pub trait CustomCursorExtWebSys {
+    /// Returns if this cursor is an animation.
+    fn is_animation(&self) -> bool;
+
+    /// Creates a new cursor from a URL pointing to an image.
+    /// It uses the [url css function](https://developer.mozilla.org/en-US/docs/Web/CSS/url),
+    /// but browser support for image formats is inconsistent. Using [PNG] is recommended.
+    ///
+    /// [PNG]: https://en.wikipedia.org/wiki/PNG
+    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorSource;
+
+    /// Crates a new animated cursor from multiple [`CustomCursor`]s.
+    /// Supplied `cursors` can't be empty or other animations.
+    fn from_animation(
+        duration: Duration,
+        cursors: Vec<CustomCursor>,
+    ) -> Result<CustomCursorSource, BadAnimation>;
+}
+
+impl CustomCursorExtWebSys for CustomCursor {
+    fn is_animation(&self) -> bool {
+        self.inner.animation
+    }
+
+    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorSource {
+        CustomCursorSource { inner: PlatformCustomCursorSource::Url { url, hotspot_x, hotspot_y } }
+    }
+
+    fn from_animation(
+        duration: Duration,
+        cursors: Vec<CustomCursor>,
+    ) -> Result<CustomCursorSource, BadAnimation> {
+        if cursors.is_empty() {
+            return Err(BadAnimation::Empty);
+        }
+
+        if cursors.iter().any(CustomCursor::is_animation) {
+            return Err(BadAnimation::Animation);
+        }
+
+        Ok(CustomCursorSource {
+            inner: PlatformCustomCursorSource::Animation { duration, cursors },
+        })
+    }
+}
+
+/// An error produced when using [`CustomCursor::from_animation`] with invalid arguments.
+#[derive(Debug, Clone)]
+pub enum BadAnimation {
+    /// Produced when no cursors were supplied.
+    Empty,
+    /// Produced when a supplied cursor is an animation.
+    Animation,
+}
+
+impl fmt::Display for BadAnimation {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Empty => write!(f, "No cursors supplied"),
+            Self::Animation => write!(f, "A supplied cursor is an animation"),
+        }
+    }
+}
+
+impl Error for BadAnimation {}
+
+#[cfg(not(web_platform))]
+struct PlatformCustomCursorFuture;
+
+#[derive(Debug)]
+pub struct CustomCursorFuture(pub(crate) PlatformCustomCursorFuture);
+
+impl Future for CustomCursorFuture {
+    type Output = Result<CustomCursor, CustomCursorError>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        Pin::new(&mut self.0).poll(cx).map_ok(|cursor| CustomCursor { inner: cursor })
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum CustomCursorError {
+    Blob,
+    Decode(String),
+    Animation,
+}
+
+impl Display for CustomCursorError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Blob => write!(f, "failed to create `Blob`"),
+            Self::Decode(error) => write!(f, "failed to decode image: {error}"),
+            Self::Animation => {
+                write!(f, "found `CustomCursor` that is an animation when building an animation")
+            },
+        }
+    }
+}
+
+impl Error for CustomCursorError {}

vendor/winit/src/platform/windows.rs

@@ -0,0 +1,767 @@
+//! # Windows
+//!
+//! The supported OS version is Windows 7 or higher, though Windows 10 is
+//! tested regularly.
+use std::borrow::Borrow;
+use std::ffi::c_void;
+use std::path::Path;
+
+use crate::dpi::PhysicalSize;
+use crate::event::DeviceId;
+use crate::event_loop::EventLoopBuilder;
+use crate::monitor::MonitorHandle;
+use crate::window::{BadIcon, Icon, Window, WindowAttributes};
+
+/// Window Handle type used by Win32 API
+pub type HWND = isize;
+/// Menu Handle type used by Win32 API
+pub type HMENU = isize;
+/// Monitor Handle type used by Win32 API
+pub type HMONITOR = isize;
+
+/// Describes a system-drawn backdrop material of a window.
+///
+/// For a detailed explanation, see [`DWM_SYSTEMBACKDROP_TYPE docs`].
+///
+/// [`DWM_SYSTEMBACKDROP_TYPE docs`]: https://learn.microsoft.com/en-us/windows/win32/api/dwmapi/ne-dwmapi-dwm_systembackdrop_type
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum BackdropType {
+    /// Corresponds to `DWMSBT_AUTO`.
+    ///
+    /// Usually draws a default backdrop effect on the title bar.
+    #[default]
+    Auto = 0,
+
+    /// Corresponds to `DWMSBT_NONE`.
+    None = 1,
+
+    /// Corresponds to `DWMSBT_MAINWINDOW`.
+    ///
+    /// Draws the Mica backdrop material.
+    MainWindow = 2,
+
+    /// Corresponds to `DWMSBT_TRANSIENTWINDOW`.
+    ///
+    /// Draws the Background Acrylic backdrop material.
+    TransientWindow = 3,
+
+    /// Corresponds to `DWMSBT_TABBEDWINDOW`.
+    ///
+    /// Draws the Alt Mica backdrop material.
+    TabbedWindow = 4,
+}
+
+/// Describes a color used by Windows
+#[repr(transparent)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct Color(u32);
+
+impl Color {
+    // Special constant only valid for the window border and therefore modeled using Option<Color>
+    // for user facing code
+    const NONE: Color = Color(0xfffffffe);
+    /// Use the system's default color
+    pub const SYSTEM_DEFAULT: Color = Color(0xffffffff);
+
+    /// Create a new color from the given RGB values
+    pub const fn from_rgb(r: u8, g: u8, b: u8) -> Self {
+        Self((r as u32) | ((g as u32) << 8) | ((b as u32) << 16))
+    }
+}
+
+impl Default for Color {
+    fn default() -> Self {
+        Self::SYSTEM_DEFAULT
+    }
+}
+
+/// Describes how the corners of a window should look like.
+///
+/// For a detailed explanation, see [`DWM_WINDOW_CORNER_PREFERENCE docs`].
+///
+/// [`DWM_WINDOW_CORNER_PREFERENCE docs`]: https://learn.microsoft.com/en-us/windows/win32/api/dwmapi/ne-dwmapi-dwm_window_corner_preference
+#[repr(i32)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum CornerPreference {
+    /// Corresponds to `DWMWCP_DEFAULT`.
+    ///
+    /// Let the system decide when to round window corners.
+    #[default]
+    Default = 0,
+
+    /// Corresponds to `DWMWCP_DONOTROUND`.
+    ///
+    /// Never round window corners.
+    DoNotRound = 1,
+
+    /// Corresponds to `DWMWCP_ROUND`.
+    ///
+    /// Round the corners, if appropriate.
+    Round = 2,
+
+    /// Corresponds to `DWMWCP_ROUNDSMALL`.
+    ///
+    /// Round the corners if appropriate, with a small radius.
+    RoundSmall = 3,
+}
+
+/// A wrapper around a [`Window`] that ignores thread-specific window handle limitations.
+///
+/// See [`WindowBorrowExtWindows::any_thread`] for more information.
+#[derive(Debug)]
+pub struct AnyThread<W>(W);
+
+impl<W: Borrow<Window>> AnyThread<W> {
+    /// Get a reference to the inner window.
+    #[inline]
+    pub fn get_ref(&self) -> &Window {
+        self.0.borrow()
+    }
+
+    /// Get a reference to the inner object.
+    #[inline]
+    pub fn inner(&self) -> &W {
+        &self.0
+    }
+
+    /// Unwrap and get the inner window.
+    #[inline]
+    pub fn into_inner(self) -> W {
+        self.0
+    }
+}
+
+impl<W: Borrow<Window>> AsRef<Window> for AnyThread<W> {
+    fn as_ref(&self) -> &Window {
+        self.get_ref()
+    }
+}
+
+impl<W: Borrow<Window>> Borrow<Window> for AnyThread<W> {
+    fn borrow(&self) -> &Window {
+        self.get_ref()
+    }
+}
+
+impl<W: Borrow<Window>> std::ops::Deref for AnyThread<W> {
+    type Target = Window;
+
+    fn deref(&self) -> &Self::Target {
+        self.get_ref()
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl<W: Borrow<Window>> rwh_06::HasWindowHandle for AnyThread<W> {
+    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        // SAFETY: The top level user has asserted this is only used safely.
+        unsafe { self.get_ref().window_handle_any_thread() }
+    }
+}
+
+/// Additional methods on `EventLoop` that are specific to Windows.
+pub trait EventLoopBuilderExtWindows {
+    /// Whether to allow the event loop to be created off of the main thread.
+    ///
+    /// By default, the window is only allowed to be created on the main
+    /// thread, to make platform compatibility easier.
+    ///
+    /// # `Window` caveats
+    ///
+    /// Note that any `Window` created on the new thread will be destroyed when the thread
+    /// terminates. Attempting to use a `Window` after its parent thread terminates has
+    /// unspecified, although explicitly not undefined, behavior.
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
+
+    /// Whether to enable process-wide DPI awareness.
+    ///
+    /// By default, `winit` will attempt to enable process-wide DPI awareness. If
+    /// that's undesirable, you can disable it with this function.
+    ///
+    /// # Example
+    ///
+    /// Disable process-wide DPI awareness.
+    ///
+    /// ```
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "windows")]
+    /// use winit::platform::windows::EventLoopBuilderExtWindows;
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "windows")]
+    /// builder.with_dpi_aware(false);
+    /// # if false { // We can't test this part
+    /// let event_loop = builder.build();
+    /// # }
+    /// ```
+    fn with_dpi_aware(&mut self, dpi_aware: bool) -> &mut Self;
+
+    /// A callback to be executed before dispatching a win32 message to the window procedure.
+    /// Return true to disable winit's internal message dispatching.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use windows_sys::Win32::UI::WindowsAndMessaging::{ACCEL, CreateAcceleratorTableW, TranslateAcceleratorW, DispatchMessageW, TranslateMessage, MSG};
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "windows")]
+    /// use winit::platform::windows::EventLoopBuilderExtWindows;
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "windows")]
+    /// builder.with_msg_hook(|msg|{
+    ///     let msg = msg as *const MSG;
+    /// #   let accels: Vec<ACCEL> = Vec::new();
+    ///     let translated = unsafe {
+    ///         TranslateAcceleratorW(
+    ///             (*msg).hwnd,
+    ///             CreateAcceleratorTableW(accels.as_ptr() as _, 1),
+    ///             msg,
+    ///         ) == 1
+    ///     };
+    ///     translated
+    /// });
+    /// ```
+    fn with_msg_hook<F>(&mut self, callback: F) -> &mut Self
+    where
+        F: FnMut(*const c_void) -> bool + 'static;
+}
+
+impl<T> EventLoopBuilderExtWindows for EventLoopBuilder<T> {
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+
+    #[inline]
+    fn with_dpi_aware(&mut self, dpi_aware: bool) -> &mut Self {
+        self.platform_specific.dpi_aware = dpi_aware;
+        self
+    }
+
+    #[inline]
+    fn with_msg_hook<F>(&mut self, callback: F) -> &mut Self
+    where
+        F: FnMut(*const c_void) -> bool + 'static,
+    {
+        self.platform_specific.msg_hook = Some(Box::new(callback));
+        self
+    }
+}
+
+/// Additional methods on `Window` that are specific to Windows.
+pub trait WindowExtWindows {
+    /// Enables or disables mouse and keyboard input to the specified window.
+    ///
+    /// A window must be enabled before it can be activated.
+    /// If an application has create a modal dialog box by disabling its owner window
+    /// (as described in [`WindowAttributesExtWindows::with_owner_window`]), the application must
+    /// enable the owner window before destroying the dialog box.
+    /// Otherwise, another window will receive the keyboard focus and be activated.
+    ///
+    /// If a child window is disabled, it is ignored when the system tries to determine which
+    /// window should receive mouse messages.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-enablewindow#remarks>
+    /// and <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#disabled-windows>
+    fn set_enable(&self, enabled: bool);
+
+    /// This sets `ICON_BIG`. A good ceiling here is 256x256.
+    fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>);
+
+    /// Whether to show or hide the window icon in the taskbar.
+    fn set_skip_taskbar(&self, skip: bool);
+
+    /// Shows or hides the background drop shadow for undecorated windows.
+    ///
+    /// Enabling the shadow causes a thin 1px line to appear on the top of the window.
+    fn set_undecorated_shadow(&self, shadow: bool);
+
+    /// Sets system-drawn backdrop type.
+    ///
+    /// Requires Windows 11 build 22523+.
+    fn set_system_backdrop(&self, backdrop_type: BackdropType);
+
+    /// Sets the color of the window border.
+    ///
+    /// Supported starting with Windows 11 Build 22000.
+    fn set_border_color(&self, color: Option<Color>);
+
+    /// Sets the background color of the title bar.
+    ///
+    /// Supported starting with Windows 11 Build 22000.
+    fn set_title_background_color(&self, color: Option<Color>);
+
+    /// Sets the color of the window title.
+    ///
+    /// Supported starting with Windows 11 Build 22000.
+    fn set_title_text_color(&self, color: Color);
+
+    /// Sets the preferred style of the window corners.
+    ///
+    /// Supported starting with Windows 11 Build 22000.
+    fn set_corner_preference(&self, preference: CornerPreference);
+
+    /// Get the raw window handle for this [`Window`] without checking for thread affinity.
+    ///
+    /// Window handles in Win32 have a property called "thread affinity" that ties them to their
+    /// origin thread. Some operations can only happen on the window's origin thread, while others
+    /// can be called from any thread. For example, [`SetWindowSubclass`] is not thread safe while
+    /// [`GetDC`] is thread safe.
+    ///
+    /// In Rust terms, the window handle is `Send` sometimes but `!Send` other times.
+    ///
+    /// Therefore, in order to avoid confusing threading errors, [`Window`] only returns the
+    /// window handle when the [`window_handle`] function is called from the thread that created
+    /// the window. In other cases, it returns an [`Unavailable`] error.
+    ///
+    /// However in some cases you may already know that you are using the window handle for
+    /// operations that are guaranteed to be thread-safe. In which case this function aims
+    /// to provide an escape hatch so these functions are still accessible from other threads.
+    ///
+    /// # Safety
+    ///
+    /// It is the responsibility of the user to only pass the window handle into thread-safe
+    /// Win32 APIs.
+    ///
+    /// [`SetWindowSubclass`]: https://learn.microsoft.com/en-us/windows/win32/api/commctrl/nf-commctrl-setwindowsubclass
+    /// [`GetDC`]: https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getdc
+    /// [`Window`]: crate::window::Window
+    /// [`window_handle`]: https://docs.rs/raw-window-handle/latest/raw_window_handle/trait.HasWindowHandle.html#tymethod.window_handle
+    /// [`Unavailable`]: https://docs.rs/raw-window-handle/latest/raw_window_handle/enum.HandleError.html#variant.Unavailable
+    ///
+    /// ## Example
+    ///
+    /// ```no_run
+    /// # use winit::window::Window;
+    /// # fn scope(window: Window) {
+    /// use std::thread;
+    /// use winit::platform::windows::WindowExtWindows;
+    /// use winit::raw_window_handle::HasWindowHandle;
+    ///
+    /// // We can get the window handle on the current thread.
+    /// let handle = window.window_handle().unwrap();
+    ///
+    /// // However, on another thread, we can't!
+    /// thread::spawn(move || {
+    ///     assert!(window.window_handle().is_err());
+    ///
+    ///     // We can use this function as an escape hatch.
+    ///     let handle = unsafe { window.window_handle_any_thread().unwrap() };
+    /// });
+    /// # }
+    /// ```
+    #[cfg(feature = "rwh_06")]
+    unsafe fn window_handle_any_thread(
+        &self,
+    ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError>;
+}
+
+impl WindowExtWindows for Window {
+    #[inline]
+    fn set_enable(&self, enabled: bool) {
+        self.window.set_enable(enabled)
+    }
+
+    #[inline]
+    fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
+        self.window.set_taskbar_icon(taskbar_icon)
+    }
+
+    #[inline]
+    fn set_skip_taskbar(&self, skip: bool) {
+        self.window.set_skip_taskbar(skip)
+    }
+
+    #[inline]
+    fn set_undecorated_shadow(&self, shadow: bool) {
+        self.window.set_undecorated_shadow(shadow)
+    }
+
+    #[inline]
+    fn set_system_backdrop(&self, backdrop_type: BackdropType) {
+        self.window.set_system_backdrop(backdrop_type)
+    }
+
+    #[inline]
+    fn set_border_color(&self, color: Option<Color>) {
+        self.window.set_border_color(color.unwrap_or(Color::NONE))
+    }
+
+    #[inline]
+    fn set_title_background_color(&self, color: Option<Color>) {
+        // The windows docs don't mention NONE as a valid options but it works in practice and is
+        // useful to circumvent the Windows option "Show accent color on title bars and
+        // window borders"
+        self.window.set_title_background_color(color.unwrap_or(Color::NONE))
+    }
+
+    #[inline]
+    fn set_title_text_color(&self, color: Color) {
+        self.window.set_title_text_color(color)
+    }
+
+    #[inline]
+    fn set_corner_preference(&self, preference: CornerPreference) {
+        self.window.set_corner_preference(preference)
+    }
+
+    #[cfg(feature = "rwh_06")]
+    unsafe fn window_handle_any_thread(
+        &self,
+    ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        unsafe {
+            let handle = self.window.rwh_06_no_thread_check()?;
+
+            // SAFETY: The handle is valid in this context.
+            Ok(rwh_06::WindowHandle::borrow_raw(handle))
+        }
+    }
+}
+
+/// Additional methods for anything that dereference to [`Window`].
+///
+/// [`Window`]: crate::window::Window
+pub trait WindowBorrowExtWindows: Borrow<Window> + Sized {
+    /// Create an object that allows accessing the inner window handle in a thread-unsafe way.
+    ///
+    /// It is possible to call [`window_handle_any_thread`] to get around Windows's thread
+    /// affinity limitations. However, it may be desired to pass the [`Window`] into something
+    /// that requires the [`HasWindowHandle`] trait, while ignoring thread affinity limitations.
+    ///
+    /// This function wraps anything that implements `Borrow<Window>` into a structure that
+    /// uses the inner window handle as a mean of implementing [`HasWindowHandle`]. It wraps
+    /// `Window`, `&Window`, `Arc<Window>`, and other reference types.
+    ///
+    /// # Safety
+    ///
+    /// It is the responsibility of the user to only pass the window handle into thread-safe
+    /// Win32 APIs.
+    ///
+    /// [`window_handle_any_thread`]: WindowExtWindows::window_handle_any_thread
+    /// [`Window`]: crate::window::Window
+    /// [`HasWindowHandle`]: rwh_06::HasWindowHandle
+    unsafe fn any_thread(self) -> AnyThread<Self> {
+        AnyThread(self)
+    }
+}
+
+impl<W: Borrow<Window> + Sized> WindowBorrowExtWindows for W {}
+
+/// Additional methods on `WindowAttributes` that are specific to Windows.
+#[allow(rustdoc::broken_intra_doc_links)]
+pub trait WindowAttributesExtWindows {
+    /// Set an owner to the window to be created. Can be used to create a dialog box, for example.
+    /// This only works when [`WindowAttributes::with_parent_window`] isn't called or set to `None`.
+    /// Can be used in combination with
+    /// [`WindowExtWindows::set_enable(false)`][WindowExtWindows::set_enable] on the owner
+    /// window to create a modal dialog box.
+    ///
+    /// From MSDN:
+    /// - An owned window is always above its owner in the z-order.
+    /// - The system automatically destroys an owned window when its owner is destroyed.
+    /// - An owned window is hidden when its owner is minimized.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#owned-windows>
+    fn with_owner_window(self, parent: HWND) -> Self;
+
+    /// Sets a menu on the window to be created.
+    ///
+    /// Parent and menu are mutually exclusive; a child window cannot have a menu!
+    ///
+    /// The menu must have been manually created beforehand with [`CreateMenu`] or similar.
+    ///
+    /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how
+    /// the menus look. If you use this, it is recommended that you combine it with
+    /// `with_theme(Some(Theme::Light))` to avoid a jarring effect.
+    #[cfg_attr(
+        windows_platform,
+        doc = "[`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu"
+    )]
+    #[cfg_attr(not(windows_platform), doc = "[`CreateMenu`]: #only-available-on-windows")]
+    fn with_menu(self, menu: HMENU) -> Self;
+
+    /// This sets `ICON_BIG`. A good ceiling here is 256x256.
+    fn with_taskbar_icon(self, taskbar_icon: Option<Icon>) -> Self;
+
+    /// This sets `WS_EX_NOREDIRECTIONBITMAP`.
+    fn with_no_redirection_bitmap(self, flag: bool) -> Self;
+
+    /// Enables or disables drag and drop support (enabled by default). Will interfere with other
+    /// crates that use multi-threaded COM API (`CoInitializeEx` with `COINIT_MULTITHREADED`
+    /// instead of `COINIT_APARTMENTTHREADED`) on the same thread. Note that winit may still
+    /// attempt to initialize COM API regardless of this option. Currently only fullscreen mode
+    /// does that, but there may be more in the future. If you need COM API with
+    /// `COINIT_MULTITHREADED` you must initialize it before calling any winit functions. See <https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks> for more information.
+    fn with_drag_and_drop(self, flag: bool) -> Self;
+
+    /// Whether show or hide the window icon in the taskbar.
+    fn with_skip_taskbar(self, skip: bool) -> Self;
+
+    /// Customize the window class name.
+    fn with_class_name<S: Into<String>>(self, class_name: S) -> Self;
+
+    /// Shows or hides the background drop shadow for undecorated windows.
+    ///
+    /// The shadow is hidden by default.
+    /// Enabling the shadow causes a thin 1px line to appear on the top of the window.
+    fn with_undecorated_shadow(self, shadow: bool) -> Self;
+
+    /// Sets system-drawn backdrop type.
+    ///
+    /// Requires Windows 11 build 22523+.
+    fn with_system_backdrop(self, backdrop_type: BackdropType) -> Self;
+
+    /// This sets or removes `WS_CLIPCHILDREN` style.
+    fn with_clip_children(self, flag: bool) -> Self;
+
+    /// Sets the color of the window border.
+    ///
+    /// Supported starting with Windows 11 Build 22000.
+    fn with_border_color(self, color: Option<Color>) -> Self;
+
+    /// Sets the background color of the title bar.
+    ///
+    /// Supported starting with Windows 11 Build 22000.
+    fn with_title_background_color(self, color: Option<Color>) -> Self;
+
+    /// Sets the color of the window title.
+    ///
+    /// Supported starting with Windows 11 Build 22000.
+    fn with_title_text_color(self, color: Color) -> Self;
+
+    /// Sets the preferred style of the window corners.
+    ///
+    /// Supported starting with Windows 11 Build 22000.
+    fn with_corner_preference(self, corners: CornerPreference) -> Self;
+}
+
+impl WindowAttributesExtWindows for WindowAttributes {
+    #[inline]
+    fn with_owner_window(mut self, parent: HWND) -> Self {
+        self.platform_specific.owner = Some(parent);
+        self
+    }
+
+    #[inline]
+    fn with_menu(mut self, menu: HMENU) -> Self {
+        self.platform_specific.menu = Some(menu);
+        self
+    }
+
+    #[inline]
+    fn with_taskbar_icon(mut self, taskbar_icon: Option<Icon>) -> Self {
+        self.platform_specific.taskbar_icon = taskbar_icon;
+        self
+    }
+
+    #[inline]
+    fn with_no_redirection_bitmap(mut self, flag: bool) -> Self {
+        self.platform_specific.no_redirection_bitmap = flag;
+        self
+    }
+
+    #[inline]
+    fn with_drag_and_drop(mut self, flag: bool) -> Self {
+        self.platform_specific.drag_and_drop = flag;
+        self
+    }
+
+    #[inline]
+    fn with_skip_taskbar(mut self, skip: bool) -> Self {
+        self.platform_specific.skip_taskbar = skip;
+        self
+    }
+
+    #[inline]
+    fn with_class_name<S: Into<String>>(mut self, class_name: S) -> Self {
+        self.platform_specific.class_name = class_name.into();
+        self
+    }
+
+    #[inline]
+    fn with_undecorated_shadow(mut self, shadow: bool) -> Self {
+        self.platform_specific.decoration_shadow = shadow;
+        self
+    }
+
+    #[inline]
+    fn with_system_backdrop(mut self, backdrop_type: BackdropType) -> Self {
+        self.platform_specific.backdrop_type = backdrop_type;
+        self
+    }
+
+    #[inline]
+    fn with_clip_children(mut self, flag: bool) -> Self {
+        self.platform_specific.clip_children = flag;
+        self
+    }
+
+    #[inline]
+    fn with_border_color(mut self, color: Option<Color>) -> Self {
+        self.platform_specific.border_color = Some(color.unwrap_or(Color::NONE));
+        self
+    }
+
+    #[inline]
+    fn with_title_background_color(mut self, color: Option<Color>) -> Self {
+        self.platform_specific.title_background_color = Some(color.unwrap_or(Color::NONE));
+        self
+    }
+
+    #[inline]
+    fn with_title_text_color(mut self, color: Color) -> Self {
+        self.platform_specific.title_text_color = Some(color);
+        self
+    }
+
+    #[inline]
+    fn with_corner_preference(mut self, corners: CornerPreference) -> Self {
+        self.platform_specific.corner_preference = Some(corners);
+        self
+    }
+}
+
+/// Additional methods on `MonitorHandle` that are specific to Windows.
+pub trait MonitorHandleExtWindows {
+    /// Returns the name of the monitor adapter specific to the Win32 API.
+    fn native_id(&self) -> String;
+
+    /// Returns the handle of the monitor - `HMONITOR`.
+    fn hmonitor(&self) -> HMONITOR;
+}
+
+impl MonitorHandleExtWindows for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> String {
+        self.inner.native_identifier()
+    }
+
+    #[inline]
+    fn hmonitor(&self) -> HMONITOR {
+        self.inner.hmonitor()
+    }
+}
+
+/// Additional methods on `DeviceId` that are specific to Windows.
+pub trait DeviceIdExtWindows {
+    /// Returns an identifier that persistently refers to this specific device.
+    ///
+    /// Will return `None` if the device is no longer available.
+    fn persistent_identifier(&self) -> Option<String>;
+}
+
+impl DeviceIdExtWindows for DeviceId {
+    #[inline]
+    fn persistent_identifier(&self) -> Option<String> {
+        self.0.persistent_identifier()
+    }
+}
+
+/// Additional methods on `Icon` that are specific to Windows.
+///
+/// Windows icons can be created from files, or from the [`embedded resources`](https://learn.microsoft.com/en-us/windows/win32/menurc/about-resource-files).
+///
+/// The `ICON` resource definition statement use the following syntax:
+/// ```rc
+/// nameID ICON filename
+/// ```
+/// `nameID` is a unique name or a 16-bit unsigned integer value identifying the resource,
+/// `filename` is the name of the file that contains the resource.
+///
+/// More information about the `ICON` resource can be found at [`Microsoft Learn`](https://learn.microsoft.com/en-us/windows/win32/menurc/icon-resource) portal.
+pub trait IconExtWindows: Sized {
+    /// Create an icon from a file path.
+    ///
+    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
+    /// icon size from the file.
+    ///
+    /// In cases where the specified size does not exist in the file, Windows may perform scaling
+    /// to get an icon of the desired size.
+    fn from_path<P: AsRef<Path>>(path: P, size: Option<PhysicalSize<u32>>)
+        -> Result<Self, BadIcon>;
+
+    /// Create an icon from a resource embedded in this executable or library by its ordinal id.
+    ///
+    /// The valid `ordinal` values range from 1 to [`u16::MAX`] (inclusive). The value `0` is an
+    /// invalid ordinal id, but it can be used with [`from_resource_name`] as `"0"`.
+    ///
+    /// [`from_resource_name`]: IconExtWindows::from_resource_name
+    ///
+    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
+    /// icon size from the file.
+    ///
+    /// In cases where the specified size does not exist in the file, Windows may perform scaling
+    /// to get an icon of the desired size.
+    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
+
+    /// Create an icon from a resource embedded in this executable or library by its name.
+    ///
+    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
+    /// icon size from the file.
+    ///
+    /// In cases where the specified size does not exist in the file, Windows may perform scaling
+    /// to get an icon of the desired size.
+    ///
+    /// # Notes
+    ///
+    /// Consider the following resource definition statements:
+    /// ```rc
+    /// app     ICON "app.ico"
+    /// 1       ICON "a.ico"
+    /// 0027    ICON "custom.ico"
+    /// 0       ICON "alt.ico"
+    /// ```
+    ///
+    /// Due to some internal implementation details of the resource embedding/loading process on
+    /// Windows platform, strings that can be interpreted as 16-bit unsigned integers (`"1"`,
+    /// `"002"`, etc.) cannot be used as valid resource names, and instead should be passed into
+    /// [`from_resource`]:
+    ///
+    /// [`from_resource`]: IconExtWindows::from_resource
+    ///
+    /// ```rust,no_run
+    /// use winit::platform::windows::IconExtWindows;
+    /// use winit::window::Icon;
+    ///
+    /// assert!(Icon::from_resource_name("app", None).is_ok());
+    /// assert!(Icon::from_resource(1, None).is_ok());
+    /// assert!(Icon::from_resource(27, None).is_ok());
+    /// assert!(Icon::from_resource_name("27", None).is_err());
+    /// assert!(Icon::from_resource_name("0027", None).is_err());
+    /// ```
+    ///
+    /// While `0` cannot be used as an ordinal id (see [`from_resource`]), it can be used as a
+    /// name:
+    ///
+    /// [`from_resource`]: IconExtWindows::from_resource
+    ///
+    /// ```rust,no_run
+    /// # use winit::platform::windows::IconExtWindows;
+    /// # use winit::window::Icon;
+    /// assert!(Icon::from_resource_name("0", None).is_ok());
+    /// assert!(Icon::from_resource(0, None).is_err());
+    /// ```
+    fn from_resource_name(name: &str, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
+}
+
+impl IconExtWindows for Icon {
+    fn from_path<P: AsRef<Path>>(
+        path: P,
+        size: Option<PhysicalSize<u32>>,
+    ) -> Result<Self, BadIcon> {
+        let win_icon = crate::platform_impl::WinIcon::from_path(path, size)?;
+        Ok(Icon { inner: win_icon })
+    }
+
+    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
+        let win_icon = crate::platform_impl::WinIcon::from_resource(ordinal, size)?;
+        Ok(Icon { inner: win_icon })
+    }
+
+    fn from_resource_name(name: &str, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
+        let win_icon = crate::platform_impl::WinIcon::from_resource_name(name, size)?;
+        Ok(Icon { inner: win_icon })
+    }
+}

vendor/winit/src/platform/x11.rs

@@ -0,0 +1,254 @@
+//! # X11
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
+use crate::monitor::MonitorHandle;
+use crate::window::{Window, WindowAttributes};
+
+use crate::dpi::Size;
+
+/// X window type. Maps directly to
+/// [`_NET_WM_WINDOW_TYPE`](https://specifications.freedesktop.org/wm-spec/wm-spec-1.5.html).
+#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum WindowType {
+    /// A desktop feature. This can include a single window containing desktop icons with the same
+    /// dimensions as the screen, allowing the desktop environment to have full control of the
+    /// desktop, without the need for proxying root window clicks.
+    Desktop,
+    /// A dock or panel feature. Typically a Window Manager would keep such windows on top of all
+    /// other windows.
+    Dock,
+    /// Toolbar windows. "Torn off" from the main application.
+    Toolbar,
+    /// Pinnable menu windows. "Torn off" from the main application.
+    Menu,
+    /// A small persistent utility window, such as a palette or toolbox.
+    Utility,
+    /// The window is a splash screen displayed as an application is starting up.
+    Splash,
+    /// This is a dialog window.
+    Dialog,
+    /// A dropdown menu that usually appears when the user clicks on an item in a menu bar.
+    /// This property is typically used on override-redirect windows.
+    DropdownMenu,
+    /// A popup menu that usually appears when the user right clicks on an object.
+    /// This property is typically used on override-redirect windows.
+    PopupMenu,
+    /// A tooltip window. Usually used to show additional information when hovering over an object
+    /// with the cursor. This property is typically used on override-redirect windows.
+    Tooltip,
+    /// The window is a notification.
+    /// This property is typically used on override-redirect windows.
+    Notification,
+    /// This should be used on the windows that are popped up by combo boxes.
+    /// This property is typically used on override-redirect windows.
+    Combo,
+    /// This indicates the window is being dragged.
+    /// This property is typically used on override-redirect windows.
+    Dnd,
+    /// This is a normal, top-level window.
+    #[default]
+    Normal,
+}
+
+/// The first argument in the provided hook will be the pointer to `XDisplay`
+/// and the second one the pointer to [`XErrorEvent`]. The returned `bool` is an
+/// indicator whether the error was handled by the callback.
+///
+/// [`XErrorEvent`]: https://linux.die.net/man/3/xerrorevent
+pub type XlibErrorHook =
+    Box<dyn Fn(*mut std::ffi::c_void, *mut std::ffi::c_void) -> bool + Send + Sync>;
+
+/// A unique identifier 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 coming from X11
+/// when using xlib in external crates, like glutin for GLX access. Trying to
+/// handle errors by speculating with `XSetErrorHandler` is [`unsafe`].
+///
+/// **Be aware that your hook is always invoked and returning `true` from it will
+/// prevent `winit` from getting the error itself. It's wise to always return
+/// `false` if you're not initiated the `Sync`.**
+///
+/// [`unsafe`]: https://www.remlab.net/op/xlib.shtml
+#[inline]
+pub fn register_xlib_error_hook(hook: XlibErrorHook) {
+    // Append new hook.
+    crate::platform_impl::XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
+}
+
+/// Additional methods on [`ActiveEventLoop`] that are specific to X11.
+pub trait ActiveEventLoopExtX11 {
+    /// True if the [`ActiveEventLoop`] uses X11.
+    fn is_x11(&self) -> bool;
+}
+
+impl ActiveEventLoopExtX11 for ActiveEventLoop {
+    #[inline]
+    fn is_x11(&self) -> bool {
+        !self.p.is_wayland()
+    }
+}
+
+/// Additional methods on [`EventLoop`] that are specific to X11.
+pub trait EventLoopExtX11 {
+    /// True if the [`EventLoop`] uses X11.
+    fn is_x11(&self) -> bool;
+}
+
+impl<T: 'static> EventLoopExtX11 for EventLoop<T> {
+    #[inline]
+    fn is_x11(&self) -> bool {
+        !self.event_loop.is_wayland()
+    }
+}
+
+/// Additional methods on [`EventLoopBuilder`] that are specific to X11.
+pub trait EventLoopBuilderExtX11 {
+    /// Force using X11.
+    fn with_x11(&mut self) -> &mut Self;
+
+    /// Whether to allow the event loop to be created off of the main thread.
+    ///
+    /// By default, the window is only allowed to be created on the main
+    /// thread, to make platform compatibility easier.
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtX11 for EventLoopBuilder<T> {
+    #[inline]
+    fn with_x11(&mut self) -> &mut Self {
+        self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::X);
+        self
+    }
+
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+}
+
+/// Additional methods on [`Window`] that are specific to X11.
+pub trait WindowExtX11 {}
+
+impl WindowExtX11 for Window {}
+
+/// Additional methods on [`WindowAttributes`] that are specific to X11.
+pub trait WindowAttributesExtX11 {
+    /// Create this window with a specific X11 visual.
+    fn with_x11_visual(self, visual_id: XVisualID) -> Self;
+
+    fn with_x11_screen(self, screen_id: i32) -> Self;
+
+    /// Build window with the given `general` and `instance` names.
+    ///
+    /// The `general` sets general class of `WM_CLASS(STRING)`, while `instance` set the
+    /// instance part of it. The resulted property looks like `WM_CLASS(STRING) = "instance",
+    /// "general"`.
+    ///
+    /// For details about application ID conventions, see the
+    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
+    fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;
+
+    /// Build window with override-redirect flag; defaults to false.
+    fn with_override_redirect(self, override_redirect: bool) -> Self;
+
+    /// Build window with `_NET_WM_WINDOW_TYPE` hints; defaults to `Normal`.
+    fn with_x11_window_type(self, x11_window_type: Vec<WindowType>) -> Self;
+
+    /// Build window with base size hint.
+    ///
+    /// ```
+    /// # use winit::dpi::{LogicalSize, PhysicalSize};
+    /// # use winit::window::Window;
+    /// # use winit::platform::x11::WindowAttributesExtX11;
+    /// // Specify the size in logical dimensions like this:
+    /// Window::default_attributes().with_base_size(LogicalSize::new(400.0, 200.0));
+    ///
+    /// // Or specify the size in physical dimensions like this:
+    /// Window::default_attributes().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::Window;
+    /// use winit::event_loop::ActiveEventLoop;
+    /// use winit::platform::x11::{XWindow, WindowAttributesExtX11};
+    /// # fn create_window(event_loop: &ActiveEventLoop) -> Result<(), Box<dyn std::error::Error>> {
+    /// let parent_window_id = std::env::args().nth(1).unwrap().parse::<XWindow>()?;
+    /// let window_attributes = Window::default_attributes().with_embed_parent_window(parent_window_id);
+    /// let window = event_loop.create_window(window_attributes)?;
+    /// # Ok(()) }
+    /// ```
+    fn with_embed_parent_window(self, parent_window_id: XWindow) -> Self;
+}
+
+impl WindowAttributesExtX11 for WindowAttributes {
+    #[inline]
+    fn with_x11_visual(mut self, visual_id: XVisualID) -> Self {
+        self.platform_specific.x11.visual_id = Some(visual_id);
+        self
+    }
+
+    #[inline]
+    fn with_x11_screen(mut self, screen_id: i32) -> Self {
+        self.platform_specific.x11.screen_id = Some(screen_id);
+        self
+    }
+
+    #[inline]
+    fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
+        self.platform_specific.name =
+            Some(crate::platform_impl::ApplicationName::new(general.into(), instance.into()));
+        self
+    }
+
+    #[inline]
+    fn with_override_redirect(mut self, override_redirect: bool) -> Self {
+        self.platform_specific.x11.override_redirect = override_redirect;
+        self
+    }
+
+    #[inline]
+    fn with_x11_window_type(mut self, x11_window_types: Vec<WindowType>) -> Self {
+        self.platform_specific.x11.x11_window_types = x11_window_types;
+        self
+    }
+
+    #[inline]
+    fn with_base_size<S: Into<Size>>(mut self, base_size: S) -> Self {
+        self.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
+    }
+}
+
+/// Additional methods on `MonitorHandle` that are specific to X11.
+pub trait MonitorHandleExtX11 {
+    /// Returns the inner identifier of the monitor.
+    fn native_id(&self) -> u32;
+}
+
+impl MonitorHandleExtX11 for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+}

vendor/winit/src/platform_impl/android/keycodes.rs

@@ -0,0 +1,608 @@
+use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
+use android_activity::AndroidApp;
+
+use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
+
+pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
+    PhysicalKey::Code(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 => return PhysicalKey::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) => {
+            tracing::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) => {
+                            tracing::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) => {
+            tracing::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])),
+        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::Named(NamedKey::BrowserHome),
+            Back => Key::Named(NamedKey::BrowserBack),
+            Call => Key::Named(NamedKey::Call),
+            Endcall => Key::Named(NamedKey::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::Named(NamedKey::ArrowUp),
+            DpadDown => Key::Named(NamedKey::ArrowDown),
+            DpadLeft => Key::Named(NamedKey::ArrowLeft),
+            DpadRight => Key::Named(NamedKey::ArrowRight),
+            DpadCenter => Key::Named(NamedKey::Enter),
+
+            VolumeUp => Key::Named(NamedKey::AudioVolumeUp),
+            VolumeDown => Key::Named(NamedKey::AudioVolumeDown),
+            Power => Key::Named(NamedKey::Power),
+            Camera => Key::Named(NamedKey::Camera),
+            Clear => Key::Named(NamedKey::Clear),
+
+            AltLeft => Key::Named(NamedKey::Alt),
+            AltRight => Key::Named(NamedKey::Alt),
+            ShiftLeft => Key::Named(NamedKey::Shift),
+            ShiftRight => Key::Named(NamedKey::Shift),
+            Tab => Key::Named(NamedKey::Tab),
+            Space => Key::Named(NamedKey::Space),
+            Sym => Key::Named(NamedKey::Symbol),
+            Explorer => Key::Named(NamedKey::LaunchWebBrowser),
+            Envelope => Key::Named(NamedKey::LaunchMail),
+            Enter => Key::Named(NamedKey::Enter),
+            Del => Key::Named(NamedKey::Backspace),
+
+            // According to https://developer.android.com/reference/android/view/KeyEvent#KEYCODE_NUM
+            Num => Key::Named(NamedKey::Alt),
+
+            Headsethook => Key::Named(NamedKey::HeadsetHook),
+            Focus => Key::Named(NamedKey::CameraFocus),
+
+            Notification => Key::Named(NamedKey::Notification),
+            Search => Key::Named(NamedKey::BrowserSearch),
+            MediaPlayPause => Key::Named(NamedKey::MediaPlayPause),
+            MediaStop => Key::Named(NamedKey::MediaStop),
+            MediaNext => Key::Named(NamedKey::MediaTrackNext),
+            MediaPrevious => Key::Named(NamedKey::MediaTrackPrevious),
+            MediaRewind => Key::Named(NamedKey::MediaRewind),
+            MediaFastForward => Key::Named(NamedKey::MediaFastForward),
+            Mute => Key::Named(NamedKey::MicrophoneVolumeMute),
+            PageUp => Key::Named(NamedKey::PageUp),
+            PageDown => Key::Named(NamedKey::PageDown),
+
+            Escape => Key::Named(NamedKey::Escape),
+            ForwardDel => Key::Named(NamedKey::Delete),
+            CtrlLeft => Key::Named(NamedKey::Control),
+            CtrlRight => Key::Named(NamedKey::Control),
+            CapsLock => Key::Named(NamedKey::CapsLock),
+            ScrollLock => Key::Named(NamedKey::ScrollLock),
+            MetaLeft => Key::Named(NamedKey::Super),
+            MetaRight => Key::Named(NamedKey::Super),
+            Function => Key::Named(NamedKey::Fn),
+            Sysrq => Key::Named(NamedKey::PrintScreen),
+            Break => Key::Named(NamedKey::Pause),
+            MoveHome => Key::Named(NamedKey::Home),
+            MoveEnd => Key::Named(NamedKey::End),
+            Insert => Key::Named(NamedKey::Insert),
+            Forward => Key::Named(NamedKey::BrowserForward),
+            MediaPlay => Key::Named(NamedKey::MediaPlay),
+            MediaPause => Key::Named(NamedKey::MediaPause),
+            MediaClose => Key::Named(NamedKey::MediaClose),
+            MediaEject => Key::Named(NamedKey::Eject),
+            MediaRecord => Key::Named(NamedKey::MediaRecord),
+            F1 => Key::Named(NamedKey::F1),
+            F2 => Key::Named(NamedKey::F2),
+            F3 => Key::Named(NamedKey::F3),
+            F4 => Key::Named(NamedKey::F4),
+            F5 => Key::Named(NamedKey::F5),
+            F6 => Key::Named(NamedKey::F6),
+            F7 => Key::Named(NamedKey::F7),
+            F8 => Key::Named(NamedKey::F8),
+            F9 => Key::Named(NamedKey::F9),
+            F10 => Key::Named(NamedKey::F10),
+            F11 => Key::Named(NamedKey::F11),
+            F12 => Key::Named(NamedKey::F12),
+            NumLock => Key::Named(NamedKey::NumLock),
+            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::Named(NamedKey::Enter),
+            NumpadEquals => Key::Character("=".into()),
+            NumpadLeftParen => Key::Character("(".into()),
+            NumpadRightParen => Key::Character(")".into()),
+
+            VolumeMute => Key::Named(NamedKey::AudioVolumeMute),
+            Info => Key::Named(NamedKey::Info),
+            ChannelUp => Key::Named(NamedKey::ChannelUp),
+            ChannelDown => Key::Named(NamedKey::ChannelDown),
+            ZoomIn => Key::Named(NamedKey::ZoomIn),
+            ZoomOut => Key::Named(NamedKey::ZoomOut),
+            Tv => Key::Named(NamedKey::TV),
+            Guide => Key::Named(NamedKey::Guide),
+            Dvr => Key::Named(NamedKey::DVR),
+            Bookmark => Key::Named(NamedKey::BrowserFavorites),
+            Captions => Key::Named(NamedKey::ClosedCaptionToggle),
+            Settings => Key::Named(NamedKey::Settings),
+            TvPower => Key::Named(NamedKey::TVPower),
+            TvInput => Key::Named(NamedKey::TVInput),
+            StbPower => Key::Named(NamedKey::STBPower),
+            StbInput => Key::Named(NamedKey::STBInput),
+            AvrPower => Key::Named(NamedKey::AVRPower),
+            AvrInput => Key::Named(NamedKey::AVRInput),
+            ProgRed => Key::Named(NamedKey::ColorF0Red),
+            ProgGreen => Key::Named(NamedKey::ColorF1Green),
+            ProgYellow => Key::Named(NamedKey::ColorF2Yellow),
+            ProgBlue => Key::Named(NamedKey::ColorF3Blue),
+            AppSwitch => Key::Named(NamedKey::AppSwitch),
+            LanguageSwitch => Key::Named(NamedKey::GroupNext),
+            MannerMode => Key::Named(NamedKey::MannerMode),
+            Keycode3dMode => Key::Named(NamedKey::TV3DMode),
+            Contacts => Key::Named(NamedKey::LaunchContacts),
+            Calendar => Key::Named(NamedKey::LaunchCalendar),
+            Music => Key::Named(NamedKey::LaunchMusicPlayer),
+            Calculator => Key::Named(NamedKey::LaunchApplication2),
+            ZenkakuHankaku => Key::Named(NamedKey::ZenkakuHankaku),
+            Eisu => Key::Named(NamedKey::Eisu),
+            Muhenkan => Key::Named(NamedKey::NonConvert),
+            Henkan => Key::Named(NamedKey::Convert),
+            KatakanaHiragana => Key::Named(NamedKey::HiraganaKatakana),
+            Kana => Key::Named(NamedKey::KanjiMode),
+            BrightnessDown => Key::Named(NamedKey::BrightnessDown),
+            BrightnessUp => Key::Named(NamedKey::BrightnessUp),
+            MediaAudioTrack => Key::Named(NamedKey::MediaAudioTrack),
+            Sleep => Key::Named(NamedKey::Standby),
+            Wakeup => Key::Named(NamedKey::WakeUp),
+            Pairing => Key::Named(NamedKey::Pairing),
+            MediaTopMenu => Key::Named(NamedKey::MediaTopMenu),
+            LastChannel => Key::Named(NamedKey::MediaLast),
+            TvDataService => Key::Named(NamedKey::TVDataService),
+            VoiceAssist => Key::Named(NamedKey::VoiceDial),
+            TvRadioService => Key::Named(NamedKey::TVRadioService),
+            TvTeletext => Key::Named(NamedKey::Teletext),
+            TvNumberEntry => Key::Named(NamedKey::TVNumberEntry),
+            TvTerrestrialAnalog => Key::Named(NamedKey::TVTerrestrialAnalog),
+            TvTerrestrialDigital => Key::Named(NamedKey::TVTerrestrialDigital),
+            TvSatellite => Key::Named(NamedKey::TVSatellite),
+            TvSatelliteBs => Key::Named(NamedKey::TVSatelliteBS),
+            TvSatelliteCs => Key::Named(NamedKey::TVSatelliteCS),
+            TvSatelliteService => Key::Named(NamedKey::TVSatelliteToggle),
+            TvNetwork => Key::Named(NamedKey::TVNetwork),
+            TvAntennaCable => Key::Named(NamedKey::TVAntennaCable),
+            TvInputHdmi1 => Key::Named(NamedKey::TVInputHDMI1),
+            TvInputHdmi2 => Key::Named(NamedKey::TVInputHDMI2),
+            TvInputHdmi3 => Key::Named(NamedKey::TVInputHDMI3),
+            TvInputHdmi4 => Key::Named(NamedKey::TVInputHDMI4),
+            TvInputComposite1 => Key::Named(NamedKey::TVInputComposite1),
+            TvInputComposite2 => Key::Named(NamedKey::TVInputComposite2),
+            TvInputComponent1 => Key::Named(NamedKey::TVInputComponent1),
+            TvInputComponent2 => Key::Named(NamedKey::TVInputComponent2),
+            TvInputVga1 => Key::Named(NamedKey::TVInputVGA1),
+            TvAudioDescription => Key::Named(NamedKey::TVAudioDescription),
+            TvAudioDescriptionMixUp => Key::Named(NamedKey::TVAudioDescriptionMixUp),
+            TvAudioDescriptionMixDown => Key::Named(NamedKey::TVAudioDescriptionMixDown),
+            TvZoomMode => Key::Named(NamedKey::ZoomToggle),
+            TvContentsMenu => Key::Named(NamedKey::TVContentsMenu),
+            TvMediaContextMenu => Key::Named(NamedKey::TVMediaContext),
+            TvTimerProgramming => Key::Named(NamedKey::TVTimer),
+            Help => Key::Named(NamedKey::Help),
+            NavigatePrevious => Key::Named(NamedKey::NavigatePrevious),
+            NavigateNext => Key::Named(NamedKey::NavigateNext),
+            NavigateIn => Key::Named(NamedKey::NavigateIn),
+            NavigateOut => Key::Named(NamedKey::NavigateOut),
+            MediaSkipForward => Key::Named(NamedKey::MediaSkipForward),
+            MediaSkipBackward => Key::Named(NamedKey::MediaSkipBackward),
+            MediaStepForward => Key::Named(NamedKey::MediaStepForward),
+            MediaStepBackward => Key::Named(NamedKey::MediaStepBackward),
+            Cut => Key::Named(NamedKey::Cut),
+            Copy => Key::Named(NamedKey::Copy),
+            Paste => Key::Named(NamedKey::Paste),
+            Refresh => Key::Named(NamedKey::BrowserRefresh),
+
+            // -----------------------------------------------------------------
+            // 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),
+
+            // It's always possible that new versions of Android could introduce
+            // key codes we can't know about at compile time.
+            _ => 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,
+    }
+}

vendor/winit/src/platform_impl/ios/app_state.rs

@@ -0,0 +1,925 @@
+#![deny(unused_results)]
+
+use std::cell::{RefCell, RefMut};
+use std::collections::HashSet;
+use std::os::raw::c_void;
+use std::sync::{Arc, Mutex, OnceLock};
+use std::time::Instant;
+use std::{fmt, mem, ptr};
+
+use core_foundation::base::CFRelease;
+use core_foundation::date::CFAbsoluteTimeGetCurrent;
+use core_foundation::runloop::{
+    kCFRunLoopCommonModes, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
+    CFRunLoopTimerInvalidate, CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate,
+};
+use objc2::rc::Retained;
+use objc2::runtime::AnyObject;
+use objc2::{msg_send, sel};
+use objc2_foundation::{
+    CGRect, CGSize, MainThreadMarker, NSInteger, NSObjectProtocol, NSOperatingSystemVersion,
+    NSProcessInfo,
+};
+use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView, UIWindow};
+
+use super::window::WinitUIWindow;
+use crate::dpi::PhysicalSize;
+use crate::event::{Event, InnerSizeWriter, StartCause, WindowEvent};
+use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
+use crate::window::WindowId as RootWindowId;
+
+macro_rules! bug {
+    ($($msg:tt)*) => {
+        panic!("winit iOS bug, file an issue: {}", format!($($msg)*))
+    };
+}
+
+macro_rules! bug_assert {
+    ($test:expr, $($msg:tt)*) => {
+        assert!($test, "winit iOS bug, file an issue: {}", format!($($msg)*))
+    };
+}
+
+#[derive(Debug)]
+pub(crate) struct HandlePendingUserEvents;
+
+pub(crate) struct EventLoopHandler {
+    #[allow(clippy::type_complexity)]
+    pub(crate) handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
+    pub(crate) event_loop: RootActiveEventLoop,
+}
+
+impl fmt::Debug for EventLoopHandler {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventLoopHandler")
+            .field("handler", &"...")
+            .field("event_loop", &self.event_loop)
+            .finish()
+    }
+}
+
+impl EventLoopHandler {
+    fn handle_event(&mut self, event: Event<HandlePendingUserEvents>) {
+        (self.handler)(event, &self.event_loop)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) enum EventWrapper {
+    StaticEvent(Event<HandlePendingUserEvents>),
+    ScaleFactorChanged(ScaleFactorChanged),
+}
+
+#[derive(Debug)]
+pub struct ScaleFactorChanged {
+    pub(super) window: Retained<WinitUIWindow>,
+    pub(super) suggested_size: PhysicalSize<u32>,
+    pub(super) scale_factor: f64,
+}
+
+enum UserCallbackTransitionResult<'a> {
+    Success {
+        handler: EventLoopHandler,
+        active_control_flow: ControlFlow,
+        processing_redraws: bool,
+    },
+    ReentrancyPrevented {
+        queued_events: &'a mut Vec<EventWrapper>,
+    },
+}
+
+impl Event<HandlePendingUserEvents> {
+    fn is_redraw(&self) -> bool {
+        matches!(self, Event::WindowEvent { event: WindowEvent::RedrawRequested, .. })
+    }
+}
+
+// this is the state machine for the app lifecycle
+#[derive(Debug)]
+#[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"]
+enum AppStateImpl {
+    NotLaunched {
+        queued_windows: Vec<Retained<WinitUIWindow>>,
+        queued_events: Vec<EventWrapper>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
+    },
+    Launching {
+        queued_windows: Vec<Retained<WinitUIWindow>>,
+        queued_events: Vec<EventWrapper>,
+        queued_handler: EventLoopHandler,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
+    },
+    ProcessingEvents {
+        handler: EventLoopHandler,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
+        active_control_flow: ControlFlow,
+    },
+    // special state to deal with reentrancy and prevent mutable aliasing.
+    InUserCallback {
+        queued_events: Vec<EventWrapper>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
+    },
+    ProcessingRedraws {
+        handler: EventLoopHandler,
+        active_control_flow: ControlFlow,
+    },
+    Waiting {
+        waiting_handler: EventLoopHandler,
+        start: Instant,
+    },
+    PollFinished {
+        waiting_handler: EventLoopHandler,
+    },
+    Terminated,
+}
+
+pub(crate) struct AppState {
+    // This should never be `None`, except for briefly during a state transition.
+    app_state: Option<AppStateImpl>,
+    control_flow: ControlFlow,
+    waker: EventLoopWaker,
+}
+
+impl AppState {
+    pub(crate) fn get_mut(_mtm: MainThreadMarker) -> RefMut<'static, AppState> {
+        // basically everything in UIKit requires the main thread, so it's pointless to use the
+        // std::sync APIs.
+        // must be mut because plain `static` requires `Sync`
+        static mut APP_STATE: RefCell<Option<AppState>> = RefCell::new(None);
+
+        #[allow(unknown_lints)] // New lint below
+        #[allow(static_mut_refs)] // TODO: Use `MainThreadBound` instead.
+        let mut guard = unsafe { APP_STATE.borrow_mut() };
+        if guard.is_none() {
+            #[inline(never)]
+            #[cold]
+            fn init_guard(guard: &mut RefMut<'static, Option<AppState>>) {
+                let waker = EventLoopWaker::new(unsafe { CFRunLoopGetMain() });
+                **guard = Some(AppState {
+                    app_state: Some(AppStateImpl::NotLaunched {
+                        queued_windows: Vec::new(),
+                        queued_events: Vec::new(),
+                        queued_gpu_redraws: HashSet::new(),
+                    }),
+                    control_flow: ControlFlow::default(),
+                    waker,
+                });
+            }
+            init_guard(&mut guard);
+        }
+        RefMut::map(guard, |state| state.as_mut().unwrap())
+    }
+
+    fn state(&self) -> &AppStateImpl {
+        match &self.app_state {
+            Some(ref state) => state,
+            None => bug!("`AppState` previously failed a state transition"),
+        }
+    }
+
+    fn state_mut(&mut self) -> &mut AppStateImpl {
+        match &mut self.app_state {
+            Some(ref mut state) => state,
+            None => bug!("`AppState` previously failed a state transition"),
+        }
+    }
+
+    fn take_state(&mut self) -> AppStateImpl {
+        match self.app_state.take() {
+            Some(state) => state,
+            None => bug!("`AppState` previously failed a state transition"),
+        }
+    }
+
+    fn set_state(&mut self, new_state: AppStateImpl) {
+        bug_assert!(
+            self.app_state.is_none(),
+            "attempted to set an `AppState` without calling `take_state` first {:?}",
+            self.app_state
+        );
+        self.app_state = Some(new_state)
+    }
+
+    fn replace_state(&mut self, new_state: AppStateImpl) -> AppStateImpl {
+        match &mut self.app_state {
+            Some(ref mut state) => mem::replace(state, new_state),
+            None => bug!("`AppState` previously failed a state transition"),
+        }
+    }
+
+    fn has_launched(&self) -> bool {
+        !matches!(self.state(), AppStateImpl::NotLaunched { .. } | AppStateImpl::Launching { .. })
+    }
+
+    fn has_terminated(&self) -> bool {
+        matches!(self.state(), AppStateImpl::Terminated)
+    }
+
+    fn will_launch_transition(&mut self, queued_handler: EventLoopHandler) {
+        let (queued_windows, queued_events, queued_gpu_redraws) = match self.take_state() {
+            AppStateImpl::NotLaunched { queued_windows, queued_events, queued_gpu_redraws } => {
+                (queued_windows, queued_events, queued_gpu_redraws)
+            },
+            s => bug!("unexpected state {:?}", s),
+        };
+        self.set_state(AppStateImpl::Launching {
+            queued_windows,
+            queued_events,
+            queued_handler,
+            queued_gpu_redraws,
+        });
+    }
+
+    fn did_finish_launching_transition(
+        &mut self,
+    ) -> (Vec<Retained<WinitUIWindow>>, Vec<EventWrapper>) {
+        let (windows, events, handler, queued_gpu_redraws) = match self.take_state() {
+            AppStateImpl::Launching {
+                queued_windows,
+                queued_events,
+                queued_handler,
+                queued_gpu_redraws,
+            } => (queued_windows, queued_events, queued_handler, queued_gpu_redraws),
+            s => bug!("unexpected state {:?}", s),
+        };
+        self.set_state(AppStateImpl::ProcessingEvents {
+            handler,
+            active_control_flow: self.control_flow,
+            queued_gpu_redraws,
+        });
+        (windows, events)
+    }
+
+    fn wakeup_transition(&mut self) -> Option<EventWrapper> {
+        // before `AppState::did_finish_launching` is called, pretend there is no running
+        // event loop.
+        if !self.has_launched() || self.has_terminated() {
+            return None;
+        }
+
+        let (handler, event) = match (self.control_flow, self.take_state()) {
+            (ControlFlow::Poll, AppStateImpl::PollFinished { waiting_handler }) => {
+                (waiting_handler, EventWrapper::StaticEvent(Event::NewEvents(StartCause::Poll)))
+            },
+            (ControlFlow::Wait, AppStateImpl::Waiting { waiting_handler, start }) => (
+                waiting_handler,
+                EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled {
+                    start,
+                    requested_resume: None,
+                })),
+            ),
+            (
+                ControlFlow::WaitUntil(requested_resume),
+                AppStateImpl::Waiting { waiting_handler, start },
+            ) => {
+                let event = if Instant::now() >= requested_resume {
+                    EventWrapper::StaticEvent(Event::NewEvents(StartCause::ResumeTimeReached {
+                        start,
+                        requested_resume,
+                    }))
+                } else {
+                    EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled {
+                        start,
+                        requested_resume: Some(requested_resume),
+                    }))
+                };
+                (waiting_handler, event)
+            },
+            s => bug!("`EventHandler` unexpectedly woke up {:?}", s),
+        };
+
+        self.set_state(AppStateImpl::ProcessingEvents {
+            handler,
+            queued_gpu_redraws: Default::default(),
+            active_control_flow: self.control_flow,
+        });
+        Some(event)
+    }
+
+    fn try_user_callback_transition(&mut self) -> UserCallbackTransitionResult<'_> {
+        // If we're not able to process an event due to recursion or `Init` not having been sent out
+        // yet, then queue the events up.
+        match self.state_mut() {
+            &mut AppStateImpl::Launching { ref mut queued_events, .. }
+            | &mut AppStateImpl::NotLaunched { ref mut queued_events, .. }
+            | &mut AppStateImpl::InUserCallback { ref mut queued_events, .. } => {
+                // A lifetime cast: early returns are not currently handled well with NLL, but
+                // polonius handles them well. This transmute is a safe workaround.
+                return unsafe {
+                    mem::transmute::<
+                        UserCallbackTransitionResult<'_>,
+                        UserCallbackTransitionResult<'_>,
+                    >(UserCallbackTransitionResult::ReentrancyPrevented {
+                        queued_events,
+                    })
+                };
+            },
+
+            &mut AppStateImpl::ProcessingEvents { .. }
+            | &mut AppStateImpl::ProcessingRedraws { .. } => {},
+
+            s @ &mut AppStateImpl::PollFinished { .. }
+            | s @ &mut AppStateImpl::Waiting { .. }
+            | s @ &mut AppStateImpl::Terminated => {
+                bug!("unexpected attempted to process an event {:?}", s)
+            },
+        }
+
+        let (handler, queued_gpu_redraws, active_control_flow, processing_redraws) = match self
+            .take_state()
+        {
+            AppStateImpl::Launching { .. }
+            | AppStateImpl::NotLaunched { .. }
+            | AppStateImpl::InUserCallback { .. } => unreachable!(),
+            AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow } => {
+                (handler, queued_gpu_redraws, active_control_flow, false)
+            },
+            AppStateImpl::ProcessingRedraws { handler, active_control_flow } => {
+                (handler, Default::default(), active_control_flow, true)
+            },
+            AppStateImpl::PollFinished { .. }
+            | AppStateImpl::Waiting { .. }
+            | AppStateImpl::Terminated => unreachable!(),
+        };
+        self.set_state(AppStateImpl::InUserCallback {
+            queued_events: Vec::new(),
+            queued_gpu_redraws,
+        });
+        UserCallbackTransitionResult::Success { handler, active_control_flow, processing_redraws }
+    }
+
+    fn main_events_cleared_transition(&mut self) -> HashSet<Retained<WinitUIWindow>> {
+        let (handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
+            AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow } => {
+                (handler, queued_gpu_redraws, active_control_flow)
+            },
+            s => bug!("unexpected state {:?}", s),
+        };
+        self.set_state(AppStateImpl::ProcessingRedraws { handler, active_control_flow });
+        queued_gpu_redraws
+    }
+
+    fn events_cleared_transition(&mut self) {
+        if !self.has_launched() || self.has_terminated() {
+            return;
+        }
+        let (waiting_handler, old) = match self.take_state() {
+            AppStateImpl::ProcessingRedraws { handler, active_control_flow } => {
+                (handler, active_control_flow)
+            },
+            s => bug!("unexpected state {:?}", s),
+        };
+
+        let new = self.control_flow;
+        match (old, new) {
+            (ControlFlow::Wait, ControlFlow::Wait) => {
+                let start = Instant::now();
+                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+                self.waker.stop()
+            },
+            (ControlFlow::WaitUntil(old_instant), ControlFlow::WaitUntil(new_instant))
+                if old_instant == new_instant =>
+            {
+                let start = Instant::now();
+                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+            },
+            (_, ControlFlow::Wait) => {
+                let start = Instant::now();
+                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+                self.waker.stop()
+            },
+            (_, ControlFlow::WaitUntil(new_instant)) => {
+                let start = Instant::now();
+                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+                self.waker.start_at(new_instant)
+            },
+            // Unlike on macOS, handle Poll to Poll transition here to call the waker
+            (_, ControlFlow::Poll) => {
+                self.set_state(AppStateImpl::PollFinished { waiting_handler });
+                self.waker.start()
+            },
+        }
+    }
+
+    fn terminated_transition(&mut self) -> EventLoopHandler {
+        match self.replace_state(AppStateImpl::Terminated) {
+            AppStateImpl::ProcessingEvents { handler, .. } => handler,
+            s => bug!("`LoopExiting` happened while not processing events {:?}", s),
+        }
+    }
+
+    pub(crate) fn set_control_flow(&mut self, control_flow: ControlFlow) {
+        self.control_flow = control_flow;
+    }
+
+    pub(crate) fn control_flow(&self) -> ControlFlow {
+        self.control_flow
+    }
+}
+
+pub(crate) fn set_key_window(mtm: MainThreadMarker, window: &Retained<WinitUIWindow>) {
+    let mut this = AppState::get_mut(mtm);
+    match this.state_mut() {
+        &mut AppStateImpl::NotLaunched { ref mut queued_windows, .. } => {
+            return queued_windows.push(window.clone())
+        },
+        &mut AppStateImpl::ProcessingEvents { .. }
+        | &mut AppStateImpl::InUserCallback { .. }
+        | &mut AppStateImpl::ProcessingRedraws { .. } => {},
+        s @ &mut AppStateImpl::Launching { .. }
+        | s @ &mut AppStateImpl::Waiting { .. }
+        | s @ &mut AppStateImpl::PollFinished { .. } => bug!("unexpected state {:?}", s),
+        &mut AppStateImpl::Terminated => {
+            panic!("Attempt to create a `Window` after the app has terminated")
+        },
+    }
+    drop(this);
+    window.makeKeyAndVisible();
+}
+
+pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Retained<WinitUIWindow>) {
+    let mut this = AppState::get_mut(mtm);
+    match this.state_mut() {
+        &mut AppStateImpl::NotLaunched { ref mut queued_gpu_redraws, .. }
+        | &mut AppStateImpl::Launching { ref mut queued_gpu_redraws, .. }
+        | &mut AppStateImpl::ProcessingEvents { ref mut queued_gpu_redraws, .. }
+        | &mut AppStateImpl::InUserCallback { ref mut queued_gpu_redraws, .. } => {
+            let _ = queued_gpu_redraws.insert(window);
+        },
+        s @ &mut AppStateImpl::ProcessingRedraws { .. }
+        | s @ &mut AppStateImpl::Waiting { .. }
+        | s @ &mut AppStateImpl::PollFinished { .. } => bug!("unexpected state {:?}", s),
+        &mut AppStateImpl::Terminated => {
+            panic!("Attempt to create a `Window` after the app has terminated")
+        },
+    }
+}
+
+pub(crate) fn will_launch(mtm: MainThreadMarker, queued_handler: EventLoopHandler) {
+    AppState::get_mut(mtm).will_launch_transition(queued_handler)
+}
+
+pub fn did_finish_launching(mtm: MainThreadMarker) {
+    let mut this = AppState::get_mut(mtm);
+    let windows = match this.state_mut() {
+        AppStateImpl::Launching { queued_windows, .. } => mem::take(queued_windows),
+        s => bug!("unexpected state {:?}", s),
+    };
+
+    this.waker.start();
+
+    // have to drop RefMut because the window setup code below can trigger new events
+    drop(this);
+
+    for window in windows {
+        // Do a little screen dance here to account for windows being created before
+        // `UIApplicationMain` is called. This fixes visual issues such as being
+        // offcenter and sized incorrectly. Additionally, to fix orientation issues, we
+        // gotta reset the `rootViewController`.
+        //
+        // relevant iOS log:
+        // ```
+        // [ApplicationLifecycle] Windows were created before application initialization
+        // completed. This may result in incorrect visual appearance.
+        // ```
+        let screen = window.screen();
+        let _: () = unsafe { msg_send![&window, setScreen: ptr::null::<AnyObject>()] };
+        window.setScreen(&screen);
+
+        let controller = window.rootViewController();
+        window.setRootViewController(None);
+        window.setRootViewController(controller.as_deref());
+
+        window.makeKeyAndVisible();
+    }
+
+    let (windows, events) = AppState::get_mut(mtm).did_finish_launching_transition();
+
+    let events = std::iter::once(EventWrapper::StaticEvent(Event::NewEvents(StartCause::Init)))
+        .chain(events);
+    handle_nonuser_events(mtm, events);
+
+    // the above window dance hack, could possibly trigger new windows to be created.
+    // we can just set those windows up normally, as they were created after didFinishLaunching
+    for window in windows {
+        window.makeKeyAndVisible();
+    }
+}
+
+// AppState::did_finish_launching handles the special transition `Init`
+pub fn handle_wakeup_transition(mtm: MainThreadMarker) {
+    let mut this = AppState::get_mut(mtm);
+    let wakeup_event = match this.wakeup_transition() {
+        None => return,
+        Some(wakeup_event) => wakeup_event,
+    };
+    drop(this);
+
+    handle_nonuser_event(mtm, wakeup_event)
+}
+
+pub(crate) fn handle_nonuser_event(mtm: MainThreadMarker, event: EventWrapper) {
+    handle_nonuser_events(mtm, std::iter::once(event))
+}
+
+pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
+    mtm: MainThreadMarker,
+    events: I,
+) {
+    let mut this = AppState::get_mut(mtm);
+    if this.has_terminated() {
+        return;
+    }
+
+    let (mut handler, active_control_flow, processing_redraws) =
+        match this.try_user_callback_transition() {
+            UserCallbackTransitionResult::ReentrancyPrevented { queued_events } => {
+                queued_events.extend(events);
+                return;
+            },
+            UserCallbackTransitionResult::Success {
+                handler,
+                active_control_flow,
+                processing_redraws,
+            } => (handler, active_control_flow, processing_redraws),
+        };
+    drop(this);
+
+    for wrapper in events {
+        match wrapper {
+            EventWrapper::StaticEvent(event) => {
+                if !processing_redraws && event.is_redraw() {
+                    tracing::info!("processing `RedrawRequested` during the main event loop");
+                } else if processing_redraws && !event.is_redraw() {
+                    tracing::warn!(
+                        "processing non `RedrawRequested` event after the main event loop: {:#?}",
+                        event
+                    );
+                }
+                handler.handle_event(event)
+            },
+            EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
+        }
+    }
+
+    loop {
+        let mut this = AppState::get_mut(mtm);
+        let queued_events = match this.state_mut() {
+            &mut AppStateImpl::InUserCallback { ref mut queued_events, queued_gpu_redraws: _ } => {
+                mem::take(queued_events)
+            },
+            s => bug!("unexpected state {:?}", s),
+        };
+        if queued_events.is_empty() {
+            let queued_gpu_redraws = match this.take_state() {
+                AppStateImpl::InUserCallback { queued_events: _, queued_gpu_redraws } => {
+                    queued_gpu_redraws
+                },
+                _ => unreachable!(),
+            };
+            this.app_state = Some(if processing_redraws {
+                bug_assert!(
+                    queued_gpu_redraws.is_empty(),
+                    "redraw queued while processing redraws"
+                );
+                AppStateImpl::ProcessingRedraws { handler, active_control_flow }
+            } else {
+                AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow }
+            });
+            break;
+        }
+        drop(this);
+
+        for wrapper in queued_events {
+            match wrapper {
+                EventWrapper::StaticEvent(event) => {
+                    if !processing_redraws && event.is_redraw() {
+                        tracing::info!("processing `RedrawRequested` during the main event loop");
+                    } else if processing_redraws && !event.is_redraw() {
+                        tracing::warn!(
+                            "processing non-`RedrawRequested` event after the main event loop: \
+                             {:#?}",
+                            event
+                        );
+                    }
+                    handler.handle_event(event)
+                },
+                EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
+            }
+        }
+    }
+}
+
+fn handle_user_events(mtm: MainThreadMarker) {
+    let mut this = AppState::get_mut(mtm);
+    let (mut handler, active_control_flow, processing_redraws) =
+        match this.try_user_callback_transition() {
+            UserCallbackTransitionResult::ReentrancyPrevented { .. } => {
+                bug!("unexpected attempted to process an event")
+            },
+            UserCallbackTransitionResult::Success {
+                handler,
+                active_control_flow,
+                processing_redraws,
+            } => (handler, active_control_flow, processing_redraws),
+        };
+    if processing_redraws {
+        bug!("user events attempted to be sent out while `ProcessingRedraws`");
+    }
+    drop(this);
+
+    handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
+
+    loop {
+        let mut this = AppState::get_mut(mtm);
+        let queued_events = match this.state_mut() {
+            &mut AppStateImpl::InUserCallback { ref mut queued_events, queued_gpu_redraws: _ } => {
+                mem::take(queued_events)
+            },
+            s => bug!("unexpected state {:?}", s),
+        };
+        if queued_events.is_empty() {
+            let queued_gpu_redraws = match this.take_state() {
+                AppStateImpl::InUserCallback { queued_events: _, queued_gpu_redraws } => {
+                    queued_gpu_redraws
+                },
+                _ => unreachable!(),
+            };
+            this.app_state = Some(AppStateImpl::ProcessingEvents {
+                handler,
+                queued_gpu_redraws,
+                active_control_flow,
+            });
+            break;
+        }
+        drop(this);
+
+        for wrapper in queued_events {
+            match wrapper {
+                EventWrapper::StaticEvent(event) => handler.handle_event(event),
+                EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
+            }
+        }
+
+        handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
+    }
+}
+
+pub(crate) fn send_occluded_event_for_all_windows(application: &UIApplication, occluded: bool) {
+    let mtm = MainThreadMarker::from(application);
+
+    let mut events = Vec::new();
+    #[allow(deprecated)]
+    for window in application.windows().iter() {
+        if window.is_kind_of::<WinitUIWindow>() {
+            // SAFETY: We just checked that the window is a `winit` window
+            let window = unsafe {
+                let ptr: *const UIWindow = window;
+                let ptr: *const WinitUIWindow = ptr.cast();
+                &*ptr
+            };
+            events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::Occluded(occluded),
+            }));
+        }
+    }
+    handle_nonuser_events(mtm, events);
+}
+
+pub fn handle_main_events_cleared(mtm: MainThreadMarker) {
+    let mut this = AppState::get_mut(mtm);
+    if !this.has_launched() || this.has_terminated() {
+        return;
+    }
+    match this.state_mut() {
+        AppStateImpl::ProcessingEvents { .. } => {},
+        _ => bug!("`ProcessingRedraws` happened unexpectedly"),
+    };
+    drop(this);
+
+    handle_user_events(mtm);
+
+    let mut this = AppState::get_mut(mtm);
+    let redraw_events: Vec<EventWrapper> = this
+        .main_events_cleared_transition()
+        .into_iter()
+        .map(|window| {
+            EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::RedrawRequested,
+            })
+        })
+        .collect();
+    drop(this);
+
+    handle_nonuser_events(mtm, redraw_events);
+    handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::AboutToWait));
+}
+
+pub fn handle_events_cleared(mtm: MainThreadMarker) {
+    AppState::get_mut(mtm).events_cleared_transition();
+}
+
+pub(crate) fn terminated(application: &UIApplication) {
+    let mtm = MainThreadMarker::from(application);
+
+    let mut events = Vec::new();
+    #[allow(deprecated)]
+    for window in application.windows().iter() {
+        if window.is_kind_of::<WinitUIWindow>() {
+            // SAFETY: We just checked that the window is a `winit` window
+            let window = unsafe {
+                let ptr: *const UIWindow = window;
+                let ptr: *const WinitUIWindow = ptr.cast();
+                &*ptr
+            };
+            events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::Destroyed,
+            }));
+        }
+    }
+    handle_nonuser_events(mtm, events);
+
+    let mut this = AppState::get_mut(mtm);
+    let mut handler = this.terminated_transition();
+    drop(this);
+
+    handler.handle_event(Event::LoopExiting)
+}
+
+fn handle_hidpi_proxy(handler: &mut EventLoopHandler, event: ScaleFactorChanged) {
+    let ScaleFactorChanged { suggested_size, scale_factor, window } = event;
+    let new_inner_size = Arc::new(Mutex::new(suggested_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)),
+        },
+    };
+    handler.handle_event(event);
+    let (view, screen_frame) = get_view_and_screen_frame(&window);
+    let physical_size = *new_inner_size.lock().unwrap();
+    drop(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) -> (Retained<UIView>, CGRect) {
+    let view_controller = window.rootViewController().unwrap();
+    let view = view_controller.view().unwrap();
+    let bounds = window.bounds();
+    let screen = window.screen();
+    let screen_space = screen.coordinateSpace();
+    let screen_frame = window.convertRect_toCoordinateSpace(bounds, &screen_space);
+    (view, screen_frame)
+}
+
+struct EventLoopWaker {
+    timer: CFRunLoopTimerRef,
+}
+
+impl Drop for EventLoopWaker {
+    fn drop(&mut self) {
+        unsafe {
+            CFRunLoopTimerInvalidate(self.timer);
+            CFRelease(self.timer as _);
+        }
+    }
+}
+
+impl EventLoopWaker {
+    fn new(rl: CFRunLoopRef) -> EventLoopWaker {
+        extern "C" fn wakeup_main_loop(_timer: CFRunLoopTimerRef, _info: *mut c_void) {}
+        unsafe {
+            // Create a timer with a 0.1µs interval (1ns does not work) to mimic polling.
+            // It is initially setup with a first fire time really far into the
+            // future, but that gets changed to fire immediately in did_finish_launching
+            let timer = CFRunLoopTimerCreate(
+                ptr::null_mut(),
+                f64::MAX,
+                0.000_000_1,
+                0,
+                0,
+                wakeup_main_loop,
+                ptr::null_mut(),
+            );
+            CFRunLoopAddTimer(rl, timer, kCFRunLoopCommonModes);
+
+            EventLoopWaker { timer }
+        }
+    }
+
+    fn stop(&mut self) {
+        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MAX) }
+    }
+
+    fn start(&mut self) {
+        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MIN) }
+    }
+
+    fn start_at(&mut self, instant: Instant) {
+        let now = Instant::now();
+        if now >= instant {
+            self.start();
+        } else {
+            unsafe {
+                let current = CFAbsoluteTimeGetCurrent();
+                let duration = instant - now;
+                let fsecs =
+                    duration.subsec_nanos() as f64 / 1_000_000_000.0 + duration.as_secs() as f64;
+                CFRunLoopTimerSetNextFireDate(self.timer, current + fsecs)
+            }
+        }
+    }
+}
+
+macro_rules! os_capabilities {
+    (
+        $(
+            $(#[$attr:meta])*
+            $error_name:ident: $objc_call:literal,
+            $name:ident: $major:literal-$minor:literal
+        ),*
+        $(,)*
+    ) => {
+        #[derive(Clone, Debug)]
+        pub struct OSCapabilities {
+            $(
+                pub $name: bool,
+            )*
+
+            os_version: NSOperatingSystemVersion,
+        }
+
+        impl OSCapabilities {
+            fn from_os_version(os_version: NSOperatingSystemVersion) -> Self {
+                $(let $name = meets_requirements(os_version, $major, $minor);)*
+                Self { $($name,)* os_version, }
+            }
+        }
+
+        impl OSCapabilities {$(
+            $(#[$attr])*
+            pub fn $error_name(&self, extra_msg: &str) {
+                tracing::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,
+                    extra_msg
+                )
+            }
+        )*}
+    };
+}
+
+os_capabilities! {
+    /// <https://developer.apple.com/documentation/uikit/uiview/2891103-safeareainsets?language=objc>
+    #[allow(unused)] // error message unused
+    safe_area_err_msg: "-[UIView safeAreaInsets]",
+    safe_area: 11-0,
+    /// <https://developer.apple.com/documentation/uikit/uiviewcontroller/2887509-setneedsupdateofhomeindicatoraut?language=objc>
+    home_indicator_hidden_err_msg: "-[UIViewController setNeedsUpdateOfHomeIndicatorAutoHidden]",
+    home_indicator_hidden: 11-0,
+    /// <https://developer.apple.com/documentation/uikit/uiviewcontroller/2887507-setneedsupdateofscreenedgesdefer?language=objc>
+    defer_system_gestures_err_msg: "-[UIViewController setNeedsUpdateOfScreenEdgesDeferringSystem]",
+    defer_system_gestures: 11-0,
+    /// <https://developer.apple.com/documentation/uikit/uiscreen/2806814-maximumframespersecond?language=objc>
+    maximum_frames_per_second_err_msg: "-[UIScreen maximumFramesPerSecond]",
+    maximum_frames_per_second: 10-3,
+    /// <https://developer.apple.com/documentation/uikit/uitouch/1618110-force?language=objc>
+    #[allow(unused)] // error message unused
+    force_touch_err_msg: "-[UITouch force]",
+    force_touch: 9-0,
+}
+
+fn meets_requirements(
+    version: NSOperatingSystemVersion,
+    required_major: NSInteger,
+    required_minor: NSInteger,
+) -> bool {
+    (version.majorVersion, version.minorVersion) >= (required_major, required_minor)
+}
+
+fn get_version() -> NSOperatingSystemVersion {
+    let process_info = NSProcessInfo::processInfo();
+    let atleast_ios_8 = process_info.respondsToSelector(sel!(operatingSystemVersion));
+    // Winit requires atleast iOS 8 because no one has put the time into supporting earlier os
+    // versions. Older iOS versions are increasingly difficult to test. For example, Xcode 11 does
+    // not support debugging on devices with an iOS version of less than 8. Another example, in
+    // order to use an iOS simulator older than iOS 8, you must download an older version of Xcode
+    // (<9), and at least Xcode 7 has been tested to not even run on macOS 10.15 - Xcode 8 might?
+    //
+    // 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()
+}
+
+pub fn os_capabilities() -> OSCapabilities {
+    // Cache the version lookup for efficiency
+    static OS_CAPABILITIES: OnceLock<OSCapabilities> = OnceLock::new();
+    OS_CAPABILITIES.get_or_init(|| OSCapabilities::from_os_version(get_version())).clone()
+}

vendor/winit/src/platform_impl/ios/event_loop.rs

@@ -0,0 +1,494 @@
+use std::collections::VecDeque;
+use std::ffi::{c_char, c_int, c_void};
+use std::marker::PhantomData;
+use std::ptr::{self, NonNull};
+use std::sync::mpsc::{self, Receiver, Sender};
+
+use core_foundation::base::{CFIndex, CFRelease};
+use core_foundation::runloop::{
+    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes, kCFRunLoopDefaultMode,
+    kCFRunLoopExit, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
+    CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext, CFRunLoopSourceCreate,
+    CFRunLoopSourceInvalidate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
+};
+use objc2::rc::Retained;
+use objc2::{msg_send_id, ClassType};
+use objc2_foundation::{MainThreadMarker, NSNotificationCenter, NSObject};
+use objc2_ui_kit::{
+    UIApplication, UIApplicationDidBecomeActiveNotification,
+    UIApplicationDidEnterBackgroundNotification, UIApplicationDidFinishLaunchingNotification,
+    UIApplicationDidReceiveMemoryWarningNotification, UIApplicationMain,
+    UIApplicationWillEnterForegroundNotification, UIApplicationWillResignActiveNotification,
+    UIApplicationWillTerminateNotification, UIDevice, UIScreen, UIUserInterfaceIdiom,
+};
+
+use crate::error::EventLoopError;
+use crate::event::Event;
+use crate::event_loop::{
+    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents, EventLoopClosed,
+};
+use crate::platform::ios::Idiom;
+use crate::platform_impl::ios::app_state::{EventLoopHandler, HandlePendingUserEvents};
+use crate::window::{CustomCursor, CustomCursorSource, Theme};
+
+use super::app_state::{send_occluded_event_for_all_windows, AppState, EventWrapper};
+use super::notification_center::create_observer;
+use super::{app_state, monitor, MonitorHandle};
+
+#[derive(Debug)]
+pub struct ActiveEventLoop {
+    pub(super) mtm: MainThreadMarker,
+}
+
+impl ActiveEventLoop {
+    pub fn create_custom_cursor(&self, source: CustomCursorSource) -> CustomCursor {
+        let _ = source.inner;
+        CustomCursor { inner: super::PlatformCustomCursor }
+    }
+
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        monitor::uiscreens(self.mtm)
+    }
+
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        #[allow(deprecated)]
+        Some(MonitorHandle::new(UIScreen::mainScreen(self.mtm)))
+    }
+
+    #[inline]
+    pub fn listen_device_events(&self, _allowed: DeviceEvents) {}
+
+    #[cfg(feature = "rwh_05")]
+    #[inline]
+    pub fn raw_display_handle_rwh_05(&self) -> rwh_05::RawDisplayHandle {
+        rwh_05::RawDisplayHandle::UiKit(rwh_05::UiKitDisplayHandle::empty())
+    }
+
+    #[inline]
+    pub fn system_theme(&self) -> Option<Theme> {
+        None
+    }
+
+    #[cfg(feature = "rwh_06")]
+    #[inline]
+    pub fn raw_display_handle_rwh_06(
+        &self,
+    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
+        Ok(rwh_06::RawDisplayHandle::UiKit(rwh_06::UiKitDisplayHandle::new()))
+    }
+
+    pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
+        AppState::get_mut(self.mtm).set_control_flow(control_flow)
+    }
+
+    pub(crate) fn control_flow(&self) -> ControlFlow {
+        AppState::get_mut(self.mtm).control_flow()
+    }
+
+    pub(crate) fn exit(&self) {
+        // https://developer.apple.com/library/archive/qa/qa1561/_index.html
+        // it is not possible to quit an iOS app gracefully and programmatically
+        tracing::warn!("`ControlFlow::Exit` ignored on iOS");
+    }
+
+    pub(crate) fn exiting(&self) -> bool {
+        false
+    }
+
+    pub(crate) fn owned_display_handle(&self) -> OwnedDisplayHandle {
+        OwnedDisplayHandle
+    }
+}
+
+#[derive(Clone)]
+pub(crate) struct OwnedDisplayHandle;
+
+impl OwnedDisplayHandle {
+    #[cfg(feature = "rwh_05")]
+    #[inline]
+    pub fn raw_display_handle_rwh_05(&self) -> rwh_05::RawDisplayHandle {
+        rwh_05::UiKitDisplayHandle::empty().into()
+    }
+
+    #[cfg(feature = "rwh_06")]
+    #[inline]
+    pub fn raw_display_handle_rwh_06(
+        &self,
+    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
+        Ok(rwh_06::UiKitDisplayHandle::new().into())
+    }
+}
+
+fn map_user_event<T: 'static>(
+    mut handler: impl FnMut(Event<T>, &RootActiveEventLoop),
+    receiver: mpsc::Receiver<T>,
+) -> impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) {
+    move |event, window_target| match event.map_nonuser_event() {
+        Ok(event) => (handler)(event, window_target),
+        Err(_) => {
+            for event in receiver.try_iter() {
+                (handler)(Event::UserEvent(event), window_target);
+            }
+        },
+    }
+}
+
+pub struct EventLoop<T: 'static> {
+    mtm: MainThreadMarker,
+    sender: Sender<T>,
+    receiver: Receiver<T>,
+    window_target: RootActiveEventLoop,
+
+    // Since iOS 9.0, we no longer need to remove the observers before they are deallocated; the
+    // system instead cleans it up next time it would have posted a notification to it.
+    //
+    // Though we do still need to keep the observers around to prevent them from being deallocated.
+    _did_finish_launching_observer: Retained<NSObject>,
+    _did_become_active_observer: Retained<NSObject>,
+    _will_resign_active_observer: Retained<NSObject>,
+    _will_enter_foreground_observer: Retained<NSObject>,
+    _did_enter_background_observer: Retained<NSObject>,
+    _will_terminate_observer: Retained<NSObject>,
+    _did_receive_memory_warning_observer: Retained<NSObject>,
+}
+
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct PlatformSpecificEventLoopAttributes {}
+
+impl<T: 'static> EventLoop<T> {
+    pub(crate) fn new(
+        _: &PlatformSpecificEventLoopAttributes,
+    ) -> Result<EventLoop<T>, EventLoopError> {
+        let mtm = MainThreadMarker::new()
+            .expect("On iOS, `EventLoop` must be created on the main thread");
+
+        static mut SINGLETON_INIT: bool = false;
+        unsafe {
+            assert!(
+                !SINGLETON_INIT,
+                "Only one `EventLoop` is supported on iOS. `EventLoopProxy` might be helpful"
+            );
+            SINGLETON_INIT = true;
+        }
+
+        let (sender, receiver) = mpsc::channel();
+
+        // this line sets up the main run loop before `UIApplicationMain`
+        setup_control_flow_observers();
+
+        let center = unsafe { NSNotificationCenter::defaultCenter() };
+
+        let _did_finish_launching_observer = create_observer(
+            &center,
+            // `application:didFinishLaunchingWithOptions:`
+            unsafe { UIApplicationDidFinishLaunchingNotification },
+            move |_| {
+                app_state::did_finish_launching(mtm);
+            },
+        );
+        let _did_become_active_observer = create_observer(
+            &center,
+            // `applicationDidBecomeActive:`
+            unsafe { UIApplicationDidBecomeActiveNotification },
+            move |_| {
+                app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Resumed));
+            },
+        );
+        let _will_resign_active_observer = create_observer(
+            &center,
+            // `applicationWillResignActive:`
+            unsafe { UIApplicationWillResignActiveNotification },
+            move |_| {
+                app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Suspended));
+            },
+        );
+        let _will_enter_foreground_observer = create_observer(
+            &center,
+            // `applicationWillEnterForeground:`
+            unsafe { UIApplicationWillEnterForegroundNotification },
+            move |notification| {
+                let app = unsafe { notification.object() }.expect(
+                    "UIApplicationWillEnterForegroundNotification to have application object",
+                );
+                // SAFETY: The `object` in `UIApplicationWillEnterForegroundNotification` is
+                // documented to be `UIApplication`.
+                let app: Retained<UIApplication> = unsafe { Retained::cast(app) };
+                send_occluded_event_for_all_windows(&app, false);
+            },
+        );
+        let _did_enter_background_observer = create_observer(
+            &center,
+            // `applicationDidEnterBackground:`
+            unsafe { UIApplicationDidEnterBackgroundNotification },
+            move |notification| {
+                let app = unsafe { notification.object() }.expect(
+                    "UIApplicationDidEnterBackgroundNotification to have application object",
+                );
+                // SAFETY: The `object` in `UIApplicationDidEnterBackgroundNotification` is
+                // documented to be `UIApplication`.
+                let app: Retained<UIApplication> = unsafe { Retained::cast(app) };
+                send_occluded_event_for_all_windows(&app, true);
+            },
+        );
+        let _will_terminate_observer = create_observer(
+            &center,
+            // `applicationWillTerminate:`
+            unsafe { UIApplicationWillTerminateNotification },
+            move |notification| {
+                let app = unsafe { notification.object() }
+                    .expect("UIApplicationWillTerminateNotification to have application object");
+                // SAFETY: The `object` in `UIApplicationWillTerminateNotification` is
+                // (somewhat) documented to be `UIApplication`.
+                let app: Retained<UIApplication> = unsafe { Retained::cast(app) };
+                app_state::terminated(&app);
+            },
+        );
+        let _did_receive_memory_warning_observer = create_observer(
+            &center,
+            // `applicationDidReceiveMemoryWarning:`
+            unsafe { UIApplicationDidReceiveMemoryWarningNotification },
+            move |_| {
+                app_state::handle_nonuser_event(
+                    mtm,
+                    EventWrapper::StaticEvent(Event::MemoryWarning),
+                );
+            },
+        );
+
+        Ok(EventLoop {
+            mtm,
+            sender,
+            receiver,
+            window_target: RootActiveEventLoop { p: ActiveEventLoop { mtm }, _marker: PhantomData },
+            _did_finish_launching_observer,
+            _did_become_active_observer,
+            _will_resign_active_observer,
+            _will_enter_foreground_observer,
+            _did_enter_background_observer,
+            _will_terminate_observer,
+            _did_receive_memory_warning_observer,
+        })
+    }
+
+    pub fn run<F>(self, handler: F) -> !
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
+        let application: Option<Retained<UIApplication>> =
+            unsafe { msg_send_id![UIApplication::class(), sharedApplication] };
+        assert!(
+            application.is_none(),
+            "\
+                `EventLoop` cannot be `run` after a call to `UIApplicationMain` on iOS\nNote: \
+             `EventLoop::run_app` calls `UIApplicationMain` on iOS",
+        );
+
+        let handler = map_user_event(handler, self.receiver);
+
+        let handler = unsafe {
+            std::mem::transmute::<
+                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
+                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
+            >(Box::new(handler))
+        };
+
+        let handler = EventLoopHandler { handler, event_loop: self.window_target };
+
+        app_state::will_launch(self.mtm, handler);
+
+        extern "C" {
+            // These functions are in crt_externs.h.
+            fn _NSGetArgc() -> *mut c_int;
+            fn _NSGetArgv() -> *mut *mut *mut c_char;
+        }
+
+        unsafe {
+            UIApplicationMain(
+                *_NSGetArgc(),
+                NonNull::new(*_NSGetArgv()).unwrap(),
+                // We intentionally override neither the application nor the delegate, to allow the
+                // user to do so themselves!
+                None,
+                None,
+            )
+        };
+        unreachable!()
+    }
+
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.sender.clone())
+    }
+
+    pub fn window_target(&self) -> &RootActiveEventLoop {
+        &self.window_target
+    }
+}
+
+// EventLoopExtIOS
+impl<T: 'static> EventLoop<T> {
+    pub fn idiom(&self) -> Idiom {
+        match UIDevice::currentDevice(self.mtm).userInterfaceIdiom() {
+            UIUserInterfaceIdiom::Unspecified => Idiom::Unspecified,
+            UIUserInterfaceIdiom::Phone => Idiom::Phone,
+            UIUserInterfaceIdiom::Pad => Idiom::Pad,
+            UIUserInterfaceIdiom::TV => Idiom::TV,
+            UIUserInterfaceIdiom::CarPlay => Idiom::CarPlay,
+            _ => Idiom::Unspecified,
+        }
+    }
+}
+
+pub struct EventLoopProxy<T> {
+    sender: Sender<T>,
+    source: CFRunLoopSourceRef,
+}
+
+unsafe impl<T: Send> Send for EventLoopProxy<T> {}
+unsafe impl<T: Send> Sync for EventLoopProxy<T> {}
+
+impl<T> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.sender.clone())
+    }
+}
+
+impl<T> Drop for EventLoopProxy<T> {
+    fn drop(&mut self) {
+        unsafe {
+            CFRunLoopSourceInvalidate(self.source);
+            CFRelease(self.source as _);
+        }
+    }
+}
+
+impl<T> EventLoopProxy<T> {
+    fn new(sender: Sender<T>) -> EventLoopProxy<T> {
+        unsafe {
+            // just wake up the eventloop
+            extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
+
+            // adding a Source to the main CFRunLoop lets us wake it up and
+            // process user events through the normal OS EventLoop mechanisms.
+            let rl = CFRunLoopGetMain();
+            let mut context = CFRunLoopSourceContext {
+                version: 0,
+                info: ptr::null_mut(),
+                retain: None,
+                release: None,
+                copyDescription: None,
+                equal: None,
+                hash: None,
+                schedule: None,
+                cancel: None,
+                perform: event_loop_proxy_handler,
+            };
+            let source = CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::MAX - 1, &mut context);
+            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+            CFRunLoopWakeUp(rl);
+
+            EventLoopProxy { sender, source }
+        }
+    }
+
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.sender.send(event).map_err(|::std::sync::mpsc::SendError(x)| EventLoopClosed(x))?;
+        unsafe {
+            // let the main thread know there's a new event
+            CFRunLoopSourceSignal(self.source);
+            let rl = CFRunLoopGetMain();
+            CFRunLoopWakeUp(rl);
+        }
+        Ok(())
+    }
+}
+
+fn setup_control_flow_observers() {
+    unsafe {
+        // begin is queued with the highest priority to ensure it is processed before other
+        // observers
+        extern "C" fn control_flow_begin_handler(
+            _: CFRunLoopObserverRef,
+            activity: CFRunLoopActivity,
+            _: *mut c_void,
+        ) {
+            let mtm = MainThreadMarker::new().unwrap();
+            #[allow(non_upper_case_globals)]
+            match activity {
+                kCFRunLoopAfterWaiting => app_state::handle_wakeup_transition(mtm),
+                _ => unreachable!(),
+            }
+        }
+
+        // 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
+        // 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`.
+        //
+        // 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.
+        //
+        // Also tested to be `0x1e8480` on iPhone 8, iOS 13 beta 4.
+        extern "C" fn control_flow_main_end_handler(
+            _: CFRunLoopObserverRef,
+            activity: CFRunLoopActivity,
+            _: *mut c_void,
+        ) {
+            let mtm = MainThreadMarker::new().unwrap();
+            #[allow(non_upper_case_globals)]
+            match activity {
+                kCFRunLoopBeforeWaiting => app_state::handle_main_events_cleared(mtm),
+                kCFRunLoopExit => {}, // may happen when running on macOS
+                _ => unreachable!(),
+            }
+        }
+
+        // end is queued with the lowest priority to ensure it is processed after other observers
+        extern "C" fn control_flow_end_handler(
+            _: CFRunLoopObserverRef,
+            activity: CFRunLoopActivity,
+            _: *mut c_void,
+        ) {
+            let mtm = MainThreadMarker::new().unwrap();
+            #[allow(non_upper_case_globals)]
+            match activity {
+                kCFRunLoopBeforeWaiting => app_state::handle_events_cleared(mtm),
+                kCFRunLoopExit => {}, // may happen when running on macOS
+                _ => unreachable!(),
+            }
+        }
+
+        let main_loop = CFRunLoopGetMain();
+
+        let begin_observer = CFRunLoopObserverCreate(
+            ptr::null_mut(),
+            kCFRunLoopAfterWaiting,
+            1, // repeat = true
+            CFIndex::MIN,
+            control_flow_begin_handler,
+            ptr::null_mut(),
+        );
+        CFRunLoopAddObserver(main_loop, begin_observer, kCFRunLoopDefaultMode);
+
+        let main_end_observer = CFRunLoopObserverCreate(
+            ptr::null_mut(),
+            kCFRunLoopExit | kCFRunLoopBeforeWaiting,
+            1, // repeat = true
+            0, // see comment on `control_flow_main_end_handler`
+            control_flow_main_end_handler,
+            ptr::null_mut(),
+        );
+        CFRunLoopAddObserver(main_loop, main_end_observer, kCFRunLoopDefaultMode);
+
+        let end_observer = CFRunLoopObserverCreate(
+            ptr::null_mut(),
+            kCFRunLoopExit | kCFRunLoopBeforeWaiting,
+            1, // repeat = true
+            CFIndex::MAX,
+            control_flow_end_handler,
+            ptr::null_mut(),
+        );
+        CFRunLoopAddObserver(main_loop, end_observer, kCFRunLoopDefaultMode);
+    }
+}

vendor/winit/src/platform_impl/ios/mod.rs

@@ -0,0 +1,52 @@
+#![allow(clippy::let_unit_value)]
+
+mod app_state;
+mod event_loop;
+mod monitor;
+mod notification_center;
+mod view;
+mod view_controller;
+mod window;
+
+use std::fmt;
+
+use crate::event::DeviceId as RootDeviceId;
+
+pub(crate) use self::event_loop::{
+    ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
+    PlatformSpecificEventLoopAttributes,
+};
+pub(crate) use self::monitor::{MonitorHandle, VideoModeHandle};
+pub(crate) use self::window::{PlatformSpecificWindowAttributes, Window, WindowId};
+pub(crate) use crate::cursor::{
+    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
+};
+pub(crate) use crate::icon::NoIcon as PlatformIcon;
+pub(crate) use crate::platform_impl::Fullscreen;
+
+/// There is no way to detect which device that performed a certain event in
+/// UIKit (i.e. you can't differentiate between different external keyboards,
+/// or whether it was the main touchscreen, assistive technologies, or some
+/// other pointer device that caused a touch event).
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct DeviceId;
+
+impl DeviceId {
+    pub const fn dummy() -> Self {
+        DeviceId
+    }
+}
+
+pub(crate) const DEVICE_ID: RootDeviceId = RootDeviceId(DeviceId);
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct KeyEventExtra {}
+
+#[derive(Debug)]
+pub enum OsError {}
+
+impl fmt::Display for OsError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "os error")
+    }
+}

vendor/winit/src/platform_impl/ios/monitor.rs

@@ -0,0 +1,277 @@
+#![allow(clippy::unnecessary_cast)]
+
+use std::collections::{BTreeSet, VecDeque};
+use std::{fmt, hash, ptr};
+
+use objc2::mutability::IsRetainable;
+use objc2::rc::Retained;
+use objc2::Message;
+use objc2_foundation::{run_on_main, MainThreadBound, MainThreadMarker, NSInteger};
+use objc2_ui_kit::{UIScreen, UIScreenMode};
+
+use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::monitor::VideoModeHandle as RootVideoModeHandle;
+use crate::platform_impl::platform::app_state;
+
+// Workaround for `MainThreadBound` implementing almost no traits
+#[derive(Debug)]
+struct MainThreadBoundDelegateImpls<T>(MainThreadBound<Retained<T>>);
+
+impl<T: IsRetainable + Message> Clone for MainThreadBoundDelegateImpls<T> {
+    fn clone(&self) -> Self {
+        Self(run_on_main(|mtm| MainThreadBound::new(Retained::clone(self.0.get(mtm)), mtm)))
+    }
+}
+
+impl<T: IsRetainable + Message> hash::Hash for MainThreadBoundDelegateImpls<T> {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        // SAFETY: Marker only used to get the pointer
+        let mtm = unsafe { MainThreadMarker::new_unchecked() };
+        Retained::as_ptr(self.0.get(mtm)).hash(state);
+    }
+}
+
+impl<T: IsRetainable + Message> PartialEq for MainThreadBoundDelegateImpls<T> {
+    fn eq(&self, other: &Self) -> bool {
+        // SAFETY: Marker only used to get the pointer
+        let mtm = unsafe { MainThreadMarker::new_unchecked() };
+        Retained::as_ptr(self.0.get(mtm)) == Retained::as_ptr(other.0.get(mtm))
+    }
+}
+
+impl<T: IsRetainable + Message> Eq for MainThreadBoundDelegateImpls<T> {}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub struct VideoModeHandle {
+    pub(crate) size: (u32, u32),
+    pub(crate) bit_depth: u16,
+    pub(crate) refresh_rate_millihertz: u32,
+    screen_mode: MainThreadBoundDelegateImpls<UIScreenMode>,
+    pub(crate) monitor: MonitorHandle,
+}
+
+impl VideoModeHandle {
+    fn new(
+        uiscreen: Retained<UIScreen>,
+        screen_mode: Retained<UIScreenMode>,
+        mtm: MainThreadMarker,
+    ) -> VideoModeHandle {
+        let refresh_rate_millihertz = refresh_rate_millihertz(&uiscreen);
+        let size = screen_mode.size();
+        VideoModeHandle {
+            size: (size.width as u32, size.height as u32),
+            bit_depth: 32,
+            refresh_rate_millihertz,
+            screen_mode: MainThreadBoundDelegateImpls(MainThreadBound::new(screen_mode, mtm)),
+            monitor: MonitorHandle::new(uiscreen),
+        }
+    }
+
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.size.into()
+    }
+
+    pub fn bit_depth(&self) -> u16 {
+        self.bit_depth
+    }
+
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.refresh_rate_millihertz
+    }
+
+    pub fn monitor(&self) -> MonitorHandle {
+        self.monitor.clone()
+    }
+
+    pub(super) fn screen_mode(&self, mtm: MainThreadMarker) -> &Retained<UIScreenMode> {
+        self.screen_mode.0.get(mtm)
+    }
+}
+
+pub struct MonitorHandle {
+    ui_screen: MainThreadBound<Retained<UIScreen>>,
+}
+
+impl Clone for MonitorHandle {
+    fn clone(&self) -> Self {
+        run_on_main(|mtm| Self {
+            ui_screen: MainThreadBound::new(self.ui_screen.get(mtm).clone(), mtm),
+        })
+    }
+}
+
+impl hash::Hash for MonitorHandle {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        // SAFETY: Only getting the pointer.
+        let mtm = unsafe { MainThreadMarker::new_unchecked() };
+        Retained::as_ptr(self.ui_screen.get(mtm)).hash(state);
+    }
+}
+
+impl PartialEq for MonitorHandle {
+    fn eq(&self, other: &Self) -> bool {
+        // SAFETY: Only getting the pointer.
+        let mtm = unsafe { MainThreadMarker::new_unchecked() };
+        ptr::eq(
+            Retained::as_ptr(self.ui_screen.get(mtm)),
+            Retained::as_ptr(other.ui_screen.get(mtm)),
+        )
+    }
+}
+
+impl Eq for MonitorHandle {}
+
+impl PartialOrd for MonitorHandle {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MonitorHandle {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        // SAFETY: Only getting the pointer.
+        // TODO: Make a better ordering
+        let mtm = unsafe { MainThreadMarker::new_unchecked() };
+        Retained::as_ptr(self.ui_screen.get(mtm)).cmp(&Retained::as_ptr(other.ui_screen.get(mtm)))
+    }
+}
+
+impl fmt::Debug for MonitorHandle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MonitorHandle")
+            .field("name", &self.name())
+            .field("size", &self.size())
+            .field("position", &self.position())
+            .field("scale_factor", &self.scale_factor())
+            .field("refresh_rate_millihertz", &self.refresh_rate_millihertz())
+            .finish_non_exhaustive()
+    }
+}
+
+impl MonitorHandle {
+    pub(crate) fn new(ui_screen: Retained<UIScreen>) -> Self {
+        // Holding `Retained<UIScreen>` implies we're on the main thread.
+        let mtm = MainThreadMarker::new().unwrap();
+        Self { ui_screen: MainThreadBound::new(ui_screen, mtm) }
+    }
+
+    pub fn name(&self) -> Option<String> {
+        run_on_main(|mtm| {
+            #[allow(deprecated)]
+            let main = UIScreen::mainScreen(mtm);
+            if *self.ui_screen(mtm) == main {
+                Some("Primary".to_string())
+            } else if Some(self.ui_screen(mtm)) == main.mirroredScreen().as_ref() {
+                Some("Mirrored".to_string())
+            } else {
+                #[allow(deprecated)]
+                UIScreen::screens(mtm)
+                    .iter()
+                    .position(|rhs| rhs == &**self.ui_screen(mtm))
+                    .map(|idx| idx.to_string())
+            }
+        })
+    }
+
+    pub fn size(&self) -> PhysicalSize<u32> {
+        let bounds = self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeBounds());
+        PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
+    }
+
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        let bounds = self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeBounds());
+        (bounds.origin.x as f64, bounds.origin.y as f64).into()
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeScale()) as f64
+    }
+
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        Some(self.ui_screen.get_on_main(|ui_screen| refresh_rate_millihertz(ui_screen)))
+    }
+
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
+        run_on_main(|mtm| {
+            let ui_screen = self.ui_screen(mtm);
+            // Use Ord impl of RootVideoModeHandle
+
+            let modes: BTreeSet<_> = ui_screen
+                .availableModes()
+                .into_iter()
+                .map(|mode| RootVideoModeHandle {
+                    video_mode: VideoModeHandle::new(ui_screen.clone(), mode, mtm),
+                })
+                .collect();
+
+            modes.into_iter().map(|mode| mode.video_mode)
+        })
+    }
+
+    pub(crate) fn ui_screen(&self, mtm: MainThreadMarker) -> &Retained<UIScreen> {
+        self.ui_screen.get(mtm)
+    }
+
+    pub fn preferred_video_mode(&self) -> VideoModeHandle {
+        run_on_main(|mtm| {
+            VideoModeHandle::new(
+                self.ui_screen(mtm).clone(),
+                self.ui_screen(mtm).preferredMode().unwrap(),
+                mtm,
+            )
+        })
+    }
+}
+
+fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
+    let refresh_rate_millihertz: NSInteger = {
+        let os_capabilities = app_state::os_capabilities();
+        if os_capabilities.maximum_frames_per_second {
+            uiscreen.maximumFramesPerSecond()
+        } else {
+            // https://developer.apple.com/library/archive/technotes/tn2460/_index.html
+            // https://en.wikipedia.org/wiki/IPad_Pro#Model_comparison
+            //
+            // All iOS devices support 60 fps, and on devices where `maximumFramesPerSecond` is not
+            // supported, they are all guaranteed to have 60hz refresh rates. This does not
+            // correctly handle external displays. ProMotion displays support 120fps, but they were
+            // introduced at the same time as the `maximumFramesPerSecond` API.
+            //
+            // FIXME: earlier OSs could calculate the refresh rate using
+            // `-[CADisplayLink duration]`.
+            os_capabilities.maximum_frames_per_second_err_msg("defaulting to 60 fps");
+            60
+        }
+    };
+
+    refresh_rate_millihertz as u32 * 1000
+}
+
+pub fn uiscreens(mtm: MainThreadMarker) -> VecDeque<MonitorHandle> {
+    #[allow(deprecated)]
+    UIScreen::screens(mtm).into_iter().map(MonitorHandle::new).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use objc2_foundation::NSSet;
+
+    use super::*;
+
+    // Test that UIScreen pointer comparisons are correct.
+    #[test]
+    #[allow(deprecated)]
+    fn screen_comparisons() {
+        // Test code, doesn't matter that it's not thread safe
+        let mtm = unsafe { MainThreadMarker::new_unchecked() };
+
+        assert!(ptr::eq(&*UIScreen::mainScreen(mtm), &*UIScreen::mainScreen(mtm)));
+
+        let main = UIScreen::mainScreen(mtm);
+        assert!(UIScreen::screens(mtm).iter().any(|screen| ptr::eq(screen, &*main)));
+
+        assert!(unsafe {
+            NSSet::setWithArray(&UIScreen::screens(mtm)).containsObject(&UIScreen::mainScreen(mtm))
+        });
+    }
+}

vendor/winit/src/platform_impl/ios/notification_center.rs

@@ -0,0 +1,27 @@
+use std::ptr::NonNull;
+
+use block2::RcBlock;
+use objc2::rc::Retained;
+use objc2_foundation::{NSNotification, NSNotificationCenter, NSNotificationName, NSObject};
+
+/// Observe the given notification.
+///
+/// This is used in Winit as an alternative to declaring an application delegate, as we want to
+/// give the user full control over those.
+pub fn create_observer(
+    center: &NSNotificationCenter,
+    name: &NSNotificationName,
+    handler: impl Fn(&NSNotification) + 'static,
+) -> Retained<NSObject> {
+    let block = RcBlock::new(move |notification: NonNull<NSNotification>| {
+        handler(unsafe { notification.as_ref() });
+    });
+    unsafe {
+        center.addObserverForName_object_queue_usingBlock(
+            Some(name),
+            None, // No sender filter
+            None, // No queue, run on posting thread (i.e. main thread)
+            &block,
+        )
+    }
+}

vendor/winit/src/platform_impl/ios/view.rs

@@ -0,0 +1,607 @@
+#![allow(clippy::unnecessary_cast)]
+use std::cell::{Cell, RefCell};
+
+use objc2::rc::Retained;
+use objc2::runtime::{NSObjectProtocol, ProtocolObject};
+use objc2::{declare_class, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass};
+use objc2_foundation::{CGFloat, CGPoint, CGRect, MainThreadMarker, NSObject, NSSet, NSString};
+use objc2_ui_kit::{
+    UICoordinateSpace, UIEvent, UIForceTouchCapability, UIGestureRecognizer,
+    UIGestureRecognizerDelegate, UIGestureRecognizerState, UIKeyInput, UIPanGestureRecognizer,
+    UIPinchGestureRecognizer, UIResponder, UIRotationGestureRecognizer, UITapGestureRecognizer,
+    UITextInputTraits, UITouch, UITouchPhase, UITouchType, UITraitEnvironment, UIView,
+};
+
+use super::app_state::{self, EventWrapper};
+use super::window::WinitUIWindow;
+use crate::dpi::PhysicalPosition;
+use crate::event::{ElementState, Event, Force, KeyEvent, Touch, TouchPhase, WindowEvent};
+use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKeyCode, PhysicalKey};
+use crate::platform_impl::platform::DEVICE_ID;
+use crate::platform_impl::KeyEventExtra;
+use crate::window::{WindowAttributes, WindowId as RootWindowId};
+
+pub struct WinitViewState {
+    pinch_gesture_recognizer: RefCell<Option<Retained<UIPinchGestureRecognizer>>>,
+    doubletap_gesture_recognizer: RefCell<Option<Retained<UITapGestureRecognizer>>>,
+    rotation_gesture_recognizer: RefCell<Option<Retained<UIRotationGestureRecognizer>>>,
+    pan_gesture_recognizer: RefCell<Option<Retained<UIPanGestureRecognizer>>>,
+
+    // for iOS delta references the start of the Gesture
+    rotation_last_delta: Cell<CGFloat>,
+    pinch_last_delta: Cell<CGFloat>,
+    pan_last_delta: Cell<CGPoint>,
+}
+
+declare_class!(
+    pub(crate) struct WinitView;
+
+    unsafe impl ClassType for WinitView {
+        #[inherits(UIResponder, NSObject)]
+        type Super = UIView;
+        type Mutability = mutability::MainThreadOnly;
+        const NAME: &'static str = "WinitUIView";
+    }
+
+    impl DeclaredClass for WinitView {
+        type Ivars = WinitViewState;
+    }
+
+    unsafe impl WinitView {
+        #[method(drawRect:)]
+        fn draw_rect(&self, rect: CGRect) {
+            let mtm = MainThreadMarker::new().unwrap();
+            let window = self.window().unwrap();
+            app_state::handle_nonuser_event(
+                mtm,
+                EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id: RootWindowId(window.id()),
+                    event: WindowEvent::RedrawRequested,
+                }),
+            );
+            let _: () = unsafe { msg_send![super(self), drawRect: rect] };
+        }
+
+        #[method(layoutSubviews)]
+        fn layout_subviews(&self) {
+            let mtm = MainThreadMarker::new().unwrap();
+            let _: () = unsafe { msg_send![super(self), layoutSubviews] };
+
+            let window = self.window().unwrap();
+            let window_bounds = window.bounds();
+            let screen = window.screen();
+            let screen_space = screen.coordinateSpace();
+            let screen_frame = self.convertRect_toCoordinateSpace(window_bounds, &screen_space);
+            let scale_factor = screen.scale();
+            let size = crate::dpi::LogicalSize {
+                width: screen_frame.size.width as f64,
+                height: screen_frame.size.height as f64,
+            }
+            .to_physical(scale_factor as f64);
+
+            // If the app is started in landscape, the view frame and window bounds can be mismatched.
+            // The view frame will be in portrait and the window bounds in landscape. So apply the
+            // window bounds to the view frame to make it consistent.
+            let view_frame = self.frame();
+            if view_frame != window_bounds {
+                self.setFrame(window_bounds);
+            }
+
+            app_state::handle_nonuser_event(
+                mtm,
+                EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id: RootWindowId(window.id()),
+                    event: WindowEvent::Resized(size),
+                }),
+            );
+        }
+
+        #[method(setContentScaleFactor:)]
+        fn set_content_scale_factor(&self, untrusted_scale_factor: CGFloat) {
+            let mtm = MainThreadMarker::new().unwrap();
+            let _: () =
+                unsafe { msg_send![super(self), setContentScaleFactor: untrusted_scale_factor] };
+
+            // `window` is null when `setContentScaleFactor` is invoked prior to `[UIWindow
+            // makeKeyAndVisible]` at window creation time (either manually or internally by
+            // UIKit when the `UIView` is first created), in which case we send no events here
+            let window = match self.window() {
+                Some(window) => window,
+                None => return,
+            };
+            // `setContentScaleFactor` may be called with a value of 0, which means "reset the
+            // content scale factor to a device-specific default value", so we can't use the
+            // parameter here. We can query the actual factor using the getter
+            let scale_factor = self.contentScaleFactor();
+            assert!(
+                !scale_factor.is_nan()
+                    && scale_factor.is_finite()
+                    && scale_factor.is_sign_positive()
+                    && scale_factor > 0.0,
+                "invalid scale_factor set on UIView",
+            );
+            let scale_factor = scale_factor as f64;
+            let bounds = self.bounds();
+            let screen = window.screen();
+            let screen_space = screen.coordinateSpace();
+            let screen_frame = self.convertRect_toCoordinateSpace(bounds, &screen_space);
+            let size = crate::dpi::LogicalSize {
+                width: screen_frame.size.width as f64,
+                height: screen_frame.size.height as f64,
+            };
+            let window_id = RootWindowId(window.id());
+            app_state::handle_nonuser_events(
+                mtm,
+                std::iter::once(EventWrapper::ScaleFactorChanged(
+                    app_state::ScaleFactorChanged {
+                        window,
+                        scale_factor,
+                        suggested_size: size.to_physical(scale_factor),
+                    },
+                ))
+                .chain(std::iter::once(EventWrapper::StaticEvent(
+                    Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::Resized(size.to_physical(scale_factor)),
+                    },
+                ))),
+            );
+        }
+
+        #[method(touchesBegan:withEvent:)]
+        fn touches_began(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            self.handle_touches(touches)
+        }
+
+        #[method(touchesMoved:withEvent:)]
+        fn touches_moved(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            self.handle_touches(touches)
+        }
+
+        #[method(touchesEnded:withEvent:)]
+        fn touches_ended(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            self.handle_touches(touches)
+        }
+
+        #[method(touchesCancelled:withEvent:)]
+        fn touches_cancelled(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            self.handle_touches(touches)
+        }
+
+        #[method(pinchGesture:)]
+        fn pinch_gesture(&self, recognizer: &UIPinchGestureRecognizer) {
+            let window = self.window().unwrap();
+
+            let (phase, delta) = match recognizer.state() {
+                UIGestureRecognizerState::Began => {
+                    self.ivars().pinch_last_delta.set(recognizer.scale());
+                    (TouchPhase::Started, 0.0)
+                }
+                UIGestureRecognizerState::Changed => {
+                    let last_scale: f64 = self.ivars().pinch_last_delta.replace(recognizer.scale());
+                    (TouchPhase::Moved, recognizer.scale() - last_scale)
+                }
+                UIGestureRecognizerState::Ended => {
+                    let last_scale: f64 = self.ivars().pinch_last_delta.replace(0.0);
+                    (TouchPhase::Moved, recognizer.scale() - last_scale)
+                }
+                UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => {
+                    self.ivars().rotation_last_delta.set(0.0);
+                    // Pass -delta so that action is reversed
+                    (TouchPhase::Cancelled, -recognizer.scale())
+                }
+                state => panic!("unexpected recognizer state: {state:?}"),
+            };
+
+            let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::PinchGesture {
+                    device_id: DEVICE_ID,
+                    delta: delta as f64,
+                    phase,
+                },
+            });
+
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, gesture_event);
+        }
+
+        #[method(doubleTapGesture:)]
+        fn double_tap_gesture(&self, recognizer: &UITapGestureRecognizer) {
+            let window = self.window().unwrap();
+
+            if recognizer.state() == UIGestureRecognizerState::Ended {
+                let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id: RootWindowId(window.id()),
+                    event: WindowEvent::DoubleTapGesture {
+                        device_id: DEVICE_ID,
+                    },
+                });
+
+                let mtm = MainThreadMarker::new().unwrap();
+                app_state::handle_nonuser_event(mtm, gesture_event);
+            }
+        }
+
+        #[method(rotationGesture:)]
+        fn rotation_gesture(&self, recognizer: &UIRotationGestureRecognizer) {
+            let window = self.window().unwrap();
+
+            let (phase, delta) = match recognizer.state() {
+                UIGestureRecognizerState::Began => {
+                    self.ivars().rotation_last_delta.set(0.0);
+
+                    (TouchPhase::Started, 0.0)
+                }
+                UIGestureRecognizerState::Changed => {
+                    let last_rotation = self.ivars().rotation_last_delta.replace(recognizer.rotation());
+
+                    (TouchPhase::Moved, recognizer.rotation() - last_rotation)
+                }
+                UIGestureRecognizerState::Ended => {
+                    let last_rotation = self.ivars().rotation_last_delta.replace(0.0);
+
+                    (TouchPhase::Ended, recognizer.rotation() - last_rotation)
+                }
+                UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => {
+                    self.ivars().rotation_last_delta.set(0.0);
+
+                    // Pass -delta so that action is reversed
+                    (TouchPhase::Cancelled, -recognizer.rotation())
+                }
+                state => panic!("unexpected recognizer state: {state:?}"),
+            };
+
+            // Make delta negative to match macos, convert to degrees
+            let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::RotationGesture {
+                    device_id: DEVICE_ID,
+                    delta: -delta.to_degrees() as _,
+                    phase,
+                },
+            });
+
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, gesture_event);
+        }
+
+        #[method(panGesture:)]
+        fn pan_gesture(&self, recognizer: &UIPanGestureRecognizer) {
+            let window = self.window().unwrap();
+
+            let translation = recognizer.translationInView(Some(self));
+
+            let (phase, dx, dy) = match recognizer.state() {
+                UIGestureRecognizerState::Began => {
+                    self.ivars().pan_last_delta.set(translation);
+
+                    (TouchPhase::Started, 0.0, 0.0)
+                }
+                UIGestureRecognizerState::Changed => {
+                    let last_pan: CGPoint = self.ivars().pan_last_delta.replace(translation);
+
+                    let dx = translation.x - last_pan.x;
+                    let dy = translation.y - last_pan.y;
+
+                    (TouchPhase::Moved, dx, dy)
+                }
+                UIGestureRecognizerState::Ended => {
+                    let last_pan: CGPoint = self.ivars().pan_last_delta.replace(CGPoint{x:0.0, y:0.0});
+
+                    let dx = translation.x - last_pan.x;
+                    let dy = translation.y - last_pan.y;
+
+                    (TouchPhase::Ended, dx, dy)
+                }
+                UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => {
+                    let last_pan: CGPoint = self.ivars().pan_last_delta.replace(CGPoint{x:0.0, y:0.0});
+
+                    // Pass -delta so that action is reversed
+                    (TouchPhase::Cancelled, -last_pan.x, -last_pan.y)
+                }
+                state => panic!("unexpected recognizer state: {state:?}"),
+            };
+
+
+            let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::PanGesture {
+                    device_id: DEVICE_ID,
+                    delta: PhysicalPosition::new(dx as _, dy as _),
+                    phase,
+                },
+            });
+
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, gesture_event);
+        }
+
+        #[method(canBecomeFirstResponder)]
+        fn can_become_first_responder(&self) -> bool {
+            true
+        }
+    }
+
+    unsafe impl NSObjectProtocol for WinitView {}
+
+    unsafe impl UIGestureRecognizerDelegate for WinitView {
+        #[method(gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:)]
+        fn should_recognize_simultaneously(&self, _gesture_recognizer: &UIGestureRecognizer, _other_gesture_recognizer: &UIGestureRecognizer) -> bool {
+            true
+        }
+    }
+
+    unsafe impl UITextInputTraits for WinitView {
+    }
+
+    unsafe impl UIKeyInput for WinitView {
+        #[method(hasText)]
+        fn has_text(&self) -> bool {
+            true
+        }
+
+        #[method(insertText:)]
+        fn insert_text(&self, text: &NSString) {
+            self.handle_insert_text(text)
+        }
+
+        #[method(deleteBackward)]
+        fn delete_backward(&self) {
+            self.handle_delete_backward()
+        }
+    }
+);
+
+impl WinitView {
+    pub(crate) fn new(
+        mtm: MainThreadMarker,
+        window_attributes: &WindowAttributes,
+        frame: CGRect,
+    ) -> Retained<Self> {
+        let this = mtm.alloc().set_ivars(WinitViewState {
+            pinch_gesture_recognizer: RefCell::new(None),
+            doubletap_gesture_recognizer: RefCell::new(None),
+            rotation_gesture_recognizer: RefCell::new(None),
+            pan_gesture_recognizer: RefCell::new(None),
+
+            rotation_last_delta: Cell::new(0.0),
+            pinch_last_delta: Cell::new(0.0),
+            pan_last_delta: Cell::new(CGPoint { x: 0.0, y: 0.0 }),
+        });
+        let this: Retained<Self> = unsafe { msg_send_id![super(this), initWithFrame: frame] };
+
+        this.setMultipleTouchEnabled(true);
+
+        if let Some(scale_factor) = window_attributes.platform_specific.scale_factor {
+            this.setContentScaleFactor(scale_factor as _);
+        }
+
+        this
+    }
+
+    fn window(&self) -> Option<Retained<WinitUIWindow>> {
+        // SAFETY: `WinitView`s are always installed in a `WinitUIWindow`
+        (**self).window().map(|window| unsafe { Retained::cast(window) })
+    }
+
+    pub(crate) fn recognize_pinch_gesture(&self, should_recognize: bool) {
+        let mtm = MainThreadMarker::from(self);
+        if should_recognize {
+            if self.ivars().pinch_gesture_recognizer.borrow().is_none() {
+                let pinch = unsafe {
+                    UIPinchGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(pinchGesture:)),
+                    )
+                };
+                pinch.setDelegate(Some(ProtocolObject::from_ref(self)));
+                self.addGestureRecognizer(&pinch);
+                self.ivars().pinch_gesture_recognizer.replace(Some(pinch));
+            }
+        } else if let Some(recognizer) = self.ivars().pinch_gesture_recognizer.take() {
+            self.removeGestureRecognizer(&recognizer);
+        }
+    }
+
+    pub(crate) fn recognize_pan_gesture(
+        &self,
+        should_recognize: bool,
+        minimum_number_of_touches: u8,
+        maximum_number_of_touches: u8,
+    ) {
+        let mtm = MainThreadMarker::from(self);
+        if should_recognize {
+            if self.ivars().pan_gesture_recognizer.borrow().is_none() {
+                let pan = unsafe {
+                    UIPanGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(panGesture:)),
+                    )
+                };
+                pan.setDelegate(Some(ProtocolObject::from_ref(self)));
+                pan.setMinimumNumberOfTouches(minimum_number_of_touches as _);
+                pan.setMaximumNumberOfTouches(maximum_number_of_touches as _);
+                self.addGestureRecognizer(&pan);
+                self.ivars().pan_gesture_recognizer.replace(Some(pan));
+            }
+        } else if let Some(recognizer) = self.ivars().pan_gesture_recognizer.take() {
+            self.removeGestureRecognizer(&recognizer);
+        }
+    }
+
+    pub(crate) fn recognize_doubletap_gesture(&self, should_recognize: bool) {
+        let mtm = MainThreadMarker::from(self);
+        if should_recognize {
+            if self.ivars().doubletap_gesture_recognizer.borrow().is_none() {
+                let tap = unsafe {
+                    UITapGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(doubleTapGesture:)),
+                    )
+                };
+                tap.setDelegate(Some(ProtocolObject::from_ref(self)));
+                tap.setNumberOfTapsRequired(2);
+                tap.setNumberOfTouchesRequired(1);
+                self.addGestureRecognizer(&tap);
+                self.ivars().doubletap_gesture_recognizer.replace(Some(tap));
+            }
+        } else if let Some(recognizer) = self.ivars().doubletap_gesture_recognizer.take() {
+            self.removeGestureRecognizer(&recognizer);
+        }
+    }
+
+    pub(crate) fn recognize_rotation_gesture(&self, should_recognize: bool) {
+        let mtm = MainThreadMarker::from(self);
+        if should_recognize {
+            if self.ivars().rotation_gesture_recognizer.borrow().is_none() {
+                let rotation = unsafe {
+                    UIRotationGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(rotationGesture:)),
+                    )
+                };
+                rotation.setDelegate(Some(ProtocolObject::from_ref(self)));
+                self.addGestureRecognizer(&rotation);
+                self.ivars().rotation_gesture_recognizer.replace(Some(rotation));
+            }
+        } else if let Some(recognizer) = self.ivars().rotation_gesture_recognizer.take() {
+            self.removeGestureRecognizer(&recognizer);
+        }
+    }
+
+    fn handle_touches(&self, touches: &NSSet<UITouch>) {
+        let window = self.window().unwrap();
+        let mut touch_events = Vec::new();
+        let os_supports_force = app_state::os_capabilities().force_touch;
+        for touch in touches {
+            let logical_location = touch.locationInView(None);
+            let touch_type = touch.r#type();
+            let force = if os_supports_force {
+                let trait_collection = 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
+                {
+                    let force = touch.force();
+                    let max_possible_force = touch.maximumPossibleForce();
+                    let altitude_angle: Option<f64> = if touch_type == UITouchType::Pencil {
+                        let angle = touch.altitudeAngle();
+                        Some(angle as _)
+                    } else {
+                        None
+                    };
+                    Some(Force::Calibrated {
+                        force: force as _,
+                        max_possible_force: max_possible_force as _,
+                        altitude_angle,
+                    })
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+            let touch_id = touch as *const UITouch as u64;
+            let phase = touch.phase();
+            let phase = match phase {
+                UITouchPhase::Began => TouchPhase::Started,
+                UITouchPhase::Moved => TouchPhase::Moved,
+                // 2 is UITouchPhase::Stationary and is not expected here
+                UITouchPhase::Ended => TouchPhase::Ended,
+                UITouchPhase::Cancelled => TouchPhase::Cancelled,
+                _ => panic!("unexpected touch phase: {phase:?}"),
+            };
+
+            let physical_location = {
+                let scale_factor = self.contentScaleFactor();
+                PhysicalPosition::from_logical::<(f64, f64), f64>(
+                    (logical_location.x as _, logical_location.y as _),
+                    scale_factor as f64,
+                )
+            };
+            touch_events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::Touch(Touch {
+                    device_id: DEVICE_ID,
+                    id: touch_id,
+                    location: physical_location,
+                    force,
+                    phase,
+                }),
+            }));
+        }
+        let mtm = MainThreadMarker::new().unwrap();
+        app_state::handle_nonuser_events(mtm, touch_events);
+    }
+
+    fn handle_insert_text(&self, text: &NSString) {
+        let window = self.window().unwrap();
+        let window_id = RootWindowId(window.id());
+        let mtm = MainThreadMarker::new().unwrap();
+        // send individual events for each character
+        app_state::handle_nonuser_events(
+            mtm,
+            text.to_string().chars().flat_map(|c| {
+                let text = smol_str::SmolStr::from_iter([c]);
+                // Emit both press and release events
+                [ElementState::Pressed, ElementState::Released].map(|state| {
+                    EventWrapper::StaticEvent(Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::KeyboardInput {
+                            event: KeyEvent {
+                                text: if state == ElementState::Pressed {
+                                    Some(text.clone())
+                                } else {
+                                    None
+                                },
+                                state,
+                                location: KeyLocation::Standard,
+                                repeat: false,
+                                logical_key: Key::Character(text.clone()),
+                                physical_key: PhysicalKey::Unidentified(
+                                    NativeKeyCode::Unidentified,
+                                ),
+                                platform_specific: KeyEventExtra {},
+                            },
+                            is_synthetic: false,
+                            device_id: DEVICE_ID,
+                        },
+                    })
+                })
+            }),
+        );
+    }
+
+    fn handle_delete_backward(&self) {
+        let window = self.window().unwrap();
+        let window_id = RootWindowId(window.id());
+        let mtm = MainThreadMarker::new().unwrap();
+        app_state::handle_nonuser_events(
+            mtm,
+            [ElementState::Pressed, ElementState::Released].map(|state| {
+                EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id,
+                    event: WindowEvent::KeyboardInput {
+                        device_id: DEVICE_ID,
+                        event: KeyEvent {
+                            state,
+                            logical_key: Key::Named(NamedKey::Backspace),
+                            physical_key: PhysicalKey::Code(KeyCode::Backspace),
+                            platform_specific: KeyEventExtra {},
+                            repeat: false,
+                            location: KeyLocation::Standard,
+                            text: None,
+                        },
+                        is_synthetic: false,
+                    },
+                })
+            }),
+        );
+    }
+}

vendor/winit/src/platform_impl/ios/view_controller.rs

@@ -0,0 +1,176 @@
+use std::cell::Cell;
+
+use objc2::rc::Retained;
+use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
+use objc2_foundation::{MainThreadMarker, NSObject};
+use objc2_ui_kit::{
+    UIDevice, UIInterfaceOrientationMask, UIRectEdge, UIResponder, UIStatusBarStyle,
+    UIUserInterfaceIdiom, UIView, UIViewController,
+};
+
+use super::app_state::{self};
+use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
+use crate::window::WindowAttributes;
+
+pub struct ViewControllerState {
+    prefers_status_bar_hidden: Cell<bool>,
+    preferred_status_bar_style: Cell<UIStatusBarStyle>,
+    prefers_home_indicator_auto_hidden: Cell<bool>,
+    supported_orientations: Cell<UIInterfaceOrientationMask>,
+    preferred_screen_edges_deferring_system_gestures: Cell<UIRectEdge>,
+}
+
+declare_class!(
+    pub(crate) struct WinitViewController;
+
+    unsafe impl ClassType for WinitViewController {
+        #[inherits(UIResponder, NSObject)]
+        type Super = UIViewController;
+        type Mutability = mutability::MainThreadOnly;
+        const NAME: &'static str = "WinitUIViewController";
+    }
+
+    impl DeclaredClass for WinitViewController {
+        type Ivars = ViewControllerState;
+    }
+
+    unsafe impl WinitViewController {
+        #[method(shouldAutorotate)]
+        fn should_autorotate(&self) -> bool {
+            true
+        }
+
+        #[method(prefersStatusBarHidden)]
+        fn prefers_status_bar_hidden(&self) -> bool {
+            self.ivars().prefers_status_bar_hidden.get()
+        }
+
+        #[method(preferredStatusBarStyle)]
+        fn preferred_status_bar_style(&self) -> UIStatusBarStyle {
+            self.ivars().preferred_status_bar_style.get()
+        }
+
+        #[method(prefersHomeIndicatorAutoHidden)]
+        fn prefers_home_indicator_auto_hidden(&self) -> bool {
+            self.ivars().prefers_home_indicator_auto_hidden.get()
+        }
+
+        #[method(supportedInterfaceOrientations)]
+        fn supported_orientations(&self) -> UIInterfaceOrientationMask {
+            self.ivars().supported_orientations.get()
+        }
+
+        #[method(preferredScreenEdgesDeferringSystemGestures)]
+        fn preferred_screen_edges_deferring_system_gestures(&self) -> UIRectEdge {
+            self.ivars()
+                .preferred_screen_edges_deferring_system_gestures
+                .get()
+        }
+    }
+);
+
+impl WinitViewController {
+    pub(crate) fn set_prefers_status_bar_hidden(&self, val: bool) {
+        self.ivars().prefers_status_bar_hidden.set(val);
+        self.setNeedsStatusBarAppearanceUpdate();
+    }
+
+    pub(crate) fn set_preferred_status_bar_style(&self, val: StatusBarStyle) {
+        let val = match val {
+            StatusBarStyle::Default => UIStatusBarStyle::Default,
+            StatusBarStyle::LightContent => UIStatusBarStyle::LightContent,
+            StatusBarStyle::DarkContent => UIStatusBarStyle::DarkContent,
+        };
+        self.ivars().preferred_status_bar_style.set(val);
+        self.setNeedsStatusBarAppearanceUpdate();
+    }
+
+    pub(crate) fn set_prefers_home_indicator_auto_hidden(&self, val: bool) {
+        self.ivars().prefers_home_indicator_auto_hidden.set(val);
+        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: ScreenEdge) {
+        let val = {
+            assert_eq!(val.bits() & !ScreenEdge::ALL.bits(), 0, "invalid `ScreenEdge`");
+            UIRectEdge(val.bits().into())
+        };
+        self.ivars().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,
+        valid_orientations: ValidOrientations,
+    ) {
+        let mask = match (valid_orientations, UIDevice::currentDevice(mtm).userInterfaceIdiom()) {
+            (ValidOrientations::LandscapeAndPortrait, UIUserInterfaceIdiom::Phone) => {
+                UIInterfaceOrientationMask::AllButUpsideDown
+            },
+            (ValidOrientations::LandscapeAndPortrait, _) => UIInterfaceOrientationMask::All,
+            (ValidOrientations::Landscape, _) => UIInterfaceOrientationMask::Landscape,
+            (ValidOrientations::Portrait, UIUserInterfaceIdiom::Phone) => {
+                UIInterfaceOrientationMask::Portrait
+            },
+            (ValidOrientations::Portrait, _) => {
+                UIInterfaceOrientationMask::Portrait
+                    | UIInterfaceOrientationMask::PortraitUpsideDown
+            },
+        };
+        self.ivars().supported_orientations.set(mask);
+        #[allow(deprecated)]
+        UIViewController::attemptRotationToDeviceOrientation(mtm);
+    }
+
+    pub(crate) fn new(
+        mtm: MainThreadMarker,
+        window_attributes: &WindowAttributes,
+        view: &UIView,
+    ) -> Retained<Self> {
+        // These are set properly below, we just to set them to something in the meantime.
+        let this = mtm.alloc().set_ivars(ViewControllerState {
+            prefers_status_bar_hidden: Cell::new(false),
+            preferred_status_bar_style: Cell::new(UIStatusBarStyle::Default),
+            prefers_home_indicator_auto_hidden: Cell::new(false),
+            supported_orientations: Cell::new(UIInterfaceOrientationMask::All),
+            preferred_screen_edges_deferring_system_gestures: Cell::new(UIRectEdge::empty()),
+        });
+        let this: Retained<Self> = unsafe { msg_send_id![super(this), init] };
+
+        this.set_prefers_status_bar_hidden(
+            window_attributes.platform_specific.prefers_status_bar_hidden,
+        );
+
+        this.set_preferred_status_bar_style(
+            window_attributes.platform_specific.preferred_status_bar_style,
+        );
+
+        this.set_supported_interface_orientations(
+            mtm,
+            window_attributes.platform_specific.valid_orientations,
+        );
+
+        this.set_prefers_home_indicator_auto_hidden(
+            window_attributes.platform_specific.prefers_home_indicator_hidden,
+        );
+
+        this.set_preferred_screen_edges_deferring_system_gestures(
+            window_attributes.platform_specific.preferred_screen_edges_deferring_system_gestures,
+        );
+
+        this.setView(Some(view));
+
+        this
+    }
+}

vendor/winit/src/platform_impl/ios/window.rs

@@ -0,0 +1,750 @@
+#![allow(clippy::unnecessary_cast)]
+
+use std::collections::VecDeque;
+
+use objc2::rc::Retained;
+use objc2::runtime::{AnyObject, NSObject};
+use objc2::{class, declare_class, msg_send, msg_send_id, mutability, ClassType, DeclaredClass};
+use objc2_foundation::{
+    CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker, NSObjectProtocol,
+};
+use objc2_ui_kit::{
+    UIApplication, UICoordinateSpace, UIResponder, UIScreen, UIScreenOverscanCompensation,
+    UIViewController, UIWindow,
+};
+use tracing::{debug, warn};
+
+use super::app_state::EventWrapper;
+use super::view::WinitView;
+use super::view_controller::WinitViewController;
+use crate::cursor::Cursor;
+use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
+use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
+use crate::event::{Event, WindowEvent};
+use crate::icon::Icon;
+use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
+use crate::platform_impl::platform::{
+    app_state, monitor, ActiveEventLoop, Fullscreen, MonitorHandle,
+};
+use crate::window::{
+    CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, WindowAttributes,
+    WindowButtons, WindowId as RootWindowId, WindowLevel,
+};
+
+declare_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct WinitUIWindow;
+
+    unsafe impl ClassType for WinitUIWindow {
+        #[inherits(UIResponder, NSObject)]
+        type Super = UIWindow;
+        type Mutability = mutability::MainThreadOnly;
+        const NAME: &'static str = "WinitUIWindow";
+    }
+
+    impl DeclaredClass for WinitUIWindow {}
+
+    unsafe impl WinitUIWindow {
+        #[method(becomeKeyWindow)]
+        fn become_key_window(&self) {
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(
+                mtm,
+                EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id: RootWindowId(self.id()),
+                    event: WindowEvent::Focused(true),
+                }),
+            );
+            let _: () = unsafe { msg_send![super(self), becomeKeyWindow] };
+        }
+
+        #[method(resignKeyWindow)]
+        fn resign_key_window(&self) {
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(
+                mtm,
+                EventWrapper::StaticEvent(Event::WindowEvent {
+                    window_id: RootWindowId(self.id()),
+                    event: WindowEvent::Focused(false),
+                }),
+            );
+            let _: () = unsafe { msg_send![super(self), resignKeyWindow] };
+        }
+    }
+);
+
+impl WinitUIWindow {
+    pub(crate) fn new(
+        mtm: MainThreadMarker,
+        window_attributes: &WindowAttributes,
+        frame: CGRect,
+        view_controller: &UIViewController,
+    ) -> Retained<Self> {
+        let this: Retained<Self> = unsafe { msg_send_id![mtm.alloc(), initWithFrame: frame] };
+
+        this.setRootViewController(Some(view_controller));
+
+        match window_attributes.fullscreen.clone().map(Into::into) {
+            Some(Fullscreen::Exclusive(ref video_mode)) => {
+                let monitor = video_mode.monitor();
+                let screen = monitor.ui_screen(mtm);
+                screen.setCurrentMode(Some(video_mode.screen_mode(mtm)));
+                this.setScreen(screen);
+            },
+            Some(Fullscreen::Borderless(Some(ref monitor))) => {
+                let screen = monitor.ui_screen(mtm);
+                this.setScreen(screen);
+            },
+            _ => (),
+        }
+
+        this
+    }
+
+    pub(crate) fn id(&self) -> WindowId {
+        (self as *const Self as usize as u64).into()
+    }
+}
+
+pub struct Inner {
+    window: Retained<WinitUIWindow>,
+    view_controller: Retained<WinitViewController>,
+    view: Retained<WinitView>,
+    gl_or_metal_backed: bool,
+}
+
+impl Inner {
+    pub fn set_title(&self, _title: &str) {
+        debug!("`Window::set_title` is ignored on iOS")
+    }
+
+    pub fn set_transparent(&self, _transparent: bool) {
+        debug!("`Window::set_transparent` is ignored on iOS")
+    }
+
+    pub fn set_blur(&self, _blur: bool) {
+        debug!("`Window::set_blur` is ignored on iOS")
+    }
+
+    pub fn set_visible(&self, visible: bool) {
+        self.window.setHidden(!visible)
+    }
+
+    pub fn is_visible(&self) -> Option<bool> {
+        warn!("`Window::is_visible` is ignored on iOS");
+        None
+    }
+
+    pub fn request_redraw(&self) {
+        if self.gl_or_metal_backed {
+            let mtm = MainThreadMarker::new().unwrap();
+            // `setNeedsDisplay` does nothing on UIViews which are directly backed by CAEAGLLayer or
+            // CAMetalLayer. Ordinarily the OS sets up a bunch of UIKit state before
+            // calling drawRect: on a UIView, but when using raw or gl/metal for drawing
+            // this work is completely avoided.
+            //
+            // The docs for `setNeedsDisplay` don't mention `CAMetalLayer`; however, this has been
+            // confirmed via testing.
+            //
+            // https://developer.apple.com/documentation/uikit/uiview/1622437-setneedsdisplay?language=objc
+            app_state::queue_gl_or_metal_redraw(mtm, self.window.clone());
+        } else {
+            self.view.setNeedsDisplay();
+        }
+    }
+
+    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))
+    }
+
+    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))
+    }
+
+    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);
+    }
+
+    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)
+    }
+
+    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)
+    }
+
+    pub fn request_inner_size(&self, _size: Size) -> Option<PhysicalSize<u32>> {
+        Some(self.inner_size())
+    }
+
+    pub fn set_min_inner_size(&self, _dimensions: Option<Size>) {
+        warn!("`Window::set_min_inner_size` is ignored on iOS")
+    }
+
+    pub fn set_max_inner_size(&self, _dimensions: Option<Size>) {
+        warn!("`Window::set_max_inner_size` is ignored on iOS")
+    }
+
+    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        None
+    }
+
+    #[inline]
+    pub fn set_resize_increments(&self, _increments: Option<Size>) {
+        warn!("`Window::set_resize_increments` is ignored on iOS")
+    }
+
+    pub fn set_resizable(&self, _resizable: bool) {
+        warn!("`Window::set_resizable` is ignored on iOS")
+    }
+
+    pub fn is_resizable(&self) -> bool {
+        warn!("`Window::is_resizable` is ignored on iOS");
+        false
+    }
+
+    #[inline]
+    pub fn set_enabled_buttons(&self, _buttons: WindowButtons) {
+        warn!("`Window::set_enabled_buttons` is ignored on iOS");
+    }
+
+    #[inline]
+    pub fn enabled_buttons(&self) -> WindowButtons {
+        warn!("`Window::enabled_buttons` is ignored on iOS");
+        WindowButtons::all()
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        self.view.contentScaleFactor() as _
+    }
+
+    pub fn set_cursor(&self, _cursor: Cursor) {
+        debug!("`Window::set_cursor` ignored on iOS")
+    }
+
+    pub fn set_cursor_position(&self, _position: Position) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn set_cursor_grab(&self, _: CursorGrabMode) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn set_cursor_visible(&self, _visible: bool) {
+        debug!("`Window::set_cursor_visible` is ignored on iOS")
+    }
+
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    #[inline]
+    pub fn show_window_menu(&self, _position: Position) {}
+
+    pub fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn set_minimized(&self, _minimized: bool) {
+        warn!("`Window::set_minimized` is ignored on iOS")
+    }
+
+    pub fn is_minimized(&self) -> Option<bool> {
+        warn!("`Window::is_minimized` is ignored on iOS");
+        None
+    }
+
+    pub fn set_maximized(&self, _maximized: bool) {
+        warn!("`Window::set_maximized` is ignored on iOS")
+    }
+
+    pub fn is_maximized(&self) -> bool {
+        warn!("`Window::is_maximized` is ignored on iOS");
+        false
+    }
+
+    pub(crate) fn set_fullscreen(&self, monitor: Option<Fullscreen>) {
+        let mtm = MainThreadMarker::new().unwrap();
+        let uiscreen = match &monitor {
+            Some(Fullscreen::Exclusive(video_mode)) => {
+                let uiscreen = video_mode.monitor.ui_screen(mtm);
+                uiscreen.setCurrentMode(Some(video_mode.screen_mode(mtm)));
+                uiscreen.clone()
+            },
+            Some(Fullscreen::Borderless(Some(monitor))) => monitor.ui_screen(mtm).clone(),
+            Some(Fullscreen::Borderless(None)) => {
+                self.current_monitor_inner().ui_screen(mtm).clone()
+            },
+            None => {
+                warn!("`Window::set_fullscreen(None)` ignored on iOS");
+                return;
+            },
+        };
+
+        // this is pretty slow on iOS, so avoid doing it if we can
+        let current = self.window.screen();
+        if uiscreen != current {
+            self.window.setScreen(&uiscreen);
+        }
+
+        let bounds = uiscreen.bounds();
+        self.window.setFrame(bounds);
+
+        // For external displays, we must disable overscan compensation or
+        // the displayed image will have giant black bars surrounding it on
+        // each side
+        uiscreen.setOverscanCompensation(UIScreenOverscanCompensation::None);
+    }
+
+    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
+        let mtm = MainThreadMarker::new().unwrap();
+        let monitor = self.current_monitor_inner();
+        let uiscreen = monitor.ui_screen(mtm);
+        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
+        }
+    }
+
+    pub fn set_decorations(&self, _decorations: bool) {}
+
+    pub fn is_decorated(&self) -> bool {
+        true
+    }
+
+    pub fn set_window_level(&self, _level: WindowLevel) {
+        warn!("`Window::set_window_level` is ignored on iOS")
+    }
+
+    pub fn set_window_icon(&self, _icon: Option<Icon>) {
+        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")
+    }
+
+    /// Show / hide the keyboard. To show the keyboard, we call `becomeFirstResponder`,
+    /// requesting focus for the [WinitView]. Since [WinitView] implements
+    /// [objc2_ui_kit::UIKeyInput], the keyboard will be shown.
+    /// <https://developer.apple.com/documentation/uikit/uiresponder/1621113-becomefirstresponder>
+    pub fn set_ime_allowed(&self, allowed: bool) {
+        if allowed {
+            unsafe {
+                self.view.becomeFirstResponder();
+            }
+        } else {
+            unsafe {
+                self.view.resignFirstResponder();
+            }
+        }
+    }
+
+    pub fn set_ime_purpose(&self, _purpose: ImePurpose) {
+        warn!("`Window::set_ime_purpose` is ignored on iOS")
+    }
+
+    pub fn focus_window(&self) {
+        warn!("`Window::set_focus` is ignored on iOS")
+    }
+
+    pub fn request_user_attention(&self, _request_type: Option<UserAttentionType>) {
+        warn!("`Window::request_user_attention` is ignored on iOS")
+    }
+
+    // Allow directly accessing the current monitor internally without unwrapping.
+    fn current_monitor_inner(&self) -> MonitorHandle {
+        MonitorHandle::new(self.window.screen())
+    }
+
+    pub fn current_monitor(&self) -> Option<MonitorHandle> {
+        Some(self.current_monitor_inner())
+    }
+
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        monitor::uiscreens(MainThreadMarker::new().unwrap())
+    }
+
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        #[allow(deprecated)]
+        Some(MonitorHandle::new(UIScreen::mainScreen(MainThreadMarker::new().unwrap())))
+    }
+
+    pub fn id(&self) -> WindowId {
+        self.window.id()
+    }
+
+    #[cfg(feature = "rwh_04")]
+    pub fn raw_window_handle_rwh_04(&self) -> rwh_04::RawWindowHandle {
+        let mut window_handle = rwh_04::UiKitHandle::empty();
+        window_handle.ui_window = Retained::as_ptr(&self.window) as _;
+        window_handle.ui_view = Retained::as_ptr(&self.view) as _;
+        window_handle.ui_view_controller = Retained::as_ptr(&self.view_controller) as _;
+        rwh_04::RawWindowHandle::UiKit(window_handle)
+    }
+
+    #[cfg(feature = "rwh_05")]
+    pub fn raw_window_handle_rwh_05(&self) -> rwh_05::RawWindowHandle {
+        let mut window_handle = rwh_05::UiKitWindowHandle::empty();
+        window_handle.ui_window = Retained::as_ptr(&self.window) as _;
+        window_handle.ui_view = Retained::as_ptr(&self.view) as _;
+        window_handle.ui_view_controller = Retained::as_ptr(&self.view_controller) as _;
+        rwh_05::RawWindowHandle::UiKit(window_handle)
+    }
+
+    #[cfg(feature = "rwh_05")]
+    pub fn raw_display_handle_rwh_05(&self) -> rwh_05::RawDisplayHandle {
+        rwh_05::RawDisplayHandle::UiKit(rwh_05::UiKitDisplayHandle::empty())
+    }
+
+    #[cfg(feature = "rwh_06")]
+    pub fn raw_window_handle_rwh_06(&self) -> rwh_06::RawWindowHandle {
+        let mut window_handle = rwh_06::UiKitWindowHandle::new({
+            let ui_view = Retained::as_ptr(&self.view) as _;
+            std::ptr::NonNull::new(ui_view).expect("Retained<T> should never be null")
+        });
+        window_handle.ui_view_controller =
+            std::ptr::NonNull::new(Retained::as_ptr(&self.view_controller) as _);
+        rwh_06::RawWindowHandle::UiKit(window_handle)
+    }
+
+    pub fn theme(&self) -> Option<Theme> {
+        warn!("`Window::theme` is ignored on iOS");
+        None
+    }
+
+    pub fn set_content_protected(&self, _protected: bool) {}
+
+    pub fn has_focus(&self) -> bool {
+        self.window.isKeyWindow()
+    }
+
+    #[inline]
+    pub fn set_theme(&self, _theme: Option<Theme>) {
+        warn!("`Window::set_theme` is ignored on iOS");
+    }
+
+    pub fn title(&self) -> String {
+        warn!("`Window::title` is ignored on iOS");
+        String::new()
+    }
+
+    pub fn reset_dead_keys(&self) {
+        // Noop
+    }
+}
+
+pub struct Window {
+    inner: MainThreadBound<Inner>,
+}
+
+impl Window {
+    pub(crate) fn new(
+        event_loop: &ActiveEventLoop,
+        window_attributes: WindowAttributes,
+    ) -> Result<Window, RootOsError> {
+        let mtm = event_loop.mtm;
+
+        if window_attributes.min_inner_size.is_some() {
+            warn!("`WindowAttributes::min_inner_size` is ignored on iOS");
+        }
+        if window_attributes.max_inner_size.is_some() {
+            warn!("`WindowAttributes::max_inner_size` is ignored on iOS");
+        }
+
+        // TODO: transparency, visible
+
+        #[allow(deprecated)]
+        let main_screen = UIScreen::mainScreen(mtm);
+        let fullscreen = window_attributes.fullscreen.clone().map(Into::into);
+        let screen = match fullscreen {
+            Some(Fullscreen::Exclusive(ref video_mode)) => video_mode.monitor.ui_screen(mtm),
+            Some(Fullscreen::Borderless(Some(ref monitor))) => monitor.ui_screen(mtm),
+            Some(Fullscreen::Borderless(None)) | None => &main_screen,
+        };
+
+        let screen_bounds = screen.bounds();
+
+        let frame = match window_attributes.inner_size {
+            Some(dim) => {
+                let scale_factor = screen.scale();
+                let size = dim.to_logical::<f64>(scale_factor as f64);
+                CGRect {
+                    origin: screen_bounds.origin,
+                    size: CGSize { width: size.width as _, height: size.height as _ },
+                }
+            },
+            None => screen_bounds,
+        };
+
+        let view = WinitView::new(mtm, &window_attributes, frame);
+
+        let gl_or_metal_backed =
+            view.isKindOfClass(class!(CAMetalLayer)) || view.isKindOfClass(class!(CAEAGLLayer));
+
+        let view_controller = WinitViewController::new(mtm, &window_attributes, &view);
+        let window = WinitUIWindow::new(mtm, &window_attributes, frame, &view_controller);
+
+        app_state::set_key_window(mtm, &window);
+
+        // Like the Windows and macOS backends, we send a `ScaleFactorChanged` and `Resized`
+        // event on window creation if the DPI factor != 1.0
+        let scale_factor = view.contentScaleFactor();
+        let scale_factor = scale_factor as f64;
+        if scale_factor != 1.0 {
+            let bounds = view.bounds();
+            let screen = window.screen();
+            let screen_space = screen.coordinateSpace();
+            let screen_frame = view.convertRect_toCoordinateSpace(bounds, &screen_space);
+            let size = LogicalSize {
+                width: screen_frame.size.width as f64,
+                height: screen_frame.size.height as f64,
+            };
+            let window_id = RootWindowId(window.id());
+            app_state::handle_nonuser_events(
+                mtm,
+                std::iter::once(EventWrapper::ScaleFactorChanged(app_state::ScaleFactorChanged {
+                    window: window.clone(),
+                    scale_factor,
+                    suggested_size: size.to_physical(scale_factor),
+                }))
+                .chain(std::iter::once(EventWrapper::StaticEvent(
+                    Event::WindowEvent {
+                        window_id,
+                        event: WindowEvent::Resized(size.to_physical(scale_factor)),
+                    },
+                ))),
+            );
+        }
+
+        let inner = Inner { window, view_controller, view, gl_or_metal_backed };
+        Ok(Window { inner: MainThreadBound::new(inner, mtm) })
+    }
+
+    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| f(inner))
+    }
+
+    #[cfg(feature = "rwh_06")]
+    #[inline]
+    pub(crate) fn raw_window_handle_rwh_06(
+        &self,
+    ) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
+        if let Some(mtm) = MainThreadMarker::new() {
+            Ok(self.inner.get(mtm).raw_window_handle_rwh_06())
+        } else {
+            Err(rwh_06::HandleError::Unavailable)
+        }
+    }
+
+    #[cfg(feature = "rwh_06")]
+    #[inline]
+    pub(crate) fn raw_display_handle_rwh_06(
+        &self,
+    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
+        Ok(rwh_06::RawDisplayHandle::UiKit(rwh_06::UiKitDisplayHandle::new()))
+    }
+}
+
+// WindowExtIOS
+impl Inner {
+    pub fn set_scale_factor(&self, scale_factor: f64) {
+        assert!(
+            dpi::validate_scale_factor(scale_factor),
+            "`WindowExtIOS::set_scale_factor` received an invalid hidpi factor"
+        );
+        let scale_factor = scale_factor as CGFloat;
+        self.view.setContentScaleFactor(scale_factor);
+    }
+
+    pub fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
+        self.view_controller.set_supported_interface_orientations(
+            MainThreadMarker::new().unwrap(),
+            valid_orientations,
+        );
+    }
+
+    pub fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
+        self.view_controller.set_prefers_home_indicator_auto_hidden(hidden);
+    }
+
+    pub fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
+        self.view_controller.set_preferred_screen_edges_deferring_system_gestures(edges);
+    }
+
+    pub fn set_prefers_status_bar_hidden(&self, hidden: bool) {
+        self.view_controller.set_prefers_status_bar_hidden(hidden);
+    }
+
+    pub fn set_preferred_status_bar_style(&self, status_bar_style: StatusBarStyle) {
+        self.view_controller.set_preferred_status_bar_style(status_bar_style);
+    }
+
+    pub fn recognize_pinch_gesture(&self, should_recognize: bool) {
+        self.view.recognize_pinch_gesture(should_recognize);
+    }
+
+    pub fn recognize_pan_gesture(
+        &self,
+        should_recognize: bool,
+        minimum_number_of_touches: u8,
+        maximum_number_of_touches: u8,
+    ) {
+        self.view.recognize_pan_gesture(
+            should_recognize,
+            minimum_number_of_touches,
+            maximum_number_of_touches,
+        );
+    }
+
+    pub fn recognize_doubletap_gesture(&self, should_recognize: bool) {
+        self.view.recognize_doubletap_gesture(should_recognize);
+    }
+
+    pub fn recognize_rotation_gesture(&self, should_recognize: bool) {
+        self.view.recognize_rotation_gesture(should_recognize);
+    }
+}
+
+impl Inner {
+    fn screen_frame(&self) -> CGRect {
+        self.rect_to_screen_space(self.window.bounds())
+    }
+
+    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 {
+        let screen_space = self.window.screen().coordinateSpace();
+        self.window.convertRect_fromCoordinateSpace(rect, &screen_space)
+    }
+
+    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();
+            let safe_bounds = CGRect {
+                origin: CGPoint {
+                    x: bounds.origin.x + safe_area.left,
+                    y: bounds.origin.y + safe_area.top,
+                },
+                size: CGSize {
+                    width: bounds.size.width - safe_area.left - safe_area.right,
+                    height: bounds.size.height - safe_area.top - safe_area.bottom,
+                },
+            };
+            self.rect_to_screen_space(safe_bounds)
+        } else {
+            let screen_frame = self.rect_to_screen_space(bounds);
+            let status_bar_frame = {
+                let app = UIApplication::sharedApplication(MainThreadMarker::new().unwrap());
+                #[allow(deprecated)]
+                app.statusBarFrame()
+            };
+            let (y, height) = if screen_frame.origin.y > status_bar_frame.size.height {
+                (screen_frame.origin.y, screen_frame.size.height)
+            } else {
+                let y = status_bar_frame.size.height;
+                let height = screen_frame.size.height
+                    - (status_bar_frame.size.height - screen_frame.origin.y);
+                (y, height)
+            };
+            CGRect {
+                origin: CGPoint { x: screen_frame.origin.x, y },
+                size: CGSize { width: screen_frame.size.width, height },
+            }
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct WindowId {
+    window: *mut WinitUIWindow,
+}
+
+impl WindowId {
+    pub const fn dummy() -> Self {
+        WindowId { window: std::ptr::null_mut() }
+    }
+}
+
+impl From<WindowId> for u64 {
+    fn from(window_id: WindowId) -> Self {
+        window_id.window as u64
+    }
+}
+
+impl From<u64> for WindowId {
+    fn from(raw_id: u64) -> Self {
+        Self { window: raw_id as _ }
+    }
+}
+
+unsafe impl Send for WindowId {}
+unsafe impl Sync for WindowId {}
+
+impl From<&AnyObject> for WindowId {
+    fn from(window: &AnyObject) -> WindowId {
+        WindowId { window: window as *const _ as _ }
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct PlatformSpecificWindowAttributes {
+    pub scale_factor: Option<f64>,
+    pub valid_orientations: ValidOrientations,
+    pub prefers_home_indicator_hidden: bool,
+    pub prefers_status_bar_hidden: bool,
+    pub preferred_status_bar_style: StatusBarStyle,
+    pub preferred_screen_edges_deferring_system_gestures: ScreenEdge,
+}

vendor/winit/src/platform_impl/linux/common/mod.rs

@@ -0,0 +1 @@
+pub mod xkb;

vendor/winit/src/platform_impl/linux/common/xkb/compose.rs

@@ -0,0 +1,123 @@
+//! XKB compose handling.
+
+use std::env;
+use std::ffi::CString;
+use std::ops::Deref;
+use std::os::unix::ffi::OsStringExt;
+use std::ptr::NonNull;
+
+use super::{XkbContext, XKBCH};
+use smol_str::SmolStr;
+use xkbcommon_dl::{
+    xkb_compose_compile_flags, xkb_compose_feed_result, xkb_compose_state, xkb_compose_state_flags,
+    xkb_compose_status, xkb_compose_table, xkb_keysym_t,
+};
+
+#[derive(Debug)]
+pub struct XkbComposeTable {
+    table: NonNull<xkb_compose_table>,
+}
+
+impl XkbComposeTable {
+    pub fn new(context: &XkbContext) -> Option<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 table = unsafe {
+            (XKBCH.xkb_compose_table_new_from_locale)(
+                context.as_ptr(),
+                locale.as_ptr(),
+                xkb_compose_compile_flags::XKB_COMPOSE_COMPILE_NO_FLAGS,
+            )
+        };
+
+        let table = NonNull::new(table)?;
+        Some(Self { table })
+    }
+
+    /// Create new state with the given compose table.
+    pub fn new_state(&self) -> Option<XkbComposeState> {
+        let state = unsafe {
+            (XKBCH.xkb_compose_state_new)(
+                self.table.as_ptr(),
+                xkb_compose_state_flags::XKB_COMPOSE_STATE_NO_FLAGS,
+            )
+        };
+
+        let state = NonNull::new(state)?;
+        Some(XkbComposeState { state })
+    }
+}
+
+impl Deref for XkbComposeTable {
+    type Target = NonNull<xkb_compose_table>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.table
+    }
+}
+
+impl Drop for XkbComposeTable {
+    fn drop(&mut self) {
+        unsafe {
+            (XKBCH.xkb_compose_table_unref)(self.table.as_ptr());
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct XkbComposeState {
+    state: NonNull<xkb_compose_state>,
+}
+
+impl XkbComposeState {
+    pub fn get_string(&mut self, scratch_buffer: &mut Vec<u8>) -> Option<SmolStr> {
+        super::make_string_with(scratch_buffer, |ptr, len| unsafe {
+            (XKBCH.xkb_compose_state_get_utf8)(self.state.as_ptr(), ptr, len)
+        })
+    }
+
+    #[inline]
+    pub fn feed(&mut self, keysym: xkb_keysym_t) -> ComposeStatus {
+        let feed_result = unsafe { (XKBCH.xkb_compose_state_feed)(self.state.as_ptr(), keysym) };
+        match feed_result {
+            xkb_compose_feed_result::XKB_COMPOSE_FEED_IGNORED => ComposeStatus::Ignored,
+            xkb_compose_feed_result::XKB_COMPOSE_FEED_ACCEPTED => {
+                ComposeStatus::Accepted(self.status())
+            },
+        }
+    }
+
+    #[inline]
+    pub fn reset(&mut self) {
+        unsafe {
+            (XKBCH.xkb_compose_state_reset)(self.state.as_ptr());
+        }
+    }
+
+    #[inline]
+    pub fn status(&mut self) -> xkb_compose_status {
+        unsafe { (XKBCH.xkb_compose_state_get_status)(self.state.as_ptr()) }
+    }
+}
+
+impl Drop for XkbComposeState {
+    fn drop(&mut self) {
+        unsafe {
+            (XKBCH.xkb_compose_state_unref)(self.state.as_ptr());
+        };
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub enum ComposeStatus {
+    Accepted(xkb_compose_status),
+    Ignored,
+    None,
+}

vendor/winit/src/platform_impl/linux/common/xkb/mod.rs

@@ -0,0 +1,416 @@
+use std::ops::Deref;
+use std::os::raw::c_char;
+use std::ptr::{self, NonNull};
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use crate::utils::Lazy;
+use smol_str::SmolStr;
+#[cfg(wayland_platform)]
+use std::os::unix::io::OwnedFd;
+use tracing::warn;
+use xkbcommon_dl::{
+    self as xkb, xkb_compose_status, xkb_context, xkb_context_flags, xkbcommon_compose_handle,
+    xkbcommon_handle, XkbCommon, XkbCommonCompose,
+};
+#[cfg(x11_platform)]
+use {x11_dl::xlib_xcb::xcb_connection_t, xkbcommon_dl::x11::xkbcommon_x11_handle};
+
+use crate::event::{ElementState, KeyEvent};
+use crate::keyboard::{Key, KeyLocation};
+use crate::platform_impl::KeyEventExtra;
+
+mod compose;
+mod keymap;
+mod state;
+
+use compose::{ComposeStatus, XkbComposeState, XkbComposeTable};
+use keymap::XkbKeymap;
+
+#[cfg(x11_platform)]
+pub use keymap::raw_keycode_to_physicalkey;
+pub use keymap::{physicalkey_to_scancode, scancode_to_physicalkey};
+pub use state::XkbState;
+
+// TODO: Wire this up without using a static `AtomicBool`.
+static RESET_DEAD_KEYS: AtomicBool = AtomicBool::new(false);
+
+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 xkb::x11::XkbCommonX11> = Lazy::new(xkbcommon_x11_handle);
+
+#[inline(always)]
+pub fn reset_dead_keys() {
+    RESET_DEAD_KEYS.store(true, Ordering::SeqCst);
+}
+
+#[derive(Debug)]
+pub enum Error {
+    /// libxkbcommon is not available
+    XKBNotFound,
+}
+
+#[derive(Debug)]
+pub struct Context {
+    // NOTE: field order matters.
+    #[cfg(x11_platform)]
+    pub core_keyboard_id: i32,
+    state: Option<XkbState>,
+    keymap: Option<XkbKeymap>,
+    compose_state1: Option<XkbComposeState>,
+    compose_state2: Option<XkbComposeState>,
+    _compose_table: Option<XkbComposeTable>,
+    context: XkbContext,
+    scratch_buffer: Vec<u8>,
+}
+
+impl Context {
+    pub fn new() -> Result<Self, Error> {
+        if xkb::xkbcommon_option().is_none() {
+            return Err(Error::XKBNotFound);
+        }
+
+        let context = XkbContext::new()?;
+        let mut compose_table = XkbComposeTable::new(&context);
+        let mut compose_state1 = compose_table.as_ref().and_then(|table| table.new_state());
+        let mut compose_state2 = compose_table.as_ref().and_then(|table| table.new_state());
+
+        // Disable compose if anything compose related failed to initialize.
+        if compose_table.is_none() || compose_state1.is_none() || compose_state2.is_none() {
+            compose_state2 = None;
+            compose_state1 = None;
+            compose_table = None;
+        }
+
+        Ok(Self {
+            state: None,
+            keymap: None,
+            compose_state1,
+            compose_state2,
+            #[cfg(x11_platform)]
+            core_keyboard_id: 0,
+            _compose_table: compose_table,
+            context,
+            scratch_buffer: Vec::with_capacity(8),
+        })
+    }
+
+    #[cfg(feature = "x11")]
+    pub fn from_x11_xkb(xcb: *mut xcb_connection_t) -> Result<Self, Error> {
+        let result = unsafe {
+            (XKBXH.xkb_x11_setup_xkb_extension)(
+                xcb,
+                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(),
+            )
+        };
+
+        if result != 1 {
+            return Err(Error::XKBNotFound);
+        }
+
+        let mut this = Self::new()?;
+        this.core_keyboard_id = unsafe { (XKBXH.xkb_x11_get_core_keyboard_device_id)(xcb) };
+        this.set_keymap_from_x11(xcb);
+        Ok(this)
+    }
+
+    pub fn state_mut(&mut self) -> Option<&mut XkbState> {
+        self.state.as_mut()
+    }
+
+    pub fn keymap_mut(&mut self) -> Option<&mut XkbKeymap> {
+        self.keymap.as_mut()
+    }
+
+    #[cfg(wayland_platform)]
+    pub fn set_keymap_from_fd(&mut self, fd: OwnedFd, size: usize) {
+        let keymap = XkbKeymap::from_fd(&self.context, fd, size);
+        let state = keymap.as_ref().and_then(XkbState::new_wayland);
+        if keymap.is_none() || state.is_none() {
+            warn!("failed to update xkb keymap");
+        }
+        self.state = state;
+        self.keymap = keymap;
+    }
+
+    #[cfg(x11_platform)]
+    pub fn set_keymap_from_x11(&mut self, xcb: *mut xcb_connection_t) {
+        let keymap = XkbKeymap::from_x11_keymap(&self.context, xcb, self.core_keyboard_id);
+        let state = keymap.as_ref().and_then(|keymap| XkbState::new_x11(xcb, keymap));
+        if keymap.is_none() || state.is_none() {
+            warn!("failed to update xkb keymap");
+        }
+        self.state = state;
+        self.keymap = keymap;
+    }
+
+    /// Key builder context with the user provided xkb state.
+    pub fn key_context(&mut self) -> Option<KeyContext<'_>> {
+        let state = self.state.as_mut()?;
+        let keymap = self.keymap.as_mut()?;
+        let compose_state1 = self.compose_state1.as_mut();
+        let compose_state2 = self.compose_state2.as_mut();
+        let scratch_buffer = &mut self.scratch_buffer;
+        Some(KeyContext { state, keymap, compose_state1, compose_state2, scratch_buffer })
+    }
+
+    /// Key builder context with the user provided xkb state.
+    ///
+    /// Should be used when the original context must not be altered.
+    #[cfg(x11_platform)]
+    pub fn key_context_with_state<'a>(
+        &'a mut self,
+        state: &'a mut XkbState,
+    ) -> Option<KeyContext<'a>> {
+        let keymap = self.keymap.as_mut()?;
+        let compose_state1 = self.compose_state1.as_mut();
+        let compose_state2 = self.compose_state2.as_mut();
+        let scratch_buffer = &mut self.scratch_buffer;
+        Some(KeyContext { state, keymap, compose_state1, compose_state2, scratch_buffer })
+    }
+}
+
+pub struct KeyContext<'a> {
+    pub state: &'a mut XkbState,
+    pub keymap: &'a mut XkbKeymap,
+    compose_state1: Option<&'a mut XkbComposeState>,
+    compose_state2: Option<&'a mut XkbComposeState>,
+    scratch_buffer: &'a mut Vec<u8>,
+}
+
+impl KeyContext<'_> {
+    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 = keymap::raw_keycode_to_physicalkey(keycode);
+        let (logical_key, location) = event.key();
+        let text = event.text();
+        let (key_without_modifiers, _) = event.key_without_modifiers();
+        let text_with_all_modifiers = event.text_with_all_modifiers();
+
+        let platform_specific = KeyEventExtra { text_with_all_modifiers, key_without_modifiers };
+
+        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)
+    }
+}
+
+struct KeyEventResults<'a, 'b> {
+    context: &'a mut KeyContext<'b>,
+    keycode: u32,
+    keysym: u32,
+    compose: ComposeStatus,
+}
+
+impl<'a, 'b> KeyEventResults<'a, 'b> {
+    fn new(context: &'a mut KeyContext<'b>, keycode: u32, compose: bool) -> Self {
+        let keysym = context.state.get_one_sym_raw(keycode);
+
+        let compose = if let Some(state) = context.compose_state1.as_mut().filter(|_| compose) {
+            if RESET_DEAD_KEYS.swap(false, Ordering::SeqCst) {
+                state.reset();
+                context.compose_state2.as_mut().unwrap().reset();
+            }
+            state.feed(keysym)
+        } else {
+            ComposeStatus::None
+        };
+
+        KeyEventResults { context, keycode, keysym, compose }
+    }
+
+    pub fn key(&mut self) -> (Key, KeyLocation) {
+        let (key, location) = match self.keysym_to_key(self.keysym) {
+            Ok(known) => return known,
+            Err(undefined) => undefined,
+        };
+
+        if let ComposeStatus::Accepted(xkb_compose_status::XKB_COMPOSE_COMPOSING) = self.compose {
+            let compose_state = self.context.compose_state2.as_mut().unwrap();
+            // 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.
+
+            compose_state.feed(self.keysym);
+            if matches!(compose_state.feed(self.keysym), ComposeStatus::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`.
+                let text = compose_state.get_string(self.context.scratch_buffer);
+                let key = Key::Dead(text.and_then(|s| s.chars().next()));
+                (key, location)
+            } else {
+                (key, location)
+            }
+        } else {
+            let key = self
+                .composed_text()
+                .unwrap_or_else(|_| self.context.keysym_to_utf8_raw(self.keysym))
+                .map(Key::Character)
+                .unwrap_or(key);
+            (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 layout = self.context.state.layout(self.keycode);
+        let keysym = self.context.keymap.first_keysym_by_level(layout, self.keycode);
+
+        match self.keysym_to_key(keysym) {
+            Ok((key, location)) => (key, location),
+            Err((key, location)) => {
+                let key =
+                    self.context.keysym_to_utf8_raw(keysym).map(Key::Character).unwrap_or(key);
+                (key, location)
+            },
+        }
+    }
+
+    fn keysym_to_key(&self, keysym: u32) -> Result<(Key, KeyLocation), (Key, KeyLocation)> {
+        let location = keymap::keysym_location(keysym);
+        let key = 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.context.keysym_to_utf8_raw(self.keysym))
+    }
+
+    // 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 opposite behaviour.
+    pub fn text_with_all_modifiers(&mut self) -> Option<SmolStr> {
+        match self.composed_text() {
+            Ok(text) => text,
+            Err(_) => self.context.state.get_utf8_raw(self.keycode, self.context.scratch_buffer),
+        }
+    }
+
+    fn composed_text(&mut self) -> Result<Option<SmolStr>, ()> {
+        match self.compose {
+            ComposeStatus::Accepted(status) => match status {
+                xkb_compose_status::XKB_COMPOSE_COMPOSED => {
+                    let state = self.context.compose_state1.as_mut().unwrap();
+                    Ok(state.get_string(self.context.scratch_buffer))
+                },
+                xkb_compose_status::XKB_COMPOSE_COMPOSING
+                | xkb_compose_status::XKB_COMPOSE_CANCELLED => Ok(None),
+                xkb_compose_status::XKB_COMPOSE_NOTHING => Err(()),
+            },
+            _ => Err(()),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct XkbContext {
+    context: NonNull<xkb_context>,
+}
+
+impl XkbContext {
+    pub fn new() -> Result<Self, Error> {
+        let context = unsafe { (XKBH.xkb_context_new)(xkb_context_flags::XKB_CONTEXT_NO_FLAGS) };
+
+        let context = match NonNull::new(context) {
+            Some(context) => context,
+            None => return Err(Error::XKBNotFound),
+        };
+
+        Ok(Self { context })
+    }
+}
+
+impl Drop for XkbContext {
+    fn drop(&mut self) {
+        unsafe {
+            (XKBH.xkb_context_unref)(self.context.as_ptr());
+        }
+    }
+}
+
+impl Deref for XkbContext {
+    type Target = NonNull<xkb_context>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.context
+    }
+}
+
+/// Shared logic for constructing a string with `xkb_compose_state_get_utf8` and
+/// `xkb_state_key_get_utf8`.
+fn make_string_with<F>(scratch_buffer: &mut Vec<u8>, 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();
+    scratch_buffer.clear();
+    // The allocated buffer must include space for the null-terminator.
+    scratch_buffer.reserve(size + 1);
+    unsafe {
+        let written = f(scratch_buffer.as_mut_ptr().cast(), scratch_buffer.capacity());
+        if usize::try_from(written).unwrap() != size {
+            // This will likely never happen.
+            return None;
+        }
+        scratch_buffer.set_len(size);
+    };
+
+    byte_slice_to_smol_str(scratch_buffer)
+}
+
+// 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| {
+            tracing::warn!("UTF-8 received from libxkbcommon ({:?}) was invalid: {e}", bytes)
+        })
+        .ok()
+}

vendor/winit/src/platform_impl/linux/common/xkb/state.rs

@@ -0,0 +1,189 @@
+//! XKB state.
+
+use std::os::raw::c_char;
+use std::ptr::NonNull;
+
+use smol_str::SmolStr;
+#[cfg(x11_platform)]
+use x11_dl::xlib_xcb::xcb_connection_t;
+use xkbcommon_dl::{
+    self as xkb, xkb_keycode_t, xkb_keysym_t, xkb_layout_index_t, xkb_state, xkb_state_component,
+};
+
+use crate::platform_impl::common::xkb::keymap::XkbKeymap;
+#[cfg(x11_platform)]
+use crate::platform_impl::common::xkb::XKBXH;
+use crate::platform_impl::common::xkb::{make_string_with, XKBH};
+
+#[derive(Debug)]
+pub struct XkbState {
+    state: NonNull<xkb_state>,
+    modifiers: ModifiersState,
+}
+
+impl XkbState {
+    #[cfg(wayland_platform)]
+    pub fn new_wayland(keymap: &XkbKeymap) -> Option<Self> {
+        let state = NonNull::new(unsafe { (XKBH.xkb_state_new)(keymap.as_ptr()) })?;
+        Some(Self::new_inner(state))
+    }
+
+    #[cfg(x11_platform)]
+    pub fn new_x11(xcb: *mut xcb_connection_t, keymap: &XkbKeymap) -> Option<Self> {
+        let state = unsafe {
+            (XKBXH.xkb_x11_state_new_from_device)(keymap.as_ptr(), xcb, keymap._core_keyboard_id)
+        };
+        let state = NonNull::new(state)?;
+        Some(Self::new_inner(state))
+    }
+
+    fn new_inner(state: NonNull<xkb_state>) -> Self {
+        let modifiers = ModifiersState::default();
+        let mut this = Self { state, modifiers };
+        this.reload_modifiers();
+        this
+    }
+
+    pub fn get_one_sym_raw(&mut self, keycode: xkb_keycode_t) -> xkb_keysym_t {
+        unsafe { (XKBH.xkb_state_key_get_one_sym)(self.state.as_ptr(), keycode) }
+    }
+
+    pub fn layout(&mut self, key: xkb_keycode_t) -> xkb_layout_index_t {
+        unsafe { (XKBH.xkb_state_key_get_layout)(self.state.as_ptr(), key) }
+    }
+
+    #[cfg(x11_platform)]
+    pub fn depressed_modifiers(&mut self) -> xkb::xkb_mod_mask_t {
+        unsafe {
+            (XKBH.xkb_state_serialize_mods)(
+                self.state.as_ptr(),
+                xkb_state_component::XKB_STATE_MODS_DEPRESSED,
+            )
+        }
+    }
+
+    #[cfg(x11_platform)]
+    pub fn latched_modifiers(&mut self) -> xkb::xkb_mod_mask_t {
+        unsafe {
+            (XKBH.xkb_state_serialize_mods)(
+                self.state.as_ptr(),
+                xkb_state_component::XKB_STATE_MODS_LATCHED,
+            )
+        }
+    }
+
+    #[cfg(x11_platform)]
+    pub fn locked_modifiers(&mut self) -> xkb::xkb_mod_mask_t {
+        unsafe {
+            (XKBH.xkb_state_serialize_mods)(
+                self.state.as_ptr(),
+                xkb_state_component::XKB_STATE_MODS_LOCKED,
+            )
+        }
+    }
+
+    pub fn get_utf8_raw(
+        &mut self,
+        keycode: xkb_keycode_t,
+        scratch_buffer: &mut Vec<u8>,
+    ) -> Option<SmolStr> {
+        make_string_with(scratch_buffer, |ptr, len| unsafe {
+            (XKBH.xkb_state_key_get_utf8)(self.state.as_ptr(), keycode, ptr, len)
+        })
+    }
+
+    pub fn modifiers(&self) -> ModifiersState {
+        self.modifiers
+    }
+
+    pub fn update_modifiers(
+        &mut self,
+        mods_depressed: u32,
+        mods_latched: u32,
+        mods_locked: u32,
+        depressed_group: u32,
+        latched_group: u32,
+        locked_group: u32,
+    ) {
+        let mask = unsafe {
+            (XKBH.xkb_state_update_mask)(
+                self.state.as_ptr(),
+                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.reload_modifiers();
+        }
+    }
+
+    /// Reload the modifiers.
+    fn reload_modifiers(&mut self) {
+        self.modifiers.ctrl = self.mod_name_is_active(xkb::XKB_MOD_NAME_CTRL);
+        self.modifiers.alt = self.mod_name_is_active(xkb::XKB_MOD_NAME_ALT);
+        self.modifiers.shift = self.mod_name_is_active(xkb::XKB_MOD_NAME_SHIFT);
+        self.modifiers.caps_lock = self.mod_name_is_active(xkb::XKB_MOD_NAME_CAPS);
+        self.modifiers.logo = self.mod_name_is_active(xkb::XKB_MOD_NAME_LOGO);
+        self.modifiers.num_lock = self.mod_name_is_active(xkb::XKB_MOD_NAME_NUM);
+    }
+
+    /// Check if the modifier is active within xkb.
+    fn mod_name_is_active(&mut self, name: &[u8]) -> bool {
+        unsafe {
+            (XKBH.xkb_state_mod_name_is_active)(
+                self.state.as_ptr(),
+                name.as_ptr() as *const c_char,
+                xkb_state_component::XKB_STATE_MODS_EFFECTIVE,
+            ) > 0
+        }
+    }
+}
+
+impl Drop for XkbState {
+    fn drop(&mut self) {
+        unsafe {
+            (XKBH.xkb_state_unref)(self.state.as_ptr());
+        }
+    }
+}
+
+/// 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 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
+    }
+}

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

@@ -0,0 +1,810 @@
+//! The event-loop routines.
+
+use std::cell::{Cell, RefCell};
+use std::io::Result as IOResult;
+use std::marker::PhantomData;
+use std::mem;
+use std::os::fd::OwnedFd;
+use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
+use std::rc::Rc;
+use std::sync::atomic::Ordering;
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread::JoinHandle;
+use std::time::{Duration, Instant};
+
+use calloop::ping::Ping;
+use rustix::event::{PollFd, PollFlags};
+use rustix::pipe::{self, PipeFlags};
+use sctk::reexports::calloop::Error as CalloopError;
+use sctk::reexports::calloop_wayland_source::WaylandSource;
+use sctk::reexports::client::{globals, Connection, QueueHandle};
+use tracing::warn;
+
+use crate::cursor::OnlyCursorImage;
+use crate::dpi::LogicalSize;
+use crate::error::{EventLoopError, OsError as RootOsError};
+use crate::event::{Event, InnerSizeWriter, StartCause, WindowEvent};
+use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents};
+use crate::platform::pump_events::PumpStatus;
+use crate::platform_impl::platform::min_timeout;
+use crate::platform_impl::{
+    ActiveEventLoop as PlatformActiveEventLoop, OsError, PlatformCustomCursor,
+};
+use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource};
+
+mod proxy;
+pub mod sink;
+
+pub use proxy::EventLoopProxy;
+use sink::EventSink;
+
+use super::state::{WindowCompositorUpdate, WinitState};
+use super::window::state::FrameCallbackState;
+use super::{logical_to_physical_rounded, DeviceId, WaylandError, WindowId};
+
+type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;
+
+/// The Wayland event loop.
+pub struct EventLoop<T: 'static> {
+    /// Has `run` or `run_on_demand` been called or a call to `pump_events` that starts the loop
+    loop_running: bool,
+
+    buffer_sink: EventSink,
+    compositor_updates: Vec<WindowCompositorUpdate>,
+    window_ids: Vec<WindowId>,
+
+    /// Sender of user events.
+    user_events_sender: calloop::channel::Sender<T>,
+
+    // XXX can't remove RefCell out of here, unless we can plumb generics into the `Window`, which
+    // we don't really want, since it'll break public API by a lot.
+    /// Pending events from the user.
+    pending_user_events: Rc<RefCell<Vec<T>>>,
+
+    /// The Wayland dispatcher to has raw access to the queue when needed, such as
+    /// when creating a new window.
+    wayland_dispatcher: WaylandDispatcher,
+
+    /// Connection to the wayland server.
+    connection: Connection,
+
+    /// Event loop window target.
+    window_target: RootActiveEventLoop,
+
+    // XXX drop after everything else, just to be safe.
+    /// Calloop's event loop.
+    event_loop: calloop::EventLoop<'static, WinitState>,
+
+    pump_event_notifier: Option<PumpEventNotifier>,
+}
+
+impl<T: 'static> EventLoop<T> {
+    pub fn new() -> Result<EventLoop<T>, EventLoopError> {
+        macro_rules! map_err {
+            ($e:expr, $err:expr) => {
+                $e.map_err(|error| os_error!($err(error).into()))
+            };
+        }
+
+        let connection = map_err!(Connection::connect_to_env(), WaylandError::Connection)?;
+
+        let (globals, mut event_queue) =
+            map_err!(globals::registry_queue_init(&connection), WaylandError::Global)?;
+        let queue_handle = event_queue.handle();
+
+        let event_loop =
+            map_err!(calloop::EventLoop::<WinitState>::try_new(), WaylandError::Calloop)?;
+
+        let mut winit_state = WinitState::new(&globals, &queue_handle, event_loop.handle())
+            .map_err(|error| os_error!(error))?;
+
+        // NOTE: do a roundtrip after binding the globals to prevent potential
+        // races with the server.
+        map_err!(event_queue.roundtrip(&mut winit_state), WaylandError::Dispatch)?;
+
+        // Register Wayland source.
+        let wayland_source = WaylandSource::new(connection.clone(), event_queue);
+        let wayland_dispatcher =
+            calloop::Dispatcher::new(wayland_source, |_, queue, winit_state: &mut WinitState| {
+                let result = queue.dispatch_pending(winit_state);
+                if result.is_ok()
+                    && (!winit_state.events_sink.is_empty()
+                        || !winit_state.window_compositor_updates.is_empty())
+                {
+                    winit_state.dispatched_events = true;
+                }
+                result
+            });
+
+        map_err!(
+            event_loop.handle().register_dispatcher(wayland_dispatcher.clone()),
+            WaylandError::Calloop
+        )?;
+
+        // Setup the user proxy.
+        let pending_user_events = Rc::new(RefCell::new(Vec::new()));
+        let pending_user_events_clone = pending_user_events.clone();
+        let (user_events_sender, user_events_channel) = calloop::channel::channel();
+        let result = event_loop
+            .handle()
+            .insert_source(user_events_channel, move |event, _, winit_state: &mut WinitState| {
+                if let calloop::channel::Event::Msg(msg) = event {
+                    winit_state.dispatched_events = true;
+                    pending_user_events_clone.borrow_mut().push(msg);
+                }
+            })
+            .map_err(|error| error.error);
+        map_err!(result, WaylandError::Calloop)?;
+
+        // An event's loop awakener to wake up for window events from winit's windows.
+        let (event_loop_awakener, event_loop_awakener_source) = map_err!(
+            calloop::ping::make_ping()
+                .map_err(|error| CalloopError::OtherError(Box::new(error).into())),
+            WaylandError::Calloop
+        )?;
+
+        let result = event_loop
+            .handle()
+            .insert_source(event_loop_awakener_source, move |_, _, winit_state: &mut WinitState| {
+                // Mark that we have something to dispatch.
+                winit_state.dispatched_events = true;
+            })
+            .map_err(|error| error.error);
+        map_err!(result, WaylandError::Calloop)?;
+
+        let window_target = ActiveEventLoop {
+            connection: connection.clone(),
+            wayland_dispatcher: wayland_dispatcher.clone(),
+            event_loop_awakener,
+            queue_handle,
+            control_flow: Cell::new(ControlFlow::default()),
+            exit: Cell::new(None),
+            state: RefCell::new(winit_state),
+        };
+
+        let event_loop = Self {
+            loop_running: false,
+            compositor_updates: Vec::new(),
+            buffer_sink: EventSink::default(),
+            window_ids: Vec::new(),
+            connection,
+            wayland_dispatcher,
+            user_events_sender,
+            pending_user_events,
+            event_loop,
+            window_target: RootActiveEventLoop {
+                p: PlatformActiveEventLoop::Wayland(window_target),
+                _marker: PhantomData,
+            },
+            pump_event_notifier: None,
+        };
+
+        Ok(event_loop)
+    }
+
+    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
+        let exit = loop {
+            match self.pump_events(None, &mut event_handler) {
+                PumpStatus::Exit(0) => {
+                    break Ok(());
+                },
+                PumpStatus::Exit(code) => {
+                    break Err(EventLoopError::ExitFailure(code));
+                },
+                _ => {
+                    continue;
+                },
+            }
+        };
+
+        // Applications aren't allowed to carry windows between separate
+        // `run_on_demand` calls but if they have only just dropped their
+        // windows we need to make sure those last requests are sent to the
+        // compositor.
+        let _ = self.roundtrip().map_err(EventLoopError::Os);
+
+        exit
+    }
+
+    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
+        if !self.loop_running {
+            self.loop_running = true;
+
+            // Run the initial loop iteration.
+            self.single_iteration(&mut callback, StartCause::Init);
+        }
+
+        // Consider the possibility that the `StartCause::Init` iteration could
+        // request to Exit.
+        if !self.exiting() {
+            self.poll_events_with_timeout(timeout, &mut callback);
+        }
+        if let Some(code) = self.exit_code() {
+            self.loop_running = false;
+
+            callback(Event::LoopExiting, self.window_target());
+
+            PumpStatus::Exit(code)
+        } else {
+            // NOTE: spawn a wake-up thread, thus if we have code reading the wayland connection
+            // in parallel to winit, we ensure that the loop itself is marked as having events.
+            if timeout.is_some() && self.pump_event_notifier.is_none() {
+                let awakener = match &self.window_target.p {
+                    PlatformActiveEventLoop::Wayland(window_target) => {
+                        window_target.event_loop_awakener.clone()
+                    },
+                    #[cfg(x11_platform)]
+                    PlatformActiveEventLoop::X(_) => unreachable!(),
+                };
+
+                self.pump_event_notifier =
+                    Some(PumpEventNotifier::spawn(self.connection.clone(), awakener));
+            }
+
+            if let Some(pump_event_notifier) = self.pump_event_notifier.as_ref() {
+                // Notify that we don't have to wait, since we're out of winit.
+                *pump_event_notifier.control.0.lock().unwrap() = PumpEventNotifierAction::Monitor;
+                pump_event_notifier.control.1.notify_one();
+            }
+
+            PumpStatus::Continue
+        }
+    }
+
+    pub fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
+        let cause = loop {
+            let start = Instant::now();
+
+            timeout = {
+                let control_flow_timeout = match self.control_flow() {
+                    ControlFlow::Wait => None,
+                    ControlFlow::Poll => Some(Duration::ZERO),
+                    ControlFlow::WaitUntil(wait_deadline) => {
+                        Some(wait_deadline.saturating_duration_since(start))
+                    },
+                };
+                min_timeout(control_flow_timeout, timeout)
+            };
+
+            // NOTE Ideally we should flush as the last thing we do before polling
+            // to wait for events, and this should be done by the calloop
+            // WaylandSource but we currently need to flush writes manually.
+            //
+            // Checking for flush error is essential to perform an exit with error, since
+            // once we have a protocol error, we could get stuck retrying...
+            if self.connection.flush().is_err() {
+                self.set_exit_code(1);
+                return;
+            }
+
+            if let Err(error) = self.loop_dispatch(timeout) {
+                // NOTE We exit on errors from dispatches, since if we've got protocol error
+                // libwayland-client/wayland-rs will inform us anyway, but crashing downstream is
+                // not really an option. Instead we inform that the event loop got
+                // destroyed. We may communicate an error that something was
+                // terminated, but winit doesn't provide us with an API to do that
+                // via some event. Still, we set the exit code to the error's OS
+                // error code, or to 1 if not possible.
+                let exit_code = error.raw_os_error().unwrap_or(1);
+                self.set_exit_code(exit_code);
+                return;
+            }
+
+            // NB: `StartCause::Init` is handled as a special case and doesn't need
+            // to be considered here
+            let cause = match self.control_flow() {
+                ControlFlow::Poll => StartCause::Poll,
+                ControlFlow::Wait => StartCause::WaitCancelled { start, requested_resume: None },
+                ControlFlow::WaitUntil(deadline) => {
+                    if Instant::now() < deadline {
+                        StartCause::WaitCancelled { start, requested_resume: Some(deadline) }
+                    } else {
+                        StartCause::ResumeTimeReached { start, requested_resume: deadline }
+                    }
+                },
+            };
+
+            // Reduce spurious wake-ups.
+            let dispatched_events = self.with_state(|state| state.dispatched_events);
+            if matches!(cause, StartCause::WaitCancelled { .. })
+                && !dispatched_events
+                && timeout.is_none()
+            {
+                continue;
+            }
+
+            break cause;
+        };
+
+        self.single_iteration(&mut callback, cause);
+    }
+
+    fn single_iteration<F>(&mut self, callback: &mut F, cause: StartCause)
+    where
+        F: FnMut(Event<T>, &RootActiveEventLoop),
+    {
+        // NOTE currently just indented to simplify the diff
+
+        // We retain these grow-only scratch buffers as part of the EventLoop
+        // for the sake of avoiding lots of reallocs. We take them here to avoid
+        // trying to mutably borrow `self` more than once and we swap them back
+        // when finished.
+        let mut compositor_updates = std::mem::take(&mut self.compositor_updates);
+        let mut buffer_sink = std::mem::take(&mut self.buffer_sink);
+        let mut window_ids = std::mem::take(&mut self.window_ids);
+
+        callback(Event::NewEvents(cause), &self.window_target);
+
+        // NB: For consistency all platforms must emit a 'resumed' event even though Wayland
+        // applications don't themselves have a formal suspend/resume lifecycle.
+        if cause == StartCause::Init {
+            callback(Event::Resumed, &self.window_target);
+        }
+
+        // Handle pending user events. We don't need back buffer, since we can't dispatch
+        // user events indirectly via callback to the user.
+        for user_event in self.pending_user_events.borrow_mut().drain(..) {
+            callback(Event::UserEvent(user_event), &self.window_target);
+        }
+
+        // Drain the pending compositor updates.
+        self.with_state(|state| compositor_updates.append(&mut state.window_compositor_updates));
+
+        for mut compositor_update in compositor_updates.drain(..) {
+            let window_id = compositor_update.window_id;
+            if compositor_update.scale_changed {
+                let (physical_size, scale_factor) = self.with_state(|state| {
+                    let windows = state.windows.get_mut();
+                    let window = windows.get(&window_id).unwrap().lock().unwrap();
+                    let scale_factor = window.scale_factor();
+                    let size = logical_to_physical_rounded(window.inner_size(), scale_factor);
+                    (size, scale_factor)
+                });
+
+                // Stash the old window size.
+                let old_physical_size = physical_size;
+
+                let new_inner_size = Arc::new(Mutex::new(physical_size));
+                callback(
+                    Event::WindowEvent {
+                        window_id: crate::window::WindowId(window_id),
+                        event: WindowEvent::ScaleFactorChanged {
+                            scale_factor,
+                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
+                                &new_inner_size,
+                            )),
+                        },
+                    },
+                    &self.window_target,
+                );
+
+                let physical_size = *new_inner_size.lock().unwrap();
+                drop(new_inner_size);
+
+                // Resize the window when user altered the size.
+                if old_physical_size != physical_size {
+                    self.with_state(|state| {
+                        let windows = state.windows.get_mut();
+                        let mut window = windows.get(&window_id).unwrap().lock().unwrap();
+
+                        let new_logical_size: LogicalSize<f64> =
+                            physical_size.to_logical(scale_factor);
+                        window.request_inner_size(new_logical_size.into());
+                    });
+
+                    // Make it queue resize.
+                    compositor_update.resized = true;
+                }
+            }
+
+            // NOTE: Rescale changed the physical size which winit operates in, thus we should
+            // resize.
+            if compositor_update.resized || compositor_update.scale_changed {
+                let physical_size = self.with_state(|state| {
+                    let windows = state.windows.get_mut();
+                    let window = windows.get(&window_id).unwrap().lock().unwrap();
+
+                    let scale_factor = window.scale_factor();
+                    let size = logical_to_physical_rounded(window.inner_size(), scale_factor);
+
+                    // Mark the window as needed a redraw.
+                    state
+                        .window_requests
+                        .get_mut()
+                        .get_mut(&window_id)
+                        .unwrap()
+                        .redraw_requested
+                        .store(true, Ordering::Relaxed);
+
+                    size
+                });
+
+                callback(
+                    Event::WindowEvent {
+                        window_id: crate::window::WindowId(window_id),
+                        event: WindowEvent::Resized(physical_size),
+                    },
+                    &self.window_target,
+                );
+            }
+
+            if compositor_update.close_window {
+                callback(
+                    Event::WindowEvent {
+                        window_id: crate::window::WindowId(window_id),
+                        event: WindowEvent::CloseRequested,
+                    },
+                    &self.window_target,
+                );
+            }
+        }
+
+        // Push the events directly from the window.
+        self.with_state(|state| {
+            buffer_sink.append(&mut state.window_events_sink.lock().unwrap());
+        });
+        for event in buffer_sink.drain() {
+            let event = event.map_nonuser_event().unwrap();
+            callback(event, &self.window_target);
+        }
+
+        // Handle non-synthetic events.
+        self.with_state(|state| {
+            buffer_sink.append(&mut state.events_sink);
+        });
+        for event in buffer_sink.drain() {
+            let event = event.map_nonuser_event().unwrap();
+            callback(event, &self.window_target);
+        }
+
+        // Collect the window ids
+        self.with_state(|state| {
+            window_ids.extend(state.window_requests.get_mut().keys());
+        });
+
+        for window_id in window_ids.iter() {
+            let event = self.with_state(|state| {
+                let window_requests = state.window_requests.get_mut();
+                if window_requests.get(window_id).unwrap().take_closed() {
+                    mem::drop(window_requests.remove(window_id));
+                    mem::drop(state.windows.get_mut().remove(window_id));
+                    return Some(WindowEvent::Destroyed);
+                }
+
+                let mut window =
+                    state.windows.get_mut().get_mut(window_id).unwrap().lock().unwrap();
+
+                if window.frame_callback_state() == FrameCallbackState::Requested {
+                    return None;
+                }
+
+                // Reset the frame callbacks state.
+                window.frame_callback_reset();
+                let mut redraw_requested =
+                    window_requests.get(window_id).unwrap().take_redraw_requested();
+
+                // Redraw the frame while at it.
+                redraw_requested |= window.refresh_frame();
+
+                redraw_requested.then_some(WindowEvent::RedrawRequested)
+            });
+
+            if let Some(event) = event {
+                callback(
+                    Event::WindowEvent { window_id: crate::window::WindowId(*window_id), event },
+                    &self.window_target,
+                );
+            }
+        }
+
+        // Reset the hint that we've dispatched events.
+        self.with_state(|state| {
+            state.dispatched_events = false;
+        });
+
+        // This is always the last event we dispatch before poll again
+        callback(Event::AboutToWait, &self.window_target);
+
+        // Update the window frames and schedule redraws.
+        let mut wake_up = false;
+        for window_id in window_ids.drain(..) {
+            wake_up |= self.with_state(|state| match state.windows.get_mut().get_mut(&window_id) {
+                Some(window) => {
+                    let refresh = window.lock().unwrap().refresh_frame();
+                    if refresh {
+                        state
+                            .window_requests
+                            .get_mut()
+                            .get_mut(&window_id)
+                            .unwrap()
+                            .redraw_requested
+                            .store(true, Ordering::Relaxed);
+                    }
+
+                    refresh
+                },
+                None => false,
+            });
+        }
+
+        // Wakeup event loop if needed.
+        //
+        // If the user draws from the `AboutToWait` this is likely not required, however
+        // we can't do much about it.
+        if wake_up {
+            match &self.window_target.p {
+                PlatformActiveEventLoop::Wayland(window_target) => {
+                    window_target.event_loop_awakener.ping();
+                },
+                #[cfg(x11_platform)]
+                PlatformActiveEventLoop::X(_) => unreachable!(),
+            }
+        }
+
+        std::mem::swap(&mut self.compositor_updates, &mut compositor_updates);
+        std::mem::swap(&mut self.buffer_sink, &mut buffer_sink);
+        std::mem::swap(&mut self.window_ids, &mut window_ids);
+    }
+
+    #[inline]
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.user_events_sender.clone())
+    }
+
+    #[inline]
+    pub fn window_target(&self) -> &RootActiveEventLoop {
+        &self.window_target
+    }
+
+    fn with_state<'a, U: 'a, F: FnOnce(&'a mut WinitState) -> U>(&'a mut self, callback: F) -> U {
+        let state = match &mut self.window_target.p {
+            PlatformActiveEventLoop::Wayland(window_target) => window_target.state.get_mut(),
+            #[cfg(x11_platform)]
+            _ => unreachable!(),
+        };
+
+        callback(state)
+    }
+
+    fn loop_dispatch<D: Into<Option<std::time::Duration>>>(&mut self, timeout: D) -> IOResult<()> {
+        let state = match &mut self.window_target.p {
+            PlatformActiveEventLoop::Wayland(window_target) => window_target.state.get_mut(),
+            #[cfg(feature = "x11")]
+            _ => unreachable!(),
+        };
+
+        self.event_loop.dispatch(timeout, state).map_err(|error| {
+            tracing::error!("Error dispatching event loop: {}", error);
+            error.into()
+        })
+    }
+
+    fn roundtrip(&mut self) -> Result<usize, RootOsError> {
+        let state = match &mut self.window_target.p {
+            PlatformActiveEventLoop::Wayland(window_target) => window_target.state.get_mut(),
+            #[cfg(feature = "x11")]
+            _ => unreachable!(),
+        };
+
+        let mut wayland_source = self.wayland_dispatcher.as_source_mut();
+        let event_queue = wayland_source.queue();
+        event_queue.roundtrip(state).map_err(|error| {
+            os_error!(OsError::WaylandError(Arc::new(WaylandError::Dispatch(error))))
+        })
+    }
+
+    fn control_flow(&self) -> ControlFlow {
+        self.window_target.p.control_flow()
+    }
+
+    fn exiting(&self) -> bool {
+        self.window_target.p.exiting()
+    }
+
+    fn set_exit_code(&self, code: i32) {
+        self.window_target.p.set_exit_code(code)
+    }
+
+    fn exit_code(&self) -> Option<i32> {
+        self.window_target.p.exit_code()
+    }
+}
+
+impl<T> AsFd for EventLoop<T> {
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.event_loop.as_fd()
+    }
+}
+
+impl<T> AsRawFd for EventLoop<T> {
+    fn as_raw_fd(&self) -> RawFd {
+        self.event_loop.as_raw_fd()
+    }
+}
+
+pub struct ActiveEventLoop {
+    /// The event loop wakeup source.
+    pub event_loop_awakener: Ping,
+
+    /// The main queue used by the event loop.
+    pub queue_handle: QueueHandle<WinitState>,
+
+    /// The application's latest control_flow state
+    pub(crate) control_flow: Cell<ControlFlow>,
+
+    /// The application's exit state.
+    pub(crate) exit: Cell<Option<i32>>,
+
+    // TODO remove that RefCell once we can pass `&mut` in `Window::new`.
+    /// Winit state.
+    pub state: RefCell<WinitState>,
+
+    /// Dispatcher of Wayland events.
+    pub wayland_dispatcher: WaylandDispatcher,
+
+    /// Connection to the wayland server.
+    pub connection: Connection,
+}
+
+impl ActiveEventLoop {
+    pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
+        self.control_flow.set(control_flow)
+    }
+
+    pub(crate) fn control_flow(&self) -> ControlFlow {
+        self.control_flow.get()
+    }
+
+    pub(crate) fn exit(&self) {
+        self.exit.set(Some(0))
+    }
+
+    pub(crate) fn clear_exit(&self) {
+        self.exit.set(None)
+    }
+
+    pub(crate) fn exiting(&self) -> bool {
+        self.exit.get().is_some()
+    }
+
+    pub(crate) fn set_exit_code(&self, code: i32) {
+        self.exit.set(Some(code))
+    }
+
+    pub(crate) fn exit_code(&self) -> Option<i32> {
+        self.exit.get()
+    }
+
+    #[inline]
+    pub fn listen_device_events(&self, _allowed: DeviceEvents) {}
+
+    pub(crate) fn create_custom_cursor(&self, cursor: CustomCursorSource) -> RootCustomCursor {
+        RootCustomCursor {
+            inner: PlatformCustomCursor::Wayland(OnlyCursorImage(Arc::from(cursor.inner.0))),
+        }
+    }
+
+    #[cfg(feature = "rwh_05")]
+    #[inline]
+    pub fn raw_display_handle_rwh_05(&self) -> rwh_05::RawDisplayHandle {
+        use sctk::reexports::client::Proxy;
+
+        let mut display_handle = rwh_05::WaylandDisplayHandle::empty();
+        display_handle.display = self.connection.display().id().as_ptr() as *mut _;
+        rwh_05::RawDisplayHandle::Wayland(display_handle)
+    }
+
+    #[cfg(feature = "rwh_06")]
+    #[inline]
+    pub fn raw_display_handle_rwh_06(
+        &self,
+    ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
+        use sctk::reexports::client::Proxy;
+
+        Ok(rwh_06::WaylandDisplayHandle::new({
+            let ptr = self.connection.display().id().as_ptr();
+            std::ptr::NonNull::new(ptr as *mut _).expect("wl_display should never be null")
+        })
+        .into())
+    }
+}
+
+#[derive(Debug)]
+struct PumpEventNotifier {
+    /// Whether we're in winit or not.
+    control: Arc<(Mutex<PumpEventNotifierAction>, Condvar)>,
+    /// Waker handle for the working thread.
+    worker_waker: Option<OwnedFd>,
+    /// Thread handle.
+    handle: Option<JoinHandle<()>>,
+}
+
+impl Drop for PumpEventNotifier {
+    fn drop(&mut self) {
+        // Wake-up the thread.
+        if let Some(worker_waker) = self.worker_waker.as_ref() {
+            let _ = rustix::io::write(worker_waker.as_fd(), &[0u8]);
+        }
+        *self.control.0.lock().unwrap() = PumpEventNotifierAction::Shutdown;
+        self.control.1.notify_one();
+
+        if let Some(handle) = self.handle.take() {
+            let _ = handle.join();
+        }
+    }
+}
+
+impl PumpEventNotifier {
+    fn spawn(connection: Connection, awakener: Ping) -> Self {
+        // Start from the waiting state.
+        let control = Arc::new((Mutex::new(PumpEventNotifierAction::Pause), Condvar::new()));
+        let control_thread = Arc::clone(&control);
+
+        let (read, write) = match pipe::pipe_with(PipeFlags::CLOEXEC | PipeFlags::NONBLOCK) {
+            Ok((read, write)) => (read, write),
+            Err(_) => return Self { control, handle: None, worker_waker: None },
+        };
+
+        let handle =
+            std::thread::Builder::new().name(String::from("pump_events mon")).spawn(move || {
+                let (lock, cvar) = &*control_thread;
+                'outer: loop {
+                    let mut wait = lock.lock().unwrap();
+                    while *wait == PumpEventNotifierAction::Pause {
+                        wait = cvar.wait(wait).unwrap();
+                    }
+
+                    // Exit the loop when we're asked to. Given that we poll
+                    // only once we can take the `prepare_read`, but in some cases
+                    // it could be not possible, we may block on `join`.
+                    if *wait == PumpEventNotifierAction::Shutdown {
+                        break 'outer;
+                    }
+
+                    // Wake-up the main loop and put this one back to sleep.
+                    *wait = PumpEventNotifierAction::Pause;
+                    drop(wait);
+
+                    while let Some(read_guard) = connection.prepare_read() {
+                        let _ = connection.flush();
+                        let poll_fd = PollFd::from_borrowed_fd(connection.as_fd(), PollFlags::IN);
+                        let pipe_poll_fd = PollFd::from_borrowed_fd(read.as_fd(), PollFlags::IN);
+                        // Read from the `fd` before going back to poll.
+                        if Ok(1) == rustix::io::read(read.as_fd(), &mut [0u8; 1]) {
+                            break 'outer;
+                        }
+                        let _ = rustix::event::poll(&mut [poll_fd, pipe_poll_fd], -1);
+                        // Non-blocking read the connection.
+                        let _ = read_guard.read_without_dispatch();
+                    }
+
+                    awakener.ping();
+                }
+            });
+
+        if let Some(err) = handle.as_ref().err() {
+            warn!("failed to spawn pump_events wake-up thread: {err}");
+        }
+
+        PumpEventNotifier { control, handle: handle.ok(), worker_waker: Some(write) }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq)]
+enum PumpEventNotifierAction {
+    /// Monitor the wayland queue.
+    Monitor,
+    /// Pause monitoring.
+    Pause,
+    /// Shutdown the thread.
+    Shutdown,
+}

vendor/winit/src/platform_impl/linux/wayland/event_loop/proxy.rs

@@ -0,0 +1,28 @@
+//! An event loop proxy.
+
+use std::sync::mpsc::SendError;
+
+use sctk::reexports::calloop::channel::Sender;
+
+use crate::event_loop::EventLoopClosed;
+
+/// A handle that can be sent across the threads and used to wake up the `EventLoop`.
+pub struct EventLoopProxy<T: 'static> {
+    user_events_sender: Sender<T>,
+}
+
+impl<T: 'static> Clone for EventLoopProxy<T> {
+    fn clone(&self) -> Self {
+        EventLoopProxy { user_events_sender: self.user_events_sender.clone() }
+    }
+}
+
+impl<T: 'static> EventLoopProxy<T> {
+    pub fn new(user_events_sender: Sender<T>) -> Self {
+        Self { user_events_sender }
+    }
+
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.user_events_sender.send(event).map_err(|SendError(error)| EventLoopClosed(error))
+    }
+}

vendor/winit/src/platform_impl/linux/wayland/event_loop/sink.rs

@@ -0,0 +1,53 @@
+//! An event loop's sink to deliver events from the Wayland event callbacks.
+
+use std::vec::Drain;
+
+use crate::event::{DeviceEvent, DeviceId as RootDeviceId, Event, WindowEvent};
+use crate::platform_impl::platform::DeviceId as PlatformDeviceId;
+use crate::window::WindowId as RootWindowId;
+
+use super::{DeviceId, WindowId};
+
+/// An event loop's sink to deliver events from the Wayland event callbacks
+/// to the winit's user.
+#[derive(Default)]
+pub struct EventSink {
+    pub window_events: Vec<Event<()>>,
+}
+
+impl EventSink {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Return `true` if there're pending events.
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.window_events.is_empty()
+    }
+
+    /// Add new device event to a queue.
+    #[inline]
+    pub fn push_device_event(&mut self, event: DeviceEvent, device_id: DeviceId) {
+        self.window_events.push(Event::DeviceEvent {
+            event,
+            device_id: RootDeviceId(PlatformDeviceId::Wayland(device_id)),
+        });
+    }
+
+    /// Add new window event to a queue.
+    #[inline]
+    pub fn push_window_event(&mut self, event: WindowEvent, window_id: WindowId) {
+        self.window_events.push(Event::WindowEvent { event, window_id: RootWindowId(window_id) });
+    }
+
+    #[inline]
+    pub fn append(&mut self, other: &mut Self) {
+        self.window_events.append(&mut other.window_events);
+    }
+
+    #[inline]
+    pub fn drain(&mut self) -> Drain<'_, Event<()>> {
+        self.window_events.drain(..)
+    }
+}

vendor/winit/src/platform_impl/linux/wayland/mod.rs

@@ -0,0 +1,85 @@
+//! Winit's Wayland backend.
+
+use std::fmt::Display;
+use std::sync::Arc;
+
+use sctk::reexports::client::globals::{BindError, GlobalError};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{self, ConnectError, DispatchError, Proxy};
+
+pub(super) use crate::cursor::OnlyCursorImage as CustomCursor;
+use crate::dpi::{LogicalSize, PhysicalSize};
+pub use crate::platform_impl::platform::{OsError, WindowId};
+pub use event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy};
+pub use output::{MonitorHandle, VideoModeHandle};
+pub use window::Window;
+
+mod event_loop;
+mod output;
+mod seat;
+mod state;
+mod types;
+mod window;
+
+#[derive(Debug)]
+pub enum WaylandError {
+    /// Error connecting to the socket.
+    Connection(ConnectError),
+
+    /// Error binding the global.
+    Global(GlobalError),
+
+    // Bind error.
+    Bind(BindError),
+
+    /// Error during the dispatching the event queue.
+    Dispatch(DispatchError),
+
+    /// Calloop error.
+    Calloop(calloop::Error),
+
+    /// Wayland
+    Wire(client::backend::WaylandError),
+}
+
+impl Display for WaylandError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            WaylandError::Connection(error) => error.fmt(f),
+            WaylandError::Global(error) => error.fmt(f),
+            WaylandError::Bind(error) => error.fmt(f),
+            WaylandError::Dispatch(error) => error.fmt(f),
+            WaylandError::Calloop(error) => error.fmt(f),
+            WaylandError::Wire(error) => error.fmt(f),
+        }
+    }
+}
+
+impl From<WaylandError> for OsError {
+    fn from(value: WaylandError) -> Self {
+        Self::WaylandError(Arc::new(value))
+    }
+}
+
+/// Dummy device id, since Wayland doesn't have device events.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct DeviceId;
+
+impl DeviceId {
+    pub const fn dummy() -> Self {
+        DeviceId
+    }
+}
+
+/// Get the WindowId out of the surface.
+#[inline]
+fn make_wid(surface: &WlSurface) -> WindowId {
+    WindowId(surface.id().as_ptr() as u64)
+}
+
+/// The default routine does floor, but we need round on Wayland.
+fn logical_to_physical_rounded(size: LogicalSize<u32>, scale_factor: f64) -> PhysicalSize<u32> {
+    let width = size.width as f64 * scale_factor;
+    let height = size.height as f64 * scale_factor;
+    (width.round(), height.round()).into()
+}

vendor/winit/src/platform_impl/linux/wayland/output.rs

@@ -0,0 +1,163 @@
+use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::client::Proxy;
+
+use sctk::output::OutputData;
+
+use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
+use crate::platform_impl::platform::VideoModeHandle as PlatformVideoModeHandle;
+
+use super::event_loop::ActiveEventLoop;
+
+impl ActiveEventLoop {
+    #[inline]
+    pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
+        self.state.borrow().output_state.outputs().map(MonitorHandle::new)
+    }
+
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        // There's no primary monitor on Wayland.
+        None
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct MonitorHandle {
+    pub(crate) proxy: WlOutput,
+}
+
+impl MonitorHandle {
+    #[inline]
+    pub(crate) fn new(proxy: WlOutput) -> Self {
+        Self { proxy }
+    }
+
+    #[inline]
+    pub fn name(&self) -> Option<String> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.with_output_info(|info| info.name.clone())
+    }
+
+    #[inline]
+    pub fn native_identifier(&self) -> u32 {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.with_output_info(|info| info.id)
+    }
+
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        let dimensions = output_data.with_output_info(|info| {
+            info.modes.iter().find_map(|mode| mode.current.then_some(mode.dimensions))
+        });
+
+        match dimensions {
+            Some((width, height)) => (width as u32, height as u32),
+            _ => (0, 0),
+        }
+        .into()
+    }
+
+    #[inline]
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.with_output_info(|info| {
+            info.logical_position.map_or_else(
+                || {
+                    LogicalPosition::<i32>::from(info.location)
+                        .to_physical(info.scale_factor as f64)
+                },
+                |logical_position| {
+                    LogicalPosition::<i32>::from(logical_position)
+                        .to_physical(info.scale_factor as f64)
+                },
+            )
+        })
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.with_output_info(|info| {
+            info.modes.iter().find_map(|mode| mode.current.then_some(mode.refresh_rate as u32))
+        })
+    }
+
+    #[inline]
+    pub fn scale_factor(&self) -> i32 {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        output_data.scale_factor()
+    }
+
+    #[inline]
+    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoModeHandle> {
+        let output_data = self.proxy.data::<OutputData>().unwrap();
+        let modes = output_data.with_output_info(|info| info.modes.clone());
+
+        let monitor = self.clone();
+
+        modes.into_iter().map(move |mode| {
+            PlatformVideoModeHandle::Wayland(VideoModeHandle {
+                size: (mode.dimensions.0 as u32, mode.dimensions.1 as u32).into(),
+                refresh_rate_millihertz: mode.refresh_rate as u32,
+                bit_depth: 32,
+                monitor: monitor.clone(),
+            })
+        })
+    }
+}
+
+impl PartialEq for MonitorHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.native_identifier() == other.native_identifier()
+    }
+}
+
+impl Eq for MonitorHandle {}
+
+impl PartialOrd for MonitorHandle {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MonitorHandle {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.native_identifier().cmp(&other.native_identifier())
+    }
+}
+
+impl std::hash::Hash for MonitorHandle {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.native_identifier().hash(state);
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct VideoModeHandle {
+    pub(crate) size: PhysicalSize<u32>,
+    pub(crate) bit_depth: u16,
+    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) monitor: MonitorHandle,
+}
+
+impl VideoModeHandle {
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.size
+    }
+
+    #[inline]
+    pub fn bit_depth(&self) -> u16 {
+        self.bit_depth
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.refresh_rate_millihertz
+    }
+
+    pub fn monitor(&self) -> MonitorHandle {
+        self.monitor.clone()
+    }
+}

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

@@ -0,0 +1,380 @@
+//! The keyboard input handling.
+
+use std::sync::Mutex;
+use std::time::Duration;
+
+use calloop::timer::{TimeoutAction, Timer};
+use calloop::{LoopHandle, RegistrationToken};
+use tracing::warn;
+
+use sctk::reexports::client::protocol::wl_keyboard::{
+    Event as WlKeyboardEvent, KeyState as WlKeyState, KeymapFormat as WlKeymapFormat, WlKeyboard,
+};
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, WEnum};
+
+use crate::event::{ElementState, WindowEvent};
+use crate::keyboard::ModifiersState;
+
+use crate::platform_impl::common::xkb::Context;
+use crate::platform_impl::wayland::event_loop::sink::EventSink;
+use crate::platform_impl::wayland::state::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId, WindowId};
+
+impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
+    fn event(
+        state: &mut WinitState,
+        wl_keyboard: &WlKeyboard,
+        event: <WlKeyboard as Proxy>::Event,
+        data: &KeyboardData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        let seat_state = match state.seats.get_mut(&data.seat.id()) {
+            Some(seat_state) => seat_state,
+            None => {
+                warn!("Received keyboard event {event:?} without seat");
+                return;
+            },
+        };
+        let keyboard_state = match seat_state.keyboard_state.as_mut() {
+            Some(keyboard_state) => keyboard_state,
+            None => {
+                warn!("Received keyboard event {event:?} without keyboard");
+                return;
+            },
+        };
+
+        match event {
+            WlKeyboardEvent::Keymap { format, fd, size } => match format {
+                WEnum::Value(format) => match format {
+                    WlKeymapFormat::NoKeymap => {
+                        warn!("non-xkb compatible keymap")
+                    },
+                    WlKeymapFormat::XkbV1 => {
+                        let context = &mut keyboard_state.xkb_context;
+                        context.set_keymap_from_fd(fd, size as usize);
+                    },
+                    _ => unreachable!(),
+                },
+                WEnum::Unknown(value) => {
+                    warn!("unknown keymap format 0x{:x}", value)
+                },
+            },
+            WlKeyboardEvent::Enter { surface, .. } => {
+                let window_id = wayland::make_wid(&surface);
+
+                // Mark the window as focused.
+                let was_unfocused = match state.windows.get_mut().get(&window_id) {
+                    Some(window) => {
+                        let mut window = window.lock().unwrap();
+                        let was_unfocused = !window.has_focus();
+                        window.add_seat_focus(data.seat.id());
+                        was_unfocused
+                    },
+                    None => return,
+                };
+
+                // Drop the repeat, if there were any.
+                keyboard_state.current_repeat = None;
+                if let Some(token) = keyboard_state.repeat_token.take() {
+                    keyboard_state.loop_handle.remove(token);
+                }
+
+                *data.window_id.lock().unwrap() = Some(window_id);
+
+                // The keyboard focus is considered as general focus.
+                if was_unfocused {
+                    state.events_sink.push_window_event(WindowEvent::Focused(true), window_id);
+                }
+
+                // HACK: this is just for GNOME not fixing their ordering issue of modifiers.
+                if std::mem::take(&mut seat_state.modifiers_pending) {
+                    state.events_sink.push_window_event(
+                        WindowEvent::ModifiersChanged(seat_state.modifiers.into()),
+                        window_id,
+                    );
+                }
+            },
+            WlKeyboardEvent::Leave { surface, .. } => {
+                let window_id = wayland::make_wid(&surface);
+
+                // NOTE: we should drop the repeat regardless whether it was for the present
+                // window of for the window which just went gone.
+                keyboard_state.current_repeat = None;
+                if let Some(token) = keyboard_state.repeat_token.take() {
+                    keyboard_state.loop_handle.remove(token);
+                }
+
+                // NOTE: The check whether the window exists is essential as we might get a
+                // nil surface, regardless of what protocol says.
+                let focused = match state.windows.get_mut().get(&window_id) {
+                    Some(window) => {
+                        let mut window = window.lock().unwrap();
+                        window.remove_seat_focus(&data.seat.id());
+                        window.has_focus()
+                    },
+                    None => return,
+                };
+
+                // We don't need to update it above, because the next `Enter` will overwrite
+                // anyway.
+                *data.window_id.lock().unwrap() = None;
+
+                if !focused {
+                    // Notify that no modifiers are being pressed.
+                    state.events_sink.push_window_event(
+                        WindowEvent::ModifiersChanged(ModifiersState::empty().into()),
+                        window_id,
+                    );
+
+                    state.events_sink.push_window_event(WindowEvent::Focused(false), window_id);
+                }
+            },
+            WlKeyboardEvent::Key { key, state: WEnum::Value(WlKeyState::Pressed), .. } => {
+                let key = key + 8;
+
+                key_input(
+                    keyboard_state,
+                    &mut state.events_sink,
+                    data,
+                    key,
+                    ElementState::Pressed,
+                    false,
+                );
+
+                let delay = match keyboard_state.repeat_info {
+                    RepeatInfo::Repeat { delay, .. } => delay,
+                    RepeatInfo::Disable => return,
+                };
+
+                if !keyboard_state.xkb_context.keymap_mut().unwrap().key_repeats(key) {
+                    return;
+                }
+
+                keyboard_state.current_repeat = Some(key);
+
+                // NOTE terminate ongoing timer and start a new timer.
+
+                if let Some(token) = keyboard_state.repeat_token.take() {
+                    keyboard_state.loop_handle.remove(token);
+                }
+
+                let timer = Timer::from_duration(delay);
+                let wl_keyboard = wl_keyboard.clone();
+                keyboard_state.repeat_token = keyboard_state
+                    .loop_handle
+                    .insert_source(timer, move |_, _, state| {
+                        // Required to handle the wakeups from the repeat sources.
+                        state.dispatched_events = true;
+
+                        let data = wl_keyboard.data::<KeyboardData>().unwrap();
+                        let seat_state = match state.seats.get_mut(&data.seat.id()) {
+                            Some(seat_state) => seat_state,
+                            None => return TimeoutAction::Drop,
+                        };
+
+                        let keyboard_state = match seat_state.keyboard_state.as_mut() {
+                            Some(keyboard_state) => keyboard_state,
+                            None => return TimeoutAction::Drop,
+                        };
+
+                        // NOTE: The removed on event source is batched, but key change to `None`
+                        // is instant.
+                        let repeat_keycode = match keyboard_state.current_repeat {
+                            Some(repeat_keycode) => repeat_keycode,
+                            None => return TimeoutAction::Drop,
+                        };
+
+                        key_input(
+                            keyboard_state,
+                            &mut state.events_sink,
+                            data,
+                            repeat_keycode,
+                            ElementState::Pressed,
+                            true,
+                        );
+
+                        // NOTE: the gap could change dynamically while repeat is going.
+                        match keyboard_state.repeat_info {
+                            RepeatInfo::Repeat { gap, .. } => TimeoutAction::ToDuration(gap),
+                            RepeatInfo::Disable => TimeoutAction::Drop,
+                        }
+                    })
+                    .ok();
+            },
+            WlKeyboardEvent::Key { key, state: WEnum::Value(WlKeyState::Released), .. } => {
+                let key = key + 8;
+
+                key_input(
+                    keyboard_state,
+                    &mut state.events_sink,
+                    data,
+                    key,
+                    ElementState::Released,
+                    false,
+                );
+
+                if keyboard_state.repeat_info != RepeatInfo::Disable
+                    && keyboard_state.xkb_context.keymap_mut().unwrap().key_repeats(key)
+                    && Some(key) == keyboard_state.current_repeat
+                {
+                    keyboard_state.current_repeat = None;
+                    if let Some(token) = keyboard_state.repeat_token.take() {
+                        keyboard_state.loop_handle.remove(token);
+                    }
+                }
+            },
+            WlKeyboardEvent::Modifiers {
+                mods_depressed, mods_latched, mods_locked, group, ..
+            } => {
+                let xkb_context = &mut keyboard_state.xkb_context;
+                let xkb_state = match xkb_context.state_mut() {
+                    Some(state) => state,
+                    None => return,
+                };
+
+                xkb_state.update_modifiers(mods_depressed, mods_latched, mods_locked, 0, 0, group);
+                seat_state.modifiers = xkb_state.modifiers().into();
+
+                // HACK: part of the workaround from `WlKeyboardEvent::Enter`.
+                let window_id = match *data.window_id.lock().unwrap() {
+                    Some(window_id) => window_id,
+                    None => {
+                        seat_state.modifiers_pending = true;
+                        return;
+                    },
+                };
+
+                state.events_sink.push_window_event(
+                    WindowEvent::ModifiersChanged(seat_state.modifiers.into()),
+                    window_id,
+                );
+            },
+            WlKeyboardEvent::RepeatInfo { rate, delay } => {
+                keyboard_state.repeat_info = if rate == 0 {
+                    // Stop the repeat once we get a disable event.
+                    keyboard_state.current_repeat = None;
+                    if let Some(repeat_token) = keyboard_state.repeat_token.take() {
+                        keyboard_state.loop_handle.remove(repeat_token);
+                    }
+                    RepeatInfo::Disable
+                } else {
+                    let gap = Duration::from_micros(1_000_000 / rate as u64);
+                    let delay = Duration::from_millis(delay as u64);
+                    RepeatInfo::Repeat { gap, delay }
+                };
+            },
+            _ => unreachable!(),
+        }
+    }
+}
+
+/// The state of the keyboard on the current seat.
+#[derive(Debug)]
+pub struct KeyboardState {
+    /// The underlying WlKeyboard.
+    pub keyboard: WlKeyboard,
+
+    /// Loop handle to handle key repeat.
+    pub loop_handle: LoopHandle<'static, WinitState>,
+
+    /// The state of the keyboard.
+    pub xkb_context: Context,
+
+    /// The information about the repeat rate obtained from the compositor.
+    pub repeat_info: RepeatInfo,
+
+    /// The token of the current handle inside the calloop's event loop.
+    pub repeat_token: Option<RegistrationToken>,
+
+    /// The current repeat raw key.
+    pub current_repeat: Option<u32>,
+}
+
+impl KeyboardState {
+    pub fn new(keyboard: WlKeyboard, loop_handle: LoopHandle<'static, WinitState>) -> Self {
+        Self {
+            keyboard,
+            loop_handle,
+            xkb_context: Context::new().unwrap(),
+            repeat_info: RepeatInfo::default(),
+            repeat_token: None,
+            current_repeat: None,
+        }
+    }
+}
+
+impl Drop for KeyboardState {
+    fn drop(&mut self) {
+        if self.keyboard.version() >= 3 {
+            self.keyboard.release();
+        }
+
+        if let Some(token) = self.repeat_token.take() {
+            self.loop_handle.remove(token);
+        }
+    }
+}
+
+/// The rate at which a pressed key is repeated.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RepeatInfo {
+    /// Keys will be repeated at the specified rate and delay.
+    Repeat {
+        /// The time between the key repeats.
+        gap: Duration,
+
+        /// Delay (in milliseconds) between a key press and the start of repetition.
+        delay: Duration,
+    },
+
+    /// Keys should not be repeated.
+    Disable,
+}
+
+impl Default for RepeatInfo {
+    /// The default repeat rate is 25 keys per second with the delay of 200ms.
+    ///
+    /// The values are picked based on the default in various compositors and Xorg.
+    fn default() -> Self {
+        Self::Repeat { gap: Duration::from_millis(40), delay: Duration::from_millis(200) }
+    }
+}
+
+/// Keyboard user data.
+#[derive(Debug)]
+pub struct KeyboardData {
+    /// The currently focused window surface. Could be `None` on bugged compositors, like mutter.
+    window_id: Mutex<Option<WindowId>>,
+
+    /// The seat used to create this keyboard.
+    seat: WlSeat,
+}
+
+impl KeyboardData {
+    pub fn new(seat: WlSeat) -> Self {
+        Self { window_id: Default::default(), seat }
+    }
+}
+
+fn key_input(
+    keyboard_state: &mut KeyboardState,
+    event_sink: &mut EventSink,
+    data: &KeyboardData,
+    keycode: u32,
+    state: ElementState,
+    repeat: bool,
+) {
+    let window_id = match *data.window_id.lock().unwrap() {
+        Some(window_id) => window_id,
+        None => return,
+    };
+
+    let device_id = crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId));
+    if let Some(mut key_context) = keyboard_state.xkb_context.key_context() {
+        let event = key_context.process_key_event(keycode, state, repeat);
+        let event = WindowEvent::KeyboardInput { device_id, event, is_synthetic: false };
+        event_sink.push_window_event(event, window_id);
+    }
+}

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

@@ -0,0 +1,235 @@
+//! Seat handling.
+
+use std::sync::Arc;
+
+use ahash::AHashMap;
+use tracing::warn;
+
+use sctk::reexports::client::backend::ObjectId;
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::protocol::wl_touch::WlTouch;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+use sctk::reexports::protocols::wp::relative_pointer::zv1::client::zwp_relative_pointer_v1::ZwpRelativePointerV1;
+use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::ZwpTextInputV3;
+
+use sctk::seat::pointer::{ThemeSpec, ThemedPointer};
+use sctk::seat::{Capability as SeatCapability, SeatHandler, SeatState};
+
+use crate::event::WindowEvent;
+use crate::keyboard::ModifiersState;
+use crate::platform_impl::wayland::state::WinitState;
+
+mod keyboard;
+mod pointer;
+mod text_input;
+mod touch;
+
+pub use pointer::relative_pointer::RelativePointerState;
+pub use pointer::{PointerConstraintsState, WinitPointerData, WinitPointerDataExt};
+pub use text_input::{TextInputState, ZwpTextInputV3Ext};
+
+use keyboard::{KeyboardData, KeyboardState};
+use text_input::TextInputData;
+use touch::TouchPoint;
+
+#[derive(Debug, Default)]
+pub struct WinitSeatState {
+    /// The pointer bound on the seat.
+    pointer: Option<Arc<ThemedPointer<WinitPointerData>>>,
+
+    /// The touch bound on the seat.
+    touch: Option<WlTouch>,
+
+    /// The mapping from touched points to the surfaces they're present.
+    touch_map: AHashMap<i32, TouchPoint>,
+
+    /// The text input bound on the seat.
+    text_input: Option<Arc<ZwpTextInputV3>>,
+
+    /// The relative pointer bound on the seat.
+    relative_pointer: Option<ZwpRelativePointerV1>,
+
+    /// The keyboard bound on the seat.
+    keyboard_state: Option<KeyboardState>,
+
+    /// The current modifiers state on the seat.
+    modifiers: ModifiersState,
+
+    /// Whether we have pending modifiers.
+    modifiers_pending: bool,
+}
+
+impl WinitSeatState {
+    pub fn new() -> Self {
+        Default::default()
+    }
+}
+
+impl SeatHandler for WinitState {
+    fn seat_state(&mut self) -> &mut SeatState {
+        &mut self.seat_state
+    }
+
+    fn new_capability(
+        &mut self,
+        _: &Connection,
+        queue_handle: &QueueHandle<Self>,
+        seat: WlSeat,
+        capability: SeatCapability,
+    ) {
+        let seat_state = match self.seats.get_mut(&seat.id()) {
+            Some(seat_state) => seat_state,
+            None => {
+                warn!("Received wl_seat::new_capability for unknown seat");
+                return;
+            },
+        };
+
+        match capability {
+            SeatCapability::Touch if seat_state.touch.is_none() => {
+                seat_state.touch = self.seat_state.get_touch(queue_handle, &seat).ok();
+            },
+            SeatCapability::Keyboard if seat_state.keyboard_state.is_none() => {
+                let keyboard = seat.get_keyboard(queue_handle, KeyboardData::new(seat.clone()));
+                seat_state.keyboard_state =
+                    Some(KeyboardState::new(keyboard, self.loop_handle.clone()));
+            },
+            SeatCapability::Pointer if seat_state.pointer.is_none() => {
+                let surface = self.compositor_state.create_surface(queue_handle);
+                let viewport = self
+                    .viewporter_state
+                    .as_ref()
+                    .map(|state| state.get_viewport(&surface, queue_handle));
+                let surface_id = surface.id();
+                let pointer_data = WinitPointerData::new(seat.clone(), viewport);
+                let themed_pointer = self
+                    .seat_state
+                    .get_pointer_with_theme_and_data(
+                        queue_handle,
+                        &seat,
+                        self.shm.wl_shm(),
+                        surface,
+                        ThemeSpec::System,
+                        pointer_data,
+                    )
+                    .expect("failed to create pointer with present capability.");
+
+                seat_state.relative_pointer = self.relative_pointer.as_ref().map(|manager| {
+                    manager.get_relative_pointer(
+                        themed_pointer.pointer(),
+                        queue_handle,
+                        sctk::globals::GlobalData,
+                    )
+                });
+
+                let themed_pointer = Arc::new(themed_pointer);
+
+                // Register cursor surface.
+                self.pointer_surfaces.insert(surface_id, themed_pointer.clone());
+
+                seat_state.pointer = Some(themed_pointer);
+            },
+            _ => (),
+        }
+
+        if let Some(text_input_state) =
+            seat_state.text_input.is_none().then_some(self.text_input_state.as_ref()).flatten()
+        {
+            seat_state.text_input = Some(Arc::new(text_input_state.get_text_input(
+                &seat,
+                queue_handle,
+                TextInputData::default(),
+            )));
+        }
+    }
+
+    fn remove_capability(
+        &mut self,
+        _: &Connection,
+        _queue_handle: &QueueHandle<Self>,
+        seat: WlSeat,
+        capability: SeatCapability,
+    ) {
+        let seat_state = match self.seats.get_mut(&seat.id()) {
+            Some(seat_state) => seat_state,
+            None => {
+                warn!("Received wl_seat::remove_capability for unknown seat");
+                return;
+            },
+        };
+
+        if let Some(text_input) = seat_state.text_input.take() {
+            text_input.destroy();
+        }
+
+        match capability {
+            SeatCapability::Touch => {
+                if let Some(touch) = seat_state.touch.take() {
+                    if touch.version() >= 3 {
+                        touch.release();
+                    }
+                }
+            },
+            SeatCapability::Pointer => {
+                if let Some(relative_pointer) = seat_state.relative_pointer.take() {
+                    relative_pointer.destroy();
+                }
+
+                if let Some(pointer) = seat_state.pointer.take() {
+                    let pointer_data = pointer.pointer().winit_data();
+
+                    // Remove the cursor from the mapping.
+                    let surface_id = pointer.surface().id();
+                    let _ = self.pointer_surfaces.remove(&surface_id);
+
+                    // Remove the inner locks/confines before dropping the pointer.
+                    pointer_data.unlock_pointer();
+                    pointer_data.unconfine_pointer();
+
+                    if pointer.pointer().version() >= 3 {
+                        pointer.pointer().release();
+                    }
+                }
+            },
+            SeatCapability::Keyboard => {
+                seat_state.keyboard_state = None;
+                self.on_keyboard_destroy(&seat.id());
+            },
+            _ => (),
+        }
+    }
+
+    fn new_seat(
+        &mut self,
+        _connection: &Connection,
+        _queue_handle: &QueueHandle<Self>,
+        seat: WlSeat,
+    ) {
+        self.seats.insert(seat.id(), WinitSeatState::new());
+    }
+
+    fn remove_seat(
+        &mut self,
+        _connection: &Connection,
+        _queue_handle: &QueueHandle<Self>,
+        seat: WlSeat,
+    ) {
+        let _ = self.seats.remove(&seat.id());
+        self.on_keyboard_destroy(&seat.id());
+    }
+}
+
+impl WinitState {
+    fn on_keyboard_destroy(&mut self, seat: &ObjectId) {
+        for (window_id, window) in self.windows.get_mut() {
+            let mut window = window.lock().unwrap();
+            let had_focus = window.has_focus();
+            window.remove_seat_focus(seat);
+            if had_focus != window.has_focus() {
+                self.events_sink.push_window_event(WindowEvent::Focused(false), *window_id);
+            }
+        }
+    }
+}
+
+sctk::delegate_seat!(WinitState);

vendor/winit/src/platform_impl/linux/wayland/seat/pointer/mod.rs

@@ -0,0 +1,502 @@
+//! The pointer events.
+
+use std::ops::Deref;
+use std::sync::{Arc, Mutex};
+use std::time::Duration;
+
+use tracing::warn;
+
+use sctk::reexports::client::delegate_dispatch;
+use sctk::reexports::client::protocol::wl_pointer::WlPointer;
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle, Dispatch};
+use sctk::reexports::protocols::wp::pointer_constraints::zv1::client::zwp_confined_pointer_v1::ZwpConfinedPointerV1;
+use sctk::reexports::protocols::wp::pointer_constraints::zv1::client::zwp_locked_pointer_v1::ZwpLockedPointerV1;
+use sctk::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::WpCursorShapeDeviceV1;
+use sctk::reexports::protocols::wp::cursor_shape::v1::client::wp_cursor_shape_manager_v1::WpCursorShapeManagerV1;
+use sctk::reexports::protocols::wp::pointer_constraints::zv1::client::zwp_pointer_constraints_v1::{Lifetime, ZwpPointerConstraintsV1};
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::csd_frame::FrameClick;
+use sctk::reexports::protocols::wp::viewporter::client::wp_viewport::WpViewport;
+
+use sctk::compositor::SurfaceData;
+use sctk::globals::GlobalData;
+use sctk::seat::pointer::{
+    PointerData, PointerDataExt, PointerEvent, PointerEventKind, PointerHandler,
+};
+use sctk::seat::SeatState;
+
+use crate::dpi::{LogicalPosition, PhysicalPosition};
+use crate::event::{ElementState, MouseButton, MouseScrollDelta, TouchPhase, WindowEvent};
+
+use crate::platform_impl::wayland::state::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId, WindowId};
+
+pub mod relative_pointer;
+
+impl PointerHandler for WinitState {
+    fn pointer_frame(
+        &mut self,
+        connection: &Connection,
+        _: &QueueHandle<Self>,
+        pointer: &WlPointer,
+        events: &[PointerEvent],
+    ) {
+        let seat = pointer.winit_data().seat();
+        let seat_state = match self.seats.get(&seat.id()) {
+            Some(seat_state) => seat_state,
+            None => {
+                warn!("Received pointer event without seat");
+                return;
+            },
+        };
+
+        let themed_pointer = match seat_state.pointer.as_ref() {
+            Some(pointer) => pointer,
+            None => {
+                warn!("Received pointer event without pointer");
+                return;
+            },
+        };
+
+        let device_id = crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(DeviceId));
+
+        for event in events {
+            let surface = &event.surface;
+
+            // The parent surface.
+            let parent_surface = match event.surface.data::<SurfaceData>() {
+                Some(data) => data.parent_surface().unwrap_or(surface),
+                None => continue,
+            };
+
+            let window_id = wayland::make_wid(parent_surface);
+
+            // Ensure that window exists.
+            let mut window = match self.windows.get_mut().get_mut(&window_id) {
+                Some(window) => window.lock().unwrap(),
+                None => continue,
+            };
+
+            let scale_factor = window.scale_factor();
+            let position: PhysicalPosition<f64> =
+                LogicalPosition::new(event.position.0, event.position.1).to_physical(scale_factor);
+
+            match event.kind {
+                // Pointer movements on decorations.
+                PointerEventKind::Enter { .. } | PointerEventKind::Motion { .. }
+                    if parent_surface != surface =>
+                {
+                    if let Some(icon) = window.frame_point_moved(
+                        seat,
+                        surface,
+                        Duration::ZERO,
+                        event.position.0,
+                        event.position.1,
+                    ) {
+                        let _ = themed_pointer.set_cursor(connection, icon);
+                    }
+                },
+                PointerEventKind::Leave { .. } if parent_surface != surface => {
+                    window.frame_point_left();
+                },
+                ref kind @ PointerEventKind::Press { button, serial, time }
+                | ref kind @ PointerEventKind::Release { button, serial, time }
+                    if parent_surface != surface =>
+                {
+                    let click = match wayland_button_to_winit(button) {
+                        MouseButton::Left => FrameClick::Normal,
+                        MouseButton::Right => FrameClick::Alternate,
+                        _ => continue,
+                    };
+                    let pressed = matches!(kind, PointerEventKind::Press { .. });
+
+                    // Emulate click on the frame.
+                    window.frame_click(
+                        click,
+                        pressed,
+                        seat,
+                        serial,
+                        Duration::from_millis(time as u64),
+                        window_id,
+                        &mut self.window_compositor_updates,
+                    );
+                },
+                // Regular events on the main surface.
+                PointerEventKind::Enter { .. } => {
+                    self.events_sink
+                        .push_window_event(WindowEvent::CursorEntered { device_id }, window_id);
+
+                    window.pointer_entered(Arc::downgrade(themed_pointer));
+
+                    // Set the currently focused surface.
+                    pointer.winit_data().inner.lock().unwrap().surface = Some(window_id);
+
+                    self.events_sink.push_window_event(
+                        WindowEvent::CursorMoved { device_id, position },
+                        window_id,
+                    );
+                },
+                PointerEventKind::Leave { .. } => {
+                    window.pointer_left(Arc::downgrade(themed_pointer));
+
+                    // Remove the active surface.
+                    pointer.winit_data().inner.lock().unwrap().surface = None;
+
+                    self.events_sink
+                        .push_window_event(WindowEvent::CursorLeft { device_id }, window_id);
+                },
+                PointerEventKind::Motion { .. } => {
+                    self.events_sink.push_window_event(
+                        WindowEvent::CursorMoved { device_id, position },
+                        window_id,
+                    );
+                },
+                ref kind @ PointerEventKind::Press { button, serial, .. }
+                | ref kind @ PointerEventKind::Release { button, serial, .. } => {
+                    // Update the last button serial.
+                    pointer.winit_data().inner.lock().unwrap().latest_button_serial = serial;
+
+                    let button = wayland_button_to_winit(button);
+                    let state = if matches!(kind, PointerEventKind::Press { .. }) {
+                        ElementState::Pressed
+                    } else {
+                        ElementState::Released
+                    };
+                    self.events_sink.push_window_event(
+                        WindowEvent::MouseInput { device_id, state, button },
+                        window_id,
+                    );
+                },
+                PointerEventKind::Axis { horizontal, vertical, .. } => {
+                    // Get the current phase.
+                    let mut pointer_data = pointer.winit_data().inner.lock().unwrap();
+
+                    let has_discrete_scroll = horizontal.discrete != 0 || vertical.discrete != 0;
+
+                    // Figure out what to do about start/ended phases here.
+                    //
+                    // Figure out how to deal with `Started`. Also the `Ended` is not guaranteed
+                    // to be sent for mouse wheels.
+                    let phase = if horizontal.stop || vertical.stop {
+                        TouchPhase::Ended
+                    } else {
+                        match pointer_data.phase {
+                            // Discrete scroll only results in moved events.
+                            _ if has_discrete_scroll => TouchPhase::Moved,
+                            TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
+                            _ => TouchPhase::Started,
+                        }
+                    };
+
+                    // Update the phase.
+                    pointer_data.phase = phase;
+
+                    // Mice events have both pixel and discrete delta's at the same time. So prefer
+                    // the discrete values if they are present.
+                    let delta = if has_discrete_scroll {
+                        // NOTE: Wayland sign convention is the inverse of winit.
+                        MouseScrollDelta::LineDelta(
+                            (-horizontal.discrete) as f32,
+                            (-vertical.discrete) as f32,
+                        )
+                    } else {
+                        // NOTE: Wayland sign convention is the inverse of winit.
+                        MouseScrollDelta::PixelDelta(
+                            LogicalPosition::new(-horizontal.absolute, -vertical.absolute)
+                                .to_physical(scale_factor),
+                        )
+                    };
+
+                    self.events_sink.push_window_event(
+                        WindowEvent::MouseWheel { device_id, delta, phase },
+                        window_id,
+                    )
+                },
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct WinitPointerData {
+    /// The inner winit data associated with the pointer.
+    inner: Mutex<WinitPointerDataInner>,
+
+    /// The data required by the sctk.
+    sctk_data: PointerData,
+
+    /// Viewport for fractional cursor.
+    viewport: Option<WpViewport>,
+}
+
+impl WinitPointerData {
+    pub fn new(seat: WlSeat, viewport: Option<WpViewport>) -> Self {
+        Self {
+            inner: Mutex::new(WinitPointerDataInner::default()),
+            sctk_data: PointerData::new(seat),
+            viewport,
+        }
+    }
+
+    pub fn lock_pointer(
+        &self,
+        pointer_constraints: &PointerConstraintsState,
+        surface: &WlSurface,
+        pointer: &WlPointer,
+        queue_handle: &QueueHandle<WinitState>,
+    ) {
+        let mut inner = self.inner.lock().unwrap();
+        if inner.locked_pointer.is_none() {
+            inner.locked_pointer = Some(pointer_constraints.lock_pointer(
+                surface,
+                pointer,
+                None,
+                Lifetime::Persistent,
+                queue_handle,
+                GlobalData,
+            ));
+        }
+    }
+
+    pub fn unlock_pointer(&self) {
+        let mut inner = self.inner.lock().unwrap();
+        if let Some(locked_pointer) = inner.locked_pointer.take() {
+            locked_pointer.destroy();
+        }
+    }
+
+    pub fn confine_pointer(
+        &self,
+        pointer_constraints: &PointerConstraintsState,
+        surface: &WlSurface,
+        pointer: &WlPointer,
+        queue_handle: &QueueHandle<WinitState>,
+    ) {
+        self.inner.lock().unwrap().confined_pointer = Some(pointer_constraints.confine_pointer(
+            surface,
+            pointer,
+            None,
+            Lifetime::Persistent,
+            queue_handle,
+            GlobalData,
+        ));
+    }
+
+    pub fn unconfine_pointer(&self) {
+        let inner = self.inner.lock().unwrap();
+        if let Some(confined_pointer) = inner.confined_pointer.as_ref() {
+            confined_pointer.destroy();
+        }
+    }
+
+    /// Seat associated with this pointer.
+    pub fn seat(&self) -> &WlSeat {
+        self.sctk_data.seat()
+    }
+
+    /// Active window.
+    pub fn focused_window(&self) -> Option<WindowId> {
+        self.inner.lock().unwrap().surface
+    }
+
+    /// Last button serial.
+    pub fn latest_button_serial(&self) -> u32 {
+        self.sctk_data.latest_button_serial().unwrap_or_default()
+    }
+
+    /// Last enter serial.
+    pub fn latest_enter_serial(&self) -> u32 {
+        self.sctk_data.latest_enter_serial().unwrap_or_default()
+    }
+
+    pub fn set_locked_cursor_position(&self, surface_x: f64, surface_y: f64) {
+        let inner = self.inner.lock().unwrap();
+        if let Some(locked_pointer) = inner.locked_pointer.as_ref() {
+            locked_pointer.set_cursor_position_hint(surface_x, surface_y);
+        }
+    }
+
+    pub fn viewport(&self) -> Option<&WpViewport> {
+        self.viewport.as_ref()
+    }
+}
+
+impl Drop for WinitPointerData {
+    fn drop(&mut self) {
+        if let Some(viewport) = self.viewport.take() {
+            viewport.destroy();
+        }
+    }
+}
+
+impl PointerDataExt for WinitPointerData {
+    fn pointer_data(&self) -> &PointerData {
+        &self.sctk_data
+    }
+}
+
+#[derive(Debug)]
+pub struct WinitPointerDataInner {
+    /// The associated locked pointer.
+    locked_pointer: Option<ZwpLockedPointerV1>,
+
+    /// The associated confined pointer.
+    confined_pointer: Option<ZwpConfinedPointerV1>,
+
+    /// Serial of the last button event.
+    latest_button_serial: u32,
+
+    /// Currently focused window.
+    surface: Option<WindowId>,
+
+    /// Current axis phase.
+    phase: TouchPhase,
+}
+
+impl Drop for WinitPointerDataInner {
+    fn drop(&mut self) {
+        if let Some(locked_pointer) = self.locked_pointer.take() {
+            locked_pointer.destroy();
+        }
+
+        if let Some(confined_pointer) = self.confined_pointer.take() {
+            confined_pointer.destroy();
+        }
+    }
+}
+
+impl Default for WinitPointerDataInner {
+    fn default() -> Self {
+        Self {
+            surface: None,
+            locked_pointer: None,
+            confined_pointer: None,
+            latest_button_serial: 0,
+            phase: TouchPhase::Ended,
+        }
+    }
+}
+
+/// Convert the Wayland button into winit.
+fn wayland_button_to_winit(button: u32) -> MouseButton {
+    // These values are coming from <linux/input-event-codes.h>.
+    const BTN_LEFT: u32 = 0x110;
+    const BTN_RIGHT: u32 = 0x111;
+    const BTN_MIDDLE: u32 = 0x112;
+    const BTN_SIDE: u32 = 0x113;
+    const BTN_EXTRA: u32 = 0x114;
+    const BTN_FORWARD: u32 = 0x115;
+    const BTN_BACK: u32 = 0x116;
+
+    match button {
+        BTN_LEFT => MouseButton::Left,
+        BTN_RIGHT => MouseButton::Right,
+        BTN_MIDDLE => MouseButton::Middle,
+        BTN_BACK | BTN_SIDE => MouseButton::Back,
+        BTN_FORWARD | BTN_EXTRA => MouseButton::Forward,
+        button => MouseButton::Other(button as u16),
+    }
+}
+
+pub trait WinitPointerDataExt {
+    fn winit_data(&self) -> &WinitPointerData;
+}
+
+impl WinitPointerDataExt for WlPointer {
+    fn winit_data(&self) -> &WinitPointerData {
+        self.data::<WinitPointerData>().expect("failed to get pointer data.")
+    }
+}
+
+pub struct PointerConstraintsState {
+    pointer_constraints: ZwpPointerConstraintsV1,
+}
+
+impl PointerConstraintsState {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let pointer_constraints = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { pointer_constraints })
+    }
+}
+
+impl Deref for PointerConstraintsState {
+    type Target = ZwpPointerConstraintsV1;
+
+    fn deref(&self) -> &Self::Target {
+        &self.pointer_constraints
+    }
+}
+
+impl Dispatch<ZwpPointerConstraintsV1, GlobalData, WinitState> for PointerConstraintsState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpPointerConstraintsV1,
+        _event: <ZwpPointerConstraintsV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpLockedPointerV1, GlobalData, WinitState> for PointerConstraintsState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpLockedPointerV1,
+        _event: <ZwpLockedPointerV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpConfinedPointerV1, GlobalData, WinitState> for PointerConstraintsState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpConfinedPointerV1,
+        _event: <ZwpConfinedPointerV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<WpCursorShapeDeviceV1, GlobalData, WinitState> for SeatState {
+    fn event(
+        _: &mut WinitState,
+        _: &WpCursorShapeDeviceV1,
+        _: <WpCursorShapeDeviceV1 as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        unreachable!("wp_cursor_shape_manager has no events")
+    }
+}
+
+impl Dispatch<WpCursorShapeManagerV1, GlobalData, WinitState> for SeatState {
+    fn event(
+        _: &mut WinitState,
+        _: &WpCursorShapeManagerV1,
+        _: <WpCursorShapeManagerV1 as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        unreachable!("wp_cursor_device_manager has no events")
+    }
+}
+
+delegate_dispatch!(WinitState: [ WlPointer: WinitPointerData] => SeatState);
+delegate_dispatch!(WinitState: [ WpCursorShapeManagerV1: GlobalData] => SeatState);
+delegate_dispatch!(WinitState: [ WpCursorShapeDeviceV1: GlobalData] => SeatState);
+delegate_dispatch!(WinitState: [ZwpPointerConstraintsV1: GlobalData] => PointerConstraintsState);
+delegate_dispatch!(WinitState: [ZwpLockedPointerV1: GlobalData] => PointerConstraintsState);
+delegate_dispatch!(WinitState: [ZwpConfinedPointerV1: GlobalData] => PointerConstraintsState);

vendor/winit/src/platform_impl/linux/wayland/seat/pointer/relative_pointer.rs

@@ -0,0 +1,83 @@
+//! Relative pointer.
+
+use std::ops::Deref;
+
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::{delegate_dispatch, Dispatch};
+use sctk::reexports::client::{Connection, QueueHandle};
+use sctk::reexports::protocols::wp::relative_pointer::zv1::{
+    client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1,
+    client::zwp_relative_pointer_v1::{self, ZwpRelativePointerV1},
+};
+
+use sctk::globals::GlobalData;
+
+use crate::event::DeviceEvent;
+use crate::platform_impl::wayland::state::WinitState;
+
+/// Wrapper around the relative pointer.
+pub struct RelativePointerState {
+    manager: ZwpRelativePointerManagerV1,
+}
+
+impl RelativePointerState {
+    /// Create new relative pointer manager.
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { manager })
+    }
+}
+
+impl Deref for RelativePointerState {
+    type Target = ZwpRelativePointerManagerV1;
+
+    fn deref(&self) -> &Self::Target {
+        &self.manager
+    }
+}
+
+impl Dispatch<ZwpRelativePointerManagerV1, GlobalData, WinitState> for RelativePointerState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpRelativePointerManagerV1,
+        _event: <ZwpRelativePointerManagerV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpRelativePointerV1, GlobalData, WinitState> for RelativePointerState {
+    fn event(
+        state: &mut WinitState,
+        _proxy: &ZwpRelativePointerV1,
+        event: <ZwpRelativePointerV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+        let (dx_unaccel, dy_unaccel) = match event {
+            zwp_relative_pointer_v1::Event::RelativeMotion { dx_unaccel, dy_unaccel, .. } => {
+                (dx_unaccel, dy_unaccel)
+            },
+            _ => return,
+        };
+        state
+            .events_sink
+            .push_device_event(DeviceEvent::Motion { axis: 0, value: dx_unaccel }, super::DeviceId);
+        state
+            .events_sink
+            .push_device_event(DeviceEvent::Motion { axis: 1, value: dy_unaccel }, super::DeviceId);
+        state.events_sink.push_device_event(
+            DeviceEvent::MouseMotion { delta: (dx_unaccel, dy_unaccel) },
+            super::DeviceId,
+        );
+    }
+}
+
+delegate_dispatch!(WinitState: [ZwpRelativePointerV1: GlobalData] => RelativePointerState);
+delegate_dispatch!(WinitState: [ZwpRelativePointerManagerV1: GlobalData] => RelativePointerState);

vendor/winit/src/platform_impl/linux/wayland/seat/text_input/mod.rs

@@ -0,0 +1,201 @@
+use std::ops::Deref;
+
+use sctk::globals::GlobalData;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{delegate_dispatch, Dispatch};
+use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
+use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::{
+    ContentHint, ContentPurpose, Event as TextInputEvent, ZwpTextInputV3,
+};
+
+use crate::event::{Ime, WindowEvent};
+use crate::platform_impl::wayland;
+use crate::platform_impl::wayland::state::WinitState;
+use crate::window::ImePurpose;
+
+pub struct TextInputState {
+    text_input_manager: ZwpTextInputManagerV3,
+}
+
+impl TextInputState {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let text_input_manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { text_input_manager })
+    }
+}
+
+impl Deref for TextInputState {
+    type Target = ZwpTextInputManagerV3;
+
+    fn deref(&self) -> &Self::Target {
+        &self.text_input_manager
+    }
+}
+
+impl Dispatch<ZwpTextInputManagerV3, GlobalData, WinitState> for TextInputState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpTextInputManagerV3,
+        _event: <ZwpTextInputManagerV3 as Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
+    fn event(
+        state: &mut WinitState,
+        text_input: &ZwpTextInputV3,
+        event: <ZwpTextInputV3 as Proxy>::Event,
+        data: &TextInputData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+        let windows = state.windows.get_mut();
+        let mut text_input_data = data.inner.lock().unwrap();
+        match event {
+            TextInputEvent::Enter { surface } => {
+                let window_id = wayland::make_wid(&surface);
+                text_input_data.surface = Some(surface);
+
+                let mut window = match windows.get(&window_id) {
+                    Some(window) => window.lock().unwrap(),
+                    None => return,
+                };
+
+                if window.ime_allowed() {
+                    text_input.enable();
+                    text_input.set_content_type_by_purpose(window.ime_purpose());
+                    text_input.commit();
+                    state.events_sink.push_window_event(WindowEvent::Ime(Ime::Enabled), window_id);
+                }
+
+                window.text_input_entered(text_input);
+            },
+            TextInputEvent::Leave { surface } => {
+                text_input_data.surface = None;
+
+                // Always issue a disable.
+                text_input.disable();
+                text_input.commit();
+
+                let window_id = wayland::make_wid(&surface);
+
+                // XXX this check is essential, because `leave` could have a
+                // reference to nil surface...
+                let mut window = match windows.get(&window_id) {
+                    Some(window) => window.lock().unwrap(),
+                    None => return,
+                };
+
+                window.text_input_left(text_input);
+
+                state.events_sink.push_window_event(WindowEvent::Ime(Ime::Disabled), window_id);
+            },
+            TextInputEvent::PreeditString { text, cursor_begin, cursor_end } => {
+                let text = text.unwrap_or_default();
+                let cursor_begin = usize::try_from(cursor_begin)
+                    .ok()
+                    .and_then(|idx| text.is_char_boundary(idx).then_some(idx));
+                let cursor_end = usize::try_from(cursor_end)
+                    .ok()
+                    .and_then(|idx| text.is_char_boundary(idx).then_some(idx));
+
+                text_input_data.pending_preedit = Some(Preedit { text, cursor_begin, cursor_end })
+            },
+            TextInputEvent::CommitString { text } => {
+                text_input_data.pending_preedit = None;
+                text_input_data.pending_commit = text;
+            },
+            TextInputEvent::Done { .. } => {
+                let window_id = match text_input_data.surface.as_ref() {
+                    Some(surface) => wayland::make_wid(surface),
+                    None => return,
+                };
+
+                // Clear preedit, unless all we'll be doing next is sending a new preedit.
+                if text_input_data.pending_commit.is_some()
+                    || text_input_data.pending_preedit.is_none()
+                {
+                    state.events_sink.push_window_event(
+                        WindowEvent::Ime(Ime::Preedit(String::new(), None)),
+                        window_id,
+                    );
+                }
+
+                // Send `Commit`.
+                if let Some(text) = text_input_data.pending_commit.take() {
+                    state
+                        .events_sink
+                        .push_window_event(WindowEvent::Ime(Ime::Commit(text)), window_id);
+                }
+
+                // Send preedit.
+                if let Some(preedit) = text_input_data.pending_preedit.take() {
+                    let cursor_range =
+                        preedit.cursor_begin.map(|b| (b, preedit.cursor_end.unwrap_or(b)));
+
+                    state.events_sink.push_window_event(
+                        WindowEvent::Ime(Ime::Preedit(preedit.text, cursor_range)),
+                        window_id,
+                    );
+                }
+            },
+            TextInputEvent::DeleteSurroundingText { .. } => {
+                // Not handled.
+            },
+            _ => {},
+        }
+    }
+}
+
+pub trait ZwpTextInputV3Ext {
+    fn set_content_type_by_purpose(&self, purpose: ImePurpose);
+}
+
+impl ZwpTextInputV3Ext for ZwpTextInputV3 {
+    fn set_content_type_by_purpose(&self, purpose: ImePurpose) {
+        let (hint, purpose) = match purpose {
+            ImePurpose::Normal => (ContentHint::None, ContentPurpose::Normal),
+            ImePurpose::Password => (ContentHint::SensitiveData, ContentPurpose::Password),
+            ImePurpose::Terminal => (ContentHint::None, ContentPurpose::Terminal),
+        };
+        self.set_content_type(hint, purpose);
+    }
+}
+
+/// The Data associated with the text input.
+#[derive(Default)]
+pub struct TextInputData {
+    inner: std::sync::Mutex<TextInputDataInner>,
+}
+
+#[derive(Default)]
+pub struct TextInputDataInner {
+    /// The `WlSurface` we're performing input to.
+    surface: Option<WlSurface>,
+
+    /// The commit to submit on `done`.
+    pending_commit: Option<String>,
+
+    /// The preedit to submit on `done`.
+    pending_preedit: Option<Preedit>,
+}
+
+/// The state of the preedit.
+struct Preedit {
+    text: String,
+    cursor_begin: Option<usize>,
+    cursor_end: Option<usize>,
+}
+
+delegate_dispatch!(WinitState: [ZwpTextInputManagerV3: GlobalData] => TextInputState);
+delegate_dispatch!(WinitState: [ZwpTextInputV3: TextInputData] => TextInputState);

vendor/winit/src/platform_impl/linux/wayland/seat/touch/mod.rs

@@ -0,0 +1,220 @@
+//! Touch handling.
+
+use tracing::warn;
+
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::protocol::wl_touch::WlTouch;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+
+use sctk::seat::touch::{TouchData, TouchHandler};
+
+use crate::dpi::LogicalPosition;
+use crate::event::{Touch, TouchPhase, WindowEvent};
+
+use crate::platform_impl::wayland::state::WinitState;
+use crate::platform_impl::wayland::{self, DeviceId};
+
+impl TouchHandler for WinitState {
+    fn down(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        touch: &WlTouch,
+        _: u32,
+        _: u32,
+        surface: WlSurface,
+        id: i32,
+        position: (f64, f64),
+    ) {
+        let window_id = wayland::make_wid(&surface);
+        let scale_factor = match self.windows.get_mut().get(&window_id) {
+            Some(window) => window.lock().unwrap().scale_factor(),
+            None => return,
+        };
+
+        let seat_state = match self.seats.get_mut(&touch.seat().id()) {
+            Some(seat_state) => seat_state,
+            None => {
+                warn!("Received wl_touch::down without seat");
+                return;
+            },
+        };
+
+        // Update the state of the point.
+        let location = LogicalPosition::<f64>::from(position);
+        seat_state.touch_map.insert(id, TouchPoint { surface, location });
+
+        self.events_sink.push_window_event(
+            WindowEvent::Touch(Touch {
+                device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                    DeviceId,
+                )),
+                phase: TouchPhase::Started,
+                location: location.to_physical(scale_factor),
+                force: None,
+                id: id as u64,
+            }),
+            window_id,
+        );
+    }
+
+    fn up(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        touch: &WlTouch,
+        _: u32,
+        _: u32,
+        id: i32,
+    ) {
+        let seat_state = match self.seats.get_mut(&touch.seat().id()) {
+            Some(seat_state) => seat_state,
+            None => {
+                warn!("Received wl_touch::up without seat");
+                return;
+            },
+        };
+
+        // Remove the touch point.
+        let touch_point = match seat_state.touch_map.remove(&id) {
+            Some(touch_point) => touch_point,
+            None => return,
+        };
+
+        let window_id = wayland::make_wid(&touch_point.surface);
+        let scale_factor = match self.windows.get_mut().get(&window_id) {
+            Some(window) => window.lock().unwrap().scale_factor(),
+            None => return,
+        };
+
+        self.events_sink.push_window_event(
+            WindowEvent::Touch(Touch {
+                device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                    DeviceId,
+                )),
+                phase: TouchPhase::Ended,
+                location: touch_point.location.to_physical(scale_factor),
+                force: None,
+                id: id as u64,
+            }),
+            window_id,
+        );
+    }
+
+    fn motion(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        touch: &WlTouch,
+        _: u32,
+        id: i32,
+        position: (f64, f64),
+    ) {
+        let seat_state = match self.seats.get_mut(&touch.seat().id()) {
+            Some(seat_state) => seat_state,
+            None => {
+                warn!("Received wl_touch::motion without seat");
+                return;
+            },
+        };
+
+        // Remove the touch point.
+        let touch_point = match seat_state.touch_map.get_mut(&id) {
+            Some(touch_point) => touch_point,
+            None => return,
+        };
+
+        let window_id = wayland::make_wid(&touch_point.surface);
+        let scale_factor = match self.windows.get_mut().get(&window_id) {
+            Some(window) => window.lock().unwrap().scale_factor(),
+            None => return,
+        };
+
+        touch_point.location = LogicalPosition::<f64>::from(position);
+
+        self.events_sink.push_window_event(
+            WindowEvent::Touch(Touch {
+                device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                    DeviceId,
+                )),
+                phase: TouchPhase::Moved,
+                location: touch_point.location.to_physical(scale_factor),
+                force: None,
+                id: id as u64,
+            }),
+            window_id,
+        );
+    }
+
+    fn cancel(&mut self, _: &Connection, _: &QueueHandle<Self>, touch: &WlTouch) {
+        let seat_state = match self.seats.get_mut(&touch.seat().id()) {
+            Some(seat_state) => seat_state,
+            None => {
+                warn!("Received wl_touch::cancel without seat");
+                return;
+            },
+        };
+
+        for (id, touch_point) in seat_state.touch_map.drain() {
+            let window_id = wayland::make_wid(&touch_point.surface);
+            let scale_factor = match self.windows.get_mut().get(&window_id) {
+                Some(window) => window.lock().unwrap().scale_factor(),
+                None => return,
+            };
+
+            let location = touch_point.location.to_physical(scale_factor);
+
+            self.events_sink.push_window_event(
+                WindowEvent::Touch(Touch {
+                    device_id: crate::event::DeviceId(crate::platform_impl::DeviceId::Wayland(
+                        DeviceId,
+                    )),
+                    phase: TouchPhase::Cancelled,
+                    location,
+                    force: None,
+                    id: id as u64,
+                }),
+                window_id,
+            );
+        }
+    }
+
+    fn shape(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &WlTouch,
+        _: i32,
+        _: f64,
+        _: f64,
+    ) {
+        // Blank.
+    }
+
+    fn orientation(&mut self, _: &Connection, _: &QueueHandle<Self>, _: &WlTouch, _: i32, _: f64) {
+        // Blank.
+    }
+}
+
+/// The state of the touch point.
+#[derive(Debug)]
+pub struct TouchPoint {
+    /// The surface on which the point is present.
+    pub surface: WlSurface,
+
+    /// The location of the point on the surface.
+    pub location: LogicalPosition<f64>,
+}
+
+pub trait TouchDataExt {
+    fn seat(&self) -> &WlSeat;
+}
+
+impl TouchDataExt for WlTouch {
+    fn seat(&self) -> &WlSeat {
+        self.data::<TouchData>().expect("failed to get touch data.").seat()
+    }
+}
+
+sctk::delegate_touch!(WinitState);

vendor/winit/src/platform_impl/linux/wayland/state.rs

@@ -0,0 +1,435 @@
+use std::cell::RefCell;
+use std::sync::atomic::Ordering;
+use std::sync::{Arc, Mutex};
+
+use ahash::AHashMap;
+
+use sctk::reexports::calloop::LoopHandle;
+use sctk::reexports::client::backend::ObjectId;
+use sctk::reexports::client::globals::GlobalList;
+use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{Connection, Proxy, QueueHandle};
+
+use sctk::compositor::{CompositorHandler, CompositorState};
+use sctk::output::{OutputHandler, OutputState};
+use sctk::registry::{ProvidesRegistryState, RegistryState};
+use sctk::seat::pointer::ThemedPointer;
+use sctk::seat::SeatState;
+use sctk::shell::xdg::window::{Window, WindowConfigure, WindowHandler};
+use sctk::shell::xdg::XdgShell;
+use sctk::shell::WaylandSurface;
+use sctk::shm::slot::SlotPool;
+use sctk::shm::{Shm, ShmHandler};
+use sctk::subcompositor::SubcompositorState;
+
+use crate::platform_impl::wayland::event_loop::sink::EventSink;
+use crate::platform_impl::wayland::output::MonitorHandle;
+use crate::platform_impl::wayland::seat::{
+    PointerConstraintsState, RelativePointerState, TextInputState, WinitPointerData,
+    WinitPointerDataExt, WinitSeatState,
+};
+use crate::platform_impl::wayland::types::kwin_blur::KWinBlurManager;
+use crate::platform_impl::wayland::types::wp_fractional_scaling::FractionalScalingManager;
+use crate::platform_impl::wayland::types::wp_viewporter::ViewporterState;
+use crate::platform_impl::wayland::types::xdg_activation::XdgActivationState;
+use crate::platform_impl::wayland::window::{WindowRequests, WindowState};
+use crate::platform_impl::wayland::{WaylandError, WindowId};
+use crate::platform_impl::OsError;
+
+/// Winit's Wayland state.
+pub struct WinitState {
+    /// The WlRegistry.
+    pub registry_state: RegistryState,
+
+    /// The state of the WlOutput handling.
+    pub output_state: OutputState,
+
+    /// The compositor state which is used to create new windows and regions.
+    pub compositor_state: Arc<CompositorState>,
+
+    /// The state of the subcompositor.
+    pub subcompositor_state: Option<Arc<SubcompositorState>>,
+
+    /// The seat state responsible for all sorts of input.
+    pub seat_state: SeatState,
+
+    /// The shm for software buffers, such as cursors.
+    pub shm: Shm,
+
+    /// The pool where custom cursors are allocated.
+    pub custom_cursor_pool: Arc<Mutex<SlotPool>>,
+
+    /// The XDG shell that is used for windows.
+    pub xdg_shell: XdgShell,
+
+    /// The currently present windows.
+    pub windows: RefCell<AHashMap<WindowId, Arc<Mutex<WindowState>>>>,
+
+    /// The requests from the `Window` to EventLoop, such as close operations and redraw requests.
+    pub window_requests: RefCell<AHashMap<WindowId, Arc<WindowRequests>>>,
+
+    /// The events that were generated directly from the window.
+    pub window_events_sink: Arc<Mutex<EventSink>>,
+
+    /// The update for the `windows` coming from the compositor.
+    pub window_compositor_updates: Vec<WindowCompositorUpdate>,
+
+    /// Currently handled seats.
+    pub seats: AHashMap<ObjectId, WinitSeatState>,
+
+    /// Currently present cursor surfaces.
+    pub pointer_surfaces: AHashMap<ObjectId, Arc<ThemedPointer<WinitPointerData>>>,
+
+    /// The state of the text input on the client.
+    pub text_input_state: Option<TextInputState>,
+
+    /// Observed monitors.
+    pub monitors: Arc<Mutex<Vec<MonitorHandle>>>,
+
+    /// Sink to accumulate window events from the compositor, which is latter dispatched in
+    /// event loop run.
+    pub events_sink: EventSink,
+
+    /// Xdg activation.
+    pub xdg_activation: Option<XdgActivationState>,
+
+    /// Relative pointer.
+    pub relative_pointer: Option<RelativePointerState>,
+
+    /// Pointer constraints to handle pointer locking and confining.
+    pub pointer_constraints: Option<Arc<PointerConstraintsState>>,
+
+    /// Viewporter state on the given window.
+    pub viewporter_state: Option<ViewporterState>,
+
+    /// Fractional scaling manager.
+    pub fractional_scaling_manager: Option<FractionalScalingManager>,
+
+    /// KWin blur manager.
+    pub kwin_blur_manager: Option<KWinBlurManager>,
+
+    /// Loop handle to re-register event sources, such as keyboard repeat.
+    pub loop_handle: LoopHandle<'static, Self>,
+
+    /// Whether we have dispatched events to the user thus we want to
+    /// send `AboutToWait` and normally wakeup the user.
+    pub dispatched_events: bool,
+}
+
+impl WinitState {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<Self>,
+        loop_handle: LoopHandle<'static, WinitState>,
+    ) -> Result<Self, OsError> {
+        let registry_state = RegistryState::new(globals);
+        let compositor_state =
+            CompositorState::bind(globals, queue_handle).map_err(WaylandError::Bind)?;
+        let subcompositor_state = match SubcompositorState::bind(
+            compositor_state.wl_compositor().clone(),
+            globals,
+            queue_handle,
+        ) {
+            Ok(c) => Some(c),
+            Err(e) => {
+                tracing::warn!("Subcompositor protocol not available, ignoring CSD: {e:?}");
+                None
+            },
+        };
+
+        let output_state = OutputState::new(globals, queue_handle);
+        let monitors = output_state.outputs().map(MonitorHandle::new).collect();
+
+        let seat_state = SeatState::new(globals, queue_handle);
+
+        let mut seats = AHashMap::default();
+        for seat in seat_state.seats() {
+            seats.insert(seat.id(), WinitSeatState::new());
+        }
+
+        let (viewporter_state, fractional_scaling_manager) =
+            if let Ok(fsm) = FractionalScalingManager::new(globals, queue_handle) {
+                (ViewporterState::new(globals, queue_handle).ok(), Some(fsm))
+            } else {
+                (None, None)
+            };
+
+        let shm = Shm::bind(globals, queue_handle).map_err(WaylandError::Bind)?;
+        let custom_cursor_pool = Arc::new(Mutex::new(SlotPool::new(2, &shm).unwrap()));
+
+        Ok(Self {
+            registry_state,
+            compositor_state: Arc::new(compositor_state),
+            subcompositor_state: subcompositor_state.map(Arc::new),
+            output_state,
+            seat_state,
+            shm,
+            custom_cursor_pool,
+
+            xdg_shell: XdgShell::bind(globals, queue_handle).map_err(WaylandError::Bind)?,
+            xdg_activation: XdgActivationState::bind(globals, queue_handle).ok(),
+
+            windows: Default::default(),
+            window_requests: Default::default(),
+            window_compositor_updates: Vec::new(),
+            window_events_sink: Default::default(),
+            viewporter_state,
+            fractional_scaling_manager,
+            kwin_blur_manager: KWinBlurManager::new(globals, queue_handle).ok(),
+
+            seats,
+            text_input_state: TextInputState::new(globals, queue_handle).ok(),
+
+            relative_pointer: RelativePointerState::new(globals, queue_handle).ok(),
+            pointer_constraints: PointerConstraintsState::new(globals, queue_handle)
+                .map(Arc::new)
+                .ok(),
+            pointer_surfaces: Default::default(),
+
+            monitors: Arc::new(Mutex::new(monitors)),
+            events_sink: EventSink::new(),
+            loop_handle,
+            // Make it true by default.
+            dispatched_events: true,
+        })
+    }
+
+    pub fn scale_factor_changed(
+        &mut self,
+        surface: &WlSurface,
+        scale_factor: f64,
+        is_legacy: bool,
+    ) {
+        // Check if the cursor surface.
+        let window_id = super::make_wid(surface);
+
+        if let Some(window) = self.windows.get_mut().get(&window_id) {
+            // Don't update the scaling factor, when legacy method is used.
+            if is_legacy && self.fractional_scaling_manager.is_some() {
+                return;
+            }
+
+            // The scale factor change is for the window.
+            let pos = if let Some(pos) = self
+                .window_compositor_updates
+                .iter()
+                .position(|update| update.window_id == window_id)
+            {
+                pos
+            } else {
+                self.window_compositor_updates.push(WindowCompositorUpdate::new(window_id));
+                self.window_compositor_updates.len() - 1
+            };
+
+            // Update the scale factor right away.
+            window.lock().unwrap().set_scale_factor(scale_factor);
+            self.window_compositor_updates[pos].scale_changed = true;
+        } else if let Some(pointer) = self.pointer_surfaces.get(&surface.id()) {
+            // Get the window, where the pointer resides right now.
+            let focused_window = match pointer.pointer().winit_data().focused_window() {
+                Some(focused_window) => focused_window,
+                None => return,
+            };
+
+            if let Some(window_state) = self.windows.get_mut().get(&focused_window) {
+                window_state.lock().unwrap().reload_cursor_style()
+            }
+        }
+    }
+
+    pub fn queue_close(updates: &mut Vec<WindowCompositorUpdate>, window_id: WindowId) {
+        let pos = if let Some(pos) = updates.iter().position(|update| update.window_id == window_id)
+        {
+            pos
+        } else {
+            updates.push(WindowCompositorUpdate::new(window_id));
+            updates.len() - 1
+        };
+
+        updates[pos].close_window = true;
+    }
+}
+
+impl ShmHandler for WinitState {
+    fn shm_state(&mut self) -> &mut Shm {
+        &mut self.shm
+    }
+}
+
+impl WindowHandler for WinitState {
+    fn request_close(&mut self, _: &Connection, _: &QueueHandle<Self>, window: &Window) {
+        let window_id = super::make_wid(window.wl_surface());
+        Self::queue_close(&mut self.window_compositor_updates, window_id);
+    }
+
+    fn configure(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        window: &Window,
+        configure: WindowConfigure,
+        _serial: u32,
+    ) {
+        let window_id = super::make_wid(window.wl_surface());
+
+        let pos = if let Some(pos) =
+            self.window_compositor_updates.iter().position(|update| update.window_id == window_id)
+        {
+            pos
+        } else {
+            self.window_compositor_updates.push(WindowCompositorUpdate::new(window_id));
+            self.window_compositor_updates.len() - 1
+        };
+
+        // Populate the configure to the window.
+        self.window_compositor_updates[pos].resized |= self
+            .windows
+            .get_mut()
+            .get_mut(&window_id)
+            .expect("got configure for dead window.")
+            .lock()
+            .unwrap()
+            .configure(configure, &self.shm, &self.subcompositor_state);
+
+        // NOTE: configure demands wl_surface::commit, however winit doesn't commit on behalf of the
+        // users, since it can break a lot of things, thus it'll ask users to redraw instead.
+        self.window_requests
+            .get_mut()
+            .get(&window_id)
+            .unwrap()
+            .redraw_requested
+            .store(true, Ordering::Relaxed);
+
+        // Manually mark that we've got an event, since configure may not generate a resize.
+        self.dispatched_events = true;
+    }
+}
+
+impl OutputHandler for WinitState {
+    fn output_state(&mut self) -> &mut OutputState {
+        &mut self.output_state
+    }
+
+    fn new_output(&mut self, _: &Connection, _: &QueueHandle<Self>, output: WlOutput) {
+        self.monitors.lock().unwrap().push(MonitorHandle::new(output));
+    }
+
+    fn update_output(&mut self, _: &Connection, _: &QueueHandle<Self>, updated: WlOutput) {
+        let mut monitors = self.monitors.lock().unwrap();
+        let updated = MonitorHandle::new(updated);
+        if let Some(pos) = monitors.iter().position(|output| output == &updated) {
+            monitors[pos] = updated
+        } else {
+            monitors.push(updated)
+        }
+    }
+
+    fn output_destroyed(&mut self, _: &Connection, _: &QueueHandle<Self>, removed: WlOutput) {
+        let mut monitors = self.monitors.lock().unwrap();
+        let removed = MonitorHandle::new(removed);
+        if let Some(pos) = monitors.iter().position(|output| output == &removed) {
+            monitors.remove(pos);
+        }
+    }
+}
+
+impl CompositorHandler for WinitState {
+    fn transform_changed(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &WlSurface,
+        _: wayland_client::protocol::wl_output::Transform,
+    ) {
+        // TODO(kchibisov) we need to expose it somehow in winit.
+    }
+
+    fn surface_enter(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &WlSurface,
+        _: &WlOutput,
+    ) {
+    }
+
+    fn surface_leave(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        _: &WlSurface,
+        _: &WlOutput,
+    ) {
+    }
+
+    fn scale_factor_changed(
+        &mut self,
+        _: &Connection,
+        _: &QueueHandle<Self>,
+        surface: &WlSurface,
+        scale_factor: i32,
+    ) {
+        self.scale_factor_changed(surface, scale_factor as f64, true)
+    }
+
+    fn frame(&mut self, _: &Connection, _: &QueueHandle<Self>, surface: &WlSurface, _: u32) {
+        let window_id = super::make_wid(surface);
+        let window = match self.windows.get_mut().get(&window_id) {
+            Some(window) => window,
+            None => return,
+        };
+
+        // In case we have a redraw requested we must indicate the wake up.
+        if self
+            .window_requests
+            .get_mut()
+            .get(&window_id)
+            .unwrap()
+            .redraw_requested
+            .load(Ordering::Relaxed)
+        {
+            self.dispatched_events = true;
+        }
+
+        window.lock().unwrap().frame_callback_received();
+    }
+}
+
+impl ProvidesRegistryState for WinitState {
+    sctk::registry_handlers![OutputState, SeatState];
+
+    fn registry(&mut self) -> &mut RegistryState {
+        &mut self.registry_state
+    }
+}
+
+// The window update coming from the compositor.
+#[derive(Debug, Clone, Copy)]
+pub struct WindowCompositorUpdate {
+    /// The id of the window this updates belongs to.
+    pub window_id: WindowId,
+
+    /// New window size.
+    pub resized: bool,
+
+    /// New scale factor.
+    pub scale_changed: bool,
+
+    /// Close the window.
+    pub close_window: bool,
+}
+
+impl WindowCompositorUpdate {
+    fn new(window_id: WindowId) -> Self {
+        Self { window_id, resized: false, scale_changed: false, close_window: false }
+    }
+}
+
+sctk::delegate_subcompositor!(WinitState);
+sctk::delegate_compositor!(WinitState);
+sctk::delegate_output!(WinitState);
+sctk::delegate_registry!(WinitState);
+sctk::delegate_shm!(WinitState);
+sctk::delegate_xdg_shell!(WinitState);
+sctk::delegate_xdg_window!(WinitState);

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

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