chore: bump the github-actions group across 1 directory with 3 updates

Bumps the github-actions group with 3 updates in the / directory: [actions/cache](https://github.com/actions/cache), [actions/checkout](https://github.com/actions/checkout) and [actions/upload-pages-artifact](https://github.com/actions/upload-pages-artifact).


Updates `actions/cache` from 5 to 6
- [Release notes](https://github.com/actions/cache/releases)
- [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md)
- [Commits](https://github.com/actions/cache/compare/v5...v6)

Updates `actions/checkout` from 6 to 7
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v6...v7)

Updates `actions/upload-pages-artifact` from 4 to 5
- [Release notes](https://github.com/actions/upload-pages-artifact/releases)
- [Commits](https://github.com/actions/upload-pages-artifact/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/cache
  dependency-version: '6'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
- dependency-name: actions/checkout
  dependency-version: '7'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
- dependency-name: actions/upload-pages-artifact
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/CODEOWNERS

@@ -1,31 +1,26 @@
 # Android
-/src/platform/android.rs            @MarijnS95
-/src/platform_impl/android          @MarijnS95
+/winit-android                      @MarijnS95
 
 # Apple (AppKit + UIKit)
-/src/platform/ios.rs                @madsmtm
-/src/platform/macos.rs              @madsmtm
-/src/platform_impl/apple            @madsmtm
+/winit-appkit                       @madsmtm
+/winit-uikit                        @madsmtm
+/winit-common/src/core_foundation   @madsmtm
+/winit-common/src/event_handler.rs  @madsmtm
 
-# Unix
-/src/platform_impl/linux/mod.rs     @kchibisov
+# XKB
+/winit-common/src/xkb               @kchibisov
 
 # Wayland
-/src/platform/wayland.rs            @kchibisov
-/src/platform_impl/linux/wayland    @kchibisov
+/winit-wayland                      @kchibisov
 
 # X11
-/src/platform/x11.rs                @kchibisov @notgull
-/src/platform_impl/linux/x11        @kchibisov @notgull
+/winit-x11                          @kchibisov
 
 # Web
-/src/platform/web.rs                @daxpedda
-/src/platform_impl/web              @daxpedda
+/winit-web                          @daxpedda
 
-# Windows
-/src/platform/windows.rs            @notgull
-/src/platform_impl/windows          @notgull
+# Windows (Win32) (UNOWNED)
+#/winit-win32                       
 
 # Orbital (Redox OS)
-/src/platform/orbital.rs            @jackpot51
-/src/platform_impl/orbital          @jackpot51
+/winit-orbital                      @jackpot51

.github/ISSUE_TEMPLATE/bug_appkit.yml

@@ -1,8 +1,8 @@
-name: MacOS bug
+name: macOS bug
 description: Create a macOS-specific bug report
 labels:
   - B - bug
-  - DS - macos
+  - DS - appkit
 body:
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/bug_uikit.yml

@@ -1,8 +1,8 @@
 name: iOS bug
-description: Create an iOS-specific bug report
+description: Create an iOS/UIKit-specific bug report
 labels:
   - B - bug
-  - DS - ios
+  - DS - uikit
 body:
   - type: markdown
     attributes:

.github/ISSUE_TEMPLATE/bug_win32.yml

@@ -2,7 +2,7 @@ name: Windows bug
 description: Create a Windows-specific bug report
 labels:
   - B - bug
-  - DS - windows
+  - DS - win32
 body:
   - type: markdown
     attributes:

.github/workflows/ci.yml

@@ -55,7 +55,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        toolchain: [stable, nightly, '1.73']
+        toolchain: [stable, nightly, '1.85']
         platform:
           # Note: Make sure that we test all the `docs.rs` targets defined in Cargo.toml!
           - { name: 'Windows 64bit MSVC', target: x86_64-pc-windows-msvc,   os: windows-latest,  }
@@ -66,7 +66,7 @@ jobs:
           - { name: 'Linux 64bit',        target: x86_64-unknown-linux-gnu, os: ubuntu-latest,   }
           - { name: 'X11',                target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: '--no-default-features --features=x11' }
           - { name: 'Wayland',            target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: '--no-default-features --features=wayland,wayland-dlopen' }
-          - { name: 'Android',            target: aarch64-linux-android,    os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
+          - { name: 'Android',            target: aarch64-linux-android,    os: ubuntu-latest, options: '--package winit --features=android-native-activity', cmd: 'apk -- ' }
           - { name: 'Redox OS',           target: x86_64-unknown-redox,     os: ubuntu-latest,   }
           - { name: 'macOS x86_64',       target: x86_64-apple-darwin,      os: macos-latest,    }
           - { name: 'macOS Aarch64',      target: aarch64-apple-darwin,     os: macos-latest,    }
@@ -82,14 +82,14 @@ jobs:
           - toolchain: nightly
             platform: { name: 'Windows 32bit GNU' }
           # Android is tested on stable-3
-          - toolchain: '1.73'
+          - toolchain: '1.85'
             platform: { name: 'Android' }
           # Redox OS doesn't follow MSRV
-          - toolchain: '1.73'
+          - toolchain: '1.85'
             platform: { name: 'Redox OS' }
         include:
-          - toolchain: '1.73'
-            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
+          - toolchain: '1.85'
+            platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package winit --features=android-native-activity', cmd: 'apk -- ' }
           - toolchain: 'nightly'
             platform: { name: 'Web', target: wasm32-unknown-unknown, os: ubuntu-latest, test-options: -Zdoctest-xcompile }
           - toolchain: 'nightly'
@@ -124,7 +124,7 @@ jobs:
       # the cache has been downloaded.
       #
       # This could be avoided if we added Cargo.lock to the repository.
-      uses: actions/cache/restore@v4
+      uses: actions/cache/restore@v6
       with:
         # https://doc.rust-lang.org/cargo/guide/cargo-home.html#caching-the-cargo-home-in-ci
         path: |
@@ -136,7 +136,7 @@ jobs:
 
     - name: Generate lockfile
       # Also updates the crates.io index
-      run: cargo generate-lockfile && cargo update -p ahash --precise 0.8.7 && cargo update -p bumpalo --precise 3.14.0
+      run: cargo generate-lockfile && cargo update -p smol_str --precise 0.3.2 && cargo update -p unicode-segmentation --precise 1.12.0 && cargo update -p wayland-protocols --precise 0.32.12
 
     - name: Install GCC Multilib
       if: (matrix.platform.os == 'ubuntu-latest') && contains(matrix.platform.target, 'i686')
@@ -145,7 +145,7 @@ jobs:
     - name: Cache cargo-apk
       if: contains(matrix.platform.target, 'android')
       id: cargo-apk-cache
-      uses: actions/cache@v4
+      uses: actions/cache@v6
       with:
         path: ~/.cargo/bin/cargo-apk
         # Change this key if we update the required cargo-apk version
@@ -160,7 +160,7 @@ jobs:
       if: contains(matrix.platform.target, 'android') && (steps.cargo-apk-cache.outputs.cache-hit != 'true')
       run: cargo install cargo-apk --version=^0.9.7 --locked
 
-    - uses: taiki-e/cache-cargo-install-action@v2
+    - uses: taiki-e/cache-cargo-install-action@v3
       if: contains(matrix.platform.target, 'wasm32') && matrix.toolchain == 'nightly'
       with:
         tool: wasm-bindgen-cli
@@ -179,17 +179,70 @@ jobs:
     - name: Build crate
       run: cargo $CMD build $OPTIONS
 
+    - name: Test winit core
+      run: cargo test -p winit-core
+
+    - name: Test winit Android
+      if: contains(matrix.platform.target, 'android')
+      run: cargo $CMD test -p winit-android --features native-activity --no-run
+
+    - name: Test winit Common (EventHandler)
+      run: cargo $CMD test -p winit-common --features event-handler --no-run
+
+    - name: Test winit Common (CF)
+      if: contains(matrix.platform.target, 'apple')
+      run: cargo $CMD test -p winit-common --features core-foundation --no-run
+
+    - name: Test winit Common (XKB)
+      if: contains(matrix.platform.target, 'linux-gnu')
+      run: cargo $CMD test -p winit-common --features xkb,x11,wayland --no-run
+
+    - name: Test winit AppKit
+      if: contains(matrix.platform.target, 'macos')
+      run: cargo $CMD test -p winit-appkit $OPTIONS
+
+    - name: Test winit Orbital
+      if: contains(matrix.platform.target, 'redox')
+      run: cargo test -p winit-orbital
+
+    - name: Test winit UIKit
+      if: contains(matrix.platform.target, 'ios')
+      # TODO: Run on Simulator
+      run: cargo $CMD test -p winit-uikit $OPTIONS --no-run
+
+    - name: Test winit Web
+      if: contains(matrix.platform.target, 'wasm')
+      run: cargo $CMD test -p winit-web $OPTIONS --no-run
+
+    - name: Test winit Win32
+      if: contains(matrix.platform.target, 'windows')
+      run: cargo $CMD test -p winit-win32 $OPTIONS
+
+    - name: Test winit X11
+      if: contains(matrix.platform.target, 'linux-gnu')
+      run: cargo $CMD test -p winit-x11 --target=${{ matrix.platform.target }}
+
+    - name: Test winit Wayland
+      if: contains(matrix.platform.target, 'linux-gnu')
+      run: cargo $CMD test -p winit-wayland --target=${{ matrix.platform.target }}
+
     # Test only on Linux x86_64, so we avoid spending unnecessary CI hours.
     - name: Test dpi crate
       if: >
         contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.85'
       run: cargo test -p dpi
 
+    - name: Check dpi crate (no_std)
+      if: >
+        contains(matrix.platform.name, 'Linux 64bit') &&
+        matrix.toolchain != '1.85'
+      run: cargo check -p dpi --no-default-features
+
     - name: Build tests
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.85'
       run: cargo $CMD test --no-run $OPTIONS
 
     - name: Run tests
@@ -198,7 +251,7 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         (!contains(matrix.platform.target, 'wasm32') || matrix.toolchain == 'nightly') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.85'
       run: cargo $CMD test $OPTIONS
 
     - name: Lint with clippy
@@ -208,7 +261,7 @@ jobs:
     - name: Build tests with serde enabled
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.85'
       run: cargo $CMD test --no-run $OPTIONS $TEST_OPTIONS --features serde
 
     - name: Run tests with serde enabled
@@ -217,7 +270,7 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         (!contains(matrix.platform.target, 'wasm32') || matrix.toolchain == 'nightly') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.73'
+        matrix.toolchain != '1.85'
       run: cargo $CMD test $OPTIONS $TEST_OPTIONS --features serde
 
     - name: Check docs.rs documentation
@@ -228,7 +281,7 @@ jobs:
 
     # See restore step above
     - name: Save cache of cargo folder
-      uses: actions/cache/save@v4
+      uses: actions/cache/save@v6
       with:
         path: |
           ~/.cargo/registry/index/
@@ -237,30 +290,14 @@ jobs:
         key: cargo-${{ matrix.toolchain }}-${{ matrix.platform.name }}-${{ hashFiles('Cargo.lock') }}
 
   cargo-deny:
-    name: Run cargo-deny on ${{ matrix.platform.name }}
+    name: Run cargo-deny
     runs-on: ubuntu-latest
 
-    # TODO: remove this matrix when https://github.com/EmbarkStudios/cargo-deny/issues/324 is resolved
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - { name: 'Android', target: aarch64-linux-android }
-          - { name: 'iOS', target: aarch64-apple-ios }
-          - { name: 'Linux', target: x86_64-unknown-linux-gnu }
-          - { name: 'macOS', target: aarch64-apple-darwin }
-          - { name: 'Redox OS', target: x86_64-unknown-redox }
-          - { name: 'Web', target: wasm32-unknown-unknown }
-          - { name: 'Windows GNU', target: x86_64-pc-windows-gnu }
-          - { name: 'Windows MSVC', target: x86_64-pc-windows-msvc }
-
     steps:
     - uses: taiki-e/checkout-action@v1
     - uses: EmbarkStudios/cargo-deny-action@v2
       with:
-        command: check
         log-level: error
-        arguments: --all-features --target ${{ matrix.platform.target }}
 
   eslint:
     name: ESLint
@@ -268,14 +305,14 @@ jobs:
     runs-on: ubuntu-latest
     defaults:
       run:
-        working-directory: ./src/platform_impl/web/script
+        working-directory: ./winit-web/src/script
 
     steps:
       - uses: taiki-e/checkout-action@v1
       - name: Setup NPM
         run: npm install
       - name: Run ESLint
-        run: npx eslint
+        run: npx eslint@9.38.0
 
   swc:
     name: Minimize JavaScript
@@ -283,7 +320,7 @@ jobs:
     runs-on: ubuntu-latest
     defaults:
       run:
-        working-directory: ./src/platform_impl/web/script
+        working-directory: ./winit-web/src/script
 
     steps:
       - uses: taiki-e/checkout-action@v1

.github/workflows/docs.yml

@@ -19,7 +19,7 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
 
       - uses: dtolnay/rust-toolchain@master
         with:
@@ -32,7 +32,7 @@ jobs:
           cargo doc --no-deps -Z rustdoc-map -Z rustdoc-scrape-examples --features=serde,mint,android-native-activity
 
       - name: Setup Pages
-        uses: actions/configure-pages@v5
+        uses: actions/configure-pages@v6
 
       - name: Fix permissions
         run: |
@@ -41,10 +41,10 @@ jobs:
           done
 
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
+        uses: actions/upload-pages-artifact@v5
         with:
           path: target/doc
 
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v5

CHANGELOG.md

@@ -3,6 +3,6 @@ Changelog entries should be put in the [`changelog::unreleased`].
 The changelog can also be viewed [on docs.rs][docs_rs] or [on the current
 master docs][master_docs].
 
-[`changelog::unreleased`]: src/changelog/unreleased.md
+[`changelog::unreleased`]: winit/src/changelog/unreleased.md
 [docs_rs]: https://docs.rs/winit/latest/winit/changelog/index.html
 [master_docs]: https://rust-windowing.github.io/winit/winit/changelog/index.html

CONTRIBUTING.md

@@ -13,6 +13,13 @@ To save your time it's wise to check already opened [pull requests][prs] and
 accepted, however larger new API proposals should go into the issue first. When
 in doubt contact us on [Matrix][matrix] or via opening an issue.
 
+### Windows
+
+To run the examples on Windows, you must have symlinks enabled, see
+[this][git-windows-symlinks].
+
+[git-windows-symlinks]: https://gitforwindows.org/symbolic-links.html
+
 ### Submitting your work and handling review
 
 All patches have to be sent on Github as [pull requests][prs]. To simplify your
@@ -22,7 +29,12 @@ to the branch" checkbox.
 We use unstable Rustfmt options across the project, so please run
 `cargo +nightly fmt` before submitting your work. If you are unable to do so,
 the maintainers can do it for you before merging, just state so in your pull
-request description.
+request description. For details on how to use nightly, consult [the
+documentation][toolchains].
+
+When editing markdown files (`.md`) they must be wrapped at 80 characters.
+
+[toolchains]: https://rust-lang.github.io/rustup/concepts/toolchains.html
 
 #### Handling review
 

Cargo.toml

@@ -1,403 +1,97 @@
-[package]
-authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
-categories = ["gui"]
-description = "Cross-platform window creation library."
-documentation = "https://docs.rs/winit"
-edition.workspace = true
-include = [
-    "/build.rs",
-    "/docs",
-    "/examples",
-    "/FEATURES.md",
-    "/LICENSE",
-    "/src",
-    "!/src/platform_impl/web/script",
-    "/src/platform_impl/web/script/**/*.min.js",
-    "/tests",
-]
-keywords = ["windowing"]
-license.workspace = true
-name = "winit"
-readme = "README.md"
-repository.workspace = true
-rust-version.workspace = true
-version = "0.30.9"
+[workspace]
+default-members = ["winit"]
+members = ["dpi", "winit*"]
+resolver = "2"
 
-[package.metadata.docs.rs]
-features = [
-    "serde",
-    "mint",
-    # Enabled to get docs to compile
-    "android-native-activity",
-]
-# These are all tested in CI
-rustdoc-args = ["--cfg", "docsrs"]
-targets = [
-    # Windows
-    "i686-pc-windows-msvc",
-    "x86_64-pc-windows-msvc",
-    # macOS
-    "aarch64-apple-darwin",
-    "x86_64-apple-darwin",
-    # Unix (X11 & Wayland)
-    "i686-unknown-linux-gnu",
-    "x86_64-unknown-linux-gnu",
-    # iOS
-    "aarch64-apple-ios",
-    # Android
-    "aarch64-linux-android",
-    # Web
-    "wasm32-unknown-unknown",
-]
+[workspace.package]
+edition = "2024"
+license = "Apache-2.0"
+repository = "https://github.com/rust-windowing/winit"
+rust-version = "1.85"
+version = "0.31.0-beta.2"
 
-# Features are documented in either `lib.rs` or under `winit::platform`.
-[features]
-android-game-activity = ["android-activity/game-activity"]
-android-native-activity = ["android-activity/native-activity"]
-default = ["x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
-mint = ["dpi/mint"]
-serde = ["dep:serde", "cursor-icon/serde", "smol_str/serde", "dpi/serde", "bitflags/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"]
+[workspace.dependencies]
+# Workspace dependencies.
+# `winit` has no version here to allow using it in dev deps for docs.
+winit = { path = "winit" }
+winit-android = { version = "=0.31.0-beta.2", path = "winit-android" }
+winit-appkit = { version = "=0.31.0-beta.2", path = "winit-appkit" }
+winit-common = { version = "=0.31.0-beta.2", path = "winit-common" }
+winit-core = { version = "=0.31.0-beta.2", path = "winit-core" }
+winit-orbital = { version = "=0.31.0-beta.2", path = "winit-orbital" }
+winit-uikit = { version = "=0.31.0-beta.2", path = "winit-uikit" }
+winit-wayland = { version = "=0.31.0-beta.2", path = "winit-wayland", default-features = false }
+winit-web = { version = "=0.31.0-beta.2", path = "winit-web" }
+winit-win32 = { version = "=0.31.0-beta.2", path = "winit-win32" }
+winit-x11 = { version = "=0.31.0-beta.2", path = "winit-x11" }
 
-[build-dependencies]
-cfg_aliases = "0.2.1"
-
-[dependencies]
+# Core dependencies.
 bitflags = "2"
+cfg_aliases = "0.2.1"
 cursor-icon = "1.1.0"
-dpi = { version = "0.1.1", path = "dpi" }
+dpi = { version = "0.1.2", path = "dpi" }
+keyboard-types = "0.8.0"
+mint = "0.5.6"
 rwh_06 = { package = "raw-window-handle", version = "0.6", features = ["std"] }
-serde = { workspace = true, optional = true }
+serde = { version = "1", features = ["serde_derive"] }
 smol_str = "0.3"
 tracing = { version = "0.1.40", default-features = false }
 
-[dev-dependencies]
-image = { version = "0.25.0", default-features = false, features = ["png"] }
-tracing = { version = "0.1.40", default-features = false, features = ["log"] }
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
-
-[target.'cfg(not(target_os = "android"))'.dev-dependencies]
-softbuffer = { version = "0.4.6", default-features = false, features = [
+# Dev dependencies.
+image = { version = "0.25.0", default-features = false }
+softbuffer = { version = "0.4.8", default-features = false, features = [
     "x11",
     "x11-dlopen",
     "wayland",
     "wayland-dlopen",
 ] }
+tracing-subscriber = "0.3.18"
 
-# Android
-[target.'cfg(target_os = "android")'.dependencies]
+# Android dependencies.
 android-activity = "0.6.0"
 ndk = { version = "0.9.0", features = ["rwh_06"], default-features = false }
 
-# AppKit or UIKit
-[target.'cfg(target_vendor = "apple")'.dependencies]
-block2 = "0.6.0"
-dispatch2 = { version = "0.2.0", default-features = false, features = ["std", "objc2"] }
-objc2 = "0.6.0"
+# Apple dependencies.
+block2 = "0.6.1"
+dispatch2 = { version = "0.3.0", default-features = false, features = ["std", "objc2"] }
+objc2 = { version = "0.6.1", features = ["relax-sign-encoding"] }
+objc2-app-kit = { version = "0.3.2", default-features = false }
+objc2-core-foundation = { version = "0.3.2", default-features = false }
+objc2-core-graphics = { version = "0.3.2", default-features = false }
+objc2-core-video = { version = "0.3.2", default-features = false }
+objc2-foundation = { version = "0.3.2", default-features = false }
+objc2-ui-kit = { version = "0.3.2", default-features = false }
 
-# AppKit
-[target.'cfg(target_os = "macos")'.dependencies]
-objc2-app-kit = { version = "0.3.0", default-features = false, features = [
-    "std",
-    "objc2-core-foundation",
-    "NSAppearance",
-    "NSApplication",
-    "NSBitmapImageRep",
-    "NSButton",
-    "NSColor",
-    "NSControl",
-    "NSCursor",
-    "NSDragging",
-    "NSEvent",
-    "NSGraphics",
-    "NSGraphicsContext",
-    "NSImage",
-    "NSImageRep",
-    "NSMenu",
-    "NSMenuItem",
-    "NSOpenGLView",
-    "NSPanel",
-    "NSPasteboard",
-    "NSResponder",
-    "NSRunningApplication",
-    "NSScreen",
-    "NSTextInputClient",
-    "NSTextInputContext",
-    "NSToolbar",
-    "NSView",
-    "NSWindow",
-    "NSWindowScripting",
-    "NSWindowTabGroup",
-] }
-objc2-core-foundation = { version = "0.3.0", default-features = false, features = [
-    "std",
-    "block2",
-    "CFBase",
-    "CFCGTypes",
-    "CFData",
-    "CFRunLoop",
-    "CFString",
-    "CFUUID",
-] }
-objc2-core-graphics = { version = "0.3.0", default-features = false, features = [
-    "std",
-    "libc",
-    "CGDirectDisplay",
-    "CGDisplayConfiguration",
-    "CGDisplayFade",
-    "CGError",
-    "CGRemoteOperation",
-    "CGWindowLevel",
-] }
-objc2-core-video = { version = "0.3.0", default-features = false, features = [
-    "std",
-    "objc2-core-graphics",
-    "CVBase",
-    "CVReturn",
-    "CVDisplayLink",
-] }
-objc2-foundation = { version = "0.3.0", default-features = false, features = [
-    "std",
-    "block2",
-    "objc2-core-foundation",
-    "NSArray",
-    "NSAttributedString",
-    "NSData",
-    "NSDictionary",
-    "NSDistributedNotificationCenter",
-    "NSEnumerator",
-    "NSGeometry",
-    "NSKeyValueObserving",
-    "NSNotification",
-    "NSObjCRuntime",
-    "NSOperation",
-    "NSPathUtilities",
-    "NSProcessInfo",
-    "NSRunLoop",
-    "NSString",
-    "NSThread",
-    "NSValue",
-] }
-
-# UIKit
-[target.'cfg(all(target_vendor = "apple", not(target_os = "macos")))'.dependencies]
-objc2-core-foundation = { version = "0.3.0", default-features = false, features = [
-    "std",
-    "CFCGTypes",
-    "CFBase",
-    "CFRunLoop",
-    "CFString",
-] }
-objc2-foundation = { version = "0.3.0", default-features = false, features = [
-    "std",
-    "block2",
-    "objc2-core-foundation",
-    "NSArray",
-    "NSEnumerator",
-    "NSGeometry",
-    "NSObjCRuntime",
-    "NSOperation",
-    "NSString",
-    "NSThread",
-    "NSSet",
-] }
-objc2-ui-kit = { version = "0.3.0", default-features = false, features = [
-    "std",
-    "objc2-core-foundation",
-    "UIApplication",
-    "UIDevice",
-    "UIEvent",
-    "UIGeometry",
-    "UIGestureRecognizer",
-    "UITextInput",
-    "UITextInputTraits",
-    "UIOrientation",
-    "UIPanGestureRecognizer",
-    "UIPinchGestureRecognizer",
-    "UIResponder",
-    "UIRotationGestureRecognizer",
-    "UIScreen",
-    "UIScreenMode",
-    "UITapGestureRecognizer",
-    "UITouch",
-    "UITraitCollection",
-    "UIView",
-    "UIViewController",
-    "UIWindow",
-] }
-
-# Windows
-[target.'cfg(target_os = "windows")'.dependencies]
+# Windows dependencies.
 unicode-segmentation = "1.7.1"
-windows-sys = { version = "0.59.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",
-] }
+windows-sys = "0.61"
 
-# Linux
-[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_vendor = "apple"))))'.dependencies]
-ahash = { version = "0.8.7", features = ["no-rng"], optional = true }
-bytemuck = { version = "1.13.1", default-features = false, optional = true }
-calloop = "0.13.0"
+# Linux dependencies.
+bytemuck = { version = "1.13.1", default-features = false }
+calloop = "0.14.3"
+foldhash = { version = "0.2.0", default-features = false, features = ["std"] }
 libc = "0.2.64"
-memmap2 = { version = "0.9.0", optional = true }
-percent-encoding = { version = "2.0", optional = true }
-rustix = { version = "0.38.4", default-features = false, features = [
-    "std",
-    "system",
-    "thread",
-    "process",
-] }
-sctk = { package = "smithay-client-toolkit", version = "0.19.2", default-features = false, features = [
-    "calloop",
-], optional = true }
-sctk-adwaita = { version = "0.10.1", default-features = false, optional = true }
-wayland-backend = { version = "0.3.5", default-features = false, features = [
-    "client_system",
-], optional = true }
-wayland-client = { version = "0.31.4", optional = true }
-wayland-protocols = { version = "0.32.2", features = ["staging"], optional = true }
-wayland-protocols-plasma = { version = "0.3.2", features = ["client"], optional = true }
-x11-dl = { version = "2.19.1", optional = true }
-x11rb = { version = "0.13.0", default-features = false, features = [
-    "allow-unsafe-code",
-    "cursor",
-    "dl-libxcb",
-    "randr",
-    "resource_manager",
-    "sync",
-    "xinput",
-    "xkb",
-], optional = true }
+memmap2 = "0.9.0"
+percent-encoding = "2.0"
+rustix = { version = "1.0.7", default-features = false }
+x11-dl = "2.19.1"
+x11rb = { version = "0.13.0", default-features = false }
 xkbcommon-dl = "0.4.2"
 
-# Orbital
-[target.'cfg(target_os = "redox")'.dependencies]
+# Orbital dependencies.
+libredox = "0.1.12"
 orbclient = { version = "0.3.47", default-features = false }
-redox_syscall = "0.5.7"
+redox_event = { package = "redox_event", version = "0.4.5" }
 
-# Web
-[target.'cfg(target_family = "wasm")'.dependencies]
-js-sys = "0.3.70"
-pin-project = "1"
-wasm-bindgen = "0.2.93"
-wasm-bindgen-futures = "0.4.43"
-web-time = "1"
-web_sys = { package = "web-sys", version = "0.3.70", features = [
-    "AbortController",
-    "AbortSignal",
-    "Blob",
-    "BlobPropertyBag",
-    "console",
-    "CssStyleDeclaration",
-    "Document",
-    "DomException",
-    "DomRect",
-    "DomRectReadOnly",
-    "Element",
-    "Event",
-    "EventTarget",
-    "FocusEvent",
-    "HtmlCanvasElement",
-    "HtmlElement",
-    "HtmlHtmlElement",
-    "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",
-] }
-
-[target.'cfg(all(target_family = "wasm", target_feature = "atomics"))'.dependencies]
+# Web dependencies.
 atomic-waker = "1"
 concurrent-queue = { version = "2", default-features = false }
-
-[target.'cfg(target_family = "wasm")'.dev-dependencies]
 console_error_panic_hook = "0.1"
+js-sys = "0.3.70"
+pin-project = "1"
 tracing-web = "0.1"
+wasm-bindgen = "0.2.93"
+wasm-bindgen-futures = "0.4.43"
 wasm-bindgen-test = "0.3"
-
-[[example]]
-doc-scrape-examples = true
-name = "window"
-
-[[example]]
-name = "child_window"
-
-[workspace]
-members = ["dpi"]
-resolver = "2"
-
-[workspace.package]
-edition = "2021"
-license = "Apache-2.0"
-repository = "https://github.com/rust-windowing/winit"
-rust-version = "1.73"
-
-[workspace.dependencies]
-mint = "0.5.6"
-serde = { version = "1", features = ["serde_derive"] }
+web-time = "1"
+web_sys = { package = "web-sys", version = "0.3.70" }

README.md

@@ -8,7 +8,7 @@
 
 ```toml
 [dependencies]
-winit = "0.30.9"
+winit = "0.31.0-beta.2"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -33,9 +33,13 @@ Winit is designed to be a low-level brick in a hierarchy of libraries. Consequen
 show something on the window you need to use the platform-specific getters provided by winit, or
 another library.
 
+## CONTRIBUTING
+
+For contributing guidelines see [CONTRIBUTING.md](./CONTRIBUTING.md).
+
 ## MSRV Policy
 
-This crate's Minimum Supported Rust Version (MSRV) is **1.73**. Changes to
+This crate's Minimum Supported Rust Version (MSRV) is **1.85**. Changes to
 the MSRV will be accompanied by a minor version bump.
 
 As a **tentative** policy, the upper bound of the MSRV is given by the following
@@ -67,3 +71,9 @@ same MSRV policy.
 ### Platform-specific usage
 
 Check out the [`winit::platform`](https://docs.rs/winit/latest/winit/platform/index.html) module for platform-specific usage.
+
+### Repository License
+
+Note that the license in `LICENSE` doesn't apply in full to the DPI package [./dpi](./dpi).
+Full details can be found in that folder's README.
+<!-- This doesn't apply to users of the Winit crate, but this is also the repository level README -->

clippy.toml

@@ -1,16 +1,27 @@
-disallowed-methods = [
-    { path = "objc2_app_kit::NSView::visibleRect", reason = "We expose a render target to the user, and visibility is not really relevant to that (and can break if you don't use the rectangle position as well). Use `frame` instead." },
-    { path = "objc2_app_kit::NSWindow::setFrameTopLeftPoint", reason = "Not sufficient when working with Winit's coordinate system, use `flip_window_screen_coordinates` instead" },
-    { path = "web_sys::Document::exit_fullscreen", reason = "Doesn't account for compatibility with Safari" },
-    { path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },
-    { path = "web_sys::Element::request_fullscreen", reason = "Doesn't account for compatibility with Safari" },
-    { path = "web_sys::HtmlCanvasElement::height", reason = "Winit shouldn't touch the internal canvas size" },
-    { path = "web_sys::HtmlCanvasElement::set_height", reason = "Winit shouldn't touch the internal canvas size" },
-    { path = "web_sys::HtmlCanvasElement::set_width", reason = "Winit shouldn't touch the internal canvas size" },
-    { path = "web_sys::HtmlCanvasElement::width", reason = "Winit shouldn't touch the internal canvas size" },
-    { path = "web_sys::HtmlElement::style", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::Window::document", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::Window::get_computed_style", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::Window::navigator", reason = "cache this to reduce calls to JS" },
-    { path = "web_sys::window", reason = "is not available in every context" },
+# Using allow-invalid because this is platform-specific code
+disallowed-macros = [
+    { path = "std::print", reason = "works badly on web", replacement = "tracing::info" },
+    { path = "std::println", reason = "works badly on web", replacement = "tracing::info" },
+    { path = "std::eprint", reason = "works badly on web", replacement = "tracing::error" },
+    { path = "std::eprintln", reason = "works badly on web", replacement = "tracing::error" },
+    { path = "std::dbg", reason = "leftover debugging aid, remove it or use tracing" },
+]
+disallowed-methods = [
+    { allow-invalid = true, path = "objc2_app_kit::NSView::visibleRect", reason = "We expose a render target to the user, and visibility is not really relevant to that (and can break if you don't use the rectangle position as well). Use `frame` instead." },
+    { allow-invalid = true, path = "objc2_app_kit::NSWindow::setFrameTopLeftPoint", reason = "Not sufficient when working with Winit's coordinate system, use `flip_window_screen_coordinates` instead" },
+    { allow-invalid = true, path = "web_sys::Document::exit_fullscreen", reason = "Doesn't account for compatibility with Safari" },
+    { allow-invalid = true, path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },
+    { allow-invalid = true, path = "web_sys::Element::request_fullscreen", reason = "Doesn't account for compatibility with Safari" },
+    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::height", reason = "Winit shouldn't touch the internal canvas size" },
+    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::set_height", reason = "Winit shouldn't touch the internal canvas size" },
+    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::set_width", reason = "Winit shouldn't touch the internal canvas size" },
+    { allow-invalid = true, path = "web_sys::HtmlCanvasElement::width", reason = "Winit shouldn't touch the internal canvas size" },
+    { allow-invalid = true, path = "web_sys::HtmlElement::style", reason = "cache this to reduce calls to JS" },
+    { allow-invalid = true, path = "web_sys::MouseEvent::buttons", reason = "Use `backend::event::cursor_buttons()` to avoid wrong conversions" },
+    { allow-invalid = true, path = "web_sys::MouseEvent::button", reason = "Use `backend::event::cursor_button()` to avoid wrong conversions" },
+    { allow-invalid = true, path = "web_sys::PointerEvent::pointer_type", reason = "Use `WebPointerType` to emit warnings" },
+    { allow-invalid = true, path = "web_sys::Window::document", reason = "cache this to reduce calls to JS" },
+    { allow-invalid = true, path = "web_sys::Window::get_computed_style", reason = "cache this to reduce calls to JS" },
+    { allow-invalid = true, path = "web_sys::Window::navigator", reason = "cache this to reduce calls to JS" },
+    { allow-invalid = true, path = "web_sys::window", reason = "is not available in every context" },
 ]

deny.toml

@@ -1,27 +1,25 @@
 # https://embarkstudios.github.io/cargo-deny
 # cargo install cargo-deny
-# cargo update && cargo deny --target aarch64-apple-ios check
-# Note: running just `cargo deny check` without a `--target` will result in
-# false positives due to https://github.com/EmbarkStudios/cargo-deny/issues/324
+# cargo update && cargo deny check
 [graph]
 all-features = true
 exclude-dev = true
 targets = [
-    { triple = "aarch64-apple-darwin" },
-    { triple = "aarch64-apple-ios" },
-    { triple = "aarch64-linux-android" },
-    { triple = "i686-pc-windows-gnu" },
-    { triple = "i686-pc-windows-msvc" },
-    { triple = "i686-unknown-linux-gnu" },
+    "aarch64-apple-darwin",
+    "aarch64-apple-ios",
+    "aarch64-linux-android",
+    "i686-pc-windows-gnu",
+    "i686-pc-windows-msvc",
+    "i686-unknown-linux-gnu",
     { triple = "wasm32-unknown-unknown", features = [
         "atomics",
     ] },
-    { triple = "x86_64-apple-darwin" },
-    { triple = "x86_64-apple-ios" },
-    { triple = "x86_64-pc-windows-gnu" },
-    { triple = "x86_64-pc-windows-msvc" },
-    { triple = "x86_64-unknown-linux-gnu" },
-    { triple = "x86_64-unknown-redox" },
+    "x86_64-apple-darwin",
+    "x86_64-apple-ios",
+    "x86_64-pc-windows-gnu",
+    "x86_64-pc-windows-msvc",
+    "x86_64-unknown-linux-gnu",
+    "x86_64-unknown-redox",
 ]
 
 [licenses]
@@ -32,41 +30,32 @@ allow = [
     "ISC",          # https://tldrlegal.com/license/isc-license
     "MIT",          # https://tldrlegal.com/license/mit-license
     "Unicode-3.0",  # https://spdx.org/licenses/Unicode-3.0.html
+    "Zlib",         # https://spdx.org/licenses/Zlib.html
+    "MPL-2.0",      # https://www.mozilla.org/en-US/MPL/2.0/
 ]
 confidence-threshold = 1.0
 private = { ignore = true }
 
 [bans]
 multiple-versions = "deny"
-skip = [{ crate = "bitflags@1", reason = "the ecosystem is in the process of migrating" }]
-wildcards = "allow"                                                                        # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
+skip = [
+    { crate = "jni-sys@0.3", reason = "uses the semver trick to depend on v0.4, but `ndk` hasn't been updated to v0.4 yet" },
+    { crate = "thiserror@1.0", reason = "dep of `ndk` crate, yet to be updated" },
+    { crate = "thiserror-impl@1.0", reason = "dep of `thiserror`" },
+    { crate = "objc2@0.5", reason = "used by crossfont" },
+    { crate = "objc2-foundation@0.2", reason = "used by crossfont" },
+]
+skip-tree = [
+    { crate = "windows-sys", reason = "foundational but bumps fairly often, nothing we can do about it not having a shared version" },
+]
 
 [bans.build]
+bypass = [
+    { crate = "android-activity", allow-globs = ["android-games-sdk/import-games-sdk.sh"] },
+    { crate = "freetype-sys", allow-globs = ["freetype2/*"] },
+    # `crossfont` still depends (partially transitively) on `winapi`.
+    { crate = "winapi-i686-pc-windows-gnu", allow-globs = ["lib/lib*.a"] },
+    { crate = "winapi-x86_64-pc-windows-gnu", allow-globs = ["lib/lib*.a"] },
+]
 include-archives = true
 interpreted = "deny"
-
-[[bans.build.bypass]]
-allow = [
-    { path = "generate-bindings.sh", checksum = "268ec23248218d779e33853cdc60e2985e70214ff004716cd734270de1f6b561" },
-]
-crate = "android-activity"
-
-[[bans.build.bypass]]
-allow-globs = ["freetype2/*"]
-crate = "freetype-sys"
-
-[[bans.build.bypass]]
-allow-globs = ["lib/*.a"]
-crate = "windows_i686_gnu"
-
-[[bans.build.bypass]]
-allow-globs = ["lib/*.lib"]
-crate = "windows_i686_msvc"
-
-[[bans.build.bypass]]
-allow-globs = ["lib/*.a"]
-crate = "windows_x86_64_gnu"
-
-[[bans.build.bypass]]
-allow-globs = ["lib/*.lib"]
-crate = "windows_x86_64_msvc"

docs/ATTRIBUTION.md

@@ -1,18 +0,0 @@
-# Image Attribution
-
-These images are used in the documentation of `winit`.
-
-## keyboard_*.svg
-
-These files are a modified version of "[ANSI US QWERTY (Windows)](https://commons.wikimedia.org/wiki/File:ANSI_US_QWERTY_(Windows).svg)"
-by [Tomiĉo] (https://commons.wikimedia.org/wiki/User:Tomi%C4%89o). It 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.
-
-## `coordinate-systems*`
-
-These files are created by [Mads Marquart](https://github.com/madsmtm) using
-[draw.io](https://draw.io/), and compressed using [svgomg.net](https://svgomg.net/).
-
-They are licensed under the [CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/) license.

dpi/CHANGELOG.md

@@ -11,7 +11,10 @@ Unreleased` header.
 
 ## Unreleased
 
+## 0.1.2
+
 - Added `Insets`, `LogicalInsets` and `PhysicalInsets` types.
+- Make `no_std` compatible. If you use this functionality, DPI's license has changed.
 
 ## 0.1.1
 

dpi/Cargo.toml

@@ -3,16 +3,22 @@ categories = ["gui"]
 description = "Types for handling UI scaling"
 edition.workspace = true
 keywords = ["DPI", "HiDPI", "scale-factor"]
-license.workspace = true
+# N.B. This is "AND", because of the imported libm code.
+license = "Apache-2.0 AND MIT"
 name = "dpi"
 repository.workspace = true
 rust-version.workspace = true
-version = "0.1.1"
+version = "0.1.2"
 
 [features]
+default = ["std"]
+
 mint = ["dep:mint"]
 serde = ["dep:serde"]
 
+# Access mathematical functions using the standard library implementations
+std = []
+
 [dependencies]
 mint = { workspace = true, optional = true }
 serde = { workspace = true, optional = true }

dpi/LICENSE-LIBM-MIT

@@ -0,0 +1,51 @@
+rust-lang/libm as a whole is available for use under the MIT license:
+
+------------------------------------------------------------------------------
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+
+This Rust library contains the following copyrights:
+
+    Copyright (c) 2018 Jorge Aparicio
+
+Portions of this software are derived from third-party works licensed under
+terms compatible with the above MIT license:
+
+* musl libc https://www.musl-libc.org/. This library contains the following
+  copyright:
+
+      Copyright © 2005-2020 Rich Felker, et al.
+
+* The CORE-MATH project https://core-math.gitlabpages.inria.fr/. CORE-MATH
+  routines are available under the MIT license on a per-file basis.
+
+The musl libc COPYRIGHT file also includes the following notice relevant to
+math portions of the library:
+
+------------------------------------------------------------------------------
+Much of the math library code (src/math/* and src/complex/*) is
+Copyright © 1993,2004 Sun Microsystems or
+Copyright © 2003-2011 David Schultz or
+Copyright © 2003-2009 Steven G. Kargl or
+Copyright © 2003-2009 Bruce D. Evans or
+Copyright © 2008 Stephen L. Moshier or
+Copyright © 2017-2018 Arm Limited
+and labelled as such in comments in the individual source files. All
+have been licensed under extremely permissive terms.
+------------------------------------------------------------------------------

dpi/README.md

@@ -0,0 +1,18 @@
+# DPI
+
+Full docs can be found on docs.rs.
+
+## License
+
+Most of DPI is licensed under the Apache License, Version 2.0 ([LICENSE](LICENSE)).
+All files except for `src/libm.rs` (and `LICENSE-LIBM-MIT`) are available solely under that license.
+
+For its `no_std` support, DPI uses code from the [libm](https://crates.io/crates/libm) crate.
+This is in the `libm.rs` file, and is licensed solely under the MIT Licence ([LICENSE-LIBM-MIT](LICENSE-LIBM-MIT)).
+That file contains details of all potentially applicable copyright notices.
+This is feature gated to only be included if you disable the `std` feature, otherwise it will not be compiled into your final binary
+(and so these license terms will not apply).
+
+Overall, this means that the license for this crate depends on what features you have enabled.
+If you enable the `std` feature, then DPI uses only code available under the Apache-2.0 license, and so can be used under the terms of that license.
+However, if you disable the `std` feature, then both these licenses must be followed to use the crate as a whole.

dpi/src/lib.rs

@@ -54,13 +54,25 @@
 //!
 //! * `serde`: Enables serialization/deserialization of certain types with [Serde](https://crates.io/crates/serde).
 //! * `mint`: Enables mint (math interoperability standard types) conversions.
+//! * `std` (enabled by default): Uses the standard library mathematical functions (normally through
+//!   your target platform's libm). This feature also changes the library's license from `Apache-2.0
+//!   AND MIT` to `APACHE-2.0` (only). For full details, see the package README.
 //!
+//! To use this library on a target without the standard library available, you should disable
+//! default features (thus disabling the `std` feature, with the license consequences thereof).
 //!
 //! [points]: https://en.wikipedia.org/wiki/Point_(typography)
 //! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)
 
-#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
-#![forbid(unsafe_code)]
+#![cfg_attr(docsrs, feature(doc_cfg), doc(auto_cfg(hide(doc, docsrs))))]
+#![cfg_attr(feature = "std", forbid(unsafe_code))]
+#![no_std]
+
+#[cfg(not(feature = "std"))]
+mod libm;
+
+#[cfg(any(feature = "std", test))]
+extern crate std;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -72,36 +84,18 @@ pub trait Pixel: Copy + Into<f64> {
     }
 }
 
-impl Pixel for u8 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as u8
-    }
-}
-impl Pixel for u16 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as u16
-    }
-}
-impl Pixel for u32 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as u32
-    }
-}
-impl Pixel for i8 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as i8
-    }
-}
-impl Pixel for i16 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as i16
-    }
-}
-impl Pixel for i32 {
-    fn from_f64(f: f64) -> Self {
-        f.round() as i32
-    }
+macro_rules! pixel_int_impl {
+    ($($t:ty),*) => {$(
+        impl Pixel for $t {
+            fn from_f64(f: f64) -> Self {
+                round(f) as $t
+            }
+        }
+    )*}
 }
+
+pixel_int_impl!(u8, u16, u32, i8, i16, i32);
+
 impl Pixel for f32 {
     fn from_f64(f: f64) -> Self {
         f as f32
@@ -113,6 +107,15 @@ impl Pixel for f64 {
     }
 }
 
+/// Round f to the closest integer, rounding away from `0.0`
+#[inline]
+fn round(f: f64) -> f64 {
+    #[cfg(feature = "std")]
+    return f.round();
+    #[cfg(not(feature = "std"))]
+    return libm::round(f);
+}
+
 /// Checks that the scale factor is a normal positive `f64`.
 ///
 /// All functions that take a scale factor assert that this will return `true`. If you're sourcing
@@ -357,6 +360,48 @@ impl<P: Pixel> From<LogicalUnit<P>> for PixelUnit {
     }
 }
 
+macro_rules! vec2_from_impls {
+    ($t:ident, $a:ident, $b:ident, $mint_ty:ident) => {
+        impl<P: Pixel, X: Pixel> From<(X, X)> for $t<P> {
+            fn from(($a, $b): (X, X)) -> Self {
+                Self::new($a.cast(), $b.cast())
+            }
+        }
+
+        impl<P: Pixel, X: Pixel> From<$t<P>> for (X, X) {
+            fn from(p: $t<P>) -> Self {
+                (p.$a.cast(), p.$b.cast())
+            }
+        }
+
+        impl<P: Pixel, X: Pixel> From<[X; 2]> for $t<P> {
+            fn from([$a, $b]: [X; 2]) -> Self {
+                Self::new($a.cast(), $b.cast())
+            }
+        }
+
+        impl<P: Pixel, X: Pixel> From<$t<P>> for [X; 2] {
+            fn from(p: $t<P>) -> Self {
+                [p.$a.cast(), p.$b.cast()]
+            }
+        }
+
+        #[cfg(feature = "mint")]
+        impl<P: Pixel> From<mint::$mint_ty<P>> for $t<P> {
+            fn from(p: mint::$mint_ty<P>) -> Self {
+                Self::new(p.x, p.y)
+            }
+        }
+
+        #[cfg(feature = "mint")]
+        impl<P: Pixel> From<$t<P>> for mint::$mint_ty<P> {
+            fn from(p: $t<P>) -> Self {
+                Self { x: p.$a, y: p.$b }
+            }
+        }
+    };
+}
+
 /// A position represented in logical pixels.
 ///
 /// The position is stored as floats, so please be careful. Casting floats to integers truncates the
@@ -399,43 +444,7 @@ impl<P: Pixel> LogicalPosition<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalPosition<P> {
-    fn from((x, y): (X, X)) -> LogicalPosition<P> {
-        LogicalPosition::new(x.cast(), y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for (X, X) {
-    fn from(p: LogicalPosition<P>) -> (X, X) {
-        (p.x.cast(), p.y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalPosition<P> {
-    fn from([x, y]: [X; 2]) -> LogicalPosition<P> {
-        LogicalPosition::new(x.cast(), y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for [X; 2] {
-    fn from(p: LogicalPosition<P>) -> [X; 2] {
-        [p.x.cast(), p.y.cast()]
-    }
-}
-
-#[cfg(feature = "mint")]
-impl<P: Pixel> From<mint::Point2<P>> for LogicalPosition<P> {
-    fn from(p: mint::Point2<P>) -> Self {
-        Self::new(p.x, p.y)
-    }
-}
-
-#[cfg(feature = "mint")]
-impl<P: Pixel> From<LogicalPosition<P>> for mint::Point2<P> {
-    fn from(p: LogicalPosition<P>) -> Self {
-        mint::Point2 { x: p.x, y: p.y }
-    }
-}
+vec2_from_impls!(LogicalPosition, x, y, Point2);
 
 /// A position represented in physical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
@@ -475,43 +484,7 @@ impl<P: Pixel> PhysicalPosition<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalPosition<P> {
-    fn from((x, y): (X, X)) -> PhysicalPosition<P> {
-        PhysicalPosition::new(x.cast(), y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for (X, X) {
-    fn from(p: PhysicalPosition<P>) -> (X, X) {
-        (p.x.cast(), p.y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalPosition<P> {
-    fn from([x, y]: [X; 2]) -> PhysicalPosition<P> {
-        PhysicalPosition::new(x.cast(), y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for [X; 2] {
-    fn from(p: PhysicalPosition<P>) -> [X; 2] {
-        [p.x.cast(), p.y.cast()]
-    }
-}
-
-#[cfg(feature = "mint")]
-impl<P: Pixel> From<mint::Point2<P>> for PhysicalPosition<P> {
-    fn from(p: mint::Point2<P>) -> Self {
-        Self::new(p.x, p.y)
-    }
-}
-
-#[cfg(feature = "mint")]
-impl<P: Pixel> From<PhysicalPosition<P>> for mint::Point2<P> {
-    fn from(p: PhysicalPosition<P>) -> Self {
-        mint::Point2 { x: p.x, y: p.y }
-    }
-}
+vec2_from_impls!(PhysicalPosition, x, y, Point2);
 
 /// A size represented in logical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
@@ -551,43 +524,7 @@ impl<P: Pixel> LogicalSize<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalSize<P> {
-    fn from((x, y): (X, X)) -> LogicalSize<P> {
-        LogicalSize::new(x.cast(), y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for (X, X) {
-    fn from(s: LogicalSize<P>) -> (X, X) {
-        (s.width.cast(), s.height.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalSize<P> {
-    fn from([x, y]: [X; 2]) -> LogicalSize<P> {
-        LogicalSize::new(x.cast(), y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for [X; 2] {
-    fn from(s: LogicalSize<P>) -> [X; 2] {
-        [s.width.cast(), s.height.cast()]
-    }
-}
-
-#[cfg(feature = "mint")]
-impl<P: Pixel> From<mint::Vector2<P>> for LogicalSize<P> {
-    fn from(v: mint::Vector2<P>) -> Self {
-        Self::new(v.x, v.y)
-    }
-}
-
-#[cfg(feature = "mint")]
-impl<P: Pixel> From<LogicalSize<P>> for mint::Vector2<P> {
-    fn from(s: LogicalSize<P>) -> Self {
-        mint::Vector2 { x: s.width, y: s.height }
-    }
-}
+vec2_from_impls!(LogicalSize, width, height, Vector2);
 
 /// A size represented in physical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
@@ -624,43 +561,7 @@ impl<P: Pixel> PhysicalSize<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalSize<P> {
-    fn from((x, y): (X, X)) -> PhysicalSize<P> {
-        PhysicalSize::new(x.cast(), y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for (X, X) {
-    fn from(s: PhysicalSize<P>) -> (X, X) {
-        (s.width.cast(), s.height.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalSize<P> {
-    fn from([x, y]: [X; 2]) -> PhysicalSize<P> {
-        PhysicalSize::new(x.cast(), y.cast())
-    }
-}
-
-impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for [X; 2] {
-    fn from(s: PhysicalSize<P>) -> [X; 2] {
-        [s.width.cast(), s.height.cast()]
-    }
-}
-
-#[cfg(feature = "mint")]
-impl<P: Pixel> From<mint::Vector2<P>> for PhysicalSize<P> {
-    fn from(v: mint::Vector2<P>) -> Self {
-        Self::new(v.x, v.y)
-    }
-}
-
-#[cfg(feature = "mint")]
-impl<P: Pixel> From<PhysicalSize<P>> for mint::Vector2<P> {
-    fn from(s: PhysicalSize<P>) -> Self {
-        mint::Vector2 { x: s.width, y: s.height }
-    }
-}
+vec2_from_impls!(PhysicalSize, width, height, Vector2);
 
 /// A size that's either physical or logical.
 #[derive(Debug, Copy, Clone, PartialEq)]
@@ -1270,20 +1171,20 @@ mod tests {
     // Eat coverage for the Debug impls et al
     #[test]
     fn ensure_attrs_do_not_panic() {
-        let _ = format!("{:?}", LogicalPosition::<u32>::default().clone());
+        let _ = std::format!("{:?}", LogicalPosition::<u32>::default().clone());
         HashSet::new().insert(LogicalPosition::<u32>::default());
 
-        let _ = format!("{:?}", PhysicalPosition::<u32>::default().clone());
+        let _ = std::format!("{:?}", PhysicalPosition::<u32>::default().clone());
         HashSet::new().insert(PhysicalPosition::<u32>::default());
 
-        let _ = format!("{:?}", LogicalSize::<u32>::default().clone());
+        let _ = std::format!("{:?}", LogicalSize::<u32>::default().clone());
         HashSet::new().insert(LogicalSize::<u32>::default());
 
-        let _ = format!("{:?}", PhysicalSize::<u32>::default().clone());
+        let _ = std::format!("{:?}", PhysicalSize::<u32>::default().clone());
         HashSet::new().insert(PhysicalSize::<u32>::default());
 
-        let _ = format!("{:?}", Size::Physical((1, 2).into()).clone());
-        let _ = format!("{:?}", Position::Physical((1, 2).into()).clone());
+        let _ = std::format!("{:?}", Size::Physical((1, 2).into()).clone());
+        let _ = std::format!("{:?}", Position::Physical((1, 2).into()).clone());
     }
 
     #[test]

dpi/src/libm.rs

@@ -0,0 +1,56 @@
+// Copyright (c) 2018 Jorge Aparicio
+// Copyright © 2005-2020 Rich Felker, et al.
+// Copyright © 1993,2004 Sun Microsystems or
+// Copyright © 2003-2011 David Schultz or
+// Copyright © 2003-2009 Steven G. Kargl or
+// Copyright © 2003-2009 Bruce D. Evans or
+// Copyright © 2008 Stephen L. Moshier or
+// Copyright © 2017-2018 Arm Limited
+// SPDX-License-Identifier: MIT
+// This file is licensed solely under the terms discussed in LICENSE-LIBM-MIT at the crate root.
+// See the package-level README for full details.
+
+// Taken from https://github.com/rust-lang/libm/blob/master/src/math/mod.rs#L1
+macro_rules! force_eval {
+    ($e:expr) => {
+        unsafe { ::core::ptr::read_volatile(&$e) }
+    };
+}
+
+// Taken from https://github.com/rust-lang/libm/blob/libm-v0.2.11/src/math/round.rs
+pub(crate) fn round(x: f64) -> f64 {
+    trunc(x + copysign(0.5 - 0.25 * f64::EPSILON, x))
+}
+
+// Adapted from: https://github.com/rust-lang/libm/blob/libm-v0.2.11/src/math/trunc.rs#L8-L12
+#[allow(clippy::needless_late_init /*, reason = "The original libm code uses this style" */)]
+fn trunc(x: f64) -> f64 {
+    let x1p120 = f64::from_bits(0x4770000000000000); // 0x1p120f === 2 ^ 120
+
+    let mut i: u64 = x.to_bits();
+    let mut e: i64 = ((i >> 52) & 0x7ff) as i64 - 0x3ff + 12;
+    let m: u64;
+
+    if e >= 52 + 12 {
+        return x;
+    }
+    if e < 12 {
+        e = 1;
+    }
+    m = -1i64 as u64 >> e;
+    if (i & m) == 0 {
+        return x;
+    }
+    force_eval!(x + x1p120);
+    i &= !m;
+    f64::from_bits(i)
+}
+
+// Taken from https://github.com/rust-lang/libm/blob/libm-v0.2.11/src/math/copysign.rs
+fn copysign(x: f64, y: f64) -> f64 {
+    let mut ux = x.to_bits();
+    let uy = y.to_bits();
+    ux &= (!0) >> 1;
+    ux |= uy & (1 << 63);
+    f64::from_bits(ux)
+}

examples

@@ -0,0 +1 @@
+winit/examples

examples/util/fill.rs

@@ -1,131 +0,0 @@
-//! Fill the window buffer with a solid color.
-//!
-//! Launching a window without drawing to it has unpredictable results varying from platform to
-//! platform. In order to have well-defined examples, this module provides an easy way to
-//! fill the window buffer with a solid color.
-//!
-//! The `softbuffer` crate is used, largely because of its ease of use. `glutin` or `wgpu` could
-//! also be used to fill the window buffer, but they are more complicated to use.
-
-#[allow(unused_imports)]
-pub use platform::cleanup_window;
-#[allow(unused_imports)]
-pub use platform::fill_window;
-#[allow(unused_imports)]
-pub use platform::fill_window_with_color;
-
-#[cfg(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 dyn Window>>,
-
-        /// The hash map of window IDs to surfaces.
-        surfaces: HashMap<WindowId, Surface<&'static dyn Window, &'static dyn Window>>,
-    }
-
-    impl GraphicsContext {
-        fn new(w: &dyn Window) -> Self {
-            Self {
-                context: RefCell::new(
-                    Context::new(unsafe {
-                        mem::transmute::<&'_ dyn Window, &'static dyn Window>(w)
-                    })
-                    .expect("Failed to create a softbuffer context"),
-                ),
-                surfaces: HashMap::new(),
-            }
-        }
-
-        fn create_surface(
-            &mut self,
-            window: &dyn Window,
-        ) -> &mut Surface<&'static dyn Window, &'static dyn Window> {
-            self.surfaces.entry(window.id()).or_insert_with(|| {
-                Surface::new(&self.context.borrow(), unsafe {
-                    mem::transmute::<&'_ dyn Window, &'static dyn Window>(window)
-                })
-                .expect("Failed to create a softbuffer surface")
-            })
-        }
-
-        fn destroy_surface(&mut self, window: &dyn Window) {
-            self.surfaces.remove(&window.id());
-        }
-    }
-
-    pub fn fill_window_with_color(window: &dyn Window, color: u32) {
-        GC.with(|gc| {
-            let size = window.surface_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
-
-            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(color);
-            buffer.present().expect("Failed to present the softbuffer buffer");
-        })
-    }
-
-    #[allow(dead_code)]
-    pub fn fill_window(window: &dyn Window) {
-        fill_window_with_color(window, 0xff181818);
-    }
-
-    #[allow(dead_code)]
-    pub fn cleanup_window(window: &dyn Window) {
-        GC.with(|gc| {
-            let mut gc = gc.borrow_mut();
-            if let Some(context) = gc.as_mut() {
-                context.destroy_surface(window);
-            }
-        });
-    }
-}
-
-#[cfg(any(target_os = "android", target_os = "ios"))]
-mod platform {
-    pub fn fill_window(_window: &dyn winit::window::Window) {
-        // No-op on mobile platforms.
-    }
-
-    #[allow(dead_code)]
-    pub fn fill_window_with_color(_window: &dyn winit::window::Window, _color: u32) {
-        // No-op on mobile platforms.
-    }
-
-    #[allow(dead_code)]
-    pub fn cleanup_window(_window: &dyn winit::window::Window) {
-        // No-op on mobile platforms.
-    }
-}

src/event_loop.rs

@@ -1,545 +0,0 @@
-//! 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
-//! [`wake_up`][EventLoopProxy::wake_up] method. Then during handling the wake up
-//! you can poll your event sources.
-//!
-//! See the root-level documentation for information on how to create and use an event loop to
-//! handle events.
-use std::fmt;
-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::sync::Arc;
-#[cfg(not(web_platform))]
-use std::time::{Duration, Instant};
-
-use rwh_06::{DisplayHandle, HandleError, HasDisplayHandle};
-#[cfg(web_platform)]
-use web_time::{Duration, Instant};
-
-use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, RequestError};
-use crate::monitor::MonitorHandle;
-use crate::platform_impl;
-use crate::utils::AsAny;
-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 {
-    pub(crate) event_loop: platform_impl::EventLoop,
-    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::builder`].
-#[derive(Default, PartialEq, Eq, Hash)]
-pub struct EventLoopBuilder {
-    pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
-}
-
-static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
-
-impl EventLoopBuilder {
-    /// 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::with_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, 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 fmt::Debug for EventLoopBuilder {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventLoopBuilder").finish_non_exhaustive()
-    }
-}
-
-impl fmt::Debug for EventLoop {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventLoop").finish_non_exhaustive()
-    }
-}
-
-/// Set through [`ActiveEventLoop::set_control_flow()`].
-///
-/// Indicates the desired behavior of the event loop after [`about_to_wait`] is called.
-///
-/// Defaults to [`Wait`].
-///
-/// [`Wait`]: Self::Wait
-/// [`about_to_wait`]: crate::application::ApplicationHandler::about_to_wait
-#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash)]
-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 {
-        EventLoopBuilder { platform_specific: Default::default() }
-    }
-}
-
-impl EventLoop {
-    /// 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(
-        any(web_platform, docsrs),
-        doc = "  [`EventLoopExtWeb::spawn_app()`][crate::platform::web::EventLoopExtWeb::spawn_app()]"
-    )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  `EventLoopExtWeb::spawn_app()`")]
-    ///   [^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"`.
-    ///
-    /// [^1]: `spawn_app()` is only available on the Web platform.
-    ///
-    /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
-    /// [`run_app()`]: Self::run_app()
-    #[inline]
-    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
-    pub fn run_app<A: ApplicationHandler>(self, app: A) -> Result<(), EventLoopError> {
-        self.event_loop.run_app(app)
-    }
-
-    /// 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 {
-        self.event_loop.window_target().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 {
-        self.event_loop.window_target().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().listen_device_events(allowed)
-    }
-
-    /// Sets the [`ControlFlow`].
-    pub fn set_control_flow(&self, control_flow: ControlFlow) {
-        self.event_loop.window_target().set_control_flow(control_flow);
-    }
-
-    /// Create custom cursor.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **iOS / Android / Orbital:** Unsupported.
-    pub fn create_custom_cursor(
-        &self,
-        custom_cursor: CustomCursorSource,
-    ) -> Result<CustomCursor, RequestError> {
-        self.event_loop.window_target().create_custom_cursor(custom_cursor)
-    }
-}
-
-impl HasDisplayHandle for EventLoop {
-    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
-        HasDisplayHandle::display_handle(self.event_loop.window_target().rwh_06_handle())
-    }
-}
-
-#[cfg(any(x11_platform, wayland_platform))]
-impl AsFd for EventLoop {
-    /// 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 AsRawFd for EventLoop {
-    /// 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()
-    }
-}
-
-pub trait ActiveEventLoop: AsAny {
-    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
-    /// to the main event loop, possibly from another thread.
-    fn create_proxy(&self) -> EventLoopProxy;
-
-    /// 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.
-    fn create_window(
-        &self,
-        window_attributes: WindowAttributes,
-    ) -> Result<Box<dyn Window>, RequestError>;
-
-    /// Create custom cursor.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **iOS / Android / Orbital:** Unsupported.
-    fn create_custom_cursor(
-        &self,
-        custom_cursor: CustomCursorSource,
-    ) -> Result<CustomCursor, RequestError>;
-
-    /// Returns the list of all the monitors available on the system.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Only returns the current monitor without
-    #[cfg_attr(
-        any(web_platform, docsrs),
-        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = MonitorHandle>>;
-
-    /// Returns the primary monitor of the system.
-    ///
-    /// Returns `None` if it can't identify any monitor as a primary one.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Wayland:** Always returns `None`.
-    /// - **Web:** Always returns `None` without
-    #[cfg_attr(
-        any(web_platform, docsrs),
-        doc = "  [detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  detailed monitor permissions.")]
-    fn primary_monitor(&self) -> Option<MonitorHandle>;
-
-    /// 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
-    fn listen_device_events(&self, allowed: DeviceEvents);
-
-    /// Returns the current system theme.
-    ///
-    /// Returns `None` if it cannot be determined on the current platform.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Wayland / x11 / Orbital:** Unsupported.
-    fn system_theme(&self) -> Option<Theme>;
-
-    /// Sets the [`ControlFlow`].
-    fn set_control_flow(&self, control_flow: ControlFlow);
-
-    /// Gets the current [`ControlFlow`].
-    fn control_flow(&self) -> ControlFlow;
-
-    /// This exits the event loop.
-    ///
-    /// See [`exiting`][crate::application::ApplicationHandler::exiting].
-    fn exit(&self);
-
-    /// Returns if the [`EventLoop`] is about to stop.
-    ///
-    /// See [`exit()`][Self::exit].
-    fn exiting(&self) -> bool;
-
-    /// Gets a persistent reference to the underlying platform display.
-    ///
-    /// See the [`OwnedDisplayHandle`] type for more information.
-    fn owned_display_handle(&self) -> OwnedDisplayHandle;
-
-    /// Get the raw-window-handle handle.
-    fn rwh_06_handle(&self) -> &dyn HasDisplayHandle;
-}
-
-impl HasDisplayHandle for dyn ActiveEventLoop + '_ {
-    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
-        self.rwh_06_handle().display_handle()
-    }
-}
-
-/// 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 {
-    pub(crate) handle: Arc<dyn HasDisplayHandle>,
-}
-
-impl OwnedDisplayHandle {
-    pub(crate) fn new(handle: Arc<dyn HasDisplayHandle>) -> Self {
-        Self { handle }
-    }
-}
-
-impl HasDisplayHandle for OwnedDisplayHandle {
-    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
-        self.handle.display_handle()
-    }
-}
-
-impl fmt::Debug for OwnedDisplayHandle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("OwnedDisplayHandle").finish_non_exhaustive()
-    }
-}
-
-impl PartialEq for OwnedDisplayHandle {
-    fn eq(&self, other: &Self) -> bool {
-        match (self.display_handle(), other.display_handle()) {
-            (Ok(lhs), Ok(rhs)) => lhs == rhs,
-            _ => false,
-        }
-    }
-}
-
-impl Eq for OwnedDisplayHandle {}
-
-pub(crate) trait EventLoopProxyProvider: Send + Sync {
-    /// See [`EventLoopProxy::wake_up`] for details.
-    fn wake_up(&self);
-}
-
-/// Control the [`EventLoop`], possibly from a different thread, without referencing it directly.
-#[derive(Clone)]
-pub struct EventLoopProxy {
-    pub(crate) proxy: Arc<dyn EventLoopProxyProvider>,
-}
-
-impl fmt::Debug for EventLoopProxy {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventLoopProxy").finish_non_exhaustive()
-    }
-}
-
-impl EventLoopProxy {
-    /// Wake up the [`EventLoop`], resulting in [`ApplicationHandler::proxy_wake_up()`] being
-    /// called.
-    ///
-    /// Calls to this method are coalesced into a single call to [`proxy_wake_up`], see the
-    /// documentation on that for details.
-    ///
-    /// If the event loop is no longer running, this is a no-op.
-    ///
-    /// [`proxy_wake_up`]: ApplicationHandler::proxy_wake_up
-    ///
-    /// # Platform-specific
-    ///
-    /// - **Windows**: The wake-up may be ignored under high contention, see [#3687].
-    ///
-    /// [#3687]: https://github.com/rust-windowing/winit/pull/3687
-    pub fn wake_up(&self) {
-        self.proxy.wake_up();
-    }
-
-    pub(crate) fn new(proxy: Arc<dyn EventLoopProxyProvider>) -> Self {
-        Self { proxy }
-    }
-}
-
-/// Control when device events are captured.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-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, Hash)]
-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 }
-    }
-}

src/icon.rs

@@ -1,118 +0,0 @@
-use std::error::Error;
-use std::{fmt, io, mem};
-
-use crate::platform_impl::PlatformIcon;
-
-#[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, Hash)]
-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, Hash)]
-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, Eq, Hash, PartialEq)]
-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)? })
-    }
-}

src/monitor.rs

@@ -1,169 +0,0 @@
-//! Types useful for interacting with a user's monitors.
-use std::fmt;
-use std::num::{NonZeroU16, NonZeroU32};
-
-use crate::dpi::{PhysicalPosition, PhysicalSize};
-use crate::platform_impl;
-
-/// Describes a fullscreen video mode of a monitor.
-///
-/// Can be retrieved with [`MonitorHandle::video_modes()`].
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct VideoMode {
-    pub(crate) size: PhysicalSize<u32>,
-    pub(crate) bit_depth: Option<NonZeroU16>,
-    pub(crate) refresh_rate_millihertz: Option<NonZeroU32>,
-}
-
-impl VideoMode {
-    /// Returns the resolution of this video mode. This **must not** be used to create your
-    /// rendering surface. Use [`Window::surface_size()`] instead.
-    ///
-    /// [`Window::surface_size()`]: crate::window::Window::surface_size
-    pub fn size(&self) -> PhysicalSize<u32> {
-        self.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.
-    pub fn bit_depth(&self) -> Option<NonZeroU16> {
-        self.bit_depth
-    }
-
-    /// Returns the refresh rate of this video mode in mHz.
-    pub fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
-        self.refresh_rate_millihertz
-    }
-}
-
-impl fmt::Display for VideoMode {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}x{}", self.size.width, self.size.height)?;
-
-        if let Some(refresh_rate) = self.refresh_rate_millihertz {
-            write!(f, "@{refresh_rate}mHz")?;
-        }
-
-        if let Some(bit_depth) = self.bit_depth {
-            write!(f, " ({bit_depth} bpp)")?;
-        }
-
-        Ok(())
-    }
-}
-
-/// Handle to a monitor.
-///
-/// Allows you to retrieve basic information and metadata about a monitor.
-///
-/// Can be used in [`Window`] creation to place the window on a specific
-/// monitor.
-///
-/// This can be retrieved from one of the following methods, which return an
-/// iterator of [`MonitorHandle`]s:
-/// - [`ActiveEventLoop::available_monitors`](crate::event_loop::ActiveEventLoop::available_monitors).
-/// - [`Window::available_monitors`](crate::window::Window::available_monitors).
-///
-/// ## Platform-specific
-///
-/// **Web:** A [`MonitorHandle`] created without
-#[cfg_attr(
-    any(web_platform, docsrs),
-    doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-)]
-#[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
-/// will always represent the current monitor the browser window is in instead of a specific
-/// monitor. See
-#[cfg_attr(
-    any(web_platform, docsrs),
-    doc = "[`MonitorHandleExtWeb::is_detailed()`][crate::platform::web::MonitorHandleExtWeb::is_detailed]"
-)]
-#[cfg_attr(not(any(web_platform, docsrs)), doc = "`MonitorHandleExtWeb::is_detailed()`")]
-/// to check.
-///
-/// [`Window`]: crate::window::Window
-#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct MonitorHandle {
-    pub(crate) inner: platform_impl::MonitorHandle,
-}
-
-impl std::fmt::Debug for MonitorHandle {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.inner.fmt(f)
-    }
-}
-
-impl MonitorHandle {
-    /// Returns a human-readable name of the monitor.
-    ///
-    /// Returns `None` if the monitor doesn't exist anymore.
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Always returns [`None`] without
-    #[cfg_attr(
-        any(web_platform, docsrs),
-        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
-    #[inline]
-    pub fn name(&self) -> Option<String> {
-        self.inner.name()
-    }
-
-    /// Returns the top-left corner position of the monitor in desktop coordinates.
-    ///
-    /// This position is in the same coordinate system as [`Window::outer_position`].
-    ///
-    /// [`Window::outer_position`]: crate::window::Window::outer_position
-    ///
-    /// ## Platform-specific
-    ///
-    /// **Web:** Always returns [`None`] without
-    #[cfg_attr(
-        any(web_platform, docsrs),
-        doc = "[detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "detailed monitor permissions.")]
-    #[inline]
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        self.inner.position()
-    }
-
-    /// 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.
-    /// - **Web:** Always returns `0.0` without
-    #[cfg_attr(
-        any(web_platform, docsrs),
-        doc = "  [detailed monitor permissions][crate::platform::web::ActiveEventLoopExtWeb::request_detailed_monitor_permission]."
-    )]
-    #[cfg_attr(not(any(web_platform, docsrs)), doc = "  detailed monitor permissions.")]
-    ///
-    #[rustfmt::skip]
-    /// [`Window::scale_factor`]: crate::window::Window::scale_factor
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        self.inner.scale_factor()
-    }
-
-    /// Returns the currently active video mode of this monitor.
-    #[inline]
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        self.inner.current_video_mode()
-    }
-
-    /// Returns all fullscreen video modes supported by this monitor.
-    #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        self.inner.video_modes()
-    }
-}

src/platform/mod.rs

@@ -1,46 +0,0 @@
-//! 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;
-
-#[allow(unused_imports)]
-#[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, docsrs))]
-pub mod scancode;

src/platform/orbital.rs

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

src/platform/wayland.rs

@@ -1,112 +0,0 @@
-//! # 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 crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
-use crate::monitor::MonitorHandle;
-pub use crate::window::Theme;
-use crate::window::{Window as CoreWindow, WindowAttributes};
-
-/// 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 dyn ActiveEventLoop + '_ {
-    #[inline]
-    fn is_wayland(&self) -> bool {
-        self.as_any().downcast_ref::<crate::platform_impl::wayland::ActiveEventLoop>().is_some()
-    }
-}
-
-/// Additional methods on [`EventLoop`] that are specific to Wayland.
-pub trait EventLoopExtWayland {
-    /// True if the [`EventLoop`] uses Wayland.
-    fn is_wayland(&self) -> bool;
-}
-
-impl EventLoopExtWayland for EventLoop {
-    #[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 EventLoopBuilderExtWayland for EventLoopBuilder {
-    #[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 {}
-
-impl WindowExtWayland for dyn CoreWindow + '_ {}
-
-/// 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()
-    }
-}

src/platform_impl/apple/appkit/cursor.rs

@@ -1,224 +0,0 @@
-use std::ffi::c_uchar;
-use std::slice;
-use std::sync::OnceLock;
-
-use objc2::rc::Retained;
-use objc2::runtime::Sel;
-use objc2::{available, msg_send, sel, AllocAnyThread, ClassType};
-use objc2_app_kit::{NSBitmapImageRep, NSCursor, NSDeviceRGBColorSpace, NSImage};
-use objc2_foundation::{
-    ns_string, NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString,
-};
-
-use crate::cursor::{CursorImage, OnlyCursorImageSource};
-use crate::error::RequestError;
-use crate::window::CursorIcon;
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct CustomCursor(pub(crate) Retained<NSCursor>);
-
-// SAFETY: NSCursor is immutable and thread-safe
-// TODO(madsmtm): Put this logic in objc2-app-kit itself
-unsafe impl Send for CustomCursor {}
-unsafe impl Sync for CustomCursor {}
-
-impl CustomCursor {
-    pub(crate) fn new(cursor: OnlyCursorImageSource) -> Result<CustomCursor, RequestError> {
-        cursor_from_image(&cursor.0).map(Self)
-    }
-}
-
-pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Result<Retained<NSCursor>, RequestError> {
-    let width = cursor.width;
-    let height = cursor.height;
-
-    let bitmap = unsafe {
-        NSBitmapImageRep::initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel(
-            NSBitmapImageRep::alloc(),
-            std::ptr::null_mut::<*mut c_uchar>(),
-            width as isize,
-            height as isize,
-            8,
-            4,
-            true,
-            false,
-            NSDeviceRGBColorSpace,
-            width as isize * 4,
-            32,
-        )
-    }.ok_or_else(|| os_error!("parent view should be installed in a window"))?;
-    let bitmap_data = unsafe { slice::from_raw_parts_mut(bitmap.bitmapData(), cursor.rgba.len()) };
-    bitmap_data.copy_from_slice(&cursor.rgba);
-
-    let image = unsafe {
-        NSImage::initWithSize(NSImage::alloc(), NSSize::new(width.into(), height.into()))
-    };
-    unsafe { image.addRepresentation(&bitmap) };
-
-    let hotspot = NSPoint::new(cursor.hotspot_x as f64, cursor.hotspot_y as f64);
-
-    Ok(NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot))
-}
-
-pub(crate) fn default_cursor() -> Retained<NSCursor> {
-    NSCursor::arrowCursor()
-}
-
-unsafe fn try_cursor_from_selector(sel: Sel) -> Option<Retained<NSCursor>> {
-    let cls = NSCursor::class();
-    if unsafe { msg_send![cls, respondsToSelector: sel] } {
-        let cursor: Retained<NSCursor> = unsafe { msg_send![cls, performSelector: sel] };
-        Some(cursor)
-    } else {
-        tracing::warn!("cursor `{sel}` appears to be invalid");
-        None
-    }
-}
-
-macro_rules! def_undocumented_cursor {
-    {$(
-        $(#[$($m:meta)*])*
-        fn $name:ident();
-    )*} => {$(
-        $(#[$($m)*])*
-        #[allow(non_snake_case)]
-        fn $name() -> Retained<NSCursor> {
-            unsafe { try_cursor_from_selector(sel!($name)).unwrap_or_else(|| default_cursor()) }
-        }
-    )*};
-}
-
-def_undocumented_cursor!(
-    // Undocumented cursors: https://stackoverflow.com/a/46635398/5435443
-    fn _helpCursor();
-    fn _zoomInCursor();
-    fn _zoomOutCursor();
-    fn _windowResizeNorthEastCursor();
-    fn _windowResizeNorthWestCursor();
-    fn _windowResizeSouthEastCursor();
-    fn _windowResizeSouthWestCursor();
-    fn _windowResizeNorthEastSouthWestCursor();
-    fn _windowResizeNorthWestSouthEastCursor();
-
-    // While these two are available, the former just loads a white arrow,
-    // and the latter loads an ugly deflated beachball!
-    // pub fn _moveCursor();
-    // pub fn _waitCursor();
-
-    // An even more undocumented cursor...
-    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=522349
-    fn busyButClickableCursor();
-);
-
-// Note that loading `busybutclickable` with this code won't animate
-// the frames; instead you'll just get them all in a column.
-unsafe fn load_webkit_cursor(name: &NSString) -> Retained<NSCursor> {
-    // Snatch a cursor from WebKit; They fit the style of the native
-    // cursors, and will seem completely standard to macOS users.
-    //
-    // https://stackoverflow.com/a/21786835/5435443
-    let root = ns_string!(
-        "/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/\
-         HIServices.framework/Versions/A/Resources/cursors"
-    );
-    let cursor_path = root.stringByAppendingPathComponent(name);
-
-    let pdf_path = cursor_path.stringByAppendingPathComponent(ns_string!("cursor.pdf"));
-    let image = NSImage::initByReferencingFile(NSImage::alloc(), &pdf_path).unwrap();
-
-    // TODO: Handle PLists better
-    let info_path = cursor_path.stringByAppendingPathComponent(ns_string!("info.plist"));
-    let info: Retained<NSDictionary<NSObject, NSObject>> = unsafe {
-        msg_send![
-            <NSDictionary<NSObject, NSObject>>::class(),
-            dictionaryWithContentsOfFile: &*info_path,
-        ]
-    };
-    let mut x = 0.0;
-    if let Some(n) = info.objectForKey(ns_string!("hotx")) {
-        if let Ok(n) = n.downcast::<NSNumber>() {
-            x = n.as_cgfloat();
-        }
-    }
-    let mut y = 0.0;
-    if let Some(n) = info.objectForKey(ns_string!("hoty")) {
-        if let Ok(n) = n.downcast::<NSNumber>() {
-            y = n.as_cgfloat();
-        }
-    }
-
-    let hotspot = NSPoint::new(x, y);
-    NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
-}
-
-fn webkit_move() -> Retained<NSCursor> {
-    unsafe { load_webkit_cursor(ns_string!("move")) }
-}
-
-fn webkit_cell() -> Retained<NSCursor> {
-    unsafe { load_webkit_cursor(ns_string!("cell")) }
-}
-
-pub(crate) fn invisible_cursor() -> Retained<NSCursor> {
-    // 16x16 GIF data for invisible cursor
-    // You can reproduce this via ImageMagick.
-    // $ convert -size 16x16 xc:none cursor.gif
-    static CURSOR_BYTES: &[u8] = &[
-        0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x10, 0x00, 0x10, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x21, 0xf9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00,
-        0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x0e, 0x84, 0x8f, 0xa9, 0xcb, 0xed, 0x0f,
-        0xa3, 0x9c, 0xb4, 0xda, 0x8b, 0xb3, 0x3e, 0x05, 0x00, 0x3b,
-    ];
-
-    fn new_invisible() -> Retained<NSCursor> {
-        // TODO: Consider using `dataWithBytesNoCopy:`
-        let data = NSData::with_bytes(CURSOR_BYTES);
-        let image = NSImage::initWithData(NSImage::alloc(), &data).unwrap();
-        let hotspot = NSPoint::new(0.0, 0.0);
-        NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
-    }
-
-    // Cache this for efficiency
-    static CURSOR: OnceLock<CustomCursor> = OnceLock::new();
-    CURSOR.get_or_init(|| CustomCursor(new_invisible())).0.clone()
-}
-
-#[allow(deprecated)]
-pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Retained<NSCursor> {
-    match icon {
-        CursorIcon::Default => default_cursor(),
-        CursorIcon::Pointer => NSCursor::pointingHandCursor(),
-        CursorIcon::Grab => NSCursor::openHandCursor(),
-        CursorIcon::Grabbing => NSCursor::closedHandCursor(),
-        CursorIcon::Text => NSCursor::IBeamCursor(),
-        CursorIcon::VerticalText => NSCursor::IBeamCursorForVerticalLayout(),
-        CursorIcon::Copy => NSCursor::dragCopyCursor(),
-        CursorIcon::Alias => NSCursor::dragLinkCursor(),
-        CursorIcon::NotAllowed | CursorIcon::NoDrop => NSCursor::operationNotAllowedCursor(),
-        CursorIcon::ContextMenu => NSCursor::contextualMenuCursor(),
-        CursorIcon::Crosshair => NSCursor::crosshairCursor(),
-        CursorIcon::EResize => NSCursor::resizeRightCursor(),
-        CursorIcon::NResize => NSCursor::resizeUpCursor(),
-        CursorIcon::WResize => NSCursor::resizeLeftCursor(),
-        CursorIcon::SResize => NSCursor::resizeDownCursor(),
-        CursorIcon::EwResize | CursorIcon::ColResize => NSCursor::resizeLeftRightCursor(),
-        CursorIcon::NsResize | CursorIcon::RowResize => NSCursor::resizeUpDownCursor(),
-        CursorIcon::Help => _helpCursor(),
-        CursorIcon::ZoomIn if available!(macos = 15.0) => unsafe { NSCursor::zoomInCursor() },
-        CursorIcon::ZoomIn => _zoomInCursor(),
-        CursorIcon::ZoomOut if available!(macos = 15.0) => unsafe { NSCursor::zoomOutCursor() },
-        CursorIcon::ZoomOut => _zoomOutCursor(),
-        CursorIcon::NeResize => _windowResizeNorthEastCursor(),
-        CursorIcon::NwResize => _windowResizeNorthWestCursor(),
-        CursorIcon::SeResize => _windowResizeSouthEastCursor(),
-        CursorIcon::SwResize => _windowResizeSouthWestCursor(),
-        CursorIcon::NeswResize => _windowResizeNorthEastSouthWestCursor(),
-        CursorIcon::NwseResize => _windowResizeNorthWestSouthEastCursor(),
-        // This is the wrong semantics for `Wait`, but it's the same as
-        // what's used in Safari and Chrome.
-        CursorIcon::Wait | CursorIcon::Progress => busyButClickableCursor(),
-        CursorIcon::Move | CursorIcon::AllScroll => webkit_move(),
-        CursorIcon::Cell => webkit_cell(),
-        _ => default_cursor(),
-    }
-}

src/platform_impl/apple/appkit/mod.rs

@@ -1,27 +0,0 @@
-#[macro_use]
-mod util;
-
-mod app;
-mod app_state;
-mod cursor;
-mod event;
-mod event_loop;
-mod ffi;
-mod menu;
-mod monitor;
-mod observer;
-mod view;
-mod window;
-mod window_delegate;
-
-pub(crate) use self::cursor::CustomCursor as PlatformCustomCursor;
-pub(crate) use self::event::{physicalkey_to_scancode, scancode_to_physicalkey};
-pub(crate) use self::event_loop::{
-    ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
-};
-pub(crate) use self::monitor::MonitorHandle;
-pub(crate) use self::window::Window;
-pub(crate) use self::window_delegate::PlatformSpecificWindowAttributes;
-pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
-pub(crate) use crate::icon::NoIcon as PlatformIcon;
-pub(crate) use crate::platform_impl::Fullscreen;

src/platform_impl/apple/appkit/monitor.rs

@@ -1,355 +0,0 @@
-#![allow(clippy::unnecessary_cast)]
-
-use std::collections::VecDeque;
-use std::num::{NonZeroU16, NonZeroU32};
-use std::ptr::NonNull;
-use std::{fmt, ptr};
-
-use dispatch2::run_on_main;
-use objc2::rc::Retained;
-use objc2::MainThreadMarker;
-use objc2_app_kit::NSScreen;
-use objc2_core_foundation::{
-    CFArrayGetCount, CFArrayGetValueAtIndex, CFRetained, CFUUIDGetUUIDBytes,
-};
-#[allow(deprecated)]
-use objc2_core_graphics::{
-    CGDirectDisplayID, CGDisplayBounds, CGDisplayCopyAllDisplayModes, CGDisplayCopyDisplayMode,
-    CGDisplayMode, CGDisplayModeCopyPixelEncoding, CGDisplayModeGetPixelHeight,
-    CGDisplayModeGetPixelWidth, CGDisplayModeGetRefreshRate, CGDisplayModelNumber,
-    CGGetActiveDisplayList, CGMainDisplayID,
-};
-#[allow(deprecated)]
-use objc2_core_video::{
-    kCVReturnSuccess, CVDisplayLinkCreateWithCGDisplay,
-    CVDisplayLinkGetNominalOutputVideoRefreshPeriod, CVTimeFlags,
-};
-use objc2_foundation::{ns_string, NSNumber, NSPoint, NSRect};
-
-use super::ffi;
-use super::util::cgerr;
-use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use crate::monitor::VideoMode;
-
-#[derive(Clone)]
-pub struct VideoModeHandle {
-    pub(crate) mode: VideoMode,
-    pub(crate) monitor: MonitorHandle,
-    pub(crate) native_mode: NativeDisplayMode,
-}
-
-impl PartialEq for VideoModeHandle {
-    fn eq(&self, other: &Self) -> bool {
-        self.monitor == other.monitor && self.mode == other.mode
-    }
-}
-
-impl Eq for VideoModeHandle {}
-
-impl std::hash::Hash for VideoModeHandle {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.monitor.hash(state);
-    }
-}
-
-impl std::fmt::Debug for VideoModeHandle {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("VideoMode")
-            .field("mode", &self.mode)
-            .field("monitor", &self.monitor)
-            .finish()
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct NativeDisplayMode(pub CFRetained<CGDisplayMode>);
-
-unsafe impl Send for NativeDisplayMode {}
-unsafe impl Sync for NativeDisplayMode {}
-
-impl VideoModeHandle {
-    fn new(
-        monitor: MonitorHandle,
-        native_mode: NativeDisplayMode,
-        refresh_rate_millihertz: Option<NonZeroU32>,
-    ) -> Self {
-        unsafe {
-            #[allow(deprecated)]
-            let pixel_encoding =
-                CGDisplayModeCopyPixelEncoding(Some(&native_mode.0)).unwrap().to_string();
-            let bit_depth = if pixel_encoding.eq_ignore_ascii_case(ffi::IO32BitDirectPixels) {
-                32
-            } else if pixel_encoding.eq_ignore_ascii_case(ffi::IO16BitDirectPixels) {
-                16
-            } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO30BitDirectPixels) {
-                30
-            } else {
-                unimplemented!()
-            };
-
-            let mode = VideoMode {
-                size: PhysicalSize::new(
-                    CGDisplayModeGetPixelWidth(Some(&native_mode.0)) as u32,
-                    CGDisplayModeGetPixelHeight(Some(&native_mode.0)) as u32,
-                ),
-                refresh_rate_millihertz,
-                bit_depth: NonZeroU16::new(bit_depth),
-            };
-
-            VideoModeHandle { mode, monitor: monitor.clone(), native_mode }
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct MonitorHandle(CGDirectDisplayID);
-
-impl MonitorHandle {
-    /// Internal comparisons of [`MonitorHandle`]s are done first requesting a UUID for the handle.
-    fn uuid(&self) -> [u8; 16] {
-        let ptr = unsafe { ffi::CGDisplayCreateUUIDFromDisplayID(self.0) };
-        let cf_uuid = unsafe { CFRetained::from_raw(NonNull::new(ptr).unwrap()) };
-        unsafe { CFUUIDGetUUIDBytes(&cf_uuid) }.into()
-    }
-}
-
-// `CGDirectDisplayID` changes on video mode change, so we cannot rely on that
-// for comparisons, but we can use `CGDisplayCreateUUIDFromDisplayID` to get an
-// unique identifier that persists even across system reboots
-impl PartialEq for MonitorHandle {
-    fn eq(&self, other: &Self) -> bool {
-        self.uuid() == other.uuid()
-    }
-}
-
-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.uuid().cmp(&other.uuid())
-    }
-}
-
-impl std::hash::Hash for MonitorHandle {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.uuid().hash(state);
-    }
-}
-
-pub fn available_monitors() -> VecDeque<MonitorHandle> {
-    let mut expected_count = 0;
-    let res = cgerr(unsafe { CGGetActiveDisplayList(0, ptr::null_mut(), &mut expected_count) });
-    if res.is_err() {
-        return VecDeque::with_capacity(0);
-    }
-
-    let mut displays: Vec<CGDirectDisplayID> = vec![0; expected_count as usize];
-    let mut actual_count = 0;
-    let res = cgerr(unsafe {
-        CGGetActiveDisplayList(expected_count, displays.as_mut_ptr(), &mut actual_count)
-    });
-    displays.truncate(actual_count as usize);
-
-    if res.is_err() {
-        return VecDeque::with_capacity(0);
-    }
-
-    let mut monitors = VecDeque::with_capacity(displays.len());
-    for display in displays {
-        monitors.push_back(MonitorHandle(display));
-    }
-    monitors
-}
-
-pub fn primary_monitor() -> MonitorHandle {
-    MonitorHandle(unsafe { CGMainDisplayID() })
-}
-
-impl fmt::Debug for MonitorHandle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("MonitorHandle")
-            .field("name", &self.name())
-            .field("native_identifier", &self.native_identifier())
-            .field("position", &self.position())
-            .field("scale_factor", &self.scale_factor())
-            .finish_non_exhaustive()
-    }
-}
-
-impl MonitorHandle {
-    pub fn new(id: CGDirectDisplayID) -> Self {
-        MonitorHandle(id)
-    }
-
-    // TODO: Be smarter about this:
-    // <https://github.com/glfw/glfw/blob/57cbded0760a50b9039ee0cb3f3c14f60145567c/src/cocoa_monitor.m#L44-L126>
-    pub fn name(&self) -> Option<String> {
-        let screen_num = unsafe { CGDisplayModelNumber(self.0) };
-        Some(format!("Monitor #{screen_num}"))
-    }
-
-    #[inline]
-    pub fn native_identifier(&self) -> u32 {
-        self.0
-    }
-
-    #[inline]
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        // This is already in screen coordinates. If we were using `NSScreen`,
-        // then a conversion would've been needed:
-        // flip_window_screen_coordinates(self.ns_screen(mtm)?.frame())
-        let bounds = unsafe { CGDisplayBounds(self.0) };
-        let position = LogicalPosition::new(bounds.origin.x, bounds.origin.y);
-        Some(position.to_physical(self.scale_factor()))
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        run_on_main(|mtm| {
-            match self.ns_screen(mtm) {
-                Some(screen) => screen.backingScaleFactor() as f64,
-                None => 1.0, // default to 1.0 when we can't find the screen
-            }
-        })
-    }
-
-    fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
-        let current_display_mode =
-            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.0) }.unwrap());
-        refresh_rate_millihertz(self.0, &current_display_mode)
-    }
-
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        let mode = NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.0) }.unwrap());
-        let refresh_rate_millihertz = refresh_rate_millihertz(self.0, &mode);
-        Some(VideoModeHandle::new(self.clone(), mode, refresh_rate_millihertz).mode)
-    }
-
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        self.video_modes_handles().map(|handle| handle.mode)
-    }
-
-    pub(crate) fn video_modes_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
-        let refresh_rate_millihertz = self.refresh_rate_millihertz();
-        let monitor = self.clone();
-
-        unsafe {
-            let modes = {
-                let array = CGDisplayCopyAllDisplayModes(self.0, None)
-                    .expect("failed to get list of display modes");
-                let array_count = CFArrayGetCount(&array);
-                let modes: Vec<_> = (0..array_count)
-                    .map(move |i| {
-                        let mode = CFArrayGetValueAtIndex(&array, i) as *mut CGDisplayMode;
-                        CFRetained::retain(NonNull::new(mode).unwrap())
-                    })
-                    .collect();
-                modes
-            };
-
-            modes.into_iter().map(move |mode| {
-                let cg_refresh_rate_hertz = CGDisplayModeGetRefreshRate(Some(&mode)).round() as i64;
-
-                // CGDisplayModeGetRefreshRate returns 0.0 for any display that
-                // isn't a CRT
-                let refresh_rate_millihertz = if cg_refresh_rate_hertz > 0 {
-                    NonZeroU32::new((cg_refresh_rate_hertz * 1000) as u32)
-                } else {
-                    refresh_rate_millihertz
-                };
-
-                VideoModeHandle::new(
-                    monitor.clone(),
-                    NativeDisplayMode(mode),
-                    refresh_rate_millihertz,
-                )
-            })
-        }
-    }
-
-    pub(crate) fn ns_screen(&self, mtm: MainThreadMarker) -> Option<Retained<NSScreen>> {
-        let uuid = self.uuid();
-        NSScreen::screens(mtm).into_iter().find(|screen| {
-            let other_native_id = get_display_id(screen);
-            let other = MonitorHandle::new(other_native_id);
-            uuid == other.uuid()
-        })
-    }
-}
-
-pub(crate) fn get_display_id(screen: &NSScreen) -> u32 {
-    let key = ns_string!("NSScreenNumber");
-
-    objc2::rc::autoreleasepool(|_| {
-        let device_description = screen.deviceDescription();
-
-        // Retrieve the CGDirectDisplayID associated with this screen
-        //
-        // The value from @"NSScreenNumber" in deviceDescription is guaranteed
-        // to be an NSNumber. See documentation for details:
-        // <https://developer.apple.com/documentation/appkit/nsscreen/1388360-devicedescription?language=objc>
-        let obj = device_description
-            .objectForKey(key)
-            .expect("failed getting screen display id from device description")
-            .downcast::<NSNumber>()
-            .expect("NSScreenNumber must be NSNumber");
-
-        obj.as_u32()
-    })
-}
-
-/// Core graphics screen coordinates are relative to the top-left corner of
-/// the so-called "main" display, with y increasing downwards - which is
-/// exactly what we want in Winit.
-///
-/// However, `NSWindow` and `NSScreen` changes these coordinates to:
-/// 1. Be relative to the bottom-left corner of the "main" screen.
-/// 2. Be relative to the bottom-left corner of the window/screen itself.
-/// 3. Have y increasing upwards.
-///
-/// This conversion happens to be symmetric, so we only need this one function
-/// to convert between the two coordinate systems.
-pub(crate) fn flip_window_screen_coordinates(frame: NSRect) -> NSPoint {
-    // It is intentional that we use `CGMainDisplayID` (as opposed to
-    // `NSScreen::mainScreen`), because that's what the screen coordinates
-    // are relative to, no matter which display the window is currently on.
-    let main_screen_height = unsafe { CGDisplayBounds(CGMainDisplayID()) }.size.height;
-
-    let y = main_screen_height - frame.size.height - frame.origin.y;
-    NSPoint::new(frame.origin.x, y)
-}
-
-fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> Option<NonZeroU32> {
-    unsafe {
-        let refresh_rate = CGDisplayModeGetRefreshRate(Some(&mode.0));
-        if refresh_rate > 0.0 {
-            return NonZeroU32::new((refresh_rate * 1000.0).round() as u32);
-        }
-
-        let mut display_link = std::ptr::null_mut();
-        #[allow(deprecated)]
-        if CVDisplayLinkCreateWithCGDisplay(id, NonNull::from(&mut display_link))
-            != kCVReturnSuccess
-        {
-            return None;
-        }
-        let display_link = CFRetained::from_raw(NonNull::new(display_link).unwrap());
-        #[allow(deprecated)]
-        let time = CVDisplayLinkGetNominalOutputVideoRefreshPeriod(&display_link);
-
-        // This value is indefinite if an invalid display link was specified
-        if time.flags & CVTimeFlags::IsIndefinite.0 != 0 {
-            return None;
-        }
-
-        (time.timeScale as i64)
-            .checked_div(time.timeValue)
-            .map(|v| (v * 1000) as u32)
-            .and_then(NonZeroU32::new)
-    }
-}

src/platform_impl/apple/appkit/observer.rs

@@ -1,252 +0,0 @@
-//! Utilities for working with `CFRunLoop`.
-//!
-//! See Apple's documentation on Run Loops for details:
-//! <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html>
-use std::cell::Cell;
-use std::ffi::c_void;
-use std::ptr;
-use std::time::Instant;
-
-use objc2::MainThreadMarker;
-use objc2_core_foundation::{
-    kCFRunLoopCommonModes, kCFRunLoopDefaultMode, CFAbsoluteTimeGetCurrent, CFIndex, CFRetained,
-    CFRunLoop, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddTimer, CFRunLoopGetMain,
-    CFRunLoopObserver, CFRunLoopObserverCallBack, CFRunLoopObserverContext,
-    CFRunLoopObserverCreate, CFRunLoopPerformBlock, CFRunLoopTimer, CFRunLoopTimerCreate,
-    CFRunLoopTimerInvalidate, CFRunLoopTimerSetNextFireDate, CFRunLoopWakeUp,
-};
-use tracing::error;
-
-use super::app_state::AppState;
-
-// begin is queued with the highest priority to ensure it is processed before other observers
-extern "C-unwind" fn control_flow_begin_handler(
-    _: *mut CFRunLoopObserver,
-    activity: CFRunLoopActivity,
-    _info: *mut c_void,
-) {
-    match activity {
-        CFRunLoopActivity::AfterWaiting => {
-            AppState::get(MainThreadMarker::new().unwrap()).wakeup();
-        },
-        _ => unreachable!(),
-    }
-}
-
-// end is queued with the lowest priority to ensure it is processed after other observers
-// without that, LoopExiting would  get sent after AboutToWait
-extern "C-unwind" fn control_flow_end_handler(
-    _: *mut CFRunLoopObserver,
-    activity: CFRunLoopActivity,
-    _info: *mut c_void,
-) {
-    match activity {
-        CFRunLoopActivity::BeforeWaiting => {
-            AppState::get(MainThreadMarker::new().unwrap()).cleared();
-        },
-        CFRunLoopActivity::Exit => (), // unimplemented!(), // not expected to ever happen
-        _ => unreachable!(),
-    }
-}
-
-#[derive(Debug)]
-pub struct RunLoop(CFRetained<CFRunLoop>);
-
-impl RunLoop {
-    pub fn main(mtm: MainThreadMarker) -> Self {
-        // SAFETY: We have a MainThreadMarker here, which means we know we're on the main thread, so
-        // scheduling (and scheduling a non-`Send` block) to that thread is allowed.
-        let _ = mtm;
-        RunLoop(unsafe { CFRunLoopGetMain() }.unwrap())
-    }
-
-    pub fn wakeup(&self) {
-        unsafe { CFRunLoopWakeUp(&self.0) }
-    }
-
-    unsafe fn add_observer(
-        &self,
-        flags: CFRunLoopActivity,
-        // The lower the value, the sooner this will run
-        priority: CFIndex,
-        handler: CFRunLoopObserverCallBack,
-        context: *mut CFRunLoopObserverContext,
-    ) {
-        let observer =
-            unsafe { CFRunLoopObserverCreate(None, flags.0, true, priority, handler, context) }
-                .unwrap();
-        unsafe { CFRunLoopAddObserver(&self.0, Some(&observer), kCFRunLoopCommonModes) };
-    }
-
-    /// Submit a closure to run on the main thread as the next step in the run loop, before other
-    /// event sources are processed.
-    ///
-    /// This is used for running event handlers, as those are not allowed to run re-entrantly.
-    ///
-    /// # Implementation
-    ///
-    /// This queuing could be implemented in the following several ways with subtle differences in
-    /// timing. This list is sorted in rough order in which they are run:
-    ///
-    /// 1. Using `CFRunLoopPerformBlock` or `-[NSRunLoop performBlock:]`.
-    ///
-    /// 2. Using `-[NSObject performSelectorOnMainThread:withObject:waitUntilDone:]` or wrapping the
-    ///    event in `NSEvent` and posting that to `-[NSApplication postEvent:atStart:]` (both
-    ///    creates a custom `CFRunLoopSource`, and signals that to wake up the main event loop).
-    ///
-    ///    a. `atStart = true`.
-    ///
-    ///    b. `atStart = false`.
-    ///
-    /// 3. `dispatch_async` or `dispatch_async_f`. Note that this may appear before 2b, it does not
-    ///    respect the ordering that runloop events have.
-    ///
-    /// We choose the first one, both for ease-of-implementation, but mostly for consistency, as we
-    /// want the event to be queued in a way that preserves the order the events originally arrived
-    /// in.
-    ///
-    /// As an example, let's assume that we receive two events from the user, a mouse click which we
-    /// handled by queuing it, and a window resize which we handled immediately. If we allowed
-    /// AppKit to choose the ordering when queuing the mouse event, it might get put in the back of
-    /// the queue, and the events would appear out of order to the user of Winit. So we must instead
-    /// put the event at the very front of the queue, to be handled as soon as possible after
-    /// handling whatever event it's currently handling.
-    pub fn queue_closure(&self, closure: impl FnOnce() + 'static) {
-        // Convert `FnOnce()` to `Block<dyn Fn()>`.
-        let closure = Cell::new(Some(closure));
-        let block = block2::RcBlock::new(move || {
-            if let Some(closure) = closure.take() {
-                closure()
-            } else {
-                error!("tried to execute queued closure on main thread twice");
-            }
-        });
-
-        // There are a few common modes (`kCFRunLoopCommonModes`) defined by Cocoa:
-        // - `NSDefaultRunLoopMode`, alias of `kCFRunLoopDefaultMode`.
-        // - `NSEventTrackingRunLoopMode`, used when mouse-dragging and live-resizing a window.
-        // - `NSModalPanelRunLoopMode`, used when running a modal inside the Winit event loop.
-        // - `NSConnectionReplyMode`: TODO.
-        //
-        // We only want to run event handlers in the default mode, as we support running a blocking
-        // modal inside a Winit event handler (see [#1779]) which outrules the modal panel mode, and
-        // resizing such panel window enters the event tracking run loop mode, so we can't directly
-        // trigger events inside that mode either.
-        //
-        // Any events that are queued while running a modal or when live-resizing will instead wait,
-        // and be delivered to the application afterwards.
-        //
-        // [#1779]: https://github.com/rust-windowing/winit/issues/1779
-        let mode = unsafe { kCFRunLoopDefaultMode.unwrap() };
-
-        // SAFETY: The runloop is valid, the mode is a `CFStringRef`, and the block is `'static`.
-        unsafe { CFRunLoopPerformBlock(&self.0, Some(mode), Some(&block)) }
-    }
-}
-
-pub fn setup_control_flow_observers(mtm: MainThreadMarker) {
-    let run_loop = RunLoop::main(mtm);
-    unsafe {
-        let mut context = CFRunLoopObserverContext {
-            info: ptr::null_mut(),
-            version: 0,
-            retain: None,
-            release: None,
-            copyDescription: None,
-        };
-        run_loop.add_observer(
-            CFRunLoopActivity::AfterWaiting,
-            CFIndex::MIN,
-            Some(control_flow_begin_handler),
-            &mut context as *mut _,
-        );
-        run_loop.add_observer(
-            CFRunLoopActivity::Exit | CFRunLoopActivity::BeforeWaiting,
-            CFIndex::MAX,
-            Some(control_flow_end_handler),
-            &mut context as *mut _,
-        );
-    }
-}
-
-#[derive(Debug)]
-pub struct EventLoopWaker {
-    timer: CFRetained<CFRunLoopTimer>,
-
-    /// An arbitrary instant in the past, that will trigger an immediate wake
-    /// We save this as the `next_fire_date` for consistency so we can
-    /// easily check if the next_fire_date needs updating.
-    start_instant: Instant,
-
-    /// This is what the `NextFireDate` has been set to.
-    /// `None` corresponds to `waker.stop()` and `start_instant` is used
-    /// for `waker.start()`
-    next_fire_date: Option<Instant>,
-}
-
-impl Drop for EventLoopWaker {
-    fn drop(&mut self) {
-        unsafe { CFRunLoopTimerInvalidate(&self.timer) };
-    }
-}
-
-impl EventLoopWaker {
-    pub(crate) fn new() -> Self {
-        extern "C-unwind" fn wakeup_main_loop(_timer: *mut CFRunLoopTimer, _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(
-                None,
-                f64::MAX,
-                0.000_000_1,
-                0,
-                0,
-                Some(wakeup_main_loop),
-                ptr::null_mut(),
-            )
-            .unwrap();
-            CFRunLoopAddTimer(&CFRunLoopGetMain().unwrap(), Some(&timer), kCFRunLoopCommonModes);
-            Self { timer, start_instant: Instant::now(), next_fire_date: None }
-        }
-    }
-
-    pub fn stop(&mut self) {
-        if self.next_fire_date.is_some() {
-            self.next_fire_date = None;
-            unsafe { CFRunLoopTimerSetNextFireDate(&self.timer, f64::MAX) };
-        }
-    }
-
-    pub fn start(&mut self) {
-        if self.next_fire_date != Some(self.start_instant) {
-            self.next_fire_date = Some(self.start_instant);
-            unsafe { CFRunLoopTimerSetNextFireDate(&self.timer, f64::MIN) };
-        }
-    }
-
-    pub fn start_at(&mut self, instant: Option<Instant>) {
-        let now = Instant::now();
-        match instant {
-            Some(instant) if now >= instant => {
-                self.start();
-            },
-            Some(instant) => {
-                if self.next_fire_date != Some(instant) {
-                    self.next_fire_date = Some(instant);
-                    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);
-                    }
-                }
-            },
-            None => {
-                self.stop();
-            },
-        }
-    }
-}

src/platform_impl/apple/appkit/util.rs

@@ -1,40 +0,0 @@
-use objc2_core_graphics::CGError;
-use tracing::trace;
-
-use crate::error::OsError;
-
-macro_rules! trace_scope {
-    ($s:literal) => {
-        let _crate =
-            $crate::platform_impl::platform::appkit::util::TraceGuard::new(module_path!(), $s);
-    };
-}
-
-pub(crate) struct TraceGuard {
-    module_path: &'static str,
-    called_from_fn: &'static str,
-}
-
-impl TraceGuard {
-    #[inline]
-    pub(crate) fn new(module_path: &'static str, called_from_fn: &'static str) -> Self {
-        trace!(target = module_path, "Triggered `{}`", called_from_fn);
-        Self { module_path, called_from_fn }
-    }
-}
-
-impl Drop for TraceGuard {
-    #[inline]
-    fn drop(&mut self) {
-        trace!(target = self.module_path, "Completed `{}`", self.called_from_fn);
-    }
-}
-
-#[track_caller]
-pub(crate) fn cgerr(err: CGError) -> Result<(), OsError> {
-    if err == CGError::Success {
-        Ok(())
-    } else {
-        Err(os_error!(format!("CGError {err:?}")))
-    }
-}

src/platform_impl/apple/mod.rs

@@ -1,16 +0,0 @@
-//! Apple/Darwin-specific implementations
-
-#[cfg(target_os = "macos")]
-mod appkit;
-mod event_handler;
-mod event_loop_proxy;
-mod notification_center;
-#[cfg(not(target_os = "macos"))]
-mod uikit;
-
-#[allow(unused_imports)]
-#[cfg(target_os = "macos")]
-pub use self::appkit::*;
-#[allow(unused_imports)]
-#[cfg(not(target_os = "macos"))]
-pub use self::uikit::*;

src/platform_impl/apple/uikit/mod.rs

@@ -1,30 +0,0 @@
-#![allow(clippy::let_unit_value)]
-
-mod app_state;
-mod event_loop;
-mod monitor;
-mod view;
-mod view_controller;
-mod window;
-
-use std::fmt;
-
-pub(crate) use self::event_loop::{
-    ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
-};
-pub(crate) use self::monitor::MonitorHandle;
-pub(crate) use self::window::{PlatformSpecificWindowAttributes, Window};
-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;
-
-#[derive(Debug)]
-pub enum OsError {}
-
-impl fmt::Display for OsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "os error")
-    }
-}

src/platform_impl/linux/common/mod.rs

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

src/platform_impl/linux/mod.rs

@@ -1,382 +0,0 @@
-#![cfg(free_unix)]
-
-#[cfg(all(not(x11_platform), not(wayland_platform)))]
-compile_error!("Please select a feature to build for unix: `x11`, `wayland`");
-
-use std::env;
-use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
-use std::time::Duration;
-#[cfg(x11_platform)]
-use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Arc, sync::Mutex};
-
-pub(crate) use self::common::xkb::{physicalkey_to_scancode, scancode_to_physicalkey};
-#[cfg(x11_platform)]
-use self::x11::{XConnection, XError, XNotSupported};
-use crate::application::ApplicationHandler;
-pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
-use crate::dpi::PhysicalPosition;
-#[cfg(x11_platform)]
-use crate::dpi::Size;
-use crate::error::{EventLoopError, NotSupportedError};
-use crate::event_loop::ActiveEventLoop;
-pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
-use crate::monitor::VideoMode;
-use crate::platform::pump_events::PumpStatus;
-#[cfg(x11_platform)]
-use crate::platform::x11::{WindowType as XWindowType, XlibErrorHook};
-#[cfg(x11_platform)]
-use crate::utils::Lazy;
-use crate::window::ActivationToken;
-
-pub(crate) mod common;
-#[cfg(wayland_platform)]
-pub(crate) mod wayland;
-#[cfg(x11_platform)]
-pub(crate) mod x11;
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub(crate) enum Backend {
-    #[cfg(x11_platform)]
-    X,
-    #[cfg(wayland_platform)]
-    Wayland,
-}
-
-#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PlatformSpecificEventLoopAttributes {
-    pub(crate) forced_backend: Option<Backend>,
-    pub(crate) any_thread: bool,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApplicationName {
-    pub general: String,
-    pub instance: String,
-}
-
-impl ApplicationName {
-    pub fn new(general: String, instance: String) -> Self {
-        Self { general, instance }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct PlatformSpecificWindowAttributes {
-    pub name: Option<ApplicationName>,
-    pub activation_token: Option<ActivationToken>,
-    #[cfg(x11_platform)]
-    pub x11: X11WindowAttributes,
-}
-
-#[derive(Clone, Debug, PartialEq)]
-#[cfg(x11_platform)]
-pub struct X11WindowAttributes {
-    pub visual_id: Option<x11rb::protocol::xproto::Visualid>,
-    pub screen_id: Option<i32>,
-    pub base_size: Option<Size>,
-    pub override_redirect: bool,
-    pub x11_window_types: Vec<XWindowType>,
-
-    /// The parent window to embed this window into.
-    pub embed_window: Option<x11rb::protocol::xproto::Window>,
-}
-
-#[cfg_attr(not(x11_platform), allow(clippy::derivable_impls))]
-impl Default for PlatformSpecificWindowAttributes {
-    fn default() -> Self {
-        Self {
-            name: None,
-            activation_token: None,
-            #[cfg(x11_platform)]
-            x11: X11WindowAttributes {
-                visual_id: None,
-                screen_id: None,
-                base_size: None,
-                override_redirect: false,
-                x11_window_types: vec![XWindowType::Normal],
-                embed_window: None,
-            },
-        }
-    }
-}
-
-#[cfg(x11_platform)]
-pub(crate) static X11_BACKEND: Lazy<Mutex<Result<Arc<XConnection>, XNotSupported>>> =
-    Lazy::new(|| Mutex::new(XConnection::new(Some(x_error_callback)).map(Arc::new)));
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum MonitorHandle {
-    #[cfg(x11_platform)]
-    X(x11::MonitorHandle),
-    #[cfg(wayland_platform)]
-    Wayland(wayland::MonitorHandle),
-}
-
-/// `x11_or_wayland!(match expr; Enum(foo) => foo.something())`
-/// expands to the equivalent of
-/// ```ignore
-/// match self {
-///    Enum::X(foo) => foo.something(),
-///    Enum::Wayland(foo) => foo.something(),
-/// }
-/// ```
-/// The result can be converted to another enum by adding `; as AnotherEnum`
-macro_rules! x11_or_wayland {
-    (match $what:expr; $enum:ident ( $($c1:tt)* ) => $x:expr; as $enum2:ident ) => {
-        match $what {
-            #[cfg(x11_platform)]
-            $enum::X($($c1)*) => $enum2::X($x),
-            #[cfg(wayland_platform)]
-            $enum::Wayland($($c1)*) => $enum2::Wayland($x),
-        }
-    };
-    (match $what:expr; $enum:ident ( $($c1:tt)* ) => $x:expr) => {
-        match $what {
-            #[cfg(x11_platform)]
-            $enum::X($($c1)*) => $x,
-            #[cfg(wayland_platform)]
-            $enum::Wayland($($c1)*) => $x,
-        }
-    };
-}
-
-impl MonitorHandle {
-    #[inline]
-    pub fn name(&self) -> Option<String> {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.name())
-    }
-
-    #[inline]
-    pub fn native_identifier(&self) -> u32 {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.native_identifier())
-    }
-
-    #[inline]
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.position())
-    }
-
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.scale_factor() as _)
-    }
-
-    #[inline]
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.current_video_mode())
-    }
-
-    #[inline]
-    pub fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
-        x11_or_wayland!(match self; MonitorHandle(m) => Box::new(m.video_modes()))
-    }
-}
-
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub(crate) enum PlatformCustomCursor {
-    #[cfg(wayland_platform)]
-    Wayland(wayland::CustomCursor),
-    #[cfg(x11_platform)]
-    X(x11::CustomCursor),
-}
-
-/// Hooks for X11 errors.
-#[cfg(x11_platform)]
-pub(crate) static XLIB_ERROR_HOOKS: Mutex<Vec<XlibErrorHook>> = Mutex::new(Vec::new());
-
-#[cfg(x11_platform)]
-unsafe extern "C" fn x_error_callback(
-    display: *mut x11::ffi::Display,
-    event: *mut x11::ffi::XErrorEvent,
-) -> c_int {
-    let xconn_lock = X11_BACKEND.lock().unwrap_or_else(|e| e.into_inner());
-    if let Ok(ref xconn) = *xconn_lock {
-        // Call all the hooks.
-        let mut error_handled = false;
-        for hook in XLIB_ERROR_HOOKS.lock().unwrap().iter() {
-            error_handled |= hook(display as *mut _, event as *mut _);
-        }
-
-        // `assume_init` is safe here because the array consists of `MaybeUninit` values,
-        // which do not require initialization.
-        let mut buf: [MaybeUninit<c_char>; 1024] = unsafe { MaybeUninit::uninit().assume_init() };
-        unsafe {
-            (xconn.xlib.XGetErrorText)(
-                display,
-                (*event).error_code as c_int,
-                buf.as_mut_ptr() as *mut c_char,
-                buf.len() as c_int,
-            )
-        };
-        let description =
-            unsafe { CStr::from_ptr(buf.as_ptr() as *const c_char) }.to_string_lossy();
-
-        let error = unsafe {
-            XError {
-                description: description.into_owned(),
-                error_code: (*event).error_code,
-                request_code: (*event).request_code,
-                minor_code: (*event).minor_code,
-            }
-        };
-
-        // Don't log error.
-        if !error_handled {
-            tracing::error!("X11 error: {:#?}", error);
-            // XXX only update the error, if it wasn't handled by any of the hooks.
-            *xconn.latest_error.lock().unwrap() = Some(error);
-        }
-    }
-    // Fun fact: this return value is completely ignored.
-    0
-}
-
-pub enum EventLoop {
-    #[cfg(wayland_platform)]
-    Wayland(Box<wayland::EventLoop>),
-    #[cfg(x11_platform)]
-    X(x11::EventLoop),
-}
-
-impl EventLoop {
-    pub(crate) fn new(
-        attributes: &PlatformSpecificEventLoopAttributes,
-    ) -> Result<Self, EventLoopError> {
-        if !attributes.any_thread && !is_main_thread() {
-            panic!(
-                "Initializing the event loop outside of the main thread is a significant \
-                 cross-platform compatibility hazard. If you absolutely need to create an \
-                 EventLoop on a different thread, you can use the \
-                 `EventLoopBuilderExtX11::with_any_thread` or \
-                 `EventLoopBuilderExtWayland::with_any_thread` functions."
-            );
-        }
-
-        // NOTE: Wayland first because of X11 could be present under Wayland as well. Empty
-        // variables are also treated as not set.
-        let backend = match (
-            attributes.forced_backend,
-            env::var("WAYLAND_DISPLAY")
-                .ok()
-                .filter(|var| !var.is_empty())
-                .or_else(|| env::var("WAYLAND_SOCKET").ok())
-                .filter(|var| !var.is_empty())
-                .is_some(),
-            env::var("DISPLAY").map(|var| !var.is_empty()).unwrap_or(false),
-        ) {
-            // User is forcing a backend.
-            (Some(backend), ..) => backend,
-            // Wayland is present.
-            #[cfg(wayland_platform)]
-            (None, true, _) => Backend::Wayland,
-            // X11 is present.
-            #[cfg(x11_platform)]
-            (None, _, true) => Backend::X,
-            // No backend is present.
-            (_, wayland_display, x11_display) => {
-                let msg = if wayland_display && !cfg!(wayland_platform) {
-                    "DISPLAY is not set; note: enable the `winit/wayland` feature to support \
-                     Wayland"
-                } else if x11_display && !cfg!(x11_platform) {
-                    "neither WAYLAND_DISPLAY nor WAYLAND_SOCKET is set; note: enable the \
-                     `winit/x11` feature to support X11"
-                } else {
-                    "neither WAYLAND_DISPLAY nor WAYLAND_SOCKET nor DISPLAY is set."
-                };
-                return Err(NotSupportedError::new(msg).into());
-            },
-        };
-
-        // Create the display based on the backend.
-        match backend {
-            #[cfg(wayland_platform)]
-            Backend::Wayland => EventLoop::new_wayland_any_thread(),
-            #[cfg(x11_platform)]
-            Backend::X => EventLoop::new_x11_any_thread(),
-        }
-    }
-
-    #[cfg(wayland_platform)]
-    fn new_wayland_any_thread() -> Result<EventLoop, EventLoopError> {
-        wayland::EventLoop::new().map(|evlp| EventLoop::Wayland(Box::new(evlp)))
-    }
-
-    #[cfg(x11_platform)]
-    fn new_x11_any_thread() -> Result<EventLoop, EventLoopError> {
-        let xconn = match X11_BACKEND.lock().unwrap_or_else(|e| e.into_inner()).as_ref() {
-            Ok(xconn) => xconn.clone(),
-            Err(err) => return Err(os_error!(err.clone()).into()),
-        };
-
-        Ok(EventLoop::X(x11::EventLoop::new(xconn)))
-    }
-
-    #[inline]
-    pub fn is_wayland(&self) -> bool {
-        match *self {
-            #[cfg(wayland_platform)]
-            EventLoop::Wayland(_) => true,
-            #[cfg(x11_platform)]
-            _ => false,
-        }
-    }
-
-    pub fn run_app<A: ApplicationHandler>(self, app: A) -> Result<(), EventLoopError> {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app(app))
-    }
-
-    pub fn run_app_on_demand<A: ApplicationHandler>(
-        &mut self,
-        app: A,
-    ) -> Result<(), EventLoopError> {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app_on_demand(app))
-    }
-
-    pub fn pump_app_events<A: ApplicationHandler>(
-        &mut self,
-        timeout: Option<Duration>,
-        app: A,
-    ) -> PumpStatus {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_app_events(timeout, app))
-    }
-
-    pub fn window_target(&self) -> &dyn ActiveEventLoop {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.window_target())
-    }
-}
-
-impl AsFd for EventLoop {
-    fn as_fd(&self) -> BorrowedFd<'_> {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_fd())
-    }
-}
-
-impl AsRawFd for EventLoop {
-    fn as_raw_fd(&self) -> RawFd {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_raw_fd())
-    }
-}
-
-/// Returns the minimum `Option<Duration>`, taking into account that `None`
-/// equates to an infinite timeout, not a zero timeout (so can't just use
-/// `Option::min`)
-fn min_timeout(a: Option<Duration>, b: Option<Duration>) -> Option<Duration> {
-    a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
-}
-
-#[cfg(target_os = "linux")]
-fn is_main_thread() -> bool {
-    rustix::thread::gettid() == rustix::process::getpid()
-}
-
-#[cfg(any(target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd"))]
-fn is_main_thread() -> bool {
-    use libc::pthread_main_np;
-
-    unsafe { pthread_main_np() == 1 }
-}
-
-#[cfg(target_os = "netbsd")]
-fn is_main_thread() -> bool {
-    std::thread::current().name() == Some("main")
-}

src/platform_impl/linux/wayland/mod.rs

@@ -1,31 +0,0 @@
-//! Winit's Wayland backend.
-
-pub use event_loop::{ActiveEventLoop, EventLoop};
-pub use output::MonitorHandle;
-use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::Proxy;
-pub use window::Window;
-
-pub(super) use crate::cursor::OnlyCursorImage as CustomCursor;
-use crate::dpi::{LogicalSize, PhysicalSize};
-use crate::window::WindowId;
-
-mod event_loop;
-mod output;
-mod seat;
-mod state;
-mod types;
-mod window;
-
-/// Get the WindowId out of the surface.
-#[inline]
-fn make_wid(surface: &WlSurface) -> WindowId {
-    WindowId::from_raw(surface.id().as_ptr() as usize)
-}
-
-/// 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()
-}

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

@@ -1,199 +0,0 @@
-use std::ops::Deref;
-
-use sctk::globals::GlobalData;
-use sctk::reexports::client::globals::{BindError, GlobalList};
-use sctk::reexports::client::protocol::wl_surface::WlSurface;
-use sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
-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);

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

@@ -1,58 +0,0 @@
-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,
-        }
-    }
-}

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

@@ -1,36 +0,0 @@
-#![allow(clippy::assertions_on_constants)]
-
-use super::*;
-use crate::icon::{Pixel, RgbaIcon, PIXEL_SIZE};
-
-impl Pixel {
-    pub fn to_packed_argb(&self) -> Cardinal {
-        let mut cardinal = 0;
-        assert!(CARDINAL_SIZE >= PIXEL_SIZE);
-        let as_bytes = &mut cardinal as *mut _ as *mut u8;
-        unsafe {
-            *as_bytes.offset(0) = self.b;
-            *as_bytes.offset(1) = self.g;
-            *as_bytes.offset(2) = self.r;
-            *as_bytes.offset(3) = self.a;
-        }
-        cardinal
-    }
-}
-
-impl RgbaIcon {
-    pub(crate) fn to_cardinals(&self) -> Vec<Cardinal> {
-        assert_eq!(self.rgba.len() % PIXEL_SIZE, 0);
-        let pixel_count = self.rgba.len() / PIXEL_SIZE;
-        assert_eq!(pixel_count, (self.width * self.height) as usize);
-        let mut data = Vec::with_capacity(pixel_count);
-        data.push(self.width as Cardinal);
-        data.push(self.height as Cardinal);
-        let pixels = self.rgba.as_ptr() as *const Pixel;
-        for pixel_index in 0..pixel_count {
-            let pixel = unsafe { &*pixels.add(pixel_index) };
-            data.push(pixel.to_packed_argb());
-        }
-        data
-    }
-}

src/platform_impl/mod.rs

@@ -1,76 +0,0 @@
-use crate::monitor::{MonitorHandle as RootMonitorHandle, VideoMode};
-use crate::window::Fullscreen as RootFullscreen;
-
-#[cfg(android_platform)]
-mod android;
-#[cfg(target_vendor = "apple")]
-mod apple;
-#[cfg(any(x11_platform, wayland_platform))]
-mod linux;
-#[cfg(orbital_platform)]
-mod orbital;
-#[cfg(web_platform)]
-mod web;
-#[cfg(windows_platform)]
-mod windows;
-
-#[cfg(android_platform)]
-use self::android as platform;
-#[cfg(target_vendor = "apple")]
-use self::apple as platform;
-#[cfg(any(x11_platform, wayland_platform))]
-use self::linux as platform;
-#[cfg(orbital_platform)]
-use self::orbital as platform;
-#[allow(unused_imports)]
-pub use self::platform::*;
-#[cfg(web_platform)]
-use self::web as platform;
-#[cfg(windows_platform)]
-use self::windows as platform;
-
-/// Helper for converting between platform-specific and generic
-/// [`VideoMode`]/[`MonitorHandle`]
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub(crate) enum Fullscreen {
-    Exclusive(MonitorHandle, VideoMode),
-    Borderless(Option<MonitorHandle>),
-}
-
-impl From<RootFullscreen> for Fullscreen {
-    fn from(f: RootFullscreen) -> Self {
-        match f {
-            RootFullscreen::Exclusive(handle, video_mode) => {
-                Self::Exclusive(handle.inner, video_mode)
-            },
-            RootFullscreen::Borderless(Some(handle)) => Self::Borderless(Some(handle.inner)),
-            RootFullscreen::Borderless(None) => Self::Borderless(None),
-        }
-    }
-}
-
-impl From<Fullscreen> for RootFullscreen {
-    fn from(f: Fullscreen) -> Self {
-        match f {
-            Fullscreen::Exclusive(inner, video_mode) => {
-                Self::Exclusive(RootMonitorHandle { inner }, video_mode)
-            },
-            Fullscreen::Borderless(Some(inner)) => {
-                Self::Borderless(Some(RootMonitorHandle { inner }))
-            },
-            Fullscreen::Borderless(None) => Self::Borderless(None),
-        }
-    }
-}
-
-#[cfg(all(
-    not(ios_platform),
-    not(windows_platform),
-    not(macos_platform),
-    not(android_platform),
-    not(x11_platform),
-    not(wayland_platform),
-    not(web_platform),
-    not(orbital_platform),
-))]
-compile_error!("The platform you're compiling for is not supported by winit");

src/platform_impl/orbital/mod.rs

@@ -1,159 +0,0 @@
-#![cfg(target_os = "redox")]
-
-use std::{fmt, str};
-
-pub(crate) use self::event_loop::{ActiveEventLoop, EventLoop};
-pub use self::window::Window;
-use crate::dpi::PhysicalPosition;
-use crate::monitor::VideoMode;
-
-mod event_loop;
-mod window;
-
-pub(crate) use crate::cursor::{
-    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
-};
-pub(crate) use crate::icon::NoIcon as PlatformIcon;
-
-struct RedoxSocket {
-    fd: usize,
-}
-
-impl RedoxSocket {
-    fn event() -> syscall::Result<Self> {
-        Self::open_raw("event:")
-    }
-
-    fn orbital(properties: &WindowProperties<'_>) -> syscall::Result<Self> {
-        Self::open_raw(&format!("{properties}"))
-    }
-
-    // Paths should be checked to ensure they are actually sockets and not normal files. If a
-    // non-socket path is used, it could cause read and write to not function as expected. For
-    // example, the seek would change in a potentially unpredictable way if either read or write
-    // were called at the same time by multiple threads.
-    fn open_raw(path: &str) -> syscall::Result<Self> {
-        let fd = syscall::open(path, syscall::O_RDWR | syscall::O_CLOEXEC)?;
-        Ok(Self { fd })
-    }
-
-    fn read(&self, buf: &mut [u8]) -> syscall::Result<()> {
-        let count = syscall::read(self.fd, buf)?;
-        if count == buf.len() {
-            Ok(())
-        } else {
-            Err(syscall::Error::new(syscall::EINVAL))
-        }
-    }
-
-    fn write(&self, buf: &[u8]) -> syscall::Result<()> {
-        let count = syscall::write(self.fd, buf)?;
-        if count == buf.len() {
-            Ok(())
-        } else {
-            Err(syscall::Error::new(syscall::EINVAL))
-        }
-    }
-
-    fn fpath<'a>(&self, buf: &'a mut [u8]) -> syscall::Result<&'a str> {
-        let count = syscall::fpath(self.fd, buf)?;
-        str::from_utf8(&buf[..count]).map_err(|_err| syscall::Error::new(syscall::EINVAL))
-    }
-}
-
-impl Drop for RedoxSocket {
-    fn drop(&mut self) {
-        let _ = syscall::close(self.fd);
-    }
-}
-
-pub struct TimeSocket(RedoxSocket);
-
-impl TimeSocket {
-    fn open() -> syscall::Result<Self> {
-        RedoxSocket::open_raw("time:4").map(Self)
-    }
-
-    // Read current time.
-    fn current_time(&self) -> syscall::Result<syscall::TimeSpec> {
-        let mut timespec = syscall::TimeSpec::default();
-        self.0.read(&mut timespec)?;
-        Ok(timespec)
-    }
-
-    // Write a timeout.
-    fn timeout(&self, timespec: &syscall::TimeSpec) -> syscall::Result<()> {
-        self.0.write(timespec)
-    }
-
-    // Wake immediately.
-    fn wake(&self) -> syscall::Result<()> {
-        // Writing a default TimeSpec will always trigger a time event.
-        self.timeout(&syscall::TimeSpec::default())
-    }
-}
-
-#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PlatformSpecificEventLoopAttributes {}
-
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub struct PlatformSpecificWindowAttributes;
-
-struct WindowProperties<'a> {
-    flags: &'a str,
-    x: i32,
-    y: i32,
-    w: u32,
-    h: u32,
-    title: &'a str,
-}
-
-impl<'a> WindowProperties<'a> {
-    fn new(path: &'a str) -> Self {
-        // orbital:flags/x/y/w/h/t
-        let mut parts = path.splitn(6, '/');
-        let flags = parts.next().unwrap_or("");
-        let x = parts.next().map_or(0, |part| part.parse::<i32>().unwrap_or(0));
-        let y = parts.next().map_or(0, |part| part.parse::<i32>().unwrap_or(0));
-        let w = parts.next().map_or(0, |part| part.parse::<u32>().unwrap_or(0));
-        let h = parts.next().map_or(0, |part| part.parse::<u32>().unwrap_or(0));
-        let title = parts.next().unwrap_or("");
-        Self { flags, x, y, w, h, title }
-    }
-}
-
-impl fmt::Display for WindowProperties<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "orbital:{}/{}/{}/{}/{}/{}",
-            self.flags, self.x, self.y, self.w, self.h, self.title
-        )
-    }
-}
-
-#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct MonitorHandle;
-
-impl MonitorHandle {
-    pub fn name(&self) -> Option<String> {
-        None
-    }
-
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        None
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        1.0 // TODO
-    }
-
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        // (it is guaranteed to support 32 bit color though)
-        None
-    }
-
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        std::iter::empty()
-    }
-}

src/platform_impl/web/error.rs

@@ -1,10 +0,0 @@
-use std::fmt;
-
-#[derive(Debug)]
-pub struct OsError(pub String);
-
-impl fmt::Display for OsError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}

src/platform_impl/web/event_loop/mod.rs

@@ -1,85 +0,0 @@
-use super::{backend, HasMonitorPermissionFuture, MonitorPermissionFuture};
-use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, NotSupportedError};
-use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;
-use crate::platform::web::{PollStrategy, WaitUntilStrategy};
-
-mod proxy;
-pub(crate) mod runner;
-mod state;
-mod window_target;
-
-pub(crate) use window_target::ActiveEventLoop;
-
-pub struct EventLoop {
-    elw: ActiveEventLoop,
-}
-
-#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PlatformSpecificEventLoopAttributes {}
-
-impl EventLoop {
-    pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
-        Ok(EventLoop { elw: ActiveEventLoop::new() })
-    }
-
-    pub fn run_app<A: ApplicationHandler>(self, app: A) -> ! {
-        let app = Box::new(app);
-
-        // SAFETY: The `transmute` is necessary because `run()` requires `'static`. This is safe
-        // because this function will never return and all resources not cleaned up by the point we
-        // `throw` will leak, making this actually `'static`.
-        let app = unsafe {
-            std::mem::transmute::<
-                Box<dyn ApplicationHandler + '_>,
-                Box<dyn ApplicationHandler + 'static>,
-            >(app)
-        };
-
-        self.elw.run(app, false);
-
-        // Throw an exception to break out of Rust execution and use unreachable to tell the
-        // compiler this function won't return, giving it a return type of '!'
-        backend::throw(
-            "Using exceptions for control flow, don't mind me. This isn't actually an error!",
-        );
-
-        unreachable!();
-    }
-
-    pub fn spawn_app<A: ApplicationHandler + 'static>(self, app: A) {
-        self.elw.run(Box::new(app), true);
-    }
-
-    pub fn window_target(&self) -> &dyn RootActiveEventLoop {
-        &self.elw
-    }
-
-    pub fn set_poll_strategy(&self, strategy: PollStrategy) {
-        self.elw.set_poll_strategy(strategy);
-    }
-
-    pub fn poll_strategy(&self) -> PollStrategy {
-        self.elw.poll_strategy()
-    }
-
-    pub fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
-        self.elw.set_wait_until_strategy(strategy);
-    }
-
-    pub fn wait_until_strategy(&self) -> WaitUntilStrategy {
-        self.elw.wait_until_strategy()
-    }
-
-    pub fn has_multiple_screens(&self) -> Result<bool, NotSupportedError> {
-        self.elw.has_multiple_screens()
-    }
-
-    pub(crate) fn request_detailed_monitor_permission(&self) -> MonitorPermissionFuture {
-        self.elw.request_detailed_monitor_permission()
-    }
-
-    pub fn has_detailed_monitor_permission(&self) -> HasMonitorPermissionFuture {
-        self.elw.runner.monitor().has_detailed_monitor_permission_async()
-    }
-}

src/platform_impl/web/keyboard.rs

@@ -1,519 +0,0 @@
-use smol_str::SmolStr;
-
-use crate::keyboard::{Key, KeyCode, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
-
-impl Key {
-    pub(crate) fn from_key_attribute_value(kav: &str) -> Self {
-        Key::Named(match kav {
-            "Unidentified" => return Key::Unidentified(NativeKey::Web(SmolStr::new(kav))),
-            "Dead" => return Key::Dead(None),
-            "Alt" => NamedKey::Alt,
-            "AltGraph" => NamedKey::AltGraph,
-            "CapsLock" => NamedKey::CapsLock,
-            "Control" => NamedKey::Control,
-            "Fn" => NamedKey::Fn,
-            "FnLock" => NamedKey::FnLock,
-            "NumLock" => NamedKey::NumLock,
-            "ScrollLock" => NamedKey::ScrollLock,
-            "Shift" => NamedKey::Shift,
-            "Symbol" => NamedKey::Symbol,
-            "SymbolLock" => NamedKey::SymbolLock,
-            "Hyper" => NamedKey::Hyper,
-            "Meta" => NamedKey::Super,
-            "Enter" => NamedKey::Enter,
-            "Tab" => NamedKey::Tab,
-            " " => NamedKey::Space,
-            "ArrowDown" => NamedKey::ArrowDown,
-            "ArrowLeft" => NamedKey::ArrowLeft,
-            "ArrowRight" => NamedKey::ArrowRight,
-            "ArrowUp" => NamedKey::ArrowUp,
-            "End" => NamedKey::End,
-            "Home" => NamedKey::Home,
-            "PageDown" => NamedKey::PageDown,
-            "PageUp" => NamedKey::PageUp,
-            "Backspace" => NamedKey::Backspace,
-            "Clear" => NamedKey::Clear,
-            "Copy" => NamedKey::Copy,
-            "CrSel" => NamedKey::CrSel,
-            "Cut" => NamedKey::Cut,
-            "Delete" => NamedKey::Delete,
-            "EraseEof" => NamedKey::EraseEof,
-            "ExSel" => NamedKey::ExSel,
-            "Insert" => NamedKey::Insert,
-            "Paste" => NamedKey::Paste,
-            "Redo" => NamedKey::Redo,
-            "Undo" => NamedKey::Undo,
-            "Accept" => NamedKey::Accept,
-            "Again" => NamedKey::Again,
-            "Attn" => NamedKey::Attn,
-            "Cancel" => NamedKey::Cancel,
-            "ContextMenu" => NamedKey::ContextMenu,
-            "Escape" => NamedKey::Escape,
-            "Execute" => NamedKey::Execute,
-            "Find" => NamedKey::Find,
-            "Help" => NamedKey::Help,
-            "Pause" => NamedKey::Pause,
-            "Play" => NamedKey::Play,
-            "Props" => NamedKey::Props,
-            "Select" => NamedKey::Select,
-            "ZoomIn" => NamedKey::ZoomIn,
-            "ZoomOut" => NamedKey::ZoomOut,
-            "BrightnessDown" => NamedKey::BrightnessDown,
-            "BrightnessUp" => NamedKey::BrightnessUp,
-            "Eject" => NamedKey::Eject,
-            "LogOff" => NamedKey::LogOff,
-            "Power" => NamedKey::Power,
-            "PowerOff" => NamedKey::PowerOff,
-            "PrintScreen" => NamedKey::PrintScreen,
-            "Hibernate" => NamedKey::Hibernate,
-            "Standby" => NamedKey::Standby,
-            "WakeUp" => NamedKey::WakeUp,
-            "AllCandidates" => NamedKey::AllCandidates,
-            "Alphanumeric" => NamedKey::Alphanumeric,
-            "CodeInput" => NamedKey::CodeInput,
-            "Compose" => NamedKey::Compose,
-            "Convert" => NamedKey::Convert,
-            "FinalMode" => NamedKey::FinalMode,
-            "GroupFirst" => NamedKey::GroupFirst,
-            "GroupLast" => NamedKey::GroupLast,
-            "GroupNext" => NamedKey::GroupNext,
-            "GroupPrevious" => NamedKey::GroupPrevious,
-            "ModeChange" => NamedKey::ModeChange,
-            "NextCandidate" => NamedKey::NextCandidate,
-            "NonConvert" => NamedKey::NonConvert,
-            "PreviousCandidate" => NamedKey::PreviousCandidate,
-            "Process" => NamedKey::Process,
-            "SingleCandidate" => NamedKey::SingleCandidate,
-            "HangulMode" => NamedKey::HangulMode,
-            "HanjaMode" => NamedKey::HanjaMode,
-            "JunjaMode" => NamedKey::JunjaMode,
-            "Eisu" => NamedKey::Eisu,
-            "Hankaku" => NamedKey::Hankaku,
-            "Hiragana" => NamedKey::Hiragana,
-            "HiraganaKatakana" => NamedKey::HiraganaKatakana,
-            "KanaMode" => NamedKey::KanaMode,
-            "KanjiMode" => NamedKey::KanjiMode,
-            "Katakana" => NamedKey::Katakana,
-            "Romaji" => NamedKey::Romaji,
-            "Zenkaku" => NamedKey::Zenkaku,
-            "ZenkakuHankaku" => NamedKey::ZenkakuHankaku,
-            "Soft1" => NamedKey::Soft1,
-            "Soft2" => NamedKey::Soft2,
-            "Soft3" => NamedKey::Soft3,
-            "Soft4" => NamedKey::Soft4,
-            "ChannelDown" => NamedKey::ChannelDown,
-            "ChannelUp" => NamedKey::ChannelUp,
-            "Close" => NamedKey::Close,
-            "MailForward" => NamedKey::MailForward,
-            "MailReply" => NamedKey::MailReply,
-            "MailSend" => NamedKey::MailSend,
-            "MediaClose" => NamedKey::MediaClose,
-            "MediaFastForward" => NamedKey::MediaFastForward,
-            "MediaPause" => NamedKey::MediaPause,
-            "MediaPlay" => NamedKey::MediaPlay,
-            "MediaPlayPause" => NamedKey::MediaPlayPause,
-            "MediaRecord" => NamedKey::MediaRecord,
-            "MediaRewind" => NamedKey::MediaRewind,
-            "MediaStop" => NamedKey::MediaStop,
-            "MediaTrackNext" => NamedKey::MediaTrackNext,
-            "MediaTrackPrevious" => NamedKey::MediaTrackPrevious,
-            "New" => NamedKey::New,
-            "Open" => NamedKey::Open,
-            "Print" => NamedKey::Print,
-            "Save" => NamedKey::Save,
-            "SpellCheck" => NamedKey::SpellCheck,
-            "Key11" => NamedKey::Key11,
-            "Key12" => NamedKey::Key12,
-            "AudioBalanceLeft" => NamedKey::AudioBalanceLeft,
-            "AudioBalanceRight" => NamedKey::AudioBalanceRight,
-            "AudioBassBoostDown" => NamedKey::AudioBassBoostDown,
-            "AudioBassBoostToggle" => NamedKey::AudioBassBoostToggle,
-            "AudioBassBoostUp" => NamedKey::AudioBassBoostUp,
-            "AudioFaderFront" => NamedKey::AudioFaderFront,
-            "AudioFaderRear" => NamedKey::AudioFaderRear,
-            "AudioSurroundModeNext" => NamedKey::AudioSurroundModeNext,
-            "AudioTrebleDown" => NamedKey::AudioTrebleDown,
-            "AudioTrebleUp" => NamedKey::AudioTrebleUp,
-            "AudioVolumeDown" => NamedKey::AudioVolumeDown,
-            "AudioVolumeUp" => NamedKey::AudioVolumeUp,
-            "AudioVolumeMute" => NamedKey::AudioVolumeMute,
-            "MicrophoneToggle" => NamedKey::MicrophoneToggle,
-            "MicrophoneVolumeDown" => NamedKey::MicrophoneVolumeDown,
-            "MicrophoneVolumeUp" => NamedKey::MicrophoneVolumeUp,
-            "MicrophoneVolumeMute" => NamedKey::MicrophoneVolumeMute,
-            "SpeechCorrectionList" => NamedKey::SpeechCorrectionList,
-            "SpeechInputToggle" => NamedKey::SpeechInputToggle,
-            "LaunchApplication1" => NamedKey::LaunchApplication1,
-            "LaunchApplication2" => NamedKey::LaunchApplication2,
-            "LaunchCalendar" => NamedKey::LaunchCalendar,
-            "LaunchContacts" => NamedKey::LaunchContacts,
-            "LaunchMail" => NamedKey::LaunchMail,
-            "LaunchMediaPlayer" => NamedKey::LaunchMediaPlayer,
-            "LaunchMusicPlayer" => NamedKey::LaunchMusicPlayer,
-            "LaunchPhone" => NamedKey::LaunchPhone,
-            "LaunchScreenSaver" => NamedKey::LaunchScreenSaver,
-            "LaunchSpreadsheet" => NamedKey::LaunchSpreadsheet,
-            "LaunchWebBrowser" => NamedKey::LaunchWebBrowser,
-            "LaunchWebCam" => NamedKey::LaunchWebCam,
-            "LaunchWordProcessor" => NamedKey::LaunchWordProcessor,
-            "BrowserBack" => NamedKey::BrowserBack,
-            "BrowserFavorites" => NamedKey::BrowserFavorites,
-            "BrowserForward" => NamedKey::BrowserForward,
-            "BrowserHome" => NamedKey::BrowserHome,
-            "BrowserRefresh" => NamedKey::BrowserRefresh,
-            "BrowserSearch" => NamedKey::BrowserSearch,
-            "BrowserStop" => NamedKey::BrowserStop,
-            "AppSwitch" => NamedKey::AppSwitch,
-            "Call" => NamedKey::Call,
-            "Camera" => NamedKey::Camera,
-            "CameraFocus" => NamedKey::CameraFocus,
-            "EndCall" => NamedKey::EndCall,
-            "GoBack" => NamedKey::GoBack,
-            "GoHome" => NamedKey::GoHome,
-            "HeadsetHook" => NamedKey::HeadsetHook,
-            "LastNumberRedial" => NamedKey::LastNumberRedial,
-            "Notification" => NamedKey::Notification,
-            "MannerMode" => NamedKey::MannerMode,
-            "VoiceDial" => NamedKey::VoiceDial,
-            "TV" => NamedKey::TV,
-            "TV3DMode" => NamedKey::TV3DMode,
-            "TVAntennaCable" => NamedKey::TVAntennaCable,
-            "TVAudioDescription" => NamedKey::TVAudioDescription,
-            "TVAudioDescriptionMixDown" => NamedKey::TVAudioDescriptionMixDown,
-            "TVAudioDescriptionMixUp" => NamedKey::TVAudioDescriptionMixUp,
-            "TVContentsMenu" => NamedKey::TVContentsMenu,
-            "TVDataService" => NamedKey::TVDataService,
-            "TVInput" => NamedKey::TVInput,
-            "TVInputComponent1" => NamedKey::TVInputComponent1,
-            "TVInputComponent2" => NamedKey::TVInputComponent2,
-            "TVInputComposite1" => NamedKey::TVInputComposite1,
-            "TVInputComposite2" => NamedKey::TVInputComposite2,
-            "TVInputHDMI1" => NamedKey::TVInputHDMI1,
-            "TVInputHDMI2" => NamedKey::TVInputHDMI2,
-            "TVInputHDMI3" => NamedKey::TVInputHDMI3,
-            "TVInputHDMI4" => NamedKey::TVInputHDMI4,
-            "TVInputVGA1" => NamedKey::TVInputVGA1,
-            "TVMediaContext" => NamedKey::TVMediaContext,
-            "TVNetwork" => NamedKey::TVNetwork,
-            "TVNumberEntry" => NamedKey::TVNumberEntry,
-            "TVPower" => NamedKey::TVPower,
-            "TVRadioService" => NamedKey::TVRadioService,
-            "TVSatellite" => NamedKey::TVSatellite,
-            "TVSatelliteBS" => NamedKey::TVSatelliteBS,
-            "TVSatelliteCS" => NamedKey::TVSatelliteCS,
-            "TVSatelliteToggle" => NamedKey::TVSatelliteToggle,
-            "TVTerrestrialAnalog" => NamedKey::TVTerrestrialAnalog,
-            "TVTerrestrialDigital" => NamedKey::TVTerrestrialDigital,
-            "TVTimer" => NamedKey::TVTimer,
-            "AVRInput" => NamedKey::AVRInput,
-            "AVRPower" => NamedKey::AVRPower,
-            "ColorF0Red" => NamedKey::ColorF0Red,
-            "ColorF1Green" => NamedKey::ColorF1Green,
-            "ColorF2Yellow" => NamedKey::ColorF2Yellow,
-            "ColorF3Blue" => NamedKey::ColorF3Blue,
-            "ColorF4Grey" => NamedKey::ColorF4Grey,
-            "ColorF5Brown" => NamedKey::ColorF5Brown,
-            "ClosedCaptionToggle" => NamedKey::ClosedCaptionToggle,
-            "Dimmer" => NamedKey::Dimmer,
-            "DisplaySwap" => NamedKey::DisplaySwap,
-            "DVR" => NamedKey::DVR,
-            "Exit" => NamedKey::Exit,
-            "FavoriteClear0" => NamedKey::FavoriteClear0,
-            "FavoriteClear1" => NamedKey::FavoriteClear1,
-            "FavoriteClear2" => NamedKey::FavoriteClear2,
-            "FavoriteClear3" => NamedKey::FavoriteClear3,
-            "FavoriteRecall0" => NamedKey::FavoriteRecall0,
-            "FavoriteRecall1" => NamedKey::FavoriteRecall1,
-            "FavoriteRecall2" => NamedKey::FavoriteRecall2,
-            "FavoriteRecall3" => NamedKey::FavoriteRecall3,
-            "FavoriteStore0" => NamedKey::FavoriteStore0,
-            "FavoriteStore1" => NamedKey::FavoriteStore1,
-            "FavoriteStore2" => NamedKey::FavoriteStore2,
-            "FavoriteStore3" => NamedKey::FavoriteStore3,
-            "Guide" => NamedKey::Guide,
-            "GuideNextDay" => NamedKey::GuideNextDay,
-            "GuidePreviousDay" => NamedKey::GuidePreviousDay,
-            "Info" => NamedKey::Info,
-            "InstantReplay" => NamedKey::InstantReplay,
-            "Link" => NamedKey::Link,
-            "ListProgram" => NamedKey::ListProgram,
-            "LiveContent" => NamedKey::LiveContent,
-            "Lock" => NamedKey::Lock,
-            "MediaApps" => NamedKey::MediaApps,
-            "MediaAudioTrack" => NamedKey::MediaAudioTrack,
-            "MediaLast" => NamedKey::MediaLast,
-            "MediaSkipBackward" => NamedKey::MediaSkipBackward,
-            "MediaSkipForward" => NamedKey::MediaSkipForward,
-            "MediaStepBackward" => NamedKey::MediaStepBackward,
-            "MediaStepForward" => NamedKey::MediaStepForward,
-            "MediaTopMenu" => NamedKey::MediaTopMenu,
-            "NavigateIn" => NamedKey::NavigateIn,
-            "NavigateNext" => NamedKey::NavigateNext,
-            "NavigateOut" => NamedKey::NavigateOut,
-            "NavigatePrevious" => NamedKey::NavigatePrevious,
-            "NextFavoriteChannel" => NamedKey::NextFavoriteChannel,
-            "NextUserProfile" => NamedKey::NextUserProfile,
-            "OnDemand" => NamedKey::OnDemand,
-            "Pairing" => NamedKey::Pairing,
-            "PinPDown" => NamedKey::PinPDown,
-            "PinPMove" => NamedKey::PinPMove,
-            "PinPToggle" => NamedKey::PinPToggle,
-            "PinPUp" => NamedKey::PinPUp,
-            "PlaySpeedDown" => NamedKey::PlaySpeedDown,
-            "PlaySpeedReset" => NamedKey::PlaySpeedReset,
-            "PlaySpeedUp" => NamedKey::PlaySpeedUp,
-            "RandomToggle" => NamedKey::RandomToggle,
-            "RcLowBattery" => NamedKey::RcLowBattery,
-            "RecordSpeedNext" => NamedKey::RecordSpeedNext,
-            "RfBypass" => NamedKey::RfBypass,
-            "ScanChannelsToggle" => NamedKey::ScanChannelsToggle,
-            "ScreenModeNext" => NamedKey::ScreenModeNext,
-            "Settings" => NamedKey::Settings,
-            "SplitScreenToggle" => NamedKey::SplitScreenToggle,
-            "STBInput" => NamedKey::STBInput,
-            "STBPower" => NamedKey::STBPower,
-            "Subtitle" => NamedKey::Subtitle,
-            "Teletext" => NamedKey::Teletext,
-            "VideoModeNext" => NamedKey::VideoModeNext,
-            "Wink" => NamedKey::Wink,
-            "ZoomToggle" => NamedKey::ZoomToggle,
-            "F1" => NamedKey::F1,
-            "F2" => NamedKey::F2,
-            "F3" => NamedKey::F3,
-            "F4" => NamedKey::F4,
-            "F5" => NamedKey::F5,
-            "F6" => NamedKey::F6,
-            "F7" => NamedKey::F7,
-            "F8" => NamedKey::F8,
-            "F9" => NamedKey::F9,
-            "F10" => NamedKey::F10,
-            "F11" => NamedKey::F11,
-            "F12" => NamedKey::F12,
-            "F13" => NamedKey::F13,
-            "F14" => NamedKey::F14,
-            "F15" => NamedKey::F15,
-            "F16" => NamedKey::F16,
-            "F17" => NamedKey::F17,
-            "F18" => NamedKey::F18,
-            "F19" => NamedKey::F19,
-            "F20" => NamedKey::F20,
-            "F21" => NamedKey::F21,
-            "F22" => NamedKey::F22,
-            "F23" => NamedKey::F23,
-            "F24" => NamedKey::F24,
-            "F25" => NamedKey::F25,
-            "F26" => NamedKey::F26,
-            "F27" => NamedKey::F27,
-            "F28" => NamedKey::F28,
-            "F29" => NamedKey::F29,
-            "F30" => NamedKey::F30,
-            "F31" => NamedKey::F31,
-            "F32" => NamedKey::F32,
-            "F33" => NamedKey::F33,
-            "F34" => NamedKey::F34,
-            "F35" => NamedKey::F35,
-            string => return Key::Character(SmolStr::new(string)),
-        })
-    }
-}
-
-impl PhysicalKey {
-    pub fn from_key_code_attribute_value(kcav: &str) -> Self {
-        PhysicalKey::Code(match kcav {
-            "Backquote" => KeyCode::Backquote,
-            "Backslash" => KeyCode::Backslash,
-            "BracketLeft" => KeyCode::BracketLeft,
-            "BracketRight" => KeyCode::BracketRight,
-            "Comma" => KeyCode::Comma,
-            "Digit0" => KeyCode::Digit0,
-            "Digit1" => KeyCode::Digit1,
-            "Digit2" => KeyCode::Digit2,
-            "Digit3" => KeyCode::Digit3,
-            "Digit4" => KeyCode::Digit4,
-            "Digit5" => KeyCode::Digit5,
-            "Digit6" => KeyCode::Digit6,
-            "Digit7" => KeyCode::Digit7,
-            "Digit8" => KeyCode::Digit8,
-            "Digit9" => KeyCode::Digit9,
-            "Equal" => KeyCode::Equal,
-            "IntlBackslash" => KeyCode::IntlBackslash,
-            "IntlRo" => KeyCode::IntlRo,
-            "IntlYen" => KeyCode::IntlYen,
-            "KeyA" => KeyCode::KeyA,
-            "KeyB" => KeyCode::KeyB,
-            "KeyC" => KeyCode::KeyC,
-            "KeyD" => KeyCode::KeyD,
-            "KeyE" => KeyCode::KeyE,
-            "KeyF" => KeyCode::KeyF,
-            "KeyG" => KeyCode::KeyG,
-            "KeyH" => KeyCode::KeyH,
-            "KeyI" => KeyCode::KeyI,
-            "KeyJ" => KeyCode::KeyJ,
-            "KeyK" => KeyCode::KeyK,
-            "KeyL" => KeyCode::KeyL,
-            "KeyM" => KeyCode::KeyM,
-            "KeyN" => KeyCode::KeyN,
-            "KeyO" => KeyCode::KeyO,
-            "KeyP" => KeyCode::KeyP,
-            "KeyQ" => KeyCode::KeyQ,
-            "KeyR" => KeyCode::KeyR,
-            "KeyS" => KeyCode::KeyS,
-            "KeyT" => KeyCode::KeyT,
-            "KeyU" => KeyCode::KeyU,
-            "KeyV" => KeyCode::KeyV,
-            "KeyW" => KeyCode::KeyW,
-            "KeyX" => KeyCode::KeyX,
-            "KeyY" => KeyCode::KeyY,
-            "KeyZ" => KeyCode::KeyZ,
-            "Minus" => KeyCode::Minus,
-            "Period" => KeyCode::Period,
-            "Quote" => KeyCode::Quote,
-            "Semicolon" => KeyCode::Semicolon,
-            "Slash" => KeyCode::Slash,
-            "AltLeft" => KeyCode::AltLeft,
-            "AltRight" => KeyCode::AltRight,
-            "Backspace" => KeyCode::Backspace,
-            "CapsLock" => KeyCode::CapsLock,
-            "ContextMenu" => KeyCode::ContextMenu,
-            "ControlLeft" => KeyCode::ControlLeft,
-            "ControlRight" => KeyCode::ControlRight,
-            "Enter" => KeyCode::Enter,
-            "MetaLeft" => KeyCode::SuperLeft,
-            "MetaRight" => KeyCode::SuperRight,
-            "ShiftLeft" => KeyCode::ShiftLeft,
-            "ShiftRight" => KeyCode::ShiftRight,
-            "Space" => KeyCode::Space,
-            "Tab" => KeyCode::Tab,
-            "Convert" => KeyCode::Convert,
-            "KanaMode" => KeyCode::KanaMode,
-            "Lang1" => KeyCode::Lang1,
-            "Lang2" => KeyCode::Lang2,
-            "Lang3" => KeyCode::Lang3,
-            "Lang4" => KeyCode::Lang4,
-            "Lang5" => KeyCode::Lang5,
-            "NonConvert" => KeyCode::NonConvert,
-            "Delete" => KeyCode::Delete,
-            "End" => KeyCode::End,
-            "Help" => KeyCode::Help,
-            "Home" => KeyCode::Home,
-            "Insert" => KeyCode::Insert,
-            "PageDown" => KeyCode::PageDown,
-            "PageUp" => KeyCode::PageUp,
-            "ArrowDown" => KeyCode::ArrowDown,
-            "ArrowLeft" => KeyCode::ArrowLeft,
-            "ArrowRight" => KeyCode::ArrowRight,
-            "ArrowUp" => KeyCode::ArrowUp,
-            "NumLock" => KeyCode::NumLock,
-            "Numpad0" => KeyCode::Numpad0,
-            "Numpad1" => KeyCode::Numpad1,
-            "Numpad2" => KeyCode::Numpad2,
-            "Numpad3" => KeyCode::Numpad3,
-            "Numpad4" => KeyCode::Numpad4,
-            "Numpad5" => KeyCode::Numpad5,
-            "Numpad6" => KeyCode::Numpad6,
-            "Numpad7" => KeyCode::Numpad7,
-            "Numpad8" => KeyCode::Numpad8,
-            "Numpad9" => KeyCode::Numpad9,
-            "NumpadAdd" => KeyCode::NumpadAdd,
-            "NumpadBackspace" => KeyCode::NumpadBackspace,
-            "NumpadClear" => KeyCode::NumpadClear,
-            "NumpadClearEntry" => KeyCode::NumpadClearEntry,
-            "NumpadComma" => KeyCode::NumpadComma,
-            "NumpadDecimal" => KeyCode::NumpadDecimal,
-            "NumpadDivide" => KeyCode::NumpadDivide,
-            "NumpadEnter" => KeyCode::NumpadEnter,
-            "NumpadEqual" => KeyCode::NumpadEqual,
-            "NumpadHash" => KeyCode::NumpadHash,
-            "NumpadMemoryAdd" => KeyCode::NumpadMemoryAdd,
-            "NumpadMemoryClear" => KeyCode::NumpadMemoryClear,
-            "NumpadMemoryRecall" => KeyCode::NumpadMemoryRecall,
-            "NumpadMemoryStore" => KeyCode::NumpadMemoryStore,
-            "NumpadMemorySubtract" => KeyCode::NumpadMemorySubtract,
-            "NumpadMultiply" => KeyCode::NumpadMultiply,
-            "NumpadParenLeft" => KeyCode::NumpadParenLeft,
-            "NumpadParenRight" => KeyCode::NumpadParenRight,
-            "NumpadStar" => KeyCode::NumpadStar,
-            "NumpadSubtract" => KeyCode::NumpadSubtract,
-            "Escape" => KeyCode::Escape,
-            "Fn" => KeyCode::Fn,
-            "FnLock" => KeyCode::FnLock,
-            "PrintScreen" => KeyCode::PrintScreen,
-            "ScrollLock" => KeyCode::ScrollLock,
-            "Pause" => KeyCode::Pause,
-            "BrowserBack" => KeyCode::BrowserBack,
-            "BrowserFavorites" => KeyCode::BrowserFavorites,
-            "BrowserForward" => KeyCode::BrowserForward,
-            "BrowserHome" => KeyCode::BrowserHome,
-            "BrowserRefresh" => KeyCode::BrowserRefresh,
-            "BrowserSearch" => KeyCode::BrowserSearch,
-            "BrowserStop" => KeyCode::BrowserStop,
-            "Eject" => KeyCode::Eject,
-            "LaunchApp1" => KeyCode::LaunchApp1,
-            "LaunchApp2" => KeyCode::LaunchApp2,
-            "LaunchMail" => KeyCode::LaunchMail,
-            "MediaPlayPause" => KeyCode::MediaPlayPause,
-            "MediaSelect" => KeyCode::MediaSelect,
-            "MediaStop" => KeyCode::MediaStop,
-            "MediaTrackNext" => KeyCode::MediaTrackNext,
-            "MediaTrackPrevious" => KeyCode::MediaTrackPrevious,
-            "Power" => KeyCode::Power,
-            "Sleep" => KeyCode::Sleep,
-            "AudioVolumeDown" => KeyCode::AudioVolumeDown,
-            "AudioVolumeMute" => KeyCode::AudioVolumeMute,
-            "AudioVolumeUp" => KeyCode::AudioVolumeUp,
-            "WakeUp" => KeyCode::WakeUp,
-            "Hyper" => KeyCode::Hyper,
-            "Turbo" => KeyCode::Turbo,
-            "Abort" => KeyCode::Abort,
-            "Resume" => KeyCode::Resume,
-            "Suspend" => KeyCode::Suspend,
-            "Again" => KeyCode::Again,
-            "Copy" => KeyCode::Copy,
-            "Cut" => KeyCode::Cut,
-            "Find" => KeyCode::Find,
-            "Open" => KeyCode::Open,
-            "Paste" => KeyCode::Paste,
-            "Props" => KeyCode::Props,
-            "Select" => KeyCode::Select,
-            "Undo" => KeyCode::Undo,
-            "Hiragana" => KeyCode::Hiragana,
-            "Katakana" => KeyCode::Katakana,
-            "F1" => KeyCode::F1,
-            "F2" => KeyCode::F2,
-            "F3" => KeyCode::F3,
-            "F4" => KeyCode::F4,
-            "F5" => KeyCode::F5,
-            "F6" => KeyCode::F6,
-            "F7" => KeyCode::F7,
-            "F8" => KeyCode::F8,
-            "F9" => KeyCode::F9,
-            "F10" => KeyCode::F10,
-            "F11" => KeyCode::F11,
-            "F12" => KeyCode::F12,
-            "F13" => KeyCode::F13,
-            "F14" => KeyCode::F14,
-            "F15" => KeyCode::F15,
-            "F16" => KeyCode::F16,
-            "F17" => KeyCode::F17,
-            "F18" => KeyCode::F18,
-            "F19" => KeyCode::F19,
-            "F20" => KeyCode::F20,
-            "F21" => KeyCode::F21,
-            "F22" => KeyCode::F22,
-            "F23" => KeyCode::F23,
-            "F24" => KeyCode::F24,
-            "F25" => KeyCode::F25,
-            "F26" => KeyCode::F26,
-            "F27" => KeyCode::F27,
-            "F28" => KeyCode::F28,
-            "F29" => KeyCode::F29,
-            "F30" => KeyCode::F30,
-            "F31" => KeyCode::F31,
-            "F32" => KeyCode::F32,
-            "F33" => KeyCode::F33,
-            "F34" => KeyCode::F34,
-            "F35" => KeyCode::F35,
-            _ => return PhysicalKey::Unidentified(NativeKeyCode::Unidentified),
-        })
-    }
-}

src/platform_impl/web/mod.rs

@@ -1,48 +0,0 @@
-// Brief introduction to the internals of the Web backend:
-// The Web backend used to support both wasm-bindgen and stdweb as methods of binding to the
-// environment. Because they are both supporting the same underlying APIs, the actual Web bindings
-// are cordoned off into backend abstractions, which present the thinnest unifying layer possible.
-//
-// When adding support for new events or interactions with the browser, first consult trusted
-// documentation (such as MDN) to ensure it is well-standardised and supported across many browsers.
-// Once you have decided on the relevant Web APIs, add support to both backends.
-//
-// The backend is used by the rest of the module to implement Winit's business logic, which forms
-// the rest of the code. 'device', 'error', 'monitor', and 'window' define Web-specific structures
-// for winit's cross-platform structures. They are all relatively simple translations.
-//
-// The event_loop module handles listening for and processing events. 'Proxy' implements
-// EventLoopProxy and 'WindowTarget' implements ActiveEventLoop. WindowTarget also handles
-// registering the event handlers. The 'Execution' struct in the 'runner' module handles taking
-// incoming events (from the registered handlers) and ensuring they are passed to the user in a
-// compliant way.
-
-// TODO: FP, remove when <https://github.com/rust-lang/rust-clippy/issues/12377> is fixed.
-#![allow(clippy::empty_docs)]
-
-mod r#async;
-mod cursor;
-mod error;
-mod event;
-mod event_loop;
-mod keyboard;
-mod lock;
-mod main_thread;
-mod monitor;
-mod web_sys;
-mod window;
-
-pub(crate) use cursor::{
-    CustomCursor as PlatformCustomCursor, CustomCursorFuture,
-    CustomCursorSource as PlatformCustomCursorSource,
-};
-
-pub(crate) use self::event_loop::{
-    ActiveEventLoop, EventLoop, PlatformSpecificEventLoopAttributes,
-};
-pub(crate) use self::monitor::{
-    HasMonitorPermissionFuture, MonitorHandle, MonitorPermissionFuture, OrientationLockFuture,
-};
-use self::web_sys as backend;
-pub use self::window::{PlatformSpecificWindowAttributes, Window};
-pub(crate) use crate::icon::NoIcon as PlatformIcon;

src/platform_impl/windows/mod.rs

@@ -1,129 +0,0 @@
-use windows_sys::Win32::Foundation::HWND;
-use windows_sys::Win32::UI::WindowsAndMessaging::{HMENU, WINDOW_LONG_PTR_INDEX};
-
-pub(crate) use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};
-pub use self::icon::WinIcon as PlatformIcon;
-pub(crate) use self::icon::{SelectedCursor, WinCursor as PlatformCustomCursor, WinIcon};
-pub(crate) use self::keyboard::{physicalkey_to_scancode, scancode_to_physicalkey};
-pub(crate) use self::monitor::MonitorHandle;
-pub(crate) use self::window::Window;
-pub(crate) use crate::cursor::OnlyCursorImageSource as PlatformCustomCursorSource;
-use crate::event::DeviceId;
-use crate::icon::Icon;
-use crate::platform::windows::{BackdropType, Color, CornerPreference};
-use crate::platform_impl::Fullscreen;
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct PlatformSpecificWindowAttributes {
-    pub owner: Option<HWND>,
-    pub menu: Option<HMENU>,
-    pub taskbar_icon: Option<Icon>,
-    pub no_redirection_bitmap: bool,
-    pub drag_and_drop: bool,
-    pub skip_taskbar: bool,
-    pub class_name: String,
-    pub decoration_shadow: bool,
-    pub backdrop_type: BackdropType,
-    pub clip_children: bool,
-    pub border_color: Option<Color>,
-    pub title_background_color: Option<Color>,
-    pub title_text_color: Option<Color>,
-    pub corner_preference: Option<CornerPreference>,
-}
-
-impl Default for PlatformSpecificWindowAttributes {
-    fn default() -> Self {
-        Self {
-            owner: None,
-            menu: None,
-            taskbar_icon: None,
-            no_redirection_bitmap: false,
-            drag_and_drop: true,
-            skip_taskbar: false,
-            class_name: "Window Class".to_string(),
-            decoration_shadow: false,
-            backdrop_type: BackdropType::default(),
-            clip_children: true,
-            border_color: None,
-            title_background_color: None,
-            title_text_color: None,
-            corner_preference: None,
-        }
-    }
-}
-
-unsafe impl Send for PlatformSpecificWindowAttributes {}
-unsafe impl Sync for PlatformSpecificWindowAttributes {}
-
-fn wrap_device_id(id: u32) -> DeviceId {
-    DeviceId::from_raw(id as i64)
-}
-
-#[inline(always)]
-const fn get_xbutton_wparam(x: u32) -> u16 {
-    hiword(x)
-}
-
-#[inline(always)]
-const fn get_x_lparam(x: u32) -> i16 {
-    loword(x) as _
-}
-
-#[inline(always)]
-const fn get_y_lparam(x: u32) -> i16 {
-    hiword(x) as _
-}
-
-#[inline(always)]
-pub(crate) const fn primarylangid(lgid: u16) -> u16 {
-    lgid & 0x3ff
-}
-
-#[inline(always)]
-pub(crate) const fn loword(x: u32) -> u16 {
-    (x & 0xffff) as u16
-}
-
-#[inline(always)]
-const fn hiword(x: u32) -> u16 {
-    ((x >> 16) & 0xffff) as u16
-}
-
-#[inline(always)]
-unsafe fn get_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX) -> isize {
-    #[cfg(target_pointer_width = "64")]
-    return unsafe { windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW(hwnd, nindex) };
-    #[cfg(target_pointer_width = "32")]
-    return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongW(hwnd, nindex) as isize
-    };
-}
-
-#[inline(always)]
-unsafe fn set_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX, dwnewlong: isize) -> isize {
-    #[cfg(target_pointer_width = "64")]
-    return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW(hwnd, nindex, dwnewlong)
-    };
-    #[cfg(target_pointer_width = "32")]
-    return unsafe {
-        windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongW(hwnd, nindex, dwnewlong as i32)
-            as isize
-    };
-}
-
-#[macro_use]
-mod util;
-mod dark_mode;
-mod definitions;
-mod dpi;
-mod drop_handler;
-mod event_loop;
-mod icon;
-mod ime;
-mod keyboard;
-mod keyboard_layout;
-mod monitor;
-pub(crate) mod raw_input;
-mod window;
-mod window_state;

src/utils.rs

@@ -1,46 +0,0 @@
-// A poly-fill for `lazy_cell`
-// Replace with std::sync::LazyLock when https://github.com/rust-lang/rust/issues/109736 is stabilized.
-
-// This isn't used on every platform, which can come up as dead code warnings.
-#![allow(dead_code)]
-
-use std::any::Any;
-use std::ops::Deref;
-use std::sync::OnceLock;
-
-pub(crate) struct Lazy<T> {
-    cell: OnceLock<T>,
-    init: fn() -> T,
-}
-
-impl<T> Lazy<T> {
-    pub const fn new(f: fn() -> T) -> Self {
-        Self { cell: OnceLock::new(), init: f }
-    }
-}
-
-impl<T> Deref for Lazy<T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &'_ T {
-        self.cell.get_or_init(self.init)
-    }
-}
-
-pub trait AsAny {
-    fn as_any(&self) -> &dyn Any;
-    fn as_any_mut(&mut self) -> &mut dyn Any;
-}
-
-impl<T: Any> AsAny for T {
-    #[inline(always)]
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    #[inline(always)]
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-}

winit-android/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+description = "Winit's Android backend"
+documentation = "https://docs.rs/winit-android"
+edition.workspace = true
+license.workspace = true
+name = "winit-android"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+game-activity = ["android-activity/game-activity"]
+native-activity = ["android-activity/native-activity"]
+serde = ["dep:serde", "bitflags/serde", "smol_str/serde", "dpi/serde", "winit-core/serde"]
+
+[dependencies]
+bitflags.workspace = true
+dpi.workspace = true
+rwh_06.workspace = true
+serde = { workspace = true, optional = true }
+smol_str.workspace = true
+tracing.workspace = true
+winit-core.workspace = true
+
+# Platform-specific
+[target.'cfg(target_os = "android")'.dependencies]
+android-activity.workspace = true
+ndk.workspace = true
+
+[dev-dependencies]
+winit.workspace = true
+
+[package.metadata.docs.rs]
+features = ["serde", "native-activity"]
+targets = ["aarch64-linux-android"]

winit-android/LICENSE

@@ -0,0 +1 @@
+../LICENSE

winit-android/README.md

@@ -0,0 +1 @@
+../README.md

winit-android/src/event_loop.rs

@@ -1,4 +1,5 @@
 use std::cell::Cell;
+use std::fmt;
 use std::hash::Hash;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
@@ -8,32 +9,26 @@ use android_activity::input::{InputEvent, KeyAction, Keycode, MotionAction};
 use android_activity::{
     AndroidApp, AndroidAppWaker, ConfigurationRef, InputStatus, MainEvent, Rect,
 };
+use dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
 use tracing::{debug, trace, warn};
-
-use crate::application::ApplicationHandler;
-use crate::cursor::Cursor;
-use crate::dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
-use crate::error::{EventLoopError, NotSupportedError, RequestError};
-use crate::event::{self, DeviceId, FingerId, Force, StartCause, SurfaceSizeWriter};
-use crate::event_loop::{
+use winit_core::application::ApplicationHandler;
+use winit_core::cursor::{Cursor, CustomCursor, CustomCursorSource};
+use winit_core::error::{EventLoopError, NotSupportedError, RequestError};
+use winit_core::event::{self, DeviceId, FingerId, Force, StartCause, SurfaceSizeWriter};
+use winit_core::event_loop::pump_events::PumpStatus;
+use winit_core::event_loop::{
     ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
     EventLoopProxy as CoreEventLoopProxy, EventLoopProxyProvider,
     OwnedDisplayHandle as CoreOwnedDisplayHandle,
 };
-use crate::monitor::{MonitorHandle as RootMonitorHandle, VideoMode};
-use crate::platform::pump_events::PumpStatus;
-use crate::window::{
-    self, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, ImePurpose,
+use winit_core::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
+use winit_core::window::{
+    self, CursorGrabMode, ImeCapabilities, ImePurpose, ImeRequest, ImeRequestError,
     ResizeDirection, Theme, Window as CoreWindow, WindowAttributes, WindowButtons, WindowId,
     WindowLevel,
 };
 
-mod keycodes;
-
-pub(crate) use crate::cursor::{
-    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
-};
-pub(crate) use crate::icon::NoIcon as PlatformIcon;
+use crate::keycodes;
 
 static HAS_FOCUS: AtomicBool = AtomicBool::new(true);
 
@@ -44,16 +39,17 @@ fn min_timeout(a: Option<Duration>, b: Option<Duration>) -> Option<Duration> {
     a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
 }
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 struct SharedFlagSetter {
     flag: Arc<AtomicBool>,
 }
 impl SharedFlagSetter {
-    pub fn set(&self) -> bool {
+    fn set(&self) -> bool {
         self.flag.compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed).is_ok()
     }
 }
 
+#[derive(Debug)]
 struct SharedFlag {
     flag: Arc<AtomicBool>,
 }
@@ -63,31 +59,37 @@ struct SharedFlag {
 // we just need to know at the start of a main loop iteration if a redraw
 // was queued and be able to read and clear the state atomically)
 impl SharedFlag {
-    pub fn new() -> Self {
+    fn new() -> Self {
         Self { flag: Arc::new(AtomicBool::new(false)) }
     }
 
-    pub fn setter(&self) -> SharedFlagSetter {
+    fn setter(&self) -> SharedFlagSetter {
         SharedFlagSetter { flag: self.flag.clone() }
     }
 
-    pub fn get_and_reset(&self) -> bool {
+    fn get_and_reset(&self) -> bool {
         self.flag.swap(false, std::sync::atomic::Ordering::AcqRel)
     }
 }
 
 #[derive(Clone)]
-pub struct RedrawRequester {
+struct RedrawRequester {
     flag: SharedFlagSetter,
     waker: AndroidAppWaker,
 }
 
+impl fmt::Debug for RedrawRequester {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("RedrawRequester").field("flag", &self.flag).finish_non_exhaustive()
+    }
+}
+
 impl RedrawRequester {
     fn new(flag: &SharedFlag, waker: AndroidAppWaker) -> Self {
         RedrawRequester { flag: flag.setter(), waker }
     }
 
-    pub fn request_redraw(&self) {
+    fn request_redraw(&self) {
         if self.flag.set() {
             // Only explicitly try to wake up the main loop when the flag
             // value changes
@@ -96,8 +98,9 @@ impl RedrawRequester {
     }
 }
 
+#[derive(Debug)]
 pub struct EventLoop {
-    pub(crate) android_app: AndroidApp,
+    pub android_app: AndroidApp,
     window_target: ActiveEventLoop,
     redraw_flag: SharedFlag,
     loop_running: bool, // Dispatched `NewEvents<Init>`
@@ -110,9 +113,9 @@ pub struct EventLoop {
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PlatformSpecificEventLoopAttributes {
-    pub(crate) android_app: Option<AndroidApp>,
-    pub(crate) ignore_volume_keys: bool,
+pub struct PlatformSpecificEventLoopAttributes {
+    pub android_app: Option<AndroidApp>,
+    pub ignore_volume_keys: bool,
 }
 
 impl Default for PlatformSpecificEventLoopAttributes {
@@ -125,9 +128,13 @@ impl Default for PlatformSpecificEventLoopAttributes {
 const GLOBAL_WINDOW: WindowId = WindowId::from_raw(0);
 
 impl EventLoop {
-    pub(crate) fn new(
-        attributes: &PlatformSpecificEventLoopAttributes,
-    ) -> Result<Self, EventLoopError> {
+    pub fn new(attributes: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
+        static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
+        if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
+            // For better cross-platformness.
+            return Err(EventLoopError::RecreationAttempt);
+        }
+
         let android_app = attributes.android_app.as_ref().expect(
             "An `AndroidApp` as passed to android_main() is required to create an `EventLoop` on \
              Android",
@@ -157,7 +164,7 @@ impl EventLoop {
         })
     }
 
-    pub(crate) fn window_target(&self) -> &dyn RootActiveEventLoop {
+    pub fn window_target(&self) -> &dyn RootActiveEventLoop {
         &self.window_target
     }
 
@@ -466,16 +473,23 @@ impl EventLoop {
                             &mut self.combining_accent,
                         );
 
+                        let logical_key = keycodes::to_logical(key_char, keycode);
+                        let text = if state == event::ElementState::Pressed {
+                            logical_key.to_text().map(smol_str::SmolStr::new)
+                        } else {
+                            None
+                        };
+
                         let event = event::WindowEvent::KeyboardInput {
                             device_id: Some(DeviceId::from_raw(key.device_id() as i64)),
                             event: event::KeyEvent {
                                 state,
                                 physical_key: keycodes::to_physical_key(keycode),
-                                logical_key: keycodes::to_logical(key_char, keycode),
+                                logical_key,
                                 location: keycodes::to_location(keycode),
                                 repeat: key.repeat_count() > 0,
-                                text: None,
-                                text_with_all_modifiers: None,
+                                text: text.clone(),
+                                text_with_all_modifiers: text,
                                 key_without_modifiers: keycodes::to_logical(key_char, keycode),
                             },
                             is_synthetic: false,
@@ -493,10 +507,6 @@ impl EventLoop {
         input_status
     }
 
-    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
-    }
-
     pub fn run_app_on_demand<A: ApplicationHandler>(
         &mut self,
         mut app: A,
@@ -543,8 +553,6 @@ impl EventLoop {
         if self.exiting() {
             self.loop_running = false;
 
-            app.exiting(&self.window_target);
-
             PumpStatus::Exit(0)
         } else {
             PumpStatus::Continue
@@ -639,6 +647,12 @@ pub struct EventLoopProxy {
     waker: AndroidAppWaker,
 }
 
+impl fmt::Debug for EventLoopProxy {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("EventLoopProxy").field("wake_up", &self.wake_up).finish_non_exhaustive()
+    }
+}
+
 impl EventLoopProxy {
     fn new(waker: AndroidAppWaker) -> Self {
         Self { wake_up: AtomicBool::new(false), waker }
@@ -652,6 +666,7 @@ impl EventLoopProxyProvider for EventLoopProxy {
     }
 }
 
+#[derive(Debug)]
 pub struct ActiveEventLoop {
     pub(crate) app: AndroidApp,
     control_flow: Cell<ControlFlow>,
@@ -685,11 +700,11 @@ impl RootActiveEventLoop for ActiveEventLoop {
         Err(NotSupportedError::new("create_custom_cursor is not supported").into())
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         Box::new(std::iter::empty())
     }
 
-    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
         None
     }
 
@@ -744,8 +759,10 @@ impl rwh_06::HasDisplayHandle for OwnedDisplayHandle {
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub struct PlatformSpecificWindowAttributes;
 
-pub(crate) struct Window {
+#[derive(Debug)]
+pub struct Window {
     app: AndroidApp,
+    ime_capabilities: Mutex<Option<ImeCapabilities>>,
     redraw_requester: RedrawRequester,
 }
 
@@ -756,14 +773,18 @@ impl Window {
     ) -> Result<Self, RequestError> {
         // FIXME this ignores requested window attributes
 
-        Ok(Self { app: el.app.clone(), redraw_requester: el.redraw_requester.clone() })
+        Ok(Self {
+            app: el.app.clone(),
+            ime_capabilities: Default::default(),
+            redraw_requester: el.redraw_requester.clone(),
+        })
     }
 
-    pub fn config(&self) -> ConfigurationRef {
+    pub(crate) fn config(&self) -> ConfigurationRef {
         self.app.config()
     }
 
-    pub fn content_rect(&self) -> Rect {
+    pub(crate) fn content_rect(&self) -> Rect {
         self.app.content_rect()
     }
 
@@ -808,15 +829,15 @@ impl CoreWindow for Window {
         GLOBAL_WINDOW
     }
 
-    fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+    fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
         None
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         Box::new(std::iter::empty())
     }
 
-    fn current_monitor(&self) -> Option<RootMonitorHandle> {
+    fn current_monitor(&self) -> Option<CoreMonitorHandle> {
         None
     }
 
@@ -920,16 +941,37 @@ impl CoreWindow for Window {
 
     fn set_window_level(&self, _level: WindowLevel) {}
 
-    fn set_window_icon(&self, _window_icon: Option<crate::icon::Icon>) {}
+    fn set_window_icon(&self, _window_icon: Option<winit_core::icon::Icon>) {}
 
     fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}
 
-    fn set_ime_allowed(&self, allowed: bool) {
-        if allowed {
-            self.app.show_soft_input(true);
-        } else {
-            self.app.hide_soft_input(true);
+    fn request_ime_update(&self, request: ImeRequest) -> Result<(), ImeRequestError> {
+        let mut current_caps = self.ime_capabilities.lock().unwrap();
+        match request {
+            ImeRequest::Enable(enable) => {
+                let (capabilities, _) = enable.into_raw();
+                if current_caps.is_some() {
+                    return Err(ImeRequestError::AlreadyEnabled);
+                }
+                *current_caps = Some(capabilities);
+                self.app.show_soft_input(true);
+            },
+            ImeRequest::Update(_) => {
+                if current_caps.is_none() {
+                    return Err(ImeRequestError::NotEnabled);
+                }
+            },
+            ImeRequest::Disable => {
+                *current_caps = None;
+                self.app.hide_soft_input(true);
+            },
         }
+
+        Ok(())
+    }
+
+    fn ime_capabilities(&self) -> Option<ImeCapabilities> {
+        *self.ime_capabilities.lock().unwrap()
     }
 
     fn set_ime_purpose(&self, _purpose: ImePurpose) {}
@@ -992,41 +1034,6 @@ impl CoreWindow for Window {
     }
 }
 
-#[derive(Default, Clone, Debug)]
-pub struct OsError;
-
-use std::fmt::{self, Display, Formatter};
-impl Display for OsError {
-    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), fmt::Error> {
-        write!(fmt, "Android OS Error")
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct MonitorHandle;
-
-impl MonitorHandle {
-    pub fn name(&self) -> Option<String> {
-        unreachable!()
-    }
-
-    pub fn position(&self) -> Option<PhysicalPosition<i32>> {
-        unreachable!()
-    }
-
-    pub fn scale_factor(&self) -> f64 {
-        unreachable!()
-    }
-
-    pub fn current_video_mode(&self) -> Option<VideoMode> {
-        unreachable!()
-    }
-
-    pub fn video_modes(&self) -> std::iter::Empty<VideoMode> {
-        unreachable!()
-    }
-}
-
 fn screen_size(app: &AndroidApp) -> PhysicalSize<u32> {
     if let Some(native_window) = app.native_window() {
         PhysicalSize::new(native_window.width() as _, native_window.height() as _)

winit-android/src/keycodes.rs

@@ -1,7 +1,8 @@
-use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
 use android_activity::AndroidApp;
-
-use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
+use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
+use winit_core::keyboard::{
+    Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey,
+};
 
 pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
     PhysicalKey::Code(match keycode {
@@ -108,6 +109,7 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         Keycode::MediaStop => KeyCode::MediaStop,
         Keycode::MediaNext => KeyCode::MediaTrackNext,
         Keycode::MediaPrevious => KeyCode::MediaTrackPrevious,
+        Keycode::MediaEject => KeyCode::Eject,
 
         Keycode::Plus => KeyCode::Equal,
         Keycode::Minus => KeyCode::Minus,
@@ -130,7 +132,11 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         // These are exactly the same
         Keycode::ScrollLock => KeyCode::ScrollLock,
 
+        Keycode::Eisu => KeyCode::Lang2,
+        Keycode::Muhenkan => KeyCode::NonConvert,
+        Keycode::Henkan => KeyCode::Convert,
         Keycode::Yen => KeyCode::IntlYen,
+        Keycode::Ro => KeyCode::IntlRo,
         Keycode::Kana => KeyCode::Lang1,
         Keycode::KatakanaHiragana => KeyCode::KanaMode,
 
@@ -143,8 +149,8 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         Keycode::AltLeft => KeyCode::AltLeft,
         Keycode::AltRight => KeyCode::AltRight,
 
-        Keycode::MetaLeft => KeyCode::SuperLeft,
-        Keycode::MetaRight => KeyCode::SuperRight,
+        Keycode::MetaLeft => KeyCode::MetaLeft,
+        Keycode::MetaRight => KeyCode::MetaRight,
 
         Keycode::LeftBracket => KeyCode::BracketLeft,
         Keycode::RightBracket => KeyCode::BracketRight,
@@ -153,6 +159,14 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         Keycode::Sleep => KeyCode::Sleep, // what about SoftSleep?
         Keycode::Wakeup => KeyCode::WakeUp,
 
+        Keycode::CapsLock => KeyCode::CapsLock,
+        Keycode::Help => KeyCode::Help,
+
+        Keycode::Back => KeyCode::BrowserBack,
+        Keycode::Forward => KeyCode::BrowserForward,
+        Keycode::Refresh => KeyCode::BrowserRefresh,
+        Keycode::Search => KeyCode::BrowserSearch,
+
         keycode => return PhysicalKey::Unidentified(NativeKeyCode::Android(keycode.into())),
     })
 }
@@ -309,7 +323,7 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
             ShiftLeft => Key::Named(NamedKey::Shift),
             ShiftRight => Key::Named(NamedKey::Shift),
             Tab => Key::Named(NamedKey::Tab),
-            Space => Key::Named(NamedKey::Space),
+            Space => Key::Character(" ".into()),
             Sym => Key::Named(NamedKey::Symbol),
             Explorer => Key::Named(NamedKey::LaunchWebBrowser),
             Envelope => Key::Named(NamedKey::LaunchMail),
@@ -340,8 +354,8 @@ pub fn to_logical(key_char: Option<KeyMapChar>, keycode: Keycode) -> Key {
             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),
+            MetaLeft => Key::Named(NamedKey::Meta),
+            MetaRight => Key::Named(NamedKey::Meta),
             Function => Key::Named(NamedKey::Fn),
             Sysrq => Key::Named(NamedKey::PrintScreen),
             Break => Key::Named(NamedKey::Pause),

winit-android/src/lib.rs

@@ -62,17 +62,26 @@
 //! 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.9",
-//!    features = [ "android-native-activity" ] }`
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version =
+//!    "0.31.0-beta.2", 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).
+#![cfg(target_os = "android")]
+
+mod event_loop;
+mod keycodes;
+
+use winit_core::event_loop::ActiveEventLoop as CoreActiveEventLoop;
+use winit_core::window::Window as CoreWindow;
 
 use self::activity::{AndroidApp, ConfigurationRef, Rect};
-use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
-use crate::window::{Window, WindowAttributes};
+pub use crate::event_loop::{
+    ActiveEventLoop, EventLoop, EventLoopProxy, PlatformSpecificEventLoopAttributes,
+    PlatformSpecificWindowAttributes, Window,
+};
 
 /// Additional methods on [`EventLoop`] that are specific to Android.
 pub trait EventLoopExtAndroid {
@@ -80,12 +89,6 @@ pub trait EventLoopExtAndroid {
     fn android_app(&self) -> &AndroidApp;
 }
 
-impl EventLoopExtAndroid for EventLoop {
-    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.
@@ -99,31 +102,25 @@ pub trait WindowExtAndroid {
     fn config(&self) -> ConfigurationRef;
 }
 
-impl WindowExtAndroid for dyn Window + '_ {
+impl WindowExtAndroid for dyn CoreWindow + '_ {
     fn content_rect(&self) -> Rect {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<Window>().unwrap();
         window.content_rect()
     }
 
     fn config(&self) -> ConfigurationRef {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<Window>().unwrap();
         window.config()
     }
 }
 
-impl ActiveEventLoopExtAndroid for dyn ActiveEventLoop + '_ {
+impl ActiveEventLoopExtAndroid for dyn CoreActiveEventLoop + '_ {
     fn android_app(&self) -> &AndroidApp {
-        let event_loop =
-            self.as_any().downcast_ref::<crate::platform_impl::ActiveEventLoop>().unwrap();
+        let event_loop = self.cast_ref::<ActiveEventLoop>().unwrap();
         &event_loop.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
     ///
@@ -136,18 +133,6 @@ pub trait EventLoopBuilderExtAndroid {
     fn handle_volume_keys(&mut self) -> &mut Self;
 }
 
-impl EventLoopBuilderExtAndroid for EventLoopBuilder {
-    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
@@ -176,16 +161,5 @@ pub mod activity {
     // 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;
 }

winit-appkit/Cargo.toml

@@ -0,0 +1,117 @@
+[package]
+description = "Winit's Appkit / macOS backend"
+documentation = "https://docs.rs/winit-appkit"
+edition.workspace = true
+license.workspace = true
+name = "winit-appkit"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+serde = ["dep:serde", "bitflags/serde", "smol_str/serde", "dpi/serde"]
+
+[dependencies]
+bitflags.workspace = true
+dpi.workspace = true
+rwh_06.workspace = true
+serde = { workspace = true, optional = true }
+smol_str.workspace = true
+tracing.workspace = true
+winit-core.workspace = true
+
+# Platform-specific
+[target.'cfg(target_vendor = "apple")'.dependencies]
+block2.workspace = true
+dispatch2 = { workspace = true, features = ["std", "objc2"] }
+objc2.workspace = true
+objc2-app-kit = { workspace = true, features = [
+    "std",
+    "objc2-core-foundation",
+    "NSAppearance",
+    "NSApplication",
+    "NSBitmapImageRep",
+    "NSButton",
+    "NSColor",
+    "NSControl",
+    "NSCursor",
+    "NSDragging",
+    "NSEvent",
+    "NSGraphics",
+    "NSGraphicsContext",
+    "NSImage",
+    "NSImageRep",
+    "NSMenu",
+    "NSMenuItem",
+    "NSOpenGLView",
+    "NSPanel",
+    "NSPasteboard",
+    "NSResponder",
+    "NSRunningApplication",
+    "NSScreen",
+    "NSTextInputClient",
+    "NSTextInputContext",
+    "NSTrackingArea",
+    "NSToolbar",
+    "NSView",
+    "NSWindow",
+    "NSWindowScripting",
+    "NSWindowTabGroup",
+] }
+objc2-core-foundation = { workspace = true, features = [
+    "std",
+    "block2",
+    "CFBase",
+    "CFCGTypes",
+    "CFData",
+    "CFRunLoop",
+    "CFString",
+    "CFUUID",
+] }
+objc2-core-graphics = { workspace = true, features = [
+    "std",
+    "libc",
+    "CGDirectDisplay",
+    "CGDisplayConfiguration",
+    "CGDisplayFade",
+    "CGError",
+    "CGRemoteOperation",
+    "CGWindowLevel",
+] }
+objc2-core-video = { workspace = true, features = [
+    "std",
+    "objc2-core-graphics",
+    "CVBase",
+    "CVReturn",
+    "CVDisplayLink",
+] }
+objc2-foundation = { workspace = true, features = [
+    "std",
+    "block2",
+    "objc2-core-foundation",
+    "NSArray",
+    "NSAttributedString",
+    "NSData",
+    "NSDictionary",
+    "NSDistributedNotificationCenter",
+    "NSEnumerator",
+    "NSGeometry",
+    "NSKeyValueObserving",
+    "NSNotification",
+    "NSObjCRuntime",
+    "NSOperation",
+    "NSPathUtilities",
+    "NSProcessInfo",
+    "NSRunLoop",
+    "NSString",
+    "NSThread",
+    "NSValue",
+] }
+winit-common = { workspace = true, features = ["core-foundation", "event-handler", "foundation"] }
+
+[dev-dependencies]
+winit.workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
+targets = ["aarch64-apple-darwin", "x86_64-apple-darwin"]

winit-appkit/LICENSE

@@ -0,0 +1 @@
+../LICENSE

winit-appkit/README.md

@@ -0,0 +1 @@
+../README.md

winit-appkit/src/app.rs

@@ -1,17 +1,18 @@
 #![allow(clippy::unnecessary_cast)]
 
 use std::cell::Cell;
-use std::mem;
 use std::rc::Rc;
+use std::{mem, ptr};
 
 use dispatch2::MainThreadBound;
 use objc2::runtime::{Imp, Sel};
 use objc2::sel;
 use objc2_app_kit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType};
 use objc2_foundation::MainThreadMarker;
+use tracing::trace_span;
+use winit_core::event::{DeviceEvent, ElementState};
 
 use super::app_state::AppState;
-use crate::event::{DeviceEvent, ElementState};
 
 type SendEvent = extern "C-unwind" fn(&NSApplication, Sel, &NSEvent);
 
@@ -21,6 +22,10 @@ static ORIGINAL: MainThreadBound<Cell<Option<SendEvent>>> = {
 };
 
 extern "C-unwind" fn send_event(app: &NSApplication, sel: Sel, event: &NSEvent) {
+    // This can be a bit noisy, since `event` is fairly large. Note that you can use
+    // `RUST_LOG='trace,winit_appkit::app=warn'` if you're debugging and want TRACE-level logs but
+    // not this.
+    let _entered = trace_span!("sendEvent:", ?event).entered();
     let mtm = MainThreadMarker::from(app);
 
     // Normally, holding Cmd + any key never sends us a `keyUp` event for that key.
@@ -30,8 +35,8 @@ extern "C-unwind" fn send_event(app: &NSApplication, sel: Sel, event: &NSEvent)
     // For posterity, there are some undocumented event types
     // (https://github.com/servo/cocoa-rs/issues/155)
     // but that doesn't really matter here.
-    let event_type = unsafe { event.r#type() };
-    let modifier_flags = unsafe { event.modifierFlags() };
+    let event_type = event.r#type();
+    let modifier_flags = event.modifierFlags();
     if event_type == NSEventType::KeyUp && modifier_flags.contains(NSEventModifierFlags::Command) {
         if let Some(key_window) = app.keyWindow() {
             key_window.sendEvent(event);
@@ -75,9 +80,7 @@ pub(crate) fn override_send_event(global_app: &NSApplication) {
     let overridden = unsafe { mem::transmute::<SendEvent, Imp>(send_event) };
 
     // If we've already overridden the method, don't do anything.
-    // FIXME(madsmtm): Use `std::ptr::fn_addr_eq` (Rust 1.85) once available in MSRV.
-    #[allow(unknown_lints, unpredictable_function_pointer_comparisons)]
-    if overridden == method.implementation() {
+    if ptr::fn_addr_eq(overridden, method.implementation()) {
         return;
     }
 
@@ -98,15 +101,15 @@ pub(crate) fn override_send_event(global_app: &NSApplication) {
 }
 
 fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
-    let event_type = unsafe { event.r#type() };
+    let event_type = event.r#type();
     #[allow(non_upper_case_globals)]
     match event_type {
         NSEventType::MouseMoved
         | NSEventType::LeftMouseDragged
         | NSEventType::OtherMouseDragged
         | NSEventType::RightMouseDragged => {
-            let delta_x = unsafe { event.deltaX() } as f64;
-            let delta_y = unsafe { event.deltaY() } as f64;
+            let delta_x = event.deltaX() as f64;
+            let delta_y = event.deltaY() as f64;
 
             if delta_x != 0.0 || delta_y != 0.0 {
                 app_state.maybe_queue_with_handler(move |app, event_loop| {
@@ -117,7 +120,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
             }
         },
         NSEventType::LeftMouseDown | NSEventType::RightMouseDown | NSEventType::OtherMouseDown => {
-            let button = unsafe { event.buttonNumber() } as u32;
+            let button = event.buttonNumber() as u32;
             app_state.maybe_queue_with_handler(move |app, event_loop| {
                 app.device_event(event_loop, None, DeviceEvent::Button {
                     button,
@@ -126,7 +129,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
             });
         },
         NSEventType::LeftMouseUp | NSEventType::RightMouseUp | NSEventType::OtherMouseUp => {
-            let button = unsafe { event.buttonNumber() } as u32;
+            let button = event.buttonNumber() as u32;
             app_state.maybe_queue_with_handler(move |app, event_loop| {
                 app.device_event(event_loop, None, DeviceEvent::Button {
                     button,
@@ -141,7 +144,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
 #[cfg(test)]
 mod tests {
     use objc2::rc::Retained;
-    use objc2::{define_class, msg_send, ClassType};
+    use objc2::{ClassType, define_class, msg_send};
     use objc2_app_kit::NSResponder;
     use objc2_foundation::NSObject;
 
@@ -153,16 +156,14 @@ mod tests {
         let Some(mtm) = MainThreadMarker::new() else { return };
 
         // Create a new application, without making it the shared application.
-        let app = unsafe { NSApplication::new(mtm) };
+        let app = NSApplication::new(mtm);
         override_send_event(&app);
         // Test calling twice works.
         override_send_event(&app);
 
         // FIXME(madsmtm): Can't test this yet, need some way to mock AppState.
-        // unsafe {
-        //     let event = super::super::event::dummy_event().unwrap();
-        //     app.sendEvent(&event)
-        // }
+        // let event = super::super::event::dummy_event().unwrap();
+        // app.sendEvent(&event)
     }
 
     #[test]

winit-appkit/src/app_state.rs

@@ -8,16 +8,16 @@ use dispatch2::MainThreadBound;
 use objc2::MainThreadMarker;
 use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSRunningApplication};
 use objc2_foundation::NSNotification;
+use winit_common::core_foundation::{EventLoopProxy, MainRunLoop};
+use winit_common::event_handler::EventHandler;
+use winit_core::application::ApplicationHandler;
+use winit_core::event::{StartCause, WindowEvent};
+use winit_core::event_loop::ControlFlow;
+use winit_core::window::WindowId;
 
-use super::super::event_handler::EventHandler;
-use super::super::event_loop_proxy::EventLoopProxy;
-use super::event_loop::{stop_app_immediately, ActiveEventLoop};
+use super::event_loop::{ActiveEventLoop, notify_windows_of_exit, stop_app_immediately};
 use super::menu;
-use super::observer::{EventLoopWaker, RunLoop};
-use crate::application::ApplicationHandler;
-use crate::event::{StartCause, WindowEvent};
-use crate::event_loop::ControlFlow;
-use crate::window::WindowId;
+use super::observer::EventLoopWaker;
 
 #[derive(Debug)]
 pub(super) struct AppState {
@@ -25,16 +25,23 @@ pub(super) struct AppState {
     activation_policy: Option<NSApplicationActivationPolicy>,
     default_menu: bool,
     activate_ignoring_other_apps: bool,
-    run_loop: RunLoop,
+    run_loop: MainRunLoop,
     event_loop_proxy: Arc<EventLoopProxy>,
     event_handler: EventHandler,
-    /// Whether `NSApplicationDidFinishLaunchingNotification` has been sent.
+    stop_on_launch: Cell<bool>,
+    stop_before_wait: Cell<bool>,
+    stop_after_wait: Cell<bool>,
+    stop_on_redraw: Cell<bool>,
+    /// Whether `applicationDidFinishLaunching:` has been run or not.
     is_launched: Cell<bool>,
+    /// Whether an `EventLoop` is currently running.
+    is_running: Cell<bool>,
     /// Whether the user has requested the event loop to exit.
     exit: Cell<bool>,
     control_flow: Cell<ControlFlow>,
     waker: RefCell<EventLoopWaker>,
     start_time: Cell<Option<Instant>>,
+    wait_timeout: Cell<Option<Instant>>,
     pending_redraw: RefCell<Vec<WindowId>>,
     // NOTE: This is strongly referenced by our `NSWindowDelegate` and our `NSView` subclass, and
     // as such should be careful to not add fields that, in turn, strongly reference those.
@@ -51,7 +58,7 @@ impl AppState {
         activation_policy: Option<NSApplicationActivationPolicy>,
         default_menu: bool,
         activate_ignoring_other_apps: bool,
-    ) -> Rc<Self> {
+    ) -> Option<Rc<Self>> {
         let event_loop_proxy = Arc::new(EventLoopProxy::new(mtm, move || {
             Self::get(mtm).with_handler(|app, event_loop| app.proxy_wake_up(event_loop));
         }));
@@ -61,19 +68,24 @@ impl AppState {
             activation_policy,
             default_menu,
             activate_ignoring_other_apps,
-            run_loop: RunLoop::main(mtm),
+            run_loop: MainRunLoop::get(mtm),
             event_loop_proxy,
             event_handler: EventHandler::new(),
+            stop_on_launch: Cell::new(false),
+            stop_before_wait: Cell::new(false),
+            stop_after_wait: Cell::new(false),
+            stop_on_redraw: Cell::new(false),
             is_launched: Cell::new(false),
+            is_running: Cell::new(false),
             exit: Cell::new(false),
             control_flow: Cell::new(ControlFlow::default()),
             waker: RefCell::new(EventLoopWaker::new()),
             start_time: Cell::new(None),
+            wait_timeout: Cell::new(None),
             pending_redraw: RefCell::new(vec![]),
         });
 
-        GLOBAL.get(mtm).set(this.clone()).expect("application state can only be set once");
-        this
+        GLOBAL.get(mtm).set(this.clone()).ok().and(Some(this))
     }
 
     pub fn get(mtm: MainThreadMarker) -> Rc<Self> {
@@ -84,17 +96,14 @@ impl AppState {
             .clone()
     }
 
+    // NOTE: This notification will, globally, only be emitted once,
+    // no matter how many `EventLoop`s the user creates.
     pub fn did_finish_launching(self: &Rc<Self>, _notification: &NSNotification) {
-        trace_scope!("NSApplicationDidFinishLaunchingNotification");
-        // NOTE: This notification will, globally, only be emitted once,
-        // no matter how many `EventLoop`s the user creates. There is no other
-        // way to know this information, other than to keep track of it
-        // ourselves.
         self.is_launched.set(true);
 
         let app = NSApplication::sharedApplication(self.mtm);
-        // We need to delay setting the activation policy and activating the app until
-        // `NSApplicationDidFinishLaunchingNotification` has been sent. Otherwise the
+        // We need to delay setting the activation policy and activating the app
+        // until `applicationDidFinishLaunching` has been called. Otherwise the
         // menu bar is initially unresponsive on macOS 10.15.
         if let Some(activation_policy) = self.activation_policy {
             app.setActivationPolicy(activation_policy);
@@ -107,7 +116,7 @@ impl AppState {
             // - https://github.com/rust-windowing/winit/issues/261
             // - https://github.com/rust-windowing/winit/issues/3958
             let is_bundled =
-                unsafe { NSRunningApplication::currentApplication().bundleIdentifier().is_some() };
+                NSRunningApplication::currentApplication().bundleIdentifier().is_some();
             if !is_bundled {
                 app.setActivationPolicy(NSApplicationActivationPolicy::Regular);
             }
@@ -124,12 +133,29 @@ impl AppState {
 
         self.waker.borrow_mut().start();
 
+        self.set_is_running(true);
         self.dispatch_init_events();
+
+        // If the application is being launched via `EventLoop::pump_app_events()` then we'll
+        // want to stop the app once it is launched (and return to the external loop)
+        //
+        // In this case we still want to consider Winit's `EventLoop` to be "running",
+        // so we call `start_running()` above.
+        if self.stop_on_launch.get() {
+            // NOTE: the original idea had been to only stop the underlying `RunLoop`
+            // for the app but that didn't work as expected (`-[NSApplication run]`
+            // effectively ignored the attempt to stop the RunLoop and re-started it).
+            //
+            // So we return from `pump_events` by stopping the application.
+            let app = NSApplication::sharedApplication(self.mtm);
+            stop_app_immediately(&app);
+        }
     }
 
     pub fn will_terminate(self: &Rc<Self>, _notification: &NSNotification) {
-        trace_scope!("NSApplicationWillTerminateNotification");
-        // TODO: Notify every window that it will be destroyed, like done in iOS?
+        let app = NSApplication::sharedApplication(self.mtm);
+        notify_windows_of_exit(&app);
+        self.event_handler.terminate();
         self.internal_exit();
     }
 
@@ -137,26 +163,63 @@ impl AppState {
     /// of the given closure.
     pub fn set_event_handler<R>(
         &self,
-        handler: &mut dyn ApplicationHandler,
+        handler: impl ApplicationHandler,
         closure: impl FnOnce() -> R,
     ) -> R {
-        self.event_handler.set(handler, closure)
+        self.event_handler.set(Box::new(handler), closure)
     }
 
     pub fn event_loop_proxy(&self) -> &Arc<EventLoopProxy> {
         &self.event_loop_proxy
     }
 
+    /// If `pump_events` is called to progress the event loop then we
+    /// bootstrap the event loop via `-[NSApplication run]` but will use
+    /// `CFRunLoopRunInMode` for subsequent calls to `pump_events`.
+    pub fn set_stop_on_launch(&self) {
+        self.stop_on_launch.set(true);
+    }
+
+    pub fn set_stop_before_wait(&self, value: bool) {
+        self.stop_before_wait.set(value)
+    }
+
+    pub fn set_stop_after_wait(&self, value: bool) {
+        self.stop_after_wait.set(value)
+    }
+
+    pub fn set_stop_on_redraw(&self, value: bool) {
+        self.stop_on_redraw.set(value)
+    }
+
+    pub fn set_wait_timeout(&self, value: Option<Instant>) {
+        self.wait_timeout.set(value)
+    }
+
+    /// Clears the `running` state and resets the `control_flow` state when an `EventLoop` exits.
+    ///
+    /// NOTE: that if the `NSApplication` has been launched then that state is preserved,
+    /// and we won't need to re-launch the app if subsequent EventLoops are run.
     pub fn internal_exit(self: &Rc<Self>) {
-        self.with_handler(|app, event_loop| {
-            app.exiting(event_loop);
-        });
+        self.set_is_running(false);
+        self.set_stop_on_redraw(false);
+        self.set_stop_before_wait(false);
+        self.set_stop_after_wait(false);
+        self.set_wait_timeout(None);
     }
 
     pub fn is_launched(&self) -> bool {
         self.is_launched.get()
     }
 
+    pub fn set_is_running(&self, value: bool) {
+        self.is_running.set(value)
+    }
+
+    pub fn is_running(&self) -> bool {
+        self.is_running.get()
+    }
+
     pub fn exit(&self) {
         self.exit.set(true)
     }
@@ -184,6 +247,14 @@ impl AppState {
             self.with_handler(|app, event_loop| {
                 app.window_event(event_loop, window_id, WindowEvent::RedrawRequested);
             });
+
+            // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested
+            // events as a way to ensure that `pump_events` can't block an external loop
+            // indefinitely
+            if self.stop_on_redraw.get() {
+                let app = NSApplication::sharedApplication(self.mtm);
+                stop_app_immediately(&app);
+            }
         }
     }
 
@@ -192,7 +263,7 @@ impl AppState {
         if !pending_redraw.contains(&window_id) {
             pending_redraw.push(window_id);
         }
-        self.run_loop.wakeup();
+        self.run_loop.wake_up();
     }
 
     #[track_caller]
@@ -237,10 +308,16 @@ impl AppState {
     // Called by RunLoopObserver after finishing waiting for new events
     pub fn wakeup(self: &Rc<Self>) {
         // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        if !self.event_handler.ready() {
+        // (we have registered to observe all modes, including modal event loops).
+        if !self.event_handler.ready() || !self.is_running() {
             return;
         }
 
+        if self.stop_after_wait.get() {
+            let app = NSApplication::sharedApplication(self.mtm);
+            stop_app_immediately(&app);
+        }
+
         let start = self.start_time.get().unwrap();
         let cause = match self.control_flow() {
             ControlFlow::Poll => StartCause::Poll,
@@ -260,9 +337,8 @@ impl AppState {
     // Called by RunLoopObserver before waiting for new events
     pub fn cleared(self: &Rc<Self>) {
         // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        // XXX: how does it make sense that `event_handler.ready()` can ever return `false` here if
-        // we're about to return to the `CFRunLoop` to poll for new events?
-        if !self.event_handler.ready() {
+        // (we have registered to observe all modes, including modal event loops).
+        if !self.event_handler.ready() || !self.is_running() {
             return;
         }
 
@@ -279,14 +355,27 @@ impl AppState {
         if self.exiting() {
             let app = NSApplication::sharedApplication(self.mtm);
             stop_app_immediately(&app);
+            notify_windows_of_exit(&app);
         }
 
+        if self.stop_before_wait.get() {
+            let app = NSApplication::sharedApplication(self.mtm);
+            stop_app_immediately(&app);
+        }
         self.start_time.set(Some(Instant::now()));
+        let wait_timeout = self.wait_timeout.get(); // configured by pump_events
         let app_timeout = match self.control_flow() {
             ControlFlow::Wait => None,
             ControlFlow::Poll => Some(Instant::now()),
             ControlFlow::WaitUntil(instant) => Some(instant),
         };
-        self.waker.borrow_mut().start_at(app_timeout);
+        self.waker.borrow_mut().start_at(min_timeout(wait_timeout, app_timeout));
     }
 }
+
+/// Returns the minimum `Option<Instant>`, taking into account that `None`
+/// equates to an infinite timeout, not a zero timeout (so can't just use
+/// `Option::min`)
+fn min_timeout(a: Option<Instant>, b: Option<Instant>) -> Option<Instant> {
+    a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
+}

winit-appkit/src/cursor.rs

@@ -0,0 +1,366 @@
+use std::ffi::c_uchar;
+use std::slice;
+use std::sync::OnceLock;
+
+use objc2::rc::Retained;
+use objc2::runtime::Sel;
+use objc2::{AllocAnyThread, ClassType, available, msg_send, sel};
+use objc2_app_kit::{
+    NSBitmapImageRep, NSCursor, NSCursorFrameResizeDirections, NSCursorFrameResizePosition,
+    NSDeviceRGBColorSpace, NSImage,
+};
+use objc2_foundation::{
+    NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString, ns_string,
+};
+use winit_core::cursor::{CursorIcon, CursorImage, CustomCursorProvider, CustomCursorSource};
+use winit_core::error::{NotSupportedError, RequestError};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct CustomCursor(pub(crate) Retained<NSCursor>);
+
+impl CustomCursorProvider for CustomCursor {
+    fn is_animated(&self) -> bool {
+        false
+    }
+}
+
+// SAFETY: NSCursor is immutable and thread-safe
+// TODO(madsmtm): Put this logic in objc2-app-kit itself
+unsafe impl Send for CustomCursor {}
+unsafe impl Sync for CustomCursor {}
+
+impl CustomCursor {
+    pub(crate) fn new(cursor: CustomCursorSource) -> Result<CustomCursor, RequestError> {
+        let cursor = match cursor {
+            CustomCursorSource::Image(cursor_image) => cursor_image,
+            CustomCursorSource::Animation { .. } | CustomCursorSource::Url { .. } => {
+                return Err(NotSupportedError::new("unsupported cursor kind").into());
+            },
+        };
+
+        cursor_from_image(&cursor).map(Self)
+    }
+}
+
+pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Result<Retained<NSCursor>, RequestError> {
+    let width = cursor.width();
+    let height = cursor.height();
+
+    let bitmap = unsafe {
+        NSBitmapImageRep::initWithBitmapDataPlanes_pixelsWide_pixelsHigh_bitsPerSample_samplesPerPixel_hasAlpha_isPlanar_colorSpaceName_bytesPerRow_bitsPerPixel(
+            NSBitmapImageRep::alloc(),
+            std::ptr::null_mut::<*mut c_uchar>(),
+            width as isize,
+            height as isize,
+            8,
+            4,
+            true,
+            false,
+            NSDeviceRGBColorSpace,
+            width as isize * 4,
+            32,
+        )
+    }.ok_or_else(|| os_error!("parent view should be installed in a window"))?;
+    let bitmap_data =
+        unsafe { slice::from_raw_parts_mut(bitmap.bitmapData(), cursor.buffer().len()) };
+    bitmap_data.copy_from_slice(cursor.buffer());
+
+    let image = NSImage::initWithSize(NSImage::alloc(), NSSize::new(width.into(), height.into()));
+    image.addRepresentation(&bitmap);
+
+    let hotspot = NSPoint::new(cursor.hotspot_x() as f64, cursor.hotspot_y() as f64);
+
+    Ok(NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot))
+}
+
+pub(crate) fn default_cursor() -> Retained<NSCursor> {
+    NSCursor::arrowCursor()
+}
+
+unsafe fn try_cursor_from_selector(sel: Sel) -> Option<Retained<NSCursor>> {
+    let cls = NSCursor::class();
+    if unsafe { msg_send![cls, respondsToSelector: sel] } {
+        let cursor: Retained<NSCursor> = unsafe { msg_send![cls, performSelector: sel] };
+        Some(cursor)
+    } else {
+        tracing::warn!("cursor `{sel}` appears to be invalid");
+        None
+    }
+}
+
+macro_rules! def_undocumented_cursor {
+    {$(
+        $(#[$($m:meta)*])*
+        fn $name:ident();
+    )*} => {$(
+        $(#[$($m)*])*
+        #[allow(non_snake_case)]
+        fn $name() -> Retained<NSCursor> {
+            unsafe { try_cursor_from_selector(sel!($name)).unwrap_or_else(|| default_cursor()) }
+        }
+    )*};
+}
+
+def_undocumented_cursor!(
+    // Undocumented cursors: https://stackoverflow.com/a/46635398/5435443
+    fn _helpCursor();
+    fn _zoomInCursor();
+    fn _zoomOutCursor();
+    fn _windowResizeNorthEastCursor();
+    fn _windowResizeNorthWestCursor();
+    fn _windowResizeSouthEastCursor();
+    fn _windowResizeSouthWestCursor();
+    fn _windowResizeNorthEastSouthWestCursor();
+    fn _windowResizeNorthWestSouthEastCursor();
+
+    // While these two are available, the former just loads a white arrow,
+    // and the latter loads an ugly deflated beachball!
+    // pub fn _moveCursor();
+    // pub fn _waitCursor();
+
+    // An even more undocumented cursor...
+    // https://bugs.eclipse.org/bugs/show_bug.cgi?id=522349
+    fn busyButClickableCursor();
+);
+
+// Note that loading `busybutclickable` with this code won't animate
+// the frames; instead you'll just get them all in a column.
+unsafe fn load_webkit_cursor(name: &NSString) -> Retained<NSCursor> {
+    // Snatch a cursor from WebKit; They fit the style of the native
+    // cursors, and will seem completely standard to macOS users.
+    //
+    // https://stackoverflow.com/a/21786835/5435443
+    let root = ns_string!(
+        "/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/\
+         HIServices.framework/Versions/A/Resources/cursors"
+    );
+    let cursor_path = root.stringByAppendingPathComponent(name);
+
+    let pdf_path = cursor_path.stringByAppendingPathComponent(ns_string!("cursor.pdf"));
+    let image = NSImage::initByReferencingFile(NSImage::alloc(), &pdf_path).unwrap();
+
+    // TODO: Handle PLists better
+    let info_path = cursor_path.stringByAppendingPathComponent(ns_string!("info.plist"));
+    #[allow(deprecated)]
+    let info: Retained<NSDictionary<NSObject, NSObject>> =
+        unsafe { NSDictionary::dictionaryWithContentsOfFile(&info_path) }.unwrap();
+    let mut x = 0.0;
+    if let Some(n) = info.objectForKey(ns_string!("hotx")) {
+        if let Ok(n) = n.downcast::<NSNumber>() {
+            x = n.as_cgfloat();
+        }
+    }
+    let mut y = 0.0;
+    if let Some(n) = info.objectForKey(ns_string!("hoty")) {
+        if let Ok(n) = n.downcast::<NSNumber>() {
+            y = n.as_cgfloat();
+        }
+    }
+
+    let hotspot = NSPoint::new(x, y);
+    NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
+}
+
+fn webkit_move() -> Retained<NSCursor> {
+    unsafe { load_webkit_cursor(ns_string!("move")) }
+}
+
+fn webkit_cell() -> Retained<NSCursor> {
+    unsafe { load_webkit_cursor(ns_string!("cell")) }
+}
+
+pub(crate) fn invisible_cursor() -> Retained<NSCursor> {
+    // 16x16 GIF data for invisible cursor
+    // You can reproduce this via ImageMagick.
+    // $ convert -size 16x16 xc:none cursor.gif
+    static CURSOR_BYTES: &[u8] = &[
+        0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x10, 0x00, 0x10, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x21, 0xf9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00,
+        0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x0e, 0x84, 0x8f, 0xa9, 0xcb, 0xed, 0x0f,
+        0xa3, 0x9c, 0xb4, 0xda, 0x8b, 0xb3, 0x3e, 0x05, 0x00, 0x3b,
+    ];
+
+    fn new_invisible() -> Retained<NSCursor> {
+        // TODO: Consider using `dataWithBytesNoCopy:`
+        let data = NSData::with_bytes(CURSOR_BYTES);
+        let image = NSImage::initWithData(NSImage::alloc(), &data).unwrap();
+        let hotspot = NSPoint::new(0.0, 0.0);
+        NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
+    }
+
+    // Cache this for efficiency
+    static CURSOR: OnceLock<CustomCursor> = OnceLock::new();
+    CURSOR.get_or_init(|| CustomCursor(new_invisible())).0.clone()
+}
+
+#[allow(deprecated)]
+pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Retained<NSCursor> {
+    match icon {
+        CursorIcon::Default => default_cursor(),
+        CursorIcon::Pointer => NSCursor::pointingHandCursor(),
+        CursorIcon::Grab => NSCursor::openHandCursor(),
+        CursorIcon::Grabbing => NSCursor::closedHandCursor(),
+        CursorIcon::Text => NSCursor::IBeamCursor(),
+        CursorIcon::VerticalText => NSCursor::IBeamCursorForVerticalLayout(),
+        CursorIcon::Copy => NSCursor::dragCopyCursor(),
+        CursorIcon::Alias => NSCursor::dragLinkCursor(),
+        CursorIcon::NotAllowed | CursorIcon::NoDrop => NSCursor::operationNotAllowedCursor(),
+        CursorIcon::ContextMenu => NSCursor::contextualMenuCursor(),
+        CursorIcon::Crosshair => NSCursor::crosshairCursor(),
+        CursorIcon::EResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::Right,
+                    NSCursorFrameResizeDirections::Outward,
+                )
+            } else {
+                NSCursor::resizeRightCursor()
+            }
+        },
+        CursorIcon::NResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::Top,
+                    NSCursorFrameResizeDirections::Outward,
+                )
+            } else {
+                NSCursor::resizeUpCursor()
+            }
+        },
+        CursorIcon::WResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::Left,
+                    NSCursorFrameResizeDirections::Outward,
+                )
+            } else {
+                NSCursor::resizeLeftCursor()
+            }
+        },
+        CursorIcon::SResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::Bottom,
+                    NSCursorFrameResizeDirections::Outward,
+                )
+            } else {
+                NSCursor::resizeDownCursor()
+            }
+        },
+        CursorIcon::EwResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::Right,
+                    NSCursorFrameResizeDirections::All,
+                )
+            } else {
+                NSCursor::resizeLeftRightCursor()
+            }
+        },
+        CursorIcon::NsResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::Top,
+                    NSCursorFrameResizeDirections::All,
+                )
+            } else {
+                NSCursor::resizeUpDownCursor()
+            }
+        },
+        CursorIcon::NeResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::TopRight,
+                    NSCursorFrameResizeDirections::Outward,
+                )
+            } else {
+                _windowResizeNorthEastCursor()
+            }
+        },
+        CursorIcon::NwResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::TopLeft,
+                    NSCursorFrameResizeDirections::Outward,
+                )
+            } else {
+                _windowResizeNorthWestCursor()
+            }
+        },
+        CursorIcon::SeResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::BottomRight,
+                    NSCursorFrameResizeDirections::Outward,
+                )
+            } else {
+                _windowResizeSouthEastCursor()
+            }
+        },
+        CursorIcon::SwResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::BottomLeft,
+                    NSCursorFrameResizeDirections::Outward,
+                )
+            } else {
+                _windowResizeSouthWestCursor()
+            }
+        },
+        CursorIcon::NeswResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::TopRight,
+                    NSCursorFrameResizeDirections::All,
+                )
+            } else {
+                _windowResizeNorthEastSouthWestCursor()
+            }
+        },
+        CursorIcon::NwseResize => {
+            if available!(macos = 15.0) {
+                NSCursor::frameResizeCursorFromPosition_inDirections(
+                    NSCursorFrameResizePosition::TopLeft,
+                    NSCursorFrameResizeDirections::All,
+                )
+            } else {
+                _windowResizeNorthWestSouthEastCursor()
+            }
+        },
+        CursorIcon::ColResize => {
+            if available!(macos = 15.0) {
+                NSCursor::columnResizeCursor()
+            } else {
+                NSCursor::resizeLeftRightCursor()
+            }
+        },
+        CursorIcon::RowResize => {
+            if available!(macos = 15.0) {
+                NSCursor::rowResizeCursor()
+            } else {
+                NSCursor::resizeUpDownCursor()
+            }
+        },
+        CursorIcon::ZoomIn => {
+            if available!(macos = 15.0) {
+                NSCursor::zoomInCursor()
+            } else {
+                _zoomInCursor()
+            }
+        },
+        CursorIcon::ZoomOut => {
+            if available!(macos = 15.0) {
+                NSCursor::zoomOutCursor()
+            } else {
+                _zoomOutCursor()
+            }
+        },
+        CursorIcon::Help => _helpCursor(),
+        // This is the wrong semantics for `Wait`, but it's the same as
+        // what's used in Safari and Chrome.
+        CursorIcon::Wait | CursorIcon::Progress => busyButClickableCursor(),
+        CursorIcon::Move | CursorIcon::AllScroll => webkit_move(),
+        CursorIcon::Cell => webkit_cell(),
+        _ => default_cursor(),
+    }
+}

winit-appkit/src/event.rs

@@ -3,17 +3,17 @@ use std::ptr::NonNull;
 use dispatch2::run_on_main;
 use objc2::rc::Retained;
 use objc2_app_kit::{NSEvent, NSEventModifierFlags, NSEventSubtype, NSEventType};
-use objc2_core_foundation::{CFData, CFDataGetBytePtr, CFRetained};
+use objc2_core_foundation::{CFData, CFRetained};
 use objc2_foundation::NSPoint;
 use smol_str::SmolStr;
-
-use super::ffi;
-use crate::event::{ElementState, KeyEvent, Modifiers};
-use crate::keyboard::{
+use winit_core::event::{ElementState, KeyEvent, Modifiers};
+use winit_core::keyboard::{
     Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey, NativeKeyCode,
     PhysicalKey,
 };
 
+use super::ffi;
+
 /// Ignores ALL modifiers.
 pub fn get_modifierless_char(scancode: u16) -> Key {
     let Some(ptr) = NonNull::new(unsafe { ffi::TISCopyCurrentKeyboardLayoutInputSource() }) else {
@@ -30,7 +30,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
         return Key::Unidentified(NativeKey::MacOS(scancode));
     };
 
-    let layout = unsafe { CFDataGetBytePtr(layout_data).cast() };
+    let layout = layout_data.byte_ptr().cast();
     let keyboard_type = run_on_main(|_mtm| unsafe { ffi::LMGetKbdType() });
 
     let mut result_len = 0;
@@ -67,9 +67,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
 
 // Ignores all modifiers except for SHIFT (yes, even ALT is ignored).
 fn get_logical_key_char(ns_event: &NSEvent, modifierless_chars: &str) -> Key {
-    let string = unsafe { ns_event.charactersIgnoringModifiers() }
-        .map(|s| s.to_string())
-        .unwrap_or_default();
+    let string = ns_event.charactersIgnoringModifiers().map(|s| s.to_string()).unwrap_or_default();
     if string.is_empty() {
         // Probably a dead key
         let first_char = modifierless_chars.chars().next();
@@ -85,7 +83,7 @@ pub(crate) fn create_key_event(ns_event: &NSEvent, is_press: bool, is_repeat: bo
     use ElementState::{Pressed, Released};
     let state = if is_press { Pressed } else { Released };
 
-    let scancode = unsafe { ns_event.keyCode() };
+    let scancode = ns_event.keyCode();
     let mut physical_key = scancode_to_physicalkey(scancode as u32);
 
     // NOTE: The logical key should heed both SHIFT and ALT if possible.
@@ -95,7 +93,7 @@ pub(crate) fn create_key_event(ns_event: &NSEvent, is_press: bool, is_repeat: bo
     // * Pressing CTRL SHIFT A: logical key should also be "A"
     // This is not easy to tease out of `NSEvent`, but we do our best.
 
-    let characters = unsafe { ns_event.characters() }.map(|s| s.to_string()).unwrap_or_default();
+    let characters = ns_event.characters().map(|s| s.to_string()).unwrap_or_default();
     let text_with_all_modifiers = if characters.is_empty() {
         None
     } else {
@@ -111,13 +109,13 @@ pub(crate) fn create_key_event(ns_event: &NSEvent, is_press: bool, is_repeat: bo
         // `get_modifierless_char/key_without_modifiers` ignores ALL modifiers.
         let key_without_modifiers = get_modifierless_char(scancode);
 
-        let modifiers = unsafe { ns_event.modifierFlags() };
+        let modifiers = ns_event.modifierFlags();
         let has_ctrl = modifiers.contains(NSEventModifierFlags::Control);
         let has_cmd = modifiers.contains(NSEventModifierFlags::Command);
 
         let logical_key = match text_with_all_modifiers.as_ref() {
             // Only checking for ctrl and cmd here, not checking for alt because we DO want to
-            // include its effect in the key. For example if -on the Germay layout- one
+            // include its effect in the key. For example if -on the German layout- one
             // presses alt+8, the logical key should be "{"
             // Also not checking if this is a release event because then this issue would
             // still affect the key release.
@@ -168,11 +166,11 @@ pub fn code_to_key(key: PhysicalKey, scancode: u16) -> Key {
     Key::Named(match code {
         KeyCode::Enter => NamedKey::Enter,
         KeyCode::Tab => NamedKey::Tab,
-        KeyCode::Space => NamedKey::Space,
+        KeyCode::Space => return Key::Character(" ".into()),
         KeyCode::Backspace => NamedKey::Backspace,
         KeyCode::Escape => NamedKey::Escape,
-        KeyCode::SuperRight => NamedKey::Super,
-        KeyCode::SuperLeft => NamedKey::Super,
+        KeyCode::MetaRight => NamedKey::Meta,
+        KeyCode::MetaLeft => NamedKey::Meta,
         KeyCode::ShiftLeft => NamedKey::Shift,
         KeyCode::AltLeft => NamedKey::Alt,
         KeyCode::ControlLeft => NamedKey::Control,
@@ -242,8 +240,8 @@ pub fn code_to_location(key: PhysicalKey) -> KeyLocation {
     };
 
     match code {
-        KeyCode::SuperRight => KeyLocation::Right,
-        KeyCode::SuperLeft => KeyLocation::Left,
+        KeyCode::MetaRight => KeyLocation::Right,
+        KeyCode::MetaLeft => KeyLocation::Left,
         KeyCode::ShiftLeft => KeyLocation::Left,
         KeyCode::AltLeft => KeyLocation::Left,
         KeyCode::ControlLeft => KeyLocation::Left,
@@ -302,15 +300,15 @@ const NX_DEVICERALTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x000000
 const NX_DEVICERCTLKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00002000);
 
 pub(super) fn lalt_pressed(event: &NSEvent) -> bool {
-    unsafe { event.modifierFlags() }.contains(NX_DEVICELALTKEYMASK)
+    event.modifierFlags().contains(NX_DEVICELALTKEYMASK)
 }
 
 pub(super) fn ralt_pressed(event: &NSEvent) -> bool {
-    unsafe { event.modifierFlags() }.contains(NX_DEVICERALTKEYMASK)
+    event.modifierFlags().contains(NX_DEVICERALTKEYMASK)
 }
 
 pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
-    let flags = unsafe { event.modifierFlags() };
+    let flags = event.modifierFlags();
     let mut state = ModifiersState::empty();
     let mut pressed_mods = ModifiersKeys::empty();
 
@@ -326,16 +324,15 @@ pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
     pressed_mods.set(ModifiersKeys::LALT, flags.contains(NX_DEVICELALTKEYMASK));
     pressed_mods.set(ModifiersKeys::RALT, flags.contains(NX_DEVICERALTKEYMASK));
 
-    state.set(ModifiersState::SUPER, flags.contains(NSEventModifierFlags::Command));
-    pressed_mods.set(ModifiersKeys::LSUPER, flags.contains(NX_DEVICELCMDKEYMASK));
-    pressed_mods.set(ModifiersKeys::RSUPER, flags.contains(NX_DEVICERCMDKEYMASK));
+    state.set(ModifiersState::META, flags.contains(NSEventModifierFlags::Command));
+    pressed_mods.set(ModifiersKeys::LMETA, flags.contains(NX_DEVICELCMDKEYMASK));
+    pressed_mods.set(ModifiersKeys::RMETA, flags.contains(NX_DEVICERCMDKEYMASK));
 
-    Modifiers { state, pressed_mods }
+    Modifiers::new(state, pressed_mods)
 }
 
 pub(super) fn dummy_event() -> Option<Retained<NSEvent>> {
-    unsafe {
-        NSEvent::otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2(
+    NSEvent::otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2(
             NSEventType::ApplicationDefined,
             NSPoint::new(0.0, 0.0),
             NSEventModifierFlags(0),
@@ -346,10 +343,9 @@ pub(super) fn dummy_event() -> Option<Retained<NSEvent>> {
             0,
             0,
         )
-    }
 }
 
-pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
+pub fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
     let code = match physical_key {
         PhysicalKey::Code(code) => code,
         PhysicalKey::Unidentified(_) => return None,
@@ -409,8 +405,8 @@ pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32>
         KeyCode::Backquote => Some(0x32),
         KeyCode::Backspace => Some(0x33),
         KeyCode::Escape => Some(0x35),
-        KeyCode::SuperRight => Some(0x36),
-        KeyCode::SuperLeft => Some(0x37),
+        KeyCode::MetaRight => Some(0x36),
+        KeyCode::MetaLeft => Some(0x37),
         KeyCode::ShiftLeft => Some(0x38),
         KeyCode::CapsLock => Some(0x39),
         KeyCode::AltLeft => Some(0x3a),
@@ -481,7 +477,7 @@ pub(crate) fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32>
     }
 }
 
-pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
+pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
     // Follows what Chromium and Firefox do:
     // https://chromium.googlesource.com/chromium/src.git/+/3e1a26c44c024d97dc9a4c09bbc6a2365398ca2c/ui/events/keycodes/dom/dom_code_data.inc
     // https://searchfox.org/mozilla-central/rev/c597e9c789ad36af84a0370d395be066b7dc94f4/widget/NativeKeyToDOMCodeName.h
@@ -555,8 +551,8 @@ pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         0x33 => KeyCode::Backspace,
         // 0x34 => unknown, // kVK_Powerbook_KeypadEnter
         0x35 => KeyCode::Escape,
-        0x36 => KeyCode::SuperRight,
-        0x37 => KeyCode::SuperLeft,
+        0x36 => KeyCode::MetaRight,
+        0x37 => KeyCode::MetaLeft,
         0x38 => KeyCode::ShiftLeft,
         0x39 => KeyCode::CapsLock,
         0x3a => KeyCode::AltLeft,

winit-appkit/src/event_loop.rs

@@ -1,37 +1,38 @@
 use std::rc::Rc;
 use std::sync::Arc;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
-use objc2::rc::{autoreleasepool, Retained};
+use objc2::rc::{Retained, autoreleasepool};
 use objc2::runtime::ProtocolObject;
-use objc2::{available, MainThreadMarker};
+use objc2::{MainThreadMarker, available};
 use objc2_app_kit::{
     NSApplication, NSApplicationActivationPolicy, NSApplicationDidFinishLaunchingNotification,
-    NSApplicationWillTerminateNotification, NSEventMask, NSWindow,
-};
-use objc2_foundation::{
-    NSDate, NSDefaultRunLoopMode, NSNotificationCenter, NSObjectProtocol, NSTimeInterval,
+    NSApplicationWillTerminateNotification, NSWindow,
 };
+use objc2_core_foundation::{CFIndex, CFRunLoopActivity, kCFRunLoopCommonModes};
+use objc2_foundation::{NSNotificationCenter, NSObjectProtocol};
 use rwh_06::HasDisplayHandle;
+use tracing::debug_span;
+use winit_common::core_foundation::{MainRunLoop, MainRunLoopObserver, tracing_observers};
+use winit_common::foundation::create_observer;
+use winit_core::application::ApplicationHandler;
+use winit_core::cursor::{CustomCursor as CoreCustomCursor, CustomCursorSource};
+use winit_core::error::{EventLoopError, RequestError};
+use winit_core::event_loop::pump_events::PumpStatus;
+use winit_core::event_loop::{
+    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
+    EventLoopProxy as CoreEventLoopProxy, OwnedDisplayHandle as CoreOwnedDisplayHandle,
+};
+use winit_core::monitor::MonitorHandle as CoreMonitorHandle;
+use winit_core::window::Theme;
 
-use super::super::notification_center::create_observer;
 use super::app::override_send_event;
 use super::app_state::AppState;
 use super::cursor::CustomCursor;
 use super::event::dummy_event;
 use super::monitor;
-use super::observer::setup_control_flow_observers;
-use crate::application::ApplicationHandler;
-use crate::error::{EventLoopError, RequestError};
-use crate::event_loop::{
-    ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents,
-    EventLoopProxy as CoreEventLoopProxy, OwnedDisplayHandle as CoreOwnedDisplayHandle,
-};
-use crate::monitor::MonitorHandle as RootMonitorHandle;
-use crate::platform::macos::ActivationPolicy;
-use crate::platform::pump_events::PumpStatus;
-use crate::platform_impl::Window;
-use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource, Theme};
+use crate::ActivationPolicy;
+use crate::window::Window;
 
 #[derive(Debug)]
 pub struct ActiveEventLoop {
@@ -64,25 +65,29 @@ impl RootActiveEventLoop for ActiveEventLoop {
 
     fn create_window(
         &self,
-        window_attributes: crate::window::WindowAttributes,
-    ) -> Result<Box<dyn crate::window::Window>, RequestError> {
+        window_attributes: winit_core::window::WindowAttributes,
+    ) -> Result<Box<dyn winit_core::window::Window>, RequestError> {
         Ok(Box::new(Window::new(self, window_attributes)?))
     }
 
     fn create_custom_cursor(
         &self,
         source: CustomCursorSource,
-    ) -> Result<RootCustomCursor, RequestError> {
-        Ok(RootCustomCursor { inner: CustomCursor::new(source.inner)? })
+    ) -> Result<CoreCustomCursor, RequestError> {
+        Ok(CoreCustomCursor(Arc::new(CustomCursor::new(source)?)))
     }
 
-    fn available_monitors(&self) -> Box<dyn Iterator<Item = RootMonitorHandle>> {
-        Box::new(monitor::available_monitors().into_iter().map(|inner| RootMonitorHandle { inner }))
+    fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
+        Box::new(
+            monitor::available_monitors()
+                .into_iter()
+                .map(|monitor| CoreMonitorHandle(Arc::new(monitor))),
+        )
     }
 
-    fn primary_monitor(&self) -> Option<crate::monitor::MonitorHandle> {
+    fn primary_monitor(&self) -> Option<winit_core::monitor::MonitorHandle> {
         let monitor = monitor::primary_monitor();
-        Some(RootMonitorHandle { inner: monitor })
+        Some(CoreMonitorHandle(Arc::new(monitor)))
     }
 
     fn listen_device_events(&self, _allowed: DeviceEvents) {}
@@ -130,6 +135,7 @@ impl rwh_06::HasDisplayHandle for ActiveEventLoop {
     }
 }
 
+#[derive(Debug)]
 pub struct EventLoop {
     /// Store a reference to the application for convenience.
     ///
@@ -138,9 +144,6 @@ pub struct EventLoop {
     app: Retained<NSApplication>,
     app_state: Rc<AppState>,
 
-    /// Whether an outer event loop is running.
-    pump_has_sent_init: bool,
-
     window_target: ActiveEventLoop,
 
     // Since macOS 10.11, we no longer need to remove the observers before they are deallocated;
@@ -149,13 +152,17 @@ pub struct EventLoop {
     // Though we do still need to keep the observers around to prevent them from being deallocated.
     _did_finish_launching_observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,
     _will_terminate_observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,
+
+    _tracing_observers: Option<(MainRunLoopObserver, MainRunLoopObserver)>,
+    _before_waiting_observer: MainRunLoopObserver,
+    _after_waiting_observer: MainRunLoopObserver,
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct PlatformSpecificEventLoopAttributes {
-    pub(crate) activation_policy: Option<ActivationPolicy>,
-    pub(crate) default_menu: bool,
-    pub(crate) activate_ignoring_other_apps: bool,
+pub struct PlatformSpecificEventLoopAttributes {
+    pub activation_policy: Option<ActivationPolicy>,
+    pub default_menu: bool,
+    pub activate_ignoring_other_apps: bool,
 }
 
 impl Default for PlatformSpecificEventLoopAttributes {
@@ -165,9 +172,7 @@ impl Default for PlatformSpecificEventLoopAttributes {
 }
 
 impl EventLoop {
-    pub(crate) fn new(
-        attributes: &PlatformSpecificEventLoopAttributes,
-    ) -> Result<Self, EventLoopError> {
+    pub fn new(attributes: &PlatformSpecificEventLoopAttributes) -> Result<Self, EventLoopError> {
         let mtm = MainThreadMarker::new()
             .expect("on macOS, `EventLoop` must be created on the main thread!");
 
@@ -183,7 +188,8 @@ impl EventLoop {
             activation_policy,
             attributes.default_menu,
             attributes.activate_ignoring_other_apps,
-        );
+        )
+        .ok_or_else(|| EventLoopError::RecreationAttempt)?;
 
         // Initialize the application (if it has not already been).
         let app = NSApplication::sharedApplication(mtm);
@@ -191,16 +197,7 @@ impl EventLoop {
         // Override `sendEvent:` on the application to forward to our application state.
         override_send_event(&app);
 
-        // Queue `NSApplicationDidFinishLaunchingNotification` and generally
-        // make sure the application is fully initialized (once the run loop
-        // starts).
-        //
-        // This is technically only necessary when using `pump_app_events`
-        // (`app.run()` will do it for us in `run_app_on_demand`), but we
-        // might as well do it everywhere.
-        unsafe { app.finishLaunching() };
-
-        let center = unsafe { NSNotificationCenter::defaultCenter() };
+        let center = NSNotificationCenter::defaultCenter();
 
         let weak_app_state = Rc::downgrade(&app_state);
         let _did_finish_launching_observer = create_observer(
@@ -208,6 +205,7 @@ impl EventLoop {
             // `applicationDidFinishLaunching:`
             unsafe { NSApplicationDidFinishLaunchingNotification },
             move |notification| {
+                let _entered = debug_span!("NSApplicationDidFinishLaunchingNotification").entered();
                 if let Some(app_state) = weak_app_state.upgrade() {
                     app_state.did_finish_launching(notification);
                 }
@@ -220,21 +218,55 @@ impl EventLoop {
             // `applicationWillTerminate:`
             unsafe { NSApplicationWillTerminateNotification },
             move |notification| {
+                let _entered = debug_span!("NSApplicationWillTerminateNotification").entered();
                 if let Some(app_state) = weak_app_state.upgrade() {
                     app_state.will_terminate(notification);
                 }
             },
         );
 
-        setup_control_flow_observers(mtm);
+        let main_loop = MainRunLoop::get(mtm);
+        let mode = unsafe { kCFRunLoopCommonModes }.unwrap();
+
+        // Tracing observers have the lowest and highest orderings.
+        let _tracing_observers = tracing_observers(mtm).inspect(|(start, end)| {
+            main_loop.add_observer(start, mode);
+            main_loop.add_observer(end, mode);
+        });
+
+        let app_state_clone = Rc::clone(&app_state);
+        let _before_waiting_observer = MainRunLoopObserver::new(
+            mtm,
+            CFRunLoopActivity::BeforeWaiting,
+            true,
+            // Queued with the second-lowest priority (tracing observers use the lowest) to ensure
+            // it is processed after other observers.
+            CFIndex::MAX - 1,
+            move |_| app_state_clone.cleared(),
+        );
+        main_loop.add_observer(&_before_waiting_observer, mode);
+
+        let app_state_clone = Rc::clone(&app_state);
+        let _after_waiting_observer = MainRunLoopObserver::new(
+            mtm,
+            CFRunLoopActivity::AfterWaiting,
+            true,
+            // Queued with the second-highest priority (tracing observers use the highest) to
+            // ensure it is processed before other observers.
+            CFIndex::MIN + 1,
+            move |_| app_state_clone.wakeup(),
+        );
+        main_loop.add_observer(&_after_waiting_observer, mode);
 
         Ok(EventLoop {
             app,
             app_state: app_state.clone(),
-            pump_has_sent_init: false,
             window_target: ActiveEventLoop { app_state, mtm },
             _did_finish_launching_observer,
             _will_terminate_observer,
+            _tracing_observers,
+            _before_waiting_observer,
+            _after_waiting_observer,
         })
     }
 
@@ -242,30 +274,29 @@ impl EventLoop {
         &self.window_target
     }
 
-    pub fn run_app<A: ApplicationHandler>(mut self, app: A) -> Result<(), EventLoopError> {
-        self.run_app_on_demand(app)
-    }
-
+    // NB: we don't base this on `pump_events` because for `MacOs` we can't support
+    // `pump_events` elegantly (we just ask to run the loop for a "short" amount of
+    // time and so a layered implementation would end up using a lot of CPU due to
+    // redundant wake ups.
     pub fn run_app_on_demand<A: ApplicationHandler>(
         &mut self,
-        mut app: A,
+        app: A,
     ) -> Result<(), EventLoopError> {
         self.app_state.clear_exit();
-        self.app_state.set_event_handler(&mut app, || {
+        self.app_state.set_event_handler(app, || {
             autoreleasepool(|_| {
+                // clear / normalize pump_events state
+                self.app_state.set_wait_timeout(None);
+                self.app_state.set_stop_before_wait(false);
+                self.app_state.set_stop_after_wait(false);
+                self.app_state.set_stop_on_redraw(false);
+
                 if self.app_state.is_launched() {
-                    // The `NSApplicationDidFinishLaunchingNotification` notification is globally
-                    // only delivered once, but for the purpose of our events, we want to act
-                    // as-if an entirely new event loop has been started on each invocation of
-                    // `run_app_on_demand`.
+                    debug_assert!(!self.app_state.is_running());
+                    self.app_state.set_is_running(true);
                     self.app_state.dispatch_init_events();
                 }
 
-                // NOTE: We don't base this on `pump_events` because
-                // `nextEventMatchingMask:untilDate:inMode:dequeue:` is worse supported,
-                // especially as the top-level handler. In part because this sets the `isRunning`
-                // flag (which is used by crates like `rfd`), while `nextEventMatchingMask` won't.
-                //
                 // NOTE: Make sure to not run the application re-entrantly, as that'd be confusing.
                 self.app.run();
 
@@ -279,47 +310,53 @@ impl EventLoop {
     pub fn pump_app_events<A: ApplicationHandler>(
         &mut self,
         timeout: Option<Duration>,
-        mut app: A,
+        app: A,
     ) -> PumpStatus {
-        self.app_state.set_event_handler(&mut app, || {
+        self.app_state.set_event_handler(app, || {
             autoreleasepool(|_| {
-                if self.app_state.is_launched() && !self.pump_has_sent_init {
-                    // If the application is already launched, we won't get the re-initialization
-                    // events. Dispatch them here instead.
+                // As a special case, if the application hasn't been launched yet then we at least
+                // run the loop until it has fully launched.
+                if !self.app_state.is_launched() {
+                    debug_assert!(!self.app_state.is_running());
+
+                    self.app_state.set_stop_on_launch();
+                    self.app.run();
+
+                    // Note: we dispatch `NewEvents(Init)` + `Resumed` events after the application
+                    // has launched
+                } else if !self.app_state.is_running() {
+                    // Even though the application may have been launched, it's possible we aren't
+                    // running if the `EventLoop` was run before and has since
+                    // exited. This indicates that we just starting to re-run
+                    // the same `EventLoop` again.
+                    self.app_state.set_is_running(true);
                     self.app_state.dispatch_init_events();
-                }
-                self.pump_has_sent_init = true;
-
-                // Only run for as long as the given `Duration` allows so we don't block the
-                // external loop.
-                let expiration_date = match timeout {
-                    Some(Duration::ZERO) => unsafe { NSDate::distantPast() },
-                    Some(duration) => unsafe {
-                        NSDate::dateWithTimeIntervalSinceNow(
-                            duration.as_secs_f64() as NSTimeInterval
-                        )
-                    },
-                    None => unsafe { NSDate::distantFuture() },
-                };
-
-                // Wait for an event to arrive within the specified duration,
-                // and let the application handle it if one did.
-                let event = unsafe {
-                    self.app.nextEventMatchingMask_untilDate_inMode_dequeue(
-                        NSEventMask::Any,
-                        Some(&expiration_date),
-                        NSDefaultRunLoopMode,
-                        true,
-                    )
-                };
-                if let Some(event) = event {
-                    unsafe { self.app.sendEvent(&event) };
+                } else {
+                    // Only run for as long as the given `Duration` allows so we don't block the
+                    // external loop.
+                    match timeout {
+                        Some(Duration::ZERO) => {
+                            self.app_state.set_wait_timeout(None);
+                            self.app_state.set_stop_before_wait(true);
+                        },
+                        Some(duration) => {
+                            self.app_state.set_stop_before_wait(false);
+                            let timeout = Instant::now() + duration;
+                            self.app_state.set_wait_timeout(Some(timeout));
+                            self.app_state.set_stop_after_wait(true);
+                        },
+                        None => {
+                            self.app_state.set_wait_timeout(None);
+                            self.app_state.set_stop_before_wait(false);
+                            self.app_state.set_stop_after_wait(true);
+                        },
+                    }
+                    self.app_state.set_stop_on_redraw(true);
+                    self.app.run();
                 }
 
                 if self.app_state.exiting() {
                     self.app_state.internal_exit();
-                    // If we start again, we'll emit a new set of initialization events.
-                    self.pump_has_sent_init = false;
                     PumpStatus::Exit(0)
                 } else {
                     PumpStatus::Continue
@@ -346,3 +383,19 @@ pub(super) fn stop_app_immediately(app: &NSApplication) {
         app.postEvent_atStart(&dummy_event().unwrap(), true);
     });
 }
+
+/// Tell all windows to close.
+///
+/// This will synchronously trigger `WindowEvent::Destroyed` within
+/// `windowWillClose:`, giving the application one last chance to handle
+/// those events. It doesn't matter if the user also ends up closing the
+/// windows in `Window`'s `Drop` impl, once a window has been closed once, it
+/// stays closed.
+///
+/// This ensures that no windows linger on after the event loop has exited,
+/// see <https://github.com/rust-windowing/winit/issues/4135>.
+pub(super) fn notify_windows_of_exit(app: &NSApplication) {
+    for window in app.windows() {
+        window.close();
+    }
+}

winit-appkit/src/ffi.rs

@@ -1,36 +1,19 @@
 // TODO: Upstream these
 
-#![allow(dead_code, non_snake_case, non_upper_case_globals)]
+#![allow(non_upper_case_globals)]
 
 use std::ffi::c_void;
 
 use objc2::ffi::NSInteger;
 use objc2::runtime::AnyObject;
-use objc2_core_foundation::{cf_type, CFString, CFUUID};
+use objc2_core_foundation::{CFString, CFUUID, cf_type};
 use objc2_core_graphics::CGDirectDisplayID;
 
-pub const kCGDisplayBlendNormal: f32 = 0.0;
-pub const kCGDisplayBlendSolidColor: f32 = 1.0;
-
-pub type CGDisplayFadeReservationToken = u32;
-pub const kCGDisplayFadeReservationInvalidToken: CGDisplayFadeReservationToken = 0;
-
-pub const IO1BitIndexedPixels: &str = "P";
-pub const IO2BitIndexedPixels: &str = "PP";
-pub const IO4BitIndexedPixels: &str = "PPPP";
-pub const IO8BitIndexedPixels: &str = "PPPPPPPP";
 pub const IO16BitDirectPixels: &str = "-RRRRRGGGGGBBBBB";
 pub const IO32BitDirectPixels: &str = "--------RRRRRRRRGGGGGGGGBBBBBBBB";
-
 pub const kIO30BitDirectPixels: &str = "--RRRRRRRRRRGGGGGGGGGGBBBBBBBBBB";
 pub const kIO64BitDirectPixels: &str = "-16R16G16B16";
 
-pub const kIO16BitFloatPixels: &str = "-16FR16FG16FB16";
-pub const kIO32BitFloatPixels: &str = "-32FR32FG32FB32";
-
-pub const IOYUV422Pixels: &str = "Y4U2V2";
-pub const IO8BitOverlayPixels: &str = "O8";
-
 // `CGDisplayCreateUUIDFromDisplayID` comes from the `ColorSync` framework.
 // However, that framework was only introduced "publicly" in macOS 10.13.
 //
@@ -39,12 +22,14 @@ pub const IO8BitOverlayPixels: &str = "O8";
 // `ApplicationServices`, see:
 // https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/OSX_Technology_Overview/SystemFrameworks/SystemFrameworks.html#//apple_ref/doc/uid/TP40001067-CH210-BBCFFIEG
 #[link(name = "ApplicationServices", kind = "framework")]
-extern "C" {
+unsafe extern "C" {
     pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> *mut CFUUID;
+
+    pub fn CGDisplayGetDisplayIDFromUUID(uuid: &CFUUID) -> CGDirectDisplayID;
 }
 
 #[link(name = "CoreGraphics", kind = "framework")]
-extern "C" {
+unsafe extern "C" {
     // Wildly used private APIs; Apple uses them for their Terminal.app.
     pub fn CGSMainConnectionID() -> *mut AnyObject;
     pub fn CGSSetWindowBackgroundBlurRadius(
@@ -58,7 +43,6 @@ extern "C" {
 pub struct TISInputSource(std::ffi::c_void);
 
 cf_type!(
-    #[encoding_name = "__TISInputSource"]
     unsafe impl TISInputSource {}
 );
 
@@ -76,7 +60,7 @@ pub const kUCKeyActionDisplay: u16 = 3;
 pub const kUCKeyTranslateNoDeadKeysMask: OptionBits = 1;
 
 #[link(name = "Carbon", kind = "framework")]
-extern "C" {
+unsafe extern "C" {
     pub static kTISPropertyUnicodeKeyLayoutData: &'static CFString;
 
     #[allow(non_snake_case)]
@@ -103,45 +87,3 @@ extern "C" {
         unicodeString: *mut UniChar,
     ) -> OSStatus;
 }
-
-// CGWindowLevel.h
-//
-// Note: There are two different things at play in this header:
-// `CGWindowLevel` and `CGWindowLevelKey`.
-//
-// It seems like there was a push towards using "key" values instead of the
-// raw window level values, and then you were supposed to use
-// `CGWindowLevelForKey` to get the actual level.
-//
-// But the values that `NSWindowLevel` has are compiled in, and as such has
-// to remain ABI compatible, so they're safe for us to hardcode as well.
-#[allow(dead_code, non_upper_case_globals)]
-mod window_level {
-    const kCGNumReservedWindowLevels: i32 = 16;
-    const kCGNumReservedBaseWindowLevels: i32 = 5;
-
-    pub const kCGBaseWindowLevel: i32 = i32::MIN;
-    pub const kCGMinimumWindowLevel: i32 = kCGBaseWindowLevel + kCGNumReservedBaseWindowLevels;
-    pub const kCGMaximumWindowLevel: i32 = i32::MAX - kCGNumReservedWindowLevels;
-
-    pub const kCGDesktopWindowLevel: i32 = kCGMinimumWindowLevel + 20;
-    pub const kCGDesktopIconWindowLevel: i32 = kCGDesktopWindowLevel + 20;
-    pub const kCGBackstopMenuLevel: i32 = -20;
-    pub const kCGNormalWindowLevel: i32 = 0;
-    pub const kCGFloatingWindowLevel: i32 = 3;
-    pub const kCGTornOffMenuWindowLevel: i32 = 3;
-    pub const kCGModalPanelWindowLevel: i32 = 8;
-    pub const kCGUtilityWindowLevel: i32 = 19;
-    pub const kCGDockWindowLevel: i32 = 20;
-    pub const kCGMainMenuWindowLevel: i32 = 24;
-    pub const kCGStatusWindowLevel: i32 = 25;
-    pub const kCGPopUpMenuWindowLevel: i32 = 101;
-    pub const kCGOverlayWindowLevel: i32 = 102;
-    pub const kCGHelpWindowLevel: i32 = 200;
-    pub const kCGDraggingWindowLevel: i32 = 500;
-    pub const kCGScreenSaverWindowLevel: i32 = 1000;
-    pub const kCGAssistiveTechHighWindowLevel: i32 = 1500;
-    pub const kCGCursorWindowLevel: i32 = kCGMaximumWindowLevel - 1;
-}
-
-pub use window_level::*;

winit-appkit/src/lib.rs

@@ -17,13 +17,12 @@
 //! 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::{define_class, msg_send, DefinedClass, MainThreadMarker, MainThreadOnly};
+//! use objc2::{DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
 //! use objc2_app_kit::{NSApplication, NSApplicationDelegate};
-//! use objc2_foundation::{NSArray, NSURL, NSObject, NSObjectProtocol};
+//! use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSURL};
 //! use winit::event_loop::EventLoop;
 //!
 //! define_class!(
@@ -64,16 +63,39 @@
 //!     Ok(())
 //! }
 //! ```
+#![cfg(target_vendor = "apple")] // TODO: Remove once `objc2` allows compiling on all platforms
+
+#[macro_use]
+mod util;
+
+mod app;
+mod app_state;
+mod cursor;
+mod event;
+mod event_loop;
+mod ffi;
+mod menu;
+mod monitor;
+mod observer;
+mod view;
+mod window;
+mod window_delegate;
 
 use std::os::raw::c_void;
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
+#[doc(inline)]
+pub use winit_core::application::macos::ApplicationHandlerExtMacOS;
+use winit_core::event_loop::ActiveEventLoop;
+use winit_core::monitor::MonitorHandle;
+use winit_core::window::{PlatformWindowAttributes, Window};
 
-use crate::application::ApplicationHandler;
-use crate::event_loop::{ActiveEventLoop, EventLoopBuilder};
-use crate::monitor::MonitorHandle;
-use crate::window::{Window, WindowAttributes, WindowId};
+pub use self::event::{physicalkey_to_scancode, scancode_to_physicalkey};
+use self::event_loop::ActiveEventLoop as AppKitActiveEventLoop;
+pub use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};
+use self::monitor::MonitorHandle as AppKitMonitorHandle;
+use self::window::Window as AppKitWindow;
 
 /// Additional methods on [`Window`] that are specific to MacOS.
 pub trait WindowExtMacOS {
@@ -150,7 +172,9 @@ pub trait WindowExtMacOS {
     /// Getter for the [`WindowExtMacOS::set_option_as_alt`].
     fn option_as_alt(&self) -> OptionAsAlt;
 
-    /// Disable the Menu Bar and Dock in Borderless Fullscreen mode. Useful for games.
+    /// 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`].
@@ -167,109 +191,109 @@ pub trait WindowExtMacOS {
 impl WindowExtMacOS for dyn Window + '_ {
     #[inline]
     fn simple_fullscreen(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.simple_fullscreen())
     }
 
     #[inline]
     fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_simple_fullscreen(fullscreen))
     }
 
     #[inline]
     fn has_shadow(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.has_shadow())
     }
 
     #[inline]
     fn set_has_shadow(&self, has_shadow: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_has_shadow(has_shadow));
     }
 
     #[inline]
     fn set_tabbing_identifier(&self, identifier: &str) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.set_tabbing_identifier(identifier))
     }
 
     #[inline]
     fn tabbing_identifier(&self) -> String {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.tabbing_identifier())
     }
 
     #[inline]
     fn select_next_tab(&self) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.select_next_tab());
     }
 
     #[inline]
     fn select_previous_tab(&self) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.select_previous_tab());
     }
 
     #[inline]
     fn select_tab_at_index(&self, index: usize) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(move |w| w.select_tab_at_index(index));
     }
 
     #[inline]
     fn num_tabs(&self) -> usize {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.num_tabs())
     }
 
     #[inline]
     fn is_document_edited(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.is_document_edited())
     }
 
     #[inline]
     fn set_document_edited(&self, edited: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_document_edited(edited));
     }
 
     #[inline]
     fn set_option_as_alt(&self, option_as_alt: OptionAsAlt) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(move |w| w.set_option_as_alt(option_as_alt));
     }
 
     #[inline]
     fn option_as_alt(&self) -> OptionAsAlt {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.option_as_alt())
     }
 
     #[inline]
     fn set_borderless_game(&self, borderless_game: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.set_borderless_game(borderless_game))
     }
 
     #[inline]
     fn is_borderless_game(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.is_borderless_game())
     }
 
     #[inline]
     fn set_unified_titlebar(&self, unified_titlebar: bool) {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.set_unified_titlebar(unified_titlebar))
     }
 
     #[inline]
     fn unified_titlebar(&self) -> bool {
-        let window = self.as_any().downcast_ref::<crate::platform_impl::Window>().unwrap();
+        let window = self.cast_ref::<AppKitWindow>().unwrap();
         window.maybe_wait_on_main(|w| w.unified_titlebar())
     }
 }
@@ -289,7 +313,7 @@ pub enum ActivationPolicy {
     Prohibited,
 }
 
-/// Additional methods on [`WindowAttributes`] that are specific to MacOS.
+/// Window attributes that are specific to MacOS.
 ///
 /// **Note:** Properties dealing with the titlebar will be overwritten by the
 /// [`WindowAttributes::with_decorations`] method:
@@ -298,127 +322,158 @@ pub enum ActivationPolicy {
 /// - `with_titlebar_hidden`
 /// - `with_titlebar_buttons_hidden`
 /// - `with_fullsize_content_view`
-pub trait WindowAttributesExtMacOS {
+///
+/// [`WindowAttributes::with_decorations`]: crate::window::WindowAttributes::with_decorations
+#[derive(Clone, Debug, PartialEq)]
+pub struct WindowAttributesMacOS {
+    pub(crate) movable_by_window_background: bool,
+    pub(crate) titlebar_transparent: bool,
+    pub(crate) title_hidden: bool,
+    pub(crate) titlebar_hidden: bool,
+    pub(crate) titlebar_buttons_hidden: bool,
+    pub(crate) fullsize_content_view: bool,
+    pub(crate) disallow_hidpi: bool,
+    pub(crate) has_shadow: bool,
+    pub(crate) accepts_first_mouse: bool,
+    pub(crate) tabbing_identifier: Option<String>,
+    pub(crate) option_as_alt: OptionAsAlt,
+    pub(crate) borderless_game: bool,
+    pub(crate) unified_titlebar: bool,
+    pub(crate) panel: bool,
+}
+
+impl WindowAttributesMacOS {
     /// 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;
+    #[inline]
+    pub fn with_movable_by_window_background(mut self, movable_by_window_background: bool) -> Self {
+        self.movable_by_window_background = movable_by_window_background;
+        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;
+    #[inline]
+    pub fn with_titlebar_transparent(mut self, titlebar_transparent: bool) -> Self {
+        self.titlebar_transparent = titlebar_transparent;
+        self
+    }
+
     /// Hides the window titlebar.
-    fn with_titlebar_hidden(self, titlebar_hidden: bool) -> Self;
+    #[inline]
+    pub fn with_titlebar_hidden(mut self, titlebar_hidden: bool) -> Self {
+        self.titlebar_hidden = titlebar_hidden;
+        self
+    }
+
     /// Hides the window titlebar buttons.
-    fn with_titlebar_buttons_hidden(self, titlebar_buttons_hidden: bool) -> Self;
+    #[inline]
+    pub fn with_titlebar_buttons_hidden(mut self, titlebar_buttons_hidden: bool) -> Self {
+        self.titlebar_buttons_hidden = titlebar_buttons_hidden;
+        self
+    }
+
+    /// Hides the window title.
+    #[inline]
+    pub fn with_title_hidden(mut self, title_hidden: bool) -> Self {
+        self.title_hidden = title_hidden;
+        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;
+    #[inline]
+    pub fn with_fullsize_content_view(mut self, fullsize_content_view: bool) -> Self {
+        self.fullsize_content_view = fullsize_content_view;
+        self
+    }
+
+    #[inline]
+    pub fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> Self {
+        self.disallow_hidpi = disallow_hidpi;
+        self
+    }
+
+    #[inline]
+    pub fn with_has_shadow(mut self, has_shadow: bool) -> Self {
+        self.has_shadow = has_shadow;
+        self
+    }
+
     /// Window accepts click-through mouse events.
-    fn with_accepts_first_mouse(self, accepts_first_mouse: bool) -> Self;
+    #[inline]
+    pub fn with_accepts_first_mouse(mut self, accepts_first_mouse: bool) -> Self {
+        self.accepts_first_mouse = accepts_first_mouse;
+        self
+    }
+
     /// Defines the window tabbing identifier.
     ///
     /// <https://developer.apple.com/documentation/appkit/nswindow/1644704-tabbingidentifier>
-    fn with_tabbing_identifier(self, identifier: &str) -> Self;
+    #[inline]
+    pub fn with_tabbing_identifier(mut self, tabbing_identifier: &str) -> Self {
+        self.tabbing_identifier.replace(tabbing_identifier.to_string());
+        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;
+    #[inline]
+    pub fn with_option_as_alt(mut self, option_as_alt: OptionAsAlt) -> Self {
+        self.option_as_alt = option_as_alt;
+        self
+    }
+
     /// See [`WindowExtMacOS::set_borderless_game`] for details on what this means if set.
-    fn with_borderless_game(self, borderless_game: bool) -> Self;
+    #[inline]
+    pub fn with_borderless_game(mut self, borderless_game: bool) -> Self {
+        self.borderless_game = borderless_game;
+        self
+    }
+
     /// See [`WindowExtMacOS::set_unified_titlebar`] for details on what this means if set.
-    fn with_unified_titlebar(self, unified_titlebar: bool) -> Self;
+    #[inline]
+    pub fn with_unified_titlebar(mut self, unified_titlebar: bool) -> Self {
+        self.unified_titlebar = unified_titlebar;
+        self
+    }
+
     /// Use [`NSPanel`] window with [`NonactivatingPanel`] window style mask instead of
     /// [`NSWindow`].
     ///
     /// [`NSWindow`]: https://developer.apple.com/documentation/appkit/NSWindow?language=objc
     /// [`NSPanel`]: https://developer.apple.com/documentation/appkit/NSPanel?language=objc
     /// [`NonactivatingPanel`]: https://developer.apple.com/documentation/appkit/nswindow/stylemask-swift.struct/nonactivatingpanel?language=objc
-    fn with_panel(self, panel: bool) -> Self;
+    #[inline]
+    pub fn with_panel(mut self, panel: bool) -> Self {
+        self.panel = panel;
+        self
+    }
 }
 
-impl WindowAttributesExtMacOS for WindowAttributes {
+impl Default for WindowAttributesMacOS {
     #[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
+    fn default() -> Self {
+        Self {
+            movable_by_window_background: false,
+            titlebar_transparent: false,
+            title_hidden: false,
+            titlebar_hidden: false,
+            titlebar_buttons_hidden: false,
+            fullsize_content_view: false,
+            disallow_hidpi: false,
+            has_shadow: true,
+            accepts_first_mouse: true,
+            tabbing_identifier: None,
+            option_as_alt: Default::default(),
+            borderless_game: false,
+            unified_titlebar: false,
+            panel: false,
+        }
     }
+}
 
-    #[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
-    }
-
-    #[inline]
-    fn with_unified_titlebar(mut self, unified_titlebar: bool) -> Self {
-        self.platform_specific.unified_titlebar = unified_titlebar;
-        self
-    }
-
-    #[inline]
-    fn with_panel(mut self, panel: bool) -> Self {
-        self.platform_specific.panel = panel;
-        self
+impl PlatformWindowAttributes for WindowAttributesMacOS {
+    fn box_clone(&self) -> Box<dyn PlatformWindowAttributes> {
+        Box::from(self.clone())
     }
 }
 
@@ -477,44 +532,18 @@ pub trait EventLoopBuilderExtMacOS {
     fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self;
 }
 
-impl EventLoopBuilderExtMacOS for EventLoopBuilder {
-    #[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> {
+        let monitor = self.cast_ref::<AppKitMonitorHandle>().unwrap();
         // SAFETY: We only use the marker to get a pointer
         let mtm = unsafe { objc2::MainThreadMarker::new_unchecked() };
-        self.inner.ns_screen(mtm).map(|s| objc2::rc::Retained::as_ptr(&s) as _)
+        monitor.ns_screen(mtm).map(|s| objc2::rc::Retained::as_ptr(&s) as _)
     }
 }
 
@@ -536,34 +565,26 @@ pub trait ActiveEventLoopExtMacOS {
 
 impl ActiveEventLoopExtMacOS for dyn ActiveEventLoop + '_ {
     fn hide_application(&self) {
-        let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
-            .expect("non macOS event loop on macOS");
+        let event_loop =
+            self.cast_ref::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
         event_loop.hide_application()
     }
 
     fn hide_other_applications(&self) {
-        let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
-            .expect("non macOS event loop on macOS");
+        let event_loop =
+            self.cast_ref::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
         event_loop.hide_other_applications()
     }
 
     fn set_allows_automatic_window_tabbing(&self, enabled: bool) {
-        let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
-            .expect("non macOS event loop on macOS");
+        let event_loop =
+            self.cast_ref::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
         event_loop.set_allows_automatic_window_tabbing(enabled);
     }
 
     fn allows_automatic_window_tabbing(&self) -> bool {
-        let event_loop = self
-            .as_any()
-            .downcast_ref::<crate::platform_impl::ActiveEventLoop>()
-            .expect("non macOS event loop on macOS");
+        let event_loop =
+            self.cast_ref::<AppKitActiveEventLoop>().expect("non macOS event loop on macOS");
         event_loop.allows_automatic_window_tabbing()
     }
 }
@@ -587,52 +608,3 @@ pub enum OptionAsAlt {
     #[default]
     None,
 }
-
-/// Additional events on [`ApplicationHandler`] that are specific to macOS.
-///
-/// This can be registered with [`ApplicationHandler::macos_handler`].
-pub trait ApplicationHandlerExtMacOS: ApplicationHandler {
-    /// The system interpreted a keypress as a standard key binding command.
-    ///
-    /// Examples include inserting tabs and newlines, or moving the insertion point, see
-    /// [`NSStandardKeyBindingResponding`] for the full list of key bindings. They are often text
-    /// editing related.
-    ///
-    /// This corresponds to the [`doCommandBySelector:`] method on `NSTextInputClient`.
-    ///
-    /// The `action` parameter contains the string representation of the selector. Examples include
-    /// `"insertBacktab:"`, `"indent:"` and `"noop:"`.
-    ///
-    /// # Example
-    ///
-    /// ```ignore
-    /// impl ApplicationHandlerExtMacOS for App {
-    ///     fn standard_key_binding(
-    ///         &mut self,
-    ///         event_loop: &dyn ActiveEventLoop,
-    ///         window_id: WindowId,
-    ///         action: &str,
-    ///     ) {
-    ///         match action {
-    ///             "moveBackward:" => self.cursor.position -= 1,
-    ///             "moveForward:" => self.cursor.position += 1,
-    ///             _ => {} // Ignore other actions
-    ///         }
-    ///     }
-    /// }
-    /// ```
-    ///
-    /// [`NSStandardKeyBindingResponding`]: https://developer.apple.com/documentation/appkit/nsstandardkeybindingresponding?language=objc
-    /// [`doCommandBySelector:`]: https://developer.apple.com/documentation/appkit/nstextinputclient/1438256-docommandbyselector?language=objc
-    #[doc(alias = "doCommandBySelector:")]
-    fn standard_key_binding(
-        &mut self,
-        event_loop: &dyn ActiveEventLoop,
-        window_id: WindowId,
-        action: &str,
-    ) {
-        let _ = event_loop;
-        let _ = window_id;
-        let _ = action;
-    }
-}

winit-appkit/src/menu.rs

@@ -1,8 +1,8 @@
 use objc2::rc::Retained;
 use objc2::runtime::Sel;
-use objc2::{sel, MainThreadMarker};
+use objc2::{MainThreadMarker, sel};
 use objc2_app_kit::{NSApplication, NSEventModifierFlags, NSMenu, NSMenuItem};
-use objc2_foundation::{ns_string, NSProcessInfo, NSString};
+use objc2_foundation::{NSBundle, NSProcessInfo, NSString, ns_string};
 
 struct KeyEquivalent<'a> {
     key: &'a NSString,
@@ -16,7 +16,10 @@ pub fn initialize(app: &NSApplication) {
     menubar.addItem(&app_menu_item);
 
     let app_menu = NSMenu::new(mtm);
-    let process_name = NSProcessInfo::processInfo().processName();
+    let process_name = match NSBundle::mainBundle().name() {
+        Some(bundle_name) => bundle_name,
+        None => NSProcessInfo::processInfo().processName(),
+    };
 
     // About menu item
     let about_item_title = ns_string!("About ").stringByAppendingString(&process_name);
@@ -79,7 +82,7 @@ pub fn initialize(app: &NSApplication) {
     app_menu.addItem(&quit_item);
     app_menu_item.setSubmenu(Some(&app_menu));
 
-    unsafe { app.setServicesMenu(Some(&services_menu)) };
+    app.setServicesMenu(Some(&services_menu));
     app.setMainMenu(Some(&menubar));
 }
 

winit-appkit/src/monitor.rs

@@ -0,0 +1,402 @@
+#![allow(clippy::unnecessary_cast)]
+
+use std::collections::VecDeque;
+use std::num::{NonZeroU16, NonZeroU32};
+use std::ptr::NonNull;
+use std::{fmt, ptr};
+
+use dispatch2::run_on_main;
+use dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
+use objc2::MainThreadMarker;
+use objc2::rc::Retained;
+use objc2_app_kit::NSScreen;
+use objc2_core_foundation::{CFArray, CFRetained, CFUUID};
+use objc2_core_graphics::{
+    CGDirectDisplayID, CGDisplayBounds, CGDisplayCopyAllDisplayModes, CGDisplayCopyDisplayMode,
+    CGDisplayMode, CGDisplayModelNumber, CGGetActiveDisplayList, CGMainDisplayID,
+};
+use objc2_core_video::{CVDisplayLink, CVTimeFlags, kCVReturnSuccess};
+use objc2_foundation::{NSNumber, NSPoint, NSRect, ns_string};
+use tracing::warn;
+use winit_core::monitor::{MonitorHandleProvider, VideoMode};
+
+use super::ffi;
+use super::util::cgerr;
+
+#[derive(Clone)]
+pub struct VideoModeHandle {
+    pub(crate) mode: VideoMode,
+    pub(crate) monitor: MonitorHandle,
+    pub(crate) native_mode: NativeDisplayMode,
+}
+
+impl PartialEq for VideoModeHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.monitor == other.monitor && self.mode == other.mode
+    }
+}
+
+impl Eq for VideoModeHandle {}
+
+impl std::hash::Hash for VideoModeHandle {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.monitor.hash(state);
+    }
+}
+
+impl std::fmt::Debug for VideoModeHandle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("VideoModeHandle")
+            .field("mode", &self.mode)
+            .field("monitor", &self.monitor)
+            .finish()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct NativeDisplayMode(pub CFRetained<CGDisplayMode>);
+
+unsafe impl Send for NativeDisplayMode {}
+unsafe impl Sync for NativeDisplayMode {}
+
+impl VideoModeHandle {
+    fn new(
+        monitor: MonitorHandle,
+        native_mode: NativeDisplayMode,
+        refresh_rate_millihertz: Option<NonZeroU32>,
+    ) -> Self {
+        // The bit-depth is basically always 32 since macOS 10.12.
+        #[allow(deprecated)]
+        let pixel_encoding =
+            CGDisplayMode::pixel_encoding(Some(&native_mode.0)).unwrap().to_string();
+        let bit_depth = if pixel_encoding.eq_ignore_ascii_case(ffi::IO32BitDirectPixels) {
+            NonZeroU16::new(32)
+        } else if pixel_encoding.eq_ignore_ascii_case(ffi::IO16BitDirectPixels) {
+            NonZeroU16::new(16)
+        } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO30BitDirectPixels) {
+            NonZeroU16::new(30)
+        } else if pixel_encoding.eq_ignore_ascii_case(ffi::kIO64BitDirectPixels) {
+            NonZeroU16::new(64)
+        } else {
+            warn!(?pixel_encoding, "unknown bit depth");
+            None
+        };
+
+        let mode = VideoMode::new(
+            PhysicalSize::new(
+                CGDisplayMode::pixel_width(Some(&native_mode.0)) as u32,
+                CGDisplayMode::pixel_height(Some(&native_mode.0)) as u32,
+            ),
+            bit_depth,
+            refresh_rate_millihertz,
+        );
+
+        Self { mode, monitor: monitor.clone(), native_mode }
+    }
+}
+
+/// `CGDirectDisplayID` is documented as:
+/// > a framebuffer, a color correction (gamma) table, and possibly an attached monitor.
+///
+/// That is, it doesn't actually represent the monitor itself. Instead, we use the UUID of the
+/// monitor, as retrieved from `CGDisplayCreateUUIDFromDisplayID` (this makes the monitor ID stable,
+/// even across reboots and video mode changes).
+///
+/// NOTE: I'd be perfectly valid to store `[u8; 16]` in here instead, we only store `CFUUID` to
+/// avoid having to re-create it when we want to fetch the display ID.
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct MonitorHandle(CFRetained<CFUUID>);
+
+impl MonitorHandle {
+    /// Internal comparisons of [`MonitorHandle`]s are done first requesting a UUID for the handle.
+    fn uuid(&self) -> u128 {
+        u128::from_ne_bytes(self.0.uuid_bytes().into())
+    }
+
+    fn display_id(&self) -> CGDirectDisplayID {
+        unsafe { ffi::CGDisplayGetDisplayIDFromUUID(&self.0) }
+    }
+
+    #[track_caller]
+    pub(crate) fn new(display_id: CGDirectDisplayID) -> Option<Self> {
+        // kCGNullDirectDisplay
+        if display_id == 0 {
+            // `CGDisplayCreateUUIDFromDisplayID` checks kCGNullDirectDisplay internally.
+            warn!("constructing monitor from invalid display ID 0; falling back to main monitor");
+        }
+        // SAFETY: Valid to call.
+        let ptr = unsafe { ffi::CGDisplayCreateUUIDFromDisplayID(display_id) };
+        let ptr = NonNull::new(ptr)?;
+        // SAFETY: `CGDisplayCreateUUIDFromDisplayID` is a "create" function, so the pointer has
+        // +1 retain count.
+        let uuid = unsafe { CFRetained::from_raw(ptr) };
+        Some(Self(uuid))
+    }
+
+    fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
+        let current_display_mode =
+            NativeDisplayMode(CGDisplayCopyDisplayMode(self.display_id()).unwrap());
+        refresh_rate_millihertz(self.display_id(), &current_display_mode)
+    }
+
+    pub fn video_mode_handles(&self) -> impl Iterator<Item = VideoModeHandle> + 'static {
+        let refresh_rate_millihertz = self.refresh_rate_millihertz();
+        let monitor = self.clone();
+
+        let array = unsafe { CGDisplayCopyAllDisplayModes(self.display_id(), None) };
+        let modes = if let Some(array) = array {
+            // SAFETY: `CGDisplayCopyAllDisplayModes` is documented to return an array of
+            // display modes.
+            unsafe { CFRetained::cast_unchecked::<CFArray<CGDisplayMode>>(array) }
+        } else {
+            // Occasionally, certain CalDigit Thunderbolt Hubs report a spurious monitor during
+            // sleep/wake/cycling monitors. It tends to have null or 1 video mode only.
+            // See <https://github.com/bevyengine/bevy/issues/17827>.
+            warn!(monitor = ?self, "failed to get a list of display modes");
+            CFArray::empty()
+        };
+
+        modes.into_iter().map(move |mode| {
+            let cg_refresh_rate_hertz = CGDisplayMode::refresh_rate(Some(&mode));
+
+            // CGDisplayModeGetRefreshRate returns 0.0 for any display that
+            // isn't a CRT
+            let refresh_rate_millihertz = if cg_refresh_rate_hertz > 0.0 {
+                NonZeroU32::new((cg_refresh_rate_hertz * 1000.0).round() as u32)
+            } else {
+                refresh_rate_millihertz
+            };
+
+            VideoModeHandle::new(monitor.clone(), NativeDisplayMode(mode), refresh_rate_millihertz)
+        })
+    }
+
+    pub(crate) fn ns_screen(&self, mtm: MainThreadMarker) -> Option<Retained<NSScreen>> {
+        let uuid = self.uuid();
+        NSScreen::screens(mtm).into_iter().find(|screen| {
+            let other_native_id = get_display_id(screen);
+            if let Some(other) = MonitorHandle::new(other_native_id) {
+                uuid == other.uuid()
+            } else {
+                // Display ID was just fetched from live NSScreen, but can still result in `None`
+                // with certain Thunderbolt docked monitors.
+                warn!(other_native_id, "comparing against screen with invalid display ID");
+                false
+            }
+        })
+    }
+}
+
+impl MonitorHandleProvider for MonitorHandle {
+    fn id(&self) -> u128 {
+        self.uuid()
+    }
+
+    fn native_id(&self) -> u64 {
+        self.display_id() as _
+    }
+
+    // TODO: Be smarter about this:
+    //
+    // <https://github.com/glfw/glfw/blob/57cbded0760a50b9039ee0cb3f3c14f60145567c/src/cocoa_monitor.m#L44-L126>
+    fn name(&self) -> Option<std::borrow::Cow<'_, str>> {
+        let screen_num = CGDisplayModelNumber(self.display_id());
+        Some(format!("Monitor #{screen_num}").into())
+    }
+
+    fn position(&self) -> Option<PhysicalPosition<i32>> {
+        // This is already in screen coordinates. If we were using `NSScreen`,
+        // then a conversion would've been needed:
+        // flip_window_screen_coordinates(self.ns_screen(mtm)?.frame())
+        let bounds = CGDisplayBounds(self.display_id());
+        let position = LogicalPosition::new(bounds.origin.x, bounds.origin.y);
+        Some(position.to_physical(self.scale_factor()))
+    }
+
+    fn scale_factor(&self) -> f64 {
+        run_on_main(|mtm| {
+            match self.ns_screen(mtm) {
+                Some(screen) => screen.backingScaleFactor() as f64,
+                None => 1.0, // default to 1.0 when we can't find the screen
+            }
+        })
+    }
+
+    fn current_video_mode(&self) -> Option<VideoMode> {
+        let mode = NativeDisplayMode(CGDisplayCopyDisplayMode(self.display_id()).unwrap());
+        let refresh_rate_millihertz = refresh_rate_millihertz(self.display_id(), &mode);
+        Some(VideoModeHandle::new(self.clone(), mode, refresh_rate_millihertz).mode)
+    }
+
+    fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
+        Box::new(self.video_mode_handles().map(|mode| mode.mode))
+    }
+}
+
+pub fn available_monitors() -> VecDeque<MonitorHandle> {
+    let mut expected_count = 0;
+    let res = cgerr(unsafe { CGGetActiveDisplayList(0, ptr::null_mut(), &mut expected_count) });
+    if res.is_err() {
+        return VecDeque::with_capacity(0);
+    }
+
+    let mut displays: Vec<CGDirectDisplayID> = vec![0; expected_count as usize];
+    let mut actual_count = 0;
+    let res = cgerr(unsafe {
+        CGGetActiveDisplayList(expected_count, displays.as_mut_ptr(), &mut actual_count)
+    });
+    displays.truncate(actual_count as usize);
+
+    if res.is_err() {
+        return VecDeque::with_capacity(0);
+    }
+
+    let mut monitors = VecDeque::with_capacity(displays.len());
+    for display in displays {
+        // Display ID just fetched from `CGGetActiveDisplayList`, should be fine to unwrap.
+        monitors.push_back(MonitorHandle::new(display).expect("invalid display ID"));
+    }
+    monitors
+}
+
+pub fn primary_monitor() -> MonitorHandle {
+    // Display ID just fetched from `CGMainDisplayID`, should be fine to unwrap.
+    MonitorHandle::new(CGMainDisplayID()).expect("invalid display ID")
+}
+
+impl fmt::Debug for MonitorHandle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MonitorHandle")
+            .field("name", &self.name())
+            .field("uuid", &self.uuid())
+            .field("display_id", &self.display_id())
+            .field("position", &self.position())
+            .field("scale_factor", &self.scale_factor())
+            .finish_non_exhaustive()
+    }
+}
+
+pub(crate) fn get_display_id(screen: &NSScreen) -> u32 {
+    let key = ns_string!("NSScreenNumber");
+
+    objc2::rc::autoreleasepool(|_| {
+        let device_description = screen.deviceDescription();
+
+        // Retrieve the CGDirectDisplayID associated with this screen
+        //
+        // The value from @"NSScreenNumber" in deviceDescription is guaranteed
+        // to be an NSNumber. See documentation for details:
+        // <https://developer.apple.com/documentation/appkit/nsscreen/1388360-devicedescription?language=objc>
+        let obj = device_description
+            .objectForKey(key)
+            .expect("failed getting screen display id from device description")
+            .downcast::<NSNumber>()
+            .expect("NSScreenNumber must be NSNumber");
+
+        obj.as_u32()
+    })
+}
+
+/// Core graphics screen coordinates are relative to the top-left corner of
+/// the so-called "main" display, with y increasing downwards - which is
+/// exactly what we want in Winit.
+///
+/// However, `NSWindow` and `NSScreen` changes these coordinates to:
+/// 1. Be relative to the bottom-left corner of the "main" screen.
+/// 2. Be relative to the bottom-left corner of the window/screen itself.
+/// 3. Have y increasing upwards.
+///
+/// This conversion happens to be symmetric, so we only need this one function
+/// to convert between the two coordinate systems.
+pub(crate) fn flip_window_screen_coordinates(frame: NSRect) -> NSPoint {
+    // It is intentional that we use `CGMainDisplayID` (as opposed to
+    // `NSScreen::mainScreen`), because that's what the screen coordinates
+    // are relative to, no matter which display the window is currently on.
+    let main_screen_height = CGDisplayBounds(CGMainDisplayID()).size.height;
+
+    let y = main_screen_height - frame.size.height - frame.origin.y;
+    NSPoint::new(frame.origin.x, y)
+}
+
+fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> Option<NonZeroU32> {
+    let refresh_rate = CGDisplayMode::refresh_rate(Some(&mode.0));
+    if refresh_rate > 0.0 {
+        return NonZeroU32::new((refresh_rate * 1000.0).round() as u32);
+    }
+
+    let mut display_link = std::ptr::null_mut();
+    #[allow(deprecated)]
+    if unsafe { CVDisplayLink::create_with_cg_display(id, NonNull::from(&mut display_link)) }
+        != kCVReturnSuccess
+    {
+        return None;
+    }
+    let display_link = unsafe { CFRetained::from_raw(NonNull::new(display_link).unwrap()) };
+    #[allow(deprecated)]
+    let time = display_link.nominal_output_video_refresh_period();
+
+    // This value is indefinite if an invalid display link was specified
+    if time.flags & CVTimeFlags::IsIndefinite.0 != 0 {
+        return None;
+    }
+
+    (time.timeScale as i64)
+        .checked_div(time.timeValue)
+        .map(|v| (v * 1000) as u32)
+        .and_then(NonZeroU32::new)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn uuid_stable() {
+        let primary_id = CGMainDisplayID();
+
+        let handle_a = MonitorHandle::new(primary_id).unwrap();
+        let handle_b = MonitorHandle::new(primary_id).unwrap();
+        assert_eq!(handle_a, handle_b);
+        assert_eq!(handle_a.display_id(), handle_b.display_id());
+        assert_eq!(handle_a.uuid(), handle_b.uuid());
+
+        let handle_a = primary_monitor();
+        let handle_b = primary_monitor();
+        assert_eq!(handle_a, handle_b);
+        assert_eq!(handle_a.display_id(), handle_b.display_id());
+        assert_eq!(handle_a.uuid(), handle_b.uuid());
+    }
+
+    /// Test the MonitorHandle::new fallback.
+    #[test]
+    fn monitorhandle_from_zero() {
+        let primary_id = CGMainDisplayID();
+
+        let handle0 = MonitorHandle::new(0).unwrap();
+        let handle1 = MonitorHandle::new(primary_id).unwrap();
+        assert_eq!(handle0, handle1);
+        assert_eq!(handle0.display_id(), handle1.display_id());
+        assert_eq!(handle0.uuid(), handle1.uuid());
+    }
+
+    #[test]
+    fn from_invalid_id() {
+        // Assume there are never this many monitors connected.
+        assert!(MonitorHandle::new(10000).is_none());
+    }
+
+    /// Test that calling `CGDisplayGetDisplayIDFromUUID` on an invalid UUID returns an invalid
+    /// display ID.
+    #[test]
+    fn invalid_monitor_handle() {
+        // `CGMainDisplayID` must be called to avoid:
+        // ```
+        // Assertion failed: (did_initialize), function CGS_REQUIRE_INIT, file CGInitialization.c, line 44.
+        // ```
+        // See https://github.com/JXA-Cookbook/JXA-Cookbook/issues/27#issuecomment-277517668
+        let _ = CGMainDisplayID();
+
+        let handle = MonitorHandle(CFUUID::new(None).unwrap());
+        assert_eq!(handle.display_id(), 0);
+    }
+}

winit-appkit/src/observer.rs

@@ -0,0 +1,87 @@
+use std::ffi::c_void;
+use std::ptr;
+use std::time::Instant;
+
+use objc2_core_foundation::{
+    CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, kCFRunLoopCommonModes,
+};
+
+#[derive(Debug)]
+pub struct EventLoopWaker {
+    timer: CFRetained<CFRunLoopTimer>,
+
+    /// An arbitrary instant in the past, that will trigger an immediate wake
+    /// We save this as the `next_fire_date` for consistency so we can
+    /// easily check if the next_fire_date needs updating.
+    start_instant: Instant,
+
+    /// This is what the `NextFireDate` has been set to.
+    /// `None` corresponds to `waker.stop()` and `start_instant` is used
+    /// for `waker.start()`
+    next_fire_date: Option<Instant>,
+}
+
+impl Drop for EventLoopWaker {
+    fn drop(&mut self) {
+        self.timer.invalidate();
+    }
+}
+
+impl EventLoopWaker {
+    pub(crate) fn new() -> Self {
+        extern "C-unwind" fn wakeup_main_loop(_timer: *mut CFRunLoopTimer, _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 = CFRunLoopTimer::new(
+                None,
+                f64::MAX,
+                0.000_000_1,
+                0,
+                0,
+                Some(wakeup_main_loop),
+                ptr::null_mut(),
+            )
+            .unwrap();
+            CFRunLoop::main().unwrap().add_timer(Some(&timer), kCFRunLoopCommonModes);
+            Self { timer, start_instant: Instant::now(), next_fire_date: None }
+        }
+    }
+
+    pub fn stop(&mut self) {
+        if self.next_fire_date.is_some() {
+            self.next_fire_date = None;
+            self.timer.set_next_fire_date(f64::MAX);
+        }
+    }
+
+    pub fn start(&mut self) {
+        if self.next_fire_date != Some(self.start_instant) {
+            self.next_fire_date = Some(self.start_instant);
+            self.timer.set_next_fire_date(f64::MIN);
+        }
+    }
+
+    pub fn start_at(&mut self, instant: Option<Instant>) {
+        let now = Instant::now();
+        match instant {
+            Some(instant) if now >= instant => {
+                self.start();
+            },
+            Some(instant) => {
+                if self.next_fire_date != Some(instant) {
+                    self.next_fire_date = Some(instant);
+                    let current = CFAbsoluteTimeGetCurrent();
+                    let duration = instant - now;
+                    let fsecs = duration.subsec_nanos() as f64 / 1_000_000_000.0
+                        + duration.as_secs() as f64;
+                    self.timer.set_next_fire_date(current + fsecs);
+                }
+            },
+            None => {
+                self.stop();
+            },
+        }
+    }
+}

winit-appkit/src/util.rs

@@ -0,0 +1,11 @@
+use objc2_core_graphics::CGError;
+use winit_core::error::OsError;
+
+macro_rules! os_error {
+    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
+}
+
+#[track_caller]
+pub(crate) fn cgerr(err: CGError) -> Result<(), OsError> {
+    if err == CGError::Success { Ok(()) } else { Err(os_error!(format!("CGError {err:?}"))) }
+}

winit-appkit/src/view.rs

@@ -1,20 +1,28 @@
 #![allow(clippy::unnecessary_cast)]
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, VecDeque};
-use std::ptr;
 use std::rc::Rc;
 
+use dpi::{LogicalPosition, PhysicalSize};
 use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, Sel};
-use objc2::{define_class, msg_send, DefinedClass, MainThreadMarker};
+use objc2::{AnyThread, DefinedClass, MainThreadMarker, define_class, msg_send};
 use objc2_app_kit::{
-    NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient,
-    NSTrackingRectTag, NSView, NSWindow,
+    NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient, NSTrackingArea,
+    NSTrackingAreaOptions, NSView, NSViewLayerContentsRedrawPolicy, NSWindow,
 };
+use objc2_core_foundation::CGRect;
 use objc2_foundation::{
     NSArray, NSAttributedString, NSAttributedStringKey, NSCopying, NSMutableAttributedString,
     NSNotFound, NSObject, NSPoint, NSRange, NSRect, NSSize, NSString, NSUInteger,
 };
+use tracing::{debug_span, trace_span};
+use winit_core::event::{
+    DeviceEvent, ElementState, Ime, KeyEvent, Modifiers, MouseButton, MouseScrollDelta,
+    PointerKind, PointerSource, TouchPhase, WindowEvent,
+};
+use winit_core::keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey};
+use winit_core::window::ImeCapabilities;
 
 use super::app_state::AppState;
 use super::cursor::{default_cursor, invisible_cursor};
@@ -23,13 +31,7 @@ use super::event::{
     scancode_to_physicalkey,
 };
 use super::window::window_id;
-use crate::dpi::{LogicalPosition, LogicalSize};
-use crate::event::{
-    DeviceEvent, ElementState, Ime, KeyEvent, Modifiers, MouseButton, MouseScrollDelta,
-    PointerKind, PointerSource, TouchPhase, WindowEvent,
-};
-use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey};
-use crate::platform::macos::OptionAsAlt;
+use crate::OptionAsAlt;
 
 #[derive(Debug)]
 struct CursorState {
@@ -81,7 +83,7 @@ fn key_to_modifier(key: &Key) -> Option<ModifiersState> {
     match key {
         Key::Named(NamedKey::Alt) => Some(ModifiersState::ALT),
         Key::Named(NamedKey::Control) => Some(ModifiersState::CONTROL),
-        Key::Named(NamedKey::Super) => Some(ModifiersState::SUPER),
+        Key::Named(NamedKey::Meta) => Some(ModifiersState::META),
         Key::Named(NamedKey::Shift) => Some(ModifiersState::SHIFT),
         _ => None,
     }
@@ -92,7 +94,7 @@ fn get_right_modifier_code(key: &Key) -> KeyCode {
         Key::Named(NamedKey::Alt) => KeyCode::AltRight,
         Key::Named(NamedKey::Control) => KeyCode::ControlRight,
         Key::Named(NamedKey::Shift) => KeyCode::ShiftRight,
-        Key::Named(NamedKey::Super) => KeyCode::SuperRight,
+        Key::Named(NamedKey::Meta) => KeyCode::MetaRight,
         _ => unreachable!(),
     }
 }
@@ -102,7 +104,7 @@ fn get_left_modifier_code(key: &Key) -> KeyCode {
         Key::Named(NamedKey::Alt) => KeyCode::AltLeft,
         Key::Named(NamedKey::Control) => KeyCode::ControlLeft,
         Key::Named(NamedKey::Shift) => KeyCode::ShiftLeft,
-        Key::Named(NamedKey::Super) => KeyCode::SuperLeft,
+        Key::Named(NamedKey::Meta) => KeyCode::MetaLeft,
         _ => unreachable!(),
     }
 }
@@ -117,19 +119,17 @@ pub struct ViewState {
     ime_size: Cell<NSSize>,
     modifiers: Cell<Modifiers>,
     phys_modifiers: RefCell<HashMap<Key, ModLocationMask>>,
-    tracking_rect: Cell<Option<NSTrackingRectTag>>,
     ime_state: Cell<ImeState>,
     input_source: RefCell<String>,
 
     /// True iff the application wants IME events.
     ///
     /// Can be set using `set_ime_allowed`
-    ime_allowed: Cell<bool>,
+    ime_capabilities: Cell<Option<ImeCapabilities>>,
 
     /// True if the current key event should be forwarded
     /// to the application, even during IME
     forward_key_to_app: Cell<bool>,
-
     marked_text: RefCell<Retained<NSMutableAttributedString>>,
     accepts_first_mouse: bool,
 
@@ -151,49 +151,35 @@ define_class!(
             true
         }
 
-        #[unsafe(method(viewDidMoveToWindow))]
-        fn view_did_move_to_window(&self) {
-            trace_scope!("viewDidMoveToWindow");
-            if let Some(tracking_rect) = self.ivars().tracking_rect.take() {
-                self.removeTrackingRect(tracking_rect);
-            }
-
-            let rect = self.frame();
-            let tracking_rect = unsafe {
-                self.addTrackingRect_owner_userData_assumeInside(rect, self, ptr::null_mut(), false)
-            };
-            assert_ne!(tracking_rect, 0, "failed adding tracking rect");
-            self.ivars().tracking_rect.set(Some(tracking_rect));
-        }
-
         // Not a normal method on `NSView`, it's triggered by `NSViewFrameDidChangeNotification`.
         #[unsafe(method(viewFrameDidChangeNotification:))]
         fn frame_did_change(&self, _notification: Option<&AnyObject>) {
-            trace_scope!("NSViewFrameDidChangeNotification");
-            if let Some(tracking_rect) = self.ivars().tracking_rect.take() {
-                self.removeTrackingRect(tracking_rect);
-            }
-
-            let rect = self.frame();
-            let tracking_rect = unsafe {
-                self.addTrackingRect_owner_userData_assumeInside(rect, self, ptr::null_mut(), false)
-            };
-            assert_ne!(tracking_rect, 0, "failed adding tracking rect");
-            self.ivars().tracking_rect.set(Some(tracking_rect));
+            let _entered = debug_span!("NSViewFrameDidChangeNotification").entered();
 
             // Emit resize event here rather than from windowDidResize because:
             // 1. When a new window is created as a tab, the frame size may change without a window
             //    resize occurring.
             // 2. Even when a window resize does occur on a new tabbed window, it contains the wrong
             //    size (includes tab height).
-            let logical_size = LogicalSize::new(rect.size.width as f64, rect.size.height as f64);
-            let size = logical_size.to_physical::<u32>(self.scale_factor());
-            self.queue_event(WindowEvent::SurfaceResized(size));
+            self.surface_resized();
+            // During live resize, AppKit may not let the normal event loop reach its next redraw
+            // point before stretching the current layer contents. Redraw immediately after the
+            // app has observed the new surface size.
+            self.redraw_during_live_resize();
+        }
+
+        #[unsafe(method(viewDidChangeBackingProperties))]
+        fn view_did_change_backing_properties(&self) {
+            let _entered = debug_span!("viewDidChangeBackingProperties").entered();
+            // Moving between displays or changing scale can alter the drawable backing size
+            // without a matching frame-size change.
+            self.surface_resized();
+            self.redraw_during_live_resize();
         }
 
         #[unsafe(method(drawRect:))]
         fn draw_rect(&self, _rect: NSRect) {
-            trace_scope!("drawRect:");
+            let _entered = debug_span!("drawRect:").entered();
 
             self.ivars().app_state.handle_redraw(window_id(&self.window()));
 
@@ -202,7 +188,7 @@ define_class!(
 
         #[unsafe(method(acceptsFirstResponder))]
         fn accepts_first_responder(&self) -> bool {
-            trace_scope!("acceptsFirstResponder");
+            let _entered = trace_span!("acceptsFirstResponder").entered();
             true
         }
 
@@ -216,13 +202,13 @@ define_class!(
         // extension for using `NSTouchBar`
         #[unsafe(method_id(touchBar))]
         fn touch_bar(&self) -> Option<Retained<NSObject>> {
-            trace_scope!("touchBar");
+            let _entered = debug_span!("touchBar").entered();
             None
         }
 
         #[unsafe(method(resetCursorRects))]
         fn reset_cursor_rects(&self) {
-            trace_scope!("resetCursorRects");
+            let _entered = debug_span!("resetCursorRects").entered();
             let bounds = self.bounds();
             let cursor_state = self.ivars().cursor_state.borrow();
             // We correctly invoke `addCursorRect` only from inside `resetCursorRects`
@@ -237,13 +223,13 @@ define_class!(
     unsafe impl NSTextInputClient for WinitView {
         #[unsafe(method(hasMarkedText))]
         fn has_marked_text(&self) -> bool {
-            trace_scope!("hasMarkedText");
+            let _entered = debug_span!("hasMarkedText").entered();
             self.ivars().marked_text.borrow().length() > 0
         }
 
         #[unsafe(method(markedRange))]
         fn marked_range(&self) -> NSRange {
-            trace_scope!("markedRange");
+            let _entered = debug_span!("markedRange").entered();
             let length = self.ivars().marked_text.borrow().length();
             if length > 0 {
                 NSRange::new(0, length)
@@ -255,7 +241,7 @@ define_class!(
 
         #[unsafe(method(selectedRange))]
         fn selected_range(&self) -> NSRange {
-            trace_scope!("selectedRange");
+            let _entered = debug_span!("selectedRange").entered();
             // Documented to return `{NSNotFound, 0}` if there is no selection.
             NSRange::new(NSNotFound as NSUInteger, 0)
         }
@@ -268,7 +254,7 @@ define_class!(
             _replacement_range: NSRange,
         ) {
             // TODO: Use _replacement_range, requires changing the event to report surrounding text.
-            trace_scope!("setMarkedText:selectedRange:replacementRange:");
+            let _entered = debug_span!("setMarkedText:selectedRange:replacementRange:").entered();
 
             let (marked_text, string) = if let Some(string) =
                 string.downcast_ref::<NSAttributedString>()
@@ -290,33 +276,38 @@ define_class!(
                 self.queue_event(WindowEvent::Ime(Ime::Enabled));
             }
 
-            if unsafe { self.hasMarkedText() } {
+            if self.hasMarkedText() {
                 self.ivars().ime_state.set(ImeState::Preedit);
             } else {
                 // In case the preedit was cleared, set IME into the Ground state.
                 self.ivars().ime_state.set(ImeState::Ground);
             }
 
+            let string = string.to_string();
             let cursor_range = if string.is_empty() {
                 // An empty string basically means that there's no preedit, so indicate that by
                 // sending a `None` cursor range.
                 None
             } else {
-                // Convert the selected range from UTF-16 indices to UTF-8 indices.
-                let sub_string_a = unsafe { string.substringToIndex(selected_range.location) };
-                let sub_string_b = unsafe { string.substringToIndex(selected_range.end()) };
-                let lowerbound_utf8 = sub_string_a.len();
-                let upperbound_utf8 = sub_string_b.len();
+                // Convert the selected range from UTF-16 code unit indices to UTF-8 byte
+                // offsets. `utf16_to_utf8_offset` is defensive: it snaps an offset that would
+                // split a surrogate pair down to the character boundary and clamps an
+                // out-of-bounds offset to the string length, so no `NSRangeException` is
+                // possible and the resulting range can never be inverted (`lower <= upper`).
+                // IMEs are known to send both mid-surrogate and out-of-bounds offsets (e.g.
+                // native Pinyin, see https://github.com/alacritty/alacritty/issues/8791).
+                let lowerbound_utf8 = utf16_to_utf8_offset(&string, selected_range.location);
+                let upperbound_utf8 = utf16_to_utf8_offset(&string, selected_range.end());
                 Some((lowerbound_utf8, upperbound_utf8))
             };
 
             // Send WindowEvent for updating marked text
-            self.queue_event(WindowEvent::Ime(Ime::Preedit(string.to_string(), cursor_range)));
+            self.queue_event(WindowEvent::Ime(Ime::Preedit(string, cursor_range)));
         }
 
         #[unsafe(method(unmarkText))]
         fn unmark_text(&self) {
-            trace_scope!("unmarkText");
+            let _entered = debug_span!("unmarkText").entered();
             *self.ivars().marked_text.borrow_mut() = NSMutableAttributedString::new();
 
             let input_context = self.inputContext().expect("input context");
@@ -333,7 +324,7 @@ define_class!(
 
         #[unsafe(method_id(validAttributesForMarkedText))]
         fn valid_attributes_for_marked_text(&self) -> Retained<NSArray<NSAttributedStringKey>> {
-            trace_scope!("validAttributesForMarkedText");
+            let _entered = trace_span!("validAttributesForMarkedText").entered();
             NSArray::new()
         }
 
@@ -343,13 +334,14 @@ define_class!(
             _range: NSRange,
             _actual_range: *mut NSRange,
         ) -> Option<Retained<NSAttributedString>> {
-            trace_scope!("attributedSubstringForProposedRange:actualRange:");
+            let _entered =
+                trace_span!("attributedSubstringForProposedRange:actualRange:").entered();
             None
         }
 
         #[unsafe(method(characterIndexForPoint:))]
         fn character_index_for_point(&self, _point: NSPoint) -> NSUInteger {
-            trace_scope!("characterIndexForPoint:");
+            let _entered = debug_span!("characterIndexForPoint:").entered();
             0
         }
 
@@ -359,16 +351,23 @@ define_class!(
             _range: NSRange,
             _actual_range: *mut NSRange,
         ) -> NSRect {
-            trace_scope!("firstRectForCharacterRange:actualRange:");
+            let _entered = debug_span!("firstRectForCharacterRange:actualRange:").entered();
+
+            // Guard when the view is no longer in a window during teardown.
+            let Some(window) = (**self).window() else {
+                return CGRect::ZERO;
+            };
+
+            // Return value is expected to be in screen coordinates, so we need a conversion
             let rect = NSRect::new(self.ivars().ime_position.get(), self.ivars().ime_size.get());
-            // Return value is expected to be in screen coordinates, so we need a conversion here
-            self.window().convertRectToScreen(self.convertRect_toView(rect, None))
+            let view_rect = self.convertRect_toView(rect, None);
+            window.convertRectToScreen(view_rect)
         }
 
         #[unsafe(method(insertText:replacementRange:))]
         fn insert_text(&self, string: &NSObject, _replacement_range: NSRange) {
             // TODO: Use _replacement_range, requires changing the event to report surrounding text.
-            trace_scope!("insertText:replacementRange:");
+            let _entered = debug_span!("insertText:replacementRange:").entered();
 
             let string = if let Some(string) = string.downcast_ref::<NSAttributedString>() {
                 string.string().to_string()
@@ -382,7 +381,7 @@ define_class!(
             let is_control = string.chars().next().is_some_and(|c| c.is_control());
 
             // Commit only if we have marked text.
-            if unsafe { self.hasMarkedText() } && self.is_ime_enabled() && !is_control {
+            if self.hasMarkedText() && self.is_ime_enabled() && !is_control {
                 self.queue_event(WindowEvent::Ime(Ime::Preedit(String::new(), None)));
                 self.queue_event(WindowEvent::Ime(Ime::Commit(string)));
                 self.ivars().ime_state.set(ImeState::Committed);
@@ -393,7 +392,7 @@ define_class!(
         // "human readable" character happens, i.e. newlines, tabs, and Ctrl+C.
         #[unsafe(method(doCommandBySelector:))]
         fn do_command_by_selector(&self, command: Sel) {
-            trace_scope!("doCommandBySelector:");
+            let _entered = debug_span!("doCommandBySelector:").entered();
 
             // We shouldn't forward any character from just committed text, since we'll end up
             // sending it twice with some IMEs like Korean one. We'll also always send
@@ -405,8 +404,7 @@ define_class!(
 
             self.ivars().forward_key_to_app.set(true);
 
-            if unsafe { self.hasMarkedText() } && self.ivars().ime_state.get() == ImeState::Preedit
-            {
+            if self.hasMarkedText() && self.ivars().ime_state.get() == ImeState::Preedit {
                 // Leave preedit so that we also report the key-up for this key.
                 self.ivars().ime_state.set(ImeState::Ground);
             }
@@ -433,7 +431,7 @@ define_class!(
     impl WinitView {
         #[unsafe(method(keyDown:))]
         fn key_down(&self, event: &NSEvent) {
-            trace_scope!("keyDown:");
+            let _entered = debug_span!("keyDown:").entered();
             {
                 let mut prev_input_source = self.ivars().input_source.borrow_mut();
                 let current_input_source = self.current_input_source();
@@ -456,9 +454,9 @@ define_class!(
             // we must send the `KeyboardInput` event during IME if it triggered
             // `doCommandBySelector`. (doCommandBySelector means that the keyboard input
             // is not handled by IME and should be handled by the application)
-            if self.ivars().ime_allowed.get() {
+            if self.ivars().ime_capabilities.get().is_some() {
                 let events_for_nsview = NSArray::from_slice(&[&*event]);
-                unsafe { self.interpretKeyEvents(&events_for_nsview) };
+                self.interpretKeyEvents(&events_for_nsview);
 
                 // If the text was committed we must treat the next keyboard event as IME related.
                 if self.ivars().ime_state.get() == ImeState::Committed {
@@ -481,7 +479,7 @@ define_class!(
             };
 
             if !had_ime_input || self.ivars().forward_key_to_app.get() {
-                let key_event = create_key_event(&event, true, unsafe { event.isARepeat() });
+                let key_event = create_key_event(&event, true, event.isARepeat());
                 self.queue_event(WindowEvent::KeyboardInput {
                     device_id: None,
                     event: key_event,
@@ -492,7 +490,7 @@ define_class!(
 
         #[unsafe(method(keyUp:))]
         fn key_up(&self, event: &NSEvent) {
-            trace_scope!("keyUp:");
+            let _entered = debug_span!("keyUp:").entered();
 
             let event = replace_event(event, self.option_as_alt());
             self.update_modifiers(&event, false);
@@ -509,14 +507,14 @@ define_class!(
 
         #[unsafe(method(flagsChanged:))]
         fn flags_changed(&self, event: &NSEvent) {
-            trace_scope!("flagsChanged:");
+            let _entered = debug_span!("flagsChanged:").entered();
 
             self.update_modifiers(event, true);
         }
 
         #[unsafe(method(insertTab:))]
         fn insert_tab(&self, _sender: Option<&AnyObject>) {
-            trace_scope!("insertTab:");
+            let _entered = debug_span!("insertTab:").entered();
             let window = self.window();
             if let Some(first_responder) = window.firstResponder() {
                 if *first_responder == ***self {
@@ -527,7 +525,7 @@ define_class!(
 
         #[unsafe(method(insertBackTab:))]
         fn insert_back_tab(&self, _sender: Option<&AnyObject>) {
-            trace_scope!("insertBackTab:");
+            let _entered = debug_span!("insertBackTab:").entered();
             let window = self.window();
             if let Some(first_responder) = window.firstResponder() {
                 if *first_responder == ***self {
@@ -541,14 +539,14 @@ define_class!(
         #[unsafe(method(cancelOperation:))]
         fn cancel_operation(&self, _sender: Option<&AnyObject>) {
             let mtm = MainThreadMarker::from(self);
-            trace_scope!("cancelOperation:");
+            let _entered = debug_span!("cancelOperation:").entered();
 
             let event = NSApplication::sharedApplication(mtm)
                 .currentEvent()
                 .expect("could not find current event");
 
             self.update_modifiers(&event, false);
-            let event = create_key_event(&event, true, unsafe { event.isARepeat() });
+            let event = create_key_event(&event, true, event.isARepeat());
 
             self.queue_event(WindowEvent::KeyboardInput {
                 device_id: None,
@@ -570,71 +568,73 @@ define_class!(
 
         #[unsafe(method(mouseDown:))]
         fn mouse_down(&self, event: &NSEvent) {
-            trace_scope!("mouseDown:");
+            let _entered = debug_span!("mouseDown:").entered();
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Pressed);
         }
 
         #[unsafe(method(mouseUp:))]
         fn mouse_up(&self, event: &NSEvent) {
-            trace_scope!("mouseUp:");
+            let _entered = debug_span!("mouseUp:").entered();
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Released);
         }
 
         #[unsafe(method(rightMouseDown:))]
         fn right_mouse_down(&self, event: &NSEvent) {
-            trace_scope!("rightMouseDown:");
+            let _entered = debug_span!("rightMouseDown:").entered();
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Pressed);
         }
 
         #[unsafe(method(rightMouseUp:))]
         fn right_mouse_up(&self, event: &NSEvent) {
-            trace_scope!("rightMouseUp:");
+            let _entered = debug_span!("rightMouseUp:").entered();
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Released);
         }
 
         #[unsafe(method(otherMouseDown:))]
         fn other_mouse_down(&self, event: &NSEvent) {
-            trace_scope!("otherMouseDown:");
+            let _entered = debug_span!("otherMouseDown:").entered();
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Pressed);
         }
 
         #[unsafe(method(otherMouseUp:))]
         fn other_mouse_up(&self, event: &NSEvent) {
-            trace_scope!("otherMouseUp:");
+            let _entered = debug_span!("otherMouseUp:").entered();
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Released);
         }
 
-        // No tracing on these because that would be overly verbose
-
         #[unsafe(method(mouseMoved:))]
         fn mouse_moved(&self, event: &NSEvent) {
+            let _entered = debug_span!("mouseMoved:").entered();
             self.mouse_motion(event);
         }
 
         #[unsafe(method(mouseDragged:))]
         fn mouse_dragged(&self, event: &NSEvent) {
+            let _entered = debug_span!("mouseDragged:").entered();
             self.mouse_motion(event);
         }
 
         #[unsafe(method(rightMouseDragged:))]
         fn right_mouse_dragged(&self, event: &NSEvent) {
+            let _entered = debug_span!("rightMouseDragged:").entered();
             self.mouse_motion(event);
         }
 
         #[unsafe(method(otherMouseDragged:))]
         fn other_mouse_dragged(&self, event: &NSEvent) {
+            let _entered = debug_span!("otherMouseDragged:").entered();
             self.mouse_motion(event);
         }
 
         #[unsafe(method(mouseEntered:))]
         fn mouse_entered(&self, event: &NSEvent) {
-            trace_scope!("mouseEntered:");
+            let _entered = debug_span!("mouseEntered:").entered();
 
             let position = self.mouse_view_point(event).to_physical(self.scale_factor());
 
@@ -648,7 +648,7 @@ define_class!(
 
         #[unsafe(method(mouseExited:))]
         fn mouse_exited(&self, event: &NSEvent) {
-            trace_scope!("mouseExited:");
+            let _entered = debug_span!("mouseExited:").entered();
 
             let position = self.mouse_view_point(event).to_physical(self.scale_factor());
 
@@ -662,13 +662,13 @@ define_class!(
 
         #[unsafe(method(scrollWheel:))]
         fn scroll_wheel(&self, event: &NSEvent) {
-            trace_scope!("scrollWheel:");
+            let _entered = debug_span!("scrollWheel:").entered();
 
             self.mouse_motion(event);
 
             let delta = {
-                let (x, y) = unsafe { (event.scrollingDeltaX(), event.scrollingDeltaY()) };
-                if unsafe { event.hasPreciseScrollingDeltas() } {
+                let (x, y) = (event.scrollingDeltaX(), event.scrollingDeltaY());
+                if event.hasPreciseScrollingDeltas() {
                     let delta = LogicalPosition::new(x, y).to_physical(self.scale_factor());
                     MouseScrollDelta::PixelDelta(delta)
                 } else {
@@ -681,10 +681,10 @@ define_class!(
             // momentum phase is recorded (or rather, the started/ended cases of the
             // momentum phase) then we report the touch phase.
             #[allow(non_upper_case_globals)]
-            let phase = match unsafe { event.momentumPhase() } {
+            let phase = match event.momentumPhase() {
                 NSEventPhase::MayBegin | NSEventPhase::Began => TouchPhase::Started,
                 NSEventPhase::Ended | NSEventPhase::Cancelled => TouchPhase::Ended,
-                _ => match unsafe { event.phase() } {
+                _ => match event.phase() {
                     NSEventPhase::MayBegin | NSEventPhase::Began => TouchPhase::Started,
                     NSEventPhase::Ended | NSEventPhase::Cancelled => TouchPhase::Ended,
                     _ => TouchPhase::Moved,
@@ -701,12 +701,12 @@ define_class!(
 
         #[unsafe(method(magnifyWithEvent:))]
         fn magnify_with_event(&self, event: &NSEvent) {
-            trace_scope!("magnifyWithEvent:");
+            let _entered = debug_span!("magnifyWithEvent:").entered();
 
             self.mouse_motion(event);
 
             #[allow(non_upper_case_globals)]
-            let phase = match unsafe { event.phase() } {
+            let phase = match event.phase() {
                 NSEventPhase::Began => TouchPhase::Started,
                 NSEventPhase::Changed => TouchPhase::Moved,
                 NSEventPhase::Cancelled => TouchPhase::Cancelled,
@@ -716,14 +716,14 @@ define_class!(
 
             self.queue_event(WindowEvent::PinchGesture {
                 device_id: None,
-                delta: unsafe { event.magnification() },
+                delta: event.magnification(),
                 phase,
             });
         }
 
         #[unsafe(method(smartMagnifyWithEvent:))]
         fn smart_magnify_with_event(&self, event: &NSEvent) {
-            trace_scope!("smartMagnifyWithEvent:");
+            let _entered = debug_span!("smartMagnifyWithEvent:").entered();
 
             self.mouse_motion(event);
 
@@ -732,12 +732,12 @@ define_class!(
 
         #[unsafe(method(rotateWithEvent:))]
         fn rotate_with_event(&self, event: &NSEvent) {
-            trace_scope!("rotateWithEvent:");
+            let _entered = debug_span!("rotateWithEvent:").entered();
 
             self.mouse_motion(event);
 
             #[allow(non_upper_case_globals)]
-            let phase = match unsafe { event.phase() } {
+            let phase = match event.phase() {
                 NSEventPhase::Began => TouchPhase::Started,
                 NSEventPhase::Changed => TouchPhase::Moved,
                 NSEventPhase::Cancelled => TouchPhase::Cancelled,
@@ -747,19 +747,19 @@ define_class!(
 
             self.queue_event(WindowEvent::RotationGesture {
                 device_id: None,
-                delta: unsafe { event.rotation() },
+                delta: event.rotation(),
                 phase,
             });
         }
 
         #[unsafe(method(pressureChangeWithEvent:))]
         fn pressure_change_with_event(&self, event: &NSEvent) {
-            trace_scope!("pressureChangeWithEvent:");
+            let _entered = debug_span!("pressureChangeWithEvent:").entered();
 
             self.queue_event(WindowEvent::TouchpadPressure {
                 device_id: None,
-                pressure: unsafe { event.pressure() },
-                stage: unsafe { event.stage() } as i64,
+                pressure: event.pressure(),
+                stage: event.stage() as i64,
             });
         }
 
@@ -768,13 +768,13 @@ define_class!(
         // https://github.com/chromium/chromium/blob/a86a8a6bcfa438fa3ac2eba6f02b3ad1f8e0756f/ui/views/cocoa/bridged_content_view.mm#L816
         #[unsafe(method(_wantsKeyDownForEvent:))]
         fn wants_key_down_for_event(&self, _event: &NSEvent) -> bool {
-            trace_scope!("_wantsKeyDownForEvent:");
+            let _entered = debug_span!("_wantsKeyDownForEvent:").entered();
             true
         }
 
         #[unsafe(method(acceptsFirstMouse:))]
         fn accepts_first_mouse(&self, _event: &NSEvent) -> bool {
-            trace_scope!("acceptsFirstMouse:");
+            let _entered = debug_span!("acceptsFirstMouse:").entered();
             self.ivars().accepts_first_mouse
         }
     }
@@ -794,19 +794,65 @@ impl WinitView {
             ime_size: Default::default(),
             modifiers: Default::default(),
             phys_modifiers: Default::default(),
-            tracking_rect: Default::default(),
             ime_state: Default::default(),
             input_source: Default::default(),
-            ime_allowed: Default::default(),
+            ime_capabilities: Default::default(),
             forward_key_to_app: Default::default(),
             marked_text: Default::default(),
             accepts_first_mouse,
             option_as_alt: Cell::new(option_as_alt),
         });
         let this: Retained<Self> = unsafe { msg_send![super(this), init] };
-
         *this.ivars().input_source.borrow_mut() = this.current_input_source();
 
+        // Ask AppKit to redisplay the layer while the view is being resized so layer-backed
+        // surfaces keep painting.
+        this.setLayerContentsRedrawPolicy(NSViewLayerContentsRedrawPolicy::DuringViewResize);
+
+        // `MouseEnteredAndExited` enables receiving events through `mouseEntered:` and
+        // `mouseExited:`.
+        //
+        // `MouseMoved` enables receiving events through `mouseMoved:`
+        //
+        // We do not set `CursorUpdate` because it is part of the "flexible" alternative to
+        // `cursorRect` based cursor image updates, and we currently still use
+        // `cursorRect`s. We also can't really switch to this approach because "The
+        // cursorUpdate(with:) message is not sent when the NSTrackingCursorUpdate option is
+        // specified along with [`ActiveAlways`]."
+        //
+        // `ActiveAlways` indicates we want to receive events when the window is not
+        // focused ("key window" in Cocoa terms), which matches the behavior on other
+        // platforms.
+        //
+        // We do not set `AssumeInside` because we want to avoid emitting `Left` events without a
+        // correspondering `Entered` to our consumers, and not setting this flag tells AppKit to
+        // handle this for us by synthesizing entry and exit events in some cases.
+        //
+        // `InVisibleRect` instructs the tracking area's `owner` (our `NSView`) to ignore the value
+        // we provide in `rect` and keep the tracking area's bounds up to date with the
+        // current view bounds automatically.
+        //
+        // We do not set `EnabledDuringMouseDrag` to match the platform behavior on Windows
+        // and Wayland, since neither emit events while being dragged over with an empty
+        // cursor without focus.
+        //
+        // See also https://developer.apple.com/documentation/appkit/nstrackingareaoptions.
+
+        // Safety: the type of `owner` should be `NSView` and is.
+        // The type of `user_info` is irrelevant because it is None.
+        this.addTrackingArea(&*unsafe {
+            NSTrackingArea::initWithRect_options_owner_userInfo(
+                NSTrackingArea::alloc(),
+                NSRect::ZERO,
+                NSTrackingAreaOptions::MouseEnteredAndExited
+                    | NSTrackingAreaOptions::MouseMoved
+                    | NSTrackingAreaOptions::ActiveAlways
+                    | NSTrackingAreaOptions::InVisibleRect,
+                Some(&this),
+                None,
+            )
+        });
+
         this
     }
 
@@ -821,6 +867,37 @@ impl WinitView {
         });
     }
 
+    fn surface_resized(&self) {
+        let Some(window) = (**self).window() else {
+            return;
+        };
+        let size = self.surface_size();
+        let window_id = window_id(&window);
+        self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop| {
+            app.window_event(event_loop, window_id, WindowEvent::SurfaceResized(size));
+        });
+    }
+
+    /// Returns the drawable size from the view's backing-coordinate bounds.
+    pub(super) fn surface_size(&self) -> PhysicalSize<u32> {
+        // The view bounds are authoritative for full-size content views and during live resize.
+        // Deriving this from the window frame can exclude custom titlebar content or be stale.
+        let backing_bounds = self.convertRectToBacking(self.bounds());
+        PhysicalSize::new(
+            backing_bounds.size.width.round().max(0.0) as u32,
+            backing_bounds.size.height.round().max(0.0) as u32,
+        )
+    }
+
+    fn redraw_during_live_resize(&self) {
+        let Some(window) = (**self).window() else {
+            return;
+        };
+        if window.inLiveResize() {
+            self.ivars().app_state.handle_redraw(window_id(&window));
+        }
+    }
+
     fn scale_factor(&self) -> f64 {
         self.window().backingScaleFactor() as f64
     }
@@ -858,23 +935,37 @@ impl WinitView {
             false
         }
     }
+    pub(super) fn enable_ime(&self, capabilities: ImeCapabilities) {
+        // This seems reasonable but the prior behavior of `set_ime_allowed` doesn't do this
+        // (it was also broken but let's not break things worse)
 
-    pub(super) fn set_ime_allowed(&self, ime_allowed: bool) {
-        if self.ivars().ime_allowed.get() == ime_allowed {
-            return;
-        }
-        self.ivars().ime_allowed.set(ime_allowed);
-        if self.ivars().ime_allowed.get() {
-            return;
-        }
-
-        // Clear markedText
-        *self.ivars().marked_text.borrow_mut() = NSMutableAttributedString::new();
+        // if self.ivars().ime_capabilities.get().is_none() {
+        //     self.ivars().ime_state.set(ImeState::Ground);
+        // }
 
+        // why are we disabling things in an enable fn? who knows. it's what the previous one did
+        // though
         if self.ivars().ime_state.get() != ImeState::Disabled {
             self.ivars().ime_state.set(ImeState::Disabled);
             self.queue_event(WindowEvent::Ime(Ime::Disabled));
         }
+        self.ivars().ime_capabilities.set(Some(capabilities));
+        *self.ivars().marked_text.borrow_mut() = NSMutableAttributedString::new();
+    }
+    pub(super) fn disable_ime(&self) {
+        // see above
+        self.ivars().ime_capabilities.set(None);
+        if self.ivars().ime_state.get() != ImeState::Disabled {
+            self.ivars().ime_state.set(ImeState::Disabled);
+            self.queue_event(WindowEvent::Ime(Ime::Disabled));
+        }
+        // we probably don't need to do this, but again this mirrors the prior behavior of
+        // `set_ime_allowed`
+        *self.ivars().marked_text.borrow_mut() = NSMutableAttributedString::new();
+    }
+
+    pub(super) fn ime_capabilities(&self) -> Option<ImeCapabilities> {
+        self.ivars().ime_capabilities.get()
     }
 
     pub(super) fn set_ime_cursor_area(&self, position: NSPoint, size: NSSize) {
@@ -917,8 +1008,8 @@ impl WinitView {
         // later will work though, since the flags are attached to the event and contain valid
         // information.
         'send_event: {
-            if is_flags_changed_event && unsafe { ns_event.keyCode() } != 0 {
-                let scancode = unsafe { ns_event.keyCode() };
+            if is_flags_changed_event && ns_event.keyCode() != 0 {
+                let scancode = ns_event.keyCode();
                 let physical_key = scancode_to_physicalkey(scancode as u32);
 
                 let logical_key = code_to_key(physical_key, scancode);
@@ -1050,7 +1141,7 @@ impl WinitView {
             || view_point.x > frame.size.width
             || view_point.y > frame.size.height
         {
-            let mouse_buttons_down = unsafe { NSEvent::pressedMouseButtons() };
+            let mouse_buttons_down = NSEvent::pressedMouseButtons();
             if mouse_buttons_down == 0 {
                 // Point is outside of the client area (view) and no buttons are pressed
                 return;
@@ -1068,7 +1159,7 @@ impl WinitView {
     }
 
     fn mouse_view_point(&self, event: &NSEvent) -> LogicalPosition<f64> {
-        let window_point = unsafe { event.locationInWindow() };
+        let window_point = event.locationInWindow();
         let view_point = self.convertPoint_fromView(window_point, None);
 
         LogicalPosition::new(view_point.x, view_point.y)
@@ -1082,36 +1173,31 @@ fn mouse_button(event: &NSEvent) -> MouseButton {
     // For the other events, it's always set to 0.
     // MacOS only defines the left, right and middle buttons, 3..=31 are left as generic buttons,
     // but 3 and 4 are very commonly used as Back and Forward by hardware vendors and applications.
-    match unsafe { event.buttonNumber() } {
-        0 => MouseButton::Left,
-        1 => MouseButton::Right,
-        2 => MouseButton::Middle,
-        3 => MouseButton::Back,
-        4 => MouseButton::Forward,
-        n => MouseButton::Other(n as u16),
-    }
+    let b: isize = event.buttonNumber();
+    b.try_into()
+        .ok()
+        .and_then(MouseButton::try_from_u8)
+        .expect("expected MacOS button number in the range 0..=31")
 }
 
 // NOTE: to get option as alt working we need to rewrite events
 // we're getting from the operating system, which makes it
 // impossible to provide such events as extra in `KeyEvent`.
 fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEvent> {
-    let ev_mods = event_mods(event).state;
+    let ev_mods = event_mods(event).state();
     let ignore_alt_characters = match option_as_alt {
         OptionAsAlt::OnlyLeft if lalt_pressed(event) => true,
         OptionAsAlt::OnlyRight if ralt_pressed(event) => true,
         OptionAsAlt::Both if ev_mods.alt_key() => true,
         _ => false,
     } && !ev_mods.control_key()
-        && !ev_mods.super_key();
+        && !ev_mods.meta_key();
 
     if ignore_alt_characters {
-        let ns_chars = unsafe {
-            event.charactersIgnoringModifiers().expect("expected characters to be non-null")
-        };
+        let ns_chars =
+            event.charactersIgnoringModifiers().expect("expected characters to be non-null");
 
-        unsafe {
-            NSEvent::keyEventWithType_location_modifierFlags_timestamp_windowNumber_context_characters_charactersIgnoringModifiers_isARepeat_keyCode(
+        NSEvent::keyEventWithType_location_modifierFlags_timestamp_windowNumber_context_characters_charactersIgnoringModifiers_isARepeat_keyCode(
                 event.r#type(),
                 event.locationInWindow(),
                 event.modifierFlags(),
@@ -1124,8 +1210,96 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEven
                 event.keyCode(),
             )
             .unwrap()
-        }
     } else {
         event.copy()
     }
 }
+
+/// Convert a UTF-16 code unit offset into the corresponding UTF-8 byte offset within `s`.
+///
+/// IMEs are not required to send well-formed offsets, so this is defensive: an offset that
+/// would split a surrogate pair is snapped down to the start of that character, and an
+/// out-of-bounds offset is clamped to the end of the string (e.g. native Pinyin sends
+/// out-of-bounds indices, see <https://github.com/alacritty/alacritty/issues/8791>).
+///
+/// The mapping is monotone non-decreasing, so applying it to the location and end of an
+/// `NSRange` (where `location <= end`) can never produce an inverted byte range.
+fn utf16_to_utf8_offset(s: &str, utf16_offset: usize) -> usize {
+    let mut utf16_pos = 0;
+    for (utf8_pos, ch) in s.char_indices() {
+        if utf16_pos >= utf16_offset {
+            return utf8_pos;
+        }
+        utf16_pos += ch.len_utf16();
+        // The target offset lands strictly inside this character's UTF-16 representation,
+        // i.e. it splits a surrogate pair: snap down to the character boundary.
+        if utf16_pos > utf16_offset {
+            return utf8_pos;
+        }
+    }
+    s.len()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Apply the UTF-16 -> UTF-8 conversion to both ends of a `selectedRange {loc, len}`,
+    /// mirroring what `set_marked_text` does for the emitted `Ime::Preedit` cursor range.
+    fn convert(s: &str, loc: usize, len: usize) -> (usize, usize) {
+        (utf16_to_utf8_offset(s, loc), utf16_to_utf8_offset(s, loc + len))
+    }
+
+    #[test]
+    fn mid_surrogate_offset_snaps_down() {
+        // "😀a": 😀 is one char = 2 UTF-16 units = 4 UTF-8 bytes; offset 1 is mid-pair.
+        assert_eq!(utf16_to_utf8_offset("\u{1F600}a", 1), 0);
+        // Offset 2 is the boundary just after the pair.
+        assert_eq!(utf16_to_utf8_offset("\u{1F600}a", 2), 4);
+    }
+
+    #[test]
+    fn no_longer_inverted() {
+        // "a😀b" with selectedRange {1,1}: previously emitted (1, 0) -- lower > upper, a
+        // slice-panic vector. The boundary-snapping conversion keeps lower <= upper.
+        assert_eq!(convert("a\u{1F600}b", 1, 1), (1, 1));
+    }
+
+    #[test]
+    fn prefix_preserved_on_mid_pair_collapse() {
+        // "a😀b" with selectedRange {2,0}: previously collapsed to (0, 0), discarding the
+        // valid "a" prefix; now snaps to the char boundary after "a".
+        assert_eq!(convert("a\u{1F600}b", 2, 0), (1, 1));
+    }
+
+    #[test]
+    fn out_of_bounds_clamps_to_len() {
+        // Subsumes the #4494 `.min(len)` clamp: an out-of-bounds offset maps to the string
+        // length instead of triggering an NSRangeException.
+        assert_eq!(convert("\u{1F600}a", 99, 0), (5, 5));
+    }
+
+    #[test]
+    fn well_formed_inputs_are_identity() {
+        // The common case (well-formed boundary indices) must be byte-for-byte unchanged.
+        assert_eq!(convert("a\u{1F600}b", 3, 0), (5, 5));
+        assert_eq!(convert("a\u{1F600}b", 4, 0), (6, 6));
+        // BMP multi-byte (Japanese): each char is 1 UTF-16 unit and 3 UTF-8 bytes.
+        assert_eq!(convert("\u{3053}\u{3093}", 1, 1), (3, 6));
+    }
+
+    #[test]
+    fn monotone_non_decreasing() {
+        // Sweep every UTF-16 offset (including out-of-bounds) over a string mixing BMP and
+        // non-BMP characters and assert the conversion never goes backwards, which is what
+        // guarantees `lower <= upper` for any `NSRange`.
+        let s = "a\u{1F600}b\u{3053}\u{1F4A9}c";
+        let mut prev = 0;
+        for off in 0..=20 {
+            let cur = utf16_to_utf8_offset(s, off);
+            assert!(cur >= prev, "non-monotone at offset {off}: {cur} < {prev}");
+            assert!(cur <= s.len(), "offset {off} mapped past end: {cur} > {}", s.len());
+            prev = cur;
+        }
+    }
+}

winit-appkit/src/window.rs

@@ -1,21 +1,27 @@
 #![allow(clippy::unnecessary_cast)]
 
+use std::sync::Arc;
+
 use dispatch2::MainThreadBound;
 use dpi::{Position, Size};
-use objc2::rc::{autoreleasepool, Retained};
-use objc2::{define_class, MainThreadMarker, Message};
+use objc2::rc::{Retained, autoreleasepool};
+use objc2::{MainThreadMarker, Message, define_class};
 use objc2_app_kit::{NSPanel, NSResponder, NSWindow};
 use objc2_foundation::NSObject;
-
-use super::event_loop::ActiveEventLoop;
-use super::window_delegate::WindowDelegate;
-use crate::error::RequestError;
-use crate::monitor::MonitorHandle as CoreMonitorHandle;
-use crate::window::{
-    Cursor, Fullscreen, Icon, ImePurpose, Theme, UserAttentionType, Window as CoreWindow,
+use tracing::trace_span;
+use winit_core::cursor::Cursor;
+use winit_core::error::RequestError;
+use winit_core::icon::Icon;
+use winit_core::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
+use winit_core::window::{
+    ImeCapabilities, ImeRequest, ImeRequestError, Theme, UserAttentionType, Window as CoreWindow,
     WindowAttributes, WindowButtons, WindowId, WindowLevel,
 };
 
+use super::event_loop::ActiveEventLoop;
+use super::window_delegate::WindowDelegate;
+
+#[derive(Debug)]
 pub(crate) struct Window {
     window: MainThreadBound<Retained<NSWindow>>,
     /// The window only keeps a weak reference to this, so we must keep it around here.
@@ -88,7 +94,7 @@ impl rwh_06::HasWindowHandle for Window {
 }
 
 impl CoreWindow for Window {
-    fn id(&self) -> crate::window::WindowId {
+    fn id(&self) -> winit_core::window::WindowId {
         self.maybe_wait_on_main(|delegate| delegate.id())
     }
 
@@ -205,11 +211,11 @@ impl CoreWindow for Window {
     }
 
     fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
-        self.maybe_wait_on_main(|delegate| delegate.set_fullscreen(fullscreen.map(Into::into)))
+        self.maybe_wait_on_main(|delegate| delegate.set_fullscreen(fullscreen))
     }
 
     fn fullscreen(&self) -> Option<Fullscreen> {
-        self.maybe_wait_on_main(|delegate| delegate.fullscreen().map(Into::into))
+        self.maybe_wait_on_main(|delegate| delegate.fullscreen())
     }
 
     fn set_decorations(&self, decorations: bool) {
@@ -228,16 +234,12 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.set_window_icon(window_icon));
     }
 
-    fn set_ime_cursor_area(&self, position: Position, size: Size) {
-        self.maybe_wait_on_main(|delegate| delegate.set_ime_cursor_area(position, size));
+    fn request_ime_update(&self, request: ImeRequest) -> Result<(), ImeRequestError> {
+        self.maybe_wait_on_main(|delegate| delegate.request_ime_update(request))
     }
 
-    fn set_ime_allowed(&self, allowed: bool) {
-        self.maybe_wait_on_main(|delegate| delegate.set_ime_allowed(allowed));
-    }
-
-    fn set_ime_purpose(&self, purpose: ImePurpose) {
-        self.maybe_wait_on_main(|delegate| delegate.set_ime_purpose(purpose));
+    fn ime_capabilities(&self) -> Option<ImeCapabilities> {
+        self.maybe_wait_on_main(|delegate| delegate.ime_capabilities())
     }
 
     fn focus_window(&self) {
@@ -276,7 +278,10 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.set_cursor_position(position))
     }
 
-    fn set_cursor_grab(&self, mode: crate::window::CursorGrabMode) -> Result<(), RequestError> {
+    fn set_cursor_grab(
+        &self,
+        mode: winit_core::window::CursorGrabMode,
+    ) -> Result<(), RequestError> {
         self.maybe_wait_on_main(|delegate| delegate.set_cursor_grab(mode))
     }
 
@@ -290,7 +295,7 @@ impl CoreWindow for Window {
 
     fn drag_resize_window(
         &self,
-        direction: crate::window::ResizeDirection,
+        direction: winit_core::window::ResizeDirection,
     ) -> Result<(), RequestError> {
         Ok(self.maybe_wait_on_main(|delegate| delegate.drag_resize_window(direction))?)
     }
@@ -306,21 +311,24 @@ impl CoreWindow for Window {
 
     fn current_monitor(&self) -> Option<CoreMonitorHandle> {
         self.maybe_wait_on_main(|delegate| {
-            delegate.current_monitor().map(|inner| CoreMonitorHandle { inner })
+            delegate.current_monitor().map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
         })
     }
 
     fn available_monitors(&self) -> Box<dyn Iterator<Item = CoreMonitorHandle>> {
         self.maybe_wait_on_main(|delegate| {
             Box::new(
-                delegate.available_monitors().into_iter().map(|inner| CoreMonitorHandle { inner }),
+                delegate
+                    .available_monitors()
+                    .into_iter()
+                    .map(|monitor| CoreMonitorHandle(Arc::new(monitor))),
             )
         })
     }
 
     fn primary_monitor(&self) -> Option<CoreMonitorHandle> {
         self.maybe_wait_on_main(|delegate| {
-            delegate.primary_monitor().map(|inner| CoreMonitorHandle { inner })
+            delegate.primary_monitor().map(|monitor| CoreMonitorHandle(Arc::new(monitor)))
         })
     }
 
@@ -343,13 +351,13 @@ define_class!(
     impl WinitWindow {
         #[unsafe(method(canBecomeMainWindow))]
         fn can_become_main_window(&self) -> bool {
-            trace_scope!("canBecomeMainWindow");
+            let _entered = trace_span!("canBecomeMainWindow").entered();
             true
         }
 
         #[unsafe(method(canBecomeKeyWindow))]
         fn can_become_key_window(&self) -> bool {
-            trace_scope!("canBecomeKeyWindow");
+            let _entered = trace_span!("canBecomeKeyWindow").entered();
             true
         }
     }
@@ -367,7 +375,7 @@ define_class!(
         // it doesn't if window doesn't have NSWindowStyleMask::Titled
         #[unsafe(method(canBecomeKeyWindow))]
         fn can_become_key_window(&self) -> bool {
-            trace_scope!("canBecomeKeyWindow");
+            let _entered = trace_span!("canBecomeKeyWindow").entered();
             true
         }
     }

winit-common/Cargo.toml

@@ -0,0 +1,55 @@
+[package]
+description = "Winit implementation helpers"
+documentation = "https://docs.rs/winit-common"
+edition.workspace = true
+license.workspace = true
+name = "winit-common"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+# Event Handler
+event-handler = []
+
+# XKB
+wayland = ["dep:memmap2"]
+x11 = ["xkbcommon-dl?/x11", "dep:x11-dl"]
+xkb = ["dep:xkbcommon-dl", "dep:smol_str"]
+
+# CoreFoundation
+core-foundation = ["dep:block2", "dep:objc2", "dep:objc2-core-foundation"]
+
+# Foundation
+foundation = ["dep:block2", "dep:objc2", "dep:objc2-foundation"]
+
+[dependencies]
+smol_str = { workspace = true, optional = true }
+tracing.workspace = true
+winit-core.workspace = true
+
+# XKB
+memmap2 = { workspace = true, optional = true }
+x11-dl = { workspace = true, optional = true }
+xkbcommon-dl = { workspace = true, optional = true }
+
+# Foundation / CoreFoundation
+block2 = { workspace = true, optional = true }
+objc2 = { workspace = true, optional = true }
+objc2-core-foundation = { workspace = true, optional = true, features = [
+    "std",
+    "block2",
+    "objc2",
+    "CFRunLoop",
+    "CFString",
+] }
+objc2-foundation = { workspace = true, optional = true, features = [
+    "std",
+    "block2",
+    "NSNotification",
+    "NSString",
+    "NSOperation",
+] }
+
+[package.metadata.docs.rs]
+all-features = true

winit-common/LICENSE

@@ -0,0 +1 @@
+../LICENSE

winit-common/README.md

@@ -0,0 +1 @@
+../README.md

winit-common/src/core_foundation/event_loop_proxy.rs

@@ -3,12 +3,9 @@ use std::sync::Arc;
 
 use objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    kCFRunLoopCommonModes, CFIndex, CFRetained, CFRunLoop, CFRunLoopAddSource, CFRunLoopGetMain,
-    CFRunLoopSource, CFRunLoopSourceContext, CFRunLoopSourceCreate, CFRunLoopSourceInvalidate,
-    CFRunLoopSourceSignal, CFRunLoopWakeUp,
+    CFIndex, CFRetained, CFRunLoop, CFRunLoopSource, CFRunLoopSourceContext, kCFRunLoopCommonModes,
 };
-
-use crate::event_loop::EventLoopProxyProvider;
+use winit_core::event_loop::EventLoopProxyProvider;
 
 /// A waker that signals a `CFRunLoopSource` on the main thread.
 ///
@@ -17,7 +14,7 @@ use crate::event_loop::EventLoopProxyProvider;
 ///
 /// See <https://developer.apple.com/documentation/corefoundation/cfrunloopsource?language=objc>.
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub(crate) struct EventLoopProxy {
+pub struct EventLoopProxy {
     source: CFRetained<CFRunLoopSource>,
     /// Cached value of `CFRunLoopGetMain`.
     main_loop: CFRetained<CFRunLoop>,
@@ -31,7 +28,7 @@ impl EventLoopProxy {
     /// Create a new proxy, registering it to be performed on the main thread.
     ///
     /// The provided closure should call `proxy_wake_up` on the application.
-    pub(crate) fn new<F: Fn() + 'static>(mtm: MainThreadMarker, signaller: F) -> Self {
+    pub fn new<F: Fn() + 'static>(mtm: MainThreadMarker, signaller: F) -> Self {
         // We use an `Arc` here to make sure that the reference-counting of the signal container is
         // atomic (`Retained`/`CFRetained` would be valid alternatives too).
         let signaller = Arc::new(signaller);
@@ -90,23 +87,22 @@ impl EventLoopProxy {
         // Keeping the closure alive beyond this scope is fine, because `F: 'static`.
         let source = unsafe {
             let _ = mtm;
-            CFRunLoopSourceCreate(None, order, &mut context).unwrap()
+            CFRunLoopSource::new(None, order, &mut context).unwrap()
         };
 
         // Register the source to be performed on the main thread.
-        let main_loop = unsafe { CFRunLoopGetMain() }.unwrap();
-        unsafe { CFRunLoopAddSource(&main_loop, Some(&source), kCFRunLoopCommonModes) };
+        let main_loop = CFRunLoop::main().unwrap();
+        unsafe { main_loop.add_source(Some(&source), kCFRunLoopCommonModes) };
 
         Self { source, main_loop }
     }
 
     // FIXME(madsmtm): Use this on macOS too.
     // More difficult there, since the user can re-start the event loop.
-    #[cfg_attr(target_os = "macos", allow(dead_code))]
-    pub(crate) fn invalidate(&self) {
+    pub fn invalidate(&self) {
         // NOTE: We do NOT fire this on `Drop`, since we want the proxy to be cloneable, such that
         // we only need to register a single source even if there's multiple proxies in use.
-        unsafe { CFRunLoopSourceInvalidate(&self.source) };
+        self.source.invalidate();
     }
 }
 
@@ -115,12 +111,12 @@ impl EventLoopProxyProvider for EventLoopProxy {
         // Signal the source, which ends up later invoking `perform` on the main thread.
         //
         // Multiple signals in quick succession are automatically coalesced into a single signal.
-        unsafe { CFRunLoopSourceSignal(&self.source) };
+        self.source.signal();
 
         // Let the main thread know there's a new event.
         //
         // This is required since we may be (probably are) running on a different thread, and the
         // main loop may be sleeping (and `CFRunLoopSourceSignal` won't wake it).
-        unsafe { CFRunLoopWakeUp(&self.main_loop) };
+        self.main_loop.wake_up();
     }
 }

winit-common/src/core_foundation/main_run_loop.rs

@@ -0,0 +1,136 @@
+//! Various utilities for interfacing with the main run loop.
+//!
+//! These allow for using closures without the `Send + Sync` requirement that is otherwise required
+//! when interfacing with run loops.
+//!
+//! See also <https://github.com/madsmtm/objc2/issues/696> for work on this at a lower level.
+
+use std::cell::Cell;
+
+use objc2::MainThreadMarker;
+use objc2_core_foundation::{CFRetained, CFRunLoop, CFRunLoopMode, kCFRunLoopDefaultMode};
+use tracing::{Span, error};
+
+use super::MainRunLoopObserver;
+
+/// Wrapper around [`CFRunLoop::main`].
+#[derive(Debug)]
+pub struct MainRunLoop {
+    /// This is on the main thread.
+    _mtm: MainThreadMarker,
+    /// A cached reference to the main run loop.
+    main_run_loop: CFRetained<CFRunLoop>,
+}
+
+impl MainRunLoop {
+    /// Get the main run loop.
+    pub fn get(_mtm: MainThreadMarker) -> Self {
+        let main_run_loop = CFRunLoop::main().unwrap();
+        Self { _mtm, main_run_loop }
+    }
+
+    /// Get a reference to the underlying [`CFRunLoop`].
+    pub fn run_loop(&self) -> &CFRunLoop {
+        &self.main_run_loop
+    }
+
+    /// Wake the main run loop.
+    pub fn wake_up(&self) {
+        self.main_run_loop.wake_up();
+    }
+
+    /// Submit a closure to run on the main thread as the next step in the run loop, before other
+    /// event sources are processed.
+    ///
+    /// This is used for running event handlers, as those are not allowed to run re-entrantly.
+    ///
+    /// # Implementation
+    ///
+    /// This queuing could be implemented in the following several ways with subtle differences in
+    /// timing. This list is sorted in rough order in which they are run:
+    ///
+    /// 1. Using `CFRunLoopPerformBlock` or `-[NSRunLoop performBlock:]` to queue a closure to run
+    ///    the next time runloop sources are processed.
+    ///
+    /// 2. Using `-[NSObject performSelectorOnMainThread:withObject:waitUntilDone:]` or wrapping the
+    ///    event in `NSEvent` and posting that to `-[NSApplication postEvent:atStart:]` (both
+    ///    creates a custom `CFRunLoopSource`, and signals that to wake up the main event loop).
+    ///
+    ///    a. `atStart = true`.
+    ///
+    ///    b. `atStart = false`.
+    ///
+    /// 3. `dispatch_async` or `dispatch_async_f`. Note that this may appear before 2b, it does not
+    ///    respect the ordering that runloop events have.
+    ///
+    /// We choose the first one, both for ease-of-implementation, but mostly for consistency, as we
+    /// want the event to be queued in a way that preserves the order the events originally arrived
+    /// in.
+    ///
+    /// As an example, let's assume that we receive two events from the user, a mouse click which we
+    /// handled by queuing it, and a window resize which we handled immediately. If we allowed
+    /// AppKit to choose the ordering when queuing the mouse event, it might get put in the back of
+    /// the queue, and the events would appear out of order to the user of Winit. So we must instead
+    /// put the event at the very front of the queue, to be handled as soon as possible after
+    /// handling whatever event it's currently handling.
+    pub fn queue_closure(&self, closure: impl FnOnce() + 'static) {
+        // We use this to run a closure asynchronously at a later point, so it also makes sense to
+        // re-enter the current span when running the queued closure.
+        let span = Span::current();
+
+        // Convert `FnOnce()` to `Block<dyn Fn()>`.
+        let closure = Cell::new(Some(closure));
+        let block = block2::RcBlock::new(move || {
+            // Running this block happens inside a `CFRunLoopSource`, but the spans that we emit for
+            // that are (intentionally) overwritten by entering the span from before.
+            let _enter = span.enter();
+
+            debug_assert!(MainThreadMarker::new().is_some());
+            if let Some(closure) = closure.take() {
+                closure()
+            } else {
+                error!("tried to execute queued closure on main thread twice");
+            }
+        });
+
+        // There are a few common modes (`kCFRunLoopCommonModes`) defined by Cocoa:
+        // - `NSDefaultRunLoopMode`, alias of `kCFRunLoopDefaultMode`.
+        // - `NSEventTrackingRunLoopMode`, used when mouse-dragging and live-resizing a window.
+        // - `NSModalPanelRunLoopMode`, used when running a modal inside the Winit event loop.
+        // - `NSConnectionReplyMode`: TODO.
+        //
+        // We only want to run event handlers in the default mode, as we support running a blocking
+        // modal inside a Winit event handler (see [#1779]) which outrules the modal panel mode, and
+        // resizing such panel window enters the event tracking run loop mode, so we can't directly
+        // trigger events inside that mode either.
+        //
+        // Any events that are queued while running a modal or when live-resizing will instead wait,
+        // and be delivered to the application afterwards.
+        //
+        // [#1779]: https://github.com/rust-windowing/winit/issues/1779
+        let mode = unsafe { kCFRunLoopDefaultMode.unwrap() };
+
+        let _ = self._mtm;
+        // SAFETY: The runloop is valid, the mode is a `CFStringRef`, and the block is `'static`.
+        //
+        // Additionally, we have a `MainThreadMarker` here, which means we know we're on the main
+        // thread. We also know that the run loop is the main-thread run loop, so scheduling a
+        // non-`Send` block to that is allowed.
+        unsafe { self.main_run_loop.perform_block(Some(mode), Some(&block)) }
+    }
+
+    /// Add an observer to the main run loop.
+    pub fn add_observer(&self, observer: &MainRunLoopObserver, mode: &CFRunLoopMode) {
+        // Accessing the `MainObserver`'s observer is fine here, since we're adding it to the main
+        // run loop (which is on the same thread that the observer was created on).
+        self.main_run_loop.add_observer(Some(&observer.observer), Some(mode));
+    }
+
+    /// Remove an observer from the main run loop.
+    ///
+    /// This is also done automatically when the [`MainRunLoopObserver`] is dropped.
+    pub fn remove_observer(&self, observer: &MainRunLoopObserver, mode: &CFRunLoopMode) {
+        // Same as in `add_observer`, accessing the main loop's observer is fine.
+        self.main_run_loop.add_observer(Some(&observer.observer), Some(mode));
+    }
+}

winit-common/src/core_foundation/main_run_loop_observer.rs

@@ -0,0 +1,55 @@
+use block2::RcBlock;
+use objc2::MainThreadMarker;
+use objc2_core_foundation::{
+    CFIndex, CFRetained, CFRunLoopActivity, CFRunLoopObserver, kCFAllocatorDefault,
+};
+
+/// A [`CFRunLoopObserver`] on the main thread.
+///
+/// This type has "ownership" semantics, and invalidates the observer when dropped.
+#[derive(Debug)]
+pub struct MainRunLoopObserver {
+    /// This must be private, otherwise the user might add it to an arbitrary run loop (but this
+    /// observer is not designed to only be on the main thread).
+    pub(crate) observer: CFRetained<CFRunLoopObserver>,
+}
+
+impl MainRunLoopObserver {
+    /// Create a new run loop observer that observes the main run loop.
+    pub fn new(
+        mtm: MainThreadMarker,
+        activities: CFRunLoopActivity,
+        repeats: bool,
+        // The lower the value, the sooner this will run (inverse of a "priority").
+        order: CFIndex,
+        callback: impl Fn(CFRunLoopActivity) + 'static,
+    ) -> Self {
+        let block = RcBlock::new(move |_: *mut _, activity| {
+            debug_assert!(MainThreadMarker::new().is_some());
+            callback(activity)
+        });
+
+        let _ = mtm;
+        // SAFETY: The callback is not Send + Sync, which would normally be unsound, but since we
+        // restrict the callback to only ever be on the main thread (by taking `MainThreadMarker`,
+        // and in `MainRunLoop::add_observer`), the callback doesn't have to be thread safe.
+        let observer = unsafe {
+            CFRunLoopObserver::with_handler(
+                kCFAllocatorDefault,
+                activities.0,
+                repeats,
+                order,
+                Some(&block),
+            )
+        }
+        .unwrap();
+
+        Self { observer }
+    }
+}
+
+impl Drop for MainRunLoopObserver {
+    fn drop(&mut self) {
+        self.observer.invalidate();
+    }
+}

winit-common/src/core_foundation/mod.rs

@@ -0,0 +1,14 @@
+//! Various wrappers around [`CFRunLoop`][objc2_core_foundation::CFRunLoop].
+//!
+//! See Apple's documentation on Run Loops for details:
+//! <https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/Multithreading/RunLoopManagement/RunLoopManagement.html>
+
+mod event_loop_proxy;
+mod main_run_loop;
+mod main_run_loop_observer;
+mod tracing_observers;
+
+pub use self::event_loop_proxy::*;
+pub use self::main_run_loop::*;
+pub use self::main_run_loop_observer::*;
+pub use self::tracing_observers::*;

winit-common/src/core_foundation/tracing_observers.rs

@@ -0,0 +1,146 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use objc2::MainThreadMarker;
+use objc2_core_foundation::{CFIndex, CFRunLoop, CFRunLoopActivity, kCFRunLoopDefaultMode};
+use tracing::span::EnteredSpan;
+use tracing::{Level, error, field, span_enabled, trace_span};
+
+use crate::core_foundation::MainRunLoopObserver;
+
+/// Create two run loop observers that add TRACE-level [spans][tracing::span].
+///
+/// This is useful when debugging run loops, it makes it easier to see in which run loop activity an
+/// event is triggered inside (if any).
+///
+/// When debugging these interactions, it can also be useful to configure your tracing subscriber
+/// with `.with_span_events(tracing_subscriber::fmt::format::FmtSpan::ACTIVE)` to emit events upon
+/// entering and exiting these stages.
+pub fn tracing_observers(
+    mtm: MainThreadMarker,
+) -> Option<(MainRunLoopObserver, MainRunLoopObserver)> {
+    // Observers are a bit costly, so don't create them if the tracing-level for this module is
+    // configured to disable them.
+    if !span_enabled!(Level::TRACE) {
+        return None;
+    }
+
+    /// The state that we think the runloop is currently in.
+    ///
+    /// The order of activities we observe if waiting twice looks something like:
+    /// - CFRunLoopActivity::Entry
+    /// - CFRunLoopActivity::BeforeTimers
+    /// - CFRunLoopActivity::BeforeSources
+    /// - CFRunLoopActivity::BeforeWaiting
+    /// - CFRunLoopActivity::AfterWaiting
+    /// - CFRunLoopActivity::BeforeTimers
+    /// - CFRunLoopActivity::BeforeSources
+    /// - CFRunLoopActivity::BeforeWaiting
+    /// - CFRunLoopActivity::AfterWaiting
+    /// - CFRunLoopActivity::Exit
+    ///
+    /// And if not waiting, it looks something like:
+    /// - CFRunLoopActivity::Entry
+    /// - CFRunLoopActivity::BeforeTimers
+    /// - CFRunLoopActivity::BeforeSources
+    /// - CFRunLoopActivity::Exit
+    #[derive(Default)]
+    #[allow(unused)] // EnteredSpans are kept around
+    enum RunLoopState {
+        /// Currently processing `Entry`/`Exit` observers.
+        #[default]
+        Entered,
+        /// Currently processing timers or `BeforeTimers` observers.
+        Timers(EnteredSpan),
+        /// Currently processing sources or `BeforeSources` observers.
+        Sources(EnteredSpan),
+        /// Currently waiting or processing `BeforeWaiting`/`AfterWaiting` observers.
+        Waiting(EnteredSpan),
+    }
+
+    // A list of currently entered (outer) spans and their state.
+    //
+    // This is a list because runloops can be run recursively.
+    let spans: Rc<RefCell<Vec<(EnteredSpan, RunLoopState)>>> = Rc::new(RefCell::new(Vec::new()));
+    let spans_clone = Rc::clone(&spans);
+
+    // An observer at the start of run loop activities.
+    let activities = CFRunLoopActivity::Entry
+        | CFRunLoopActivity::BeforeTimers
+        | CFRunLoopActivity::BeforeSources
+        | CFRunLoopActivity::BeforeWaiting;
+    let start = MainRunLoopObserver::new(mtm, activities, true, CFIndex::MIN, move |activity| {
+        match activity {
+            // Add an outer span for each runloop iteration.
+            CFRunLoopActivity::Entry => {
+                let span = trace_span!("inside runloop", mode = field::Empty);
+
+                // Get the mode dynamically, the observer may added to multiple different modes.
+                let mode = CFRunLoop::current().unwrap().current_mode().unwrap();
+                // Mode isn't interesting if it's the default mode.
+                if &*mode != unsafe { kCFRunLoopDefaultMode }.unwrap() {
+                    span.record("mode", field::display(mode));
+                }
+
+                let entered = span.entered();
+                spans.borrow_mut().push((entered, RunLoopState::Entered));
+            },
+
+            // Add inner spans that help inspecting the state the runloop is in.
+            CFRunLoopActivity::BeforeTimers => {
+                if let Some((_, state)) = spans.borrow_mut().last_mut() {
+                    *state = RunLoopState::Entered; // Drop any previous spans.
+                    *state = RunLoopState::Timers(trace_span!("processing timers").entered());
+                } else {
+                    error!("unbalanced observer invocations");
+                }
+            },
+            CFRunLoopActivity::BeforeSources => {
+                if let Some((_, state)) = spans.borrow_mut().last_mut() {
+                    *state = RunLoopState::Entered; // Drop any previous spans.
+                    *state = RunLoopState::Sources(trace_span!("processing sources").entered());
+                } else {
+                    error!("unbalanced observer invocations");
+                }
+            },
+            CFRunLoopActivity::BeforeWaiting => {
+                if let Some((_, state)) = spans.borrow_mut().last_mut() {
+                    *state = RunLoopState::Entered; // Drop any previous spans.
+                    *state = RunLoopState::Waiting(trace_span!("waiting").entered());
+                } else {
+                    error!("unbalanced observer invocations");
+                }
+            },
+
+            activity => unreachable!("unexpected activity: {activity:?}"),
+        }
+    });
+
+    // An observer at the end of run loop activities.
+    let activities = CFRunLoopActivity::AfterWaiting | CFRunLoopActivity::Exit;
+    let end = MainRunLoopObserver::new(mtm, activities, true, CFIndex::MAX, move |activity| {
+        match activity {
+            CFRunLoopActivity::AfterWaiting => {
+                if let Some((_, state)) = spans_clone.borrow_mut().last_mut() {
+                    // Transition from the waiting state to the initial state.
+                    *state = RunLoopState::Entered;
+                } else {
+                    error!("unbalanced observer invocations");
+                }
+            },
+
+            CFRunLoopActivity::Exit => {
+                if let Some((span, state)) = spans_clone.borrow_mut().pop() {
+                    drop(state); // Explicitly exit and drop inner span.
+                    drop(span); // Explicitly exit and drop outer span.
+                } else {
+                    error!("unbalanced observer invocations");
+                }
+            },
+
+            activity => unreachable!("unexpected activity: {activity:?}"),
+        }
+    });
+
+    Some((start, end))
+}

winit-common/src/event_handler.rs

@@ -1,17 +1,17 @@
 use std::cell::RefCell;
 use std::{fmt, mem};
 
-use crate::application::ApplicationHandler;
+use winit_core::application::ApplicationHandler;
 
 /// A helper type for storing a reference to `ApplicationHandler`, allowing interior mutable access
 /// to it within the execution of a closure.
 #[derive(Default)]
-pub(crate) struct EventHandler {
+pub struct EventHandler {
     /// This can be in the following states:
-    /// - Not registered by the event loop (None).
+    /// - Not registered by the event loop, or terminated (None).
     /// - Present (Some(handler)).
     /// - Currently executing the handler / in use (RefCell borrowed).
-    inner: RefCell<Option<&'static mut dyn ApplicationHandler>>,
+    inner: RefCell<Option<Box<dyn ApplicationHandler + 'static>>>,
 }
 
 impl fmt::Debug for EventHandler {
@@ -26,7 +26,7 @@ impl fmt::Debug for EventHandler {
 }
 
 impl EventHandler {
-    pub(crate) fn new() -> Self {
+    pub fn new() -> Self {
         Self { inner: RefCell::new(None) }
     }
 
@@ -35,9 +35,9 @@ impl EventHandler {
     /// This is similar to using the `scoped-tls` or `scoped-tls-hkt` crates
     /// to store the handler in a thread local, such that it can be accessed
     /// from within the closure.
-    pub(crate) fn set<'handler, R>(
+    pub fn set<'handler, R>(
         &self,
-        app: &'handler mut dyn ApplicationHandler,
+        app: Box<dyn ApplicationHandler + 'handler>,
         closure: impl FnOnce() -> R,
     ) -> R {
         // SAFETY: We extend the lifetime of the handler here so that we can
@@ -48,8 +48,8 @@ impl EventHandler {
         // extended beyond `'handler`.
         let handler = unsafe {
             mem::transmute::<
-                &'handler mut dyn ApplicationHandler,
-                &'static mut dyn ApplicationHandler,
+                Box<dyn ApplicationHandler + 'handler>,
+                Box<dyn ApplicationHandler + 'static>,
             >(app)
         };
 
@@ -71,11 +71,18 @@ impl EventHandler {
             fn drop(&mut self) {
                 match self.0.inner.try_borrow_mut().as_deref_mut() {
                     Ok(data @ Some(_)) => {
-                        *data = None;
+                        let handler = data.take();
+                        // Explicitly `Drop` the application handler.
+                        drop(handler);
                     },
                     Ok(None) => {
-                        tracing::error!("tried to clear handler, but no handler was set");
+                        // Allowed, happens if the handler was cleared manually
+                        // elsewhere (such as in `applicationWillTerminate:`).
                     },
+                    // We use `eprintln!` here over `tracing::error!`, since we're going to abort
+                    // immediately after this, and it'd be annoying for the user if they didn't get
+                    // any feedback on that if they don't have a tracing subscriber.
+                    #[allow(clippy::disallowed_macros)]
                     Err(_) => {
                         // Note: This is not expected to ever happen, this
                         // module generally controls the `RefCell`, and
@@ -101,16 +108,15 @@ impl EventHandler {
         // soundness.
     }
 
-    #[cfg(target_os = "macos")]
-    pub(crate) fn in_use(&self) -> bool {
+    pub fn in_use(&self) -> bool {
         self.inner.try_borrow().is_err()
     }
 
-    pub(crate) fn ready(&self) -> bool {
+    pub fn ready(&self) -> bool {
         matches!(self.inner.try_borrow().as_deref(), Ok(Some(_)))
     }
 
-    pub(crate) fn handle(&self, callback: impl FnOnce(&mut dyn ApplicationHandler)) {
+    pub fn handle(&self, callback: impl FnOnce(&mut (dyn ApplicationHandler + '_))) {
         match self.inner.try_borrow_mut().as_deref_mut() {
             Ok(Some(user_app)) => {
                 // It is important that we keep the reference borrowed here,
@@ -119,7 +125,7 @@ impl EventHandler {
                 //
                 // If the handler unwinds, the `RefMut` will ensure that the
                 // handler is no longer borrowed.
-                callback(*user_app);
+                callback(&mut **user_app);
             },
             Ok(None) => {
                 // `NSApplication`, our app state and this handler are all
@@ -133,4 +139,21 @@ impl EventHandler {
             },
         }
     }
+
+    pub fn terminate(&self) {
+        match self.inner.try_borrow_mut().as_deref_mut() {
+            Ok(data @ Some(_)) => {
+                let handler = data.take();
+                // Explicitly `Drop` the application handler.
+                drop(handler);
+            },
+            Ok(None) => {
+                // When terminating, we expect the application handler to still be registered.
+                tracing::error!("tried to clear handler, but no handler was set");
+            },
+            Err(_) => {
+                panic!("tried to clear handler while an event is currently being handled");
+            },
+        }
+    }
 }

winit-common/src/foundation/mod.rs

@@ -0,0 +1,3 @@
+mod notification_center;
+
+pub use self::notification_center::*;

winit-common/src/lib.rs

@@ -0,0 +1,10 @@
+//! Winit implementation helpers.
+
+#[cfg(feature = "core-foundation")]
+pub mod core_foundation;
+#[cfg(feature = "event-handler")]
+pub mod event_handler;
+#[cfg(feature = "foundation")]
+pub mod foundation;
+#[cfg(feature = "xkb")]
+pub mod xkb;

winit-common/src/xkb/compose.rs

@@ -12,7 +12,7 @@ use xkbcommon_dl::{
     xkb_compose_status, xkb_compose_table, xkb_keysym_t,
 };
 
-use super::{XkbContext, XKBCH};
+use super::{XKBCH, XkbContext};
 
 #[derive(Debug)]
 pub struct XkbComposeTable {

winit-common/src/xkb/keymap.rs

@@ -4,20 +4,22 @@ use std::ffi::c_char;
 use std::ops::Deref;
 use std::ptr::{self, NonNull};
 
-#[cfg(x11_platform)]
+use winit_core::keyboard::{
+    Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey,
+};
+#[cfg(feature = "x11")]
 use x11_dl::xlib_xcb::xcb_connection_t;
 use xkb::XKB_MOD_INVALID;
 use xkbcommon_dl::{
     self as xkb, xkb_keycode_t, xkb_keymap, xkb_keymap_compile_flags, xkb_keysym_t,
     xkb_layout_index_t, xkb_mod_index_t,
 };
-#[cfg(wayland_platform)]
+#[cfg(feature = "wayland")]
 use {memmap2::MmapOptions, std::os::unix::io::OwnedFd};
 
-use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
-#[cfg(x11_platform)]
-use crate::platform_impl::common::xkb::XKBXH;
-use crate::platform_impl::common::xkb::{XkbContext, XKBH};
+#[cfg(feature = "x11")]
+use super::XKBXH;
+use super::{XKBH, XkbContext};
 
 /// Map the raw X11-style keycode to the `KeyCode` enum.
 ///
@@ -35,8 +37,9 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
     // are defined by the Linux kernel. If Winit programs end up being run on other Unix-likes,
     // I can only hope they agree on what the keycodes mean.
     //
-    // The mapping here is heavily influenced by Firefox' source:
-    // https://searchfox.org/mozilla-central/rev/c597e9c789ad36af84a0370d395be066b7dc94f4/widget/NativeKeyToDOMCodeName.h
+    // The mapping here is heavily influenced by Firefox' and Chromium's sources:
+    // - https://searchfox.org/mozilla-central/rev/c597e9c789ad36af84a0370d395be066b7dc94f4/widget/NativeKeyToDOMCodeName.h
+    // - https://chromium.googlesource.com/chromium/src.git/+/3e1a26c44c024d97dc9a4c09bbc6a2365398ca2c/ui/events/keycodes/dom/dom_code_data.inc
     //
     // Some of the keycodes are likely superfluous for our purposes, and some are ones which are
     // difficult to test the correctness of, or discover the purpose of. Because of this, they've
@@ -157,17 +160,17 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         113 => KeyCode::AudioVolumeMute,
         114 => KeyCode::AudioVolumeDown,
         115 => KeyCode::AudioVolumeUp,
-        // 116 => KeyCode::POWER,
+        116 => KeyCode::Power,
         117 => KeyCode::NumpadEqual,
         // 118 => KeyCode::KPPLUSMINUS,
         119 => KeyCode::Pause,
-        // 120 => KeyCode::SCALE,
+        120 => KeyCode::ShowAllWindows,
         121 => KeyCode::NumpadComma,
         122 => KeyCode::Lang1,
         123 => KeyCode::Lang2,
         124 => KeyCode::IntlYen,
-        125 => KeyCode::SuperLeft,
-        126 => KeyCode::SuperRight,
+        125 => KeyCode::MetaLeft,
+        126 => KeyCode::MetaRight,
         127 => KeyCode::ContextMenu,
         128 => KeyCode::BrowserStop,
         129 => KeyCode::Again,
@@ -183,7 +186,7 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         // 139 => KeyCode::MENU,
         140 => KeyCode::LaunchApp2, // CALC
         // 141 => KeyCode::SETUP,
-        // 142 => KeyCode::SLEEP,
+        142 => KeyCode::Sleep,
         143 => KeyCode::WakeUp,
         144 => KeyCode::LaunchApp1, // FILE
         // 145 => KeyCode::SENDFILE,
@@ -208,8 +211,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         164 => KeyCode::MediaPlayPause,
         165 => KeyCode::MediaTrackPrevious,
         166 => KeyCode::MediaStop,
-        // 167 => KeyCode::RECORD,
-        // 168 => KeyCode::REWIND,
+        167 => KeyCode::MediaRecord,
+        168 => KeyCode::MediaRewind,
         // 169 => KeyCode::PHONE,
         // 170 => KeyCode::ISO,
         171 => KeyCode::MediaSelect, // CONFIG
@@ -220,8 +223,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         // 176 => KeyCode::EDIT,
         // 177 => KeyCode::SCROLLUP,
         // 178 => KeyCode::SCROLLDOWN,
-        // 179 => KeyCode::KPLEFTPAREN,
-        // 180 => KeyCode::KPRIGHTPAREN,
+        179 => KeyCode::NumpadParenLeft,
+        180 => KeyCode::NumpadParenRight,
         // 181 => KeyCode::NEW,
         // 182 => KeyCode::REDO,
         183 => KeyCode::F13,
@@ -237,14 +240,14 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         193 => KeyCode::F23,
         194 => KeyCode::F24,
         // 200 => KeyCode::PLAYCD,
-        // 201 => KeyCode::PAUSECD,
+        201 => KeyCode::MediaPause,
         // 202 => KeyCode::PROG3,
         // 203 => KeyCode::PROG4,
         // 204 => KeyCode::DASHBOARD,
         // 205 => KeyCode::SUSPEND,
         // 206 => KeyCode::CLOSE,
-        // 207 => KeyCode::PLAY,
-        // 208 => KeyCode::FASTFORWARD,
+        207 => KeyCode::MediaPlay,
+        208 => KeyCode::MediaFastForward,
         // 209 => KeyCode::BASSBOOST,
         // 210 => KeyCode::PRINT,
         // 211 => KeyCode::HP,
@@ -260,16 +263,16 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         // 221 => KeyCode::SHOP,
         // 222 => KeyCode::ALTERASE,
         // 223 => KeyCode::CANCEL,
-        // 224 => KeyCode::BRIGHTNESSDOW,
-        // 225 => KeyCode::BRIGHTNESSU,
+        224 => KeyCode::BrightnessDown,
+        225 => KeyCode::BrightnessUp,
         // 226 => KeyCode::MEDIA,
-        // 227 => KeyCode::SWITCHVIDEOMODE,
-        // 228 => KeyCode::KBDILLUMTOGGLE,
+        227 => KeyCode::DisplayToggleIntExt,
+        228 => KeyCode::KeyboardBacklightToggle,
         // 229 => KeyCode::KBDILLUMDOWN,
         // 230 => KeyCode::KBDILLUMUP,
-        // 231 => KeyCode::SEND,
-        // 232 => KeyCode::REPLY,
-        // 233 => KeyCode::FORWARDMAIL,
+        231 => KeyCode::MailSend,
+        232 => KeyCode::MailReply,
+        233 => KeyCode::MailForward,
         // 234 => KeyCode::SAVE,
         // 235 => KeyCode::DOCUMENTS,
         // 236 => KeyCode::BATTERY,
@@ -284,7 +287,14 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         // 245 => KeyCode::DISPLAY_OFF,
         // 246 => KeyCode::WWAN,
         // 247 => KeyCode::RFKILL,
-        // 248 => KeyCode::KEY_MICMUTE,
+        248 => KeyCode::MicrophoneMuteToggle,
+        372 => KeyCode::ZoomToggle,
+        579 => KeyCode::LaunchControlPanel,
+        580 => KeyCode::SelectTask,
+        581 => KeyCode::LaunchScreenSaver,
+        583 => KeyCode::LaunchAssistant,
+        584 => KeyCode::KeyboardLayoutSelect,
+        633 => KeyCode::PrivacyScreenToggle,
         _ => return PhysicalKey::Unidentified(NativeKeyCode::Xkb(scancode)),
     })
 }
@@ -413,14 +423,16 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
         KeyCode::AudioVolumeMute => Some(113),
         KeyCode::AudioVolumeDown => Some(114),
         KeyCode::AudioVolumeUp => Some(115),
+        KeyCode::Power => Some(116),
         KeyCode::NumpadEqual => Some(117),
         KeyCode::Pause => Some(119),
+        KeyCode::ShowAllWindows => Some(120),
         KeyCode::NumpadComma => Some(121),
         KeyCode::Lang1 => Some(122),
         KeyCode::Lang2 => Some(123),
         KeyCode::IntlYen => Some(124),
-        KeyCode::SuperLeft => Some(125),
-        KeyCode::SuperRight => Some(126),
+        KeyCode::MetaLeft => Some(125),
+        KeyCode::MetaRight => Some(126),
         KeyCode::ContextMenu => Some(127),
         KeyCode::BrowserStop => Some(128),
         KeyCode::Again => Some(129),
@@ -434,6 +446,7 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
         KeyCode::Cut => Some(137),
         KeyCode::Help => Some(138),
         KeyCode::LaunchApp2 => Some(140),
+        KeyCode::Sleep => Some(142),
         KeyCode::WakeUp => Some(143),
         KeyCode::LaunchApp1 => Some(144),
         KeyCode::LaunchMail => Some(155),
@@ -445,9 +458,13 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
         KeyCode::MediaPlayPause => Some(164),
         KeyCode::MediaTrackPrevious => Some(165),
         KeyCode::MediaStop => Some(166),
+        KeyCode::MediaRecord => Some(167),
+        KeyCode::MediaRewind => Some(168),
         KeyCode::MediaSelect => Some(171),
         KeyCode::BrowserHome => Some(172),
         KeyCode::BrowserRefresh => Some(173),
+        KeyCode::NumpadParenLeft => Some(179),
+        KeyCode::NumpadParenRight => Some(180),
         KeyCode::F13 => Some(183),
         KeyCode::F14 => Some(184),
         KeyCode::F15 => Some(185),
@@ -460,7 +477,26 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
         KeyCode::F22 => Some(192),
         KeyCode::F23 => Some(193),
         KeyCode::F24 => Some(194),
+        KeyCode::MediaPause => Some(201),
+        KeyCode::MediaPlay => Some(207),
+        KeyCode::MediaFastForward => Some(208),
         KeyCode::BrowserSearch => Some(217),
+        KeyCode::BrightnessDown => Some(224),
+        KeyCode::BrightnessUp => Some(225),
+        KeyCode::DisplayToggleIntExt => Some(227),
+        KeyCode::KeyboardBacklightToggle => Some(228),
+        KeyCode::MailSend => Some(231),
+        KeyCode::MailReply => Some(232),
+        KeyCode::MailForward => Some(233),
+        // PhysicalKey::Unidentified(NativeKeyCode::Unidentified) => Some(240),
+        KeyCode::MicrophoneMuteToggle => Some(248),
+        KeyCode::ZoomToggle => Some(372),
+        KeyCode::LaunchControlPanel => Some(579),
+        KeyCode::SelectTask => Some(580),
+        KeyCode::LaunchScreenSaver => Some(581),
+        KeyCode::LaunchAssistant => Some(583),
+        KeyCode::KeyboardLayoutSelect => Some(584),
+        KeyCode::PrivacyScreenToggle => Some(633),
         _ => None,
     }
 }
@@ -622,16 +658,20 @@ pub fn keysym_to_key(keysym: u32) -> Key {
         keysyms::Control_R => NamedKey::Control,
         keysyms::Caps_Lock => NamedKey::CapsLock,
         // keysyms::Shift_Lock => NamedKey::ShiftLock,
-
-        // keysyms::Meta_L => NamedKey::Meta,
-        // keysyms::Meta_R => NamedKey::Meta,
         keysyms::Alt_L => NamedKey::Alt,
         keysyms::Alt_R => NamedKey::Alt,
-        keysyms::Super_L => NamedKey::Super,
-        keysyms::Super_R => NamedKey::Super,
+        #[allow(deprecated)]
         keysyms::Hyper_L => NamedKey::Hyper,
+        #[allow(deprecated)]
         keysyms::Hyper_R => NamedKey::Hyper,
 
+        // Browsers map X11's Super keys to Meta, so we do that as well.
+        keysyms::Super_L => NamedKey::Meta,
+        keysyms::Super_R => NamedKey::Meta,
+        // The actual Meta keys do not seem to be used by browsers, so we don't do that either.
+        // keysyms::Meta_L => NamedKey::Super,
+        // keysyms::Meta_R => NamedKey::Super,
+
         // XKB function and modifier keys
         // keysyms::ISO_Lock => NamedKey::IsoLock,
         // keysyms::ISO_Level2_Latch => NamedKey::IsoLevel2Latch,
@@ -724,7 +764,7 @@ pub fn keysym_to_key(keysym: u32) -> Key {
         keysyms::_3270_PrintScreen => NamedKey::PrintScreen,
         keysyms::_3270_Enter => NamedKey::Enter,
 
-        keysyms::space => NamedKey::Space,
+        keysyms::space => return Key::Character(" ".into()),
         // exclam..Sinh_kunddaliya
 
         // XFree86
@@ -941,7 +981,7 @@ pub struct XkbKeymap {
 }
 
 impl XkbKeymap {
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     pub fn from_fd(context: &XkbContext, fd: OwnedFd, size: usize) -> Option<Self> {
         let map = unsafe { MmapOptions::new().len(size).map_copy_read_only(&fd).ok()? };
 
@@ -958,7 +998,7 @@ impl XkbKeymap {
         Some(Self::new_inner(keymap, 0))
     }
 
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub fn from_x11_keymap(
         context: &XkbContext,
         xcb: *mut xcb_connection_t,
@@ -991,7 +1031,7 @@ impl XkbKeymap {
         Self { keymap, _mods_indices: mods_indices, _core_keyboard_id }
     }
 
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub fn mods_indices(&self) -> ModsIndices {
         self._mods_indices
     }
@@ -1012,11 +1052,7 @@ impl XkbKeymap {
                 &mut keysyms,
             );
 
-            if count == 1 {
-                *keysyms
-            } else {
-                0
-            }
+            if count == 1 { *keysyms } else { 0 }
         }
     }
 
@@ -1043,7 +1079,7 @@ impl Deref for XkbKeymap {
 }
 
 /// Modifier index in the keymap.
-#[cfg_attr(not(x11_platform), allow(dead_code))]
+#[cfg_attr(not(feature = "x11"), allow(dead_code))]
 #[derive(Default, Debug, Clone, Copy)]
 pub struct ModsIndices {
     pub shift: Option<xkb_mod_index_t>,
@@ -1060,10 +1096,6 @@ fn mod_index_for_name(keymap: NonNull<xkb_keymap>, name: &[u8]) -> Option<xkb_mo
     unsafe {
         let mod_index =
             (XKBH.xkb_keymap_mod_get_index)(keymap.as_ptr(), name.as_ptr() as *const c_char);
-        if mod_index == XKB_MOD_INVALID {
-            None
-        } else {
-            Some(mod_index)
-        }
+        if mod_index == XKB_MOD_INVALID { None } else { Some(mod_index) }
     }
 }

winit-common/src/xkb/mod.rs

@@ -1,41 +1,39 @@
 use std::ops::Deref;
 use std::os::raw::c_char;
-#[cfg(wayland_platform)]
+#[cfg(feature = "wayland")]
 use std::os::unix::io::OwnedFd;
 use std::ptr::{self, NonNull};
+use std::sync::LazyLock;
 use std::sync::atomic::{AtomicBool, Ordering};
 
 use smol_str::SmolStr;
-use tracing::warn;
+use winit_core::event::{ElementState, KeyEvent};
+use winit_core::keyboard::{Key, KeyLocation};
 use xkbcommon_dl::{
-    self as xkb, xkb_compose_status, xkb_context, xkb_context_flags, xkbcommon_compose_handle,
-    xkbcommon_handle, XkbCommon, XkbCommonCompose,
+    self as xkb, XkbCommon, XkbCommonCompose, xkb_compose_status, xkb_context, xkb_context_flags,
+    xkbcommon_compose_handle, xkbcommon_handle,
 };
-#[cfg(x11_platform)]
+#[cfg(feature = "x11")]
 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::utils::Lazy;
-
 mod compose;
 mod keymap;
 mod state;
 
 use compose::{ComposeStatus, XkbComposeState, XkbComposeTable};
-#[cfg(x11_platform)]
-pub use keymap::raw_keycode_to_physicalkey;
 use keymap::XkbKeymap;
+#[cfg(feature = "x11")]
+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);
+static XKBH: LazyLock<&'static XkbCommon> = LazyLock::new(xkbcommon_handle);
+static XKBCH: LazyLock<&'static XkbCommonCompose> = LazyLock::new(xkbcommon_compose_handle);
 #[cfg(feature = "x11")]
-static XKBXH: Lazy<&'static xkb::x11::XkbCommonX11> = Lazy::new(xkbcommon_x11_handle);
+static XKBXH: LazyLock<&'static xkb::x11::XkbCommonX11> = LazyLock::new(xkbcommon_x11_handle);
 
 #[inline(always)]
 pub fn reset_dead_keys() {
@@ -51,7 +49,7 @@ pub enum Error {
 #[derive(Debug)]
 pub struct Context {
     // NOTE: field order matters.
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub core_keyboard_id: i32,
     state: Option<XkbState>,
     keymap: Option<XkbKeymap>,
@@ -85,7 +83,7 @@ impl Context {
             keymap: None,
             compose_state1,
             compose_state2,
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             core_keyboard_id: 0,
             _compose_table: compose_table,
             context,
@@ -126,23 +124,23 @@ impl Context {
         self.keymap.as_mut()
     }
 
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     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");
+            tracing::warn!("failed to update xkb keymap");
         }
         self.state = state;
         self.keymap = keymap;
     }
 
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     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");
+            tracing::warn!("failed to update xkb keymap");
         }
         self.state = state;
         self.keymap = keymap;
@@ -161,7 +159,7 @@ impl Context {
     /// Key builder context with the user provided xkb state.
     ///
     /// Should be used when the original context must not be altered.
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub fn key_context_with_state<'a>(
         &'a mut self,
         state: &'a mut XkbState,
@@ -312,11 +310,7 @@ impl<'a, 'b> KeyEventResults<'a, 'b> {
     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))
-        }
+        if matches!(key, Key::Unidentified(_)) { Err((key, location)) } else { Ok((key, location)) }
     }
 
     pub fn text(&mut self) -> Option<SmolStr> {
@@ -325,7 +319,7 @@ impl<'a, 'b> KeyEventResults<'a, 'b> {
 
     // The current behaviour makes it so composing a character overrides attempts to input a
     // control character with the `Ctrl` key. We can potentially add a configuration option
-    // if someone specifically wants the oppsite behaviour.
+    // if someone specifically wants the opposite behaviour.
     pub fn text_with_all_modifiers(&mut self) -> Option<SmolStr> {
         match self.composed_text() {
             Ok(text) => text,

winit-common/src/xkb/state.rs

@@ -4,16 +4,16 @@ use std::os::raw::c_char;
 use std::ptr::NonNull;
 
 use smol_str::SmolStr;
-#[cfg(x11_platform)]
+#[cfg(feature = "x11")]
 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};
+#[cfg(feature = "x11")]
+use super::XKBXH;
+use super::keymap::XkbKeymap;
+use super::{XKBH, make_string_with};
 
 #[derive(Debug)]
 pub struct XkbState {
@@ -22,13 +22,13 @@ pub struct XkbState {
 }
 
 impl XkbState {
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     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)]
+    #[cfg(feature = "x11")]
     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)
@@ -52,7 +52,7 @@ impl XkbState {
         unsafe { (XKBH.xkb_state_key_get_layout)(self.state.as_ptr(), key) }
     }
 
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub fn depressed_modifiers(&mut self) -> xkb::xkb_mod_mask_t {
         unsafe {
             (XKBH.xkb_state_serialize_mods)(
@@ -62,7 +62,7 @@ impl XkbState {
         }
     }
 
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub fn latched_modifiers(&mut self) -> xkb::xkb_mod_mask_t {
         unsafe {
             (XKBH.xkb_state_serialize_mods)(
@@ -72,7 +72,7 @@ impl XkbState {
         }
     }
 
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub fn locked_modifiers(&mut self) -> xkb::xkb_mod_mask_t {
         unsafe {
             (XKBH.xkb_state_serialize_mods)(
@@ -153,12 +153,13 @@ impl Drop for XkbState {
     }
 }
 
-/// Represents the current state of the keyboard modifiers
+/// Represents the current logical 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).
+/// For some modifiers, this means that the key is logically pressed, others are toggled (like Caps
+/// Lock). But physically the key can be in any state (for example, released Shift when
+/// it's active as a sticky modifier or released Caps Lock when it's toggled on)
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 pub struct ModifiersState {
     /// The "control" key
@@ -177,13 +178,13 @@ pub struct ModifiersState {
     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);
+impl From<ModifiersState> for winit_core::keyboard::ModifiersState {
+    fn from(mods: ModifiersState) -> winit_core::keyboard::ModifiersState {
+        let mut to_mods = winit_core::keyboard::ModifiersState::empty();
+        to_mods.set(winit_core::keyboard::ModifiersState::SHIFT, mods.shift);
+        to_mods.set(winit_core::keyboard::ModifiersState::CONTROL, mods.ctrl);
+        to_mods.set(winit_core::keyboard::ModifiersState::ALT, mods.alt);
+        to_mods.set(winit_core::keyboard::ModifiersState::META, mods.logo);
         to_mods
     }
 }

winit-core/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+authors = ["The winit contributors", "Kirill Chibisov <contact@kchibisov.com>"]
+categories = ["gui"]
+description = "winit core API."
+documentation = "https://docs.rs/winit-core"
+edition.workspace = true
+keywords = ["windowing"]
+license.workspace = true
+name = "winit-core"
+readme = "README.md"
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[features]
+serde = [
+    "dep:serde",
+    "bitflags/serde",
+    "cursor-icon/serde",
+    "dpi/serde",
+    "keyboard-types/serde",
+    "smol_str/serde",
+]
+
+[dependencies]
+bitflags.workspace = true
+cursor-icon.workspace = true
+dpi.workspace = true
+keyboard-types.workspace = true
+rwh_06.workspace = true
+serde = { workspace = true, optional = true }
+smol_str.workspace = true
+
+# `wasm32-unknown-unknown` and `wasm32-none`, but not `wasm32-wasi`.
+[target.'cfg(all(target_family = "wasm", any(target_os = "unknown", target_os = "none")))'.dependencies]
+web-time.workspace = true
+
+[dev-dependencies]
+winit.workspace = true

winit-core/LICENSE

@@ -0,0 +1 @@
+../LICENSE

winit-core/README.md

@@ -0,0 +1 @@
+../README.md

winit-core/src/application/macos.rs

@@ -0,0 +1,52 @@
+use crate::application::ApplicationHandler;
+use crate::event_loop::ActiveEventLoop;
+use crate::window::WindowId;
+
+/// Additional events on [`ApplicationHandler`] that are specific to macOS.
+///
+/// This can be registered with [`ApplicationHandler::macos_handler`].
+pub trait ApplicationHandlerExtMacOS: ApplicationHandler {
+    /// The system interpreted a keypress as a standard key binding command.
+    ///
+    /// Examples include inserting tabs and newlines, or moving the insertion point, see
+    /// [`NSStandardKeyBindingResponding`] for the full list of key bindings. They are often text
+    /// editing related.
+    ///
+    /// This corresponds to the [`doCommandBySelector:`] method on `NSTextInputClient`.
+    ///
+    /// The `action` parameter contains the string representation of the selector. Examples include
+    /// `"insertBacktab:"`, `"indent:"` and `"noop:"`.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// impl ApplicationHandlerExtMacOS for App {
+    ///     fn standard_key_binding(
+    ///         &mut self,
+    ///         event_loop: &dyn ActiveEventLoop,
+    ///         window_id: WindowId,
+    ///         action: &str,
+    ///     ) {
+    ///         match action {
+    ///             "moveBackward:" => self.cursor.position -= 1,
+    ///             "moveForward:" => self.cursor.position += 1,
+    ///             _ => {} // Ignore other actions
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// [`NSStandardKeyBindingResponding`]: https://developer.apple.com/documentation/appkit/nsstandardkeybindingresponding?language=objc
+    /// [`doCommandBySelector:`]: https://developer.apple.com/documentation/appkit/nstextinputclient/1438256-docommandbyselector?language=objc
+    #[doc(alias = "doCommandBySelector:")]
+    fn standard_key_binding(
+        &mut self,
+        event_loop: &dyn ActiveEventLoop,
+        window_id: WindowId,
+        action: &str,
+    ) {
+        let _ = event_loop;
+        let _ = window_id;
+        let _ = action;
+    }
+}

winit-core/src/application/mod.rs

@@ -2,11 +2,11 @@
 
 use crate::event::{DeviceEvent, DeviceId, StartCause, WindowEvent};
 use crate::event_loop::ActiveEventLoop;
-#[cfg(any(docsrs, macos_platform))]
-use crate::platform::macos::ApplicationHandlerExtMacOS;
 use crate::window::WindowId;
 
-/// The handler of the application events.
+pub mod macos;
+
+/// The handler of application-level events.
 pub trait ApplicationHandler {
     /// Emitted when new events arrive from the OS to be processed.
     ///
@@ -57,7 +57,6 @@ pub trait ApplicationHandler {
     ///
     /// [`resumed()`]: Self::resumed()
     /// [`suspended()`]: Self::suspended()
-    /// [`exiting()`]: Self::exiting()
     fn resumed(&mut self, event_loop: &dyn ActiveEventLoop) {
         let _ = event_loop;
     }
@@ -126,8 +125,9 @@ pub trait ApplicationHandler {
     /// use std::thread;
     /// use std::time::Duration;
     ///
-    /// use winit::application::ApplicationHandler;
-    /// use winit::event_loop::{ActiveEventLoop, EventLoop};
+    /// use winit::event_loop::EventLoop;
+    /// use winit_core::application::ApplicationHandler;
+    /// use winit_core::event_loop::ActiveEventLoop;
     ///
     /// struct MyApp {
     ///     receiver: mpsc::Receiver<u64>,
@@ -162,8 +162,6 @@ pub trait ApplicationHandler {
     ///
     ///     let (sender, receiver) = mpsc::channel();
     ///
-    ///     let mut app = MyApp { receiver };
-    ///
     ///     // Send an event in a loop
     ///     let proxy = event_loop.create_proxy();
     ///     let background_thread = thread::spawn(move || {
@@ -171,7 +169,7 @@ pub trait ApplicationHandler {
     ///         loop {
     ///             println!("sending: {i}");
     ///             if sender.send(i).is_err() {
-    ///                 // Stop sending once `MyApp` is dropped
+    ///                 // Stop sending once the receiver is dropped
     ///                 break;
     ///             }
     ///             // Trigger the wake-up _after_ we placed the event in the channel.
@@ -182,9 +180,8 @@ pub trait ApplicationHandler {
     ///         }
     ///     });
     ///
-    ///     event_loop.run_app(&mut app)?;
+    ///     event_loop.run_app(MyApp { receiver })?;
     ///
-    ///     drop(app);
     ///     background_thread.join().unwrap();
     ///
     ///     Ok(())
@@ -203,6 +200,8 @@ pub trait ApplicationHandler {
     );
 
     /// Emitted when the OS sends an event to a device.
+    ///
+    /// Whether device events are delivered depends on the backend in use.
     fn device_event(
         &mut self,
         event_loop: &dyn ActiveEventLoop,
@@ -258,7 +257,7 @@ pub trait ApplicationHandler {
     /// to the user. This is a good place to stop refreshing UI, running animations and other visual
     /// things. It is driven by Android's [`onStop()`] method.
     ///
-    /// After this event the application either receives [`resumed()`] again, or [`exiting()`].
+    /// After this event the application either receives [`resumed()`] again, or will exit.
     ///
     /// [`onStop()`]: https://developer.android.com/reference/android/app/Activity#onStop()
     ///
@@ -268,7 +267,6 @@ pub trait ApplicationHandler {
     ///
     /// [`resumed()`]: Self::resumed()
     /// [`suspended()`]: Self::suspended()
-    /// [`exiting()`]: Self::exiting()
     fn suspended(&mut self, event_loop: &dyn ActiveEventLoop) {
         let _ = event_loop;
     }
@@ -310,14 +308,6 @@ pub trait ApplicationHandler {
         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: &dyn ActiveEventLoop) {
-        let _ = event_loop;
-    }
-
     /// Emitted when the application has received a memory warning.
     ///
     /// ## Platform-specific
@@ -349,9 +339,8 @@ pub trait ApplicationHandler {
     /// The macOS-specific handler.
     ///
     /// The return value from this should not change at runtime.
-    #[cfg(any(docsrs, macos_platform))]
     #[inline(always)]
-    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+    fn macos_handler(&mut self) -> Option<&mut dyn macos::ApplicationHandlerExtMacOS> {
         None
     }
 }
@@ -413,19 +402,13 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
         (**self).destroy_surfaces(event_loop);
     }
 
-    #[inline]
-    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
-        (**self).exiting(event_loop);
-    }
-
     #[inline]
     fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
         (**self).memory_warning(event_loop);
     }
 
-    #[cfg(any(docsrs, macos_platform))]
     #[inline]
-    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+    fn macos_handler(&mut self) -> Option<&mut dyn macos::ApplicationHandlerExtMacOS> {
         (**self).macos_handler()
     }
 }
@@ -487,19 +470,13 @@ impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
         (**self).destroy_surfaces(event_loop);
     }
 
-    #[inline]
-    fn exiting(&mut self, event_loop: &dyn ActiveEventLoop) {
-        (**self).exiting(event_loop);
-    }
-
     #[inline]
     fn memory_warning(&mut self, event_loop: &dyn ActiveEventLoop) {
         (**self).memory_warning(event_loop);
     }
 
-    #[cfg(any(docsrs, macos_platform))]
     #[inline]
-    fn macos_handler(&mut self) -> Option<&mut dyn ApplicationHandlerExtMacOS> {
+    fn macos_handler(&mut self) -> Option<&mut dyn macos::ApplicationHandlerExtMacOS> {
         (**self).macos_handler()
     }
 }

winit-core/src/as_any.rs

@@ -0,0 +1,92 @@
+use std::any::Any;
+
+// NOTE: This is `pub`, but isn't actually exposed outside the crate.
+// NOTE: Marked as `#[doc(hidden)]` and underscored, because they can be quite difficult to use
+// correctly, see discussion in #4160.
+// FIXME: Remove and replace with a coercion once rust-lang/rust#65991 is in MSRV (1.86).
+#[doc(hidden)]
+pub trait AsAny: Any {
+    #[doc(hidden)]
+    fn __as_any(&self) -> &dyn Any;
+    #[doc(hidden)]
+    fn __as_any_mut(&mut self) -> &mut dyn Any;
+    #[doc(hidden)]
+    fn __into_any(self: Box<Self>) -> Box<dyn Any>;
+}
+
+impl<T: Any> AsAny for T {
+    #[inline(always)]
+    fn __as_any(&self) -> &dyn Any {
+        self
+    }
+
+    #[inline(always)]
+    fn __as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    #[inline(always)]
+    fn __into_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
+#[macro_export]
+macro_rules! impl_dyn_casting {
+    ($trait:ident) => {
+        impl dyn $trait + '_ {
+            /// Downcast to the backend concrete type.
+            ///
+            /// Returns `None` if the object was not from that backend.
+            pub fn cast_ref<T: $trait>(&self) -> Option<&T> {
+                let this: &dyn std::any::Any = self.__as_any();
+                this.downcast_ref::<T>()
+            }
+
+            /// Mutable downcast to the backend concrete type.
+            ///
+            /// Returns `None` if the object was not from that backend.
+            pub fn cast_mut<T: $trait>(&mut self) -> Option<&mut T> {
+                let this: &mut dyn std::any::Any = self.__as_any_mut();
+                this.downcast_mut::<T>()
+            }
+
+            /// Owned downcast to the backend concrete type.
+            ///
+            /// Returns `Err` with `self` if the object was not from that backend.
+            pub fn cast<T: $trait>(self: Box<Self>) -> Result<Box<T>, Box<Self>> {
+                if self.cast_ref::<T>().is_some() {
+                    let this: Box<dyn std::any::Any> = self.__into_any();
+                    // Unwrap is okay, we just checked the type of `self` is `T`.
+                    Ok(this.downcast::<T>().unwrap())
+                } else {
+                    Err(self)
+                }
+            }
+        }
+    };
+}
+
+pub use impl_dyn_casting;
+
+#[cfg(test)]
+mod tests {
+    use super::AsAny;
+
+    struct Foo;
+    trait FooTrait: AsAny {}
+    impl FooTrait for Foo {}
+    impl_dyn_casting!(FooTrait);
+
+    #[test]
+    fn dyn_casting() {
+        let foo_owned: Box<dyn FooTrait> = Box::new(Foo);
+        assert!(foo_owned.cast::<Foo>().is_ok());
+
+        let mut foo = Foo;
+        let foo_ref: &mut dyn FooTrait = &mut foo;
+        assert!((foo_ref).cast_ref::<Foo>().is_some());
+        assert!((&&&&foo_ref).cast_ref::<Foo>().is_some());
+        assert!(foo_ref.cast_mut::<Foo>().is_some());
+    }
+}

winit-core/src/cursor.rs

@@ -1,13 +1,16 @@
 use core::fmt;
 use std::error::Error;
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
+use std::ops::Deref;
 use std::sync::Arc;
+use std::time::Duration;
 
-use cursor_icon::CursorIcon;
+#[doc(inline)]
+pub use cursor_icon::CursorIcon;
 
-use crate::platform_impl::{PlatformCustomCursor, PlatformCustomCursorSource};
+use crate::as_any::AsAny;
 
-/// The maximum width and height for a cursor when using [`CustomCursor::from_rgba`].
+/// The maximum width and height for a cursor when using [`CustomCursorSource::from_rgba`].
 pub const MAX_CURSOR_SIZE: u16 = 2048;
 
 const PIXEL_SIZE: usize = 4;
@@ -48,22 +51,23 @@ impl From<CustomCursor> for Cursor {
 /// # Example
 ///
 /// ```no_run
-/// # use winit::event_loop::ActiveEventLoop;
-/// # use winit::window::Window;
+/// # use winit_core::event_loop::ActiveEventLoop;
+/// # use winit_core::window::Window;
 /// # fn scope(event_loop: &dyn ActiveEventLoop, window: &dyn Window) {
-/// use winit::window::CustomCursor;
+/// use winit_core::cursor::CustomCursorSource;
 ///
 /// 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();
+/// let source = CustomCursorSource::from_rgba(rgba, w, h, w / 2, h / 2).unwrap();
 ///
 /// #[cfg(target_family = "wasm")]
-/// let source = {
-///     use winit::platform::web::CustomCursorExtWeb;
-///     CustomCursor::from_url(String::from("http://localhost:3000/cursor.png"), 0, 0)
+/// let source = CustomCursorSource::Url {
+///     url: String::from("http://localhost:3000/cursor.png"),
+///     hotspot_x: 0,
+///     hotspot_y: 0,
 /// };
 ///
 /// if let Ok(custom_cursor) = event_loop.create_custom_cursor(source) {
@@ -71,50 +75,96 @@ impl From<CustomCursor> for Cursor {
 /// }
 /// # }
 /// ```
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
-pub struct CustomCursor {
-    /// Platforms should make sure this is cheap to clone.
-    pub(crate) inner: PlatformCustomCursor,
+#[derive(Clone, Debug)]
+pub struct CustomCursor(pub Arc<dyn CustomCursorProvider>);
+
+pub trait CustomCursorProvider: AsAny + fmt::Debug + Send + Sync {
+    /// Whether a cursor was backed by animation.
+    fn is_animated(&self) -> bool;
 }
 
-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,
-            )?,
-        })
+impl PartialEq for CustomCursor {
+    fn eq(&self, other: &Self) -> bool {
+        Arc::ptr_eq(&self.0, &other.0)
     }
 }
 
+impl Eq for CustomCursor {}
+
+impl Hash for CustomCursor {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        Arc::as_ptr(&self.0).hash(state);
+    }
+}
+
+impl Deref for CustomCursor {
+    type Target = dyn CustomCursorProvider;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.deref()
+    }
+}
+
+impl_dyn_casting!(CustomCursorProvider);
+
 /// Source for [`CustomCursor`].
 ///
 /// See [`CustomCursor`] for more details.
 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
-pub struct CustomCursorSource {
-    // Some platforms don't support custom cursors.
-    #[allow(dead_code)]
-    pub(crate) inner: PlatformCustomCursorSource,
+pub enum CustomCursorSource {
+    /// Cursor that is backed by RGBA image.
+    ///
+    /// See [CustomCursorSource::from_rgba] for more.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Orbital:** Unsupported
+    Image(CursorImage),
+    /// Animated cursor.
+    ///
+    /// See [CustomCursorSource::from_animation] for more.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Wayland / Windows / X11 / macOS / Orbital:** Unsupported
+    Animation(CursorAnimation),
+    /// 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
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Wayland / Windows / X11 / macOS / Orbital:** Unsupported
+    Url { hotspot_x: u16, hotspot_y: u16, url: String },
 }
 
-/// An error produced when using [`CustomCursor::from_rgba`] with invalid arguments.
+impl CustomCursorSource {
+    /// Creates a new cursor from an rgba buffer.
+    ///
+    /// The alpha channel is assumed to be **not** premultiplied.
+    pub 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::Image)
+    }
+
+    /// Crates a new animated cursor from multiple [`CustomCursor`]s
+    /// Supplied `cursors` can't be empty or other animations.
+    pub fn from_animation(
+        duration: Duration,
+        cursors: Vec<CustomCursor>,
+    ) -> Result<Self, BadAnimation> {
+        CursorAnimation::new(duration, cursors).map(Self::Animation)
+    }
+}
+
+/// An error produced when using [`CustomCursorSource::from_rgba`] with invalid arguments.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum BadImage {
@@ -164,47 +214,29 @@ impl fmt::Display for BadImage {
 
 impl Error for BadImage {}
 
-/// Platforms export this directly as `PlatformCustomCursorSource` if they need to only work with
-/// images.
-#[allow(dead_code)]
-#[derive(Debug, Clone, Eq, Hash, PartialEq)]
-pub(crate) struct OnlyCursorImageSource(pub(crate) CursorImage);
+/// An error produced when using [`CustomCursorSource::from_animation`] with invalid arguments.
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum BadAnimation {
+    /// Produced when no cursors were supplied.
+    Empty,
+    /// Produced when a supplied cursor is an animation.
+    Animation,
+}
 
-#[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)
+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"),
+        }
     }
 }
 
-/// 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 {}
+impl Error for BadAnimation {}
 
 #[derive(Debug, Clone, Eq, Hash, PartialEq)]
-#[allow(dead_code)]
-pub(crate) struct CursorImage {
+pub struct CursorImage {
     pub(crate) rgba: Vec<u8>,
     pub(crate) width: u16,
     pub(crate) height: u16,
@@ -245,22 +277,60 @@ impl CursorImage {
 
         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;
+    pub fn buffer(&self) -> &[u8] {
+        self.rgba.as_slice()
+    }
 
-#[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)
+    pub fn buffer_mut(&mut self) -> &mut [u8] {
+        self.rgba.as_mut_slice()
+    }
+
+    pub fn width(&self) -> u16 {
+        self.width
+    }
+
+    pub fn height(&self) -> u16 {
+        self.height
+    }
+
+    pub fn hotspot_x(&self) -> u16 {
+        self.hotspot_x
+    }
+
+    pub fn hotspot_y(&self) -> u16 {
+        self.hotspot_y
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CursorAnimation {
+    pub(crate) duration: Duration,
+    pub(crate) cursors: Vec<CustomCursor>,
+}
+
+impl CursorAnimation {
+    pub fn new(duration: Duration, cursors: Vec<CustomCursor>) -> Result<Self, BadAnimation> {
+        if cursors.is_empty() {
+            return Err(BadAnimation::Empty);
+        }
+
+        if cursors.iter().any(|cursor| cursor.is_animated()) {
+            return Err(BadAnimation::Animation);
+        }
+
+        Ok(Self { duration, cursors })
+    }
+
+    pub fn duration(&self) -> Duration {
+        self.duration
+    }
+
+    pub fn cursors(&self) -> &[CustomCursor] {
+        self.cursors.as_slice()
+    }
+
+    pub fn into_raw(self) -> (Duration, Vec<CustomCursor>) {
+        (self.duration, self.cursors)
     }
 }

winit-core/src/error.rs

@@ -19,7 +19,13 @@ pub enum EventLoopError {
 impl fmt::Display for EventLoopError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::RecreationAttempt => write!(f, "EventLoop can't be recreated"),
+            Self::RecreationAttempt => {
+                write!(
+                    f,
+                    "EventLoop can't be recreated, only a single instance of it is supported (for \
+                     cross-platform compatibility)"
+                )
+            },
             Self::Os(err) => err.fmt(f),
             Self::ExitFailure(status) => write!(f, "Exit Failure: {status}"),
             Self::NotSupported(err) => err.fmt(f),
@@ -29,11 +35,7 @@ impl fmt::Display for EventLoopError {
 
 impl Error for EventLoopError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
-        if let Self::Os(err) = self {
-            err.source()
-        } else {
-            None
-        }
+        if let Self::Os(err) = self { err.source() } else { None }
     }
 }
 
@@ -72,11 +74,7 @@ impl Display for RequestError {
 }
 impl Error for RequestError {
     fn source(&self) -> Option<&(dyn Error + 'static)> {
-        if let Self::Os(err) = self {
-            err.source()
-        } else {
-            None
-        }
+        if let Self::Os(err) = self { err.source() } else { None }
     }
 }
 
@@ -100,7 +98,7 @@ pub struct NotSupportedError {
 }
 
 impl NotSupportedError {
-    pub(crate) fn new(reason: &'static str) -> Self {
+    pub fn new(reason: &'static str) -> Self {
         Self { reason }
     }
 }
@@ -121,8 +119,7 @@ pub struct OsError {
 }
 
 impl OsError {
-    #[allow(dead_code)]
-    pub(crate) fn new(
+    pub fn new(
         line: u32,
         file: &'static str,
         error: impl Into<Box<dyn Error + Send + Sync + 'static>>,
@@ -144,7 +141,5 @@ impl Error for OsError {
 
 #[allow(unused_macros)]
 macro_rules! os_error {
-    ($error:expr) => {{
-        crate::error::OsError::new(line!(), file!(), $error)
-    }};
+    ($error:expr) => {{ crate::error::OsError::new(line!(), file!(), $error) }};
 }