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/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.80']
+        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,  }
@@ -82,13 +82,13 @@ jobs:
           - toolchain: nightly
             platform: { name: 'Windows 32bit GNU' }
           # Android is tested on stable-3
-          - toolchain: '1.80'
+          - toolchain: '1.85'
             platform: { name: 'Android' }
           # Redox OS doesn't follow MSRV
-          - toolchain: '1.80'
+          - toolchain: '1.85'
             platform: { name: 'Redox OS' }
         include:
-          - toolchain: '1.80'
+          - 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 }
@@ -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
@@ -230,19 +230,19 @@ jobs:
     - name: Test dpi crate
       if: >
         contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.80'
+        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.80'
+        matrix.toolchain != '1.85'
       run: cargo check -p dpi --no-default-features
 
     - name: Build tests
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.80'
+        matrix.toolchain != '1.85'
       run: cargo $CMD test --no-run $OPTIONS
 
     - name: Run tests
@@ -251,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.80'
+        matrix.toolchain != '1.85'
       run: cargo $CMD test $OPTIONS
 
     - name: Lint with clippy
@@ -261,7 +261,7 @@ jobs:
     - name: Build tests with serde enabled
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.80'
+        matrix.toolchain != '1.85'
       run: cargo $CMD test --no-run $OPTIONS $TEST_OPTIONS --features serde
 
     - name: Run tests with serde enabled
@@ -270,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.80'
+        matrix.toolchain != '1.85'
       run: cargo $CMD test $OPTIONS $TEST_OPTIONS --features serde
 
     - name: Check docs.rs documentation
@@ -281,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/
@@ -290,31 +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
-        manifest-path: winit/Cargo.toml
-        arguments: --all-features --target ${{ matrix.platform.target }}
 
   eslint:
     name: ESLint
@@ -329,7 +312,7 @@ jobs:
       - name: Setup NPM
         run: npm install
       - name: Run ESLint
-        run: npx eslint
+        run: npx eslint@9.38.0
 
   swc:
     name: Minimize JavaScript

.github/workflows/docs.yml

@@ -19,7 +19,7 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@v5
+      - 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@v4
+        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

Cargo.toml

@@ -4,26 +4,26 @@ members = ["dpi", "winit*"]
 resolver = "2"
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 license = "Apache-2.0"
 repository = "https://github.com/rust-windowing/winit"
-rust-version = "1.80"
-version = "0.30.12"
+rust-version = "1.85"
+version = "0.31.0-beta.2"
 
 [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.30.12", path = "winit-android" }
-winit-appkit = { version = "0.30.12", path = "winit-appkit" }
-winit-common = { version = "0.30.12", path = "winit-common" }
-winit-core = { version = "0.30.12", path = "winit-core" }
-winit-orbital = { version = "0.30.12", path = "winit-orbital" }
-winit-uikit = { version = "0.30.12", path = "winit-uikit" }
-winit-wayland = { version = "0.30.12", path = "winit-wayland", default-features = false }
-winit-web = { version = "0.30.12", path = "winit-web" }
-winit-win32 = { version = "0.30.12", path = "winit-win32" }
-winit-x11 = { version = "0.30.12", path = "winit-x11" }
+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" }
 
 # Core dependencies.
 bitflags = "2"
@@ -39,7 +39,7 @@ tracing = { version = "0.1.40", default-features = false }
 
 # Dev dependencies.
 image = { version = "0.25.0", default-features = false }
-softbuffer = { version = "0.4.6", default-features = false, features = [
+softbuffer = { version = "0.4.8", default-features = false, features = [
     "x11",
     "x11-dlopen",
     "wayland",
@@ -55,40 +55,33 @@ ndk = { version = "0.9.0", features = ["rwh_06"], default-features = false }
 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.1", default-features = false }
-objc2-core-foundation = { version = "0.3.1", default-features = false }
-objc2-core-graphics = { version = "0.3.1", default-features = false }
-objc2-core-video = { version = "0.3.1", default-features = false }
-objc2-foundation = { version = "0.3.1", default-features = false }
-objc2-ui-kit = { version = "0.3.1", default-features = false }
+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 }
 
 # Windows dependencies.
 unicode-segmentation = "1.7.1"
-windows-sys = "0.59.0"
+windows-sys = "0.61"
 
 # Linux dependencies.
-ahash = { version = "0.8.7", features = ["no-rng"] }
 bytemuck = { version = "1.13.1", default-features = false }
-calloop = "0.13.0"
+calloop = "0.14.3"
+foldhash = { version = "0.2.0", default-features = false, features = ["std"] }
 libc = "0.2.64"
 memmap2 = "0.9.0"
 percent-encoding = "2.0"
 rustix = { version = "1.0.7", default-features = false }
-sctk = { package = "smithay-client-toolkit", version = "0.19.2", default-features = false, features = [
-    "calloop",
-] }
-sctk-adwaita = { version = "0.10.1", default-features = false }
-wayland-backend = { version = "0.3.10", default-features = false, features = ["client_system"] }
-wayland-client = "0.31.10"
-wayland-protocols = { version = "0.32.8", features = ["staging"] }
-wayland-protocols-plasma = { version = "0.3.8", features = ["client"] }
 x11-dl = "2.19.1"
 x11rb = { version = "0.13.0", default-features = false }
 xkbcommon-dl = "0.4.2"
 
 # 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 dependencies.
 atomic-waker = "1"

README.md

@@ -8,7 +8,7 @@
 
 ```toml
 [dependencies]
-winit = "0.30.12"
+winit = "0.31.0-beta.2"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -39,7 +39,7 @@ For contributing guidelines see [CONTRIBUTING.md](./CONTRIBUTING.md).
 
 ## MSRV Policy
 
-This crate's Minimum Supported Rust Version (MSRV) is **1.80**. 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

clippy.toml

@@ -1,4 +1,11 @@
 # 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" },
@@ -10,6 +17,9 @@ disallowed-methods = [
     { 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" },

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,6 +30,8 @@ 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 }
@@ -39,42 +39,23 @@ private = { ignore = true }
 [bans]
 multiple-versions = "deny"
 skip = [
-    { crate = "bitflags@1", reason = "the ecosystem is in the process of migrating" },
-    { crate = "rustix@0.38", reason = "the ecosystem is in the process of migrating" },
-    { crate = "linux-raw-sys@0.4", reason = "the ecosystem is in the process of migrating" },
+    { 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" },
 ]
-wildcards = "allow" # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
 
 [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 = ["ci/*", "githooks/*"]
-crate = "zerocopy"
-
-[[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"

dpi/src/lib.rs

@@ -64,7 +64,7 @@
 //! [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)))]
+#![cfg_attr(docsrs, feature(doc_cfg), doc(auto_cfg(hide(doc, docsrs))))]
 #![cfg_attr(feature = "std", forbid(unsafe_code))]
 #![no_std]
 
@@ -84,36 +84,18 @@ pub trait Pixel: Copy + Into<f64> {
     }
 }
 
-impl Pixel for u8 {
-    fn from_f64(f: f64) -> Self {
-        round(f) as u8
-    }
-}
-impl Pixel for u16 {
-    fn from_f64(f: f64) -> Self {
-        round(f) as u16
-    }
-}
-impl Pixel for u32 {
-    fn from_f64(f: f64) -> Self {
-        round(f) as u32
-    }
-}
-impl Pixel for i8 {
-    fn from_f64(f: f64) -> Self {
-        round(f) as i8
-    }
-}
-impl Pixel for i16 {
-    fn from_f64(f: f64) -> Self {
-        round(f) as i16
-    }
-}
-impl Pixel for i32 {
-    fn from_f64(f: f64) -> Self {
-        round(f) 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
@@ -378,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
@@ -420,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)]
@@ -496,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)]
@@ -572,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)]
@@ -645,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)]

examples

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

examples/util/fill.rs

@@ -1,156 +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_animated_color;
-#[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;
-    #[cfg(all(not(android_platform), not(web_platform)))]
-    use std::time::Instant;
-
-    use softbuffer::{Context, Surface};
-    #[cfg(all(web_platform, not(android_platform)))]
-    use web_time::Instant;
-    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 fill_window_with_animated_color(window: &dyn Window, start: Instant) {
-        let time = start.elapsed().as_secs_f32() * 1.5;
-        let blue = (time.sin() * 255.0) as u32;
-        let green = ((time.cos() * 255.0) as u32) << 8;
-        let red = ((1.0 - time.sin() * 255.0) as u32) << 16;
-        let color = red | green | blue;
-        fill_window_with_color(window, color);
-    }
-
-    #[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 {
-    #[allow(dead_code)]
-    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 fill_window_with_animated_color(
-        _window: &dyn winit::window::Window,
-        _start: std::time::Instant,
-    ) {
-        // No-op on mobile platforms.
-    }
-
-    #[allow(dead_code)]
-    pub fn cleanup_window(_window: &dyn winit::window::Window) {
-        // No-op on mobile platforms.
-    }
-}

winit-android/src/event_loop.rs

@@ -473,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,
@@ -500,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,
@@ -876,16 +879,8 @@ impl CoreWindow for Window {
         PhysicalInsets::new(0, 0, 0, 0)
     }
 
-    fn min_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        None
-    }
-
     fn set_min_surface_size(&self, _: Option<Size>) {}
 
-    fn max_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        None
-    }
-
     fn set_max_surface_size(&self, _: Option<Size>) {}
 
     fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
@@ -896,16 +891,8 @@ impl CoreWindow for Window {
 
     fn set_title(&self, _title: &str) {}
 
-    fn is_transparent(&self) -> bool {
-        false
-    }
-
     fn set_transparent(&self, _transparent: bool) {}
 
-    fn is_blurred(&self) -> bool {
-        false
-    }
-
     fn set_blur(&self, _blur: bool) {}
 
     fn set_visible(&self, _visibility: bool) {}
@@ -952,16 +939,8 @@ impl CoreWindow for Window {
         true
     }
 
-    fn window_level(&self) -> WindowLevel {
-        WindowLevel::default()
-    }
-
     fn set_window_level(&self, _level: WindowLevel) {}
 
-    fn window_icon(&self) -> Option<winit_core::icon::Icon> {
-        None
-    }
-
     fn set_window_icon(&self, _window_icon: Option<winit_core::icon::Icon>) {}
 
     fn set_ime_cursor_area(&self, _position: Position, _size: Size) {}
@@ -1001,10 +980,6 @@ impl CoreWindow for Window {
 
     fn request_user_attention(&self, _request_type: Option<window::UserAttentionType>) {}
 
-    fn cursor(&self) -> Cursor {
-        Cursor::default()
-    }
-
     fn set_cursor(&self, _: Cursor) {}
 
     fn set_cursor_position(&self, _: Position) -> Result<(), RequestError> {
@@ -1038,10 +1013,6 @@ impl CoreWindow for Window {
         None
     }
 
-    fn content_protected(&self) -> bool {
-        false
-    }
-
     fn set_content_protected(&self, _protected: bool) {}
 
     fn has_focus(&self) -> bool {

winit-android/src/keycodes.rs

@@ -1,5 +1,5 @@
-use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
 use android_activity::AndroidApp;
+use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
 use winit_core::keyboard::{
     Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey,
 };
@@ -109,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,
@@ -131,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,
 
@@ -154,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())),
     })
 }

winit-android/src/lib.rs

@@ -62,8 +62,8 @@
 //! If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building
 //! with `cargo apk`, then the minimal changes would be:
 //! 1. Remove `ndk-glue` from your `Cargo.toml`
-//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.12",
-//!    features = [ "android-native-activity" ] }`
+//! 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).

winit-appkit/Cargo.toml

@@ -18,7 +18,6 @@ rwh_06.workspace = true
 serde = { workspace = true, optional = true }
 smol_str.workspace = true
 tracing.workspace = true
-winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }
 winit-core.workspace = true
 
 # Platform-specific
@@ -52,6 +51,7 @@ objc2-app-kit = { workspace = true, features = [
     "NSScreen",
     "NSTextInputClient",
     "NSTextInputContext",
+    "NSTrackingArea",
     "NSToolbar",
     "NSView",
     "NSWindow",
@@ -107,6 +107,7 @@ objc2-foundation = { workspace = true, features = [
     "NSThread",
     "NSValue",
 ] }
+winit-common = { workspace = true, features = ["core-foundation", "event-handler", "foundation"] }
 
 [dev-dependencies]
 winit.workspace = true

winit-appkit/src/app.rs

@@ -1,14 +1,15 @@
 #![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;
@@ -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;
+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::event_loop::{notify_windows_of_exit, 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 super::observer::EventLoopWaker;
 
 #[derive(Debug)]
 pub(super) struct AppState {
@@ -25,7 +25,7 @@ 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,
     stop_on_launch: Cell<bool>,
@@ -68,7 +68,7 @@ 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),
@@ -99,7 +99,6 @@ impl AppState {
     // 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");
         self.is_launched.set(true);
 
         let app = NSApplication::sharedApplication(self.mtm);
@@ -117,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);
             }
@@ -154,7 +153,6 @@ impl AppState {
     }
 
     pub fn will_terminate(self: &Rc<Self>, _notification: &NSNotification) {
-        trace_scope!("NSApplicationWillTerminateNotification");
         let app = NSApplication::sharedApplication(self.mtm);
         notify_windows_of_exit(&app);
         self.event_handler.terminate();
@@ -265,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]
@@ -310,6 +308,7 @@ 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
+        // (we have registered to observe all modes, including modal event loops).
         if !self.event_handler.ready() || !self.is_running() {
             return;
         }
@@ -338,8 +337,7 @@ 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?
+        // (we have registered to observe all modes, including modal event loops).
         if !self.event_handler.ready() || !self.is_running() {
             return;
         }

winit-appkit/src/cursor.rs

@@ -4,10 +4,13 @@ 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::{AllocAnyThread, ClassType, available, msg_send, sel};
+use objc2_app_kit::{
+    NSBitmapImageRep, NSCursor, NSCursorFrameResizeDirections, NSCursorFrameResizePosition,
+    NSDeviceRGBColorSpace, NSImage,
+};
 use objc2_foundation::{
-    ns_string, NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString,
+    NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString, ns_string,
 };
 use winit_core::cursor::{CursorIcon, CursorImage, CustomCursorProvider, CustomCursorSource};
 use winit_core::error::{NotSupportedError, RequestError};
@@ -31,7 +34,7 @@ impl CustomCursor {
         let cursor = match cursor {
             CustomCursorSource::Image(cursor_image) => cursor_image,
             CustomCursorSource::Animation { .. } | CustomCursorSource::Url { .. } => {
-                return Err(NotSupportedError::new("unsupported cursor kind").into())
+                return Err(NotSupportedError::new("unsupported cursor kind").into());
             },
         };
 
@@ -62,10 +65,8 @@ pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Result<Retained<NSCurso
         unsafe { slice::from_raw_parts_mut(bitmap.bitmapData(), cursor.buffer().len()) };
     bitmap_data.copy_from_slice(cursor.buffer());
 
-    let image = unsafe {
-        NSImage::initWithSize(NSImage::alloc(), NSSize::new(width.into(), height.into()))
-    };
-    unsafe { image.addRepresentation(&bitmap) };
+    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);
 
@@ -140,12 +141,9 @@ unsafe fn load_webkit_cursor(name: &NSString) -> Retained<NSCursor> {
 
     // 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,
-        ]
-    };
+    #[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>() {
@@ -209,23 +207,155 @@ pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Retained<NSCursor> {
         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::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(),
-        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(),

winit-appkit/src/event.rs

@@ -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.
@@ -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();
 
@@ -334,8 +332,7 @@ pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
 }
 
 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,7 +343,6 @@ pub(super) fn dummy_event() -> Option<Retained<NSEvent>> {
             0,
             0,
         )
-    }
 }
 
 pub fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {

winit-appkit/src/event_loop.rs

@@ -2,15 +2,19 @@ use std::rc::Rc;
 use std::sync::Arc;
 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, 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};
@@ -27,10 +31,8 @@ use super::app_state::AppState;
 use super::cursor::CustomCursor;
 use super::event::dummy_event;
 use super::monitor;
-use super::notification_center::create_observer;
-use super::observer::setup_control_flow_observers;
-use crate::window::Window;
 use crate::ActivationPolicy;
+use crate::window::Window;
 
 #[derive(Debug)]
 pub struct ActiveEventLoop {
@@ -150,6 +152,10 @@ 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)]
@@ -191,7 +197,7 @@ impl EventLoop {
         // Override `sendEvent:` on the application to forward to our application state.
         override_send_event(&app);
 
-        let center = unsafe { NSNotificationCenter::defaultCenter() };
+        let center = NSNotificationCenter::defaultCenter();
 
         let weak_app_state = Rc::downgrade(&app_state);
         let _did_finish_launching_observer = create_observer(
@@ -199,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);
                 }
@@ -211,13 +218,45 @@ 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,
@@ -225,6 +264,9 @@ impl EventLoop {
             window_target: ActiveEventLoop { app_state, mtm },
             _did_finish_launching_observer,
             _will_terminate_observer,
+            _tracing_observers,
+            _before_waiting_observer,
+            _after_waiting_observer,
         })
     }
 
@@ -232,10 +274,6 @@ 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

winit-appkit/src/ffi.rs

@@ -6,7 +6,7 @@ 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 IO16BitDirectPixels: &str = "-RRRRRGGGGGBBBBB";
@@ -22,14 +22,14 @@ pub const kIO64BitDirectPixels: &str = "-16R16G16B16";
 // `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(
@@ -60,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)]

winit-appkit/src/lib.rs

@@ -20,7 +20,7 @@
 //! ```
 //! 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, NSObject, NSObjectProtocol, NSURL};
 //! use winit::event_loop::EventLoop;
@@ -76,7 +76,6 @@ mod event_loop;
 mod ffi;
 mod menu;
 mod monitor;
-mod notification_center;
 mod observer;
 mod view;
 mod window;

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, NSBundle, NSProcessInfo, NSString};
+use objc2_foundation::{NSBundle, NSProcessInfo, NSString, ns_string};
 
 struct KeyEquivalent<'a> {
     key: &'a NSString,
@@ -82,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

@@ -7,16 +7,16 @@ use std::{fmt, ptr};
 
 use dispatch2::run_on_main;
 use dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use objc2::rc::Retained;
 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::{kCVReturnSuccess, CVDisplayLink, CVTimeFlags};
-use objc2_foundation::{ns_string, NSNumber, NSPoint, NSRect};
+use objc2_core_video::{CVDisplayLink, CVTimeFlags, kCVReturnSuccess};
+use objc2_foundation::{NSNumber, NSPoint, NSRect, ns_string};
 use tracing::warn;
 use winit_core::monitor::{MonitorHandleProvider, VideoMode};
 
@@ -65,35 +65,33 @@ impl VideoModeHandle {
         native_mode: NativeDisplayMode,
         refresh_rate_millihertz: Option<NonZeroU32>,
     ) -> Self {
-        unsafe {
-            // 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
-            };
+        // 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,
-            );
+        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,
+        );
 
-            VideoModeHandle { mode, monitor: monitor.clone(), native_mode }
-        }
+        Self { mode, monitor: monitor.clone(), native_mode }
     }
 }
 
@@ -137,11 +135,11 @@ impl MonitorHandle {
 
     fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
         let current_display_mode =
-            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.display_id()) }.unwrap());
+            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> {
+    pub fn video_mode_handles(&self) -> impl Iterator<Item = VideoModeHandle> + 'static {
         let refresh_rate_millihertz = self.refresh_rate_millihertz();
         let monitor = self.clone();
 
@@ -159,7 +157,7 @@ impl MonitorHandle {
         };
 
         modes.into_iter().map(move |mode| {
-            let cg_refresh_rate_hertz = unsafe { CGDisplayMode::refresh_rate(Some(&mode)) };
+            let cg_refresh_rate_hertz = CGDisplayMode::refresh_rate(Some(&mode));
 
             // CGDisplayModeGetRefreshRate returns 0.0 for any display that
             // isn't a CRT
@@ -202,7 +200,7 @@ impl MonitorHandleProvider for MonitorHandle {
     //
     // <https://github.com/glfw/glfw/blob/57cbded0760a50b9039ee0cb3f3c14f60145567c/src/cocoa_monitor.m#L44-L126>
     fn name(&self) -> Option<std::borrow::Cow<'_, str>> {
-        let screen_num = unsafe { CGDisplayModelNumber(self.display_id()) };
+        let screen_num = CGDisplayModelNumber(self.display_id());
         Some(format!("Monitor #{screen_num}").into())
     }
 
@@ -210,7 +208,7 @@ impl MonitorHandleProvider for MonitorHandle {
         // 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.display_id()) };
+        let bounds = CGDisplayBounds(self.display_id());
         let position = LogicalPosition::new(bounds.origin.x, bounds.origin.y);
         Some(position.to_physical(self.scale_factor()))
     }
@@ -225,8 +223,7 @@ impl MonitorHandleProvider for MonitorHandle {
     }
 
     fn current_video_mode(&self) -> Option<VideoMode> {
-        let mode =
-            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.display_id()) }.unwrap());
+        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)
     }
@@ -264,7 +261,7 @@ pub fn available_monitors() -> VecDeque<MonitorHandle> {
 
 pub fn primary_monitor() -> MonitorHandle {
     // Display ID just fetched from `CGMainDisplayID`, should be fine to unwrap.
-    MonitorHandle::new(unsafe { CGMainDisplayID() }).expect("invalid display ID")
+    MonitorHandle::new(CGMainDisplayID()).expect("invalid display ID")
 }
 
 impl fmt::Debug for MonitorHandle {
@@ -315,40 +312,38 @@ 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 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> {
-    unsafe {
-        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 CVDisplayLink::create_with_cg_display(id, NonNull::from(&mut display_link))
-            != kCVReturnSuccess
-        {
-            return None;
-        }
-        let display_link = 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)
+    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)]
@@ -357,8 +352,10 @@ mod tests {
 
     #[test]
     fn uuid_stable() {
-        let handle_a = MonitorHandle::new(1).unwrap();
-        let handle_b = MonitorHandle::new(1).unwrap();
+        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());
@@ -373,8 +370,10 @@ mod tests {
     /// Test the MonitorHandle::new fallback.
     #[test]
     fn monitorhandle_from_zero() {
+        let primary_id = CGMainDisplayID();
+
         let handle0 = MonitorHandle::new(0).unwrap();
-        let handle1 = MonitorHandle::new(1).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());
@@ -395,7 +394,7 @@ mod tests {
         // 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 _ = unsafe { CGMainDisplayID() };
+        let _ = CGMainDisplayID();
 
         let handle = MonitorHandle(CFUUID::new(None).unwrap());
         assert_eq!(handle.display_id(), 0);

winit-appkit/src/observer.rs

@@ -1,171 +1,10 @@
-//! 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, CFRunLoopObserver, CFRunLoopObserverCallBack,
-    CFRunLoopObserverContext, CFRunLoopTimer,
+    CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, kCFRunLoopCommonModes,
 };
-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(CFRunLoop::main().unwrap())
-    }
-
-    pub fn wakeup(&self) {
-        self.0.wake_up();
-    }
-
-    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 { CFRunLoopObserver::new(None, flags.0, true, priority, handler, context) }
-                .unwrap();
-        self.0.add_observer(Some(&observer), unsafe { 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 { self.0.perform_block(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 {

winit-appkit/src/util.rs

@@ -1,44 +1,11 @@
 use objc2_core_graphics::CGError;
-use tracing::trace;
 use winit_core::error::OsError;
 
 macro_rules! os_error {
-    ($error:expr) => {{
-        winit_core::error::OsError::new(line!(), file!(), $error)
-    }};
-}
-
-macro_rules! trace_scope {
-    ($s:literal) => {
-        let _crate = $crate::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);
-    }
+    ($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:?}")))
-    }
+    if err == CGError::Success { Ok(()) } else { Err(os_error!(format!("CGError {err:?}"))) }
 }

winit-appkit/src/view.rs

@@ -1,22 +1,22 @@
 #![allow(clippy::unnecessary_cast)]
 use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, VecDeque};
-use std::ptr;
 use std::rc::Rc;
 
-use dpi::{LogicalPosition, LogicalSize};
+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,
@@ -119,7 +119,6 @@ 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>,
 
@@ -131,7 +130,6 @@ pub struct ViewState {
     /// 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,
 
@@ -153,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()));
 
@@ -204,7 +188,7 @@ define_class!(
 
         #[unsafe(method(acceptsFirstResponder))]
         fn accepts_first_responder(&self) -> bool {
-            trace_scope!("acceptsFirstResponder");
+            let _entered = trace_span!("acceptsFirstResponder").entered();
             true
         }
 
@@ -218,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`
@@ -239,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)
@@ -257,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)
         }
@@ -270,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>()
@@ -292,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");
@@ -335,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()
         }
 
@@ -345,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
         }
 
@@ -361,7 +351,7 @@ 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 {
@@ -377,7 +367,7 @@ define_class!(
         #[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()
@@ -391,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);
@@ -402,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
@@ -414,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);
             }
@@ -442,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();
@@ -467,7 +456,7 @@ define_class!(
             // is not handled by IME and should be handled by the application)
             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 {
@@ -490,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,
@@ -501,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);
@@ -518,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 {
@@ -536,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 {
@@ -550,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,
@@ -579,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());
 
@@ -657,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());
 
@@ -671,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 {
@@ -690,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,
@@ -710,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,
@@ -725,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);
 
@@ -741,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,
@@ -756,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,
             });
         }
 
@@ -777,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
         }
     }
@@ -803,7 +794,6 @@ 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_capabilities: Default::default(),
@@ -813,9 +803,56 @@ impl WinitView {
             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
     }
 
@@ -830,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
     }
@@ -867,24 +935,33 @@ 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, capabilities: Option<ImeCapabilities>) {
-        if self.ivars().ime_capabilities.get().is_some() {
-            return;
-        }
-        self.ivars().ime_capabilities.set(capabilities);
-
-        if capabilities.is_some() {
-            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> {
@@ -931,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);
@@ -1064,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;
@@ -1082,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)
@@ -1096,14 +1173,11 @@ 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
@@ -1120,12 +1194,10 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEven
         && !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(),
@@ -1138,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

@@ -3,11 +3,12 @@
 use std::sync::Arc;
 
 use dispatch2::MainThreadBound;
-use dpi::{PhysicalSize, Position, Size};
-use objc2::rc::{autoreleasepool, Retained};
-use objc2::{define_class, MainThreadMarker, Message};
+use dpi::{Position, Size};
+use objc2::rc::{Retained, autoreleasepool};
+use objc2::{MainThreadMarker, Message, define_class};
 use objc2_app_kit::{NSPanel, NSResponder, NSWindow};
 use objc2_foundation::NSObject;
+use tracing::trace_span;
 use winit_core::cursor::Cursor;
 use winit_core::error::RequestError;
 use winit_core::icon::Icon;
@@ -141,18 +142,10 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.safe_area())
     }
 
-    fn min_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        self.maybe_wait_on_main(|delegate| delegate.min_surface_size())
-    }
-
     fn set_min_surface_size(&self, min_size: Option<Size>) {
         self.maybe_wait_on_main(|delegate| delegate.set_min_surface_size(min_size))
     }
 
-    fn max_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        self.maybe_wait_on_main(|delegate| delegate.max_surface_size())
-    }
-
     fn set_max_surface_size(&self, max_size: Option<Size>) {
         self.maybe_wait_on_main(|delegate| delegate.set_max_surface_size(max_size));
     }
@@ -169,18 +162,10 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.set_title(title));
     }
 
-    fn is_transparent(&self) -> bool {
-        self.maybe_wait_on_main(|delegate| delegate.is_transparent())
-    }
-
     fn set_transparent(&self, transparent: bool) {
         self.maybe_wait_on_main(|delegate| delegate.set_transparent(transparent));
     }
 
-    fn is_blurred(&self) -> bool {
-        self.maybe_wait_on_main(|delegate| delegate.is_blurred())
-    }
-
     fn set_blur(&self, blur: bool) {
         self.maybe_wait_on_main(|delegate| delegate.set_blur(blur));
     }
@@ -241,18 +226,10 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.is_decorated())
     }
 
-    fn window_level(&self) -> WindowLevel {
-        self.maybe_wait_on_main(|delegate| delegate.window_level())
-    }
-
     fn set_window_level(&self, level: WindowLevel) {
         self.maybe_wait_on_main(|delegate| delegate.set_window_level(level));
     }
 
-    fn window_icon(&self) -> Option<Icon> {
-        self.maybe_wait_on_main(|delegate| delegate.window_icon())
-    }
-
     fn set_window_icon(&self, window_icon: Option<Icon>) {
         self.maybe_wait_on_main(|delegate| delegate.set_window_icon(window_icon));
     }
@@ -285,10 +262,6 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.theme())
     }
 
-    fn content_protected(&self) -> bool {
-        self.maybe_wait_on_main(|delegate| delegate.content_protected())
-    }
-
     fn set_content_protected(&self, protected: bool) {
         self.maybe_wait_on_main(|delegate| delegate.set_content_protected(protected));
     }
@@ -297,10 +270,6 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.title())
     }
 
-    fn cursor(&self) -> Cursor {
-        self.maybe_wait_on_main(|delegate| delegate.cursor())
-    }
-
     fn set_cursor(&self, cursor: Cursor) {
         self.maybe_wait_on_main(|delegate| delegate.set_cursor(cursor));
     }
@@ -382,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
         }
     }
@@ -406,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-appkit/src/window_delegate.rs

@@ -10,36 +10,39 @@ use dpi::{
     LogicalInsets, LogicalPosition, LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize,
     Position, Size,
 };
-use objc2::rc::{autoreleasepool, Retained};
+use objc2::rc::{Retained, autoreleasepool};
 use objc2::runtime::{AnyObject, ProtocolObject};
 use objc2::{
-    available, define_class, msg_send, sel, ClassType, DefinedClass, MainThreadMarker,
-    MainThreadOnly, Message,
+    ClassType, DefinedClass, MainThreadMarker, MainThreadOnly, Message, available, define_class,
+    msg_send, sel,
 };
 use objc2_app_kit::{
     NSAppKitVersionNumber, NSAppKitVersionNumber10_12, NSAppearance, NSAppearanceCustomization,
     NSAppearanceNameAqua, NSApplication, NSApplicationPresentationOptions, NSBackingStoreType,
-    NSColor, NSDraggingDestination, NSDraggingInfo, NSFilenamesPboardType,
-    NSRequestUserAttentionType, NSScreen, NSToolbar, NSView, NSViewFrameDidChangeNotification,
-    NSWindow, NSWindowButton, NSWindowDelegate, NSWindowFullScreenButton, NSWindowLevel,
-    NSWindowOcclusionState, NSWindowOrderingMode, NSWindowSharingType, NSWindowStyleMask,
-    NSWindowTabbingMode, NSWindowTitleVisibility, NSWindowToolbarStyle,
+    NSColor, NSDraggingDestination, NSDraggingInfo, NSRequestUserAttentionType, NSScreen,
+    NSToolbar, NSView, NSViewFrameDidChangeNotification, NSWindow, NSWindowButton,
+    NSWindowDelegate, NSWindowLevel, NSWindowOcclusionState, NSWindowOrderingMode,
+    NSWindowSharingType, NSWindowStyleMask, NSWindowTabbingMode, NSWindowTitleVisibility,
+    NSWindowToolbarStyle,
 };
+#[allow(deprecated)]
+use objc2_app_kit::{NSFilenamesPboardType, NSWindowFullScreenButton};
 use objc2_core_foundation::{CGFloat, CGPoint};
 use objc2_core_graphics::{
-    kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, kCGDisplayFadeReservationInvalidToken,
-    kCGFloatingWindowLevel, kCGNormalWindowLevel, CGAcquireDisplayFadeReservation,
-    CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture, CGDisplayFade, CGDisplayRelease,
-    CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
+    CGAcquireDisplayFadeReservation, CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture,
+    CGDisplayFade, CGDisplayRelease, CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
     CGRestorePermanentDisplayConfiguration, CGShieldingWindowLevel, CGWarpMouseCursorPosition,
+    kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, kCGDisplayFadeReservationInvalidToken,
+    kCGFloatingWindowLevel, kCGNormalWindowLevel,
 };
 use objc2_foundation::{
-    ns_string, NSArray, NSDictionary, NSEdgeInsets, NSKeyValueChangeKey, NSKeyValueChangeNewKey,
+    NSArray, NSDictionary, NSEdgeInsets, NSKeyValueChangeKey, NSKeyValueChangeNewKey,
     NSKeyValueChangeOldKey, NSKeyValueObservingOptions, NSNotificationCenter, NSObject,
     NSObjectNSDelayedPerforming, NSObjectNSKeyValueObserverRegistration, NSObjectProtocol, NSPoint,
-    NSRect, NSSize, NSString,
+    NSRect, NSSize, NSString, ns_string,
 };
-use tracing::{trace, warn};
+use tracing::{debug_span, trace, warn};
+use winit_common::core_foundation::MainRunLoop;
 use winit_core::cursor::Cursor;
 use winit_core::error::{NotSupportedError, RequestError};
 use winit_core::event::{SurfaceSizeWriter, WindowEvent};
@@ -51,13 +54,12 @@ use winit_core::window::{
 };
 
 use super::app_state::AppState;
-use super::cursor::{cursor_from_icon, CustomCursor};
+use super::cursor::{CustomCursor, cursor_from_icon};
 use super::ffi;
-use super::monitor::{self, flip_window_screen_coordinates, get_display_id, MonitorHandle};
-use super::observer::RunLoop;
+use super::monitor::{self, MonitorHandle, flip_window_screen_coordinates, get_display_id};
 use super::util::cgerr;
 use super::view::WinitView;
-use super::window::{window_id, WinitPanel, WinitWindow};
+use super::window::{WinitPanel, WinitWindow, window_id};
 use crate::{OptionAsAlt, WindowAttributesMacOS, WindowExtMacOS};
 
 #[derive(Debug)]
@@ -119,14 +121,14 @@ define_class!(
     unsafe impl NSWindowDelegate for WindowDelegate {
         #[unsafe(method(windowShouldClose:))]
         fn window_should_close(&self, _: Option<&AnyObject>) -> bool {
-            trace_scope!("windowShouldClose:");
+            let _entered = debug_span!("windowShouldClose:").entered();
             self.queue_event(WindowEvent::CloseRequested);
             false
         }
 
         #[unsafe(method(windowWillClose:))]
         fn window_will_close(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowWillClose:");
+            let _entered = debug_span!("windowWillClose:").entered();
             // `setDelegate:` retains the previous value and then autoreleases it
             autoreleasepool(|_| {
                 // Since El Capitan, we need to be careful that delegate methods can't
@@ -138,14 +140,14 @@ define_class!(
 
         #[unsafe(method(windowDidResize:))]
         fn window_did_resize(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidResize:");
+            let _entered = debug_span!("windowDidResize:").entered();
             // NOTE: WindowEvent::SurfaceResized is reported using NSViewFrameDidChangeNotification.
             self.emit_move_event();
         }
 
         #[unsafe(method(windowWillStartLiveResize:))]
         fn window_will_start_live_resize(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowWillStartLiveResize:");
+            let _entered = debug_span!("windowWillStartLiveResize:").entered();
 
             let increments = self.ivars().surface_resize_increments.get();
             self.set_resize_increments_inner(increments);
@@ -153,20 +155,20 @@ define_class!(
 
         #[unsafe(method(windowDidEndLiveResize:))]
         fn window_did_end_live_resize(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidEndLiveResize:");
+            let _entered = debug_span!("windowDidEndLiveResize:").entered();
             self.set_resize_increments_inner(NSSize::new(1., 1.));
         }
 
         // This won't be triggered if the move was part of a resize.
         #[unsafe(method(windowDidMove:))]
         fn window_did_move(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidMove:");
+            let _entered = debug_span!("windowDidMove:").entered();
             self.emit_move_event();
         }
 
         #[unsafe(method(windowDidChangeBackingProperties:))]
         fn window_did_change_backing_properties(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidChangeBackingProperties:");
+            let _entered = debug_span!("windowDidChangeBackingProperties:").entered();
             let scale_factor = self.scale_factor();
             if scale_factor == self.ivars().previous_scale_factor.get() {
                 return;
@@ -175,14 +177,14 @@ define_class!(
 
             let mtm = MainThreadMarker::from(self);
             let this = self.retain();
-            RunLoop::main(mtm).queue_closure(move || {
+            MainRunLoop::get(mtm).queue_closure(move || {
                 this.handle_scale_factor_changed(scale_factor);
             });
         }
 
         #[unsafe(method(windowDidBecomeKey:))]
         fn window_did_become_key(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidBecomeKey:");
+            let _entered = debug_span!("windowDidBecomeKey:").entered();
             // TODO: center the cursor if the window had mouse grab when it
             // lost focus
             self.queue_event(WindowEvent::Focused(true));
@@ -190,7 +192,7 @@ define_class!(
 
         #[unsafe(method(windowDidResignKey:))]
         fn window_did_resign_key(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidResignKey:");
+            let _entered = debug_span!("windowDidResignKey:").entered();
             // It happens rather often, e.g. when the user is Cmd+Tabbing, that the
             // NSWindowDelegate will receive a didResignKey event despite no event
             // being received when the modifiers are released. This is because
@@ -206,7 +208,7 @@ define_class!(
         /// Invoked when before enter fullscreen
         #[unsafe(method(windowWillEnterFullScreen:))]
         fn window_will_enter_fullscreen(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowWillEnterFullScreen:");
+            let _entered = debug_span!("windowWillEnterFullScreen:").entered();
 
             self.ivars().maximized.set(self.is_zoomed());
             let mut fullscreen = self.ivars().fullscreen.borrow_mut();
@@ -234,7 +236,7 @@ define_class!(
         /// Invoked when before exit fullscreen
         #[unsafe(method(windowWillExitFullScreen:))]
         fn window_will_exit_fullscreen(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowWillExitFullScreen:");
+            let _entered = debug_span!("windowWillExitFullScreen:").entered();
 
             self.ivars().in_fullscreen_transition.set(true);
         }
@@ -245,7 +247,7 @@ define_class!(
             _: Option<&AnyObject>,
             proposed_options: NSApplicationPresentationOptions,
         ) -> NSApplicationPresentationOptions {
-            trace_scope!("window:willUseFullScreenPresentationOptions:");
+            let _entered = debug_span!("window:willUseFullScreenPresentationOptions:").entered();
             // Generally, games will want to disable the menu bar and the dock. Ideally,
             // this would be configurable by the user. Unfortunately because of our
             // `CGShieldingWindowLevel() + 1` hack (see `set_fullscreen`), our window is
@@ -268,7 +270,7 @@ define_class!(
         /// Invoked when entered fullscreen
         #[unsafe(method(windowDidEnterFullScreen:))]
         fn window_did_enter_fullscreen(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidEnterFullScreen:");
+            let _entered = debug_span!("windowDidEnterFullScreen:").entered();
             self.ivars().initial_fullscreen.set(false);
             self.ivars().in_fullscreen_transition.set(false);
             if let Some(target_fullscreen) = self.ivars().target_fullscreen.take() {
@@ -279,7 +281,7 @@ define_class!(
         /// Invoked when exited fullscreen
         #[unsafe(method(windowDidExitFullScreen:))]
         fn window_did_exit_fullscreen(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidExitFullScreen:");
+            let _entered = debug_span!("windowDidExitFullScreen:").entered();
 
             self.restore_state_from_fullscreen();
             self.ivars().in_fullscreen_transition.set(false);
@@ -306,7 +308,7 @@ define_class!(
         /// work you may have done to prepare to enter full-screen mode.
         #[unsafe(method(windowDidFailToEnterFullScreen:))]
         fn window_did_fail_to_enter_fullscreen(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidFailToEnterFullScreen:");
+            let _entered = debug_span!("windowDidFailToEnterFullScreen:").entered();
             self.ivars().in_fullscreen_transition.set(false);
             self.ivars().target_fullscreen.replace(None);
             if self.ivars().initial_fullscreen.get() {
@@ -325,14 +327,28 @@ define_class!(
         // Invoked when the occlusion state of the window changes
         #[unsafe(method(windowDidChangeOcclusionState:))]
         fn window_did_change_occlusion_state(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidChangeOcclusionState:");
+            let _entered = debug_span!("windowDidChangeOcclusionState:").entered();
             let visible = self.window().occlusionState().contains(NSWindowOcclusionState::Visible);
             self.queue_event(WindowEvent::Occluded(!visible));
+
+            // We do this here rather than in `window:willUseFullScreenPresentationOptions`
+            // because doing it there leaves the menu bar interactable despite being hidden.
+            // Moving it here produces the most consistent results.
+            if self.is_borderless_game()
+                && matches!(*self.ivars().fullscreen.borrow(), Some(Fullscreen::Borderless(_)))
+            {
+                let mtm = MainThreadMarker::from(self);
+                let app = NSApplication::sharedApplication(mtm);
+                app.setPresentationOptions(
+                    NSApplicationPresentationOptions::HideDock
+                        | NSApplicationPresentationOptions::HideMenuBar,
+                );
+            }
         }
 
         #[unsafe(method(windowDidChangeScreen:))]
         fn window_did_change_screen(&self, _: Option<&AnyObject>) {
-            trace_scope!("windowDidChangeScreen:");
+            let _entered = debug_span!("windowDidChangeScreen:").entered();
             let is_simple_fullscreen = self.ivars().is_simple_fullscreen.get();
             if is_simple_fullscreen {
                 if let Some(screen) = self.window().screen() {
@@ -346,22 +362,26 @@ define_class!(
         /// Invoked when the dragged image enters destination bounds or frame
         #[unsafe(method(draggingEntered:))]
         fn dragging_entered(&self, sender: &ProtocolObject<dyn NSDraggingInfo>) -> bool {
-            trace_scope!("draggingEntered:");
+            let _entered = debug_span!("draggingEntered:").entered();
 
             use std::path::PathBuf;
 
-            let pb = unsafe { sender.draggingPasteboard() };
-            let filenames = pb
-                .propertyListForType(unsafe { NSFilenamesPboardType })
-                .unwrap()
+            let pb = sender.draggingPasteboard();
+
+            #[allow(deprecated)]
+            let property_list = match pb.propertyListForType(unsafe { NSFilenamesPboardType }) {
+                Some(property_list) => property_list,
+                None => return false.into(),
+            };
+
+            let paths = property_list
                 .downcast::<NSArray>()
-                .unwrap();
-            let paths = filenames
+                .unwrap()
                 .into_iter()
                 .map(|file| PathBuf::from(file.downcast::<NSString>().unwrap().to_string()))
                 .collect();
 
-            let dl = unsafe { sender.draggingLocation() };
+            let dl = sender.draggingLocation();
             let dl = self.view().convertPoint_fromView(dl, None);
             let position =
                 LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
@@ -373,7 +393,7 @@ define_class!(
 
         #[unsafe(method(wantsPeriodicDraggingUpdates))]
         fn wants_periodic_dragging_updates(&self) -> bool {
-            trace_scope!("wantsPeriodicDraggingUpdates:");
+            let _entered = debug_span!("wantsPeriodicDraggingUpdates:").entered();
             true
         }
 
@@ -381,9 +401,9 @@ define_class!(
         /// modification of the dragging operation or mouse-pointer position.
         #[unsafe(method(draggingUpdated:))]
         fn dragging_updated(&self, sender: &ProtocolObject<dyn NSDraggingInfo>) -> bool {
-            trace_scope!("draggingUpdated:");
+            let _entered = debug_span!("draggingUpdated:").entered();
 
-            let dl = unsafe { sender.draggingLocation() };
+            let dl = sender.draggingLocation();
             let dl = self.view().convertPoint_fromView(dl, None);
             let position =
                 LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
@@ -396,29 +416,33 @@ define_class!(
         /// Invoked when the image is released
         #[unsafe(method(prepareForDragOperation:))]
         fn prepare_for_drag_operation(&self, _sender: &NSObject) -> bool {
-            trace_scope!("prepareForDragOperation:");
+            let _entered = debug_span!("prepareForDragOperation:").entered();
             true
         }
 
         /// Invoked after the released image has been removed from the screen
         #[unsafe(method(performDragOperation:))]
         fn perform_drag_operation(&self, sender: &ProtocolObject<dyn NSDraggingInfo>) -> bool {
-            trace_scope!("performDragOperation:");
+            let _entered = debug_span!("performDragOperation:").entered();
 
             use std::path::PathBuf;
 
-            let pb = unsafe { sender.draggingPasteboard() };
-            let filenames = pb
-                .propertyListForType(unsafe { NSFilenamesPboardType })
-                .unwrap()
+            let pb = sender.draggingPasteboard();
+
+            #[allow(deprecated)]
+            let property_list = match pb.propertyListForType(unsafe { NSFilenamesPboardType }) {
+                Some(property_list) => property_list,
+                None => return false.into(),
+            };
+
+            let paths = property_list
                 .downcast::<NSArray>()
-                .unwrap();
-            let paths = filenames
+                .unwrap()
                 .into_iter()
                 .map(|file| PathBuf::from(file.downcast::<NSString>().unwrap().to_string()))
                 .collect();
 
-            let dl = unsafe { sender.draggingLocation() };
+            let dl = sender.draggingLocation();
             let dl = self.view().convertPoint_fromView(dl, None);
             let position =
                 LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
@@ -431,16 +455,16 @@ define_class!(
         /// Invoked when the dragging operation is complete
         #[unsafe(method(concludeDragOperation:))]
         fn conclude_drag_operation(&self, _sender: Option<&NSObject>) {
-            trace_scope!("concludeDragOperation:");
+            let _entered = debug_span!("concludeDragOperation:").entered();
         }
 
         /// Invoked when the dragging operation is cancelled
         #[unsafe(method(draggingExited:))]
         fn dragging_exited(&self, sender: Option<&ProtocolObject<dyn NSDraggingInfo>>) {
-            trace_scope!("draggingExited:");
+            let _entered = debug_span!("draggingExited:").entered();
 
             let position = sender.map(|sender| {
-                let dl = unsafe { sender.draggingLocation() };
+                let dl = sender.draggingLocation();
                 let dl = self.view().convertPoint_fromView(dl, None);
                 LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor())
             });
@@ -459,7 +483,7 @@ define_class!(
             change: Option<&NSDictionary<NSKeyValueChangeKey, AnyObject>>,
             _context: *mut c_void,
         ) {
-            trace_scope!("observeValueForKeyPath:ofObject:change:context:");
+            let _entered = debug_span!("observeValueForKeyPath:ofObject:change:context:").entered();
             // NOTE: We don't _really_ need to check the key path, as there should only be one, but
             // in the future we might want to observe other key paths.
             if key_path == Some(ns_string!("effectiveAppearance")) {
@@ -477,12 +501,12 @@ define_class!(
                 let old = old.downcast::<NSAppearance>().unwrap();
                 let new = new.downcast::<NSAppearance>().unwrap();
 
-                trace!(old = %unsafe { old.name() }, new = %unsafe { new.name() }, "effectiveAppearance changed");
+                trace!(old = %old.name(), new = %new.name(), "effectiveAppearance changed");
 
                 // Ignore the change if the window's theme is customized by the user (since in that
                 // case the `effectiveAppearance` is only emitted upon said customization, and then
                 // it's triggered directly by a user action, and we don't want to emit the event).
-                if unsafe { self.window().appearance() }.is_some() {
+                if self.window().appearance().is_some() {
                     return;
                 }
 
@@ -505,9 +529,7 @@ define_class!(
 
 impl Drop for WindowDelegate {
     fn drop(&mut self) {
-        unsafe {
-            self.window().removeObserver_forKeyPath(self, ns_string!("effectiveAppearance"));
-        }
+        unsafe { self.window().removeObserver_forKeyPath(self, ns_string!("effectiveAppearance")) };
     }
 }
 
@@ -666,12 +688,10 @@ fn new_window(
             window.setMovableByWindowBackground(true);
         }
         if macos_attrs.unified_titlebar {
-            unsafe {
-                // The toolbar style is ignored if there is no toolbar, so it is
-                // necessary to add one.
-                window.setToolbar(Some(&NSToolbar::new(mtm)));
-                window.setToolbarStyle(NSWindowToolbarStyle::Unified);
-            }
+            // The toolbar style is ignored if there is no toolbar, so it is
+            // necessary to add one.
+            window.setToolbar(Some(&NSToolbar::new(mtm)));
+            window.setToolbarStyle(NSWindowToolbarStyle::Unified);
         }
 
         if !attrs.enabled_buttons.contains(WindowButtons::MAXIMIZE) {
@@ -720,7 +740,7 @@ fn new_window(
         view.setPostsFrameChangedNotifications(true);
         // `setPostsFrameChangedNotifications` posts the notification immediately, so register the
         // observer _after_, again so that the event isn't triggered initially.
-        let notification_center = unsafe { NSNotificationCenter::defaultCenter() };
+        let notification_center = NSNotificationCenter::defaultCenter();
         unsafe {
             notification_center.addObserver_selector_name_object(
                 &view,
@@ -733,10 +753,11 @@ fn new_window(
         if attrs.transparent {
             window.setOpaque(false);
             // See `set_transparent` for details on why we do this.
-            window.setBackgroundColor(unsafe { Some(&NSColor::clearColor()) });
+            window.setBackgroundColor(Some(&NSColor::clearColor()));
         }
 
         // register for drag and drop operations.
+        #[allow(deprecated)]
         window.registerForDraggedTypes(&NSArray::from_slice(&[unsafe { NSFilenamesPboardType }]));
 
         Some(window)
@@ -790,7 +811,7 @@ impl WindowDelegate {
         let scale_factor = window.backingScaleFactor() as _;
 
         if let Some(appearance) = theme_to_appearance(attrs.preferred_theme) {
-            unsafe { window.setAppearance(Some(&appearance)) };
+            window.setAppearance(Some(&appearance));
         }
 
         let delegate = mtm.alloc().set_ivars(State {
@@ -891,10 +912,7 @@ impl WindowDelegate {
     fn handle_scale_factor_changed(&self, scale_factor: CGFloat) {
         let window = self.window();
 
-        let content_size = window.contentRectForFrameRect(window.frame()).size;
-        let content_size = LogicalSize::new(content_size.width, content_size.height);
-
-        let suggested_size = content_size.to_physical(scale_factor);
+        let suggested_size = self.view().surface_size();
         let new_surface_size = Arc::new(Mutex::new(suggested_size));
         self.queue_event(WindowEvent::ScaleFactorChanged {
             scale_factor,
@@ -934,10 +952,6 @@ impl WindowDelegate {
         self.window().setTitle(&NSString::from_str(title))
     }
 
-    pub fn is_transparent(&self) -> bool {
-        unsafe { !self.window().isOpaque() }
-    }
-
     pub fn set_transparent(&self, transparent: bool) {
         // This is just a hint for Quartz, it doesn't actually speculate with window alpha.
         // Providing a wrong value here could result in visual artifacts, when the window is
@@ -949,26 +963,17 @@ impl WindowDelegate {
         // transparent, as in that case, the transparent contents will just be drawn on top of
         // the background color. As such, to allow the window to be transparent, we must also set
         // the background color to one with an empty alpha channel.
-        let color = if transparent {
-            unsafe { NSColor::clearColor() }
-        } else {
-            unsafe { NSColor::windowBackgroundColor() }
-        };
+        let color =
+            if transparent { NSColor::clearColor() } else { NSColor::windowBackgroundColor() };
 
         self.window().setBackgroundColor(Some(&color));
     }
 
-    pub fn is_blurred(&self) -> bool {
-        // What API would we use to get this? `CGSGetWindowBackgroundBlurRadius` doesn't exist.
-        warn!("getting the background blur of the window is not supported on macOS");
-        false
-    }
-
     pub fn set_blur(&self, blur: bool) {
         // NOTE: in general we want to specify the blur radius, but the choice of 80
         // should be a reasonable default.
         let radius = if blur { 80 } else { 0 };
-        let window_number = unsafe { self.window().windowNumber() };
+        let window_number = self.window().windowNumber();
         unsafe {
             ffi::CGSSetWindowBackgroundBlurRadius(
                 ffi::CGSMainConnectionID(),
@@ -1027,14 +1032,12 @@ impl WindowDelegate {
             NSPoint::new(position.x, position.y),
             self.window().frame().size,
         ));
-        unsafe { self.window().setFrameOrigin(point) };
+        self.window().setFrameOrigin(point);
     }
 
     #[inline]
     pub fn surface_size(&self) -> PhysicalSize<u32> {
-        let content_rect = self.window().contentRectForFrameRect(self.window().frame());
-        let logical = LogicalSize::new(content_rect.size.width, content_rect.size.height);
-        logical.to_physical(self.scale_factor())
+        self.view().surface_size()
     }
 
     #[inline]
@@ -1049,17 +1052,15 @@ impl WindowDelegate {
         let insets = if self.view().respondsToSelector(sel!(safeAreaInsets)) {
             // Includes NSWindowStyleMask::FullSizeContentView by default, and the notch because
             // we've set it up with `additionalSafeAreaInsets`.
-            unsafe { self.view().safeAreaInsets() }
+            self.view().safeAreaInsets()
         } else {
             // If `safeAreaInsets` is not available, we'll have to do the calculation ourselves.
 
-            let window_rect = unsafe {
-                self.window().convertRectFromScreen(
-                    self.window().contentRectForFrameRect(self.window().frame()),
-                )
-            };
+            let window_rect = self.window().convertRectFromScreen(
+                self.window().contentRectForFrameRect(self.window().frame()),
+            );
             // This includes NSWindowStyleMask::FullSizeContentView.
-            let layout_rect = unsafe { self.window().contentLayoutRect() };
+            let layout_rect = self.window().contentLayoutRect();
 
             // Calculate the insets from window coordinates in AppKit's coordinate system.
             NSEdgeInsets {
@@ -1083,21 +1084,13 @@ impl WindowDelegate {
         None
     }
 
-    pub fn min_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        let size = unsafe { self.window().contentMinSize() };
-        if size == NSSize::ZERO {
-            return None;
-        }
-        Some(LogicalSize::new(size.width, size.height).to_physical(self.scale_factor()))
-    }
-
     pub fn set_min_surface_size(&self, dimensions: Option<Size>) {
         let dimensions =
             dimensions.unwrap_or(Size::Logical(LogicalSize { width: 0.0, height: 0.0 }));
         let min_size = dimensions.to_logical::<CGFloat>(self.scale_factor());
 
         let min_size = NSSize::new(min_size.width, min_size.height);
-        unsafe { self.window().setContentMinSize(min_size) };
+        self.window().setContentMinSize(min_size);
 
         // If necessary, resize the window to match constraint
         let mut current_size = self.window().contentRectForFrameRect(self.window().frame()).size;
@@ -1110,15 +1103,6 @@ impl WindowDelegate {
         self.window().setContentSize(current_size);
     }
 
-    pub fn max_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        let size = unsafe { self.window().contentMaxSize() };
-        // AppKit sets the max size to f32::MAX by default.
-        if size == NSSize::new(f32::MAX as _, f32::MAX as _) {
-            return None;
-        }
-        Some(LogicalSize::new(size.width, size.height).to_physical(self.scale_factor()))
-    }
-
     pub fn set_max_surface_size(&self, dimensions: Option<Size>) {
         let dimensions = dimensions.unwrap_or(Size::Logical(LogicalSize {
             width: f32::MAX as f64,
@@ -1128,7 +1112,7 @@ impl WindowDelegate {
         let max_size = dimensions.to_logical::<CGFloat>(scale_factor);
 
         let max_size = NSSize::new(max_size.width, max_size.height);
-        unsafe { self.window().setContentMaxSize(max_size) };
+        self.window().setContentMaxSize(max_size);
 
         // If necessary, resize the window to match constraint
         let mut current_size = self.window().contentRectForFrameRect(self.window().frame()).size;
@@ -1240,11 +1224,6 @@ impl WindowDelegate {
         buttons
     }
 
-    pub fn cursor(&self) -> Cursor {
-        warn!("getting the cursor is unimplemented on macOS");
-        Cursor::default()
-    }
-
     pub fn set_cursor(&self, cursor: Cursor) {
         let view = self.view();
 
@@ -1273,12 +1252,12 @@ impl WindowDelegate {
             CursorGrabMode::Locked => false,
             CursorGrabMode::None => true,
             CursorGrabMode::Confined => {
-                return Err(NotSupportedError::new("confined cursor is not supported").into())
+                return Err(NotSupportedError::new("confined cursor is not supported").into());
             },
         };
 
         // TODO: Do this for real https://stackoverflow.com/a/40922095/5435443
-        cgerr(unsafe { CGAssociateMouseAndMouseCursorPosition(associate_mouse_cursor) })?;
+        cgerr(CGAssociateMouseAndMouseCursorPosition(associate_mouse_cursor))?;
 
         Ok(())
     }
@@ -1306,8 +1285,8 @@ impl WindowDelegate {
             x: window_position.x + cursor_position.x,
             y: window_position.y + cursor_position.y,
         };
-        cgerr(unsafe { CGWarpMouseCursorPosition(point) })?;
-        cgerr(unsafe { CGAssociateMouseAndMouseCursorPosition(true) })?;
+        cgerr(CGWarpMouseCursorPosition(point))?;
+        cgerr(CGAssociateMouseAndMouseCursorPosition(true))?;
 
         Ok(())
     }
@@ -1388,7 +1367,7 @@ impl WindowDelegate {
         if minimized {
             self.window().miniaturize(Some(self));
         } else {
-            unsafe { self.window().deminiaturize(Some(self)) };
+            self.window().deminiaturize(Some(self));
         }
     }
 
@@ -1482,7 +1461,7 @@ impl WindowDelegate {
 
             let old_screen = self.window().screen().unwrap();
             if old_screen != new_screen {
-                unsafe { self.window().setFrameOrigin(new_screen.frame().origin) };
+                self.window().setFrameOrigin(new_screen.frame().origin);
             }
         }
 
@@ -1507,25 +1486,23 @@ impl WindowDelegate {
                 self.ivars().save_presentation_opts.replace(Some(app.presentationOptions()));
             }
 
-            unsafe {
-                // Fade to black (and wait for the fade to complete) to hide the
-                // flicker from capturing the display and switching display mode
-                if cgerr(CGAcquireDisplayFadeReservation(5.0, &mut fade_token)).is_ok() {
-                    CGDisplayFade(
-                        fade_token,
-                        0.3,
-                        kCGDisplayBlendNormal,
-                        kCGDisplayBlendSolidColor,
-                        0.0,
-                        0.0,
-                        0.0,
-                        true,
-                    );
-                }
-
-                cgerr(CGDisplayCapture(display_id)).unwrap();
+            // Fade to black (and wait for the fade to complete) to hide the
+            // flicker from capturing the display and switching display mode
+            if cgerr(unsafe { CGAcquireDisplayFadeReservation(5.0, &mut fade_token) }).is_ok() {
+                CGDisplayFade(
+                    fade_token,
+                    0.3,
+                    kCGDisplayBlendNormal,
+                    kCGDisplayBlendSolidColor,
+                    0.0,
+                    0.0,
+                    0.0,
+                    true,
+                );
             }
 
+            cgerr(CGDisplayCapture(display_id)).unwrap();
+
             let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
             let video_mode =
                 match monitor.video_mode_handles().find(|mode| &mode.mode == video_mode) {
@@ -1533,25 +1510,25 @@ impl WindowDelegate {
                     None => return,
                 };
 
-            unsafe {
-                cgerr(CGDisplaySetDisplayMode(display_id, Some(&video_mode.native_mode.0), None))
-                    .expect("failed to set video mode");
+            cgerr(unsafe {
+                CGDisplaySetDisplayMode(display_id, Some(&video_mode.native_mode.0), None)
+            })
+            .expect("failed to set video mode");
 
-                // After the display has been configured, fade back in
-                // asynchronously
-                if fade_token != kCGDisplayFadeReservationInvalidToken {
-                    CGDisplayFade(
-                        fade_token,
-                        0.6,
-                        kCGDisplayBlendSolidColor,
-                        kCGDisplayBlendNormal,
-                        0.0,
-                        0.0,
-                        0.0,
-                        false,
-                    );
-                    CGReleaseDisplayFadeReservation(fade_token);
-                }
+            // After the display has been configured, fade back in
+            // asynchronously
+            if fade_token != kCGDisplayFadeReservationInvalidToken {
+                CGDisplayFade(
+                    fade_token,
+                    0.6,
+                    kCGDisplayBlendSolidColor,
+                    kCGDisplayBlendNormal,
+                    0.0,
+                    0.0,
+                    0.0,
+                    false,
+                );
+                CGReleaseDisplayFadeReservation(fade_token);
             }
         }
 
@@ -1566,7 +1543,7 @@ impl WindowDelegate {
         }
 
         match (old_fullscreen, fullscreen) {
-            (None, Some(fullscreen)) => {
+            (None, Some(_)) => {
                 // `toggleFullScreen` doesn't work if the `StyleMask` is none, so we
                 // set a normal style temporarily. The previous state will be
                 // restored in `WindowDelegate::window_did_exit_fullscreen`.
@@ -1577,16 +1554,6 @@ impl WindowDelegate {
                     self.ivars().saved_style.set(Some(curr_mask));
                 }
 
-                // In borderless games, we want to disable the dock and menu bar
-                // by setting the presentation options. We do this here rather than in
-                // `window:willUseFullScreenPresentationOptions` because for some reason
-                // the menu bar remains interactable despite being hidden.
-                if self.is_borderless_game() && matches!(fullscreen, Fullscreen::Borderless(_)) {
-                    let presentation_options = NSApplicationPresentationOptions::HideDock
-                        | NSApplicationPresentationOptions::HideMenuBar;
-                    app.setPresentationOptions(presentation_options);
-                }
-
                 toggle_fullscreen(self.window());
             },
             (Some(Fullscreen::Borderless(_)), None) => {
@@ -1614,7 +1581,7 @@ impl WindowDelegate {
                     | NSApplicationPresentationOptions::HideMenuBar;
                 app.setPresentationOptions(presentation_options);
 
-                let window_level = unsafe { CGShieldingWindowLevel() } as NSWindowLevel + 1;
+                let window_level = CGShieldingWindowLevel() as NSWindowLevel + 1;
                 self.window().setLevel(window_level);
             },
             (Some(Fullscreen::Exclusive(monitor, _)), Some(Fullscreen::Borderless(_))) => {
@@ -1675,20 +1642,6 @@ impl WindowDelegate {
         self.ivars().decorations.get()
     }
 
-    pub fn window_level(&self) -> WindowLevel {
-        let level = unsafe { self.window().level() };
-        if level == kCGFloatingWindowLevel as NSWindowLevel {
-            WindowLevel::AlwaysOnTop
-        } else if level == (kCGNormalWindowLevel - 1) as NSWindowLevel {
-            WindowLevel::AlwaysOnBottom
-        } else if level == kCGNormalWindowLevel as NSWindowLevel {
-            WindowLevel::Normal
-        } else {
-            warn!(?level, "cannot determine window level, it must've been set outside of Winit");
-            WindowLevel::default()
-        }
-    }
-
     #[inline]
     pub fn set_window_level(&self, level: WindowLevel) {
         // Note: There are two different things at play here:
@@ -1708,11 +1661,6 @@ impl WindowDelegate {
         self.window().setLevel(level);
     }
 
-    #[inline]
-    pub fn window_icon(&self) -> Option<Icon> {
-        None
-    }
-
     #[inline]
     pub fn set_window_icon(&self, _icon: Option<Icon>) {
         // macOS doesn't have window icons. Though, there is
@@ -1733,7 +1681,7 @@ impl WindowDelegate {
                 if current_caps.is_some() {
                     return Err(ImeRequestError::AlreadyEnabled);
                 }
-                self.view().set_ime_allowed(Some(capabilities));
+                self.view().enable_ime(capabilities);
                 request_data
             },
             ImeRequest::Update(request_data) => {
@@ -1743,7 +1691,7 @@ impl WindowDelegate {
                 request_data
             },
             ImeRequest::Disable => {
-                self.view().set_ime_allowed(None);
+                self.view().disable_ime();
                 return Ok(());
             },
         };
@@ -1848,9 +1796,8 @@ impl WindowDelegate {
     }
 
     pub fn theme(&self) -> Option<Theme> {
-        unsafe { self.window().appearance() }
-            .map(|appearance| appearance_to_theme(&appearance))
-            .or_else(|| {
+        self.window().appearance().map(|appearance| appearance_to_theme(&appearance)).or_else(
+            || {
                 let mtm = MainThreadMarker::from(self);
                 let app = NSApplication::sharedApplication(mtm);
 
@@ -1859,22 +1806,12 @@ impl WindowDelegate {
                 } else {
                     Some(Theme::Light)
                 }
-            })
+            },
+        )
     }
 
     pub fn set_theme(&self, theme: Option<Theme>) {
-        unsafe { self.window().setAppearance(theme_to_appearance(theme).as_deref()) };
-    }
-
-    pub fn content_protected(&self) -> bool {
-        match unsafe { self.window().sharingType() } {
-            NSWindowSharingType::None => true,
-            NSWindowSharingType::ReadOnly => false,
-            sharing_type => {
-                warn!(?sharing_type, "unknown sharing type");
-                false
-            },
-        }
+        self.window().setAppearance(theme_to_appearance(theme).as_deref());
     }
 
     #[inline]
@@ -1898,10 +1835,8 @@ impl WindowDelegate {
 fn restore_and_release_display(monitor: &MonitorHandle) {
     let available_monitors = monitor::available_monitors();
     if available_monitors.contains(monitor) {
-        unsafe {
-            CGRestorePermanentDisplayConfiguration();
-            cgerr(CGDisplayRelease(monitor.native_id() as _)).unwrap();
-        };
+        CGRestorePermanentDisplayConfiguration();
+        cgerr(CGDisplayRelease(monitor.native_id() as _)).unwrap();
     } else {
         warn!(
             monitor = monitor.name().map(|name| name.to_string()),
@@ -1963,7 +1898,7 @@ impl WindowExtMacOS for WindowDelegate {
 
             // Configure the safe area rectangle, to ensure that we don't obscure the notch.
             if NSScreen::class().responds_to(sel!(safeAreaInsets)) {
-                unsafe { self.view().setAdditionalSafeAreaInsets(screen.safeAreaInsets()) };
+                self.view().setAdditionalSafeAreaInsets(screen.safeAreaInsets());
             }
 
             // Fullscreen windows can't be resized, minimized, or moved
@@ -1982,14 +1917,12 @@ impl WindowExtMacOS for WindowDelegate {
             }
 
             if NSScreen::class().responds_to(sel!(safeAreaInsets)) {
-                unsafe {
-                    self.view().setAdditionalSafeAreaInsets(NSEdgeInsets {
-                        top: 0.0,
-                        left: 0.0,
-                        bottom: 0.0,
-                        right: 0.0,
-                    });
-                }
+                self.view().setAdditionalSafeAreaInsets(NSEdgeInsets {
+                    top: 0.0,
+                    left: 0.0,
+                    bottom: 0.0,
+                    right: 0.0,
+                });
             }
 
             self.window().setFrame_display(frame, true);
@@ -2027,7 +1960,7 @@ impl WindowExtMacOS for WindowDelegate {
 
     #[inline]
     fn select_previous_tab(&self) {
-        unsafe { self.window().selectPreviousTab(None) }
+        self.window().selectPreviousTab(None)
     }
 
     #[inline]
@@ -2037,7 +1970,7 @@ impl WindowExtMacOS for WindowDelegate {
             return;
         }
         if let Some(group) = self.window().tabGroup() {
-            if let Some(windows) = unsafe { self.window().tabbedWindows() } {
+            if let Some(windows) = self.window().tabbedWindows() {
                 if index < windows.len() {
                     group.setSelectedWindow(Some(&windows.objectAtIndex(index)));
                 }
@@ -2047,7 +1980,7 @@ impl WindowExtMacOS for WindowDelegate {
 
     #[inline]
     fn num_tabs(&self) -> usize {
-        unsafe { self.window().tabbedWindows() }.map(|windows| windows.len()).unwrap_or(1)
+        self.window().tabbedWindows().map(|windows| windows.len()).unwrap_or(1)
     }
 
     fn is_document_edited(&self) -> bool {
@@ -2080,26 +2013,20 @@ impl WindowExtMacOS for WindowDelegate {
         if unified_titlebar {
             let mtm = MainThreadMarker::from(self);
 
-            unsafe {
-                // The toolbar style is ignored if there is no toolbar, so it is
-                // necessary to add one.
-                window.setToolbar(Some(&NSToolbar::new(mtm)));
-                window.setToolbarStyle(NSWindowToolbarStyle::Unified);
-            }
+            // The toolbar style is ignored if there is no toolbar, so it is
+            // necessary to add one.
+            window.setToolbar(Some(&NSToolbar::new(mtm)));
+            window.setToolbarStyle(NSWindowToolbarStyle::Unified);
         } else {
-            unsafe {
-                window.setToolbar(None);
-                window.setToolbarStyle(NSWindowToolbarStyle::Automatic);
-            }
+            window.setToolbar(None);
+            window.setToolbarStyle(NSWindowToolbarStyle::Automatic);
         }
     }
 
     fn unified_titlebar(&self) -> bool {
         let window = self.window();
 
-        unsafe {
-            window.toolbar().is_some() && window.toolbarStyle() == NSWindowToolbarStyle::Unified
-        }
+        window.toolbar().is_some() && window.toolbarStyle() == NSWindowToolbarStyle::Unified
     }
 }
 
@@ -2117,11 +2044,7 @@ pub fn appearance_to_theme(appearance: &NSAppearance) -> Theme {
         dark_appearance_name(),
     ]));
     if let Some(best_match) = best_match {
-        if *best_match == *dark_appearance_name() {
-            Theme::Dark
-        } else {
-            Theme::Light
-        }
+        if *best_match == *dark_appearance_name() { Theme::Dark } else { Theme::Light }
     } else {
         warn!(?appearance, "failed to determine the theme of the appearance");
         // Default to light in this case

winit-common/Cargo.toml

@@ -18,7 +18,10 @@ x11 = ["xkbcommon-dl?/x11", "dep:x11-dl"]
 xkb = ["dep:xkbcommon-dl", "dep:smol_str"]
 
 # CoreFoundation
-core-foundation = ["dep:objc2", "dep:objc2-core-foundation"]
+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 }
@@ -30,13 +33,23 @@ memmap2 = { workspace = true, optional = true }
 x11-dl = { workspace = true, optional = true }
 xkbcommon-dl = { workspace = true, optional = true }
 
-# CoreFoundation
+# 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/src/core_foundation/event_loop_proxy.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 
 use objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    kCFRunLoopCommonModes, CFIndex, CFRetained, CFRunLoop, CFRunLoopSource, CFRunLoopSourceContext,
+    CFIndex, CFRetained, CFRunLoop, CFRunLoopSource, CFRunLoopSourceContext, kCFRunLoopCommonModes,
 };
 use winit_core::event_loop::EventLoopProxyProvider;
 

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

@@ -1,3 +1,14 @@
-mod event_loop_proxy;
+//! 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>
 
-pub use event_loop_proxy::*;
+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

@@ -79,6 +79,10 @@ impl EventHandler {
                         // 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
@@ -114,7 +118,7 @@ impl EventHandler {
 
     pub fn handle(&self, callback: impl FnOnce(&mut (dyn ApplicationHandler + '_))) {
         match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(ref mut user_app)) => {
+            Ok(Some(user_app)) => {
                 // It is important that we keep the reference borrowed here,
                 // so that `in_use` can properly detect that the handler is
                 // still in use.

winit-common/src/foundation/mod.rs

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

winit-common/src/foundation/notification_center.rs

@@ -1,4 +1,3 @@
-// NOTE: This is symlinked to be contained in both the AppKit and UIKit implementations.
 use std::ptr::NonNull;
 
 use block2::RcBlock;
@@ -12,7 +11,7 @@ use objc2_foundation::{
 ///
 /// This is used in Winit as an alternative to declaring an application delegate, as we want to
 /// give the user full control over those.
-pub(crate) fn create_observer(
+pub fn create_observer(
     center: &NSNotificationCenter,
     name: &NSNotificationName,
     handler: impl Fn(&NSNotification) + 'static,

winit-common/src/lib.rs

@@ -4,5 +4,7 @@
 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

@@ -19,7 +19,7 @@ use {memmap2::MmapOptions, std::os::unix::io::OwnedFd};
 
 #[cfg(feature = "x11")]
 use super::XKBXH;
-use super::{XkbContext, XKBH};
+use super::{XKBH, XkbContext};
 
 /// Map the raw X11-style keycode to the `KeyCode` enum.
 ///
@@ -37,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
@@ -159,11 +160,11 @@ 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,
@@ -185,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,
@@ -210,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
@@ -222,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,
@@ -239,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,
@@ -262,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,
@@ -286,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)),
     })
 }
@@ -415,8 +423,10 @@ 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),
@@ -436,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),
@@ -447,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),
@@ -462,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,
     }
 }
@@ -1018,11 +1052,7 @@ impl XkbKeymap {
                 &mut keysyms,
             );
 
-            if count == 1 {
-                *keysyms
-            } else {
-                0
-            }
+            if count == 1 { *keysyms } else { 0 }
         }
     }
 
@@ -1066,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

@@ -3,15 +3,15 @@ use std::os::raw::c_char;
 #[cfg(feature = "wayland")]
 use std::os::unix::io::OwnedFd;
 use std::ptr::{self, NonNull};
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::LazyLock;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use smol_str::SmolStr;
 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(feature = "x11")]
 use {x11_dl::xlib_xcb::xcb_connection_t, xkbcommon_dl::x11::xkbcommon_x11_handle};
@@ -21,9 +21,9 @@ mod keymap;
 mod state;
 
 use compose::{ComposeStatus, XkbComposeState, XkbComposeTable};
+use keymap::XkbKeymap;
 #[cfg(feature = "x11")]
 pub use keymap::raw_keycode_to_physicalkey;
-use keymap::XkbKeymap;
 pub use keymap::{physicalkey_to_scancode, scancode_to_physicalkey};
 pub use state::XkbState;
 
@@ -310,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> {

winit-common/src/xkb/state.rs

@@ -10,10 +10,10 @@ use xkbcommon_dl::{
     self as xkb, xkb_keycode_t, xkb_keysym_t, xkb_layout_index_t, xkb_state, xkb_state_component,
 };
 
-use super::keymap::XkbKeymap;
 #[cfg(feature = "x11")]
 use super::XKBXH;
-use super::{make_string_with, XKBH};
+use super::keymap::XkbKeymap;
+use super::{XKBH, make_string_with};
 
 #[derive(Debug)]
 pub struct XkbState {

winit-core/src/cursor.rs

@@ -8,7 +8,7 @@ use std::time::Duration;
 #[doc(inline)]
 pub use cursor_icon::CursorIcon;
 
-use crate::as_any::{impl_dyn_casting, AsAny};
+use crate::as_any::AsAny;
 
 /// The maximum width and height for a cursor when using [`CustomCursorSource::from_rgba`].
 pub const MAX_CURSOR_SIZE: u16 = 2048;

winit-core/src/error.rs

@@ -35,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 }
     }
 }
 
@@ -78,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 }
     }
 }
 
@@ -149,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) }};
 }

winit-core/src/event.rs

@@ -1,4 +1,7 @@
 //! The event enums and assorted supporting types.
+use std::cell::LazyCell;
+use std::cmp::Ordering;
+use std::f64;
 use std::path::PathBuf;
 use std::sync::{Mutex, Weak};
 
@@ -7,13 +10,13 @@ use dpi::{PhysicalPosition, PhysicalSize};
 use serde::{Deserialize, Serialize};
 use smol_str::SmolStr;
 
+use crate::Instant;
 use crate::error::RequestError;
 use crate::event_loop::AsyncRequestSerial;
 use crate::keyboard::{self, ModifiersKeyState, ModifiersKeys, ModifiersState};
 #[cfg(doc)]
 use crate::window::Window;
 use crate::window::{ActivationToken, Theme};
-use crate::Instant;
 
 /// Describes the reason the event loop is resuming.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -153,6 +156,8 @@ pub enum WindowEvent {
     Ime(Ime),
 
     /// The pointer has moved on the window.
+    ///
+    /// Should be emitted regardless of window focus.
     PointerMoved {
         device_id: Option<DeviceId>,
 
@@ -181,6 +186,8 @@ pub enum WindowEvent {
     },
 
     /// The pointer has entered the window.
+    ///
+    /// Should be emitted regardless of window focus.
     PointerEntered {
         device_id: Option<DeviceId>,
 
@@ -206,6 +213,8 @@ pub enum WindowEvent {
     },
 
     /// The pointer has left the window.
+    ///
+    /// Should be emitted regardless of window focus.
     PointerLeft {
         device_id: Option<DeviceId>,
 
@@ -260,11 +269,25 @@ pub enum WindowEvent {
         button: ButtonSource,
     },
 
+    /// Multi-finger hold gesture on the touchpad or touchscreen without movement.
+    ///
+    /// The `phase` field indicates the lifecycle of the hold gesture:
+    /// - `Started`: One or more fingers are in contact with the touchpad/touchscreen.
+    /// - `Ended`: All fingers have been lifted from the touchpad/touchscreen.
+    /// - `Cancelled`: The hold gesture was interrupted, for example when another finger touches the
+    ///   touchpad (causing a new `Started` event with more fingers), or when movement begins and
+    ///   transitions to other gestures like pinch, pan, or rotation.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - Only available on **Wayland**.
+    HoldGesture { device_id: Option<DeviceId>, phase: TouchPhase },
+
     /// Two-finger pinch gesture, often used for magnification.
     ///
     /// ## Platform-specific
     ///
-    /// - Only available on **macOS** and **iOS**.
+    /// - Only available on **macOS**, **iOS**, and **Wayland**.
     /// - On iOS, not recognized by default. It must be enabled when needed.
     PinchGesture {
         device_id: Option<DeviceId>,
@@ -280,7 +303,7 @@ pub enum WindowEvent {
     ///
     /// ## Platform-specific
     ///
-    /// - Only available on **iOS**.
+    /// - Only available on **iOS** and **Wayland**.
     /// - On iOS, not recognized by default. It must be enabled when needed.
     PanGesture {
         device_id: Option<DeviceId>,
@@ -316,7 +339,7 @@ pub enum WindowEvent {
     ///
     /// ## Platform-specific
     ///
-    /// - Only available on **macOS** and **iOS**.
+    /// - Only available on **macOS**, **iOS**, and **Wayland**.
     /// - On iOS, not recognized by default. It must be enabled when needed.
     RotationGesture {
         device_id: Option<DeviceId>,
@@ -435,6 +458,7 @@ pub enum PointerKind {
     ///
     /// **macOS:** Unsupported.
     Touch(FingerId),
+    TabletTool(TabletToolKind),
     Unknown,
 }
 
@@ -485,6 +509,13 @@ pub enum PointerSource {
         ///   force will be 0.5 when a button is pressed or 0.0 otherwise.
         force: Option<Force>,
     },
+    TabletTool {
+        /// Describes as which tool kind the interaction happened.
+        kind: TabletToolKind,
+
+        /// Describes how the tool was held and used.
+        data: TabletToolData,
+    },
     Unknown,
 }
 
@@ -493,6 +524,7 @@ impl From<PointerSource> for PointerKind {
         match source {
             PointerSource::Mouse => Self::Mouse,
             PointerSource::Touch { finger_id, .. } => Self::Touch(finger_id),
+            PointerSource::TabletTool { kind, .. } => Self::TabletTool(kind),
             PointerSource::Unknown => Self::Unknown,
         }
     }
@@ -502,8 +534,21 @@ impl From<PointerSource> for PointerKind {
 ///
 /// **Wayland/X11:** [`Unknown`](Self::Unknown) device types are converted to known variants by the
 /// system.
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub enum ButtonSource {
+    /// ## Platform-specific
+    ///
+    /// ### macOS
+    ///
+    /// Users may expect holding [<kbd>CTRL</kbd>](ModifiersState::CONTROL) while
+    /// clicking [`MouseButton::Left`] to result in a "secondary" click, but the way these
+    /// clicks behave natively is slightly different from how a physical secondary
+    /// button press would, depending on the content under the cursor when clicked. If
+    /// applications want this behavior they should implement it themselves by interpreting
+    /// [`Left`](MouseButton::Left) clicks as secondary when
+    /// [<kbd>CTRL</kbd>](ModifiersState::CONTROL) is held and their internal logic deems it
+    /// appropriate for the content under the pointer.
+    /// See also https://github.com/rust-windowing/winit/issues/4469.
     Mouse(MouseButton),
     /// See [`PointerSource::Touch`] for more details.
     ///
@@ -514,25 +559,27 @@ pub enum ButtonSource {
         finger_id: FingerId,
         force: Option<Force>,
     },
+    TabletTool {
+        kind: TabletToolKind,
+        button: TabletToolButton,
+        data: TabletToolData,
+    },
+    /// A pointer button of unknown source.
+    ///
+    /// Codes are undefined and may not be reproducible across platforms or winit versions.
     Unknown(u16),
 }
 
 impl ButtonSource {
-    /// Convert any [`ButtonSource`] to an equivalent [`MouseButton`]. If a pointer type has no
+    /// Try to convert a [`ButtonSource`] to an equivalent [`MouseButton`]. If a pointer type has no
     /// special handling in an application, this method can be used to handle it like any generic
     /// mouse input.
-    pub fn mouse_button(self) -> MouseButton {
+    pub fn mouse_button(self) -> Option<MouseButton> {
         match self {
-            ButtonSource::Mouse(mouse) => mouse,
-            ButtonSource::Touch { .. } => MouseButton::Left,
-            ButtonSource::Unknown(button) => match button {
-                0 => MouseButton::Left,
-                1 => MouseButton::Middle,
-                2 => MouseButton::Right,
-                3 => MouseButton::Back,
-                4 => MouseButton::Forward,
-                _ => MouseButton::Other(button),
-            },
+            ButtonSource::Mouse(mouse) => Some(mouse),
+            ButtonSource::Touch { .. } => Some(MouseButton::Left),
+            ButtonSource::TabletTool { button, .. } => button.into(),
+            ButtonSource::Unknown(_) => None,
         }
     }
 }
@@ -745,7 +792,7 @@ pub struct KeyEvent {
     ///
     /// # Example
     ///
-    /// In games, you often want to ignore repated key events - this can be
+    /// In games, you often want to ignore repeated key events - this can be
     /// done by ignoring events where this property is set.
     ///
     /// ```no_run
@@ -770,13 +817,14 @@ pub struct KeyEvent {
     /// ```
     pub repeat: bool,
 
-    /// Similar to [`text`][Self::text], except that this is affected by <kbd>Ctrl</kbd>.
+    /// Similar to [`text`][Self::text], except that this is affected by <kbd>Ctrl</kbd> and may
+    /// produce ASCII control characters.
     ///
-    /// For example, pressing <kbd>Ctrl</kbd>+<kbd>a</kbd> produces `Some("\x01")`.
+    /// For example, pressing <kbd>Ctrl</kbd>+<kbd>space</kbd> produces `Some("\x00")`.
     ///
     /// ## Platform-specific
     ///
-    /// - **Android:** Unimplemented, this field is always the same value as `text`.
+    /// - **Android:** This field is always the same value as `text`.
     /// - **iOS:** Unimplemented, this field is always the same value as `text`.
     /// - **Web:** Unsupported, this field is always the same value as `text`.
     pub text_with_all_modifiers: Option<SmolStr>,
@@ -972,15 +1020,24 @@ pub enum Ime {
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum TouchPhase {
+    /// Initial touch contact or gesture start, for example when one or more fingers touch the
+    /// screen or touchpad.
     Started,
+    /// The touch contact point changed, for example without lifting the finger.
     Moved,
+    /// All touch contact points have been lifted from the touchscreen or touchpad.
+    ///
+    /// This event is important as it should clear any state or event in flight that was
+    /// generated by the preceding `Started` and `Moved` events.
     Ended,
+    /// The event was cancelled and should cancel any event in flight and clear state.
     Cancelled,
 }
 
 /// Describes the force of a touch event
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[doc(alias = "Pressure")]
 pub enum Force {
     /// On iOS, the force is calibrated so that the same number corresponds to
     /// roughly the same amount of pressure on the screen regardless of the
@@ -991,7 +1048,7 @@ pub enum Force {
         ///
         /// The force reported by Apple Pencil is measured along the axis of the
         /// pencil. If you want a force perpendicular to the device, you need to
-        /// calculate this value using the `altitude_angle` value.
+        /// calculate this value using the [`TabletToolAngle::altitude`] value.
         force: f64,
         /// The maximum possible force for a touch.
         ///
@@ -1012,9 +1069,17 @@ impl Force {
     /// Instead of normalizing the force, you should prefer to handle
     /// [`Force::Calibrated`] so that the amount of force the user has to apply is
     /// consistent across devices.
-    pub fn normalized(&self) -> f64 {
+    ///
+    /// Passing in a [`TabletToolAngle`], returns the perpendicular force.
+    pub fn normalized(&self, angle: Option<TabletToolAngle>) -> f64 {
         match self {
-            Force::Calibrated { force, max_possible_force } => force / max_possible_force,
+            Force::Calibrated { force, max_possible_force } => {
+                let force = match angle {
+                    Some(TabletToolAngle { altitude, .. }) => force / altitude.sin(),
+                    None => *force,
+                };
+                force / max_possible_force
+            },
             Force::Normalized(force) => *force,
         }
     }
@@ -1026,6 +1091,260 @@ pub type AxisId = u32;
 /// Identifier for a specific button on some device.
 pub type ButtonId = u32;
 
+/// Tablet of the tablet tool.
+#[derive(Default, Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+#[non_exhaustive]
+pub enum TabletToolKind {
+    #[default]
+    Pen,
+    Eraser,
+    Brush,
+    Pencil,
+    Airbrush,
+    Finger,
+    Mouse,
+    Lens,
+}
+
+#[derive(Default, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct TabletToolData {
+    /// The force applied to the tool against the surface.
+    ///
+    /// When the force information is not available, [`None`] is returned.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Has no mechanism to detect support, so this will always be [`Some`].
+    pub force: Option<Force>,
+    /// Represents normalized tangential pressure, also known as barrel pressure. In the range of
+    /// -1 to 1. 0 means no tangential pressure is applied. [`None`] means backend or device has no
+    /// support.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Has no mechanism to detect support, so this will always be [`Some`] with a value
+    /// of 0.
+    pub tangential_force: Option<f32>,
+    /// The clockwise rotation in degrees of a tool around its own major axis. E.g. twisting a pen
+    /// around its length. In the range of 0 to 359. [`None`] means backend or device has no
+    /// support.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Has no mechanism to detect support, so this will always be [`Some`] with a value
+    /// of 0.
+    pub twist: Option<u16>,
+    /// The plane angle in degrees. [`None`] means backend or device has no support.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Has no mechanism to detect support, so this will always be [`Some`] with default
+    /// values.
+    pub tilt: Option<TabletToolTilt>,
+    /// The angular position in radians. [`None`] means backend or device has no support.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Web:** Has no mechanism to detect device support, so this will always be [`Some`] with
+    /// default values unless browser support is lacking.
+    pub angle: Option<TabletToolAngle>,
+}
+
+impl TabletToolData {
+    /// Returns [`TabletToolTilt`] if present or calculates it from [`TabletToolAngle`].
+    pub fn tilt(self) -> Option<TabletToolTilt> {
+        if let Some(tilt) = self.tilt { Some(tilt) } else { self.angle.map(TabletToolAngle::tilt) }
+    }
+
+    /// Returns [`TabletToolAngle`] if present or calculates it from [`TabletToolTilt`].
+    pub fn angle(self) -> Option<TabletToolAngle> {
+        if let Some(angle) = self.angle {
+            Some(angle)
+        } else {
+            self.tilt.map(TabletToolTilt::angle)
+        }
+    }
+}
+
+/// The plane angle in degrees of a tool.
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct TabletToolTilt {
+    /// The plane angle in degrees between the surface Y-Z plane and the plane containing the tool
+    /// and the surface Y axis. Positive values are to the right. In the range of -90 to 90. 0
+    /// means the tool is perpendicular to the surface and is the default.
+    ///
+    /// ![Tilt X](https://raw.githubusercontent.com/rust-windowing/winit/master/winit/docs/res/tool_tilt_x.webp)
+    ///
+    /// <sub>
+    ///   For image attribution, see the
+    ///   <a href="https://github.com/rust-windowing/winit/blob/master/winit/docs/ATTRIBUTION.md">
+    ///     ATTRIBUTION.md
+    ///   </a>
+    ///   file.
+    /// </sub>
+    pub x: i8,
+    /// The plane angle in degrees between the surface X-Z plane and the plane containing the tool
+    /// and the surface X axis. Positive values are towards the user. In the range of -90 to
+    /// 90. 0 means the tool is perpendicular to the surface and is the default.
+    ///
+    /// ![Tilt Y](https://raw.githubusercontent.com/rust-windowing/winit/master/winit/docs/res/tool_tilt_y.webp)
+    ///
+    /// <sub>
+    ///   For image attribution, see the
+    ///   <a href="https://github.com/rust-windowing/winit/blob/master/winit/docs/ATTRIBUTION.md">
+    ///     ATTRIBUTION.md
+    ///   </a>
+    ///   file.
+    /// </sub>
+    pub y: i8,
+}
+
+impl TabletToolTilt {
+    pub fn angle(self) -> TabletToolAngle {
+        // See <https://www.w3.org/TR/2024/WD-pointerevents3-20240326/#converting-between-tiltx-tilty-and-altitudeangle-azimuthangle>.
+
+        use std::f64::consts::*;
+
+        const PI_0_5: f64 = FRAC_PI_2;
+        const PI_1_5: f64 = 3. * FRAC_PI_2;
+        const PI_2: f64 = 2. * PI;
+
+        let x = LazyCell::new(|| f64::from(self.x).to_radians());
+        let y = LazyCell::new(|| f64::from(self.y).to_radians());
+
+        let mut azimuth = 0.;
+
+        if self.x == 0 {
+            match self.y.cmp(&0) {
+                Ordering::Greater => azimuth = PI_0_5,
+                Ordering::Less => azimuth = PI_1_5,
+                Ordering::Equal => (),
+            }
+        } else if self.y == 0 {
+            if self.x < 0 {
+                azimuth = PI;
+            }
+        } else if self.x.abs() == 90 || self.y.abs() == 90 {
+            // not enough information to calculate azimuth
+            azimuth = 0.;
+        } else {
+            // Non-boundary case: neither tiltX nor tiltY is equal to 0 or +-90
+            azimuth = f64::atan2(y.tan(), x.tan());
+
+            if azimuth < 0. {
+                azimuth += PI_2;
+            }
+        }
+
+        let altitude;
+
+        if self.x.abs() == 90 || self.y.abs() == 90 {
+            altitude = 0.;
+        } else if self.x == 0 {
+            altitude = PI_0_5 - y.abs();
+        } else if self.y == 0 {
+            altitude = PI_0_5 - x.abs();
+        } else {
+            // Non-boundary case: neither tiltX nor tiltY is equal to 0 or +-90
+            altitude = f64::atan(1. / f64::sqrt(x.tan().powi(2) + y.tan().powi(2)));
+        }
+
+        TabletToolAngle { altitude, azimuth }
+    }
+}
+
+/// The angular position in radians of a tool.
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct TabletToolAngle {
+    /// The altitude angle in radians between the tools perpendicular position to the surface and
+    /// the surface X-Y plane. In the range of 0, parallel to the surface, to π/2, perpendicular to
+    /// the surface. π/2 means the tool is perpendicular to the surface and is the default.
+    ///
+    /// ![Altitude angle](https://raw.githubusercontent.com/rust-windowing/winit/master/docs/res/tool_altitude.webp)
+    ///
+    /// <sub>
+    ///   For image attribution, see the
+    ///   <a href="https://github.com/rust-windowing/winit/blob/master/docs/res/ATTRIBUTION.md">
+    ///     ATTRIBUTION.md
+    ///   </a>
+    ///   file.
+    /// </sub>
+    pub altitude: f64,
+    /// The azimuth angle in radiants representing the rotation between the major axis of the tool
+    /// and the surface X-Y plane. In the range of 0, 3 o'clock, progressively increasing clockwise
+    /// to 2π. 0 means the tool is at 3 o'clock or is perpendicular to the surface (`altitude` of
+    /// π/2) and is the default.
+    ///
+    /// ![Azimuth angle](https://raw.githubusercontent.com/rust-windowing/winit/master/docs/res/tool_azimuth.webp)
+    ///
+    /// <sub>
+    ///   For image attribution, see the
+    ///   <a href="https://github.com/rust-windowing/winit/blob/master/docs/res/ATTRIBUTION.md">
+    ///     ATTRIBUTION.md
+    ///   </a>
+    ///   file.
+    /// </sub>
+    pub azimuth: f64,
+}
+
+impl Default for TabletToolAngle {
+    fn default() -> Self {
+        Self { altitude: f64::consts::FRAC_2_PI, azimuth: 0. }
+    }
+}
+
+impl TabletToolAngle {
+    pub fn tilt(self) -> TabletToolTilt {
+        // See <https://www.w3.org/TR/2024/WD-pointerevents3-20240326/#converting-between-tiltx-tilty-and-altitudeangle-azimuthangle>.
+
+        use std::f64::consts::*;
+
+        const PI_0_5: f64 = FRAC_PI_2;
+        const PI_1_5: f64 = 3. * FRAC_PI_2;
+        const PI_2: f64 = 2. * PI;
+
+        let mut x = 0.;
+        let mut y = 0.;
+
+        if self.altitude == 0. {
+            if self.azimuth == 0. || self.azimuth == PI_2 {
+                x = FRAC_PI_2;
+            } else if self.azimuth == PI_0_5 {
+                y = FRAC_PI_2;
+            } else if self.azimuth == PI {
+                x = -FRAC_PI_2;
+            } else if self.azimuth == PI_1_5 {
+                y = -FRAC_PI_2;
+            } else if self.azimuth > 0. && self.azimuth < PI_0_5 {
+                x = FRAC_PI_2;
+                y = FRAC_PI_2;
+            } else if self.azimuth > PI_0_5 && self.azimuth < PI {
+                x = -FRAC_PI_2;
+                y = FRAC_PI_2;
+            } else if self.azimuth > PI && self.azimuth < PI_1_5 {
+                x = -FRAC_PI_2;
+                y = -FRAC_PI_2;
+            } else if self.azimuth > PI_1_5 && self.azimuth < PI_2 {
+                x = FRAC_PI_2;
+                y = -FRAC_PI_2;
+            }
+        }
+
+        if self.altitude != 0. {
+            let altitude = self.altitude.tan();
+
+            x = f64::atan(f64::cos(self.azimuth) / altitude);
+            y = f64::atan(f64::sin(self.azimuth) / altitude);
+        }
+
+        TabletToolTilt { x: x.to_degrees().round() as i8, y: y.to_degrees().round() as i8 }
+    }
+}
+
 /// Describes the input state of a key.
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -1041,23 +1360,138 @@ impl ElementState {
     }
 }
 
-/// Describes a button of a mouse controller.
+/// Identifies a button of a mouse controller.
 ///
 /// ## Platform-specific
 ///
-/// **macOS:** `Back` and `Forward` might not work with all hardware.
-/// **Orbital:** `Back` and `Forward` are unsupported due to orbital not supporting them.
+/// The first three buttons should be supported on all platforms.
+/// [`Self::Back`] and [`Self::Forward`] are supported on most platforms
+/// (when using a compatible mouse).
+///
+/// - **Android, iOS:** Currently not supported.
+/// - **Orbital:** Only left/right/middle buttons are supported at this time.
+/// - **Web, Windows:** Supports left/right/middle/back/forward buttons.
+/// - **Wayland:** Supports buttons 0..=15.
+/// - **macOS:** Supports all button variants.
+/// - **X11:** Technically supports further buttons than this (0..=250), these are emitted in
+///   `ButtonSource::Unknown`.
 #[derive(Debug, Hash, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[repr(u8)]
 pub enum MouseButton {
-    Left,
-    Right,
-    Middle,
-    Back,
-    Forward,
+    /// The primary (usually left) button
+    Left = 0,
+    /// The secondary (usually right) button
+    Right = 1,
+    /// The tertiary (usually middle) button
+    Middle = 2,
+    /// The first side button, frequently assigned a back function
+    Back = 3,
+    /// The second side button, frequently assigned a forward function
+    Forward = 4,
+    /// The sixth button
+    Button6 = 5,
+    /// The seventh button
+    Button7 = 6,
+    /// The eighth button
+    Button8 = 7,
+    /// The ninth button
+    Button9 = 8,
+    /// The tenth button
+    Button10 = 9,
+    /// The eleventh button
+    Button11 = 10,
+    /// The twelfth button
+    Button12 = 11,
+    /// The thirteenth button
+    Button13 = 12,
+    /// The fourteenth button
+    Button14 = 13,
+    /// The fifteenth button
+    Button15 = 14,
+    /// The sixteenth button
+    Button16 = 15,
+    Button17 = 16,
+    Button18 = 17,
+    Button19 = 18,
+    Button20 = 19,
+    Button21 = 20,
+    Button22 = 21,
+    Button23 = 22,
+    Button24 = 23,
+    Button25 = 24,
+    Button26 = 25,
+    Button27 = 26,
+    Button28 = 27,
+    Button29 = 28,
+    Button30 = 29,
+    Button31 = 30,
+    Button32 = 31,
+}
+
+impl MouseButton {
+    /// Construct from a `u8` if within the range `0..=31`
+    pub fn try_from_u8(b: u8) -> Option<MouseButton> {
+        Some(match b {
+            0 => MouseButton::Left,
+            1 => MouseButton::Right,
+            2 => MouseButton::Middle,
+            3 => MouseButton::Back,
+            4 => MouseButton::Forward,
+            5 => MouseButton::Button6,
+            6 => MouseButton::Button7,
+            7 => MouseButton::Button8,
+            8 => MouseButton::Button9,
+            9 => MouseButton::Button10,
+            10 => MouseButton::Button11,
+            11 => MouseButton::Button12,
+            12 => MouseButton::Button13,
+            13 => MouseButton::Button14,
+            14 => MouseButton::Button15,
+            15 => MouseButton::Button16,
+            16 => MouseButton::Button17,
+            17 => MouseButton::Button18,
+            18 => MouseButton::Button19,
+            19 => MouseButton::Button20,
+            20 => MouseButton::Button21,
+            21 => MouseButton::Button22,
+            22 => MouseButton::Button23,
+            23 => MouseButton::Button24,
+            24 => MouseButton::Button25,
+            25 => MouseButton::Button26,
+            26 => MouseButton::Button27,
+            27 => MouseButton::Button28,
+            28 => MouseButton::Button29,
+            29 => MouseButton::Button30,
+            30 => MouseButton::Button31,
+            31 => MouseButton::Button32,
+            _ => return None,
+        })
+    }
+}
+
+/// Describes a button of a tool, e.g. a pen.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub enum TabletToolButton {
+    Contact,
+    Barrel,
     Other(u16),
 }
 
+impl From<TabletToolButton> for Option<MouseButton> {
+    fn from(tool: TabletToolButton) -> Self {
+        Some(match tool {
+            TabletToolButton::Contact => MouseButton::Left,
+            TabletToolButton::Barrel => MouseButton::Right,
+            TabletToolButton::Other(1) => MouseButton::Middle,
+            TabletToolButton::Other(3) => MouseButton::Back,
+            TabletToolButton::Other(4) => MouseButton::Forward,
+            TabletToolButton::Other(_) => return None,
+        })
+    }
+}
+
 /// Describes a difference in the mouse scroll wheel state.
 #[derive(Debug, Clone, Copy, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -1188,7 +1622,7 @@ mod tests {
                 primary: true,
                 state: event::ElementState::Pressed,
                 position: (0, 0).into(),
-                button: event::MouseButton::Other(0).into(),
+                button: event::ButtonSource::Unknown(0),
             });
             with_window_event(PointerButton {
                 device_id: None,
@@ -1241,16 +1675,85 @@ mod tests {
         });
     }
 
+    #[test]
+    fn test_tilt_angle_conversions() {
+        use std::f64::consts::*;
+
+        use event::{TabletToolAngle, TabletToolTilt};
+
+        // See <https://github.com/web-platform-tests/wpt/blob/5af3e9c2a2aba76ade00f0dbc3486e50a74a4506/pointerevents/pointerevent_tiltX_tiltY_to_azimuth_altitude.html#L11-L23>.
+        const TILT_TO_ANGLE: &[(TabletToolTilt, TabletToolAngle)] = &[
+            (TabletToolTilt { x: 0, y: 0 }, TabletToolAngle { altitude: FRAC_PI_2, azimuth: 0. }),
+            (TabletToolTilt { x: 0, y: 90 }, TabletToolAngle { altitude: 0., azimuth: FRAC_PI_2 }),
+            (TabletToolTilt { x: 0, y: -90 }, TabletToolAngle {
+                altitude: 0.,
+                azimuth: 3. * FRAC_PI_2,
+            }),
+            (TabletToolTilt { x: 90, y: 0 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
+            (TabletToolTilt { x: 90, y: 90 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
+            (TabletToolTilt { x: 90, y: -90 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
+            (TabletToolTilt { x: -90, y: 0 }, TabletToolAngle { altitude: 0., azimuth: PI }),
+            (TabletToolTilt { x: -90, y: 90 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
+            (TabletToolTilt { x: -90, y: -90 }, TabletToolAngle { altitude: 0., azimuth: 0. }),
+            (TabletToolTilt { x: 0, y: 45 }, TabletToolAngle {
+                altitude: FRAC_PI_4,
+                azimuth: FRAC_PI_2,
+            }),
+            (TabletToolTilt { x: 0, y: -45 }, TabletToolAngle {
+                altitude: FRAC_PI_4,
+                azimuth: 3. * FRAC_PI_2,
+            }),
+            (TabletToolTilt { x: 45, y: 0 }, TabletToolAngle { altitude: FRAC_PI_4, azimuth: 0. }),
+            (TabletToolTilt { x: -45, y: 0 }, TabletToolAngle { altitude: FRAC_PI_4, azimuth: PI }),
+        ];
+
+        for (tilt, angle) in TILT_TO_ANGLE {
+            assert_eq!(tilt.angle(), *angle, "{tilt:?}");
+        }
+
+        // See <https://github.com/web-platform-tests/wpt/blob/5af3e9c2a2aba76ade00f0dbc3486e50a74a4506/pointerevents/pointerevent_tiltX_tiltY_to_azimuth_altitude.html#L38-L46>.
+        const ANGLE_TO_TILT: &[(TabletToolAngle, TabletToolTilt)] = &[
+            (TabletToolAngle { altitude: 0., azimuth: 0. }, TabletToolTilt { x: 90, y: 0 }),
+            (TabletToolAngle { altitude: FRAC_PI_4, azimuth: 0. }, TabletToolTilt { x: 45, y: 0 }),
+            (TabletToolAngle { altitude: FRAC_PI_2, azimuth: 0. }, TabletToolTilt { x: 0, y: 0 }),
+            (TabletToolAngle { altitude: 0., azimuth: FRAC_PI_2 }, TabletToolTilt { x: 0, y: 90 }),
+            (TabletToolAngle { altitude: FRAC_PI_4, azimuth: FRAC_PI_2 }, TabletToolTilt {
+                x: 0,
+                y: 45,
+            }),
+            (TabletToolAngle { altitude: 0., azimuth: PI }, TabletToolTilt { x: -90, y: 0 }),
+            (TabletToolAngle { altitude: FRAC_PI_4, azimuth: PI }, TabletToolTilt { x: -45, y: 0 }),
+            (TabletToolAngle { altitude: 0., azimuth: 3. * FRAC_PI_2 }, TabletToolTilt {
+                x: 0,
+                y: -90,
+            }),
+            (TabletToolAngle { altitude: FRAC_PI_4, azimuth: 3. * FRAC_PI_2 }, TabletToolTilt {
+                x: 0,
+                y: -45,
+            }),
+        ];
+
+        for (angle, tilt) in ANGLE_TO_TILT {
+            assert_eq!(angle.tilt(), *tilt, "{angle:?}");
+        }
+    }
+
     #[test]
     fn test_force_normalize() {
         let force = event::Force::Normalized(0.0);
-        assert_eq!(force.normalized(), 0.0);
+        assert_eq!(force.normalized(None), 0.0);
 
         let force2 = event::Force::Calibrated { force: 5.0, max_possible_force: 2.5 };
-        assert_eq!(force2.normalized(), 2.0);
+        assert_eq!(force2.normalized(None), 2.0);
 
         let force3 = event::Force::Calibrated { force: 5.0, max_possible_force: 2.5 };
-        assert_eq!(force3.normalized(), 2.0);
+        assert_eq!(
+            force3.normalized(Some(event::TabletToolAngle {
+                altitude: std::f64::consts::PI / 2.0,
+                azimuth: 0.
+            })),
+            2.0
+        );
     }
 
     #[allow(clippy::clone_on_copy)]

winit-core/src/event_loop/mod.rs

@@ -1,19 +1,21 @@
+pub mod never_return;
 pub mod pump_events;
+pub mod register;
 pub mod run_on_demand;
 
 use std::fmt::{self, Debug};
-use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;
 
 use rwh_06::{DisplayHandle, HandleError, HasDisplayHandle};
 
+use crate::Instant;
 use crate::as_any::AsAny;
 use crate::cursor::{CustomCursor, CustomCursorSource};
 use crate::error::RequestError;
 use crate::monitor::MonitorHandle;
 use crate::window::{Theme, Window, WindowAttributes};
-use crate::Instant;
 
 pub trait ActiveEventLoop: AsAny + fmt::Debug {
     /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
@@ -174,11 +176,11 @@ pub trait EventLoopProxyProvider: Send + Sync + Debug {
 /// - A reference-counted pointer to the underlying type.
 #[derive(Clone)]
 pub struct OwnedDisplayHandle {
-    pub(crate) handle: Arc<dyn HasDisplayHandle>,
+    pub(crate) handle: Arc<dyn HasDisplayHandle + Send + Sync>,
 }
 
 impl OwnedDisplayHandle {
-    pub fn new(handle: Arc<dyn HasDisplayHandle>) -> Self {
+    pub fn new(handle: Arc<dyn HasDisplayHandle + Send + Sync>) -> Self {
         Self { handle }
     }
 }

winit-core/src/event_loop/never_return.rs

@@ -0,0 +1,14 @@
+use crate::application::ApplicationHandler;
+
+/// Additional methods on `EventLoop` for platforms whose run method never return.
+pub trait EventLoopExtNeverReturn {
+    /// Run the event loop and call `process::exit` once finished.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS**: This registers the callbacks with the system and calls `UIApplicationMain`.
+    /// - **macOS**: Unimplemented (TODO: Should call `NSApplicationMain`).
+    /// - **Android/Orbital/Wayland/Windows/X11**: Unsupported.
+    /// - **Web**: Impossible to support properly.
+    fn run_app_never_return<A: ApplicationHandler + 'static>(self, app: A) -> !;
+}

winit-core/src/event_loop/register.rs

@@ -0,0 +1,17 @@
+use crate::application::ApplicationHandler;
+
+/// Additional methods on `EventLoop` that registers it with the system event loop.
+pub trait EventLoopExtRegister {
+    /// Initialize and register the application with the system's event loop, such that the
+    /// callbacks will be run later.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web**: Once the event loop has been destroyed, it's possible to reinitialize another
+    ///   event loop by calling this function again. This can be useful if you want to recreate the
+    ///   event loop while the WebAssembly module is still loaded. For example, this can be used to
+    ///   recreate the event loop when switching between tabs on a single page application.
+    /// - **iOS/macOS**: Unimplemented.
+    /// - **Android/Orbital/Wayland/Windows/X11**: Unsupported.
+    fn register_app<A: ApplicationHandler + 'static>(self, app: A);
+}

winit-core/src/event_loop/run_on_demand.rs

@@ -2,19 +2,17 @@ use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
 #[cfg(doc)]
 use crate::{
-    event_loop::{pump_events::EventLoopExtPumpEvents, ActiveEventLoop},
+    event_loop::{ActiveEventLoop, pump_events::EventLoopExtPumpEvents},
     window::Window,
 };
 
-#[allow(rustdoc::broken_intra_doc_links)] // FIXME(madsmtm): Fix these.
 /// Additional methods on [`EventLoop`] to return control flow to the caller.
 pub trait EventLoopExtRunOnDemand {
     /// Run the application with the event loop on the calling thread.
     ///
     /// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`)
-    /// closures and it is possible to return control back to the caller without
-    /// consuming the `EventLoop` (by using [`exit()`]) and
-    /// so the event loop can be re-run after it has exit.
+    /// state and it is possible to return control back to the caller without consuming the
+    /// `EventLoop` (by using [`exit()`]) and so the event loop can be re-run after it has exit.
     ///
     /// It's expected that each run of the loop will be for orthogonal instantiations of your
     /// Winit application, but internally each instantiation may re-use some common window
@@ -31,8 +29,7 @@ pub trait EventLoopExtRunOnDemand {
     ///
     /// # Caveats
     /// - This extension isn't available on all platforms, since it's not always possible to return
-    ///   to the caller (specifically this is impossible on iOS and Web - though with the Web
-    ///   backend it is possible to use `EventLoopExtWeb::spawn_app()`[^1] more than once instead).
+    ///   to the caller (specifically this is impossible on iOS and Web).
     /// - No [`Window`] state can be carried between separate runs of the event loop.
     ///
     /// You are strongly encouraged to use [`EventLoop::run_app()`] for portability, unless you
@@ -51,8 +48,6 @@ pub trait EventLoopExtRunOnDemand {
     ///   are delivered via callbacks based on an event loop that is internal to the browser itself.
     /// - **iOS:** It's not possible to stop and start an `UIApplication` repeatedly on iOS.
     ///
-    /// [^1]: `spawn_app()` is only available on the Web platforms.
-    ///
     /// [`exit()`]: ActiveEventLoop::exit()
     /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
     fn run_app_on_demand<A: ApplicationHandler>(&mut self, app: A) -> Result<(), EventLoopError>;

winit-core/src/icon.rs

@@ -3,7 +3,7 @@ use std::ops::Deref;
 use std::sync::Arc;
 use std::{fmt, io, mem};
 
-use crate::as_any::{impl_dyn_casting, AsAny};
+use crate::as_any::AsAny;
 
 pub(crate) const PIXEL_SIZE: usize = mem::size_of::<u32>();
 

winit-core/src/keyboard.rs

@@ -29,11 +29,13 @@ pub enum NativeKeyCode {
     Windows(u16),
     /// An XKB "keycode".
     Xkb(u32),
+    /// An OpenHarmony "scancode".
+    Ohos(u32),
 }
 
 impl std::fmt::Debug for NativeKeyCode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use NativeKeyCode::{Android, MacOS, Unidentified, Windows, Xkb};
+        use NativeKeyCode::{Android, MacOS, Ohos, Unidentified, Windows, Xkb};
         let mut debug_tuple;
         match self {
             Unidentified => {
@@ -55,6 +57,10 @@ impl std::fmt::Debug for NativeKeyCode {
                 debug_tuple = f.debug_tuple("Xkb");
                 debug_tuple.field(&format_args!("0x{code:04X}"));
             },
+            Ohos(code) => {
+                debug_tuple = f.debug_tuple("OpenHarmony");
+                debug_tuple.field(&format_args!("0x{code:04X}"));
+            },
         }
         debug_tuple.finish()
     }
@@ -85,11 +91,13 @@ pub enum NativeKey {
     Xkb(u32),
     /// A "key value string".
     Web(SmolStr),
+    /// An OpenHarmony "keycode", which is similar to a "virtual-key code" on Windows.
+    Ohos(u32),
 }
 
 impl std::fmt::Debug for NativeKey {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        use NativeKey::{Android, MacOS, Unidentified, Web, Windows, Xkb};
+        use NativeKey::{Android, MacOS, Ohos, Unidentified, Web, Windows, Xkb};
         let mut debug_tuple;
         match self {
             Unidentified => {
@@ -115,6 +123,10 @@ impl std::fmt::Debug for NativeKey {
                 debug_tuple = f.debug_tuple("Web");
                 debug_tuple.field(code);
             },
+            Ohos(code) => {
+                debug_tuple = f.debug_tuple("OpenHarmony");
+                debug_tuple.field(code);
+            },
         }
         debug_tuple.finish()
     }
@@ -129,6 +141,7 @@ impl From<NativeKeyCode> for NativeKey {
             NativeKeyCode::MacOS(x) => NativeKey::MacOS(x),
             NativeKeyCode::Windows(x) => NativeKey::Windows(x),
             NativeKeyCode::Xkb(x) => NativeKey::Xkb(x),
+            NativeKeyCode::Ohos(x) => NativeKey::Ohos(x),
         }
     }
 }
@@ -193,7 +206,7 @@ impl PartialEq<KeyCode> for PhysicalKey {
     #[inline]
     fn eq(&self, rhs: &KeyCode) -> bool {
         match self {
-            PhysicalKey::Code(ref code) => code == rhs,
+            PhysicalKey::Code(code) => code == rhs,
             _ => false,
         }
     }
@@ -210,7 +223,7 @@ impl PartialEq<NativeKeyCode> for PhysicalKey {
     #[inline]
     fn eq(&self, rhs: &NativeKeyCode) -> bool {
         match self {
-            PhysicalKey::Unidentified(ref code) => code == rhs,
+            PhysicalKey::Unidentified(code) => code == rhs,
             _ => false,
         }
     }
@@ -275,7 +288,7 @@ impl<Str> PartialEq<NamedKey> for Key<Str> {
     #[inline]
     fn eq(&self, rhs: &NamedKey) -> bool {
         match self {
-            Key::Named(ref a) => a == rhs,
+            Key::Named(a) => a == rhs,
             _ => false,
         }
     }
@@ -285,7 +298,7 @@ impl<Str: PartialEq<str>> PartialEq<str> for Key<Str> {
     #[inline]
     fn eq(&self, rhs: &str) -> bool {
         match self {
-            Key::Character(ref s) => s == rhs,
+            Key::Character(s) => s == rhs,
             _ => false,
         }
     }
@@ -302,7 +315,7 @@ impl<Str> PartialEq<NativeKey> for Key<Str> {
     #[inline]
     fn eq(&self, rhs: &NativeKey) -> bool {
         match self {
-            Key::Unidentified(ref code) => code == rhs,
+            Key::Unidentified(code) => code == rhs,
             _ => false,
         }
     }

winit-core/src/monitor.rs

@@ -13,7 +13,7 @@ use std::sync::Arc;
 
 use dpi::{PhysicalPosition, PhysicalSize};
 
-use crate::as_any::{impl_dyn_casting, AsAny};
+use crate::as_any::AsAny;
 
 /// Handle to a monitor.
 ///

winit-core/src/window.rs

@@ -328,7 +328,7 @@ impl WindowAttributes {
     ///
     /// **Android / iOS / X11 / Wayland / Orbital:** Unsupported.
     ///
-    /// [`WindowEvent::Focused`]: crate::event::WindowEvent::Focused.
+    /// [`WindowEvent::Focused`]: crate::event::WindowEvent::Focused
     #[inline]
     pub fn with_active(mut self, active: bool) -> Self {
         self.active = active;
@@ -792,16 +792,6 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// ```
     fn safe_area(&self) -> PhysicalInsets<u32>;
 
-    /// The minimum dimensions of the window's surface if it was set.
-    ///
-    /// Getter for [`set_min_surface_size`][Window::set_min_surface_size], see that for details.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Orbital:** Unsupported.
-    /// - **Web:** Unimplemented, returns `None`.
-    fn min_surface_size(&self) -> Option<PhysicalSize<u32>>;
-
     /// Sets a minimum dimensions of the window's surface.
     ///
     /// ```no_run
@@ -821,16 +811,6 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **iOS / Android / Orbital:** Unsupported.
     fn set_min_surface_size(&self, min_size: Option<Size>);
 
-    /// The maximum dimensions of the window's surface if it was set.
-    ///
-    /// Getter for [`set_max_surface_size`][Window::set_max_surface_size], see that for details.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Orbital:** Unsupported.
-    /// - **Web:** Unimplemented, returns `None`.
-    fn max_surface_size(&self) -> Option<PhysicalSize<u32>>;
-
     /// Sets a maximum dimensions of the window's surface.
     ///
     /// ```no_run
@@ -854,7 +834,7 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Web / Wayland / Orbital:** Always returns [`None`].
+    /// - **iOS / Android / Web / Orbital:** Always returns [`None`].
     fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>>;
 
     /// Sets resize increments of the surface.
@@ -866,19 +846,15 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///
     /// - **macOS:** Increments are converted to logical size and then macOS rounds them to whole
     ///   numbers.
-    /// - **Wayland:** Not implemented.
     /// - **iOS / Android / Web / Orbital:** Unsupported.
     fn set_surface_resize_increments(&self, increments: Option<Size>);
 
-    /// The window transparency state.
-    ///
-    /// Getter for [`set_transparent`][Window::set_transparent], see that for details.
+    /// Modifies the title of the window.
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Web:** Unsupported.
-    /// - **X11:** Unimplemented, returns `false`.
-    fn is_transparent(&self) -> bool;
+    /// - **iOS / Android:** Unsupported.
+    fn set_title(&self, title: &str);
 
     /// Change the window transparency state.
     ///
@@ -897,15 +873,6 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///   [`WindowAttributes::with_transparent`].
     fn set_transparent(&self, transparent: bool);
 
-    /// The window blur state.
-    ///
-    /// Getter for [`set_blur`][Window::set_blur], see that for details.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Android / iOS / X11 / Web / Windows / macOS:** Unsupported.
-    fn is_blurred(&self) -> bool;
-
     /// Change the window blur state.
     ///
     /// If `true`, this will make the transparent window background blurry.
@@ -913,9 +880,19 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// ## Platform-specific
     ///
     /// - **Android / iOS / X11 / Web / Windows:** Unsupported.
-    /// - **Wayland:** Only works with org_kde_kwin_blur_manager protocol.
+    /// - **Wayland:** Only works with `org_kde_kwin_blur_manager` or
+    ///   `ext_background_effect_manager_v1` protocol.
     fn set_blur(&self, blur: bool);
 
+    /// Modifies the window's visibility.
+    ///
+    /// If `false`, this will hide the window. If `true`, this will show the window.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Android / Wayland / Web:** Unsupported.
+    fn set_visible(&self, visible: bool);
+
     /// Gets the window's current visibility state.
     ///
     /// `None` means it couldn't be determined, so it is not recommended to use this to drive your
@@ -927,23 +904,6 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **Wayland / iOS / Android / Web:** Unsupported.
     fn is_visible(&self) -> Option<bool>;
 
-    /// Modifies the window's visibility.
-    ///
-    /// If `false`, this will hide the window. If `true`, this will show the window.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **Android / Wayland / Web:** Unsupported.
-    fn set_visible(&self, visible: bool);
-
-    /// Gets the window's current resizable state.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **X11:** Not implemented.
-    /// - **iOS / Android / Web:** Unsupported.
-    fn is_resizable(&self) -> bool;
-
     /// Sets whether the window is resizable or not.
     ///
     /// Note that making the window unresizable doesn't exempt you from handling
@@ -961,13 +921,13 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// [`WindowEvent::SurfaceResized`]: crate::event::WindowEvent::SurfaceResized
     fn set_resizable(&self, resizable: bool);
 
-    /// Gets the enabled window buttons.
+    /// Gets the window's current resizable state.
     ///
     /// ## Platform-specific
     ///
-    /// - **Wayland / X11 / Orbital:** Not implemented. Always returns [`WindowButtons::all`].
-    /// - **Web / iOS / Android:** Unsupported. Always returns [`WindowButtons::all`].
-    fn enabled_buttons(&self) -> WindowButtons;
+    /// - **X11:** Not implemented.
+    /// - **iOS / Android / Web:** Unsupported.
+    fn is_resizable(&self) -> bool;
 
     /// Sets the enabled window buttons.
     ///
@@ -977,6 +937,22 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **Web / iOS / Android:** Unsupported.
     fn set_enabled_buttons(&self, buttons: WindowButtons);
 
+    /// Gets the enabled window buttons.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Wayland / X11 / Orbital:** Not implemented. Always returns [`WindowButtons::all`].
+    /// - **Web / iOS / Android:** Unsupported. Always returns [`WindowButtons::all`].
+    fn enabled_buttons(&self) -> WindowButtons;
+
+    /// Minimize the window, or put it back from the minimized state.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Web / Orbital:** Unsupported.
+    /// - **Wayland:** Un-minimize is unsupported.
+    fn set_minimized(&self, minimized: bool);
+
     /// Gets the window's current minimized state.
     ///
     /// `None` will be returned, if the minimized state couldn't be determined.
@@ -991,21 +967,6 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **iOS / Android / Web / Orbital:** Unsupported.
     fn is_minimized(&self) -> Option<bool>;
 
-    /// Minimize the window, or put it back from the minimized state.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Web / Orbital:** Unsupported.
-    /// - **Wayland:** Un-minimize is unsupported.
-    fn set_minimized(&self, minimized: bool);
-
-    /// Gets the window's current maximized state.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Web:** Unsupported.
-    fn is_maximized(&self) -> bool;
-
     /// Sets the window to maximized or back.
     ///
     /// ## Platform-specific
@@ -1013,14 +974,12 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **iOS / Android / Web:** Unsupported.
     fn set_maximized(&self, maximized: bool);
 
-    /// Gets the window's current fullscreen state.
+    /// Gets the window's current maximized state.
     ///
     /// ## Platform-specific
     ///
-    /// - **Android:** Will always return `None`.
-    /// - **Orbital / Web:** Can only return `None` or `Borderless(None)`.
-    /// - **Wayland:** Can return `Borderless(None)` when there are no monitors.
-    fn fullscreen(&self) -> Option<Fullscreen>;
+    /// - **iOS / Android / Web:** Unsupported.
+    fn is_maximized(&self) -> bool;
 
     /// Set the window's fullscreen state.
     ///
@@ -1047,15 +1006,14 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// [`VideoMode`]: crate::monitor::VideoMode
     fn set_fullscreen(&self, fullscreen: Option<Fullscreen>);
 
-    /// Gets the window's current decorations state.
-    ///
-    /// Returns `true` when windows are decorated (server-side or by Winit).
-    /// Also returns `true` when no decorations are required (mobile, Web).
+    /// Gets the window's current fullscreen state.
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Web:** Always returns `true`.
-    fn is_decorated(&self) -> bool;
+    /// - **Android:** Will always return `None`.
+    /// - **Orbital / Web:** Can only return `None` or `Borderless(None)`.
+    /// - **Wayland:** Can return `Borderless(None)` when there are no monitors.
+    fn fullscreen(&self) -> Option<Fullscreen>;
 
     /// Turn window decorations on or off.
     ///
@@ -1068,39 +1026,23 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **iOS / Android / Web:** No effect.
     fn set_decorations(&self, decorations: bool);
 
-    /// The window level.
+    /// Gets the window's current decorations state.
     ///
-    /// Getter for [`set_window_level`][Window::set_window_level], see that and [`WindowLevel`] for
-    /// details.
+    /// Returns `true` when windows are decorated (server-side or by Winit).
+    /// Also returns `true` when no decorations are required (mobile, Web).
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Web / Wayland:** Unsupported.
-    /// - **X11:** Unimplemented, returns the default window level.
-    fn window_level(&self) -> WindowLevel;
+    /// - **iOS / Android / Web:** Always returns `true`.
+    fn is_decorated(&self) -> bool;
 
     /// Change the window level.
     ///
     /// This is just a hint to the OS, and the system could ignore it.
     ///
     /// See [`WindowLevel`] for details.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Web / Wayland:** Unsupported.
     fn set_window_level(&self, level: WindowLevel);
 
-    /// The window icon, if any was set.
-    ///
-    /// Getter for [`set_window_icon`][Window::set_window_icon], see that for details.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Web / macOS / Orbital:** Unsupported.
-    /// - **Windows:** The icon may be different from the one set with `set_window_icon`.
-    /// - **X11 / Wayland:** Unimplemented, returns `None`.
-    fn window_icon(&self) -> Option<Icon>;
-
     /// Sets the window icon.
     ///
     /// On Windows, Wayland and X11, this is typically the small icon in the top-left
@@ -1108,7 +1050,7 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Web / macOS / Orbital:** Unsupported.
+    /// - **iOS / Android / Web / / macOS / Orbital:** Unsupported.
     ///
     /// - **Windows:** Sets `ICON_SMALL`. The base size for a window icon is 16x16, but it's
     ///   recommended to account for screen scaling and pick a multiple of that, i.e. 32x32.
@@ -1194,9 +1136,9 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
         let action = if allowed {
             let position = LogicalPosition::new(0, 0);
             let size = LogicalSize::new(0, 0);
-            let ime_caps = ImeCapabilities::new().with_purpose().with_cursor_area();
+            let ime_caps = ImeCapabilities::new().with_hint_and_purpose().with_cursor_area();
             let request_data = ImeRequestData {
-                purpose: Some(ImePurpose::Normal),
+                hint_and_purpose: Some((ImeHint::NONE, ImePurpose::Normal)),
                 // WARNING: there's nothing sensible to use here by default.
                 cursor_area: Some((position.into(), size.into())),
                 ..ImeRequestData::default()
@@ -1218,9 +1160,9 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **iOS / Android / Web / Windows / X11 / macOS / Orbital:** Unsupported.
     #[deprecated = "use Window::request_ime_update instead"]
     fn set_ime_purpose(&self, purpose: ImePurpose) {
-        if self.ime_capabilities().map(|caps| caps.purpose()).unwrap_or(false) {
+        if self.ime_capabilities().map(|caps| caps.hint_and_purpose()).unwrap_or(false) {
             let _ = self.request_ime_update(ImeRequest::Update(ImeRequestData {
-                purpose: Some(purpose),
+                hint_and_purpose: Some((ImeHint::NONE, purpose)),
                 ..ImeRequestData::default()
             }));
         }
@@ -1244,14 +1186,14 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///
     /// ```no_run
     /// # use dpi::{Position, Size};
-    /// # use winit_core::window::{Window, ImePurpose, ImeRequest, ImeCapabilities, ImeRequestData, ImeEnableRequest};
+    /// # use winit_core::window::{Window, ImeHint, ImePurpose, ImeRequest, ImeCapabilities, ImeRequestData, ImeEnableRequest};
     /// # fn scope(window: &dyn Window, cursor_pos: Position, cursor_size: Size) {
     /// // Clear previous state by switching off IME
     /// window.request_ime_update(ImeRequest::Disable).expect("Disable cannot fail");
     ///
-    /// let ime_caps = ImeCapabilities::new().with_cursor_area().with_purpose();
+    /// let ime_caps = ImeCapabilities::new().with_cursor_area().with_hint_and_purpose();
     /// let request_data = ImeRequestData::default()
-    ///                          .with_purpose(ImePurpose::Normal)
+    ///                          .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
     ///                          .with_cursor_area(cursor_pos, cursor_size);
     /// let enable_ime = ImeEnableRequest::new(ime_caps, request_data.clone()).unwrap();
     /// window.request_ime_update(ImeRequest::Enable(enable_ime)).expect("Enabling may fail if IME is not supported");
@@ -1281,13 +1223,6 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// By default IME is disabled, thus will return `None`.
     fn ime_capabilities(&self) -> Option<ImeCapabilities>;
 
-    /// Gets whether the window has keyboard focus.
-    ///
-    /// This queries the same state information as [`WindowEvent::Focused`].
-    ///
-    /// [`WindowEvent::Focused`]: crate::event::WindowEvent::Focused
-    fn has_focus(&self) -> bool;
-
     /// Brings the window to the front and sets input focus. Has no effect if the window is
     /// already in focus, minimized, or not visible.
     ///
@@ -1300,6 +1235,13 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **iOS / Android / Wayland / Orbital:** Unsupported.
     fn focus_window(&self);
 
+    /// Gets whether the window has keyboard focus.
+    ///
+    /// This queries the same state information as [`WindowEvent::Focused`].
+    ///
+    /// [`WindowEvent::Focused`]: crate::event::WindowEvent::Focused
+    fn has_focus(&self) -> bool;
+
     /// Requests user attention to the window, this has no effect if the application
     /// is already focused. How requesting for user attention manifests is platform dependent,
     /// see [`UserAttentionType`] for details.
@@ -1315,16 +1257,6 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **Wayland:** Requires `xdg_activation_v1` protocol, `None` has no effect.
     fn request_user_attention(&self, request_type: Option<UserAttentionType>);
 
-    /// Returns the current window theme.
-    ///
-    /// Returns `None` if it cannot be determined on the current platform.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / x11 / Orbital:** Unsupported.
-    /// - **Wayland:** Only returns theme overrides.
-    fn theme(&self) -> Option<Theme>;
-
     /// Set or override the window theme.
     ///
     /// Specify `None` to reset the theme to the system default.
@@ -1338,12 +1270,15 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **iOS / Android / Web / Orbital:** Unsupported.
     fn set_theme(&self, theme: Option<Theme>);
 
-    /// Whether the window's contents are prevented from being captured by other apps.
+    /// Returns the current window theme.
     ///
-    /// Getter for [`set_content_protected`][Window::set_content_protected], see that for details.
+    /// Returns `None` if it cannot be determined on the current platform.
     ///
-    /// - **iOS / Android / X11 / Wayland / Web / Orbital:** Unsupported.
-    fn content_protected(&self) -> bool;
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / x11 / Orbital:** Unsupported.
+    /// - **Wayland:** Only returns theme overrides.
+    fn theme(&self) -> Option<Theme>;
 
     /// Prevents the window contents from being captured by other apps.
     ///
@@ -1351,7 +1286,7 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///
     /// - **macOS**: if `false`, [`NSWindowSharingNone`] is used but doesn't completely prevent all
     ///   apps from reading the window content, for instance, QuickTime.
-    /// - **iOS / Android / X11 / Wayland / Web / Orbital:** Unsupported.
+    /// - **iOS / Android / x11 / Wayland / Web / Orbital:** Unsupported.
     ///
     /// [`NSWindowSharingNone`]: https://developer.apple.com/documentation/appkit/nswindowsharingtype/nswindowsharingnone
     fn set_content_protected(&self, protected: bool);
@@ -1363,23 +1298,6 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// - **iOS / Android / x11 / Wayland / Web:** Unsupported. Always returns an empty string.
     fn title(&self) -> String;
 
-    /// Modifies the title of the window.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android:** Unsupported.
-    fn set_title(&self, title: &str);
-
-    /// The cursor icon of the window.
-    ///
-    /// Getter for [`set_cursor`][Window::set_cursor], see that for details.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS / Android / Orbital:** Unsupported.
-    /// - **macOS / X11 / Wayland / Web / Windows:** Unimplemented, returns the default cursor.
-    fn cursor(&self) -> Cursor;
-
     /// Modifies the cursor icon of the window.
     ///
     /// ## Platform-specific
@@ -1680,29 +1598,86 @@ pub enum WindowLevel {
 
 /// Generic IME purposes for use in [`Window::set_ime_purpose`].
 ///
+/// The purpose should reflect the kind of data to be entered.
 /// The purpose may improve UX by optimizing the IME for the specific use case,
+/// for example showing relevant characters and hiding unneeded ones,
+/// or changing the icon of the confirmation button,
 /// if winit can express the purpose to the platform and the platform reacts accordingly.
 ///
 /// ## Platform-specific
 ///
 /// - **iOS / Android / Web / Windows / X11 / macOS / Orbital:** Unsupported.
 #[non_exhaustive]
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum ImePurpose {
-    /// No special hints for the IME (default).
+    /// No special purpose for the IME (default).
+    #[default]
     Normal,
     /// The IME is used for password input.
+    /// The IME will treat the contents as sensitive.
     Password,
     /// The IME is used to input into a terminal.
     ///
     /// For example, that could alter OSK on Wayland to show extra buttons.
     Terminal,
+    /// Number (including decimal separator and sign)
+    Number,
+    /// Phone number
+    Phone,
+    /// URL
+    Url,
+    /// Email address
+    Email,
+    /// Password composed only of digits (treated as sensitive data)
+    Pin,
+    /// Date
+    Date,
+    /// Time
+    Time,
+    /// Date and time
+    DateTime,
 }
 
-impl Default for ImePurpose {
-    fn default() -> Self {
-        Self::Normal
+bitflags! {
+    /// IME hints
+    ///
+    /// The hint should reflect the desired behaviour of the IME
+    /// while entering text.
+    /// The purpose may improve UX by optimizing the IME for the specific use case,
+    /// beyond just the general data type specified in `ImePurpose`.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Web / Windows / X11 / macOS / Orbital:** Unsupported.
+    #[non_exhaustive]
+    #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
+    pub struct ImeHint: u32 {
+        /// No special behaviour.
+        const NONE = 0;
+        /// Suggest word completions.
+        const COMPLETION = 0x1;
+        /// Suggest word corrections.
+        const SPELLCHECK = 0x2;
+        /// Switch to uppercase letters at the start of a sentence.
+        const AUTO_CAPITALIZATION = 0x4;
+        /// Prefer lowercase letters.
+        const LOWERCASE = 0x8;
+        /// Prefer uppercase letters.
+        const UPPERCASE = 0x10;
+        /// Prefer casing for titles and headings (can be language dependent).
+        const TITLECASE = 0x20;
+        /// Characters should be hidden.
+        ///
+        /// This may prevent e.g. layout switching with some IMEs, unless hint is disabled.
+        const HIDDEN_TEXT = 0x40;
+        /// Typed text should not be stored.
+        const SENSITIVE_DATA = 0x80;
+        /// Just Latin characters should be entered.
+        const LATIN = 0x100;
+        /// The text input is multiline.
+        const MULTILINE = 0x200;
     }
 }
 
@@ -1716,6 +1691,22 @@ pub enum ImeSurroundingTextError {
     AnchorBadPosition,
 }
 
+impl fmt::Display for ImeSurroundingTextError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ImeSurroundingTextError::TextTooLong => write!(f, "text exceeds maximum length"),
+            ImeSurroundingTextError::CursorBadPosition => {
+                write!(f, "cursor is not at a valid text index")
+            },
+            ImeSurroundingTextError::AnchorBadPosition => {
+                write!(f, "anchor is not at a valid text index")
+            },
+        }
+    }
+}
+
+impl std::error::Error for ImeSurroundingTextError {}
+
 /// Defines the text surrounding the caret
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -1810,7 +1801,7 @@ pub enum ImeRequest {
     ///
     /// **Requesting to update data matching not enabled capabilities will result in update
     /// being ignored.** The winit backend in such cases is recommended to log a warning. This
-    /// appiles to both [`ImeRequest::Enable`] and [`ImeRequest::Update`]. For details on
+    /// applies to both [`ImeRequest::Enable`] and [`ImeRequest::Update`]. For details on
     /// capabilities refer to [`ImeCapabilities`].
     ///
     /// To update the [`ImeCapabilities`], the IME must be disabled and then re-enabled.
@@ -1841,7 +1832,7 @@ impl ImeEnableRequest {
             return None;
         }
 
-        if capabilities.purpose() ^ request_data.purpose.is_some() {
+        if capabilities.hint_and_purpose() ^ request_data.hint_and_purpose.is_some() {
             return None;
         }
 
@@ -1886,23 +1877,23 @@ impl ImeCapabilities {
         Self::default()
     }
 
-    /// Marks `purpose` as supported.
+    /// Marks `hint and purpose` as supported.
     ///
-    /// For more details see [`ImeRequestData::with_purpose`].
-    pub const fn with_purpose(self) -> Self {
-        Self(self.0.union(ImeCapabilitiesFlags::PURPOSE))
+    /// For more details see [`ImeRequestData::with_hint_and_purpose`].
+    pub const fn with_hint_and_purpose(self) -> Self {
+        Self(self.0.union(ImeCapabilitiesFlags::HINT_AND_PURPOSE))
     }
 
-    /// Marks `purpose` as unsupported.
+    /// Marks `hint and purpose` as unsupported.
     ///
-    /// For more details see [`ImeRequestData::with_purpose`].
-    pub const fn without_purpose(self) -> Self {
-        Self(self.0.difference(ImeCapabilitiesFlags::PURPOSE))
+    /// For more details see [`ImeRequestData::with_hint_and_purpose`].
+    pub const fn without_hint_and_purpose(self) -> Self {
+        Self(self.0.difference(ImeCapabilitiesFlags::HINT_AND_PURPOSE))
     }
 
-    /// Returns `true` if `purpose` is supported.
-    pub const fn purpose(&self) -> bool {
-        self.0.contains(ImeCapabilitiesFlags::PURPOSE)
+    /// Returns `true` if `hint and purpose` is supported.
+    pub const fn hint_and_purpose(&self) -> bool {
+        self.0.contains(ImeCapabilitiesFlags::HINT_AND_PURPOSE)
     }
 
     /// Marks `cursor_area` as supported.
@@ -1947,8 +1938,8 @@ impl ImeCapabilities {
 bitflags! {
     #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
     pub(crate) struct ImeCapabilitiesFlags : u8 {
-        /// Client supports setting IME purpose.
-        const PURPOSE = 1 << 0;
+        /// Client supports setting IME hint and purpose.
+        const HINT_AND_PURPOSE = 1 << 0;
         /// Client supports reporting cursor area for IME popup to
         /// appear.
         const CURSOR_AREA = 1 << 1;
@@ -1966,24 +1957,24 @@ bitflags! {
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct ImeRequestData {
-    /// Text input purpose.
+    /// Text input hint and purpose.
     ///
-    /// To support updating it, enable [`ImeCapabilities::PURPOSE`].
-    pub purpose: Option<ImePurpose>,
+    /// To support updating it, enable [`ImeCapabilities::hint_and_purpose()`].
+    pub hint_and_purpose: Option<(ImeHint, ImePurpose)>,
     /// The IME cursor area which should not be covered by the input method popup.
     ///
-    /// To support updating it, enable [`ImeCapabilities::CURSOR_AREA`].
+    /// To support updating it, enable [`ImeCapabilities::cursor_area()`].
     pub cursor_area: Option<(Position, Size)>,
     /// The text surrounding the caret
     ///
-    /// To support updating it, enable [`ImeCapabilities::SURROUNDING_TEXT`].
+    /// To support updating it, enable [`ImeCapabilities::surrounding_text()`].
     pub surrounding_text: Option<ImeSurroundingText>,
 }
 
 impl ImeRequestData {
-    /// Sets the purpose hint of the current text input.
-    pub fn with_purpose(self, purpose: ImePurpose) -> Self {
-        Self { purpose: Some(purpose), ..self }
+    /// Sets the hint and purpose of the current text input content.
+    pub fn with_hint_and_purpose(self, hint: ImeHint, purpose: ImePurpose) -> Self {
+        Self { hint_and_purpose: Some((hint, purpose)), ..self }
     }
 
     /// Sets the IME cursor editing area.
@@ -2109,59 +2100,73 @@ mod tests {
         ImeCapabilities, ImeEnableRequest, ImeRequestData, ImeSurroundingText,
         ImeSurroundingTextError,
     };
-    use crate::window::ImePurpose;
+    use crate::window::{ImeHint, ImePurpose};
 
     #[test]
     fn ime_initial_request_caps_match() {
         let position: Position = LogicalPosition::new(0, 0).into();
         let size: Size = LogicalSize::new(0, 0).into();
 
-        assert!(ImeEnableRequest::new(
-            ImeCapabilities::new().with_cursor_area(),
-            ImeRequestData::default()
-        )
-        .is_none());
-        assert!(ImeEnableRequest::new(
-            ImeCapabilities::new().with_purpose(),
-            ImeRequestData::default()
-        )
-        .is_none());
+        assert!(
+            ImeEnableRequest::new(
+                ImeCapabilities::new().with_cursor_area(),
+                ImeRequestData::default()
+            )
+            .is_none()
+        );
+        assert!(
+            ImeEnableRequest::new(
+                ImeCapabilities::new().with_hint_and_purpose(),
+                ImeRequestData::default()
+            )
+            .is_none()
+        );
 
-        assert!(ImeEnableRequest::new(
-            ImeCapabilities::new().with_cursor_area(),
-            ImeRequestData::default().with_purpose(ImePurpose::Normal)
-        )
-        .is_none());
+        assert!(
+            ImeEnableRequest::new(
+                ImeCapabilities::new().with_cursor_area(),
+                ImeRequestData::default().with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+            )
+            .is_none()
+        );
 
-        assert!(ImeEnableRequest::new(
-            ImeCapabilities::new(),
-            ImeRequestData::default()
-                .with_purpose(ImePurpose::Normal)
-                .with_cursor_area(position, size)
-        )
-        .is_none());
+        assert!(
+            ImeEnableRequest::new(
+                ImeCapabilities::new(),
+                ImeRequestData::default()
+                    .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+                    .with_cursor_area(position, size)
+            )
+            .is_none()
+        );
 
-        assert!(ImeEnableRequest::new(
-            ImeCapabilities::new().with_cursor_area(),
-            ImeRequestData::default()
-                .with_purpose(ImePurpose::Normal)
-                .with_cursor_area(position, size)
-        )
-        .is_none());
+        assert!(
+            ImeEnableRequest::new(
+                ImeCapabilities::new().with_cursor_area(),
+                ImeRequestData::default()
+                    .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+                    .with_cursor_area(position, size)
+            )
+            .is_none()
+        );
 
-        assert!(ImeEnableRequest::new(
-            ImeCapabilities::new().with_cursor_area(),
-            ImeRequestData::default().with_cursor_area(position, size)
-        )
-        .is_some());
+        assert!(
+            ImeEnableRequest::new(
+                ImeCapabilities::new().with_cursor_area(),
+                ImeRequestData::default().with_cursor_area(position, size)
+            )
+            .is_some()
+        );
 
-        assert!(ImeEnableRequest::new(
-            ImeCapabilities::new().with_purpose().with_cursor_area(),
-            ImeRequestData::default()
-                .with_purpose(ImePurpose::Normal)
-                .with_cursor_area(position, size)
-        )
-        .is_some());
+        assert!(
+            ImeEnableRequest::new(
+                ImeCapabilities::new().with_hint_and_purpose().with_cursor_area(),
+                ImeRequestData::default()
+                    .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+                    .with_cursor_area(position, size)
+            )
+            .is_some()
+        );
 
         let text: &[u8] = ['a' as u8; 8000].as_slice();
         let text = std::str::from_utf8(text).unwrap();

winit-orbital/Cargo.toml

@@ -21,5 +21,6 @@ tracing.workspace = true
 winit-core.workspace = true
 
 # Platform-specific
+libredox.workspace = true
 orbclient.workspace = true
-redox_syscall.workspace = true
+redox_event.workspace = true

winit-orbital/src/event_loop.rs

@@ -1,7 +1,7 @@
 use std::cell::Cell;
 use std::collections::VecDeque;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{mpsc, Arc, Mutex};
+use std::sync::{Arc, Mutex, mpsc};
 use std::time::Instant;
 use std::{iter, mem, slice};
 
@@ -10,6 +10,7 @@ use orbclient::{
     ButtonEvent, EventOption, FocusEvent, HoverEvent, KeyEvent, MouseEvent, MouseRelativeEvent,
     MoveEvent, QuitEvent, ResizeEvent, ScrollEvent, TextInputEvent,
 };
+use redox_event::{EventFlags, EventQueue};
 use smol_str::SmolStr;
 use winit_core::application::ApplicationHandler;
 use winit_core::cursor::{CustomCursor, CustomCursorSource};
@@ -100,6 +101,7 @@ fn convert_scancode(scancode: u8) -> (PhysicalKey, Option<NamedKey>) {
         orbclient::K_LEFT => (KeyCode::ArrowLeft, Some(NamedKey::ArrowLeft)),
         orbclient::K_LEFT_SHIFT => (KeyCode::ShiftLeft, Some(NamedKey::Shift)),
         orbclient::K_MINUS => (KeyCode::Minus, None),
+
         orbclient::K_NUM_0 => (KeyCode::Numpad0, None),
         orbclient::K_NUM_1 => (KeyCode::Numpad1, None),
         orbclient::K_NUM_2 => (KeyCode::Numpad2, None),
@@ -110,12 +112,20 @@ fn convert_scancode(scancode: u8) -> (PhysicalKey, Option<NamedKey>) {
         orbclient::K_NUM_7 => (KeyCode::Numpad7, None),
         orbclient::K_NUM_8 => (KeyCode::Numpad8, None),
         orbclient::K_NUM_9 => (KeyCode::Numpad9, None),
+        orbclient::K_NUM_ASTERISK => (KeyCode::NumpadMultiply, None),
+        orbclient::K_NUM_ENTER => (KeyCode::NumpadEnter, Some(NamedKey::Enter)),
+        orbclient::K_NUM_MINUS => (KeyCode::NumpadSubtract, None),
+        orbclient::K_NUM_PLUS => (KeyCode::NumpadAdd, None),
+        orbclient::K_NUM_SLASH => (KeyCode::NumpadDivide, None),
+        orbclient::K_NUM_PERIOD => (KeyCode::NumpadDecimal, None),
+
         orbclient::K_PERIOD => (KeyCode::Period, None),
         orbclient::K_PGDN => (KeyCode::PageDown, Some(NamedKey::PageDown)),
         orbclient::K_PGUP => (KeyCode::PageUp, Some(NamedKey::PageUp)),
         orbclient::K_QUOTE => (KeyCode::Quote, None),
         orbclient::K_RIGHT => (KeyCode::ArrowRight, Some(NamedKey::ArrowRight)),
         orbclient::K_RIGHT_SHIFT => (KeyCode::ShiftRight, Some(NamedKey::Shift)),
+        orbclient::K_RIGHT_SUPER => (KeyCode::MetaRight, Some(NamedKey::Meta)),
         orbclient::K_SEMICOLON => (KeyCode::Semicolon, None),
         orbclient::K_SLASH => (KeyCode::Slash, None),
         orbclient::K_SPACE => (KeyCode::Space, None),
@@ -127,17 +137,27 @@ fn convert_scancode(scancode: u8) -> (PhysicalKey, Option<NamedKey>) {
         orbclient::K_VOLUME_TOGGLE => (KeyCode::AudioVolumeMute, Some(NamedKey::AudioVolumeMute)),
         orbclient::K_VOLUME_UP => (KeyCode::AudioVolumeUp, Some(NamedKey::AudioVolumeUp)),
 
+        orbclient::K_INS => (KeyCode::Insert, Some(NamedKey::Insert)),
+        orbclient::K_PRTSC => (KeyCode::PrintScreen, Some(NamedKey::PrintScreen)),
+        orbclient::K_NUM => (KeyCode::NumLock, Some(NamedKey::NumLock)),
+        orbclient::K_SCROLL => (KeyCode::ScrollLock, Some(NamedKey::ScrollLock)),
+        orbclient::K_APP => (KeyCode::ContextMenu, Some(NamedKey::ContextMenu)),
+
+        orbclient::K_MEDIA_FAST_FORWARD => {
+            (KeyCode::MediaFastForward, Some(NamedKey::MediaFastForward))
+        },
+        orbclient::K_MEDIA_REWIND => (KeyCode::MediaRewind, Some(NamedKey::MediaRewind)),
+        orbclient::K_MEDIA_STOP => (KeyCode::MediaStop, Some(NamedKey::MediaStop)),
+
+        orbclient::K_POWER => (KeyCode::Power, Some(NamedKey::Power)),
+
         _ => return (PhysicalKey::Unidentified(NativeKeyCode::Unidentified), None),
     };
     (PhysicalKey::Code(key_code), named_key_opt)
 }
 
 fn element_state(pressed: bool) -> event::ElementState {
-    if pressed {
-        event::ElementState::Pressed
-    } else {
-        event::ElementState::Released
-    }
+    if pressed { event::ElementState::Pressed } else { event::ElementState::Released }
 }
 
 bitflags! {
@@ -292,16 +312,12 @@ impl EventLoop {
         let (user_events_sender, user_events_receiver) = mpsc::sync_channel(1);
 
         let event_socket =
-            Arc::new(RedoxSocket::event().map_err(|error| os_error!(format!("{error}")))?);
+            Arc::new(EventQueue::new().map_err(|error| os_error!(format!("{error}")))?);
 
         let wake_socket = TimeSocket::open().map_err(|error| os_error!(format!("{error}")))?;
 
         event_socket
-            .write(&syscall::Event {
-                id: wake_socket.0.fd,
-                flags: syscall::EventFlags::EVENT_READ,
-                data: wake_socket.0.fd,
-            })
+            .subscribe(wake_socket.0.fd(), EventSource::Time, EventFlags::READ)
             .map_err(|error| os_error!(format!("{error}")))?;
 
         Ok(Self {
@@ -485,7 +501,10 @@ impl EventLoop {
         }
     }
 
-    pub fn run_app<A: ApplicationHandler>(mut self, mut app: A) -> Result<(), EventLoopError> {
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        mut app: A,
+    ) -> Result<(), EventLoopError> {
         let mut start_cause = StartCause::Init;
         loop {
             app.new_events(&self.window_target, start_cause);
@@ -499,7 +518,7 @@ impl EventLoop {
                 let mut creates = self.window_target.creates.lock().unwrap();
                 creates.pop_front()
             } {
-                let window_id = WindowId::from_raw(window.fd);
+                let window_id = WindowId::from_raw(window.fd());
 
                 let mut buf: [u8; 4096] = [0; 4096];
                 let path = window.fpath(&mut buf).expect("failed to read properties");
@@ -523,18 +542,18 @@ impl EventLoop {
             } {
                 app.window_event(&self.window_target, destroy_id, event::WindowEvent::Destroyed);
                 self.windows
-                    .retain(|(window, _event_state)| WindowId::from_raw(window.fd) != destroy_id);
+                    .retain(|(window, _event_state)| WindowId::from_raw(window.fd()) != destroy_id);
             }
 
             // Handle window events.
             let mut i = 0;
             // While loop is used here because the same window may be processed more than once.
             while let Some((window, event_state)) = self.windows.get_mut(i) {
-                let window_id = WindowId::from_raw(window.fd);
+                let window_id = WindowId::from_raw(window.fd());
 
                 let mut event_buf = [0u8; 16 * mem::size_of::<orbclient::Event>()];
-                let count =
-                    syscall::read(window.fd, &mut event_buf).expect("failed to read window events");
+                let count = libredox::call::read(window.fd(), &mut event_buf)
+                    .expect("failed to read window events");
                 // Safety: orbclient::Event is a packed struct designed to be transferred over a
                 // socket.
                 let events = unsafe {
@@ -614,11 +633,7 @@ impl EventLoop {
 
             self.window_target
                 .event_socket
-                .write(&syscall::Event {
-                    id: timeout_socket.0.fd,
-                    flags: syscall::EventFlags::EVENT_READ,
-                    data: 0,
-                })
+                .subscribe(timeout_socket.0.fd(), EventSource::Time, EventFlags::READ)
                 .unwrap();
 
             let start = Instant::now();
@@ -627,7 +642,7 @@ impl EventLoop {
 
                 if let Some(duration) = instant.checked_duration_since(start) {
                     time.tv_sec += duration.as_secs() as i64;
-                    time.tv_nsec += duration.subsec_nanos() as i32;
+                    time.tv_nsec += duration.subsec_nanos() as i64;
                     // Normalize timespec so tv_nsec is not greater than one second.
                     while time.tv_nsec >= 1_000_000_000 {
                         time.tv_sec += 1;
@@ -639,12 +654,22 @@ impl EventLoop {
             }
 
             // Wait for event if needed.
-            let mut event = syscall::Event::default();
-            self.window_target.event_socket.read(&mut event).unwrap();
+            let event = loop {
+                match self.window_target.event_socket.next_event() {
+                    Ok(event) => break event,
+                    Err(err) if err.is_interrupt() => continue,
+                    Err(err) => {
+                        return Err(os_error!(format!("failed to read event: {err}")).into());
+                    },
+                }
+            };
 
             // TODO: handle spurious wakeups (redraw caused wakeup but redraw already handled)
             match requested_resume {
-                Some(requested_resume) if event.id == timeout_socket.0.fd => {
+                Some(requested_resume)
+                    if event.fd == timeout_socket.0.fd()
+                        && matches!(event.user_data, EventSource::Time) =>
+                {
                     // If the event is from the special timeout socket, report that resume
                     // time was reached.
                     start_cause = StartCause::ResumeTimeReached { start, requested_resume };
@@ -682,6 +707,13 @@ impl EventLoopProxyProvider for EventLoopProxy {
 
 impl Unpin for EventLoopProxy {}
 
+redox_event::user_data! {
+    pub enum EventSource {
+        Orbital,
+        Time,
+    }
+}
+
 #[derive(Debug)]
 pub struct ActiveEventLoop {
     control_flow: Cell<ControlFlow>,
@@ -689,7 +721,7 @@ pub struct ActiveEventLoop {
     pub(super) creates: Mutex<VecDeque<Arc<RedoxSocket>>>,
     pub(super) redraws: Arc<Mutex<VecDeque<WindowId>>>,
     pub(super) destroys: Arc<Mutex<VecDeque<WindowId>>>,
-    pub(super) event_socket: Arc<RedoxSocket>,
+    pub(super) event_socket: Arc<EventQueue<EventSource>>,
     pub(super) event_loop_proxy: Arc<EventLoopProxy>,
 }
 

winit-orbital/src/lib.rs

@@ -3,14 +3,17 @@
 //! Redox OS has some functionality not yet present that will be implemented
 //! when its orbital display server provides it.
 
-use std::{fmt, str};
+use std::fs::{File, OpenOptions};
+use std::io::{Read, Result, Write};
+use std::os::fd::AsRawFd;
+use std::{fmt, mem, slice, str};
+
+use libredox::data::TimeSpec;
 
 pub use self::event_loop::{EventLoop, PlatformSpecificEventLoopAttributes};
 
 macro_rules! os_error {
-    ($error:expr) => {{
-        winit_core::error::OsError::new(line!(), file!(), $error)
-    }};
+    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
 }
 
 pub mod event_loop;
@@ -18,15 +21,11 @@ pub mod window;
 
 #[derive(Debug)]
 struct RedoxSocket {
-    fd: usize,
+    fd: File,
 }
 
 impl RedoxSocket {
-    fn event() -> syscall::Result<Self> {
-        Self::open_raw("/scheme/event")
-    }
-
-    fn orbital(properties: &WindowProperties<'_>) -> syscall::Result<Self> {
+    fn orbital(properties: &WindowProperties<'_>) -> Result<Self> {
         Self::open_raw(&format!("{properties}"))
     }
 
@@ -34,38 +33,27 @@ impl RedoxSocket {
     // 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)?;
+    fn open_raw(path: &str) -> Result<Self> {
+        let fd = OpenOptions::new().read(true).write(true).open(path)?;
         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 fd(&self) -> usize {
+        self.fd.as_raw_fd() as usize
     }
 
-    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 read(&self, buf: &mut [u8]) -> Result<()> {
+        (&self.fd).read_exact(buf)
     }
 
-    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))
+    fn write(&self, buf: &[u8]) -> Result<()> {
+        (&self.fd).write_all(buf)
     }
-}
 
-impl Drop for RedoxSocket {
-    fn drop(&mut self) {
-        let _ = syscall::close(self.fd);
+    fn fpath<'a>(&self, buf: &'a mut [u8]) -> Result<&'a str> {
+        let count = libredox::call::fpath(self.fd(), buf)?;
+        str::from_utf8(&buf[..count])
+            .map_err(|_| std::io::Error::from(std::io::ErrorKind::InvalidData))
     }
 }
 
@@ -73,26 +61,36 @@ impl Drop for RedoxSocket {
 struct TimeSocket(RedoxSocket);
 
 impl TimeSocket {
-    fn open() -> syscall::Result<Self> {
+    fn open() -> Result<Self> {
         RedoxSocket::open_raw("/scheme/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)?;
+    fn current_time(&self) -> Result<TimeSpec> {
+        let mut timespec: libredox::data::TimeSpec = unsafe { mem::zeroed() };
+        let timespec_bytes = unsafe {
+            slice::from_raw_parts_mut(
+                &mut timespec as *mut _ as *mut u8,
+                mem::size_of::<TimeSpec>(),
+            )
+        };
+        self.0.read(timespec_bytes)?;
         Ok(timespec)
     }
 
     // Write a timeout.
-    fn timeout(&self, timespec: &syscall::TimeSpec) -> syscall::Result<()> {
-        self.0.write(timespec)
+    fn timeout(&self, timespec: &TimeSpec) -> Result<()> {
+        let timespec_bytes = unsafe {
+            slice::from_raw_parts(timespec as *const _ as *const u8, mem::size_of::<TimeSpec>())
+        };
+        self.0.write(timespec_bytes)
     }
 
     // Wake immediately.
-    fn wake(&self) -> syscall::Result<()> {
+    fn wake(&self) -> Result<()> {
         // Writing a default TimeSpec will always trigger a time event.
-        self.timeout(&syscall::TimeSpec::default())
+        let timespec: TimeSpec = unsafe { mem::zeroed() };
+        self.timeout(&timespec)
     }
 }
 
@@ -107,7 +105,7 @@ struct WindowProperties<'a> {
 
 impl<'a> WindowProperties<'a> {
     fn new(path: &'a str) -> Self {
-        // orbital:flags/x/y/w/h/t
+        // /scheme/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));

winit-orbital/src/window.rs

@@ -3,13 +3,13 @@ use std::iter;
 use std::sync::{Arc, Mutex};
 
 use dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
-use tracing::warn;
+use redox_event::EventFlags;
 use winit_core::cursor::Cursor;
 use winit_core::error::{NotSupportedError, RequestError};
 use winit_core::monitor::{Fullscreen, MonitorHandle as CoreMonitorHandle};
 use winit_core::window::{self, Window as CoreWindow, WindowId};
 
-use crate::event_loop::{ActiveEventLoop, EventLoopProxy};
+use crate::event_loop::{ActiveEventLoop, EventLoopProxy, EventSource};
 use crate::{RedoxSocket, WindowProperties};
 
 // These values match the values uses in the `window_new` function in orbital:
@@ -104,13 +104,7 @@ impl Window {
         .expect("failed to open window");
 
         // Add to event socket.
-        el.event_socket
-            .write(&syscall::Event {
-                id: window.fd,
-                flags: syscall::EventFlags::EVENT_READ,
-                data: window.fd,
-            })
-            .unwrap();
+        el.event_socket.subscribe(window.fd(), EventSource::Orbital, EventFlags::READ).unwrap();
 
         let window_socket = Arc::new(window);
 
@@ -147,7 +141,7 @@ impl Window {
     #[inline]
     fn raw_window_handle_rwh_06(&self) -> Result<rwh_06::RawWindowHandle, rwh_06::HandleError> {
         let handle = rwh_06::OrbitalWindowHandle::new({
-            let window = self.window_socket.fd as *mut _;
+            let window = self.window_socket.fd() as *mut _;
             std::ptr::NonNull::new(window).expect("orbital fd should never be null")
         });
         Ok(rwh_06::RawWindowHandle::Orbital(handle))
@@ -161,7 +155,7 @@ impl Window {
 
 impl CoreWindow for Window {
     fn id(&self) -> WindowId {
-        WindowId::from_raw(self.window_socket.fd)
+        WindowId::from_raw(self.window_socket.fd())
     }
 
     fn ime_capabilities(&self) -> Option<window::ImeCapabilities> {
@@ -253,17 +247,9 @@ impl CoreWindow for Window {
         PhysicalInsets::new(0, 0, 0, 0)
     }
 
-    fn min_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        None
-    }
-
     #[inline]
     fn set_min_surface_size(&self, _: Option<Size>) {}
 
-    fn max_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        None
-    }
-
     #[inline]
     fn set_max_surface_size(&self, _: Option<Size>) {}
 
@@ -280,19 +266,11 @@ impl CoreWindow for Window {
         self.window_socket.write(format!("T,{title}").as_bytes()).expect("failed to set title");
     }
 
-    fn is_transparent(&self) -> bool {
-        self.get_flag(ORBITAL_FLAG_TRANSPARENT).unwrap_or(false)
-    }
-
     #[inline]
     fn set_transparent(&self, transparent: bool) {
         let _ = self.set_flag(ORBITAL_FLAG_TRANSPARENT, transparent);
     }
 
-    fn is_blurred(&self) -> bool {
-        false
-    }
-
     #[inline]
     fn set_blur(&self, _blur: bool) {}
 
@@ -376,20 +354,6 @@ impl CoreWindow for Window {
         !self.get_flag(ORBITAL_FLAG_BORDERLESS).unwrap_or(false)
     }
 
-    fn window_level(&self) -> window::WindowLevel {
-        let back = self.get_flag(ORBITAL_FLAG_BACK).unwrap_or(false);
-        let front = self.get_flag(ORBITAL_FLAG_FRONT).unwrap_or(false);
-        match (back, front) {
-            (true, false) => window::WindowLevel::AlwaysOnBottom,
-            (false, false) => window::WindowLevel::Normal,
-            (false, true) => window::WindowLevel::AlwaysOnTop,
-            (true, true) => {
-                warn!("unclear back/front window levelling");
-                window::WindowLevel::default()
-            },
-        }
-    }
-
     #[inline]
     fn set_window_level(&self, level: window::WindowLevel) {
         match level {
@@ -406,10 +370,6 @@ impl CoreWindow for Window {
         }
     }
 
-    fn window_icon(&self) -> Option<winit_core::icon::Icon> {
-        None
-    }
-
     #[inline]
     fn set_window_icon(&self, _window_icon: Option<winit_core::icon::Icon>) {}
 
@@ -423,10 +383,6 @@ impl CoreWindow for Window {
     #[inline]
     fn request_user_attention(&self, _request_type: Option<window::UserAttentionType>) {}
 
-    fn cursor(&self) -> Cursor {
-        Cursor::default()
-    }
-
     #[inline]
     fn set_cursor(&self, _: Cursor) {}
 
@@ -509,10 +465,6 @@ impl CoreWindow for Window {
     #[inline]
     fn set_theme(&self, _theme: Option<window::Theme>) {}
 
-    fn content_protected(&self) -> bool {
-        false
-    }
-
     fn set_content_protected(&self, _protected: bool) {}
 
     fn rwh_06_window_handle(&self) -> &dyn rwh_06::HasWindowHandle {

winit-uikit/Cargo.toml

@@ -18,7 +18,6 @@ rwh_06.workspace = true
 serde = { workspace = true, optional = true }
 smol_str.workspace = true
 tracing.workspace = true
-winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }
 winit-core.workspace = true
 
 # Platform-specific
@@ -70,6 +69,7 @@ objc2-ui-kit = { workspace = true, features = [
     "UIViewController",
     "UIWindow",
 ] }
+winit-common = { workspace = true, features = ["core-foundation", "event-handler", "foundation"] }
 
 [package.metadata.docs.rs]
 all-features = true

winit-uikit/src/app_state.rs

@@ -9,11 +9,11 @@ use std::{fmt, ptr};
 
 use dispatch2::MainThreadBound;
 use dpi::PhysicalSize;
-use objc2::rc::Retained;
 use objc2::MainThreadMarker;
+use objc2::rc::Retained;
 use objc2_core_foundation::{
-    kCFRunLoopCommonModes, CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, CGRect,
-    CGSize,
+    CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, CGRect, CGSize,
+    kCFRunLoopCommonModes,
 };
 use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView};
 use winit_common::core_foundation::EventLoopProxy;

winit-uikit/src/event_loop.rs

@@ -1,13 +1,9 @@
-use std::ffi::c_void;
-use std::ptr;
 use std::sync::Arc;
 
 use objc2::rc::Retained;
 use objc2::runtime::ProtocolObject;
-use objc2::{msg_send, ClassType, MainThreadMarker};
-use objc2_core_foundation::{
-    kCFRunLoopDefaultMode, CFIndex, CFRunLoop, CFRunLoopActivity, CFRunLoopObserver,
-};
+use objc2::{ClassType, MainThreadMarker, msg_send};
+use objc2_core_foundation::{CFIndex, CFRunLoopActivity, kCFRunLoopDefaultMode};
 use objc2_foundation::{NSNotificationCenter, NSObjectProtocol};
 use objc2_ui_kit::{
     UIApplication, UIApplicationDidBecomeActiveNotification,
@@ -16,6 +12,9 @@ use objc2_ui_kit::{
     UIApplicationWillResignActiveNotification, UIApplicationWillTerminateNotification, UIScreen,
 };
 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, CustomCursorSource};
 use winit_core::error::{EventLoopError, NotSupportedError, RequestError};
@@ -26,8 +25,7 @@ use winit_core::event_loop::{
 use winit_core::monitor::MonitorHandle as CoreMonitorHandle;
 use winit_core::window::{Theme, Window as CoreWindow};
 
-use super::app_state::{send_occluded_event_for_all_windows, AppState};
-use super::notification_center::create_observer;
+use super::app_state::{AppState, send_occluded_event_for_all_windows};
 use crate::monitor::MonitorHandle;
 use crate::window::Window;
 use crate::{app_state, monitor};
@@ -136,6 +134,11 @@ pub struct EventLoop {
     _did_enter_background_observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,
     _will_terminate_observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,
     _did_receive_memory_warning_observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,
+
+    _tracing_observers: Option<(MainRunLoopObserver, MainRunLoopObserver)>,
+    _wakeup_observer: MainRunLoopObserver,
+    _main_events_cleared_observer: MainRunLoopObserver,
+    _events_cleared_observer: MainRunLoopObserver,
 }
 
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -151,16 +154,14 @@ impl EventLoop {
             return Err(EventLoopError::RecreationAttempt);
         }
 
-        // this line sets up the main run loop before `UIApplicationMain`
-        setup_control_flow_observers();
-
-        let center = unsafe { NSNotificationCenter::defaultCenter() };
+        let center = NSNotificationCenter::defaultCenter();
 
         let _did_finish_launching_observer = create_observer(
             &center,
             // `application:didFinishLaunchingWithOptions:`
             unsafe { UIApplicationDidFinishLaunchingNotification },
             move |_| {
+                let _entered = debug_span!("UIApplicationDidFinishLaunchingNotification").entered();
                 app_state::did_finish_launching(mtm);
             },
         );
@@ -168,20 +169,28 @@ impl EventLoop {
             &center,
             // `applicationDidBecomeActive:`
             unsafe { UIApplicationDidBecomeActiveNotification },
-            move |_| app_state::handle_resumed(mtm),
+            move |_| {
+                let _entered = debug_span!("UIApplicationDidBecomeActiveNotification").entered();
+                app_state::handle_resumed(mtm)
+            },
         );
         let _will_resign_active_observer = create_observer(
             &center,
             // `applicationWillResignActive:`
             unsafe { UIApplicationWillResignActiveNotification },
-            move |_| app_state::handle_suspended(mtm),
+            move |_| {
+                let _entered = debug_span!("UIApplicationWillResignActiveNotification").entered();
+                app_state::handle_suspended(mtm)
+            },
         );
         let _will_enter_foreground_observer = create_observer(
             &center,
             // `applicationWillEnterForeground:`
             unsafe { UIApplicationWillEnterForegroundNotification },
             move |notification| {
-                let app = unsafe { notification.object() }.expect(
+                let _entered =
+                    debug_span!("UIApplicationWillEnterForegroundNotification").entered();
+                let app = notification.object().expect(
                     "UIApplicationWillEnterForegroundNotification to have application object",
                 );
                 // The `object` in `UIApplicationWillEnterForegroundNotification` is documented to
@@ -195,7 +204,8 @@ impl EventLoop {
             // `applicationDidEnterBackground:`
             unsafe { UIApplicationDidEnterBackgroundNotification },
             move |notification| {
-                let app = unsafe { notification.object() }.expect(
+                let _entered = debug_span!("UIApplicationDidEnterBackgroundNotification").entered();
+                let app = notification.object().expect(
                     "UIApplicationDidEnterBackgroundNotification to have application object",
                 );
                 // The `object` in `UIApplicationDidEnterBackgroundNotification` is documented to be
@@ -209,7 +219,9 @@ impl EventLoop {
             // `applicationWillTerminate:`
             unsafe { UIApplicationWillTerminateNotification },
             move |notification| {
-                let app = unsafe { notification.object() }
+                let _entered = debug_span!("UIApplicationWillTerminateNotification").entered();
+                let app = notification
+                    .object()
                     .expect("UIApplicationWillTerminateNotification to have application object");
                 // The `object` in `UIApplicationWillTerminateNotification` is (somewhat) documented
                 // to be `UIApplication`.
@@ -221,9 +233,65 @@ impl EventLoop {
             &center,
             // `applicationDidReceiveMemoryWarning:`
             unsafe { UIApplicationDidReceiveMemoryWarningNotification },
-            move |_| app_state::handle_memory_warning(mtm),
+            move |_| {
+                let _entered =
+                    debug_span!("UIApplicationDidReceiveMemoryWarningNotification").entered();
+                app_state::handle_memory_warning(mtm)
+            },
         );
 
+        let main_loop = MainRunLoop::get(mtm);
+        let mode = unsafe { kCFRunLoopDefaultMode }.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 _wakeup_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::handle_wakeup_transition(mtm),
+        );
+        main_loop.add_observer(&_wakeup_observer, mode);
+
+        let _main_events_cleared_observer = MainRunLoopObserver::new(
+            mtm,
+            CFRunLoopActivity::BeforeWaiting,
+            true,
+            // Core Animation registers its `CFRunLoopObserver` that performs drawing operations in
+            // `CA::Transaction::ensure_implicit` with a priority of `2000000`. We set the
+            // main_end priority to be 0, in order to send `AboutToWait` before `RedrawRequested`.
+            // This value was chosen conservatively to guard against apple using different
+            // priorities for their redraw observers in different OS's or on different devices. If
+            // it so happens that it's too conservative, the main symptom would be non-redraw
+            // events coming in after `AboutToWait`.
+            //
+            // The value of `2000000` was determined by inspecting stack traces and the associated
+            // registers for every `CFRunLoopAddObserver` call on an iPad Air 2 running iOS 11.4.
+            //
+            // Also tested to be `2000000` on iPhone 8, iOS 13 beta 4.
+            0,
+            move |_| app_state::handle_main_events_cleared(mtm),
+        );
+        main_loop.add_observer(&_main_events_cleared_observer, mode);
+
+        let _events_cleared_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::handle_events_cleared(mtm),
+        );
+        main_loop.add_observer(&_events_cleared_observer, mode);
+
         Ok(EventLoop {
             mtm,
             window_target: ActiveEventLoop { mtm },
@@ -234,10 +302,15 @@ impl EventLoop {
             _did_enter_background_observer,
             _will_terminate_observer,
             _did_receive_memory_warning_observer,
+            _tracing_observers,
+            _wakeup_observer,
+            _main_events_cleared_observer,
+            _events_cleared_observer,
         })
     }
 
-    pub fn run_app<A: ApplicationHandler>(self, app: A) -> ! {
+    // Require `'static` for correctness, we won't be able to `Drop` the user's state otherwise.
+    pub fn run_app_never_return<A: ApplicationHandler + 'static>(self, app: A) -> ! {
         let application: Option<Retained<UIApplication>> =
             unsafe { msg_send![UIApplication::class(), sharedApplication] };
         assert!(
@@ -249,6 +322,10 @@ impl EventLoop {
 
         // We intentionally override neither the application nor the delegate,
         // to allow the user to do so themselves!
+        //
+        // NOTE: `UIApplicationMain` is _the only way_ to start the event loop on iOS/UIKit, there
+        // are no other feasible options. See also:
+        // <https://github.com/rust-windowing/winit/pull/4165#issuecomment-2760514167>
         app_state::launch(self.mtm, app, || UIApplication::main(None, None, self.mtm))
     }
 
@@ -256,97 +333,3 @@ impl EventLoop {
         &self.window_target
     }
 }
-
-fn setup_control_flow_observers() {
-    unsafe {
-        // 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,
-            _: *mut c_void,
-        ) {
-            let mtm = MainThreadMarker::new().unwrap();
-            #[allow(non_upper_case_globals)]
-            match activity {
-                CFRunLoopActivity::AfterWaiting => app_state::handle_wakeup_transition(mtm),
-                _ => unreachable!(),
-            }
-        }
-
-        // Core Animation registers its `CFRunLoopObserver` that performs drawing operations in
-        // `CA::Transaction::ensure_implicit` with a priority of `0x1e8480`. We set the main_end
-        // priority to be 0, in order to send AboutToWait before RedrawRequested. This value was
-        // chosen conservatively to guard against apple using different priorities for their redraw
-        // observers in different OS's or on different devices. If it so happens that it's too
-        // conservative, the main symptom would be non-redraw events coming in after `AboutToWait`.
-        //
-        // The value of `0x1e8480` was determined by inspecting stack traces and the associated
-        // registers for every `CFRunLoopAddObserver` call on an iPad Air 2 running iOS 11.4.
-        //
-        // Also tested to be `0x1e8480` on iPhone 8, iOS 13 beta 4.
-        extern "C-unwind" fn control_flow_main_end_handler(
-            _: *mut CFRunLoopObserver,
-            activity: CFRunLoopActivity,
-            _: *mut c_void,
-        ) {
-            let mtm = MainThreadMarker::new().unwrap();
-            #[allow(non_upper_case_globals)]
-            match activity {
-                CFRunLoopActivity::BeforeWaiting => app_state::handle_main_events_cleared(mtm),
-                CFRunLoopActivity::Exit => {}, // may happen when running on macOS
-                _ => unreachable!(),
-            }
-        }
-
-        // end is queued with the lowest priority to ensure it is processed after other observers
-        extern "C-unwind" fn control_flow_end_handler(
-            _: *mut CFRunLoopObserver,
-            activity: CFRunLoopActivity,
-            _: *mut c_void,
-        ) {
-            let mtm = MainThreadMarker::new().unwrap();
-            #[allow(non_upper_case_globals)]
-            match activity {
-                CFRunLoopActivity::BeforeWaiting => app_state::handle_events_cleared(mtm),
-                CFRunLoopActivity::Exit => {}, // may happen when running on macOS
-                _ => unreachable!(),
-            }
-        }
-
-        let main_loop = CFRunLoop::main().unwrap();
-
-        let begin_observer = CFRunLoopObserver::new(
-            None,
-            CFRunLoopActivity::AfterWaiting.0,
-            true,
-            CFIndex::MIN,
-            Some(control_flow_begin_handler),
-            ptr::null_mut(),
-        )
-        .unwrap();
-        main_loop.add_observer(Some(&begin_observer), kCFRunLoopDefaultMode);
-
-        let main_end_observer = CFRunLoopObserver::new(
-            None,
-            (CFRunLoopActivity::Exit | CFRunLoopActivity::BeforeWaiting).0,
-            true,
-            0, // see comment on `control_flow_main_end_handler`
-            Some(control_flow_main_end_handler),
-            ptr::null_mut(),
-        )
-        .unwrap();
-        main_loop.add_observer(Some(&main_end_observer), kCFRunLoopDefaultMode);
-
-        let end_observer = CFRunLoopObserver::new(
-            None,
-            (CFRunLoopActivity::Exit | CFRunLoopActivity::BeforeWaiting).0,
-            true,
-            CFIndex::MAX,
-            Some(control_flow_end_handler),
-            ptr::null_mut(),
-        )
-        .unwrap();
-        main_loop.add_observer(Some(&end_observer), kCFRunLoopDefaultMode);
-    }
-}

winit-uikit/src/lib.rs

@@ -103,7 +103,6 @@
 mod app_state;
 mod event_loop;
 mod monitor;
-mod notification_center;
 mod view;
 mod view_controller;
 mod window;

winit-uikit/src/monitor.rs

@@ -4,10 +4,10 @@ use std::collections::VecDeque;
 use std::num::NonZeroU32;
 use std::{fmt, hash, ptr};
 
-use dispatch2::{run_on_main, MainThreadBound};
+use dispatch2::{MainThreadBound, run_on_main};
 use dpi::PhysicalPosition;
 use objc2::rc::Retained;
-use objc2::{available, MainThreadMarker, Message};
+use objc2::{MainThreadMarker, Message, available};
 use objc2_foundation::NSInteger;
 use objc2_ui_kit::{UIScreen, UIScreenMode};
 use winit_core::monitor::{MonitorHandleProvider, VideoMode};
@@ -190,7 +190,7 @@ impl MonitorHandle {
         Self { ui_screen: MainThreadBound::new(ui_screen, mtm) }
     }
 
-    pub fn video_modes_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
+    pub fn video_modes_handles(&self) -> impl Iterator<Item = VideoModeHandle> + 'static {
         run_on_main(|mtm| {
             let ui_screen = self.ui_screen(mtm);
 
@@ -203,7 +203,7 @@ impl MonitorHandle {
         })
     }
 
-    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> + 'static {
         self.video_modes_handles().map(|handle| handle.mode)
     }
 
@@ -271,8 +271,8 @@ mod tests {
         let main = UIScreen::mainScreen(mtm);
         assert!(UIScreen::screens(mtm).iter().any(|screen| ptr::eq(&*screen, &*main)));
 
-        assert!(unsafe {
+        assert!(
             NSSet::setWithArray(&UIScreen::screens(mtm)).containsObject(&UIScreen::mainScreen(mtm))
-        });
+        );
     }
 }

winit-uikit/src/notification_center.rs

@@ -1 +0,0 @@
-../../winit-appkit/src/notification_center.rs

winit-uikit/src/view.rs

@@ -4,7 +4,7 @@ use std::cell::{Cell, RefCell};
 use dpi::PhysicalPosition;
 use objc2::rc::Retained;
 use objc2::runtime::{NSObjectProtocol, ProtocolObject};
-use objc2::{available, define_class, msg_send, sel, DefinedClass, MainThreadMarker};
+use objc2::{DefinedClass, MainThreadMarker, available, define_class, msg_send, sel};
 use objc2_core_foundation::{CGFloat, CGPoint, CGRect};
 use objc2_foundation::{NSObject, NSSet, NSString};
 use objc2_ui_kit::{
@@ -13,10 +13,10 @@ use objc2_ui_kit::{
     UIResponder, UIRotationGestureRecognizer, UITapGestureRecognizer, UITextInputTraits, UITouch,
     UITouchPhase, UITouchType, UITraitEnvironment, UIView,
 };
-use tracing::debug;
+use tracing::{debug, debug_span, trace_span};
 use winit_core::event::{
-    ButtonSource, ElementState, FingerId, Force, KeyEvent, PointerKind, PointerSource, TouchPhase,
-    WindowEvent,
+    ButtonSource, ElementState, FingerId, Force, KeyEvent, PointerKind, PointerSource,
+    TabletToolAngle, TabletToolButton, TabletToolData, TabletToolKind, TouchPhase, WindowEvent,
 };
 use winit_core::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKeyCode, PhysicalKey};
 
@@ -48,6 +48,7 @@ define_class!(
     impl WinitView {
         #[unsafe(method(drawRect:))]
         fn draw_rect(&self, rect: CGRect) {
+            let _entered = debug_span!("drawRect:").entered();
             let mtm = MainThreadMarker::new().unwrap();
             let window = self.window().unwrap();
             app_state::handle_nonuser_event(mtm, EventWrapper::Window {
@@ -59,6 +60,7 @@ define_class!(
 
         #[unsafe(method(layoutSubviews))]
         fn layout_subviews(&self) {
+            let _entered = debug_span!("layoutSubviews").entered();
             let mtm = MainThreadMarker::new().unwrap();
             let _: () = unsafe { msg_send![super(self), layoutSubviews] };
 
@@ -79,6 +81,7 @@ define_class!(
 
         #[unsafe(method(setContentScaleFactor:))]
         fn set_content_scale_factor(&self, untrusted_scale_factor: CGFloat) {
+            let _entered = debug_span!("setContentScaleFactor:").entered();
             let mtm = MainThreadMarker::new().unwrap();
             let _: () =
                 unsafe { msg_send![super(self), setContentScaleFactor: untrusted_scale_factor] };
@@ -124,6 +127,7 @@ define_class!(
 
         #[unsafe(method(safeAreaInsetsDidChange))]
         fn safe_area_changed(&self) {
+            let _entered = debug_span!("safeAreaInsetsDidChange").entered();
             debug!("safeAreaInsetsDidChange was called, requesting redraw");
             // When the safe area changes we want to make sure to emit a redraw event
             self.setNeedsDisplay();
@@ -131,26 +135,31 @@ define_class!(
 
         #[unsafe(method(touchesBegan:withEvent:))]
         fn touches_began(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            let _entered = debug_span!("touchesBegan:withEvent:").entered();
             self.handle_touches(touches)
         }
 
         #[unsafe(method(touchesMoved:withEvent:))]
         fn touches_moved(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            let _entered = debug_span!("touchesMoved:withEvent:").entered();
             self.handle_touches(touches)
         }
 
         #[unsafe(method(touchesEnded:withEvent:))]
         fn touches_ended(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            let _entered = debug_span!("touchesEnded:withEvent:").entered();
             self.handle_touches(touches)
         }
 
         #[unsafe(method(touchesCancelled:withEvent:))]
         fn touches_cancelled(&self, touches: &NSSet<UITouch>, _event: Option<&UIEvent>) {
+            let _entered = debug_span!("touchesCancelled:withEvent:").entered();
             self.handle_touches(touches)
         }
 
         #[unsafe(method(pinchGesture:))]
         fn pinch_gesture(&self, recognizer: &UIPinchGestureRecognizer) {
+            let _entered = debug_span!("pinchGesture:").entered();
             let window = self.window().unwrap();
 
             let (phase, delta) = match recognizer.state() {
@@ -185,6 +194,7 @@ define_class!(
 
         #[unsafe(method(doubleTapGesture:))]
         fn double_tap_gesture(&self, recognizer: &UITapGestureRecognizer) {
+            let _entered = debug_span!("doubleTapGesture:").entered();
             let window = self.window().unwrap();
 
             if recognizer.state() == UIGestureRecognizerState::Ended {
@@ -200,6 +210,7 @@ define_class!(
 
         #[unsafe(method(rotationGesture:))]
         fn rotation_gesture(&self, recognizer: &UIRotationGestureRecognizer) {
+            let _entered = debug_span!("rotationGesture:").entered();
             let window = self.window().unwrap();
 
             let (phase, delta) = match recognizer.state() {
@@ -244,6 +255,7 @@ define_class!(
 
         #[unsafe(method(panGesture:))]
         fn pan_gesture(&self, recognizer: &UIPanGestureRecognizer) {
+            let _entered = debug_span!("panGesture:").entered();
             let window = self.window().unwrap();
 
             let translation = recognizer.translationInView(Some(self));
@@ -296,6 +308,7 @@ define_class!(
 
         #[unsafe(method(canBecomeFirstResponder))]
         fn can_become_first_responder(&self) -> bool {
+            let _entered = trace_span!("canBecomeFirstResponder").entered();
             true
         }
     }
@@ -309,6 +322,10 @@ define_class!(
             _gesture_recognizer: &UIGestureRecognizer,
             _other_gesture_recognizer: &UIGestureRecognizer,
         ) -> bool {
+            let _entered = trace_span!(
+                "gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:"
+            )
+            .entered();
             true
         }
     }
@@ -318,16 +335,19 @@ define_class!(
     unsafe impl UIKeyInput for WinitView {
         #[unsafe(method(hasText))]
         fn has_text(&self) -> bool {
+            let _entered = debug_span!("hasText").entered();
             true
         }
 
         #[unsafe(method(insertText:))]
         fn insert_text(&self, text: &NSString) {
+            let _entered = debug_span!("insertText:").entered();
             self.handle_insert_text(text)
         }
 
         #[unsafe(method(deleteBackward))]
         fn delete_backward(&self) {
+            let _entered = debug_span!("deleteBackward").entered();
             self.handle_delete_backward()
         }
     }
@@ -463,13 +483,16 @@ impl WinitView {
         for touch in touches {
             let logical_location = touch.locationInView(None);
             let touch_type = touch.r#type();
-            let force = if let UITouchType::Pencil = touch_type {
-                None
-            } else if available!(ios = 9.0, tvos = 9.0, visionos = 1.0) {
-                let trait_collection = self.traitCollection();
-                let touch_capability = trait_collection.forceTouchCapability();
-                // Both the OS _and_ the device need to be checked for force touch support.
-                if touch_capability == UIForceTouchCapability::Available {
+            let force = if available!(ios = 9.0, tvos = 9.0, visionos = 1.0) {
+                let use_force = match touch_type {
+                    UITouchType::Pencil => true,
+                    _ => {
+                        let trait_collection = self.traitCollection();
+                        trait_collection.forceTouchCapability() == UIForceTouchCapability::Available
+                    },
+                };
+
+                if use_force {
                     let force = touch.force();
                     let max_possible_force = touch.maximumPossibleForce();
                     Some(Force::Calibrated {
@@ -525,7 +548,7 @@ impl WinitView {
                             primary,
                             position,
                             kind: if let UITouchType::Pencil = touch_type {
-                                PointerKind::Unknown
+                                PointerKind::TabletTool(TabletToolKind::Pencil)
                             } else {
                                 PointerKind::Touch(finger_id)
                             },
@@ -539,7 +562,12 @@ impl WinitView {
                             state: ElementState::Pressed,
                             position,
                             button: if let UITouchType::Pencil = touch_type {
-                                ButtonSource::Unknown(0)
+                                let tool_data = self.tablet_tool_data_for_pencil(&touch);
+                                ButtonSource::TabletTool {
+                                    kind: TabletToolKind::Pencil,
+                                    button: TabletToolButton::Contact,
+                                    data: tool_data,
+                                }
                             } else {
                                 ButtonSource::Touch { finger_id, force }
                             },
@@ -548,7 +576,11 @@ impl WinitView {
                 },
                 UITouchPhase::Moved => {
                     let (primary, source) = if let UITouchType::Pencil = touch_type {
-                        (true, PointerSource::Unknown)
+                        let tool_data = self.tablet_tool_data_for_pencil(&touch);
+                        (true, PointerSource::TabletTool {
+                            kind: TabletToolKind::Pencil,
+                            data: tool_data,
+                        })
                     } else {
                         (ivars.primary_finger.get().unwrap() == finger_id, PointerSource::Touch {
                             finger_id,
@@ -588,7 +620,12 @@ impl WinitView {
                                 state: ElementState::Released,
                                 position,
                                 button: if let UITouchType::Pencil = touch_type {
-                                    ButtonSource::Unknown(0)
+                                    let tool_data = self.tablet_tool_data_for_pencil(&touch);
+                                    ButtonSource::TabletTool {
+                                        kind: TabletToolKind::Pencil,
+                                        button: TabletToolButton::Contact,
+                                        data: tool_data,
+                                    }
                                 } else {
                                     ButtonSource::Touch { finger_id, force }
                                 },
@@ -603,7 +640,7 @@ impl WinitView {
                             primary,
                             position: Some(position),
                             kind: if let UITouchType::Pencil = touch_type {
-                                PointerKind::Unknown
+                                PointerKind::TabletTool(TabletToolKind::Pencil)
                             } else {
                                 PointerKind::Touch(finger_id)
                             },
@@ -617,6 +654,32 @@ impl WinitView {
         app_state::handle_nonuser_events(mtm, touch_events);
     }
 
+    fn tablet_tool_data_for_pencil(&self, touch: &UITouch) -> TabletToolData {
+        let force = if available!(ios = 9.0, tvos = 9.0, visionos = 1.0) {
+            let force_val = touch.force();
+            let max_force = touch.maximumPossibleForce();
+            Some(Force::Calibrated { force: force_val as _, max_possible_force: max_force as _ })
+        } else {
+            None
+        };
+
+        let angle = if available!(ios = 9.1, tvos = 9.0, visionos = 1.0) {
+            let altitude = touch.altitudeAngle();
+            let azimuth = touch.azimuthAngleInView(Some(self));
+            Some(TabletToolAngle { altitude: altitude as _, azimuth: azimuth as _ })
+        } else {
+            None
+        };
+
+        TabletToolData {
+            force,
+            tangential_force: None, // iOS doesn't provide barrel pressure
+            twist: None,            // iOS doesn't provide rotation/twist
+            tilt: None,             // Will be calculated from angle if needed
+            angle,
+        }
+    }
+
     fn handle_insert_text(&self, text: &NSString) {
         let window = self.window().unwrap();
         let window_id = window.id();

winit-uikit/src/view_controller.rs

@@ -1,12 +1,13 @@
 use std::cell::Cell;
 
 use objc2::rc::Retained;
-use objc2::{available, define_class, msg_send, DefinedClass, MainThreadMarker};
+use objc2::{DefinedClass, MainThreadMarker, available, define_class, msg_send};
 use objc2_foundation::NSObject;
 use objc2_ui_kit::{
     UIDevice, UIInterfaceOrientationMask, UIRectEdge, UIResponder, UIStatusBarStyle,
     UIUserInterfaceIdiom, UIView, UIViewController,
 };
+use tracing::trace_span;
 
 use crate::{ScreenEdge, StatusBarStyle, ValidOrientations, WindowAttributesIos};
 
@@ -28,31 +29,37 @@ define_class!(
     impl WinitViewController {
         #[unsafe(method(shouldAutorotate))]
         fn should_autorotate(&self) -> bool {
+            let _entered = trace_span!("shouldAutorotate").entered();
             true
         }
 
         #[unsafe(method(prefersStatusBarHidden))]
         fn prefers_status_bar_hidden(&self) -> bool {
+            let _entered = trace_span!("prefersStatusBarHidden").entered();
             self.ivars().prefers_status_bar_hidden.get()
         }
 
         #[unsafe(method(preferredStatusBarStyle))]
         fn preferred_status_bar_style(&self) -> UIStatusBarStyle {
+            let _entered = trace_span!("preferredStatusBarStyle").entered();
             self.ivars().preferred_status_bar_style.get()
         }
 
         #[unsafe(method(prefersHomeIndicatorAutoHidden))]
         fn prefers_home_indicator_auto_hidden(&self) -> bool {
+            let _entered = trace_span!("prefersHomeIndicatorAutoHidden").entered();
             self.ivars().prefers_home_indicator_auto_hidden.get()
         }
 
         #[unsafe(method(supportedInterfaceOrientations))]
         fn supported_orientations(&self) -> UIInterfaceOrientationMask {
+            let _entered = trace_span!("supportedInterfaceOrientations").entered();
             self.ivars().supported_orientations.get()
         }
 
         #[unsafe(method(preferredScreenEdgesDeferringSystemGestures))]
         fn preferred_screen_edges_deferring_system_gestures(&self) -> UIRectEdge {
+            let _entered = trace_span!("preferredScreenEdgesDeferringSystemGestures").entered();
             self.ivars().preferred_screen_edges_deferring_system_gestures.get()
         }
     }

winit-uikit/src/window.rs

@@ -9,14 +9,14 @@ use dpi::{
     Position, Size,
 };
 use objc2::rc::Retained;
-use objc2::{available, class, define_class, msg_send, MainThreadMarker};
+use objc2::{MainThreadMarker, available, class, define_class, msg_send};
 use objc2_core_foundation::{CGFloat, CGPoint, CGRect, CGSize};
 use objc2_foundation::{NSObject, NSObjectProtocol};
 use objc2_ui_kit::{
     UIApplication, UICoordinateSpace, UIEdgeInsets, UIResponder, UIScreen,
     UIScreenOverscanCompensation, UIViewController, UIWindow,
 };
-use tracing::{debug, warn};
+use tracing::{debug, debug_span, warn};
 use winit_core::cursor::Cursor;
 use winit_core::error::{NotSupportedError, RequestError};
 use winit_core::event::WindowEvent;
@@ -46,6 +46,7 @@ define_class!(
     impl WinitUIWindow {
         #[unsafe(method(becomeKeyWindow))]
         fn become_key_window(&self) {
+            let _entered = debug_span!("becomeKeyWindow").entered();
             let mtm = MainThreadMarker::new().unwrap();
             app_state::handle_nonuser_event(mtm, EventWrapper::Window {
                 window_id: self.id(),
@@ -56,6 +57,7 @@ define_class!(
 
         #[unsafe(method(resignKeyWindow))]
         fn resign_key_window(&self) {
+            let _entered = debug_span!("resignKeyWindow").entered();
             let mtm = MainThreadMarker::new().unwrap();
             app_state::handle_nonuser_event(mtm, EventWrapper::Window {
                 window_id: self.id(),
@@ -122,20 +124,10 @@ impl Inner {
         debug!("`Window::set_title` is ignored on iOS")
     }
 
-    pub fn is_transparent(&self) -> bool {
-        debug!("`Window::is_transparent` is ignored on iOS");
-        false
-    }
-
     pub fn set_transparent(&self, _transparent: bool) {
         debug!("`Window::set_transparent` is ignored on iOS")
     }
 
-    pub fn is_blurred(&self) -> bool {
-        debug!("`Window::is_blurred` is ignored on iOS");
-        false
-    }
-
     pub fn set_blur(&self, _blur: bool) {
         debug!("`Window::set_blur` is ignored on iOS")
     }
@@ -171,8 +163,7 @@ impl Inner {
 
     pub fn surface_position(&self) -> PhysicalPosition<i32> {
         let view_position = self.view.frame().origin;
-        let position =
-            unsafe { self.window.convertPoint_fromView(view_position, Some(&self.view)) };
+        let position = self.window.convertPoint_fromView(view_position, Some(&self.view));
         let position = LogicalPosition::new(position.x, position.y);
         position.to_physical(self.scale_factor())
     }
@@ -226,20 +217,10 @@ impl Inner {
         insets.to_physical(self.scale_factor())
     }
 
-    pub fn min_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        debug!("`Window::min_surface_size` is ignored on iOS");
-        None
-    }
-
     pub fn set_min_surface_size(&self, _dimensions: Option<Size>) {
         warn!("`Window::set_min_surface_size` is ignored on iOS")
     }
 
-    pub fn max_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        debug!("`Window::max_surface_size` is ignored on iOS");
-        None
-    }
-
     pub fn set_max_surface_size(&self, _dimensions: Option<Size>) {
         warn!("`Window::set_max_surface_size` is ignored on iOS")
     }
@@ -277,11 +258,6 @@ impl Inner {
         self.view.contentScaleFactor() as _
     }
 
-    pub fn cursor(&self) -> Cursor {
-        warn!("`Window::cursor` is ignored on iOS");
-        Cursor::default()
-    }
-
     pub fn set_cursor(&self, _cursor: Cursor) {
         debug!("`Window::set_cursor` ignored on iOS")
     }
@@ -396,20 +372,10 @@ impl Inner {
         true
     }
 
-    pub fn window_level(&self) -> WindowLevel {
-        debug!("`Window::window_level` is ignored on iOS");
-        WindowLevel::default()
-    }
-
     pub fn set_window_level(&self, _level: WindowLevel) {
         warn!("`Window::set_window_level` is ignored on iOS")
     }
 
-    pub fn window_icon(&self) -> Option<Icon> {
-        debug!("`Window::window_icon` is ignored on iOS");
-        None
-    }
-
     pub fn set_window_icon(&self, _icon: Option<Icon>) {
         warn!("`Window::set_window_icon` is ignored on iOS")
     }
@@ -428,9 +394,7 @@ impl Inner {
                 }
                 *current_caps = Some(capabilities);
 
-                unsafe {
-                    self.view.becomeFirstResponder();
-                }
+                self.view.becomeFirstResponder();
             },
             ImeRequest::Update(_) => {
                 if current_caps.is_none() {
@@ -439,9 +403,7 @@ impl Inner {
             },
             ImeRequest::Disable => {
                 *current_caps = None;
-                unsafe {
-                    self.view.resignFirstResponder();
-                }
+                self.view.resignFirstResponder();
             },
         }
 
@@ -497,14 +459,7 @@ impl Inner {
         None
     }
 
-    pub fn content_protected(&self) -> bool {
-        warn!("`Window::content_protected` is ignored on iOS");
-        false
-    }
-
-    pub fn set_content_protected(&self, _protected: bool) {
-        warn!("`Window::set_content_protected` is ignored on iOS");
-    }
+    pub fn set_content_protected(&self, _protected: bool) {}
 
     pub fn has_focus(&self) -> bool {
         self.window.isKeyWindow()
@@ -683,18 +638,10 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.safe_area())
     }
 
-    fn min_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        self.maybe_wait_on_main(|delegate| delegate.min_surface_size())
-    }
-
     fn set_min_surface_size(&self, min_size: Option<Size>) {
         self.maybe_wait_on_main(|delegate| delegate.set_min_surface_size(min_size))
     }
 
-    fn max_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        self.maybe_wait_on_main(|delegate| delegate.max_surface_size())
-    }
-
     fn set_max_surface_size(&self, max_size: Option<Size>) {
         self.maybe_wait_on_main(|delegate| delegate.set_max_surface_size(max_size));
     }
@@ -711,18 +658,10 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.set_title(title));
     }
 
-    fn is_transparent(&self) -> bool {
-        self.maybe_wait_on_main(|delegate| delegate.is_transparent())
-    }
-
     fn set_transparent(&self, transparent: bool) {
         self.maybe_wait_on_main(|delegate| delegate.set_transparent(transparent));
     }
 
-    fn is_blurred(&self) -> bool {
-        self.maybe_wait_on_main(|delegate| delegate.is_blurred())
-    }
-
     fn set_blur(&self, blur: bool) {
         self.maybe_wait_on_main(|delegate| delegate.set_blur(blur));
     }
@@ -783,18 +722,10 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.is_decorated())
     }
 
-    fn window_level(&self) -> WindowLevel {
-        self.maybe_wait_on_main(|delegate| delegate.window_level())
-    }
-
     fn set_window_level(&self, level: WindowLevel) {
         self.maybe_wait_on_main(|delegate| delegate.set_window_level(level));
     }
 
-    fn window_icon(&self) -> Option<Icon> {
-        self.maybe_wait_on_main(|delegate| delegate.window_icon())
-    }
-
     fn set_window_icon(&self, window_icon: Option<Icon>) {
         self.maybe_wait_on_main(|delegate| delegate.set_window_icon(window_icon));
     }
@@ -827,10 +758,6 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.theme())
     }
 
-    fn content_protected(&self) -> bool {
-        self.maybe_wait_on_main(|delegate| delegate.content_protected())
-    }
-
     fn set_content_protected(&self, protected: bool) {
         self.maybe_wait_on_main(|delegate| delegate.set_content_protected(protected));
     }
@@ -839,10 +766,6 @@ impl CoreWindow for Window {
         self.maybe_wait_on_main(|delegate| delegate.title())
     }
 
-    fn cursor(&self) -> Cursor {
-        self.maybe_wait_on_main(|delegate| delegate.cursor())
-    }
-
     fn set_cursor(&self, cursor: Cursor) {
         self.maybe_wait_on_main(|delegate| delegate.set_cursor(cursor));
     }

winit-wayland/Cargo.toml

@@ -14,6 +14,7 @@ default = ["dlopen", "csd-adwaita"]
 csd-adwaita = ["sctk-adwaita", "sctk-adwaita/ab_glyph"]
 csd-adwaita-crossfont = ["sctk-adwaita", "sctk-adwaita/crossfont"]
 csd-adwaita-notitle = ["sctk-adwaita"]
+csd-adwaita-notitlebar = ["csd-adwaita-notitle"]
 dlopen = ["wayland-backend/dlopen"]
 serde = ["dep:serde", "bitflags/serde", "smol_str/serde", "dpi/serde"]
 
@@ -28,17 +29,19 @@ tracing.workspace = true
 winit-core.workspace = true
 
 # Platform-specific
-ahash.workspace = true
 calloop.workspace = true
+foldhash.workspace = true
 libc.workspace = true
 memmap2.workspace = true
 rustix = { workspace = true, features = ["std", "system", "thread", "process", "event", "pipe"] }
-sctk.workspace = true
-sctk-adwaita = { workspace = true, optional = true }
-wayland-backend.workspace = true
-wayland-client.workspace = true
-wayland-protocols.workspace = true
-wayland-protocols-plasma.workspace = true
+sctk = { package = "smithay-client-toolkit", version = "0.20.0", default-features = false, features = [
+    "calloop",
+] }
+sctk-adwaita = { version = "0.11.0", default-features = false, optional = true }
+wayland-backend = { version = "0.3.10", default-features = false, features = ["client_system"] }
+wayland-client = "0.31.10"
+wayland-protocols = { version = "0.32.11", features = ["staging", "unstable"] }
+wayland-protocols-plasma = { version = "0.3.8", features = ["client"] }
 winit-common = { workspace = true, features = ["xkb", "wayland"] }
 
 [package.metadata.docs.rs]

winit-wayland/src/event_loop/mod.rs

@@ -15,7 +15,7 @@ use dpi::LogicalSize;
 use rustix::event::{PollFd, PollFlags};
 use rustix::pipe::{self, PipeFlags};
 use sctk::reexports::calloop_wayland_source::WaylandSource;
-use sctk::reexports::client::{globals, Connection, QueueHandle};
+use sctk::reexports::client::{Connection, QueueHandle, globals};
 use tracing::warn;
 use winit_core::application::ApplicationHandler;
 use winit_core::cursor::{CustomCursor as CoreCustomCursor, CustomCursorSource};
@@ -41,7 +41,7 @@ pub use winit_core::event_loop::EventLoopProxy as CoreEventLoopProxy;
 use super::output::MonitorHandle;
 use super::state::{WindowCompositorUpdate, WinitState};
 use super::window::state::FrameCallbackState;
-use super::{logical_to_physical_rounded, WindowId};
+use super::{WindowId, logical_to_physical_rounded};
 
 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;
 
@@ -169,10 +169,6 @@ impl EventLoop {
         Ok(event_loop)
     }
 
-    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,
@@ -639,7 +635,7 @@ impl RootActiveEventLoop for ActiveEventLoop {
         let cursor_image = match cursor {
             CustomCursorSource::Image(cursor_image) => cursor_image,
             CustomCursorSource::Animation { .. } | CustomCursorSource::Url { .. } => {
-                return Err(NotSupportedError::new("unsupported cursor kind").into())
+                return Err(NotSupportedError::new("unsupported cursor kind").into());
             },
         };
 

winit-wayland/src/lib.rs

@@ -13,12 +13,16 @@
 //! * `wayland-csd-adwaita` (default).
 //! * `wayland-csd-adwaita-crossfont`.
 //! * `wayland-csd-adwaita-notitle`.
+//! * `wayland-csd-adwaita-notitlebar`.
+
+#![allow(clippy::mutable_key_type)]
+
 use std::ffi::c_void;
 use std::ptr::NonNull;
 
 use dpi::{LogicalSize, PhysicalSize};
-use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::Proxy;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::shm::slot::{Buffer, CreateBufferError, SlotPool};
 use wayland_client::protocol::wl_shm::Format;
 use winit_core::event_loop::ActiveEventLoop as CoreActiveEventLoop;
@@ -27,9 +31,7 @@ use winit_core::window::{
 };
 
 macro_rules! os_error {
-    ($error:expr) => {{
-        winit_core::error::OsError::new(line!(), file!(), $error)
-    }};
+    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
 }
 
 mod event_loop;
@@ -61,7 +63,7 @@ pub trait EventLoopExtWayland {
     fn is_wayland(&self) -> bool;
 }
 
-/// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
+/// Additional methods when building event loop that are specific to Wayland.
 pub trait EventLoopBuilderExtWayland {
     /// Force using Wayland.
     fn with_wayland(&mut self) -> &mut Self;
@@ -99,6 +101,7 @@ pub(crate) struct ApplicationName {
 pub struct WindowAttributesWayland {
     pub(crate) name: Option<ApplicationName>,
     pub(crate) activation_token: Option<ActivationToken>,
+    pub(crate) prefer_csd: bool,
 }
 
 impl WindowAttributesWayland {
@@ -120,6 +123,18 @@ impl WindowAttributesWayland {
         self.activation_token = Some(token);
         self
     }
+
+    /// Builds the window with a given preference for client-side decorations.
+    ///
+    /// When set to `true`, the window will tell the compositor that it prefers
+    /// client-side decorations, even if server-side decorations are available.
+    /// When set to `false` (the default), the window will indicate a preference
+    /// for server-side decorations.
+    #[inline]
+    pub fn with_prefer_csd(mut self, prefer_csd: bool) -> Self {
+        self.prefer_csd = prefer_csd;
+        self
+    }
 }
 
 impl PlatformWindowAttributes for WindowAttributesWayland {

winit-wayland/src/output.rs

@@ -3,8 +3,8 @@ use std::num::NonZeroU32;
 
 use dpi::{LogicalPosition, PhysicalPosition};
 use sctk::output::{Mode, OutputData};
-use sctk::reexports::client::protocol::wl_output::WlOutput;
 use sctk::reexports::client::Proxy;
+use sctk::reexports::client::protocol::wl_output::WlOutput;
 use winit_core::monitor::{MonitorHandleProvider as CoreMonitorHandle, VideoMode};
 
 #[derive(Clone, Debug)]

winit-wayland/src/seat/keyboard/mod.rs

@@ -15,9 +15,9 @@ use winit_common::xkb::Context;
 use winit_core::event::{ElementState, WindowEvent};
 use winit_core::keyboard::ModifiersState;
 
+use crate::WindowId;
 use crate::event_loop::sink::EventSink;
 use crate::state::WinitState;
-use crate::WindowId;
 
 impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
     fn event(
@@ -129,20 +129,23 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                     state.events_sink.push_window_event(WindowEvent::Focused(false), window_id);
                 }
             },
-            WlKeyboardEvent::Key { key, state: WEnum::Value(WlKeyState::Pressed), .. } => {
+            WlKeyboardEvent::Key { key, state: WEnum::Value(key_state), .. }
+                if matches!(key_state, WlKeyState::Repeated | WlKeyState::Pressed) =>
+            {
                 let key = key + 8;
-
                 key_input(
                     keyboard_state,
                     &mut state.events_sink,
                     data,
                     key,
                     ElementState::Pressed,
-                    false,
+                    key_state == WlKeyState::Repeated,
                 );
 
                 let delay = match keyboard_state.repeat_info {
                     RepeatInfo::Repeat { delay, .. } => delay,
+                    // When compositor handles repeat, and thus we have `repeat = true`, we have
+                    // repeat on our side disabled, if it's not true, it's a compositor bug.
                     RepeatInfo::Disable => return,
                 };
 

winit-wayland/src/seat/mod.rs

@@ -2,7 +2,7 @@
 
 use std::sync::Arc;
 
-use ahash::AHashMap;
+use foldhash::HashMap;
 use sctk::reexports::client::backend::ObjectId;
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
 use sctk::reexports::client::protocol::wl_touch::WlTouch;
@@ -12,6 +12,9 @@ use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::
 use sctk::seat::pointer::{ThemeSpec, ThemedPointer};
 use sctk::seat::{Capability as SeatCapability, SeatHandler, SeatState};
 use tracing::warn;
+use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_hold_v1::ZwpPointerGestureHoldV1;
+use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_pinch_v1::ZwpPointerGesturePinchV1;
+use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2;
 use winit_core::event::WindowEvent;
 use winit_core::keyboard::ModifiersState;
 
@@ -23,6 +26,7 @@ mod text_input;
 mod touch;
 
 use keyboard::{KeyboardData, KeyboardState};
+pub use pointer::pointer_gesture::{PointerGestureData, PointerGesturesState};
 pub use pointer::relative_pointer::RelativePointerState;
 pub use pointer::{PointerConstraintsState, WinitPointerData, WinitPointerDataExt};
 use text_input::TextInputData;
@@ -40,7 +44,7 @@ pub struct WinitSeatState {
     touch: Option<WlTouch>,
 
     /// The mapping from touched points to the surfaces they're present.
-    touch_map: AHashMap<i32, TouchPoint>,
+    touch_map: HashMap<i32, TouchPoint>,
 
     /// Id of the first touch event.
     first_touch_id: Option<i32>,
@@ -48,9 +52,18 @@ pub struct WinitSeatState {
     /// The text input bound on the seat.
     text_input: Option<Arc<ZwpTextInputV3>>,
 
+    /// The tablet input bound on the seat.
+    tablet: Option<Arc<ZwpTabletSeatV2>>,
+
     /// The relative pointer bound on the seat.
     relative_pointer: Option<ZwpRelativePointerV1>,
 
+    /// The pinch pointer gesture bound on the seat.
+    pointer_gesture_pinch: Option<ZwpPointerGesturePinchV1>,
+
+    /// The hold pointer gesture bound on the seat.
+    pointer_gesture_hold: Option<ZwpPointerGestureHoldV1>,
+
     /// The keyboard bound on the seat.
     keyboard_state: Option<KeyboardState>,
 
@@ -124,6 +137,22 @@ impl SeatHandler for WinitState {
                     )
                 });
 
+                seat_state.pointer_gesture_pinch = self.pointer_gestures.as_ref().map(|manager| {
+                    manager.get_pinch_gesture(
+                        themed_pointer.pointer(),
+                        queue_handle,
+                        PointerGestureData::default(),
+                    )
+                });
+
+                seat_state.pointer_gesture_hold = self.pointer_gestures.as_ref().map(|manager| {
+                    manager.get_hold_gesture(
+                        themed_pointer.pointer(),
+                        queue_handle,
+                        PointerGestureData::default(),
+                    )
+                });
+
                 let themed_pointer = Arc::new(themed_pointer);
 
                 // Register cursor surface.
@@ -143,6 +172,12 @@ impl SeatHandler for WinitState {
                 TextInputData::default(),
             )));
         }
+
+        if let Some(tablet_state) =
+            seat_state.tablet.is_none().then_some(self.tablet_state.as_ref()).flatten()
+        {
+            seat_state.tablet = Some(Arc::new(tablet_state.get_tablet_seat(&seat, queue_handle)));
+        }
     }
 
     fn remove_capability(
@@ -164,6 +199,11 @@ impl SeatHandler for WinitState {
             text_input.destroy();
         }
 
+        // NOTE: figure out when this should actually be destroyed.
+        if let Some(tablet) = seat_state.tablet.take() {
+            tablet.destroy();
+        }
+
         match capability {
             SeatCapability::Touch => {
                 if let Some(touch) = seat_state.touch.take() {
@@ -177,6 +217,14 @@ impl SeatHandler for WinitState {
                     relative_pointer.destroy();
                 }
 
+                if let Some(pointer_gesture_pinch) = seat_state.pointer_gesture_pinch.take() {
+                    pointer_gesture_pinch.destroy();
+                }
+
+                if let Some(pointer_gesture_hold) = seat_state.pointer_gesture_hold.take() {
+                    pointer_gesture_hold.destroy();
+                }
+
                 if let Some(pointer) = seat_state.pointer.take() {
                     let pointer_data = pointer.pointer().winit_data();
 

winit-wayland/src/seat/pointer/mod.rs

@@ -30,12 +30,13 @@ use sctk::seat::SeatState;
 use dpi::{LogicalPosition, PhysicalPosition};
 use winit_core::event::{
     ElementState, MouseButton, MouseScrollDelta, PointerKind, PointerSource, TouchPhase,
-    WindowEvent,
+    WindowEvent, ButtonSource,
 };
 
 use crate::state::WinitState;
 use crate::WindowId;
 
+pub mod pointer_gesture;
 pub mod relative_pointer;
 
 impl PointerHandler for WinitState {
@@ -107,8 +108,8 @@ impl PointerHandler for WinitState {
                     if parent_surface != surface =>
                 {
                     let click = match wayland_button_to_winit(button) {
-                        MouseButton::Left => FrameClick::Normal,
-                        MouseButton::Right => FrameClick::Alternate,
+                        ButtonSource::Mouse(MouseButton::Left) => FrameClick::Normal,
+                        ButtonSource::Mouse(MouseButton::Right) => FrameClick::Alternate,
                         _ => continue,
                     };
                     let pressed = matches!(kind, PointerEventKind::Press { .. });
@@ -185,7 +186,7 @@ impl PointerHandler for WinitState {
                             device_id: None,
                             state,
                             position,
-                            button: button.into(),
+                            button,
                         },
                         window_id,
                     );
@@ -194,6 +195,7 @@ impl PointerHandler for WinitState {
                     // Get the current phase.
                     let mut pointer_data = pointer.winit_data().inner.lock().unwrap();
 
+                    let has_value120_scroll = horizontal.value120 != 0 || vertical.value120 != 0;
                     let has_discrete_scroll = horizontal.discrete != 0 || vertical.discrete != 0;
 
                     // Figure out what to do about start/ended phases here.
@@ -205,7 +207,7 @@ impl PointerHandler for WinitState {
                     } else {
                         match pointer_data.phase {
                             // Discrete scroll only results in moved events.
-                            _ if has_discrete_scroll => TouchPhase::Moved,
+                            _ if has_value120_scroll || has_discrete_scroll => TouchPhase::Moved,
                             TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
                             _ => TouchPhase::Started,
                         }
@@ -216,7 +218,13 @@ impl PointerHandler for WinitState {
 
                     // Mice events have both pixel and discrete delta's at the same time. So prefer
                     // the discrete values if they are present.
-                    let delta = if has_discrete_scroll {
+                    let delta = if has_value120_scroll {
+                        // NOTE: Wayland sign convention is the inverse of winit.
+                        MouseScrollDelta::LineDelta(
+                            (-horizontal.value120) as f32 / 120.,
+                            (-vertical.value120) as f32 / 120.,
+                        )
+                    } else if has_discrete_scroll {
                         // NOTE: Wayland sign convention is the inverse of winit.
                         MouseScrollDelta::LineDelta(
                             (-horizontal.discrete) as f32,
@@ -401,23 +409,16 @@ impl Default for WinitPointerDataInner {
 }
 
 /// Convert the Wayland button into winit.
-fn wayland_button_to_winit(button: u32) -> MouseButton {
+fn wayland_button_to_winit(button: u32) -> ButtonSource {
     // These values are coming from <linux/input-event-codes.h>.
-    const BTN_LEFT: u32 = 0x110;
-    const BTN_RIGHT: u32 = 0x111;
-    const BTN_MIDDLE: u32 = 0x112;
-    const BTN_SIDE: u32 = 0x113;
-    const BTN_EXTRA: u32 = 0x114;
-    const BTN_FORWARD: u32 = 0x115;
-    const BTN_BACK: u32 = 0x116;
+    const BTN_MOUSE: u32 = 0x110;
+    const BTN_JOYSTICK: u32 = 0x120;
 
-    match button {
-        BTN_LEFT => MouseButton::Left,
-        BTN_RIGHT => MouseButton::Right,
-        BTN_MIDDLE => MouseButton::Middle,
-        BTN_BACK | BTN_SIDE => MouseButton::Back,
-        BTN_FORWARD | BTN_EXTRA => MouseButton::Forward,
-        button => MouseButton::Other(button as u16),
+    if (BTN_MOUSE..BTN_JOYSTICK).contains(&button) {
+        // Mapping orders match
+        MouseButton::try_from_u8((button - BTN_MOUSE) as u8).unwrap().into()
+    } else {
+        ButtonSource::Unknown(button as u16)
     }
 }
 

winit-wayland/src/seat/pointer/pointer_gesture.rs

@@ -0,0 +1,204 @@
+use std::ops::Deref;
+use std::sync::Mutex;
+
+use dpi::{LogicalPosition, PhysicalPosition};
+use sctk::compositor::SurfaceData;
+use sctk::globals::GlobalData;
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use sctk::reexports::protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_pinch_v1::{
+    Event as PinchEvent, ZwpPointerGesturePinchV1,
+};
+use sctk::reexports::protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gestures_v1::ZwpPointerGesturesV1;
+use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_hold_v1::{
+    Event as HoldEvent, ZwpPointerGestureHoldV1,
+};
+use winit_core::event::{TouchPhase, WindowEvent};
+use winit_core::window::WindowId;
+
+use crate::state::WinitState;
+
+/// Wrapper around the pointer gesture.
+#[derive(Debug)]
+pub struct PointerGesturesState {
+    pointer_gestures: ZwpPointerGesturesV1,
+}
+
+impl PointerGesturesState {
+    /// Create a new pointer gesture
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let pointer_gestures = globals.bind(queue_handle, 3..=3, GlobalData)?;
+        Ok(Self { pointer_gestures })
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct PointerGestureData {
+    inner: Mutex<PointerGestureDataInner>,
+}
+
+#[derive(Debug)]
+pub struct PointerGestureDataInner {
+    window_id: Option<WindowId>,
+    previous_pinch: f64,
+}
+
+impl Default for PointerGestureDataInner {
+    fn default() -> Self {
+        Self { window_id: Default::default(), previous_pinch: 1.0 }
+    }
+}
+
+impl Deref for PointerGesturesState {
+    type Target = ZwpPointerGesturesV1;
+
+    fn deref(&self) -> &Self::Target {
+        &self.pointer_gestures
+    }
+}
+
+impl Dispatch<ZwpPointerGesturesV1, GlobalData, WinitState> for PointerGesturesState {
+    fn event(
+        _state: &mut WinitState,
+        _proxy: &ZwpPointerGesturesV1,
+        _event: <ZwpPointerGesturesV1 as wayland_client::Proxy>::Event,
+        _data: &GlobalData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+        unreachable!("zwp_pointer_gestures_v1 has no events")
+    }
+}
+
+impl Dispatch<ZwpPointerGestureHoldV1, PointerGestureData, WinitState> for PointerGesturesState {
+    fn event(
+        state: &mut WinitState,
+        _proxy: &ZwpPointerGestureHoldV1,
+        event: <ZwpPointerGestureHoldV1 as wayland_client::Proxy>::Event,
+        data: &PointerGestureData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+        let mut pointer_gesture_data = data.inner.lock().unwrap();
+        let (window_id, phase) = match event {
+            HoldEvent::Begin { surface, fingers, .. } => {
+                if fingers < 2 {
+                    return;
+                }
+
+                let window_id = crate::make_wid(&surface);
+                pointer_gesture_data.window_id = Some(window_id);
+
+                (window_id, TouchPhase::Started)
+            },
+            HoldEvent::End { cancelled, .. } => {
+                let window_id = match pointer_gesture_data.window_id {
+                    Some(window_id) => window_id,
+                    _ => return,
+                };
+
+                // Reset the state.
+                *pointer_gesture_data = Default::default();
+
+                let phase = if cancelled == 0 { TouchPhase::Ended } else { TouchPhase::Cancelled };
+
+                (window_id, phase)
+            },
+            _ => return,
+        };
+
+        state
+            .events_sink
+            .push_window_event(WindowEvent::HoldGesture { device_id: None, phase }, window_id);
+    }
+}
+
+impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for PointerGesturesState {
+    fn event(
+        state: &mut WinitState,
+        _proxy: &ZwpPointerGesturePinchV1,
+        event: <ZwpPointerGesturePinchV1 as Proxy>::Event,
+        data: &PointerGestureData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+        let mut pointer_gesture_data = data.inner.lock().unwrap();
+        let (window_id, phase, pan_delta, pinch_delta, rotation_delta) = match event {
+            PinchEvent::Begin { surface, fingers, .. } => {
+                // We only support two fingers for now.
+                if fingers != 2 {
+                    return;
+                }
+
+                // Don't handle events from a subsurface.
+                if surface.data::<SurfaceData>().is_none_or(|data| data.parent_surface().is_some())
+                {
+                    return;
+                }
+
+                let window_id = crate::make_wid(&surface);
+
+                pointer_gesture_data.window_id = Some(window_id);
+                pointer_gesture_data.previous_pinch = 1.;
+
+                (window_id, TouchPhase::Started, PhysicalPosition::new(0., 0.), 0., 0.)
+            },
+            PinchEvent::Update { dx, dy, scale: pinch, rotation, .. } => {
+                let window_id = match pointer_gesture_data.window_id {
+                    Some(window_id) => window_id,
+                    _ => return,
+                };
+
+                let scale_factor = match state.windows.get_mut().get_mut(&window_id) {
+                    Some(window) => window.lock().unwrap().scale_factor(),
+                    None => return,
+                };
+
+                let pan_delta =
+                    LogicalPosition::new(dx as f32, dy as f32).to_physical(scale_factor);
+
+                let pinch_delta = pinch - pointer_gesture_data.previous_pinch;
+                pointer_gesture_data.previous_pinch = pinch;
+
+                // Wayland provides rotation in degrees cw, opposite of winit's degrees ccw.
+                let rotation_delta = -rotation as f32;
+                (window_id, TouchPhase::Moved, pan_delta, pinch_delta, rotation_delta)
+            },
+            PinchEvent::End { cancelled, .. } => {
+                let window_id = match pointer_gesture_data.window_id {
+                    Some(window_id) => window_id,
+                    _ => return,
+                };
+
+                // Reset the state.
+                *pointer_gesture_data = Default::default();
+
+                let phase = if cancelled == 0 { TouchPhase::Ended } else { TouchPhase::Cancelled };
+                (window_id, phase, PhysicalPosition::new(0., 0.), 0., 0.)
+            },
+            _ => unreachable!("Unknown event {event:?}"),
+        };
+
+        // The chance of only one of these events being necessary is extremely small,
+        // so it is easier to just send all three
+        state.events_sink.push_window_event(
+            WindowEvent::PanGesture { device_id: None, delta: pan_delta, phase },
+            window_id,
+        );
+        state.events_sink.push_window_event(
+            WindowEvent::PinchGesture { device_id: None, delta: pinch_delta, phase },
+            window_id,
+        );
+        state.events_sink.push_window_event(
+            WindowEvent::RotationGesture { device_id: None, delta: rotation_delta, phase },
+            window_id,
+        );
+    }
+}
+
+delegate_dispatch!(WinitState: [ZwpPointerGesturesV1: GlobalData] => PointerGesturesState);
+delegate_dispatch!(WinitState: [ZwpPointerGesturePinchV1: PointerGestureData] => PointerGesturesState);
+delegate_dispatch!(WinitState: [ZwpPointerGestureHoldV1: PointerGestureData] => PointerGesturesState);

winit-wayland/src/seat/text_input/mod.rs

@@ -4,14 +4,16 @@ use dpi::{LogicalPosition, LogicalSize};
 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::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
 use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
 use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::{
     ContentHint, ContentPurpose, Event as TextInputEvent, ZwpTextInputV3,
 };
 use tracing::warn;
 use winit_core::event::{Ime, WindowEvent};
-use winit_core::window::{ImeCapabilities, ImePurpose, ImeRequestData, ImeSurroundingText};
+use winit_core::window::{
+    ImeCapabilities, ImeHint, ImePurpose, ImeRequestData, ImeSurroundingText,
+};
 
 use crate::state::WinitState;
 
@@ -82,6 +84,7 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
             },
             TextInputEvent::Leave { surface } => {
                 text_input_data.surface = None;
+                text_input_data.last_preedit_empty = true;
 
                 // Always issue a disable.
                 text_input.disable();
@@ -127,6 +130,13 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
                     None => return,
                 };
 
+                // Just in case some IME sends an event for the disabled window.
+                if let Some(window) = windows.get(&window_id) {
+                    if window.lock().unwrap().text_input_state().is_none() {
+                        return;
+                    }
+                };
+
                 // The events are sent to the user separately, so
                 // CAUTION: events must always arrive in the order compatible with the application
                 // order specified by the text-input-v3 protocol:
@@ -140,7 +150,7 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
                 // 6. Place cursor inside preedit text.
 
                 if let Some(DeleteSurroundingText { before, after }) =
-                    text_input_data.pending_delete
+                    text_input_data.pending_delete.take()
                 {
                     state.events_sink.push_window_event(
                         WindowEvent::Ime(Ime::DeleteSurrounding {
@@ -151,14 +161,17 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
                     );
                 }
 
-                // Clear preedit, unless all we'll be doing next is sending a new preedit.
+                // Clear preedit, unless all we'll be doing next is sending a new preedit and
+                // the last preedit wasn't empty.
                 if text_input_data.pending_commit.is_some()
-                    || text_input_data.pending_preedit.is_none()
+                    || (text_input_data.pending_preedit.is_none()
+                        && !text_input_data.last_preedit_empty)
                 {
                     state.events_sink.push_window_event(
                         WindowEvent::Ime(Ime::Preedit(String::new(), None)),
                         window_id,
                     );
+                    text_input_data.last_preedit_empty = true;
                 }
 
                 // Send `Commit`.
@@ -173,6 +186,7 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
                     let cursor_range =
                         preedit.cursor_begin.map(|b| (b, preedit.cursor_end.unwrap_or(b)));
 
+                    text_input_data.last_preedit_empty = false;
                     state.events_sink.push_window_event(
                         WindowEvent::Ime(Ime::Preedit(preedit.text, cursor_range)),
                         window_id,
@@ -236,7 +250,6 @@ pub struct TextInputData {
     inner: std::sync::Mutex<TextInputDataInner>,
 }
 
-#[derive(Default)]
 pub struct TextInputDataInner {
     /// The `WlSurface` we're performing input to.
     surface: Option<WlSurface>,
@@ -249,6 +262,21 @@ pub struct TextInputDataInner {
 
     /// The text around the cursor to delete on `done`
     pending_delete: Option<DeleteSurroundingText>,
+
+    /// Last preedit empty.
+    last_preedit_empty: bool,
+}
+
+impl Default for TextInputDataInner {
+    fn default() -> Self {
+        Self {
+            surface: None,
+            pending_commit: None,
+            pending_preedit: None,
+            pending_delete: None,
+            last_preedit_empty: true,
+        }
+    }
 }
 
 /// The state of the preedit.
@@ -278,9 +306,7 @@ struct DeleteSurroundingText {
 #[derive(Debug, PartialEq, Clone)]
 pub struct ClientState {
     capabilities: ImeCapabilities,
-
     content_type: ContentType,
-
     /// The IME cursor area which should not be covered by the input method popup.
     cursor_area: (LogicalPosition<u32>, LogicalSize<u32>),
 
@@ -302,8 +328,10 @@ impl ClientState {
             surrounding_text: ImeSurroundingText::new(String::new(), 0, 0).unwrap(),
         };
 
-        let unsupported_flags =
-            capabilities.without_purpose().without_cursor_area().without_surrounding_text();
+        let unsupported_flags = capabilities
+            .without_hint_and_purpose()
+            .without_cursor_area()
+            .without_surrounding_text();
 
         if unsupported_flags != ImeCapabilities::new() {
             warn!(
@@ -322,12 +350,10 @@ impl ClientState {
 
     /// Updates the fields of the state which are present in update_fields.
     pub fn update(&mut self, request_data: ImeRequestData, scale_factor: f64) {
-        if let Some(purpose) = request_data.purpose {
-            if self.capabilities.purpose() {
-                self.content_type = purpose.into();
-            } else {
-                warn!("discarding ImePurpose update without capability enabled.");
-            }
+        if let Some((hint, purpose)) =
+            request_data.hint_and_purpose.filter(|_| self.capabilities.hint_and_purpose())
+        {
+            self.content_type = (hint, purpose).into();
         }
 
         if let Some((position, size)) = request_data.cursor_area {
@@ -350,7 +376,7 @@ impl ClientState {
     }
 
     pub fn content_type(&self) -> Option<ContentType> {
-        self.capabilities.purpose().then_some(self.content_type)
+        self.capabilities.hint_and_purpose().then_some(self.content_type)
     }
 
     pub fn cursor_area(&self) -> Option<(LogicalPosition<u32>, LogicalSize<u32>)> {
@@ -365,20 +391,69 @@ impl ClientState {
 /// Arguments to content_type
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ContentType {
-    /// Text input purpose
-    purpose: ContentPurpose,
+    /// Text input hint.
     hint: ContentHint,
+    /// Text input purpose.
+    purpose: ContentPurpose,
 }
 
-impl From<ImePurpose> for ContentType {
-    fn from(purpose: ImePurpose) -> Self {
-        let (hint, purpose) = match purpose {
-            ImePurpose::Password => (ContentHint::SensitiveData, ContentPurpose::Password),
-            ImePurpose::Terminal => (ContentHint::None, ContentPurpose::Terminal),
-            _ => return Default::default(),
+/// The two options influence each other, so they must be converted together.
+impl From<(ImeHint, ImePurpose)> for ContentType {
+    fn from((hint, purpose): (ImeHint, ImePurpose)) -> Self {
+        let purpose = match purpose {
+            ImePurpose::Password => ContentPurpose::Password,
+            ImePurpose::Terminal => ContentPurpose::Terminal,
+            ImePurpose::Phone => ContentPurpose::Phone,
+            ImePurpose::Number => ContentPurpose::Number,
+            ImePurpose::Url => ContentPurpose::Url,
+            ImePurpose::Email => ContentPurpose::Email,
+            ImePurpose::Pin => ContentPurpose::Pin,
+            ImePurpose::Date => ContentPurpose::Date,
+            ImePurpose::Time => ContentPurpose::Time,
+            ImePurpose::DateTime => ContentPurpose::Datetime,
+            _ => ContentPurpose::Normal,
         };
 
-        Self { hint, purpose }
+        let base_hint = match purpose {
+            // Before the hint API was introduced, password  purpose guaranteed the
+            // sensitive hint. Keep this behaviour for the sake of backwards compatibility.
+            ContentPurpose::Password | ContentPurpose::Pin => ContentHint::SensitiveData,
+            _ => ContentHint::None,
+        };
+
+        let mut new_hint = base_hint;
+        if hint.contains(ImeHint::COMPLETION) {
+            new_hint |= ContentHint::Completion;
+        }
+        if hint.contains(ImeHint::SPELLCHECK) {
+            new_hint |= ContentHint::Spellcheck;
+        }
+        if hint.contains(ImeHint::AUTO_CAPITALIZATION) {
+            new_hint |= ContentHint::AutoCapitalization;
+        }
+        if hint.contains(ImeHint::LOWERCASE) {
+            new_hint |= ContentHint::Lowercase;
+        }
+        if hint.contains(ImeHint::UPPERCASE) {
+            new_hint |= ContentHint::Uppercase;
+        }
+        if hint.contains(ImeHint::TITLECASE) {
+            new_hint |= ContentHint::Titlecase;
+        }
+        if hint.contains(ImeHint::HIDDEN_TEXT) {
+            new_hint |= ContentHint::HiddenText;
+        }
+        if hint.contains(ImeHint::SENSITIVE_DATA) {
+            new_hint |= ContentHint::SensitiveData;
+        }
+        if hint.contains(ImeHint::LATIN) {
+            new_hint |= ContentHint::Latin;
+        }
+        if hint.contains(ImeHint::MULTILINE) {
+            new_hint |= ContentHint::Multiline;
+        }
+
+        Self { hint: new_hint, purpose }
     }
 }
 

winit-wayland/src/state.rs

@@ -2,7 +2,7 @@ use std::cell::RefCell;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
 
-use ahash::AHashMap;
+use foldhash::HashMap;
 use sctk::compositor::{CompositorHandler, CompositorState};
 use sctk::output::{OutputHandler, OutputState};
 use sctk::reexports::calloop::LoopHandle;
@@ -12,29 +12,30 @@ use sctk::reexports::client::protocol::wl_output::WlOutput;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::{Connection, Proxy, QueueHandle};
 use sctk::registry::{ProvidesRegistryState, RegistryState};
-use sctk::seat::pointer::ThemedPointer;
 use sctk::seat::SeatState;
-use sctk::shell::xdg::window::{Window, WindowConfigure, WindowHandler};
-use sctk::shell::xdg::XdgShell;
+use sctk::seat::pointer::ThemedPointer;
 use sctk::shell::WaylandSurface;
+use sctk::shell::xdg::XdgShell;
+use sctk::shell::xdg::window::{Window, WindowConfigure, WindowHandler};
 use sctk::shm::slot::SlotPool;
 use sctk::shm::{Shm, ShmHandler};
 use sctk::subcompositor::SubcompositorState;
 use winit_core::error::OsError;
 
+use crate::WindowId;
 use crate::event_loop::sink::EventSink;
 use crate::output::MonitorHandle;
 use crate::seat::{
-    PointerConstraintsState, RelativePointerState, TextInputState, WinitPointerData,
-    WinitPointerDataExt, WinitSeatState,
+    PointerConstraintsState, PointerGesturesState, RelativePointerState, TextInputState,
+    WinitPointerData, WinitPointerDataExt, WinitSeatState,
 };
-use crate::types::kwin_blur::KWinBlurManager;
+use crate::types::bgr_effects::BgrEffectManager;
 use crate::types::wp_fractional_scaling::FractionalScalingManager;
+use crate::types::wp_tablet_input_v2::TabletManager;
 use crate::types::wp_viewporter::ViewporterState;
 use crate::types::xdg_activation::XdgActivationState;
 use crate::types::xdg_toplevel_icon_manager::XdgToplevelIconManagerState;
 use crate::window::{WindowRequests, WindowState};
-use crate::WindowId;
 
 /// Winit's Wayland state.
 #[derive(Debug)]
@@ -61,10 +62,10 @@ pub struct WinitState {
     pub xdg_shell: XdgShell,
 
     /// The currently present windows.
-    pub windows: RefCell<AHashMap<WindowId, Arc<Mutex<WindowState>>>>,
+    pub windows: RefCell<HashMap<WindowId, Arc<Mutex<WindowState>>>>,
 
     /// The requests from the `Window` to EventLoop, such as close operations and redraw requests.
-    pub window_requests: RefCell<AHashMap<WindowId, Arc<WindowRequests>>>,
+    pub window_requests: RefCell<HashMap<WindowId, Arc<WindowRequests>>>,
 
     /// The events that were generated directly from the window.
     pub window_events_sink: Arc<Mutex<EventSink>>,
@@ -73,10 +74,10 @@ pub struct WinitState {
     pub window_compositor_updates: Vec<WindowCompositorUpdate>,
 
     /// Currently handled seats.
-    pub seats: AHashMap<ObjectId, WinitSeatState>,
+    pub seats: HashMap<ObjectId, WinitSeatState>,
 
     /// Currently present cursor surfaces.
-    pub pointer_surfaces: AHashMap<ObjectId, Arc<ThemedPointer<WinitPointerData>>>,
+    pub pointer_surfaces: HashMap<ObjectId, Arc<ThemedPointer<WinitPointerData>>>,
 
     /// The state of the text input on the client.
     pub text_input_state: Option<TextInputState>,
@@ -100,17 +101,23 @@ pub struct WinitState {
     /// Relative pointer.
     pub relative_pointer: Option<RelativePointerState>,
 
+    /// Tablet manager.
+    pub tablet_state: Option<TabletManager>,
+
     /// Pointer constraints to handle pointer locking and confining.
     pub pointer_constraints: Option<Arc<PointerConstraintsState>>,
 
+    /// Pointer gestures to handle pinch, rotate, and pan
+    pub pointer_gestures: Option<PointerGesturesState>,
+
     /// Viewporter state on the given window.
     pub viewporter_state: Option<ViewporterState>,
 
     /// Fractional scaling manager.
     pub fractional_scaling_manager: Option<FractionalScalingManager>,
 
-    /// KWin blur manager.
-    pub kwin_blur_manager: Option<KWinBlurManager>,
+    /// Blur manager.
+    pub blur_manager: Option<BgrEffectManager>,
 
     /// Loop handle to re-register event sources, such as keyboard repeat.
     pub loop_handle: LoopHandle<'static, Self>,
@@ -149,7 +156,7 @@ impl WinitState {
 
         let seat_state = SeatState::new(globals, queue_handle);
 
-        let mut seats = AHashMap::default();
+        let mut seats = HashMap::default();
         for seat in seat_state.seats() {
             seats.insert(seat.id(), WinitSeatState::new());
         }
@@ -185,16 +192,18 @@ impl WinitState {
             window_events_sink: Default::default(),
             viewporter_state,
             fractional_scaling_manager,
-            kwin_blur_manager: KWinBlurManager::new(globals, queue_handle).ok(),
+            blur_manager: BgrEffectManager::new(globals, queue_handle).ok(),
 
             seats,
             text_input_state: TextInputState::new(globals, queue_handle).ok(),
 
             relative_pointer: RelativePointerState::new(globals, queue_handle).ok(),
+            tablet_state: TabletManager::new(globals, queue_handle).ok(),
             pointer_constraints: PointerConstraintsState::new(globals, queue_handle)
                 .map(Arc::new)
                 .ok(),
             pointer_surfaces: Default::default(),
+            pointer_gestures: PointerGesturesState::new(globals, queue_handle).ok(),
 
             monitors: Arc::new(Mutex::new(monitors)),
             events_sink: EventSink::new(),

winit-wayland/src/types/bgr_effects.rs

@@ -0,0 +1,85 @@
+use sctk::compositor::Region;
+use sctk::reexports::client::QueueHandle;
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::protocols::ext::background_effect::v1::client::ext_background_effect_surface_v1::ExtBackgroundEffectSurfaceV1;
+use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
+
+use crate::state::WinitState;
+use crate::types::ext_background_effect::ExtBackgroundEffectManager;
+use crate::types::kwin_blur::KWinBlurManager;
+
+/// Wrapper around various background effects for [`WlSurface`].
+#[derive(Debug, Clone)]
+pub enum BgrEffectManager {
+    Ext(ExtBackgroundEffectManager),
+    KWin(KWinBlurManager),
+}
+
+impl BgrEffectManager {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        ExtBackgroundEffectManager::new(globals, queue_handle)
+            .map(Self::Ext)
+            .or_else(|_| KWinBlurManager::new(globals, queue_handle).map(Self::KWin))
+    }
+
+    /// Creates a new blur effect for the surface.
+    pub fn new_blur_effect(
+        &mut self,
+        surface: &WlSurface,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> SurfaceBlurEffect {
+        match self {
+            BgrEffectManager::Ext(mgr) => SurfaceBlurEffect::Ext(mgr.blur(surface, queue_handle)),
+            BgrEffectManager::KWin(mgr) => SurfaceBlurEffect::Kwin(
+                mgr.blur(surface, queue_handle),
+                mgr.clone(),
+                surface.clone(),
+            ),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum SurfaceBlurEffect {
+    Ext(ExtBackgroundEffectSurfaceV1),
+    Kwin(OrgKdeKwinBlur, KWinBlurManager, WlSurface),
+}
+
+impl SurfaceBlurEffect {
+    /// Returns `true` if the main surface commit is required.
+    ///
+    /// `None` clears the blur.
+    #[must_use]
+    pub fn set_blur(&self, region: Option<&Region>) -> bool {
+        let region = region.map(|region| region.wl_region());
+        match self {
+            SurfaceBlurEffect::Ext(surface) => {
+                surface.set_blur_region(region);
+                true
+            },
+            SurfaceBlurEffect::Kwin(blur, ..) => {
+                blur.set_region(region);
+                blur.commit();
+                true
+            },
+        }
+    }
+}
+
+impl Drop for SurfaceBlurEffect {
+    fn drop(&mut self) {
+        match self {
+            SurfaceBlurEffect::Ext(surface) => surface.destroy(),
+            SurfaceBlurEffect::Kwin(blur, mgr, wl_surface) => {
+                blur.set_region(None);
+                blur.commit();
+                blur.release();
+                mgr.unset(wl_surface);
+            },
+        }
+    }
+}

winit-wayland/src/types/ext_background_effect.rs

@@ -0,0 +1,59 @@
+use sctk::globals::GlobalData;
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use wayland_protocols::ext::background_effect::v1::client::ext_background_effect_manager_v1::ExtBackgroundEffectManagerV1;
+use wayland_protocols::ext::background_effect::v1::client::ext_background_effect_surface_v1::ExtBackgroundEffectSurfaceV1;
+
+use crate::state::WinitState;
+
+#[derive(Debug, Clone)]
+pub struct ExtBackgroundEffectManager {
+    manager: ExtBackgroundEffectManagerV1,
+}
+
+impl ExtBackgroundEffectManager {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { manager })
+    }
+
+    pub fn blur(
+        &mut self,
+        surface: &WlSurface,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> ExtBackgroundEffectSurfaceV1 {
+        self.manager.get_background_effect(surface, queue_handle, ())
+    }
+}
+
+impl Dispatch<ExtBackgroundEffectManagerV1, GlobalData, WinitState> for ExtBackgroundEffectManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ExtBackgroundEffectManagerV1,
+        _: <ExtBackgroundEffectManagerV1 as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ExtBackgroundEffectSurfaceV1, (), WinitState> for ExtBackgroundEffectManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ExtBackgroundEffectSurfaceV1,
+        _: <ExtBackgroundEffectSurfaceV1 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        // There is no event
+    }
+}
+
+delegate_dispatch!(WinitState: [ExtBackgroundEffectManagerV1: GlobalData] => ExtBackgroundEffectManager);
+delegate_dispatch!(WinitState: [ExtBackgroundEffectSurfaceV1: ()] => ExtBackgroundEffectManager);

winit-wayland/src/types/kwin_blur.rs

@@ -3,7 +3,7 @@
 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::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
 use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 use wayland_protocols_plasma::blur::client::org_kde_kwin_blur_manager::OrgKdeKwinBlurManager;
 

winit-wayland/src/types/mod.rs

@@ -1,8 +1,11 @@
 //! Wayland protocol implementation boilerplate.
 
+pub mod bgr_effects;
 pub mod cursor;
+pub mod ext_background_effect;
 pub mod kwin_blur;
 pub mod wp_fractional_scaling;
+pub mod wp_tablet_input_v2;
 pub mod wp_viewporter;
 pub mod xdg_activation;
 pub mod xdg_toplevel_icon_manager;

winit-wayland/src/types/wp_fractional_scaling.rs

@@ -3,7 +3,7 @@
 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::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
 use sctk::reexports::protocols::wp::fractional_scale::v1::client::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1;
 use sctk::reexports::protocols::wp::fractional_scale::v1::client::wp_fractional_scale_v1::{
     Event as FractionalScalingEvent, WpFractionalScaleV1,

winit-wayland/src/types/wp_tablet_input_v2.rs

@@ -0,0 +1,412 @@
+//! Handling of wp_tablet_input_v2.
+
+use std::sync::Mutex;
+
+use dpi::LogicalPosition;
+use sctk::compositor::SurfaceData;
+use sctk::globals::GlobalData;
+use sctk::reexports::client::backend::smallvec::SmallVec;
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{
+    Connection, Dispatch, Proxy, QueueHandle, WEnum, delegate_dispatch, event_created_child,
+};
+use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_manager_v2::ZwpTabletManagerV2;
+use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_pad_v2::ZwpTabletPadV2;
+use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::{
+    self, ZwpTabletSeatV2,
+};
+use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_tool_v2::{
+    ButtonState, Event as ToolEvent, Type as ToolType, ZwpTabletToolV2,
+};
+use sctk::reexports::protocols::wp::tablet::zv2::client::zwp_tablet_v2::ZwpTabletV2;
+use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_pad_dial_v2::ZwpTabletPadDialV2;
+use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_pad_group_v2::{
+    self, ZwpTabletPadGroupV2,
+};
+use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_pad_ring_v2::ZwpTabletPadRingV2;
+use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_pad_strip_v2::ZwpTabletPadStripV2;
+use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_pad_v2;
+use winit_core::event::{
+    ButtonSource, ElementState, Force, PointerKind, PointerSource, TabletToolButton,
+    TabletToolData as CoreTabletToolData, TabletToolKind, TabletToolTilt, WindowEvent,
+};
+
+use crate::state::WinitState;
+
+/// KWin blur manager.
+#[derive(Debug, Clone)]
+pub struct TabletManager {
+    manager: ZwpTabletManagerV2,
+}
+
+impl TabletManager {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        // Ignore v2 since we are not interested in its events.
+        let manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { manager })
+    }
+
+    pub fn get_tablet_seat(
+        &self,
+        seat: &WlSeat,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> ZwpTabletSeatV2 {
+        self.manager.get_tablet_seat(seat, queue_handle, ())
+    }
+}
+impl Dispatch<ZwpTabletManagerV2, GlobalData, WinitState> for TabletManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ZwpTabletManagerV2,
+        _: <ZwpTabletManagerV2 as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        unreachable!("no events defined for zwp_tablet_manager_v2");
+    }
+}
+
+impl Dispatch<ZwpTabletManagerV2, (), WinitState> for TabletManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ZwpTabletManagerV2,
+        _: <ZwpTabletManagerV2 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        unreachable!("no events defined for zwp_tablet_manager_v2");
+    }
+}
+
+impl Dispatch<ZwpTabletSeatV2, (), WinitState> for TabletManager {
+    event_created_child!(WinitState, ZwpTabletSeatV2, [
+        zwp_tablet_seat_v2::EVT_TABLET_ADDED_OPCODE => (ZwpTabletV2, Default::default()),
+        zwp_tablet_seat_v2::EVT_TOOL_ADDED_OPCODE => (ZwpTabletToolV2, Default::default()),
+        zwp_tablet_seat_v2::EVT_PAD_ADDED_OPCODE => (ZwpTabletPadV2, Default::default())
+    ]);
+
+    fn event(
+        _: &mut WinitState,
+        _: &ZwpTabletSeatV2,
+        _: <ZwpTabletSeatV2 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpTabletToolV2, TabletToolData, WinitState> for TabletManager {
+    fn event(
+        state: &mut WinitState,
+        _: &ZwpTabletToolV2,
+        event: <ZwpTabletToolV2 as Proxy>::Event,
+        data: &TabletToolData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        let mut data = data.inner.lock().unwrap();
+
+        match event {
+            ToolEvent::Type { tool_type: WEnum::Value(tool_type) } => {
+                data.ty = match tool_type {
+                    ToolType::Pen => TabletToolKind::Pen,
+                    ToolType::Eraser => TabletToolKind::Eraser,
+                    ToolType::Brush => TabletToolKind::Brush,
+                    ToolType::Pencil => TabletToolKind::Pencil,
+                    ToolType::Airbrush => TabletToolKind::Airbrush,
+                    ToolType::Finger => TabletToolKind::Finger,
+                    ToolType::Mouse => TabletToolKind::Mouse,
+                    ToolType::Lens => TabletToolKind::Lens,
+                    _ => return,
+                };
+            },
+            ToolEvent::Capability { .. } => {},
+            ToolEvent::Done => (),
+            ToolEvent::ProximityIn { serial, surface, .. } => {
+                data.pending.push(TabletEvent::Enter { serial, surface });
+            },
+            ToolEvent::ProximityOut => data.pending.push(TabletEvent::Left),
+            ToolEvent::Down { serial } => {
+                let event = TabletEvent::Button {
+                    state: ElementState::Pressed,
+                    serial: Some(serial),
+                    button: TabletToolButton::Contact,
+                };
+
+                data.pending.push(event);
+            },
+            ToolEvent::Up => {
+                let event = TabletEvent::Button {
+                    state: ElementState::Released,
+                    serial: None,
+                    button: TabletToolButton::Contact,
+                };
+
+                data.pending.push(event);
+            },
+            ToolEvent::Tilt { tilt_x, tilt_y } => {
+                data.tool_state.tilt = Some(TabletToolTilt { x: tilt_x as i8, y: tilt_y as i8 });
+            },
+            ToolEvent::Motion { x, y } => {
+                data.position = (x, y).into();
+                data.pending.push(TabletEvent::Moved);
+            },
+            ToolEvent::Pressure { pressure } => {
+                data.tool_state.force = Some(Force::Normalized(pressure as f64 / u16::MAX as f64));
+            },
+            ToolEvent::Rotation { degrees } => {
+                data.tool_state.twist = Some(degrees as u16);
+            },
+            ToolEvent::Button { serial, button, state: WEnum::Value(state) } => {
+                let state = match state {
+                    ButtonState::Released => ElementState::Released,
+                    ButtonState::Pressed => ElementState::Pressed,
+                    _ => return,
+                };
+
+                // Map similar to SDL.
+                let button = match button {
+                    // BTN_STYLUS.
+                    0x14b => TabletToolButton::Contact,
+                    0x14c => TabletToolButton::Barrel,
+                    // BTN_STYLUS3.
+                    0x149 => TabletToolButton::Other(1),
+                    // There's no defined conversion for any of that.
+                    button => TabletToolButton::Other(button as u16),
+                };
+
+                let event = TabletEvent::Button { button, state, serial: Some(serial) };
+                data.pending.push(event);
+            },
+            ToolEvent::Frame { .. } => {
+                let kind = data.ty;
+                for event in std::mem::take(&mut data.pending) {
+                    if let TabletEvent::Enter { surface, serial } = &event {
+                        data.latest_enter_serial = Some(*serial);
+                        data.surface = Some(surface.clone());
+                    }
+
+                    // Handle events only for top-level surface.
+                    let surface = match data
+                        .surface
+                        .as_ref()
+                        .map(|surface| (surface, surface.data::<SurfaceData>()))
+                    {
+                        Some((surface, Some(surface_data)))
+                            if surface_data.parent_surface().is_none() =>
+                        {
+                            surface
+                        },
+                        _ => continue,
+                    };
+
+                    let window_id = crate::make_wid(surface);
+
+                    // Ensure that window exists.
+                    let window = match state.windows.get_mut().get_mut(&window_id) {
+                        Some(window) => window.lock().unwrap(),
+                        None => continue,
+                    };
+
+                    let position = data.position.to_physical(window.scale_factor());
+
+                    let window_event = match event {
+                        TabletEvent::Enter { .. } => WindowEvent::PointerEntered {
+                            device_id: None,
+                            position,
+                            primary: true,
+                            kind: PointerKind::TabletTool(kind),
+                        },
+                        TabletEvent::Moved => WindowEvent::PointerMoved {
+                            device_id: None,
+                            position,
+                            primary: true,
+                            source: PointerSource::TabletTool {
+                                kind,
+                                data: data.tool_state.clone(),
+                            },
+                        },
+                        TabletEvent::Button { button, state, serial } => {
+                            // Update serial if we have it.
+                            if let Some(serial) = serial {
+                                data.latest_button_serial = Some(serial);
+                            }
+
+                            WindowEvent::PointerButton {
+                                device_id: None,
+                                state,
+                                position,
+                                primary: true,
+                                button: ButtonSource::TabletTool {
+                                    kind,
+                                    button,
+                                    data: data.tool_state.clone(),
+                                },
+                            }
+                        },
+                        TabletEvent::Left => WindowEvent::PointerLeft {
+                            device_id: None,
+                            position: Some(position),
+                            primary: true,
+                            kind: PointerKind::TabletTool(kind),
+                        },
+                    };
+
+                    state.events_sink.push_window_event(window_event, window_id);
+
+                    // Clear up the surface after we've processed `Left` event.
+                    if matches!(event, TabletEvent::Left) {
+                        data.surface = None;
+                        data.latest_button_serial = None;
+                        data.latest_enter_serial = None;
+                        data.tool_state = Default::default();
+                    }
+                }
+            },
+            _ => (),
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+struct TabletToolData {
+    inner: Mutex<TabletToolDataInner>,
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct TabletToolDataInner {
+    pub(crate) ty: TabletToolKind,
+
+    /// Core tablet tool data.
+    pub(crate) tool_state: CoreTabletToolData,
+
+    /// Pending events until the `frame` is received.
+    pub(crate) pending: SmallVec<[TabletEvent; 4]>,
+
+    /// Surface the tablet most recently entered.
+    pub(crate) surface: Option<WlSurface>,
+
+    /// Position relative to the surface.
+    pub(crate) position: LogicalPosition<f64>,
+
+    // NOTE: even though we don't utilize serials
+    // right now, track them anyway.
+    /// The serial of the latest enter event for the pointer
+    pub(crate) latest_enter_serial: Option<u32>,
+
+    /// The serial of the latest button event for the pointer
+    pub(crate) latest_button_serial: Option<u32>,
+}
+
+// Due to wayland using logical coordinates,
+// delay the conversion to physical until the dispatch actually happens,
+// so the scaling is applied at the time of actual dispatch, since it
+// can technically change before the `frame` event.
+#[derive(Debug, Clone)]
+pub(crate) enum TabletEvent {
+    Enter { serial: u32, surface: WlSurface },
+    Left,
+    Moved,
+    Button { button: TabletToolButton, state: ElementState, serial: Option<u32> },
+}
+
+impl Dispatch<ZwpTabletV2, (), WinitState> for TabletManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ZwpTabletV2,
+        _: <ZwpTabletV2 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpTabletPadV2, (), WinitState> for TabletManager {
+    event_created_child!(WinitState, ZwpTabletPadV2, [
+        zwp_tablet_pad_v2::EVT_GROUP_OPCODE => (ZwpTabletPadGroupV2, Default::default()),
+    ]);
+
+    fn event(
+        _: &mut WinitState,
+        _: &ZwpTabletPadV2,
+        _: <ZwpTabletPadV2 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpTabletPadGroupV2, (), WinitState> for TabletManager {
+    event_created_child!(WinitState, ZwpTabletPadGroupV2, [
+        zwp_tablet_pad_group_v2::EVT_RING_OPCODE => (ZwpTabletPadRingV2, Default::default()),
+        zwp_tablet_pad_group_v2::EVT_STRIP_OPCODE => (ZwpTabletPadStripV2, Default::default()),
+        zwp_tablet_pad_group_v2::EVT_DIAL_OPCODE => (ZwpTabletPadDialV2, Default::default()),
+    ]);
+
+    fn event(
+        _: &mut WinitState,
+        _: &ZwpTabletPadGroupV2,
+        _: <ZwpTabletPadGroupV2 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpTabletPadRingV2, (), WinitState> for TabletManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ZwpTabletPadRingV2,
+        _: <ZwpTabletPadRingV2 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpTabletPadStripV2, (), WinitState> for TabletManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ZwpTabletPadStripV2,
+        _: <ZwpTabletPadStripV2 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ZwpTabletPadDialV2, (), WinitState> for TabletManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ZwpTabletPadDialV2,
+        _: <ZwpTabletPadDialV2 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+delegate_dispatch!(WinitState: [ZwpTabletManagerV2: GlobalData] => TabletManager);
+delegate_dispatch!(WinitState: [ZwpTabletManagerV2: ()] => TabletManager);
+delegate_dispatch!(WinitState: [ZwpTabletSeatV2: ()] => TabletManager);
+delegate_dispatch!(WinitState: [ZwpTabletV2: ()] => TabletManager);
+delegate_dispatch!(WinitState: [ZwpTabletToolV2: TabletToolData] => TabletManager);
+delegate_dispatch!(WinitState: [ZwpTabletPadV2: ()] => TabletManager);
+delegate_dispatch!(WinitState: [ZwpTabletPadGroupV2: ()] => TabletManager);
+delegate_dispatch!(WinitState: [ZwpTabletPadRingV2: ()] => TabletManager);
+delegate_dispatch!(WinitState: [ZwpTabletPadStripV2: ()] => TabletManager);
+delegate_dispatch!(WinitState: [ZwpTabletPadDialV2: ()] => TabletManager);

winit-wayland/src/types/wp_viewporter.rs

@@ -3,7 +3,7 @@
 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::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
 use sctk::reexports::protocols::wp::viewporter::client::wp_viewport::WpViewport;
 use sctk::reexports::protocols::wp::viewporter::client::wp_viewporter::WpViewporter;
 

winit-wayland/src/types/xdg_activation.rs

@@ -1,12 +1,12 @@
 //! Handling of xdg activation, which is used for user attention requests.
 
-use std::sync::atomic::AtomicBool;
 use std::sync::Weak;
+use std::sync::atomic::AtomicBool;
 
 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::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
 use sctk::reexports::protocols::xdg::activation::v1::client::xdg_activation_token_v1::{
     Event as ActivationTokenEvent, XdgActivationTokenV1,
 };

winit-wayland/src/types/xdg_toplevel_icon_manager.rs

@@ -7,7 +7,7 @@ use sctk::globals::GlobalData;
 use sctk::shm::slot::{Buffer, SlotPool};
 use wayland_client::globals::{BindError, GlobalList};
 use wayland_client::protocol::wl_shm::Format;
-use wayland_client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
+use wayland_client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
 use wayland_protocols::xdg::toplevel_icon::v1::client::xdg_toplevel_icon_manager_v1::XdgToplevelIconManagerV1;
 use wayland_protocols::xdg::toplevel_icon::v1::client::xdg_toplevel_icon_v1::XdgToplevelIconV1;
 use winit_core::icon::{Icon, RgbaIcon};

winit-wayland/src/window/mod.rs

@@ -11,8 +11,8 @@ use sctk::reexports::client::protocol::wl_display::WlDisplay;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 use sctk::reexports::client::{Proxy, QueueHandle};
 use sctk::reexports::protocols::xdg::activation::v1::client::xdg_activation_v1::XdgActivationV1;
-use sctk::shell::xdg::window::{Window as SctkWindow, WindowDecorations};
 use sctk::shell::WaylandSurface;
+use sctk::shell::xdg::window::{Window as SctkWindow, WindowDecorations};
 use tracing::warn;
 use winit_core::cursor::Cursor;
 use winit_core::error::{NotSupportedError, RequestError};
@@ -25,12 +25,12 @@ use winit_core::window::{
     WindowLevel,
 };
 
+use super::ActiveEventLoop;
 use super::event_loop::sink::EventSink;
 use super::output::MonitorHandle;
 use super::state::WinitState;
 use super::types::xdg_activation::XdgActivationTokenData;
-use super::ActiveEventLoop;
-use crate::{output, WindowAttributesWayland};
+use crate::{WindowAttributesWayland, output};
 
 pub(crate) mod state;
 
@@ -106,6 +106,12 @@ impl Window {
         let window =
             state.xdg_shell.create_window(surface.clone(), default_decorations, &queue_handle);
 
+        let WindowAttributesWayland { name: app_name, activation_token, prefer_csd } = *attributes
+            .platform
+            .take()
+            .and_then(|p| p.cast::<WindowAttributesWayland>().ok())
+            .unwrap_or_default();
+
         let mut window_state = WindowState::new(
             event_loop_window_target.handle.clone(),
             &event_loop_window_target.queue_handle,
@@ -113,6 +119,7 @@ impl Window {
             size,
             window.clone(),
             attributes.preferred_theme,
+            prefer_csd,
         );
 
         window_state.set_window_icon(attributes.window_icon);
@@ -120,18 +127,12 @@ impl Window {
         // Set transparency hint.
         window_state.set_transparent(attributes.transparent);
 
-        window_state.set_blur(attributes.blur);
+        // Set blur.
+        let _ = window_state.set_blur(attributes.blur);
 
         // Set the decorations hint.
         window_state.set_decorate(attributes.decorations);
 
-        let (app_name, activation_token) =
-            match attributes.platform.take().and_then(|p| p.cast::<WindowAttributesWayland>().ok())
-            {
-                Some(attrs) => (attrs.name, attrs.activation_token),
-                None => (None, None),
-            };
-
         // Set the app_id.
         if let Some(name) = app_name.map(|name| name.general) {
             window.set_app_id(name);
@@ -171,6 +172,12 @@ impl Window {
             Cursor::Custom(cursor) => window_state.set_custom_cursor(cursor),
         }
 
+        // Apply resize increments.
+        if let Some(increments) = attributes.surface_resize_increments {
+            let increments = increments.to_logical(window_state.scale_factor());
+            window_state.set_resize_increments(Some(increments));
+        }
+
         // Activate the window when the token is passed.
         if let (Some(xdg_activation), Some(token)) = (xdg_activation.as_ref(), activation_token) {
             xdg_activation.activate(token.into_raw(), &surface);
@@ -351,11 +358,6 @@ impl CoreWindow for Window {
         PhysicalInsets::new(0, 0, 0, 0)
     }
 
-    fn min_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        let size = self.window_state.lock().unwrap().min_surface_size();
-        size.map(|size| size.to_physical(self.scale_factor()))
-    }
-
     fn set_min_surface_size(&self, min_size: Option<Size>) {
         let scale_factor = self.scale_factor();
         let min_size = min_size.map(|size| size.to_logical(scale_factor));
@@ -364,11 +366,6 @@ impl CoreWindow for Window {
         self.request_redraw();
     }
 
-    fn max_surface_size(&self) -> Option<PhysicalSize<u32>> {
-        let size = self.window_state.lock().unwrap().max_surface_size();
-        size.map(|size| size.to_physical(self.scale_factor()))
-    }
-
     /// Set the maximum surface size for the window.
     #[inline]
     fn set_max_surface_size(&self, max_size: Option<Size>) {
@@ -380,11 +377,18 @@ impl CoreWindow for Window {
     }
 
     fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>> {
-        None
+        let window_state = self.window_state.lock().unwrap();
+        let scale_factor = window_state.scale_factor();
+        window_state
+            .resize_increments()
+            .map(|size| super::logical_to_physical_rounded(size, scale_factor))
     }
 
-    fn set_surface_resize_increments(&self, _increments: Option<Size>) {
-        warn!("`set_surface_resize_increments` is not implemented for Wayland");
+    fn set_surface_resize_increments(&self, increments: Option<Size>) {
+        let mut window_state = self.window_state.lock().unwrap();
+        let scale_factor = window_state.scale_factor();
+        let increments = increments.map(|size| size.to_logical(scale_factor));
+        window_state.set_resize_increments(increments);
     }
 
     fn set_title(&self, title: &str) {
@@ -392,10 +396,6 @@ impl CoreWindow for Window {
         self.window_state.lock().unwrap().set_title(new_title);
     }
 
-    fn is_transparent(&self) -> bool {
-        self.window_state.lock().unwrap().is_transparent()
-    }
-
     #[inline]
     fn set_transparent(&self, transparent: bool) {
         self.window_state.lock().unwrap().set_transparent(transparent);
@@ -445,11 +445,7 @@ impl CoreWindow for Window {
     }
 
     fn set_maximized(&self, maximized: bool) {
-        if maximized {
-            self.window.set_maximized()
-        } else {
-            self.window.unset_maximized()
-        }
+        if maximized { self.window.set_maximized() } else { self.window.unset_maximized() }
     }
 
     fn is_maximized(&self) -> bool {
@@ -501,13 +497,11 @@ impl CoreWindow for Window {
         self.window_state.lock().unwrap().scale_factor()
     }
 
-    fn is_blurred(&self) -> bool {
-        self.window_state.lock().unwrap().is_blurred()
-    }
-
     #[inline]
     fn set_blur(&self, blur: bool) {
-        self.window_state.lock().unwrap().set_blur(blur);
+        if self.window_state.lock().unwrap().set_blur(blur) {
+            self.request_redraw();
+        }
     }
 
     #[inline]
@@ -520,16 +514,8 @@ impl CoreWindow for Window {
         self.window_state.lock().unwrap().is_decorated()
     }
 
-    fn window_level(&self) -> WindowLevel {
-        WindowLevel::default()
-    }
-
     fn set_window_level(&self, _level: WindowLevel) {}
 
-    fn window_icon(&self) -> Option<winit_core::icon::Icon> {
-        self.window_state.lock().unwrap().window_icon()
-    }
-
     fn set_window_icon(&self, window_icon: Option<winit_core::icon::Icon>) {
         self.window_state.lock().unwrap().set_window_icon(window_icon)
     }
@@ -592,17 +578,8 @@ impl CoreWindow for Window {
         self.window_state.lock().unwrap().theme()
     }
 
-    fn content_protected(&self) -> bool {
-        false
-    }
-
     fn set_content_protected(&self, _protected: bool) {}
 
-    fn cursor(&self) -> Cursor {
-        warn!("getting the cursor is unimplemented on Wayland");
-        Cursor::default()
-    }
-
     fn set_cursor(&self, cursor: Cursor) {
         let window_state = &mut self.window_state.lock().unwrap();
 

winit-wayland/src/window/state.rs

@@ -4,8 +4,8 @@ use std::num::NonZeroU32;
 use std::sync::{Arc, Mutex, Weak};
 use std::time::Duration;
 
-use ahash::HashSet;
 use dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Size};
+use foldhash::HashSet;
 use sctk::compositor::{CompositorState, Region, SurfaceData, SurfaceDataExt};
 use sctk::globals::GlobalData;
 use sctk::reexports::client::backend::ObjectId;
@@ -21,15 +21,14 @@ use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::
 use sctk::reexports::protocols::wp::viewporter::client::wp_viewport::WpViewport;
 use sctk::reexports::protocols::xdg::shell::client::xdg_toplevel::ResizeEdge as XdgResizeEdge;
 use sctk::seat::pointer::{PointerDataExt, ThemedPointer};
-use sctk::shell::xdg::window::{DecorationMode, Window, WindowConfigure};
-use sctk::shell::xdg::XdgSurface;
 use sctk::shell::WaylandSurface;
-use sctk::shm::slot::SlotPool;
+use sctk::shell::xdg::XdgSurface;
+use sctk::shell::xdg::window::{DecorationMode, Window, WindowConfigure};
 use sctk::shm::Shm;
+use sctk::shm::slot::SlotPool;
 use sctk::subcompositor::SubcompositorState;
 use tracing::{info, warn};
 use wayland_protocols::xdg::toplevel_icon::v1::client::xdg_toplevel_icon_manager_v1::XdgToplevelIconManagerV1;
-use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 use winit_core::cursor::{CursorIcon, CustomCursor as CoreCustomCursor};
 use winit_core::error::{NotSupportedError, RequestError};
 use winit_core::window::{
@@ -43,8 +42,8 @@ use crate::seat::{
     ZwpTextInputV3Ext,
 };
 use crate::state::{WindowCompositorUpdate, WinitState};
+use crate::types::bgr_effects::{BgrEffectManager, SurfaceBlurEffect};
 use crate::types::cursor::{CustomCursor, SelectedCursor, WaylandCustomCursor};
-use crate::types::kwin_blur::KWinBlurManager;
 use crate::types::xdg_toplevel_icon_manager::ToplevelIcon;
 
 #[cfg(feature = "sctk-adwaita")]
@@ -134,9 +133,13 @@ pub struct WindowState {
     /// Whether we should decorate the frame.
     decorate: bool,
 
+    /// Whether we should tell the compositor that we prefer drawing decorations ourself.
+    prefer_csd: bool,
+
     /// Min size.
     min_surface_size: LogicalSize<u32>,
     max_surface_size: Option<LogicalSize<u32>>,
+    resize_increments: Option<LogicalSize<u32>>,
 
     /// The size of the window when no states were applied to it. The primary use for it
     /// is to fallback to original window size, before it was maximized, if the compositor
@@ -152,8 +155,8 @@ pub struct WindowState {
 
     viewport: Option<WpViewport>,
     fractional_scale: Option<WpFractionalScaleV1>,
-    blur: Option<OrgKdeKwinBlur>,
-    blur_manager: Option<KWinBlurManager>,
+    blur: Option<SurfaceBlurEffect>,
+    blur_manager: Option<BgrEffectManager>,
 
     /// Whether the client side decorations have pending move operations.
     ///
@@ -180,6 +183,7 @@ impl WindowState {
         initial_size: Size,
         window: Window,
         theme: Option<Theme>,
+        prefer_csd: bool,
     ) -> Self {
         let compositor = winit_state.compositor_state.clone();
         let pointer_constraints = winit_state.pointer_constraints.clone();
@@ -201,7 +205,7 @@ impl WindowState {
             toplevel_icon: None,
             xdg_toplevel_icon_manager,
             blur: None,
-            blur_manager: winit_state.kwin_blur_manager.clone(),
+            blur_manager: winit_state.blur_manager.clone(),
             compositor,
             handle,
             csd_fails: false,
@@ -209,6 +213,7 @@ impl WindowState {
             selected_cursor: Default::default(),
             cursor_visible: true,
             decorate: true,
+            prefer_csd,
             fractional_scale,
             frame: None,
             frame_callback_state: FrameCallbackState::None,
@@ -218,6 +223,7 @@ impl WindowState {
             last_configure: None,
             max_surface_size: None,
             min_surface_size: MIN_WINDOW_SIZE,
+            resize_increments: None,
             pointer_constraints,
             pointers: Default::default(),
             queue_handle: queue_handle.clone(),
@@ -302,7 +308,7 @@ impl WindowState {
                 subcompositor.clone(),
                 self.queue_handle.clone(),
                 #[cfg(feature = "sctk-adwaita")]
-                into_sctk_adwaita_config(self.theme),
+                create_sctk_adwaita_config(self.theme),
             ) {
                 Ok(mut frame) => {
                     frame.set_title(&self.title);
@@ -356,6 +362,42 @@ impl WindowState {
                 .unwrap_or(new_size.height);
         }
 
+        // Apply size increments.
+        //
+        // We conditionally apply increments to avoid conflicts with the compositor's layout rules:
+        // 1. If the window is floating (constrain == true), we snap to increments to ensure the
+        //    app's grid alignment.
+        // 2. If the user is interactively resizing (is_resizing), we snap the size to provide
+        //    feedback.
+        //
+        // However, we MUST NOT snap if the compositor enforces a specific size (constrain == false,
+        // or states like Maximized/Tiled). Snapping in these cases (e.g. corner tiling) would
+        // shrink the window below the allocated area, creating visible gaps between valid
+        // windows or screen edges.
+        if (constrain || configure.is_resizing())
+            && !configure.is_maximized()
+            && !configure.is_fullscreen()
+            && !configure.is_tiled()
+        {
+            if let Some(increments) = self.resize_increments {
+                // We use min size as a base size for the increments, similar to how X11 does it.
+                //
+                // This ensures that we can always reach the min size and the increments are
+                // calculated from it.
+                let (delta_width, delta_height) = (
+                    new_size.width.saturating_sub(self.min_surface_size.width),
+                    new_size.height.saturating_sub(self.min_surface_size.height),
+                );
+
+                let width = self.min_surface_size.width
+                    + (delta_width / increments.width) * increments.width;
+                let height = self.min_surface_size.height
+                    + (delta_height / increments.height) * increments.height;
+
+                new_size = (width, height).into();
+            }
+        }
+
         let new_state = configure.state;
         let old_state = self.last_configure.as_ref().map(|configure| configure.state);
 
@@ -699,6 +741,13 @@ impl WindowState {
             // Set surface size without the borders.
             viewport.set_destination(self.size.width as _, self.size.height as _);
         }
+
+        // Update blur region with new size.
+        if self.blur.is_some() {
+            // NOTE: either user resized or configure, in both cases
+            // the redraw scheduling is done on the caller side.
+            let _ = self.set_blur(true);
+        }
     }
 
     /// Get the scale factor of the window.
@@ -744,6 +793,18 @@ impl WindowState {
         self.selected_cursor = SelectedCursor::Custom(cursor);
     }
 
+    /// Set the resize increments of the window.
+    pub fn set_resize_increments(&mut self, increments: Option<LogicalSize<u32>>) {
+        self.resize_increments = increments;
+        // NOTE: We don't update the window size here, because it will be done on the next resize
+        // or configure event.
+    }
+
+    /// Get the resize increments of the window.
+    pub fn resize_increments(&self) -> Option<LogicalSize<u32>> {
+        self.resize_increments
+    }
+
     fn apply_custom_cursor(&self, cursor: &CustomCursor) {
         self.apply_on_pointer(|pointer, data| {
             let surface = pointer.surface();
@@ -780,10 +841,6 @@ impl WindowState {
         });
     }
 
-    pub fn min_surface_size(&self) -> Option<LogicalSize<u32>> {
-        self.min_surface_size
-    }
-
     /// Set maximum inner window size.
     pub fn set_min_surface_size(&mut self, size: Option<LogicalSize<u32>>) {
         // Ensure that the window has the right minimum size.
@@ -802,10 +859,6 @@ impl WindowState {
         self.window.set_min_size(Some(size.into()));
     }
 
-    pub fn max_surface_size(&self) -> Option<LogicalSize<u32>> {
-        self.max_surface_size
-    }
-
     /// Set maximum inner window size.
     pub fn set_max_surface_size(&mut self, size: Option<LogicalSize<u32>>) {
         let size = size.map(|size| {
@@ -824,7 +877,7 @@ impl WindowState {
         self.theme = theme;
         #[cfg(feature = "sctk-adwaita")]
         if let Some(frame) = self.frame.as_mut() {
-            frame.set_config(into_sctk_adwaita_config(theme))
+            frame.set_config(create_sctk_adwaita_config(theme))
         }
     }
 
@@ -860,7 +913,7 @@ impl WindowState {
             None => {
                 return Err(
                     NotSupportedError::new("zwp_pointer_constraints is not available").into()
-                )
+                );
             },
         };
 
@@ -963,7 +1016,7 @@ impl WindowState {
     /// Whether show or hide client side decorations.
     #[inline]
     pub fn set_decorate(&mut self, decorate: bool) {
-        if decorate == self.decorate {
+        if decorate == self.decorate && !self.prefer_csd {
             return;
         }
 
@@ -974,6 +1027,9 @@ impl WindowState {
                 // To disable decorations we should request client and hide the frame.
                 self.window.request_decoration_mode(Some(DecorationMode::Client))
             },
+            _ if self.decorate && self.prefer_csd => {
+                self.window.request_decoration_mode(Some(DecorationMode::Client))
+            },
             _ if self.decorate => self.window.request_decoration_mode(Some(DecorationMode::Server)),
             _ => (),
         }
@@ -1045,11 +1101,7 @@ impl WindowState {
             text_input.set_state(self.text_input_state.as_ref(), state_change);
         }
 
-        if state_change {
-            Ok(Some(self.text_input_state.is_some()))
-        } else {
-            Ok(None)
-        }
+        if state_change { Ok(Some(self.text_input_state.is_some())) } else { Ok(None) }
     }
 
     /// Set the scale factor for the given window.
@@ -1067,24 +1119,37 @@ impl WindowState {
         }
     }
 
-    pub fn is_blurred(&self) -> bool {
-        self.blur.is_some()
-    }
+    /// Make window background blurred.
+    ///
+    /// Returns `true` if redraw is required.
+    #[must_use]
+    pub fn set_blur(&mut self, blurred: bool) -> bool {
+        if !blurred {
+            self.blur = None;
+            return true;
+        }
 
-    /// Make window background blurred
-    #[inline]
-    pub fn set_blur(&mut self, blurred: bool) {
-        if blurred && self.blur.is_none() {
-            if let Some(blur_manager) = self.blur_manager.as_ref() {
-                let blur = blur_manager.blur(self.window.wl_surface(), &self.queue_handle);
-                blur.commit();
-                self.blur = Some(blur);
-            } else {
-                info!("Blur manager unavailable, unable to change blur")
-            }
-        } else if !blurred && self.blur.is_some() {
-            self.blur_manager.as_ref().unwrap().unset(self.window.wl_surface());
-            self.blur.take().unwrap().release();
+        let mgr = match self.blur_manager.as_mut() {
+            Some(mgr) => mgr,
+            None => {
+                info!("Blur manager unavailable, unable to change blur");
+                return false;
+            },
+        };
+
+        let blur = match self.blur.as_ref() {
+            Some(blur) => blur,
+            None => {
+                self.blur = Some(mgr.new_blur_effect(self.window.wl_surface(), &self.queue_handle));
+                self.blur.as_ref().unwrap()
+            },
+        };
+
+        if let Ok(region) = Region::new(&*self.compositor) {
+            region.add(0, 0, i32::MAX, i32::MAX);
+            blur.set_blur(Some(&region))
+        } else {
+            false
         }
     }
 
@@ -1111,11 +1176,6 @@ impl WindowState {
         self.title = title;
     }
 
-    pub fn window_icon(&self) -> Option<winit_core::icon::Icon> {
-        warn!("getting the window icon is unimplemented on Wayland");
-        None
-    }
-
     /// Set the window's icon
     pub fn set_window_icon(&mut self, window_icon: Option<winit_core::icon::Icon>) {
         let xdg_toplevel_icon_manager = match self.xdg_toplevel_icon_manager.as_ref() {
@@ -1155,10 +1215,6 @@ impl WindowState {
         }
     }
 
-    pub fn is_transparent(&self) -> bool {
-        self.transparent
-    }
-
     /// Mark the window as transparent.
     #[inline]
     pub fn set_transparent(&mut self, transparent: bool) {
@@ -1191,10 +1247,6 @@ impl WindowState {
 
 impl Drop for WindowState {
     fn drop(&mut self) {
-        if let Some(blur) = self.blur.take() {
-            blur.release();
-        }
-
         if let Some(fs) = self.fractional_scale.take() {
             fs.destroy();
         }
@@ -1249,12 +1301,14 @@ fn resize_direction_to_xdg(direction: ResizeDirection) -> XdgResizeEdge {
     }
 }
 
-// NOTE: Rust doesn't allow `From<Option<Theme>>`.
 #[cfg(feature = "sctk-adwaita")]
-fn into_sctk_adwaita_config(theme: Option<Theme>) -> sctk_adwaita::FrameConfig {
-    match theme {
+fn create_sctk_adwaita_config(theme: Option<Theme>) -> sctk_adwaita::FrameConfig {
+    let config = match theme {
         Some(Theme::Light) => sctk_adwaita::FrameConfig::light(),
         Some(Theme::Dark) => sctk_adwaita::FrameConfig::dark(),
         None => sctk_adwaita::FrameConfig::auto(),
-    }
+    };
+    #[cfg(feature = "csd-adwaita-notitlebar")]
+    let config = config.hide_titlebar(true);
+    config
 }

winit-web/src/async/abortable.rs

@@ -2,8 +2,8 @@ use std::error::Error;
 use std::fmt::{self, Display, Formatter};
 use std::future::Future;
 use std::pin::Pin;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::task::{Context, Poll};
 
 use pin_project::pin_project;

winit-web/src/async/channel.rs

@@ -1,7 +1,7 @@
 use std::future;
+use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{self, RecvError, SendError, TryRecvError};
-use std::sync::Arc;
 use std::task::Poll;
 
 use super::AtomicWaker;

winit-web/src/async/concurrent_queue.rs

@@ -32,13 +32,10 @@ impl<T> ConcurrentQueue<T> {
     }
 
     pub fn pop(&self) -> Result<T, PopError> {
-        self.queue.borrow_mut().pop().ok_or_else(|| {
-            if self.closed.get() {
-                PopError::Closed
-            } else {
-                PopError::Empty
-            }
-        })
+        self.queue
+            .borrow_mut()
+            .pop()
+            .ok_or_else(|| if self.closed.get() { PopError::Closed } else { PopError::Empty })
     }
 
     pub fn close(&self) -> bool {

winit-web/src/async/dispatcher.rs

@@ -6,7 +6,7 @@ use std::rc::Rc;
 use std::sync::{Arc, Condvar, Mutex};
 
 use super::super::main_thread::MainThreadMarker;
-use super::{channel, Receiver, Sender, Wrapper};
+use super::{Receiver, Sender, Wrapper, channel};
 
 pub struct Dispatcher<T: 'static>(Wrapper<T, Arc<Sender<Closure<T>>>, Closure<T>>);
 

winit-web/src/async/mod.rs

@@ -12,7 +12,7 @@ pub(crate) use atomic_waker::AtomicWaker;
 use concurrent_queue::{ConcurrentQueue, PushError};
 
 pub use self::abortable::{AbortHandle, Abortable, DropAbortHandle};
-pub use self::channel::{channel, Receiver, Sender};
+pub use self::channel::{Receiver, Sender, channel};
 pub use self::dispatcher::{DispatchRunner, Dispatcher};
 pub use self::notifier::{Notified, Notifier};
 pub(crate) use self::wrapper::Wrapper;

winit-web/src/cursor.rs

@@ -6,14 +6,14 @@ use std::ops::{Deref, DerefMut};
 use std::pin::Pin;
 use std::rc::Rc;
 use std::sync::Arc;
-use std::task::{ready, Context, Poll, Waker};
+use std::task::{Context, Poll, Waker, ready};
 use std::time::Duration;
 
 use cursor_icon::CursorIcon;
 use js_sys::{Array, Object};
+use wasm_bindgen::JsCast;
 use wasm_bindgen::closure::Closure;
 use wasm_bindgen::prelude::wasm_bindgen;
-use wasm_bindgen::JsCast;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{
     Blob, Document, DomException, HtmlCanvasElement, HtmlImageElement, ImageBitmap,
@@ -21,11 +21,11 @@ use web_sys::{
 };
 use winit_core::cursor::{Cursor, CursorImage, CustomCursorProvider, CustomCursorSource};
 
+use crate::CustomCursorError;
+use crate::r#async::{AbortHandle, Abortable, DropAbortHandle, Notified, Notifier};
 use crate::backend::Style;
 use crate::event_loop::ActiveEventLoop;
 use crate::main_thread::{MainThreadMarker, MainThreadSafe};
-use crate::r#async::{AbortHandle, Abortable, DropAbortHandle, Notified, Notifier};
-use crate::CustomCursorError;
 
 #[derive(Clone, Debug)]
 pub struct CustomCursor {
@@ -216,7 +216,7 @@ impl CursorHandler {
             Cursor::Custom(cursor) => {
                 let cursor = match cursor.cast_ref::<CustomCursor>() {
                     Some(cursor) => cursor,
-                    None => todo!(),
+                    None => return,
                 };
 
                 if let SelectedCursor::Loading { cursor: old_cursor, .. }
@@ -487,7 +487,7 @@ fn from_rgba(
     window: &Window,
     document: Document,
     image: &CursorImage,
-) -> impl Future<Output = Result<Image, CustomCursorError>> {
+) -> impl Future<Output = Result<Image, CustomCursorError>> + use<> {
     // 1. Create an `ImageData` from the RGBA data.
     // 2. Create an `ImageBitmap` from the `ImageData`.
     // 3. Draw `ImageBitmap` on an `HTMLCanvasElement`.

winit-web/src/event_loop/mod.rs

@@ -5,7 +5,7 @@ use winit_core::error::{EventLoopError, NotSupportedError};
 use winit_core::event_loop::ActiveEventLoop as RootActiveEventLoop;
 
 use crate::{
-    backend, HasMonitorPermissionFuture, MonitorPermissionFuture, PollStrategy, WaitUntilStrategy,
+    HasMonitorPermissionFuture, MonitorPermissionFuture, PollStrategy, WaitUntilStrategy, backend,
 };
 
 mod proxy;
@@ -39,32 +39,8 @@ impl EventLoop {
         EVENT_LOOP_CREATED.store(false, Ordering::Relaxed);
     }
 
-    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 register_app<A: ApplicationHandler + 'static>(self, app: A) {
+        self.elw.run(Box::new(app));
     }
 
     pub fn window_target(&self) -> &dyn RootActiveEventLoop {

winit-web/src/event_loop/proxy.rs

@@ -1,13 +1,13 @@
 use std::future;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::task::Poll;
 
 use winit_core::event_loop::EventLoopProxyProvider;
 
 use super::super::main_thread::MainThreadMarker;
-use crate::event_loop::runner::WeakShared;
 use crate::r#async::{AtomicWaker, Wrapper};
+use crate::event_loop::runner::WeakShared;
 
 #[derive(Debug)]
 pub struct EventLoopProxy(Wrapper<WeakShared, Arc<State>, ()>);

winit-web/src/event_loop/runner.rs

@@ -6,8 +6,8 @@ use std::sync::Arc;
 use std::{fmt, iter};
 
 use dpi::PhysicalSize;
-use wasm_bindgen::prelude::Closure;
 use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::Closure;
 use web_sys::{Document, KeyboardEvent, Navigator, PageTransitionEvent, PointerEvent, WheelEvent};
 use web_time::{Duration, Instant};
 use winit_core::application::ApplicationHandler;
@@ -19,14 +19,14 @@ use winit_core::window::WindowId;
 
 use super::proxy::EventLoopProxy;
 use super::state::State;
+use crate::r#async::DispatchRunner;
 use crate::backend::{EventListenerHandle, SafeAreaHandle};
 use crate::event_loop::ActiveEventLoop;
 use crate::main_thread::MainThreadMarker;
 use crate::monitor::MonitorHandler;
-use crate::r#async::DispatchRunner;
-use crate::web_sys::event::mouse_button_to_id;
+use crate::web_sys::event::ButtonsState;
 use crate::window::Inner;
-use crate::{backend, event, EventLoop, PollStrategy, WaitUntilStrategy};
+use crate::{EventLoop, PollStrategy, WaitUntilStrategy, backend, event};
 
 #[derive(Debug)]
 pub struct Shared(Rc<Execution>);
@@ -48,7 +48,6 @@ struct Execution {
     exit: Cell<bool>,
     runner: RefCell<RunnerEnum>,
     suspended: Cell<bool>,
-    event_loop_recreation: Cell<bool>,
     events: RefCell<VecDeque<Event>>,
     id: Cell<usize>,
     window: web_sys::Window,
@@ -195,7 +194,6 @@ impl Shared {
                 exit: Cell::new(false),
                 runner: RefCell::new(RunnerEnum::Pending),
                 suspended: Cell::new(false),
-                event_loop_recreation: Cell::new(false),
                 events: RefCell::new(VecDeque::new()),
                 window,
                 navigator,
@@ -318,8 +316,10 @@ impl Shared {
                 // chorded button event
                 let device_id = event::mkdid(event.pointer_id());
 
-                if let Some(button) = backend::event::mouse_button(&event) {
-                    let state = if backend::event::mouse_buttons(&event).contains(button.into()) {
+                if let Some(button) = backend::event::raw_button(&event) {
+                    let state = if backend::event::pointer_buttons(&event)
+                        .contains(ButtonsState::from_bits_retain(button))
+                    {
                         ElementState::Pressed
                     } else {
                         ElementState::Released
@@ -327,10 +327,7 @@ impl Shared {
 
                     runner.send_event(Event::DeviceEvent {
                         device_id,
-                        event: DeviceEvent::Button {
-                            button: mouse_button_to_id(button).into(),
-                            state,
-                        },
+                        event: DeviceEvent::Button { button: button.into(), state },
                     });
 
                     return;
@@ -338,14 +335,16 @@ impl Shared {
 
                 // pointer move event
                 let mut delta = backend::event::MouseDelta::init(&navigator, &event);
-                runner.send_events(backend::event::pointer_move_event(event).map(|event| {
-                    let delta = delta.delta(&event).to_physical(backend::scale_factor(&window));
+                runner.send_events(backend::event::pointer_move_event(event).map(
+                    |event: web_sys::PointerEvent| {
+                        let delta = delta.delta(&event).to_physical(backend::scale_factor(&window));
 
-                    Event::DeviceEvent {
-                        device_id,
-                        event: DeviceEvent::PointerMotion { delta: (delta.x, delta.y) },
-                    }
-                }));
+                        Event::DeviceEvent {
+                            device_id,
+                            event: DeviceEvent::PointerMotion { delta: (delta.x, delta.y) },
+                        }
+                    },
+                ));
             }),
         ));
         let runner = self.clone();
@@ -375,11 +374,11 @@ impl Shared {
                     return;
                 }
 
-                let button = backend::event::mouse_button(&event).expect("no mouse button pressed");
+                let button = backend::event::raw_button(&event).expect("no pointer button pressed");
                 runner.send_event(Event::DeviceEvent {
                     device_id: event::mkdid(event.pointer_id()),
                     event: DeviceEvent::Button {
-                        button: mouse_button_to_id(button).into(),
+                        button: button.into(),
                         state: ElementState::Pressed,
                     },
                 });
@@ -394,11 +393,11 @@ impl Shared {
                     return;
                 }
 
-                let button = backend::event::mouse_button(&event).expect("no mouse button pressed");
+                let button = backend::event::raw_button(&event).expect("no pointer button pressed");
                 runner.send_event(Event::DeviceEvent {
                     device_id: event::mkdid(event.pointer_id()),
                     event: DeviceEvent::Button {
-                        button: mouse_button_to_id(button).into(),
+                        button: button.into(),
                         state: ElementState::Released,
                     },
                 });
@@ -771,9 +770,7 @@ impl Shared {
         // * For each undropped `Window`:
         //     * The `register_redraw_request` closure.
         //     * The `destroy_fn` closure.
-        if self.0.event_loop_recreation.get() {
-            EventLoop::allow_event_loop_recreation();
-        }
+        EventLoop::allow_event_loop_recreation();
     }
 
     // Check if the event loop is currently closed
@@ -801,21 +798,13 @@ impl Shared {
             DeviceEvents::Always => true,
             DeviceEvents::WhenFocused => {
                 self.0.all_canvases.borrow().iter().any(|(_, canvas, _)| {
-                    if let Some(canvas) = canvas.upgrade() {
-                        canvas.has_focus.get()
-                    } else {
-                        false
-                    }
+                    if let Some(canvas) = canvas.upgrade() { canvas.has_focus.get() } else { false }
                 })
             },
             DeviceEvents::Never => false,
         }
     }
 
-    pub fn event_loop_recreation(&self, allow: bool) {
-        self.0.event_loop_recreation.set(allow)
-    }
-
     pub(crate) fn control_flow(&self) -> ControlFlow {
         self.0.control_flow.get()
     }

winit-web/src/event_loop/window_target.rs

@@ -56,8 +56,7 @@ impl ActiveEventLoop {
         Self { runner: runner::Shared::new(), modifiers: ModifiersShared::default() }
     }
 
-    pub(crate) fn run(&self, app: Box<dyn ApplicationHandler>, event_loop_recreation: bool) {
-        self.runner.event_loop_recreation(event_loop_recreation);
+    pub(crate) fn run(&self, app: Box<dyn ApplicationHandler>) {
         self.runner.start(app, self.clone());
     }
 
@@ -522,13 +521,8 @@ impl RootActiveEventLoop for ActiveEventLoop {
     }
 
     fn system_theme(&self) -> Option<Theme> {
-        backend::is_dark_mode(self.runner.window()).map(|is_dark_mode| {
-            if is_dark_mode {
-                Theme::Dark
-            } else {
-                Theme::Light
-            }
-        })
+        backend::is_dark_mode(self.runner.window())
+            .map(|is_dark_mode| if is_dark_mode { Theme::Dark } else { Theme::Light })
     }
 
     fn set_control_flow(&self, control_flow: ControlFlow) {

winit-web/src/lib.rs

@@ -61,9 +61,7 @@
 // compliant way.
 
 macro_rules! os_error {
-    ($error:expr) => {{
-        winit_core::error::OsError::new(line!(), file!(), $error)
-    }};
+    ($error:expr) => {{ winit_core::error::OsError::new(line!(), file!(), $error) }};
 }
 
 mod r#async;
@@ -87,7 +85,6 @@ use std::task::{Context, Poll};
 use ::web_sys::HtmlCanvasElement;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use winit_core::application::ApplicationHandler;
 use winit_core::cursor::{CustomCursor, CustomCursorSource};
 use winit_core::error::NotSupportedError;
 use winit_core::event_loop::ActiveEventLoop;
@@ -239,30 +236,6 @@ impl Default for WindowAttributesWeb {
 
 /// Additional methods on `EventLoop` that are specific to the Web.
 pub trait EventLoopExtWeb {
-    /// Initializes the winit event loop.
-    ///
-    /// Unlike
-    #[cfg_attr(target_feature = "exception-handling", doc = "`run_app()`")]
-    #[cfg_attr(
-        not(target_feature = "exception-handling"),
-        doc = "[`run_app()`]"
-    )]
-    /// [^1], this returns immediately, and doesn't throw an exception in order to
-    /// satisfy its [`!`] return type.
-    ///
-    /// Once the event loop has been destroyed, it's possible to reinitialize another event loop
-    /// by calling this function again. This can be useful if you want to recreate the event loop
-    /// while the WebAssembly module is still loaded. For example, this can be used to recreate the
-    /// event loop when switching between tabs on a single page application.
-    #[rustfmt::skip]
-    ///
-    #[cfg_attr(
-        not(target_feature = "exception-handling"),
-        doc = "[`run_app()`]: EventLoop::run_app()"
-    )]
-    /// [^1]: `run_app()` is _not_ available on Wasm when the target supports `exception-handling`.
-    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A);
-
     /// Sets the strategy for [`ControlFlow::Poll`].
     ///
     /// See [`PollStrategy`].