Add EventLoopProxy::into_waker

.github/ISSUE_TEMPLATE/bug_ios.yml

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

.github/ISSUE_TEMPLATE/bug_macos.yml

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

.github/ISSUE_TEMPLATE/bug_windows.yml

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

.github/workflows/ci.yml

@@ -55,7 +55,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        toolchain: [stable, nightly, '1.85']
+        toolchain: [stable, nightly, '1.80']
         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.85'
+          - toolchain: '1.80'
             platform: { name: 'Android' }
           # Redox OS doesn't follow MSRV
-          - toolchain: '1.85'
+          - toolchain: '1.80'
             platform: { name: 'Redox OS' }
         include:
-          - toolchain: '1.85'
+          - toolchain: '1.80'
             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@v6
+      uses: actions/cache/restore@v4
       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 smol_str --precise 0.3.2 && cargo update -p unicode-segmentation --precise 1.12.0 && cargo update -p wayland-protocols --precise 0.32.12
+      run: cargo generate-lockfile && cargo update -p ahash --precise 0.8.7 && cargo update -p bumpalo --precise 3.14.0
 
     - 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@v6
+      uses: actions/cache@v4
       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@v3
+    - uses: taiki-e/cache-cargo-install-action@v2
       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.85'
+        matrix.toolchain != '1.80'
       run: cargo test -p dpi
 
     - name: Check dpi crate (no_std)
       if: >
         contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.85'
+        matrix.toolchain != '1.80'
       run: cargo check -p dpi --no-default-features
 
     - name: Build tests
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.85'
+        matrix.toolchain != '1.80'
       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.85'
+        matrix.toolchain != '1.80'
       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.85'
+        matrix.toolchain != '1.80'
       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.85'
+        matrix.toolchain != '1.80'
       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@v6
+      uses: actions/cache/save@v4
       with:
         path: |
           ~/.cargo/registry/index/
@@ -290,14 +290,31 @@ jobs:
         key: cargo-${{ matrix.toolchain }}-${{ matrix.platform.name }}-${{ hashFiles('Cargo.lock') }}
 
   cargo-deny:
-    name: Run cargo-deny
+    name: Run cargo-deny on ${{ matrix.platform.name }}
     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
@@ -312,7 +329,7 @@ jobs:
       - name: Setup NPM
         run: npm install
       - name: Run ESLint
-        run: npx eslint@9.38.0
+        run: npx eslint
 
   swc:
     name: Minimize JavaScript

.github/workflows/docs.yml

@@ -19,7 +19,7 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v5
 
       - 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@v6
+        uses: actions/configure-pages@v5
 
       - name: Fix permissions
         run: |
@@ -41,10 +41,10 @@ jobs:
           done
 
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v5
+        uses: actions/upload-pages-artifact@v4
         with:
           path: target/doc
 
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v5
+        uses: actions/deploy-pages@v4

Cargo.toml

@@ -4,26 +4,26 @@ members = ["dpi", "winit*"]
 resolver = "2"
 
 [workspace.package]
-edition = "2024"
+edition = "2021"
 license = "Apache-2.0"
 repository = "https://github.com/rust-windowing/winit"
-rust-version = "1.85"
+rust-version = "1.80"
-version = "0.31.0-beta.2"
+version = "0.30.12"
 
 [workspace.dependencies]
 # Workspace dependencies.
 # `winit` has no version here to allow using it in dev deps for docs.
 winit = { path = "winit" }
-winit-android = { version = "=0.31.0-beta.2", path = "winit-android" }
+winit-android = { version = "0.30.12", path = "winit-android" }
-winit-appkit = { version = "=0.31.0-beta.2", path = "winit-appkit" }
+winit-appkit = { version = "0.30.12", path = "winit-appkit" }
-winit-common = { version = "=0.31.0-beta.2", path = "winit-common" }
+winit-common = { version = "0.30.12", path = "winit-common" }
-winit-core = { version = "=0.31.0-beta.2", path = "winit-core" }
+winit-core = { version = "0.30.12", path = "winit-core" }
-winit-orbital = { version = "=0.31.0-beta.2", path = "winit-orbital" }
+winit-orbital = { version = "0.30.12", path = "winit-orbital" }
-winit-uikit = { version = "=0.31.0-beta.2", path = "winit-uikit" }
+winit-uikit = { version = "0.30.12", path = "winit-uikit" }
-winit-wayland = { version = "=0.31.0-beta.2", path = "winit-wayland", default-features = false }
+winit-wayland = { version = "0.30.12", path = "winit-wayland", default-features = false }
-winit-web = { version = "=0.31.0-beta.2", path = "winit-web" }
+winit-web = { version = "0.30.12", path = "winit-web" }
-winit-win32 = { version = "=0.31.0-beta.2", path = "winit-win32" }
+winit-win32 = { version = "0.30.12", path = "winit-win32" }
-winit-x11 = { version = "=0.31.0-beta.2", path = "winit-x11" }
+winit-x11 = { version = "0.30.12", 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.8", default-features = false, features = [
+softbuffer = { version = "0.4.6", default-features = false, features = [
     "x11",
     "x11-dlopen",
     "wayland",
@@ -55,33 +55,40 @@ 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.2", default-features = false }
+objc2-app-kit = { version = "0.3.1", default-features = false }
-objc2-core-foundation = { version = "0.3.2", default-features = false }
+objc2-core-foundation = { version = "0.3.1", default-features = false }
-objc2-core-graphics = { version = "0.3.2", default-features = false }
+objc2-core-graphics = { version = "0.3.1", default-features = false }
-objc2-core-video = { version = "0.3.2", default-features = false }
+objc2-core-video = { version = "0.3.1", default-features = false }
-objc2-foundation = { version = "0.3.2", default-features = false }
+objc2-foundation = { version = "0.3.1", default-features = false }
-objc2-ui-kit = { version = "0.3.2", default-features = false }
+objc2-ui-kit = { version = "0.3.1", default-features = false }
 
 # Windows dependencies.
 unicode-segmentation = "1.7.1"
-windows-sys = "0.61"
+windows-sys = "0.59.0"
 
 # Linux dependencies.
+ahash = { version = "0.8.7", features = ["no-rng"] }
 bytemuck = { version = "1.13.1", default-features = false }
-calloop = "0.14.3"
+calloop = "0.13.0"
-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_event = { package = "redox_event", version = "0.4.5" }
+redox_syscall = "0.5.7"
 
 # Web dependencies.
 atomic-waker = "1"

README.md

@@ -8,7 +8,7 @@
 
 ```toml
 [dependencies]
-winit = "0.31.0-beta.2"
+winit = "0.30.12"
 ```
 
 ## [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.85**. Changes to
+This crate's Minimum Supported Rust Version (MSRV) is **1.80**. 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,11 +1,4 @@
 # 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" },
@@ -17,9 +10,6 @@ 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,25 +1,27 @@
 # https://embarkstudios.github.io/cargo-deny
 # cargo install cargo-deny
-# cargo update && cargo deny check
+# 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
 [graph]
 all-features = true
 exclude-dev = true
 targets = [
-    "aarch64-apple-darwin",
+    { triple = "aarch64-apple-darwin" },
-    "aarch64-apple-ios",
+    { triple = "aarch64-apple-ios" },
-    "aarch64-linux-android",
+    { triple = "aarch64-linux-android" },
-    "i686-pc-windows-gnu",
+    { triple = "i686-pc-windows-gnu" },
-    "i686-pc-windows-msvc",
+    { triple = "i686-pc-windows-msvc" },
-    "i686-unknown-linux-gnu",
+    { triple = "i686-unknown-linux-gnu" },
     { triple = "wasm32-unknown-unknown", features = [
         "atomics",
     ] },
-    "x86_64-apple-darwin",
+    { triple = "x86_64-apple-darwin" },
-    "x86_64-apple-ios",
+    { triple = "x86_64-apple-ios" },
-    "x86_64-pc-windows-gnu",
+    { triple = "x86_64-pc-windows-gnu" },
-    "x86_64-pc-windows-msvc",
+    { triple = "x86_64-pc-windows-msvc" },
-    "x86_64-unknown-linux-gnu",
+    { triple = "x86_64-unknown-linux-gnu" },
-    "x86_64-unknown-redox",
+    { triple = "x86_64-unknown-redox" },
 ]
 
 [licenses]
@@ -30,8 +32,6 @@ 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,23 +39,42 @@ private = { ignore = true }
 [bans]
 multiple-versions = "deny"
 skip = [
-    { crate = "jni-sys@0.3", reason = "uses the semver trick to depend on v0.4, but `ndk` hasn't been updated to v0.4 yet" },
+    { crate = "bitflags@1", reason = "the ecosystem is in the process of migrating" },
-    { crate = "thiserror@1.0", reason = "dep of `ndk` crate, yet to be updated" },
+    { crate = "rustix@0.38", reason = "the ecosystem is in the process of migrating" },
-    { crate = "thiserror-impl@1.0", reason = "dep of `thiserror`" },
+    { crate = "linux-raw-sys@0.4", reason = "the ecosystem is in the process of migrating" },
-    { 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_cfg), doc(auto_cfg(hide(doc, docsrs))))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
 #![cfg_attr(feature = "std", forbid(unsafe_code))]
 #![no_std]
 
@@ -84,18 +84,36 @@ pub trait Pixel: Copy + Into<f64> {
     }
 }
 
-macro_rules! pixel_int_impl {
+impl Pixel for u8 {
-    ($($t:ty),*) => {$(
-        impl Pixel for $t {
     fn from_f64(f: f64) -> Self {
-                round(f) as $t
+        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
+    }
 }
-
-pixel_int_impl!(u8, u16, u32, i8, i16, i32);
-
 impl Pixel for f32 {
     fn from_f64(f: f64) -> Self {
         f as f32
@@ -360,48 +378,6 @@ 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
@@ -444,7 +420,43 @@ impl<P: Pixel> LogicalPosition<P> {
     }
 }
 
-vec2_from_impls!(LogicalPosition, x, y, Point2);
+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 }
+    }
+}
 
 /// A position represented in physical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
@@ -484,7 +496,43 @@ impl<P: Pixel> PhysicalPosition<P> {
     }
 }
 
-vec2_from_impls!(PhysicalPosition, x, y, Point2);
+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 }
+    }
+}
 
 /// A size represented in logical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
@@ -524,7 +572,43 @@ impl<P: Pixel> LogicalSize<P> {
     }
 }
 
-vec2_from_impls!(LogicalSize, width, height, Vector2);
+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 }
+    }
+}
 
 /// A size represented in physical pixels.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Default, Hash)]
@@ -561,7 +645,43 @@ impl<P: Pixel> PhysicalSize<P> {
     }
 }
 
-vec2_from_impls!(PhysicalSize, width, height, Vector2);
+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 }
+    }
+}
 
 /// A size that's either physical or logical.
 #[derive(Debug, Copy, Clone, PartialEq)]

examples

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

examples/application.rs

@@ -1,30 +1,31 @@
 //! Simple winit application.
-//!
-//! Note that a real application accepting text input **should** support
-//! the IME interface. See the `ime` example.
 
-use std::borrow::Cow;
 use std::collections::HashMap;
 use std::error::Error;
 use std::fmt::Debug;
+#[cfg(not(android_platform))]
 use std::num::NonZeroU32;
-use std::sync::Arc;
 use std::sync::mpsc::{self, Receiver, Sender};
-#[cfg(not(web_platform))]
+use std::sync::Arc;
+#[cfg(all(not(android_platform), not(web_platform)))]
 use std::time::Instant;
-use std::{fmt, mem};
+use std::{cmp, fmt, mem};
 
+use ::tracing::{error, info};
 use cursor_icon::CursorIcon;
+use dpi::LogicalPosition;
+#[cfg(not(android_platform))]
+use rwh_06::{DisplayHandle, HasDisplayHandle};
+#[cfg(not(android_platform))]
 use softbuffer::{Context, Surface};
-use tracing::{error, info};
+#[cfg(all(web_platform, not(android_platform)))]
-#[cfg(web_platform)]
 use web_time::Instant;
 use winit::application::ApplicationHandler;
 use winit::cursor::{Cursor, CustomCursor, CustomCursorSource};
 use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
 use winit::error::RequestError;
-use winit::event::{DeviceEvent, DeviceId, MouseButton, MouseScrollDelta, WindowEvent};
+use winit::event::{DeviceEvent, DeviceId, Ime, MouseButton, MouseScrollDelta, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+use winit::event_loop::{ActiveEventLoop, EventLoop};
 use winit::icon::{Icon, RgbaIcon};
 use winit::keyboard::{Key, ModifiersState};
 use winit::monitor::Fullscreen;
@@ -38,20 +39,28 @@ use winit::platform::wayland::{ActiveEventLoopExtWayland, WindowAttributesWaylan
 use winit::platform::web::{ActiveEventLoopExtWeb, WindowAttributesWeb};
 #[cfg(x11_platform)]
 use winit::platform::x11::{ActiveEventLoopExtX11, WindowAttributesX11};
-use winit::window::{CursorGrabMode, ResizeDirection, Theme, Window, WindowAttributes, WindowId};
+use winit::window::{
+    CursorGrabMode, ImeCapabilities, ImeEnableRequest, ImePurpose, ImeRequestData,
+    ImeSurroundingText, ResizeDirection, Theme, Window, WindowAttributes, WindowId,
+};
 use winit_core::application::macos::ApplicationHandlerExtMacOS;
+use winit_core::window::ImeRequest;
 
 #[path = "util/tracing.rs"]
-mod tracing_init;
+mod tracing;
+
+#[path = "util/fill.rs"]
+mod fill;
 
 /// The amount of points to around the window for drag resize direction calculations.
 const BORDER_SIZE: f64 = 20.;
+const IME_CURSOR_SIZE: PhysicalSize<u32> = PhysicalSize::new(20, 20);
 
 fn main() -> Result<(), Box<dyn Error>> {
     #[cfg(web_platform)]
     console_error_panic_hook::set_once();
 
-    tracing_init::init();
+    tracing::init();
 
     let event_loop = EventLoop::new()?;
     let (sender, receiver) = mpsc::channel();
@@ -90,12 +99,22 @@ struct Application {
     /// Drawing context.
     ///
     /// With OpenGL it could be EGLDisplay.
-    context: Context<OwnedDisplayHandle>,
+    #[cfg(not(android_platform))]
+    context: Option<Context<DisplayHandle<'static>>>,
 }
 
 impl Application {
     fn new(event_loop: &EventLoop, receiver: Receiver<Action>, sender: Sender<Action>) -> Self {
-        let context = Context::new(event_loop.owned_display_handle()).unwrap();
+        // SAFETY: we drop the context right before the event loop is stopped, thus making it safe.
+        #[cfg(not(android_platform))]
+        let context = Some(
+            Context::new(unsafe {
+                std::mem::transmute::<DisplayHandle<'_>, DisplayHandle<'static>>(
+                    event_loop.display_handle().unwrap(),
+                )
+            })
+            .unwrap(),
+        );
 
         // You'll have to choose an icon size at your own discretion. On X11, the desired size
         // varies by WM, and on Windows, you still have to account for screen scaling. Here
@@ -113,7 +132,15 @@ impl Application {
         .into_iter()
         .collect();
 
-        Self { receiver, sender, context, custom_cursors, icon, windows: Default::default() }
+        Self {
+            receiver,
+            sender,
+            #[cfg(not(android_platform))]
+            context,
+            custom_cursors,
+            icon,
+            windows: Default::default(),
+        }
     }
 
     fn create_window(
@@ -178,15 +205,6 @@ impl Application {
             Action::DumpMonitors => self.dump_monitors(_event_loop),
             Action::Message => {
                 info!("User wake up");
-                for (id, window) in self.windows.iter() {
-                    if window.emit_surface_size {
-                        let size = window.window.surface_size();
-                        info!(
-                            "Window {id:?} has physical surface size {}x{}",
-                            size.width, size.height
-                        );
-                    }
-                }
             },
             _ => unreachable!("Tried to execute invalid action without `WindowId`"),
         }
@@ -226,13 +244,8 @@ impl Application {
             Action::ToggleSimpleFullscreen => {
                 window.window.set_simple_fullscreen(!window.window.simple_fullscreen());
             },
-            #[cfg(macos_platform)]
-            Action::ToggleBorderlessGame => {
-                let current = window.window.is_borderless_game();
-                window.window.set_borderless_game(!current);
-                info!("Borderless game: {}", !current);
-            },
             Action::ToggleMaximize => window.toggle_maximize(),
+            Action::ToggleImeInput => window.toggle_ime(),
             Action::Minimize => window.minimize(),
             Action::NextCursor => window.next_cursor(),
             Action::NextCustomCursor => {
@@ -305,9 +318,6 @@ impl Application {
                 window.continuous_redraw = !window.continuous_redraw;
                 window.window.request_redraw();
             },
-            Action::EmitSurfaceSize => {
-                window.toggle_emit_surface_size();
-            },
         }
     }
 
@@ -479,9 +489,8 @@ impl ApplicationHandler for Application {
                 let mods = window.modifiers;
                 if let Some(action) = state
                     .is_pressed()
-                    .then(|| button.mouse_button())
+                    .then(|| Self::process_mouse_binding(button.mouse_button(), &mods))
                     .flatten()
-                    .and_then(|button| Self::process_mouse_binding(button, &mods))
                 {
                     self.handle_action_with_window(event_loop, window_id, action);
                 }
@@ -503,6 +512,41 @@ impl ApplicationHandler for Application {
                     }
                 }
             },
+            WindowEvent::Ime(event) => match event {
+                Ime::Enabled => info!("IME enabled for Window={window_id:?}"),
+                Ime::Preedit(text, caret_pos) => {
+                    info!("Preedit: {}, with caret at {:?}", text, caret_pos);
+                },
+                Ime::Commit(text) => {
+                    window.text_field_contents.0.push_str(&text);
+                    window.text_field_contents.1 += text.len();
+
+                    info!("Committed: {}", text);
+                    let request_data = window.get_ime_update();
+                    window.window.request_ime_update(ImeRequest::Update(request_data)).unwrap();
+                },
+                Ime::DeleteSurrounding { before_bytes, after_bytes } => {
+                    let (text, cursor) = &window.text_field_contents;
+
+                    // To anyone copying this, keep in mind that this doesn't take text selection
+                    // into account. The deletion happens *around* the pre-edit,
+                    // and may remove the whole selection or a part of it.
+                    let delete_start = cursor.saturating_sub(before_bytes);
+                    let delete_end = cmp::min(cursor.saturating_add(after_bytes), text.len());
+                    if text.is_char_boundary(delete_start) && text.is_char_boundary(delete_end) {
+                        let new_text = {
+                            let mut t = String::from(&text[..delete_start]);
+                            t.push_str(&text[delete_end..]);
+                            t
+                        };
+                        window.text_field_contents = (new_text, delete_start);
+                        info!("IME deleted bytes: {before_bytes}, {after_bytes}");
+                    } else {
+                        error!("Buggy IME tried to delete with indices not on char boundary.");
+                    }
+                },
+                Ime::Disabled => info!("IME disabled for Window={window_id:?}"),
+            },
             WindowEvent::PinchGesture { delta, .. } => {
                 window.zoom += delta;
                 let zoom = window.zoom;
@@ -529,7 +573,15 @@ impl ApplicationHandler for Application {
             WindowEvent::DoubleTapGesture { .. } => {
                 info!("Smart zoom");
             },
-            _ => (),
+            WindowEvent::TouchpadPressure { .. }
+            | WindowEvent::DragLeft { .. }
+            | WindowEvent::KeyboardInput { .. }
+            | WindowEvent::PointerEntered { .. }
+            | WindowEvent::DragEntered { .. }
+            | WindowEvent::DragMoved { .. }
+            | WindowEvent::DragDropped { .. }
+            | WindowEvent::Destroyed
+            | WindowEvent::Moved(_) => (),
         }
     }
 
@@ -583,8 +635,15 @@ impl ApplicationHandlerExtMacOS for Application {
 
 /// State of the window.
 struct WindowState {
+    ime_enabled: bool,
+    /// The contents of the emulated text field for IME purposes (not displayed).
+    /// (text, cursor position in bytes).
+    text_field_contents: (String, usize),
     /// Render surface.
-    surface: Surface<OwnedDisplayHandle, Arc<dyn Window>>,
+    ///
+    /// NOTE: This surface must be dropped before the `Window`.
+    #[cfg(not(android_platform))]
+    surface: Surface<DisplayHandle<'static>, Arc<dyn Window>>,
     /// The actual winit Window.
     window: Arc<dyn Window>,
     /// The window theme we're drawing with.
@@ -592,11 +651,10 @@ struct WindowState {
     /// Fill the window with animated color
     animated_fill_color: bool,
     /// The application start time. Used for color fill animation
+    #[cfg(not(android_platform))]
     start_time: Instant,
     /// Redraw continuously
     continuous_redraw: bool,
-    /// Periodically emit the surface size
-    emit_surface_size: bool,
     /// Cursor position over the window.
     cursor_position: Option<PhysicalPosition<f64>>,
     /// Window modifiers state.
@@ -625,13 +683,31 @@ impl WindowState {
     fn new(app: &Application, window: Box<dyn Window>) -> Result<Self, Box<dyn Error>> {
         let window: Arc<dyn Window> = Arc::from(window);
 
-        let surface = Surface::new(&app.context, Arc::clone(&window))?;
+        // SAFETY: the surface is dropped before the `window` which provided it with handle, thus
+        // it doesn't outlive it.
+        #[cfg(not(android_platform))]
+        let surface = Surface::new(app.context.as_ref().unwrap(), Arc::clone(&window))?;
 
         let theme = window.theme().unwrap_or(Theme::Dark);
         info!("Theme: {theme:?}");
         let named_idx = 0;
         window.set_cursor(CURSORS[named_idx].into());
 
+        // Allow IME out of the box.
+        let request_data = ImeRequestData::default()
+            .with_purpose(ImePurpose::Normal)
+            .with_cursor_area(LogicalPosition { x: 0, y: 0 }.into(), IME_CURSOR_SIZE.into())
+            .with_surrounding_text(ImeSurroundingText::new(String::new(), 0, 0).unwrap());
+        let enable_request = ImeEnableRequest::new(
+            ImeCapabilities::new().with_purpose().with_cursor_area().with_surrounding_text(),
+            request_data,
+        )
+        .unwrap();
+        let enable_ime = ImeRequest::Enable(enable_request);
+
+        // Initial update
+        window.request_ime_update(enable_ime).unwrap();
+
         let size = window.surface_size();
         let mut state = Self {
             #[cfg(macos_platform)]
@@ -639,13 +715,16 @@ impl WindowState {
             custom_idx: app.custom_cursors.as_ref().map(Vec::len).unwrap_or(1) - 1,
             cursor_grab: CursorGrabMode::None,
             named_idx,
+            #[cfg(not(android_platform))]
             surface,
             window,
             theme,
             animated_fill_color: false,
             continuous_redraw: false,
-            emit_surface_size: false,
+            #[cfg(not(android_platform))]
             start_time: Instant::now(),
+            ime_enabled: true,
+            text_field_contents: (String::new(), 0),
             cursor_position: Default::default(),
             cursor_hidden: Default::default(),
             modifiers: Default::default(),
@@ -659,12 +738,65 @@ impl WindowState {
         Ok(state)
     }
 
+    pub fn get_ime_update(&self) -> ImeRequestData {
+        let (text, cursor) = &self.text_field_contents;
+        // A rudimentary text field emulation: the caret moves right by a constant amount for each
+        // code point.
+
+        let text_before_caret = if text.is_char_boundary(*cursor) { &text[..*cursor] } else { "" };
+        let chars_before_caret = text_before_caret.chars().count();
+        let cursor_pos = LogicalPosition { x: 10 * chars_before_caret as u32, y: 0 }.into();
+
+        // Limit text field size
+        const MAX_BYTES: usize = ImeSurroundingText::MAX_TEXT_BYTES;
+        let minimal_offset = cursor / MAX_BYTES * MAX_BYTES;
+        let first_char_boundary =
+            (minimal_offset..*cursor).find(|off| text.is_char_boundary(*off)).unwrap_or(*cursor);
+        let last_char_boundary = (*cursor..(first_char_boundary + MAX_BYTES))
+            .rev()
+            .find(|off| text.is_char_boundary(*off))
+            .unwrap_or(*cursor);
+        let surrounding_text = &text[first_char_boundary..last_char_boundary];
+        let relative_cursor = cursor - first_char_boundary;
+        let surrounding_text =
+            ImeSurroundingText::new(surrounding_text.into(), relative_cursor, relative_cursor)
+                .expect("Bug in example: bad byte calculations");
+        ImeRequestData::default()
+            .with_purpose(ImePurpose::Normal)
+            .with_cursor_area(cursor_pos, IME_CURSOR_SIZE.into())
+            .with_surrounding_text(surrounding_text)
+    }
+
+    pub fn toggle_ime(&mut self) {
+        if self.ime_enabled {
+            self.window.request_ime_update(ImeRequest::Disable).expect("disable can not fail");
+        } else {
+            let enable_request = ImeEnableRequest::new(
+                ImeCapabilities::new().with_purpose().with_cursor_area().with_surrounding_text(),
+                self.get_ime_update(),
+            )
+            .unwrap();
+            self.window.request_ime_update(ImeRequest::Enable(enable_request)).unwrap();
+        };
+
+        self.ime_enabled = !self.ime_enabled;
+    }
+
     pub fn minimize(&mut self) {
         self.window.set_minimized(true);
     }
 
     pub fn cursor_moved(&mut self, position: PhysicalPosition<f64>) {
+        // the IME really cares about the caret,
+        // but there's nothing else to demonstrate a position
         self.cursor_position = Some(position);
+        if self.ime_enabled {
+            let request_data =
+                ImeRequestData::default().with_cursor_area(position.into(), IME_CURSOR_SIZE.into());
+            self.window
+                .request_ime_update(ImeRequest::Update(request_data))
+                .expect("A capability was not initially declared");
+        }
     }
 
     pub fn cursor_left(&mut self) {
@@ -716,10 +848,6 @@ impl WindowState {
         self.window.set_fullscreen(fullscreen);
     }
 
-    fn toggle_emit_surface_size(&mut self) {
-        self.emit_surface_size = !self.emit_surface_size;
-    }
-
     /// Cycle through the grab modes ignoring errors.
     fn cycle_cursor_grab(&mut self) {
         self.cursor_grab = match self.cursor_grab {
@@ -816,12 +944,15 @@ impl WindowState {
     /// Resize the surface to the new size.
     fn resize(&mut self, size: PhysicalSize<u32>) {
         info!("Surface resized to {size:?}");
-        let (width, height) = match (NonZeroU32::new(size.width), NonZeroU32::new(size.height)) {
+        #[cfg(not(android_platform))]
+        {
+            let (width, height) = match (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
+            {
                 (Some(width), Some(height)) => (width, height),
                 _ => return,
             };
             self.surface.resize(width, height).expect("failed to resize inner buffer");
-
+        }
         self.window.request_redraw();
     }
 
@@ -906,23 +1037,20 @@ impl WindowState {
     }
 
     /// Draw the window contents.
+    #[cfg(not(android_platform))]
     fn draw(&mut self) -> Result<(), Box<dyn Error>> {
         if self.occluded {
             info!("Skipping drawing occluded window={:?}", self.window.id());
             return Ok(());
         }
 
+        if self.animated_fill_color {
+            fill::fill_window_with_animated_color(&*self.window, self.start_time);
+            return Ok(());
+        }
+
         let mut buffer = self.surface.buffer_mut()?;
 
-        if self.animated_fill_color {
-            // Fill the entire buffer with a single color.
-            let time = self.start_time.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;
-            buffer.fill(color);
-        } else {
         // Draw a different color inside the safe area
         let surface_size = self.window.surface_size();
         let insets = self.window.safe_area();
@@ -948,7 +1076,6 @@ impl WindowState {
                 }
             }
         }
-        }
 
         // Present the buffer
         self.window.pre_present_notify();
@@ -956,6 +1083,12 @@ impl WindowState {
 
         Ok(())
     }
+
+    #[cfg(android_platform)]
+    fn draw(&mut self) -> Result<(), Box<dyn Error>> {
+        info!("Drawing but without rendering...");
+        Ok(())
+    }
 }
 
 struct Binding<T: Eq> {
@@ -980,13 +1113,12 @@ enum Action {
     ToggleCursorVisibility,
     CreateNewWindow,
     ToggleResizeIncrements,
+    ToggleImeInput,
     ToggleDecorations,
     ToggleResizable,
     ToggleFullscreen,
     #[cfg(macos_platform)]
     ToggleSimpleFullscreen,
-    #[cfg(macos_platform)]
-    ToggleBorderlessGame,
     ToggleMaximize,
     Minimize,
     NextCursor,
@@ -1010,7 +1142,6 @@ enum Action {
     Message,
     ToggleAnimatedFillColor,
     ToggleContinuousRedraw,
-    EmitSurfaceSize,
 }
 
 impl Action {
@@ -1019,13 +1150,12 @@ impl Action {
             Action::CloseWindow => "Close window",
             Action::ToggleCursorVisibility => "Hide cursor",
             Action::CreateNewWindow => "Create new window",
+            Action::ToggleImeInput => "Toggle IME input",
             Action::ToggleDecorations => "Toggle decorations",
             Action::ToggleResizable => "Toggle window resizable state",
             Action::ToggleFullscreen => "Toggle fullscreen",
             #[cfg(macos_platform)]
             Action::ToggleSimpleFullscreen => "Toggle simple fullscreen",
-            #[cfg(macos_platform)]
-            Action::ToggleBorderlessGame => "Toggle borderless game mode",
             Action::ToggleMaximize => "Maximize",
             Action::Minimize => "Minimize",
             Action::ToggleResizeIncrements => "Use resize increments when resizing window",
@@ -1058,7 +1188,6 @@ impl Action {
             Action::Message => "Prints a message through a user wake up",
             Action::ToggleAnimatedFillColor => "Toggle animated fill color",
             Action::ToggleContinuousRedraw => "Toggle continuous redraw",
-            Action::EmitSurfaceSize => "Periodically print the surface size",
         }
     }
 }
@@ -1130,16 +1259,15 @@ fn modifiers_to_string(mods: ModifiersState) -> String {
     mods_line
 }
 
-fn mouse_button_to_string(button: MouseButton) -> Cow<'static, str> {
+fn mouse_button_to_string(button: MouseButton) -> &'static str {
     match button {
         MouseButton::Left => "LMB",
         MouseButton::Right => "RMB",
         MouseButton::Middle => "MMB",
         MouseButton::Back => "Back",
         MouseButton::Forward => "Forward",
-        other => return format!("button {}", other as u8 + 1).into(),
+        MouseButton::Other(_) => "",
     }
-    .into()
 }
 
 #[cfg(web_platform)]
@@ -1242,6 +1370,7 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
     #[cfg(macos_platform)]
     Binding::new("F", ModifiersState::ALT, Action::ToggleSimpleFullscreen),
     Binding::new("D", ModifiersState::CONTROL, Action::ToggleDecorations),
+    Binding::new("I", ModifiersState::CONTROL, Action::ToggleImeInput),
     Binding::new("L", ModifiersState::CONTROL, Action::CycleCursorGrab),
     Binding::new("P", ModifiersState::CONTROL, Action::ToggleResizeIncrements),
     Binding::new("R", ModifiersState::CONTROL, Action::ToggleResizable),
@@ -1277,9 +1406,6 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
     Binding::new("T", ModifiersState::META, Action::CreateNewTab),
     #[cfg(macos_platform)]
     Binding::new("O", ModifiersState::CONTROL, Action::CycleOptionAsAlt),
-    #[cfg(macos_platform)]
-    Binding::new("B", ModifiersState::CONTROL, Action::ToggleBorderlessGame),
-    Binding::new("S", ModifiersState::ALT, Action::EmitSurfaceSize),
     Binding::new("S", ModifiersState::CONTROL, Action::Message),
 ];
 

examples/child_window.rs

@@ -3,12 +3,10 @@
 fn main() -> Result<(), impl std::error::Error> {
     use std::collections::HashMap;
 
-    use softbuffer::{Context, Surface};
-    use tracing::info;
     use winit::application::ApplicationHandler;
     use winit::dpi::{LogicalPosition, LogicalSize, Position};
     use winit::event::{ElementState, KeyEvent, WindowEvent};
-    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
     use winit::raw_window_handle::HasRawWindowHandle;
     use winit::window::{Window, WindowAttributes, WindowId};
 
@@ -17,20 +15,18 @@ fn main() -> Result<(), impl std::error::Error> {
 
     #[derive(Debug)]
     struct WindowData {
-        surface: Surface<OwnedDisplayHandle, Box<dyn Window>>,
+        window: Box<dyn Window>,
         color: u32,
     }
 
     impl WindowData {
-        fn new(context: &Context<OwnedDisplayHandle>, window: Box<dyn Window>, color: u32) -> Self {
+        fn new(window: Box<dyn Window>, color: u32) -> Self {
-            let surface = Surface::new(context, window).unwrap();
+            Self { window, color }
-            Self { surface, color }
         }
     }
 
-    #[derive(Debug)]
+    #[derive(Default, Debug)]
     struct Application {
-        context: Context<OwnedDisplayHandle>,
         parent_window_id: Option<WindowId>,
         windows: HashMap<WindowId, WindowData>,
     }
@@ -42,10 +38,10 @@ fn main() -> Result<(), impl std::error::Error> {
                 .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
                 .with_surface_size(LogicalSize::new(640.0f32, 480.0f32));
             let window = event_loop.create_window(attributes).unwrap();
-            info!("Parent window id: {:?})", window.id());
+            println!("Parent window id: {:?})", window.id());
             self.parent_window_id = Some(window.id());
 
-            self.windows.insert(window.id(), WindowData::new(&self.context, window, 0xffbbbbbb));
+            self.windows.insert(window.id(), WindowData::new(window, 0xffbbbbbb));
         }
 
         fn window_event(
@@ -60,12 +56,12 @@ fn main() -> Result<(), impl std::error::Error> {
                     event_loop.exit();
                 },
                 WindowEvent::PointerEntered { device_id: _, .. } => {
-                    // On x11, log when the cursor entered in a window even if the child window
+                    // On x11, println when the cursor entered in a window even if the child window
                     // is created by some key inputs.
                     // the child windows are always placed at (0, 0) with size (200, 200) in the
                     // parent window, so we also can see this log when we move
                     // the cursor around (200, 200) in parent window.
-                    info!("cursor entered in the window {window_id:?}");
+                    println!("cursor entered in the window {window_id:?}");
                 },
                 WindowEvent::KeyboardInput {
                     event: KeyEvent { state: ElementState::Pressed, .. },
@@ -76,24 +72,18 @@ fn main() -> Result<(), impl std::error::Error> {
                         0xff000000 + 3_u32.pow((child_index + 2).rem_euclid(16) as u32);
 
                     let parent_window = self.windows.get(&self.parent_window_id.unwrap()).unwrap();
-                    let child_window = spawn_child_window(
+                    let child_window =
-                        parent_window.surface.window().as_ref(),
+                        spawn_child_window(parent_window.window.as_ref(), event_loop, child_index);
-                        event_loop,
-                        child_index,
-                    );
                     let child_id = child_window.id();
-                    info!("Child window created with id: {child_id:?}");
+                    println!("Child window created with id: {child_id:?}");
-                    self.windows.insert(
+                    self.windows.insert(child_id, WindowData::new(child_window, child_color));
-                        child_id,
-                        WindowData::new(&self.context, child_window, child_color),
-                    );
                 },
                 WindowEvent::RedrawRequested => {
-                    if let Some(window) = self.windows.get_mut(&window_id) {
+                    if let Some(window) = self.windows.get(&window_id) {
                         if window_id == self.parent_window_id.unwrap() {
-                            fill::fill(&mut window.surface);
+                            fill::fill_window(window.window.as_ref());
                         } else {
-                            fill::fill_with_color(&mut window.surface, window.color);
+                            fill::fill_window_with_color(window.window.as_ref(), window.color);
                         }
                     }
                 },
@@ -127,8 +117,7 @@ fn main() -> Result<(), impl std::error::Error> {
     }
 
     let event_loop = EventLoop::new().unwrap();
-    let context = Context::new(event_loop.owned_display_handle()).unwrap();
+    event_loop.run_app(Application::default())
-    event_loop.run_app(Application { context, parent_window_id: None, windows: HashMap::new() })
 }
 
 #[cfg(not(any(x11_platform, macos_platform, windows_platform)))]

examples/control_flow.rs

@@ -4,13 +4,12 @@ use std::thread;
 #[cfg(not(web_platform))]
 use std::time;
 
-use softbuffer::{Context, Surface};
+use ::tracing::{info, warn};
-use tracing::{info, warn};
 #[cfg(web_platform)]
 use web_time as time;
 use winit::application::ApplicationHandler;
 use winit::event::{ElementState, KeyEvent, StartCause, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop, OwnedDisplayHandle};
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
 use winit::keyboard::{Key, NamedKey};
 use winit::window::{Window, WindowAttributes, WindowId};
 
@@ -53,7 +52,7 @@ struct ControlFlowDemo {
     request_redraw: bool,
     wait_cancelled: bool,
     close_requested: bool,
-    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+    window: Option<Box<dyn Window>>,
 }
 
 impl ApplicationHandler for ControlFlowDemo {
@@ -70,10 +69,7 @@ impl ApplicationHandler for ControlFlowDemo {
         let window_attributes = WindowAttributes::default().with_title(
             "Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.",
         );
-        let window = event_loop.create_window(window_attributes).unwrap();
+        self.window = Some(event_loop.create_window(window_attributes).unwrap());
-        let context = Context::new(event_loop.owned_display_handle()).unwrap();
-        let surface = Surface::new(&context, window).unwrap();
-        self.surface = Some(surface);
     }
 
     fn window_event(
@@ -116,9 +112,9 @@ impl ApplicationHandler for ControlFlowDemo {
                 _ => (),
             },
             WindowEvent::RedrawRequested => {
-                let surface = self.surface.as_mut().unwrap();
+                let window = self.window.as_ref().unwrap();
-                surface.window().pre_present_notify();
+                window.pre_present_notify();
-                fill::fill(surface);
+                fill::fill_window(window.as_ref());
             },
             _ => (),
         }
@@ -126,7 +122,7 @@ impl ApplicationHandler for ControlFlowDemo {
 
     fn about_to_wait(&mut self, event_loop: &dyn ActiveEventLoop) {
         if self.request_redraw && !self.wait_cancelled && !self.close_requested {
-            self.surface.as_ref().unwrap().window().request_redraw();
+            self.window.as_ref().unwrap().request_redraw();
         }
 
         match self.mode {

examples/dnd.rs

@@ -1,10 +1,8 @@
 use std::error::Error;
 
-use softbuffer::{Context, Surface};
-use tracing::info;
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+use winit::event_loop::{ActiveEventLoop, EventLoop};
 use winit::window::{Window, WindowAttributes, WindowId};
 
 #[path = "util/fill.rs"]
@@ -17,24 +15,27 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     let event_loop = EventLoop::new()?;
 
-    let app = Application::default();
+    let app = Application::new();
     Ok(event_loop.run_app(app)?)
 }
 
 /// Application state and event handling.
-#[derive(Default, Debug)]
+#[derive(Debug)]
 struct Application {
-    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+    window: Option<Box<dyn Window>>,
+}
+
+impl Application {
+    fn new() -> Self {
+        Self { window: None }
+    }
 }
 
 impl ApplicationHandler for Application {
     fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
         let window_attributes =
             WindowAttributes::default().with_title("Drag and drop files on me!");
-        let window = event_loop.create_window(window_attributes).unwrap();
+        self.window = Some(event_loop.create_window(window_attributes).unwrap());
-        let context = Context::new(event_loop.owned_display_handle()).unwrap();
-        let surface = Surface::new(&context, window).unwrap();
-        self.surface = Some(surface);
     }
 
     fn window_event(
@@ -48,12 +49,12 @@ impl ApplicationHandler for Application {
             | WindowEvent::DragEntered { .. }
             | WindowEvent::DragMoved { .. }
             | WindowEvent::DragDropped { .. } => {
-                info!("{event:?}");
+                println!("{event:?}");
             },
             WindowEvent::RedrawRequested => {
-                let surface = self.surface.as_mut().unwrap();
+                let window = self.window.as_ref().unwrap();
-                surface.window().pre_present_notify();
+                window.pre_present_notify();
-                fill::fill(surface);
+                fill::fill_window(window.as_ref());
             },
             WindowEvent::CloseRequested => {
                 event_loop.exit();

examples/pump_events.rs

@@ -7,31 +7,24 @@ fn main() -> std::process::ExitCode {
     use std::thread::sleep;
     use std::time::Duration;
 
-    use softbuffer::{Context, Surface};
-    use tracing::info;
     use winit::application::ApplicationHandler;
     use winit::event::WindowEvent;
     use winit::event_loop::pump_events::{EventLoopExtPumpEvents, PumpStatus};
-    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
     use winit::window::{Window, WindowAttributes, WindowId};
 
     #[path = "util/fill.rs"]
     mod fill;
-    #[path = "util/tracing.rs"]
-    mod tracing;
 
     #[derive(Default, Debug)]
     struct PumpDemo {
-        surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+        window: Option<Box<dyn Window>>,
     }
 
     impl ApplicationHandler for PumpDemo {
         fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
             let window_attributes = WindowAttributes::default().with_title("A fantastic window!");
-            let window = event_loop.create_window(window_attributes).unwrap();
+            self.window = Some(event_loop.create_window(window_attributes).unwrap());
-
-            let context = Context::new(event_loop.owned_display_handle()).unwrap();
-            self.surface = Some(Surface::new(&context, window).unwrap());
         }
 
         fn window_event(
@@ -40,28 +33,28 @@ fn main() -> std::process::ExitCode {
             _window_id: WindowId,
             event: WindowEvent,
         ) {
-            info!("{event:?}");
+            println!("{event:?}");
 
-            let surface = match self.surface.as_mut() {
+            let window = match self.window.as_ref() {
-                Some(surface) => surface,
+                Some(window) => window,
                 None => return,
             };
 
             match event {
                 WindowEvent::CloseRequested => event_loop.exit(),
                 WindowEvent::RedrawRequested => {
-                    fill::fill(surface);
+                    fill::fill_window(window.as_ref());
-                    surface.window().request_redraw();
+                    window.request_redraw();
                 },
                 _ => (),
             }
         }
     }
 
-    tracing::init();
-
     let mut event_loop = EventLoop::new().unwrap();
 
+    tracing_subscriber::fmt::init();
+
     let mut app = PumpDemo::default();
 
     loop {
@@ -76,12 +69,12 @@ fn main() -> std::process::ExitCode {
         //
         // Since `pump_events` doesn't block it will be important to
         // throttle the loop in the app somehow.
-        info!("Update()");
+        println!("Update()");
         sleep(Duration::from_millis(16));
     }
 }
 
 #[cfg(any(ios_platform, web_platform, orbital_platform))]
 fn main() {
-    panic!("This platform doesn't support pump_events.")
+    println!("This platform doesn't support pump_events.");
 }

examples/run_on_demand.rs

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

examples/util/fill.rs

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

examples/util/tracing.rs

@@ -23,6 +23,3 @@ pub fn init() {
         )
         .init();
 }
-
-#[allow(unused_imports)]
-pub use ::tracing::*;

examples/window.rs

@@ -2,11 +2,9 @@
 
 use std::error::Error;
 
-use softbuffer::{Context, Surface};
-use tracing::info;
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+use winit::event_loop::{ActiveEventLoop, EventLoop};
 #[cfg(web_platform)]
 use winit::platform::web::WindowAttributesWeb;
 use winit::window::{Window, WindowAttributes, WindowId};
@@ -18,7 +16,7 @@ mod tracing;
 
 #[derive(Default, Debug)]
 struct App {
-    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+    window: Option<Box<dyn Window>>,
 }
 
 impl ApplicationHandler for App {
@@ -28,25 +26,25 @@ impl ApplicationHandler for App {
         #[cfg(web_platform)]
         let window_attributes = WindowAttributes::default()
             .with_platform_attributes(Box::new(WindowAttributesWeb::default().with_append(true)));
-        let window = event_loop.create_window(window_attributes).expect("failed creating window");
+        self.window = match event_loop.create_window(window_attributes) {
-
+            Ok(window) => Some(window),
-        let context =
+            Err(err) => {
-            Context::new(event_loop.owned_display_handle()).expect("failed creating context");
+                eprintln!("error creating window: {err}");
-        let surface = Surface::new(&context, window).expect("failed creating surface");
+                event_loop.exit();
-        self.surface = Some(surface);
+                return;
+            },
+        }
     }
 
     fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, _: WindowId, event: WindowEvent) {
-        info!("{event:?}");
+        println!("{event:?}");
         match event {
             WindowEvent::CloseRequested => {
-                info!("Close was requested; stopping");
+                println!("Close was requested; stopping");
                 event_loop.exit();
             },
-            WindowEvent::SurfaceResized(surface_size) => {
+            WindowEvent::SurfaceResized(_) => {
-                let surface = self.surface.as_mut().expect("resize event without a surface");
+                self.window.as_ref().expect("resize event without a window").request_redraw();
-                fill::resize(surface, surface_size);
-                surface.window().request_redraw();
             },
             WindowEvent::RedrawRequested => {
                 // Redraw the application.
@@ -55,15 +53,13 @@ impl ApplicationHandler for App {
                 // this event rather than in AboutToWait, since rendering in here allows
                 // the program to gracefully handle redraws requested by the OS.
 
-                let surface = self.surface.as_mut().expect("redraw event without a surface");
+                let window = self.window.as_ref().expect("redraw request without a window");
 
                 // Notify that you're about to draw.
-                surface.window().pre_present_notify();
+                window.pre_present_notify();
 
                 // Draw.
-                let mut buffer = surface.buffer_mut().expect("Failed to get the softbuffer buffer");
+                fill::fill_window(window.as_ref());
-                buffer.fill(0xff181818);
-                buffer.present().expect("Failed to present the softbuffer buffer");
 
                 // For contiguous redraw loop you can request a redraw from here.
                 // window.request_redraw();

examples/x11_embed.rs

@@ -3,22 +3,19 @@ use std::error::Error;
 
 #[cfg(x11_platform)]
 fn main() -> Result<(), Box<dyn Error>> {
-    use softbuffer::{Context, Surface};
     use winit::application::ApplicationHandler;
     use winit::event::WindowEvent;
-    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
+    use winit::event_loop::{ActiveEventLoop, EventLoop};
     use winit::platform::x11::WindowAttributesX11;
     use winit::window::{Window, WindowAttributes, WindowId};
 
     #[path = "util/fill.rs"]
     mod fill;
-    #[path = "util/tracing.rs"]
-    mod tracing;
 
     #[derive(Debug)]
     pub struct XEmbedDemo {
         parent_window_id: u32,
-        surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
+        window: Option<Box<dyn Window>>,
     }
 
     impl ApplicationHandler for XEmbedDemo {
@@ -30,10 +27,7 @@ fn main() -> Result<(), Box<dyn Error>> {
                 WindowAttributesX11::default().with_embed_parent_window(self.parent_window_id);
             window_attributes = window_attributes.with_platform_attributes(Box::new(x11_attrs));
 
-            let window = event_loop.create_window(window_attributes).unwrap();
+            self.window = Some(event_loop.create_window(window_attributes).unwrap());
-            let context = Context::new(event_loop.owned_display_handle()).unwrap();
-            let surface = Surface::new(&context, window).unwrap();
-            self.surface = Some(surface);
         }
 
         fn window_event(
@@ -42,19 +36,19 @@ fn main() -> Result<(), Box<dyn Error>> {
             _window_id: WindowId,
             event: WindowEvent,
         ) {
+            let window = self.window.as_ref().unwrap();
             match event {
                 WindowEvent::CloseRequested => event_loop.exit(),
                 WindowEvent::RedrawRequested => {
-                    let surface = self.surface.as_mut().unwrap();
+                    window.pre_present_notify();
-                    surface.window().pre_present_notify();
+                    fill::fill_window(window.as_ref());
-                    fill::fill(surface);
                 },
                 _ => (),
             }
         }
 
         fn about_to_wait(&mut self, _event_loop: &dyn ActiveEventLoop) {
-            self.surface.as_ref().unwrap().window().request_redraw();
+            self.window.as_ref().unwrap().request_redraw();
         }
     }
 
@@ -64,13 +58,14 @@ fn main() -> Result<(), Box<dyn Error>> {
         .ok_or("Expected a 32-bit X11 window ID as the first argument.")?
         .parse::<u32>()?;
 
-    tracing::init();
+    tracing_subscriber::fmt::init();
     let event_loop = EventLoop::new()?;
 
-    Ok(event_loop.run_app(XEmbedDemo { parent_window_id, surface: None })?)
+    Ok(event_loop.run_app(XEmbedDemo { parent_window_id, window: None })?)
 }
 
 #[cfg(not(x11_platform))]
 fn main() -> Result<(), Box<dyn Error>> {
-    panic!("This example is only supported on X11 platforms.")
+    println!("This example is only supported on X11 platforms.");
+    Ok(())
 }

winit-android/src/event_loop.rs

@@ -473,23 +473,16 @@ 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,
+                                logical_key: keycodes::to_logical(key_char, keycode),
                                 location: keycodes::to_location(keycode),
                                 repeat: key.repeat_count() > 0,
-                                text: text.clone(),
+                                text: None,
-                                text_with_all_modifiers: text,
+                                text_with_all_modifiers: None,
                                 key_without_modifiers: keycodes::to_logical(key_char, keycode),
                             },
                             is_synthetic: false,
@@ -507,6 +500,10 @@ 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,

winit-android/src/keycodes.rs

@@ -1,5 +1,5 @@
-use android_activity::AndroidApp;
 use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
+use android_activity::AndroidApp;
 use winit_core::keyboard::{
     Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey,
 };
@@ -109,7 +109,6 @@ 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,
@@ -132,11 +131,7 @@ 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,
 
@@ -159,14 +154,6 @@ 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 =
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.12",
-//!    "0.31.0-beta.2", features = [ "android-native-activity" ] }`
+//!    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,6 +18,7 @@ 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
@@ -51,7 +52,6 @@ objc2-app-kit = { workspace = true, features = [
     "NSScreen",
     "NSTextInputClient",
     "NSTextInputContext",
-    "NSTrackingArea",
     "NSToolbar",
     "NSView",
     "NSWindow",
@@ -107,7 +107,6 @@ 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,15 +1,14 @@
 #![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;
@@ -22,10 +21,6 @@ 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.
@@ -35,8 +30,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 = event.r#type();
+    let event_type = unsafe { event.r#type() };
-    let modifier_flags = event.modifierFlags();
+    let modifier_flags = unsafe { event.modifierFlags() };
     if event_type == NSEventType::KeyUp && modifier_flags.contains(NSEventModifierFlags::Command) {
         if let Some(key_window) = app.keyWindow() {
             key_window.sendEvent(event);
@@ -80,7 +75,9 @@ 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.
-    if ptr::fn_addr_eq(overridden, method.implementation()) {
+    // 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() {
         return;
     }
 
@@ -101,15 +98,15 @@ pub(crate) fn override_send_event(global_app: &NSApplication) {
 }
 
 fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
-    let event_type = event.r#type();
+    let event_type = unsafe { event.r#type() };
     #[allow(non_upper_case_globals)]
     match event_type {
         NSEventType::MouseMoved
         | NSEventType::LeftMouseDragged
         | NSEventType::OtherMouseDragged
         | NSEventType::RightMouseDragged => {
-            let delta_x = event.deltaX() as f64;
+            let delta_x = unsafe { event.deltaX() } as f64;
-            let delta_y = event.deltaY() as f64;
+            let delta_y = unsafe { event.deltaY() } as f64;
 
             if delta_x != 0.0 || delta_y != 0.0 {
                 app_state.maybe_queue_with_handler(move |app, event_loop| {
@@ -120,7 +117,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
             }
         },
         NSEventType::LeftMouseDown | NSEventType::RightMouseDown | NSEventType::OtherMouseDown => {
-            let button = event.buttonNumber() as u32;
+            let button = unsafe { event.buttonNumber() } as u32;
             app_state.maybe_queue_with_handler(move |app, event_loop| {
                 app.device_event(event_loop, None, DeviceEvent::Button {
                     button,
@@ -129,7 +126,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
             });
         },
         NSEventType::LeftMouseUp | NSEventType::RightMouseUp | NSEventType::OtherMouseUp => {
-            let button = event.buttonNumber() as u32;
+            let button = unsafe { event.buttonNumber() } as u32;
             app_state.maybe_queue_with_handler(move |app, event_loop| {
                 app.device_event(event_loop, None, DeviceEvent::Button {
                     button,
@@ -144,7 +141,7 @@ fn maybe_dispatch_device_event(app_state: &Rc<AppState>, event: &NSEvent) {
 #[cfg(test)]
 mod tests {
     use objc2::rc::Retained;
-    use objc2::{ClassType, define_class, msg_send};
+    use objc2::{define_class, msg_send, ClassType};
     use objc2_app_kit::NSResponder;
     use objc2_foundation::NSObject;
 
@@ -156,14 +153,16 @@ mod tests {
         let Some(mtm) = MainThreadMarker::new() else { return };
 
         // Create a new application, without making it the shared application.
-        let app = NSApplication::new(mtm);
+        let app = unsafe { 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)
+        // }
     }
 
     #[test]

winit-appkit/src/app_state.rs

@@ -8,16 +8,16 @@ use dispatch2::MainThreadBound;
 use objc2::MainThreadMarker;
 use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSRunningApplication};
 use objc2_foundation::NSNotification;
-use winit_common::core_foundation::{EventLoopProxy, MainRunLoop};
+use winit_common::core_foundation::EventLoopProxy;
 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::{ActiveEventLoop, notify_windows_of_exit, stop_app_immediately};
+use super::event_loop::{notify_windows_of_exit, stop_app_immediately, ActiveEventLoop};
 use super::menu;
-use super::observer::EventLoopWaker;
+use super::observer::{EventLoopWaker, RunLoop};
 
 #[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: MainRunLoop,
+    run_loop: RunLoop,
     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: MainRunLoop::get(mtm),
+            run_loop: RunLoop::main(mtm),
             event_loop_proxy,
             event_handler: EventHandler::new(),
             stop_on_launch: Cell::new(false),
@@ -99,6 +99,7 @@ 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);
@@ -116,7 +117,7 @@ impl AppState {
             // - https://github.com/rust-windowing/winit/issues/261
             // - https://github.com/rust-windowing/winit/issues/3958
             let is_bundled =
-                NSRunningApplication::currentApplication().bundleIdentifier().is_some();
+                unsafe { NSRunningApplication::currentApplication().bundleIdentifier().is_some() };
             if !is_bundled {
                 app.setActivationPolicy(NSApplicationActivationPolicy::Regular);
             }
@@ -153,6 +154,7 @@ 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();
@@ -263,7 +265,7 @@ impl AppState {
         if !pending_redraw.contains(&window_id) {
             pending_redraw.push(window_id);
         }
-        self.run_loop.wake_up();
+        self.run_loop.wakeup();
     }
 
     #[track_caller]
@@ -308,7 +310,6 @@ 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;
         }
@@ -337,7 +338,8 @@ impl AppState {
     // Called by RunLoopObserver before waiting for new events
     pub fn cleared(self: &Rc<Self>) {
         // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        // (we have registered to observe all modes, including modal event loops).
+        // XXX: how does it make sense that `event_handler.ready()` can ever return `false` here if
+        // we're about to return to the `CFRunLoop` to poll for new events?
         if !self.event_handler.ready() || !self.is_running() {
             return;
         }

winit-appkit/src/cursor.rs

@@ -4,13 +4,10 @@ use std::sync::OnceLock;
 
 use objc2::rc::Retained;
 use objc2::runtime::Sel;
-use objc2::{AllocAnyThread, ClassType, available, msg_send, sel};
+use objc2::{available, msg_send, sel, AllocAnyThread, ClassType};
-use objc2_app_kit::{
+use objc2_app_kit::{NSBitmapImageRep, NSCursor, NSDeviceRGBColorSpace, NSImage};
-    NSBitmapImageRep, NSCursor, NSCursorFrameResizeDirections, NSCursorFrameResizePosition,
-    NSDeviceRGBColorSpace, NSImage,
-};
 use objc2_foundation::{
-    NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString, ns_string,
+    ns_string, NSData, NSDictionary, NSNumber, NSObject, NSPoint, NSSize, NSString,
 };
 use winit_core::cursor::{CursorIcon, CursorImage, CustomCursorProvider, CustomCursorSource};
 use winit_core::error::{NotSupportedError, RequestError};
@@ -34,7 +31,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())
             },
         };
 
@@ -65,8 +62,10 @@ 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 = NSImage::initWithSize(NSImage::alloc(), NSSize::new(width.into(), height.into()));
+    let image = unsafe {
-    image.addRepresentation(&bitmap);
+        NSImage::initWithSize(NSImage::alloc(), NSSize::new(width.into(), height.into()))
+    };
+    unsafe { image.addRepresentation(&bitmap) };
 
     let hotspot = NSPoint::new(cursor.hotspot_x() as f64, cursor.hotspot_y() as f64);
 
@@ -141,9 +140,12 @@ unsafe fn load_webkit_cursor(name: &NSString) -> Retained<NSCursor> {
 
     // TODO: Handle PLists better
     let info_path = cursor_path.stringByAppendingPathComponent(ns_string!("info.plist"));
-    #[allow(deprecated)]
+    let info: Retained<NSDictionary<NSObject, NSObject>> = unsafe {
-    let info: Retained<NSDictionary<NSObject, NSObject>> =
+        msg_send![
-        unsafe { NSDictionary::dictionaryWithContentsOfFile(&info_path) }.unwrap();
+            <NSDictionary<NSObject, NSObject>>::class(),
+            dictionaryWithContentsOfFile: &*info_path,
+        ]
+    };
     let mut x = 0.0;
     if let Some(n) = info.objectForKey(ns_string!("hotx")) {
         if let Ok(n) = n.downcast::<NSNumber>() {
@@ -207,155 +209,23 @@ 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 => {
+        CursorIcon::EResize => NSCursor::resizeRightCursor(),
-            if available!(macos = 15.0) {
+        CursorIcon::NResize => NSCursor::resizeUpCursor(),
-                NSCursor::frameResizeCursorFromPosition_inDirections(
+        CursorIcon::WResize => NSCursor::resizeLeftCursor(),
-                    NSCursorFrameResizePosition::Right,
+        CursorIcon::SResize => NSCursor::resizeDownCursor(),
-                    NSCursorFrameResizeDirections::Outward,
+        CursorIcon::EwResize | CursorIcon::ColResize => NSCursor::resizeLeftRightCursor(),
-                )
+        CursorIcon::NsResize | CursorIcon::RowResize => NSCursor::resizeUpDownCursor(),
-            } 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,7 +67,9 @@ 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 = ns_event.charactersIgnoringModifiers().map(|s| s.to_string()).unwrap_or_default();
+    let string = unsafe { 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();
@@ -83,7 +85,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 = ns_event.keyCode();
+    let scancode = unsafe { 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.
@@ -93,7 +95,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 = ns_event.characters().map(|s| s.to_string()).unwrap_or_default();
+    let characters = unsafe { ns_event.characters() }.map(|s| s.to_string()).unwrap_or_default();
     let text_with_all_modifiers = if characters.is_empty() {
         None
     } else {
@@ -109,13 +111,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 = ns_event.modifierFlags();
+        let modifiers = unsafe { 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 German layout- one
+            // include its effect in the key. For example if -on the Germay 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.
@@ -300,15 +302,15 @@ const NX_DEVICERALTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x000000
 const NX_DEVICERCTLKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00002000);
 
 pub(super) fn lalt_pressed(event: &NSEvent) -> bool {
-    event.modifierFlags().contains(NX_DEVICELALTKEYMASK)
+    unsafe { event.modifierFlags() }.contains(NX_DEVICELALTKEYMASK)
 }
 
 pub(super) fn ralt_pressed(event: &NSEvent) -> bool {
-    event.modifierFlags().contains(NX_DEVICERALTKEYMASK)
+    unsafe { event.modifierFlags() }.contains(NX_DEVICERALTKEYMASK)
 }
 
 pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
-    let flags = event.modifierFlags();
+    let flags = unsafe { event.modifierFlags() };
     let mut state = ModifiersState::empty();
     let mut pressed_mods = ModifiersKeys::empty();
 
@@ -332,6 +334,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(
             NSEventType::ApplicationDefined,
             NSPoint::new(0.0, 0.0),
@@ -344,6 +347,7 @@ pub(super) fn dummy_event() -> Option<Retained<NSEvent>> {
             0,
         )
     }
+}
 
 pub fn physicalkey_to_scancode(physical_key: PhysicalKey) -> Option<u32> {
     let code = match physical_key {

winit-appkit/src/event_loop.rs

@@ -2,19 +2,15 @@ use std::rc::Rc;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
-use objc2::rc::{Retained, autoreleasepool};
+use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::ProtocolObject;
-use objc2::{MainThreadMarker, available};
+use objc2::{available, MainThreadMarker};
 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};
@@ -31,8 +27,10 @@ use super::app_state::AppState;
 use super::cursor::CustomCursor;
 use super::event::dummy_event;
 use super::monitor;
-use crate::ActivationPolicy;
+use super::notification_center::create_observer;
+use super::observer::setup_control_flow_observers;
 use crate::window::Window;
+use crate::ActivationPolicy;
 
 #[derive(Debug)]
 pub struct ActiveEventLoop {
@@ -152,10 +150,6 @@ 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)]
@@ -197,7 +191,7 @@ impl EventLoop {
         // Override `sendEvent:` on the application to forward to our application state.
         override_send_event(&app);
 
-        let center = NSNotificationCenter::defaultCenter();
+        let center = unsafe { NSNotificationCenter::defaultCenter() };
 
         let weak_app_state = Rc::downgrade(&app_state);
         let _did_finish_launching_observer = create_observer(
@@ -205,7 +199,6 @@ 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);
                 }
@@ -218,45 +211,13 @@ 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);
                 }
             },
         );
 
-        let main_loop = MainRunLoop::get(mtm);
+        setup_control_flow_observers(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,
@@ -264,9 +225,6 @@ impl EventLoop {
             window_target: ActiveEventLoop { app_state, mtm },
             _did_finish_launching_observer,
             _will_terminate_observer,
-            _tracing_observers,
-            _before_waiting_observer,
-            _after_waiting_observer,
         })
     }
 
@@ -274,6 +232,10 @@ 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::{CFString, CFUUID, cf_type};
+use objc2_core_foundation::{cf_type, CFString, CFUUID};
 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")]
-unsafe extern "C" {
+extern "C" {
     pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> *mut CFUUID;
 
     pub fn CGDisplayGetDisplayIDFromUUID(uuid: &CFUUID) -> CGDirectDisplayID;
 }
 
 #[link(name = "CoreGraphics", kind = "framework")]
-unsafe extern "C" {
+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")]
-unsafe extern "C" {
+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::{DefinedClass, MainThreadMarker, MainThreadOnly, define_class, msg_send};
+//! use objc2::{define_class, msg_send, DefinedClass, MainThreadMarker, MainThreadOnly};
 //! use objc2_app_kit::{NSApplication, NSApplicationDelegate};
 //! use objc2_foundation::{NSArray, NSObject, NSObjectProtocol, NSURL};
 //! use winit::event_loop::EventLoop;
@@ -76,6 +76,7 @@ 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::{MainThreadMarker, sel};
+use objc2::{sel, MainThreadMarker};
 use objc2_app_kit::{NSApplication, NSEventModifierFlags, NSMenu, NSMenuItem};
-use objc2_foundation::{NSBundle, NSProcessInfo, NSString, ns_string};
+use objc2_foundation::{ns_string, NSBundle, NSProcessInfo, NSString};
 
 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));
 
-    app.setServicesMenu(Some(&services_menu));
+    unsafe { 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::MainThreadMarker;
 use objc2::rc::Retained;
+use objc2::MainThreadMarker;
 use objc2_app_kit::NSScreen;
 use objc2_core_foundation::{CFArray, CFRetained, CFUUID};
 use objc2_core_graphics::{
     CGDirectDisplayID, CGDisplayBounds, CGDisplayCopyAllDisplayModes, CGDisplayCopyDisplayMode,
     CGDisplayMode, CGDisplayModelNumber, CGGetActiveDisplayList, CGMainDisplayID,
 };
-use objc2_core_video::{CVDisplayLink, CVTimeFlags, kCVReturnSuccess};
+use objc2_core_video::{kCVReturnSuccess, CVDisplayLink, CVTimeFlags};
-use objc2_foundation::{NSNumber, NSPoint, NSRect, ns_string};
+use objc2_foundation::{ns_string, NSNumber, NSPoint, NSRect};
 use tracing::warn;
 use winit_core::monitor::{MonitorHandleProvider, VideoMode};
 
@@ -65,6 +65,7 @@ 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 =
@@ -91,7 +92,8 @@ impl VideoModeHandle {
                 refresh_rate_millihertz,
             );
 
-        Self { mode, monitor: monitor.clone(), native_mode }
+            VideoModeHandle { mode, monitor: monitor.clone(), native_mode }
+        }
     }
 }
 
@@ -135,11 +137,11 @@ impl MonitorHandle {
 
     fn refresh_rate_millihertz(&self) -> Option<NonZeroU32> {
         let current_display_mode =
-            NativeDisplayMode(CGDisplayCopyDisplayMode(self.display_id()).unwrap());
+            NativeDisplayMode(unsafe { CGDisplayCopyDisplayMode(self.display_id()) }.unwrap());
         refresh_rate_millihertz(self.display_id(), &current_display_mode)
     }
 
-    pub fn video_mode_handles(&self) -> impl Iterator<Item = VideoModeHandle> + 'static {
+    pub fn video_mode_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
         let refresh_rate_millihertz = self.refresh_rate_millihertz();
         let monitor = self.clone();
 
@@ -157,7 +159,7 @@ impl MonitorHandle {
         };
 
         modes.into_iter().map(move |mode| {
-            let cg_refresh_rate_hertz = CGDisplayMode::refresh_rate(Some(&mode));
+            let cg_refresh_rate_hertz = unsafe { CGDisplayMode::refresh_rate(Some(&mode)) };
 
             // CGDisplayModeGetRefreshRate returns 0.0 for any display that
             // isn't a CRT
@@ -200,7 +202,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 = CGDisplayModelNumber(self.display_id());
+        let screen_num = unsafe { CGDisplayModelNumber(self.display_id()) };
         Some(format!("Monitor #{screen_num}").into())
     }
 
@@ -208,7 +210,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 = CGDisplayBounds(self.display_id());
+        let bounds = unsafe { CGDisplayBounds(self.display_id()) };
         let position = LogicalPosition::new(bounds.origin.x, bounds.origin.y);
         Some(position.to_physical(self.scale_factor()))
     }
@@ -223,7 +225,8 @@ impl MonitorHandleProvider for MonitorHandle {
     }
 
     fn current_video_mode(&self) -> Option<VideoMode> {
-        let mode = NativeDisplayMode(CGDisplayCopyDisplayMode(self.display_id()).unwrap());
+        let mode =
+            NativeDisplayMode(unsafe { 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)
     }
@@ -261,7 +264,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(CGMainDisplayID()).expect("invalid display ID")
+    MonitorHandle::new(unsafe { CGMainDisplayID() }).expect("invalid display ID")
 }
 
 impl fmt::Debug for MonitorHandle {
@@ -312,13 +315,14 @@ pub(crate) fn flip_window_screen_coordinates(frame: NSRect) -> NSPoint {
     // It is intentional that we use `CGMainDisplayID` (as opposed to
     // `NSScreen::mainScreen`), because that's what the screen coordinates
     // are relative to, no matter which display the window is currently on.
-    let main_screen_height = CGDisplayBounds(CGMainDisplayID()).size.height;
+    let main_screen_height = unsafe { CGDisplayBounds(CGMainDisplayID()) }.size.height;
 
     let y = main_screen_height - frame.size.height - frame.origin.y;
     NSPoint::new(frame.origin.x, y)
 }
 
 fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> Option<NonZeroU32> {
+    unsafe {
         let refresh_rate = CGDisplayMode::refresh_rate(Some(&mode.0));
         if refresh_rate > 0.0 {
             return NonZeroU32::new((refresh_rate * 1000.0).round() as u32);
@@ -326,12 +330,12 @@ fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> O
 
         let mut display_link = std::ptr::null_mut();
         #[allow(deprecated)]
-    if unsafe { CVDisplayLink::create_with_cg_display(id, NonNull::from(&mut display_link)) }
+        if 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()) };
+        let display_link = CFRetained::from_raw(NonNull::new(display_link).unwrap());
         #[allow(deprecated)]
         let time = display_link.nominal_output_video_refresh_period();
 
@@ -345,6 +349,7 @@ fn refresh_rate_millihertz(id: CGDirectDisplayID, mode: &NativeDisplayMode) -> O
             .map(|v| (v * 1000) as u32)
             .and_then(NonZeroU32::new)
     }
+}
 
 #[cfg(test)]
 mod tests {
@@ -352,10 +357,8 @@ mod tests {
 
     #[test]
     fn uuid_stable() {
-        let primary_id = CGMainDisplayID();
+        let handle_a = MonitorHandle::new(1).unwrap();
-
+        let handle_b = MonitorHandle::new(1).unwrap();
-        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());
@@ -370,10 +373,8 @@ 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(primary_id).unwrap();
+        let handle1 = MonitorHandle::new(1).unwrap();
         assert_eq!(handle0, handle1);
         assert_eq!(handle0.display_id(), handle1.display_id());
         assert_eq!(handle0.uuid(), handle1.uuid());
@@ -394,7 +395,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 _ = CGMainDisplayID();
+        let _ = unsafe { CGMainDisplayID() };
 
         let handle = MonitorHandle(CFUUID::new(None).unwrap());
         assert_eq!(handle.display_id(), 0);

winit-appkit/src/notification_center.rs

@@ -1,3 +1,4 @@
+// NOTE: This is symlinked to be contained in both the AppKit and UIKit implementations.
 use std::ptr::NonNull;
 
 use block2::RcBlock;
@@ -11,7 +12,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 fn create_observer(
+pub(crate) fn create_observer(
     center: &NSNotificationCenter,
     name: &NSNotificationName,
     handler: impl Fn(&NSNotification) + 'static,

winit-appkit/src/observer.rs

@@ -1,10 +1,171 @@
+//! 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::{
-    CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, kCFRunLoopCommonModes,
+    kCFRunLoopCommonModes, kCFRunLoopDefaultMode, CFAbsoluteTimeGetCurrent, CFIndex, CFRetained,
+    CFRunLoop, CFRunLoopActivity, CFRunLoopObserver, CFRunLoopObserverCallBack,
+    CFRunLoopObserverContext, CFRunLoopTimer,
 };
+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,11 +1,44 @@
 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) }};
+    ($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);
+    }
 }
 
 #[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, PhysicalSize};
+use dpi::{LogicalPosition, LogicalSize};
 use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, Sel};
-use objc2::{AnyThread, DefinedClass, MainThreadMarker, define_class, msg_send};
+use objc2::{define_class, msg_send, DefinedClass, MainThreadMarker};
 use objc2_app_kit::{
-    NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient, NSTrackingArea,
+    NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient,
-    NSTrackingAreaOptions, NSView, NSViewLayerContentsRedrawPolicy, NSWindow,
+    NSTrackingRectTag, NSView, 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,6 +119,7 @@ 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>,
 
@@ -130,6 +131,7 @@ 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,
 
@@ -151,35 +153,49 @@ 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>) {
-            let _entered = debug_span!("NSViewFrameDidChangeNotification").entered();
+            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));
 
             // 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).
-            self.surface_resized();
+            let logical_size = LogicalSize::new(rect.size.width as f64, rect.size.height as f64);
-            // During live resize, AppKit may not let the normal event loop reach its next redraw
+            let size = logical_size.to_physical::<u32>(self.scale_factor());
-            // point before stretching the current layer contents. Redraw immediately after the
+            self.queue_event(WindowEvent::SurfaceResized(size));
-            // 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) {
-            let _entered = debug_span!("drawRect:").entered();
+            trace_scope!("drawRect:");
 
             self.ivars().app_state.handle_redraw(window_id(&self.window()));
 
@@ -188,7 +204,7 @@ define_class!(
 
         #[unsafe(method(acceptsFirstResponder))]
         fn accepts_first_responder(&self) -> bool {
-            let _entered = trace_span!("acceptsFirstResponder").entered();
+            trace_scope!("acceptsFirstResponder");
             true
         }
 
@@ -202,13 +218,13 @@ define_class!(
         // extension for using `NSTouchBar`
         #[unsafe(method_id(touchBar))]
         fn touch_bar(&self) -> Option<Retained<NSObject>> {
-            let _entered = debug_span!("touchBar").entered();
+            trace_scope!("touchBar");
             None
         }
 
         #[unsafe(method(resetCursorRects))]
         fn reset_cursor_rects(&self) {
-            let _entered = debug_span!("resetCursorRects").entered();
+            trace_scope!("resetCursorRects");
             let bounds = self.bounds();
             let cursor_state = self.ivars().cursor_state.borrow();
             // We correctly invoke `addCursorRect` only from inside `resetCursorRects`
@@ -223,13 +239,13 @@ define_class!(
     unsafe impl NSTextInputClient for WinitView {
         #[unsafe(method(hasMarkedText))]
         fn has_marked_text(&self) -> bool {
-            let _entered = debug_span!("hasMarkedText").entered();
+            trace_scope!("hasMarkedText");
             self.ivars().marked_text.borrow().length() > 0
         }
 
         #[unsafe(method(markedRange))]
         fn marked_range(&self) -> NSRange {
-            let _entered = debug_span!("markedRange").entered();
+            trace_scope!("markedRange");
             let length = self.ivars().marked_text.borrow().length();
             if length > 0 {
                 NSRange::new(0, length)
@@ -241,7 +257,7 @@ define_class!(
 
         #[unsafe(method(selectedRange))]
         fn selected_range(&self) -> NSRange {
-            let _entered = debug_span!("selectedRange").entered();
+            trace_scope!("selectedRange");
             // Documented to return `{NSNotFound, 0}` if there is no selection.
             NSRange::new(NSNotFound as NSUInteger, 0)
         }
@@ -254,7 +270,7 @@ define_class!(
             _replacement_range: NSRange,
         ) {
             // TODO: Use _replacement_range, requires changing the event to report surrounding text.
-            let _entered = debug_span!("setMarkedText:selectedRange:replacementRange:").entered();
+            trace_scope!("setMarkedText:selectedRange:replacementRange:");
 
             let (marked_text, string) = if let Some(string) =
                 string.downcast_ref::<NSAttributedString>()
@@ -276,38 +292,33 @@ define_class!(
                 self.queue_event(WindowEvent::Ime(Ime::Enabled));
             }
 
-            if self.hasMarkedText() {
+            if unsafe { 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 code unit indices to UTF-8 byte
+                // Convert the selected range from UTF-16 indices to UTF-8 indices.
-                // offsets. `utf16_to_utf8_offset` is defensive: it snaps an offset that would
+                let sub_string_a = unsafe { string.substringToIndex(selected_range.location) };
-                // split a surrogate pair down to the character boundary and clamps an
+                let sub_string_b = unsafe { string.substringToIndex(selected_range.end()) };
-                // out-of-bounds offset to the string length, so no `NSRangeException` is
+                let lowerbound_utf8 = sub_string_a.len();
-                // possible and the resulting range can never be inverted (`lower <= upper`).
+                let upperbound_utf8 = sub_string_b.len();
-                // 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, cursor_range)));
+            self.queue_event(WindowEvent::Ime(Ime::Preedit(string.to_string(), cursor_range)));
         }
 
         #[unsafe(method(unmarkText))]
         fn unmark_text(&self) {
-            let _entered = debug_span!("unmarkText").entered();
+            trace_scope!("unmarkText");
             *self.ivars().marked_text.borrow_mut() = NSMutableAttributedString::new();
 
             let input_context = self.inputContext().expect("input context");
@@ -324,7 +335,7 @@ define_class!(
 
         #[unsafe(method_id(validAttributesForMarkedText))]
         fn valid_attributes_for_marked_text(&self) -> Retained<NSArray<NSAttributedStringKey>> {
-            let _entered = trace_span!("validAttributesForMarkedText").entered();
+            trace_scope!("validAttributesForMarkedText");
             NSArray::new()
         }
 
@@ -334,14 +345,13 @@ define_class!(
             _range: NSRange,
             _actual_range: *mut NSRange,
         ) -> Option<Retained<NSAttributedString>> {
-            let _entered =
+            trace_scope!("attributedSubstringForProposedRange:actualRange:");
-                trace_span!("attributedSubstringForProposedRange:actualRange:").entered();
             None
         }
 
         #[unsafe(method(characterIndexForPoint:))]
         fn character_index_for_point(&self, _point: NSPoint) -> NSUInteger {
-            let _entered = debug_span!("characterIndexForPoint:").entered();
+            trace_scope!("characterIndexForPoint:");
             0
         }
 
@@ -351,7 +361,7 @@ define_class!(
             _range: NSRange,
             _actual_range: *mut NSRange,
         ) -> NSRect {
-            let _entered = debug_span!("firstRectForCharacterRange:actualRange:").entered();
+            trace_scope!("firstRectForCharacterRange:actualRange:");
 
             // Guard when the view is no longer in a window during teardown.
             let Some(window) = (**self).window() else {
@@ -367,7 +377,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.
-            let _entered = debug_span!("insertText:replacementRange:").entered();
+            trace_scope!("insertText:replacementRange:");
 
             let string = if let Some(string) = string.downcast_ref::<NSAttributedString>() {
                 string.string().to_string()
@@ -381,7 +391,7 @@ define_class!(
             let is_control = string.chars().next().is_some_and(|c| c.is_control());
 
             // Commit only if we have marked text.
-            if self.hasMarkedText() && self.is_ime_enabled() && !is_control {
+            if unsafe { 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);
@@ -392,7 +402,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) {
-            let _entered = debug_span!("doCommandBySelector:").entered();
+            trace_scope!("doCommandBySelector:");
 
             // 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
@@ -404,7 +414,8 @@ define_class!(
 
             self.ivars().forward_key_to_app.set(true);
 
-            if self.hasMarkedText() && self.ivars().ime_state.get() == ImeState::Preedit {
+            if unsafe { 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);
             }
@@ -431,7 +442,7 @@ define_class!(
     impl WinitView {
         #[unsafe(method(keyDown:))]
         fn key_down(&self, event: &NSEvent) {
-            let _entered = debug_span!("keyDown:").entered();
+            trace_scope!("keyDown:");
             {
                 let mut prev_input_source = self.ivars().input_source.borrow_mut();
                 let current_input_source = self.current_input_source();
@@ -456,7 +467,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]);
-                self.interpretKeyEvents(&events_for_nsview);
+                unsafe { 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 {
@@ -479,7 +490,7 @@ define_class!(
             };
 
             if !had_ime_input || self.ivars().forward_key_to_app.get() {
-                let key_event = create_key_event(&event, true, event.isARepeat());
+                let key_event = create_key_event(&event, true, unsafe { event.isARepeat() });
                 self.queue_event(WindowEvent::KeyboardInput {
                     device_id: None,
                     event: key_event,
@@ -490,7 +501,7 @@ define_class!(
 
         #[unsafe(method(keyUp:))]
         fn key_up(&self, event: &NSEvent) {
-            let _entered = debug_span!("keyUp:").entered();
+            trace_scope!("keyUp:");
 
             let event = replace_event(event, self.option_as_alt());
             self.update_modifiers(&event, false);
@@ -507,14 +518,14 @@ define_class!(
 
         #[unsafe(method(flagsChanged:))]
         fn flags_changed(&self, event: &NSEvent) {
-            let _entered = debug_span!("flagsChanged:").entered();
+            trace_scope!("flagsChanged:");
 
             self.update_modifiers(event, true);
         }
 
         #[unsafe(method(insertTab:))]
         fn insert_tab(&self, _sender: Option<&AnyObject>) {
-            let _entered = debug_span!("insertTab:").entered();
+            trace_scope!("insertTab:");
             let window = self.window();
             if let Some(first_responder) = window.firstResponder() {
                 if *first_responder == ***self {
@@ -525,7 +536,7 @@ define_class!(
 
         #[unsafe(method(insertBackTab:))]
         fn insert_back_tab(&self, _sender: Option<&AnyObject>) {
-            let _entered = debug_span!("insertBackTab:").entered();
+            trace_scope!("insertBackTab:");
             let window = self.window();
             if let Some(first_responder) = window.firstResponder() {
                 if *first_responder == ***self {
@@ -539,14 +550,14 @@ define_class!(
         #[unsafe(method(cancelOperation:))]
         fn cancel_operation(&self, _sender: Option<&AnyObject>) {
             let mtm = MainThreadMarker::from(self);
-            let _entered = debug_span!("cancelOperation:").entered();
+            trace_scope!("cancelOperation:");
 
             let event = NSApplication::sharedApplication(mtm)
                 .currentEvent()
                 .expect("could not find current event");
 
             self.update_modifiers(&event, false);
-            let event = create_key_event(&event, true, event.isARepeat());
+            let event = create_key_event(&event, true, unsafe { event.isARepeat() });
 
             self.queue_event(WindowEvent::KeyboardInput {
                 device_id: None,
@@ -568,73 +579,71 @@ define_class!(
 
         #[unsafe(method(mouseDown:))]
         fn mouse_down(&self, event: &NSEvent) {
-            let _entered = debug_span!("mouseDown:").entered();
+            trace_scope!("mouseDown:");
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Pressed);
         }
 
         #[unsafe(method(mouseUp:))]
         fn mouse_up(&self, event: &NSEvent) {
-            let _entered = debug_span!("mouseUp:").entered();
+            trace_scope!("mouseUp:");
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Released);
         }
 
         #[unsafe(method(rightMouseDown:))]
         fn right_mouse_down(&self, event: &NSEvent) {
-            let _entered = debug_span!("rightMouseDown:").entered();
+            trace_scope!("rightMouseDown:");
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Pressed);
         }
 
         #[unsafe(method(rightMouseUp:))]
         fn right_mouse_up(&self, event: &NSEvent) {
-            let _entered = debug_span!("rightMouseUp:").entered();
+            trace_scope!("rightMouseUp:");
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Released);
         }
 
         #[unsafe(method(otherMouseDown:))]
         fn other_mouse_down(&self, event: &NSEvent) {
-            let _entered = debug_span!("otherMouseDown:").entered();
+            trace_scope!("otherMouseDown:");
             self.mouse_motion(event);
             self.mouse_click(event, ElementState::Pressed);
         }
 
         #[unsafe(method(otherMouseUp:))]
         fn other_mouse_up(&self, event: &NSEvent) {
-            let _entered = debug_span!("otherMouseUp:").entered();
+            trace_scope!("otherMouseUp:");
             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) {
-            let _entered = debug_span!("mouseEntered:").entered();
+            trace_scope!("mouseEntered:");
 
             let position = self.mouse_view_point(event).to_physical(self.scale_factor());
 
@@ -648,7 +657,7 @@ define_class!(
 
         #[unsafe(method(mouseExited:))]
         fn mouse_exited(&self, event: &NSEvent) {
-            let _entered = debug_span!("mouseExited:").entered();
+            trace_scope!("mouseExited:");
 
             let position = self.mouse_view_point(event).to_physical(self.scale_factor());
 
@@ -662,13 +671,13 @@ define_class!(
 
         #[unsafe(method(scrollWheel:))]
         fn scroll_wheel(&self, event: &NSEvent) {
-            let _entered = debug_span!("scrollWheel:").entered();
+            trace_scope!("scrollWheel:");
 
             self.mouse_motion(event);
 
             let delta = {
-                let (x, y) = (event.scrollingDeltaX(), event.scrollingDeltaY());
+                let (x, y) = unsafe { (event.scrollingDeltaX(), event.scrollingDeltaY()) };
-                if event.hasPreciseScrollingDeltas() {
+                if unsafe { event.hasPreciseScrollingDeltas() } {
                     let delta = LogicalPosition::new(x, y).to_physical(self.scale_factor());
                     MouseScrollDelta::PixelDelta(delta)
                 } else {
@@ -681,10 +690,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 event.momentumPhase() {
+            let phase = match unsafe { event.momentumPhase() } {
                 NSEventPhase::MayBegin | NSEventPhase::Began => TouchPhase::Started,
                 NSEventPhase::Ended | NSEventPhase::Cancelled => TouchPhase::Ended,
-                _ => match event.phase() {
+                _ => match unsafe { event.phase() } {
                     NSEventPhase::MayBegin | NSEventPhase::Began => TouchPhase::Started,
                     NSEventPhase::Ended | NSEventPhase::Cancelled => TouchPhase::Ended,
                     _ => TouchPhase::Moved,
@@ -701,12 +710,12 @@ define_class!(
 
         #[unsafe(method(magnifyWithEvent:))]
         fn magnify_with_event(&self, event: &NSEvent) {
-            let _entered = debug_span!("magnifyWithEvent:").entered();
+            trace_scope!("magnifyWithEvent:");
 
             self.mouse_motion(event);
 
             #[allow(non_upper_case_globals)]
-            let phase = match event.phase() {
+            let phase = match unsafe { event.phase() } {
                 NSEventPhase::Began => TouchPhase::Started,
                 NSEventPhase::Changed => TouchPhase::Moved,
                 NSEventPhase::Cancelled => TouchPhase::Cancelled,
@@ -716,14 +725,14 @@ define_class!(
 
             self.queue_event(WindowEvent::PinchGesture {
                 device_id: None,
-                delta: event.magnification(),
+                delta: unsafe { event.magnification() },
                 phase,
             });
         }
 
         #[unsafe(method(smartMagnifyWithEvent:))]
         fn smart_magnify_with_event(&self, event: &NSEvent) {
-            let _entered = debug_span!("smartMagnifyWithEvent:").entered();
+            trace_scope!("smartMagnifyWithEvent:");
 
             self.mouse_motion(event);
 
@@ -732,12 +741,12 @@ define_class!(
 
         #[unsafe(method(rotateWithEvent:))]
         fn rotate_with_event(&self, event: &NSEvent) {
-            let _entered = debug_span!("rotateWithEvent:").entered();
+            trace_scope!("rotateWithEvent:");
 
             self.mouse_motion(event);
 
             #[allow(non_upper_case_globals)]
-            let phase = match event.phase() {
+            let phase = match unsafe { event.phase() } {
                 NSEventPhase::Began => TouchPhase::Started,
                 NSEventPhase::Changed => TouchPhase::Moved,
                 NSEventPhase::Cancelled => TouchPhase::Cancelled,
@@ -747,19 +756,19 @@ define_class!(
 
             self.queue_event(WindowEvent::RotationGesture {
                 device_id: None,
-                delta: event.rotation(),
+                delta: unsafe { event.rotation() },
                 phase,
             });
         }
 
         #[unsafe(method(pressureChangeWithEvent:))]
         fn pressure_change_with_event(&self, event: &NSEvent) {
-            let _entered = debug_span!("pressureChangeWithEvent:").entered();
+            trace_scope!("pressureChangeWithEvent:");
 
             self.queue_event(WindowEvent::TouchpadPressure {
                 device_id: None,
-                pressure: event.pressure(),
+                pressure: unsafe { event.pressure() },
-                stage: event.stage() as i64,
+                stage: unsafe { event.stage() } as i64,
             });
         }
 
@@ -768,13 +777,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 {
-            let _entered = debug_span!("_wantsKeyDownForEvent:").entered();
+            trace_scope!("_wantsKeyDownForEvent:");
             true
         }
 
         #[unsafe(method(acceptsFirstMouse:))]
         fn accepts_first_mouse(&self, _event: &NSEvent) -> bool {
-            let _entered = debug_span!("acceptsFirstMouse:").entered();
+            trace_scope!("acceptsFirstMouse:");
             self.ivars().accepts_first_mouse
         }
     }
@@ -794,6 +803,7 @@ 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(),
@@ -803,56 +813,9 @@ 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
     }
 
@@ -867,37 +830,6 @@ 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
     }
@@ -935,33 +867,24 @@ 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)
 
-        // if self.ivars().ime_capabilities.get().is_none() {
+    pub(super) fn set_ime_allowed(&self, capabilities: Option<ImeCapabilities>) {
-        //     self.ivars().ime_state.set(ImeState::Ground);
+        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();
 
-        // 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> {
@@ -1008,8 +931,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 && ns_event.keyCode() != 0 {
+            if is_flags_changed_event && unsafe { ns_event.keyCode() } != 0 {
-                let scancode = ns_event.keyCode();
+                let scancode = unsafe { ns_event.keyCode() };
                 let physical_key = scancode_to_physicalkey(scancode as u32);
 
                 let logical_key = code_to_key(physical_key, scancode);
@@ -1141,7 +1064,7 @@ impl WinitView {
             || view_point.x > frame.size.width
             || view_point.y > frame.size.height
         {
-            let mouse_buttons_down = NSEvent::pressedMouseButtons();
+            let mouse_buttons_down = unsafe { NSEvent::pressedMouseButtons() };
             if mouse_buttons_down == 0 {
                 // Point is outside of the client area (view) and no buttons are pressed
                 return;
@@ -1159,7 +1082,7 @@ impl WinitView {
     }
 
     fn mouse_view_point(&self, event: &NSEvent) -> LogicalPosition<f64> {
-        let window_point = event.locationInWindow();
+        let window_point = unsafe { event.locationInWindow() };
         let view_point = self.convertPoint_fromView(window_point, None);
 
         LogicalPosition::new(view_point.x, view_point.y)
@@ -1173,11 +1096,14 @@ 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.
-    let b: isize = event.buttonNumber();
+    match unsafe { event.buttonNumber() } {
-    b.try_into()
+        0 => MouseButton::Left,
-        .ok()
+        1 => MouseButton::Right,
-        .and_then(MouseButton::try_from_u8)
+        2 => MouseButton::Middle,
-        .expect("expected MacOS button number in the range 0..=31")
+        3 => MouseButton::Back,
+        4 => MouseButton::Forward,
+        n => MouseButton::Other(n as u16),
+    }
 }
 
 // NOTE: to get option as alt working we need to rewrite events
@@ -1194,9 +1120,11 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEven
         && !ev_mods.meta_key();
 
     if ignore_alt_characters {
-        let ns_chars =
+        let ns_chars = unsafe {
-            event.charactersIgnoringModifiers().expect("expected characters to be non-null");
+            event.charactersIgnoringModifiers().expect("expected characters to be non-null")
+        };
 
+        unsafe {
             NSEvent::keyEventWithType_location_modifierFlags_timestamp_windowNumber_context_characters_charactersIgnoringModifiers_isARepeat_keyCode(
                 event.r#type(),
                 event.locationInWindow(),
@@ -1210,96 +1138,8 @@ 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

@@ -4,11 +4,10 @@ use std::sync::Arc;
 
 use dispatch2::MainThreadBound;
 use dpi::{Position, Size};
-use objc2::rc::{Retained, autoreleasepool};
+use objc2::rc::{autoreleasepool, Retained};
-use objc2::{MainThreadMarker, Message, define_class};
+use objc2::{define_class, MainThreadMarker, Message};
 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;
@@ -351,13 +350,13 @@ define_class!(
     impl WinitWindow {
         #[unsafe(method(canBecomeMainWindow))]
         fn can_become_main_window(&self) -> bool {
-            let _entered = trace_span!("canBecomeMainWindow").entered();
+            trace_scope!("canBecomeMainWindow");
             true
         }
 
         #[unsafe(method(canBecomeKeyWindow))]
         fn can_become_key_window(&self) -> bool {
-            let _entered = trace_span!("canBecomeKeyWindow").entered();
+            trace_scope!("canBecomeKeyWindow");
             true
         }
     }
@@ -375,7 +374,7 @@ define_class!(
         // it doesn't if window doesn't have NSWindowStyleMask::Titled
         #[unsafe(method(canBecomeKeyWindow))]
         fn can_become_key_window(&self) -> bool {
-            let _entered = trace_span!("canBecomeKeyWindow").entered();
+            trace_scope!("canBecomeKeyWindow");
             true
         }
     }

winit-appkit/src/window_delegate.rs

@@ -10,39 +10,36 @@ use dpi::{
     LogicalInsets, LogicalPosition, LogicalSize, PhysicalInsets, PhysicalPosition, PhysicalSize,
     Position, Size,
 };
-use objc2::rc::{Retained, autoreleasepool};
+use objc2::rc::{autoreleasepool, Retained};
 use objc2::runtime::{AnyObject, ProtocolObject};
 use objc2::{
-    ClassType, DefinedClass, MainThreadMarker, MainThreadOnly, Message, available, define_class,
+    available, define_class, msg_send, sel, ClassType, DefinedClass, MainThreadMarker,
-    msg_send, sel,
+    MainThreadOnly, Message,
 };
 use objc2_app_kit::{
     NSAppKitVersionNumber, NSAppKitVersionNumber10_12, NSAppearance, NSAppearanceCustomization,
     NSAppearanceNameAqua, NSApplication, NSApplicationPresentationOptions, NSBackingStoreType,
-    NSColor, NSDraggingDestination, NSDraggingInfo, NSRequestUserAttentionType, NSScreen,
+    NSColor, NSDraggingDestination, NSDraggingInfo, NSFilenamesPboardType,
-    NSToolbar, NSView, NSViewFrameDidChangeNotification, NSWindow, NSWindowButton,
+    NSRequestUserAttentionType, NSScreen, NSToolbar, NSView, NSViewFrameDidChangeNotification,
-    NSWindowDelegate, NSWindowLevel, NSWindowOcclusionState, NSWindowOrderingMode,
+    NSWindow, NSWindowButton, NSWindowDelegate, NSWindowFullScreenButton, NSWindowLevel,
-    NSWindowSharingType, NSWindowStyleMask, NSWindowTabbingMode, NSWindowTitleVisibility,
+    NSWindowOcclusionState, NSWindowOrderingMode, NSWindowSharingType, NSWindowStyleMask,
-    NSWindowToolbarStyle,
+    NSWindowTabbingMode, NSWindowTitleVisibility, NSWindowToolbarStyle,
 };
-#[allow(deprecated)]
-use objc2_app_kit::{NSFilenamesPboardType, NSWindowFullScreenButton};
 use objc2_core_foundation::{CGFloat, CGPoint};
 use objc2_core_graphics::{
-    CGAcquireDisplayFadeReservation, CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture,
-    CGDisplayFade, CGDisplayRelease, CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
-    CGRestorePermanentDisplayConfiguration, CGShieldingWindowLevel, CGWarpMouseCursorPosition,
     kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, kCGDisplayFadeReservationInvalidToken,
-    kCGFloatingWindowLevel, kCGNormalWindowLevel,
+    kCGFloatingWindowLevel, kCGNormalWindowLevel, CGAcquireDisplayFadeReservation,
+    CGAssociateMouseAndMouseCursorPosition, CGDisplayCapture, CGDisplayFade, CGDisplayRelease,
+    CGDisplaySetDisplayMode, CGReleaseDisplayFadeReservation,
+    CGRestorePermanentDisplayConfiguration, CGShieldingWindowLevel, CGWarpMouseCursorPosition,
 };
 use objc2_foundation::{
-    NSArray, NSDictionary, NSEdgeInsets, NSKeyValueChangeKey, NSKeyValueChangeNewKey,
+    ns_string, NSArray, NSDictionary, NSEdgeInsets, NSKeyValueChangeKey, NSKeyValueChangeNewKey,
     NSKeyValueChangeOldKey, NSKeyValueObservingOptions, NSNotificationCenter, NSObject,
     NSObjectNSDelayedPerforming, NSObjectNSKeyValueObserverRegistration, NSObjectProtocol, NSPoint,
-    NSRect, NSSize, NSString, ns_string,
+    NSRect, NSSize, NSString,
 };
-use tracing::{debug_span, trace, warn};
+use tracing::{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};
@@ -54,12 +51,13 @@ use winit_core::window::{
 };
 
 use super::app_state::AppState;
-use super::cursor::{CustomCursor, cursor_from_icon};
+use super::cursor::{cursor_from_icon, CustomCursor};
 use super::ffi;
-use super::monitor::{self, MonitorHandle, flip_window_screen_coordinates, get_display_id};
+use super::monitor::{self, flip_window_screen_coordinates, get_display_id, MonitorHandle};
+use super::observer::RunLoop;
 use super::util::cgerr;
 use super::view::WinitView;
-use super::window::{WinitPanel, WinitWindow, window_id};
+use super::window::{window_id, WinitPanel, WinitWindow};
 use crate::{OptionAsAlt, WindowAttributesMacOS, WindowExtMacOS};
 
 #[derive(Debug)]
@@ -121,14 +119,14 @@ define_class!(
     unsafe impl NSWindowDelegate for WindowDelegate {
         #[unsafe(method(windowShouldClose:))]
         fn window_should_close(&self, _: Option<&AnyObject>) -> bool {
-            let _entered = debug_span!("windowShouldClose:").entered();
+            trace_scope!("windowShouldClose:");
             self.queue_event(WindowEvent::CloseRequested);
             false
         }
 
         #[unsafe(method(windowWillClose:))]
         fn window_will_close(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowWillClose:").entered();
+            trace_scope!("windowWillClose:");
             // `setDelegate:` retains the previous value and then autoreleases it
             autoreleasepool(|_| {
                 // Since El Capitan, we need to be careful that delegate methods can't
@@ -140,14 +138,14 @@ define_class!(
 
         #[unsafe(method(windowDidResize:))]
         fn window_did_resize(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowDidResize:").entered();
+            trace_scope!("windowDidResize:");
             // NOTE: WindowEvent::SurfaceResized is reported using NSViewFrameDidChangeNotification.
             self.emit_move_event();
         }
 
         #[unsafe(method(windowWillStartLiveResize:))]
         fn window_will_start_live_resize(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowWillStartLiveResize:").entered();
+            trace_scope!("windowWillStartLiveResize:");
 
             let increments = self.ivars().surface_resize_increments.get();
             self.set_resize_increments_inner(increments);
@@ -155,20 +153,20 @@ define_class!(
 
         #[unsafe(method(windowDidEndLiveResize:))]
         fn window_did_end_live_resize(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowDidEndLiveResize:").entered();
+            trace_scope!("windowDidEndLiveResize:");
             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>) {
-            let _entered = debug_span!("windowDidMove:").entered();
+            trace_scope!("windowDidMove:");
             self.emit_move_event();
         }
 
         #[unsafe(method(windowDidChangeBackingProperties:))]
         fn window_did_change_backing_properties(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowDidChangeBackingProperties:").entered();
+            trace_scope!("windowDidChangeBackingProperties:");
             let scale_factor = self.scale_factor();
             if scale_factor == self.ivars().previous_scale_factor.get() {
                 return;
@@ -177,14 +175,14 @@ define_class!(
 
             let mtm = MainThreadMarker::from(self);
             let this = self.retain();
-            MainRunLoop::get(mtm).queue_closure(move || {
+            RunLoop::main(mtm).queue_closure(move || {
                 this.handle_scale_factor_changed(scale_factor);
             });
         }
 
         #[unsafe(method(windowDidBecomeKey:))]
         fn window_did_become_key(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowDidBecomeKey:").entered();
+            trace_scope!("windowDidBecomeKey:");
             // TODO: center the cursor if the window had mouse grab when it
             // lost focus
             self.queue_event(WindowEvent::Focused(true));
@@ -192,7 +190,7 @@ define_class!(
 
         #[unsafe(method(windowDidResignKey:))]
         fn window_did_resign_key(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowDidResignKey:").entered();
+            trace_scope!("windowDidResignKey:");
             // 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
@@ -208,7 +206,7 @@ define_class!(
         /// Invoked when before enter fullscreen
         #[unsafe(method(windowWillEnterFullScreen:))]
         fn window_will_enter_fullscreen(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowWillEnterFullScreen:").entered();
+            trace_scope!("windowWillEnterFullScreen:");
 
             self.ivars().maximized.set(self.is_zoomed());
             let mut fullscreen = self.ivars().fullscreen.borrow_mut();
@@ -236,7 +234,7 @@ define_class!(
         /// Invoked when before exit fullscreen
         #[unsafe(method(windowWillExitFullScreen:))]
         fn window_will_exit_fullscreen(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowWillExitFullScreen:").entered();
+            trace_scope!("windowWillExitFullScreen:");
 
             self.ivars().in_fullscreen_transition.set(true);
         }
@@ -247,7 +245,7 @@ define_class!(
             _: Option<&AnyObject>,
             proposed_options: NSApplicationPresentationOptions,
         ) -> NSApplicationPresentationOptions {
-            let _entered = debug_span!("window:willUseFullScreenPresentationOptions:").entered();
+            trace_scope!("window:willUseFullScreenPresentationOptions:");
             // 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
@@ -270,7 +268,7 @@ define_class!(
         /// Invoked when entered fullscreen
         #[unsafe(method(windowDidEnterFullScreen:))]
         fn window_did_enter_fullscreen(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowDidEnterFullScreen:").entered();
+            trace_scope!("windowDidEnterFullScreen:");
             self.ivars().initial_fullscreen.set(false);
             self.ivars().in_fullscreen_transition.set(false);
             if let Some(target_fullscreen) = self.ivars().target_fullscreen.take() {
@@ -281,7 +279,7 @@ define_class!(
         /// Invoked when exited fullscreen
         #[unsafe(method(windowDidExitFullScreen:))]
         fn window_did_exit_fullscreen(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowDidExitFullScreen:").entered();
+            trace_scope!("windowDidExitFullScreen:");
 
             self.restore_state_from_fullscreen();
             self.ivars().in_fullscreen_transition.set(false);
@@ -308,7 +306,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>) {
-            let _entered = debug_span!("windowDidFailToEnterFullScreen:").entered();
+            trace_scope!("windowDidFailToEnterFullScreen:");
             self.ivars().in_fullscreen_transition.set(false);
             self.ivars().target_fullscreen.replace(None);
             if self.ivars().initial_fullscreen.get() {
@@ -327,28 +325,14 @@ define_class!(
         // Invoked when the occlusion state of the window changes
         #[unsafe(method(windowDidChangeOcclusionState:))]
         fn window_did_change_occlusion_state(&self, _: Option<&AnyObject>) {
-            let _entered = debug_span!("windowDidChangeOcclusionState:").entered();
+            trace_scope!("windowDidChangeOcclusionState:");
             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>) {
-            let _entered = debug_span!("windowDidChangeScreen:").entered();
+            trace_scope!("windowDidChangeScreen:");
             let is_simple_fullscreen = self.ivars().is_simple_fullscreen.get();
             if is_simple_fullscreen {
                 if let Some(screen) = self.window().screen() {
@@ -362,26 +346,22 @@ define_class!(
         /// Invoked when the dragged image enters destination bounds or frame
         #[unsafe(method(draggingEntered:))]
         fn dragging_entered(&self, sender: &ProtocolObject<dyn NSDraggingInfo>) -> bool {
-            let _entered = debug_span!("draggingEntered:").entered();
+            trace_scope!("draggingEntered:");
 
             use std::path::PathBuf;
 
-            let pb = sender.draggingPasteboard();
+            let pb = unsafe { sender.draggingPasteboard() };
-
+            let filenames = pb
-            #[allow(deprecated)]
+                .propertyListForType(unsafe { NSFilenamesPboardType })
-            let property_list = match pb.propertyListForType(unsafe { NSFilenamesPboardType }) {
-                Some(property_list) => property_list,
-                None => return false.into(),
-            };
-
-            let paths = property_list
-                .downcast::<NSArray>()
                 .unwrap()
+                .downcast::<NSArray>()
+                .unwrap();
+            let paths = filenames
                 .into_iter()
                 .map(|file| PathBuf::from(file.downcast::<NSString>().unwrap().to_string()))
                 .collect();
 
-            let dl = sender.draggingLocation();
+            let dl = unsafe { sender.draggingLocation() };
             let dl = self.view().convertPoint_fromView(dl, None);
             let position =
                 LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
@@ -393,7 +373,7 @@ define_class!(
 
         #[unsafe(method(wantsPeriodicDraggingUpdates))]
         fn wants_periodic_dragging_updates(&self) -> bool {
-            let _entered = debug_span!("wantsPeriodicDraggingUpdates:").entered();
+            trace_scope!("wantsPeriodicDraggingUpdates:");
             true
         }
 
@@ -401,9 +381,9 @@ define_class!(
         /// modification of the dragging operation or mouse-pointer position.
         #[unsafe(method(draggingUpdated:))]
         fn dragging_updated(&self, sender: &ProtocolObject<dyn NSDraggingInfo>) -> bool {
-            let _entered = debug_span!("draggingUpdated:").entered();
+            trace_scope!("draggingUpdated:");
 
-            let dl = sender.draggingLocation();
+            let dl = unsafe { sender.draggingLocation() };
             let dl = self.view().convertPoint_fromView(dl, None);
             let position =
                 LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
@@ -416,33 +396,29 @@ define_class!(
         /// Invoked when the image is released
         #[unsafe(method(prepareForDragOperation:))]
         fn prepare_for_drag_operation(&self, _sender: &NSObject) -> bool {
-            let _entered = debug_span!("prepareForDragOperation:").entered();
+            trace_scope!("prepareForDragOperation:");
             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 {
-            let _entered = debug_span!("performDragOperation:").entered();
+            trace_scope!("performDragOperation:");
 
             use std::path::PathBuf;
 
-            let pb = sender.draggingPasteboard();
+            let pb = unsafe { sender.draggingPasteboard() };
-
+            let filenames = pb
-            #[allow(deprecated)]
+                .propertyListForType(unsafe { NSFilenamesPboardType })
-            let property_list = match pb.propertyListForType(unsafe { NSFilenamesPboardType }) {
-                Some(property_list) => property_list,
-                None => return false.into(),
-            };
-
-            let paths = property_list
-                .downcast::<NSArray>()
                 .unwrap()
+                .downcast::<NSArray>()
+                .unwrap();
+            let paths = filenames
                 .into_iter()
                 .map(|file| PathBuf::from(file.downcast::<NSString>().unwrap().to_string()))
                 .collect();
 
-            let dl = sender.draggingLocation();
+            let dl = unsafe { sender.draggingLocation() };
             let dl = self.view().convertPoint_fromView(dl, None);
             let position =
                 LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor());
@@ -455,16 +431,16 @@ define_class!(
         /// Invoked when the dragging operation is complete
         #[unsafe(method(concludeDragOperation:))]
         fn conclude_drag_operation(&self, _sender: Option<&NSObject>) {
-            let _entered = debug_span!("concludeDragOperation:").entered();
+            trace_scope!("concludeDragOperation:");
         }
 
         /// Invoked when the dragging operation is cancelled
         #[unsafe(method(draggingExited:))]
         fn dragging_exited(&self, sender: Option<&ProtocolObject<dyn NSDraggingInfo>>) {
-            let _entered = debug_span!("draggingExited:").entered();
+            trace_scope!("draggingExited:");
 
             let position = sender.map(|sender| {
-                let dl = sender.draggingLocation();
+                let dl = unsafe { sender.draggingLocation() };
                 let dl = self.view().convertPoint_fromView(dl, None);
                 LogicalPosition::<f64>::from((dl.x, dl.y)).to_physical(self.scale_factor())
             });
@@ -483,7 +459,7 @@ define_class!(
             change: Option<&NSDictionary<NSKeyValueChangeKey, AnyObject>>,
             _context: *mut c_void,
         ) {
-            let _entered = debug_span!("observeValueForKeyPath:ofObject:change:context:").entered();
+            trace_scope!("observeValueForKeyPath:ofObject:change:context:");
             // 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")) {
@@ -501,12 +477,12 @@ define_class!(
                 let old = old.downcast::<NSAppearance>().unwrap();
                 let new = new.downcast::<NSAppearance>().unwrap();
 
-                trace!(old = %old.name(), new = %new.name(), "effectiveAppearance changed");
+                trace!(old = %unsafe { old.name() }, new = %unsafe { 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 self.window().appearance().is_some() {
+                if unsafe { self.window().appearance() }.is_some() {
                     return;
                 }
 
@@ -529,7 +505,9 @@ 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"));
+        }
     }
 }
 
@@ -688,11 +666,13 @@ 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);
             }
+        }
 
         if !attrs.enabled_buttons.contains(WindowButtons::MAXIMIZE) {
             if let Some(button) = window.standardWindowButton(NSWindowButton::ZoomButton) {
@@ -740,7 +720,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 = NSNotificationCenter::defaultCenter();
+        let notification_center = unsafe { NSNotificationCenter::defaultCenter() };
         unsafe {
             notification_center.addObserver_selector_name_object(
                 &view,
@@ -753,11 +733,10 @@ fn new_window(
         if attrs.transparent {
             window.setOpaque(false);
             // See `set_transparent` for details on why we do this.
-            window.setBackgroundColor(Some(&NSColor::clearColor()));
+            window.setBackgroundColor(unsafe { Some(&NSColor::clearColor()) });
         }
 
         // register for drag and drop operations.
-        #[allow(deprecated)]
         window.registerForDraggedTypes(&NSArray::from_slice(&[unsafe { NSFilenamesPboardType }]));
 
         Some(window)
@@ -811,7 +790,7 @@ impl WindowDelegate {
         let scale_factor = window.backingScaleFactor() as _;
 
         if let Some(appearance) = theme_to_appearance(attrs.preferred_theme) {
-            window.setAppearance(Some(&appearance));
+            unsafe { window.setAppearance(Some(&appearance)) };
         }
 
         let delegate = mtm.alloc().set_ivars(State {
@@ -912,7 +891,10 @@ impl WindowDelegate {
     fn handle_scale_factor_changed(&self, scale_factor: CGFloat) {
         let window = self.window();
 
-        let suggested_size = self.view().surface_size();
+        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 new_surface_size = Arc::new(Mutex::new(suggested_size));
         self.queue_event(WindowEvent::ScaleFactorChanged {
             scale_factor,
@@ -963,8 +945,11 @@ 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 =
+        let color = if transparent {
-            if transparent { NSColor::clearColor() } else { NSColor::windowBackgroundColor() };
+            unsafe { NSColor::clearColor() }
+        } else {
+            unsafe { NSColor::windowBackgroundColor() }
+        };
 
         self.window().setBackgroundColor(Some(&color));
     }
@@ -973,7 +958,7 @@ impl WindowDelegate {
         // 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 = self.window().windowNumber();
+        let window_number = unsafe { self.window().windowNumber() };
         unsafe {
             ffi::CGSSetWindowBackgroundBlurRadius(
                 ffi::CGSMainConnectionID(),
@@ -1032,12 +1017,14 @@ impl WindowDelegate {
             NSPoint::new(position.x, position.y),
             self.window().frame().size,
         ));
-        self.window().setFrameOrigin(point);
+        unsafe { self.window().setFrameOrigin(point) };
     }
 
     #[inline]
     pub fn surface_size(&self) -> PhysicalSize<u32> {
-        self.view().surface_size()
+        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())
     }
 
     #[inline]
@@ -1052,15 +1039,17 @@ 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`.
-            self.view().safeAreaInsets()
+            unsafe { self.view().safeAreaInsets() }
         } else {
             // If `safeAreaInsets` is not available, we'll have to do the calculation ourselves.
 
-            let window_rect = self.window().convertRectFromScreen(
+            let window_rect = unsafe {
+                self.window().convertRectFromScreen(
                     self.window().contentRectForFrameRect(self.window().frame()),
-            );
+                )
+            };
             // This includes NSWindowStyleMask::FullSizeContentView.
-            let layout_rect = self.window().contentLayoutRect();
+            let layout_rect = unsafe { self.window().contentLayoutRect() };
 
             // Calculate the insets from window coordinates in AppKit's coordinate system.
             NSEdgeInsets {
@@ -1090,7 +1079,7 @@ impl WindowDelegate {
         let min_size = dimensions.to_logical::<CGFloat>(self.scale_factor());
 
         let min_size = NSSize::new(min_size.width, min_size.height);
-        self.window().setContentMinSize(min_size);
+        unsafe { self.window().setContentMinSize(min_size) };
 
         // If necessary, resize the window to match constraint
         let mut current_size = self.window().contentRectForFrameRect(self.window().frame()).size;
@@ -1112,7 +1101,7 @@ impl WindowDelegate {
         let max_size = dimensions.to_logical::<CGFloat>(scale_factor);
 
         let max_size = NSSize::new(max_size.width, max_size.height);
-        self.window().setContentMaxSize(max_size);
+        unsafe { self.window().setContentMaxSize(max_size) };
 
         // If necessary, resize the window to match constraint
         let mut current_size = self.window().contentRectForFrameRect(self.window().frame()).size;
@@ -1252,12 +1241,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(CGAssociateMouseAndMouseCursorPosition(associate_mouse_cursor))?;
+        cgerr(unsafe { CGAssociateMouseAndMouseCursorPosition(associate_mouse_cursor) })?;
 
         Ok(())
     }
@@ -1285,8 +1274,8 @@ impl WindowDelegate {
             x: window_position.x + cursor_position.x,
             y: window_position.y + cursor_position.y,
         };
-        cgerr(CGWarpMouseCursorPosition(point))?;
+        cgerr(unsafe { CGWarpMouseCursorPosition(point) })?;
-        cgerr(CGAssociateMouseAndMouseCursorPosition(true))?;
+        cgerr(unsafe { CGAssociateMouseAndMouseCursorPosition(true) })?;
 
         Ok(())
     }
@@ -1367,7 +1356,7 @@ impl WindowDelegate {
         if minimized {
             self.window().miniaturize(Some(self));
         } else {
-            self.window().deminiaturize(Some(self));
+            unsafe { self.window().deminiaturize(Some(self)) };
         }
     }
 
@@ -1461,7 +1450,7 @@ impl WindowDelegate {
 
             let old_screen = self.window().screen().unwrap();
             if old_screen != new_screen {
-                self.window().setFrameOrigin(new_screen.frame().origin);
+                unsafe { self.window().setFrameOrigin(new_screen.frame().origin) };
             }
         }
 
@@ -1486,9 +1475,10 @@ 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(unsafe { CGAcquireDisplayFadeReservation(5.0, &mut fade_token) }).is_ok() {
+                if cgerr(CGAcquireDisplayFadeReservation(5.0, &mut fade_token)).is_ok() {
                     CGDisplayFade(
                         fade_token,
                         0.3,
@@ -1502,6 +1492,7 @@ impl WindowDelegate {
                 }
 
                 cgerr(CGDisplayCapture(display_id)).unwrap();
+            }
 
             let monitor = monitor.cast_ref::<MonitorHandle>().unwrap();
             let video_mode =
@@ -1510,9 +1501,8 @@ impl WindowDelegate {
                     None => return,
                 };
 
-            cgerr(unsafe {
+            unsafe {
-                CGDisplaySetDisplayMode(display_id, Some(&video_mode.native_mode.0), None)
+                cgerr(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
@@ -1531,6 +1521,7 @@ impl WindowDelegate {
                     CGReleaseDisplayFadeReservation(fade_token);
                 }
             }
+        }
 
         self.ivars().fullscreen.replace(fullscreen.clone());
 
@@ -1543,7 +1534,7 @@ impl WindowDelegate {
         }
 
         match (old_fullscreen, fullscreen) {
-            (None, Some(_)) => {
+            (None, Some(fullscreen)) => {
                 // `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`.
@@ -1554,6 +1545,16 @@ 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) => {
@@ -1581,7 +1582,7 @@ impl WindowDelegate {
                     | NSApplicationPresentationOptions::HideMenuBar;
                 app.setPresentationOptions(presentation_options);
 
-                let window_level = CGShieldingWindowLevel() as NSWindowLevel + 1;
+                let window_level = unsafe { CGShieldingWindowLevel() } as NSWindowLevel + 1;
                 self.window().setLevel(window_level);
             },
             (Some(Fullscreen::Exclusive(monitor, _)), Some(Fullscreen::Borderless(_))) => {
@@ -1681,7 +1682,7 @@ impl WindowDelegate {
                 if current_caps.is_some() {
                     return Err(ImeRequestError::AlreadyEnabled);
                 }
-                self.view().enable_ime(capabilities);
+                self.view().set_ime_allowed(Some(capabilities));
                 request_data
             },
             ImeRequest::Update(request_data) => {
@@ -1691,7 +1692,7 @@ impl WindowDelegate {
                 request_data
             },
             ImeRequest::Disable => {
-                self.view().disable_ime();
+                self.view().set_ime_allowed(None);
                 return Ok(());
             },
         };
@@ -1796,8 +1797,9 @@ impl WindowDelegate {
     }
 
     pub fn theme(&self) -> Option<Theme> {
-        self.window().appearance().map(|appearance| appearance_to_theme(&appearance)).or_else(
+        unsafe { self.window().appearance() }
-            || {
+            .map(|appearance| appearance_to_theme(&appearance))
+            .or_else(|| {
                 let mtm = MainThreadMarker::from(self);
                 let app = NSApplication::sharedApplication(mtm);
 
@@ -1806,12 +1808,11 @@ impl WindowDelegate {
                 } else {
                     Some(Theme::Light)
                 }
-            },
+            })
-        )
     }
 
     pub fn set_theme(&self, theme: Option<Theme>) {
-        self.window().setAppearance(theme_to_appearance(theme).as_deref());
+        unsafe { self.window().setAppearance(theme_to_appearance(theme).as_deref()) };
     }
 
     #[inline]
@@ -1835,8 +1836,10 @@ 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();
+        };
     } else {
         warn!(
             monitor = monitor.name().map(|name| name.to_string()),
@@ -1898,7 +1901,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)) {
-                self.view().setAdditionalSafeAreaInsets(screen.safeAreaInsets());
+                unsafe { self.view().setAdditionalSafeAreaInsets(screen.safeAreaInsets()) };
             }
 
             // Fullscreen windows can't be resized, minimized, or moved
@@ -1917,6 +1920,7 @@ impl WindowExtMacOS for WindowDelegate {
             }
 
             if NSScreen::class().responds_to(sel!(safeAreaInsets)) {
+                unsafe {
                     self.view().setAdditionalSafeAreaInsets(NSEdgeInsets {
                         top: 0.0,
                         left: 0.0,
@@ -1924,6 +1928,7 @@ impl WindowExtMacOS for WindowDelegate {
                         right: 0.0,
                     });
                 }
+            }
 
             self.window().setFrame_display(frame, true);
             self.window().setMovable(true);
@@ -1960,7 +1965,7 @@ impl WindowExtMacOS for WindowDelegate {
 
     #[inline]
     fn select_previous_tab(&self) {
-        self.window().selectPreviousTab(None)
+        unsafe { self.window().selectPreviousTab(None) }
     }
 
     #[inline]
@@ -1970,7 +1975,7 @@ impl WindowExtMacOS for WindowDelegate {
             return;
         }
         if let Some(group) = self.window().tabGroup() {
-            if let Some(windows) = self.window().tabbedWindows() {
+            if let Some(windows) = unsafe { self.window().tabbedWindows() } {
                 if index < windows.len() {
                     group.setSelectedWindow(Some(&windows.objectAtIndex(index)));
                 }
@@ -1980,7 +1985,7 @@ impl WindowExtMacOS for WindowDelegate {
 
     #[inline]
     fn num_tabs(&self) -> usize {
-        self.window().tabbedWindows().map(|windows| windows.len()).unwrap_or(1)
+        unsafe { self.window().tabbedWindows() }.map(|windows| windows.len()).unwrap_or(1)
     }
 
     fn is_document_edited(&self) -> bool {
@@ -2013,22 +2018,28 @@ 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);
+            }
         } else {
+            unsafe {
                 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
         }
     }
+}
 
 const DEFAULT_STANDARD_FRAME: NSRect =
     NSRect::new(NSPoint::new(50.0, 50.0), NSSize::new(800.0, 600.0));
@@ -2044,7 +2055,11 @@ 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,10 +18,7 @@ x11 = ["xkbcommon-dl?/x11", "dep:x11-dl"]
 xkb = ["dep:xkbcommon-dl", "dep:smol_str"]
 
 # CoreFoundation
-core-foundation = ["dep:block2", "dep:objc2", "dep:objc2-core-foundation"]
+core-foundation = ["dep:objc2", "dep:objc2-core-foundation"]
-
-# Foundation
-foundation = ["dep:block2", "dep:objc2", "dep:objc2-foundation"]
 
 [dependencies]
 smol_str = { workspace = true, optional = true }
@@ -33,23 +30,13 @@ memmap2 = { workspace = true, optional = true }
 x11-dl = { workspace = true, optional = true }
 xkbcommon-dl = { workspace = true, optional = true }
 
-# Foundation / CoreFoundation
+# 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

@@ -1,9 +1,12 @@
 use std::os::raw::c_void;
+use std::ptr::NonNull;
 use std::sync::Arc;
+use std::task::{RawWaker, RawWakerVTable, Waker};
 
 use objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    CFIndex, CFRetained, CFRunLoop, CFRunLoopSource, CFRunLoopSourceContext, kCFRunLoopCommonModes,
+    kCFRunLoopCommonModes, CFIndex, CFRetained, CFRunLoop, CFRunLoopSource, CFRunLoopSourceContext,
+    Type,
 };
 use winit_core::event_loop::EventLoopProxyProvider;
 
@@ -119,4 +122,54 @@ impl EventLoopProxyProvider for EventLoopProxy {
         // main loop may be sleeping (and `CFRunLoopSourceSignal` won't wake it).
         self.main_loop.wake_up();
     }
+
+    fn waker(&self) -> Waker {
+        const VTABLE: RawWakerVTable =
+            RawWakerVTable::new(clone_waker, wake, wake_by_ref, drop_waker);
+
+        unsafe fn clone_waker(data: *const ()) -> RawWaker {
+            // SAFETY: The poiner came from `CFRunLoopSource` and is valid and non-null.
+            let source = unsafe { &*data.cast::<CFRunLoopSource>() };
+
+            // Increment reference count.
+            let source = source.retain();
+
+            // Pass ownership to the raw waker.
+            let data: *const CFRunLoopSource = CFRetained::into_raw(source).as_ptr();
+            RawWaker::new(data.cast(), &VTABLE)
+        }
+
+        unsafe fn wake(data: *const ()) {
+            unsafe { wake_by_ref(data) };
+            unsafe { drop_waker(data) };
+        }
+
+        unsafe fn wake_by_ref(data: *const ()) {
+            // SAFETY: The poiner came from `CFRunLoopSource` and is valid and non-null.
+            let source = unsafe { &*data.cast::<CFRunLoopSource>() };
+
+            // Signal the source, which ends up later invoking `perform` on the main thread.
+            //
+            // Multiple signals in quick succession are automatically coalesced into a single
+            // signal.
+            source.signal();
+
+            let main_loop = CFRunLoop::main().unwrap();
+            // Let the main thread know there's a new event.
+            //
+            // This is required since we may be (probably are) running on a different thread, and
+            // the main loop may be sleeping (and `CFRunLoopSourceSignal` won't wake it).
+            main_loop.wake_up();
+        }
+
+        unsafe fn drop_waker(data: *const ()) {
+            let source = data.cast::<CFRunLoopSource>().cast_mut();
+            // SAFETY: The poiner came from `CFRunLoopSource` and is valid and non-null.
+            // We take ownership of a retain count here.
+            let _source = unsafe { CFRetained::from_raw(NonNull::new_unchecked(source)) };
+        }
+
+        let data: *const CFRunLoopSource = CFRetained::into_raw(self.source.clone()).as_ptr();
+        unsafe { Waker::from_raw(RawWaker::new(data.cast(), &VTABLE)) }
+    }
 }

winit-common/src/core_foundation/main_run_loop.rs

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

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

@@ -1,146 +0,0 @@
-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,10 +79,6 @@ 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
@@ -118,7 +114,7 @@ impl EventHandler {
 
     pub fn handle(&self, callback: impl FnOnce(&mut (dyn ApplicationHandler + '_))) {
         match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(user_app)) => {
+            Ok(Some(ref mut 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

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

winit-common/src/lib.rs

@@ -4,7 +4,5 @@
 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::{XKBCH, XkbContext};
+use super::{XkbContext, XKBCH};
 
 #[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::{XKBH, XkbContext};
+use super::{XkbContext, XKBH};
 
 /// Map the raw X11-style keycode to the `KeyCode` enum.
 ///
@@ -37,9 +37,8 @@ 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' and Chromium's sources:
+    // The mapping here is heavily influenced by Firefox' source:
-    // - https://searchfox.org/mozilla-central/rev/c597e9c789ad36af84a0370d395be066b7dc94f4/widget/NativeKeyToDOMCodeName.h
+    // 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
@@ -160,11 +159,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::ShowAllWindows,
+        // 120 => KeyCode::SCALE,
         121 => KeyCode::NumpadComma,
         122 => KeyCode::Lang1,
         123 => KeyCode::Lang2,
@@ -186,7 +185,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,
@@ -211,8 +210,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         164 => KeyCode::MediaPlayPause,
         165 => KeyCode::MediaTrackPrevious,
         166 => KeyCode::MediaStop,
-        167 => KeyCode::MediaRecord,
+        // 167 => KeyCode::RECORD,
-        168 => KeyCode::MediaRewind,
+        // 168 => KeyCode::REWIND,
         // 169 => KeyCode::PHONE,
         // 170 => KeyCode::ISO,
         171 => KeyCode::MediaSelect, // CONFIG
@@ -223,8 +222,8 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         // 176 => KeyCode::EDIT,
         // 177 => KeyCode::SCROLLUP,
         // 178 => KeyCode::SCROLLDOWN,
-        179 => KeyCode::NumpadParenLeft,
+        // 179 => KeyCode::KPLEFTPAREN,
-        180 => KeyCode::NumpadParenRight,
+        // 180 => KeyCode::KPRIGHTPAREN,
         // 181 => KeyCode::NEW,
         // 182 => KeyCode::REDO,
         183 => KeyCode::F13,
@@ -240,14 +239,14 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         193 => KeyCode::F23,
         194 => KeyCode::F24,
         // 200 => KeyCode::PLAYCD,
-        201 => KeyCode::MediaPause,
+        // 201 => KeyCode::PAUSECD,
         // 202 => KeyCode::PROG3,
         // 203 => KeyCode::PROG4,
         // 204 => KeyCode::DASHBOARD,
         // 205 => KeyCode::SUSPEND,
         // 206 => KeyCode::CLOSE,
-        207 => KeyCode::MediaPlay,
+        // 207 => KeyCode::PLAY,
-        208 => KeyCode::MediaFastForward,
+        // 208 => KeyCode::FASTFORWARD,
         // 209 => KeyCode::BASSBOOST,
         // 210 => KeyCode::PRINT,
         // 211 => KeyCode::HP,
@@ -263,16 +262,16 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         // 221 => KeyCode::SHOP,
         // 222 => KeyCode::ALTERASE,
         // 223 => KeyCode::CANCEL,
-        224 => KeyCode::BrightnessDown,
+        // 224 => KeyCode::BRIGHTNESSDOW,
-        225 => KeyCode::BrightnessUp,
+        // 225 => KeyCode::BRIGHTNESSU,
         // 226 => KeyCode::MEDIA,
-        227 => KeyCode::DisplayToggleIntExt,
+        // 227 => KeyCode::SWITCHVIDEOMODE,
-        228 => KeyCode::KeyboardBacklightToggle,
+        // 228 => KeyCode::KBDILLUMTOGGLE,
         // 229 => KeyCode::KBDILLUMDOWN,
         // 230 => KeyCode::KBDILLUMUP,
-        231 => KeyCode::MailSend,
+        // 231 => KeyCode::SEND,
-        232 => KeyCode::MailReply,
+        // 232 => KeyCode::REPLY,
-        233 => KeyCode::MailForward,
+        // 233 => KeyCode::FORWARDMAIL,
         // 234 => KeyCode::SAVE,
         // 235 => KeyCode::DOCUMENTS,
         // 236 => KeyCode::BATTERY,
@@ -287,14 +286,7 @@ pub fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         // 245 => KeyCode::DISPLAY_OFF,
         // 246 => KeyCode::WWAN,
         // 247 => KeyCode::RFKILL,
-        248 => KeyCode::MicrophoneMuteToggle,
+        // 248 => KeyCode::KEY_MICMUTE,
-        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)),
     })
 }
@@ -423,10 +415,8 @@ 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),
@@ -446,7 +436,6 @@ 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),
@@ -458,13 +447,9 @@ 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),
@@ -477,26 +462,7 @@ 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,
     }
 }
@@ -1052,7 +1018,11 @@ impl XkbKeymap {
                 &mut keysyms,
             );
 
-            if count == 1 { *keysyms } else { 0 }
+            if count == 1 {
+                *keysyms
+            } else {
+                0
+            }
         }
     }
 
@@ -1096,6 +1066,10 @@ 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::LazyLock;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::LazyLock;
 
 use smol_str::SmolStr;
 use winit_core::event::{ElementState, KeyEvent};
 use winit_core::keyboard::{Key, KeyLocation};
 use xkbcommon_dl::{
-    self as xkb, XkbCommon, XkbCommonCompose, xkb_compose_status, xkb_context, xkb_context_flags,
+    self as xkb, xkb_compose_status, xkb_context, xkb_context_flags, xkbcommon_compose_handle,
-    xkbcommon_compose_handle, xkbcommon_handle,
+    xkbcommon_handle, XkbCommon, XkbCommonCompose,
 };
 #[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,7 +310,11 @@ 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::keymap::XkbKeymap;
+use super::{make_string_with, XKBH};
-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::AsAny;
+use crate::as_any::{impl_dyn_casting, 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,7 +35,11 @@ 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
+        }
     }
 }
 
@@ -74,7 +78,11 @@ 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
+        }
     }
 }
 
@@ -141,5 +149,7 @@ 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,7 +1,4 @@
 //! 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};
 
@@ -10,13 +7,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)]
@@ -156,8 +153,6 @@ pub enum WindowEvent {
     Ime(Ime),
 
     /// The pointer has moved on the window.
-    ///
-    /// Should be emitted regardless of window focus.
     PointerMoved {
         device_id: Option<DeviceId>,
 
@@ -186,8 +181,6 @@ pub enum WindowEvent {
     },
 
     /// The pointer has entered the window.
-    ///
-    /// Should be emitted regardless of window focus.
     PointerEntered {
         device_id: Option<DeviceId>,
 
@@ -213,8 +206,6 @@ pub enum WindowEvent {
     },
 
     /// The pointer has left the window.
-    ///
-    /// Should be emitted regardless of window focus.
     PointerLeft {
         device_id: Option<DeviceId>,
 
@@ -269,25 +260,11 @@ 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**, **iOS**, and **Wayland**.
+    /// - Only available on **macOS** and **iOS**.
     /// - On iOS, not recognized by default. It must be enabled when needed.
     PinchGesture {
         device_id: Option<DeviceId>,
@@ -303,7 +280,7 @@ pub enum WindowEvent {
     ///
     /// ## Platform-specific
     ///
-    /// - Only available on **iOS** and **Wayland**.
+    /// - Only available on **iOS**.
     /// - On iOS, not recognized by default. It must be enabled when needed.
     PanGesture {
         device_id: Option<DeviceId>,
@@ -339,7 +316,7 @@ pub enum WindowEvent {
     ///
     /// ## Platform-specific
     ///
-    /// - Only available on **macOS**, **iOS**, and **Wayland**.
+    /// - Only available on **macOS** and **iOS**.
     /// - On iOS, not recognized by default. It must be enabled when needed.
     RotationGesture {
         device_id: Option<DeviceId>,
@@ -458,7 +435,6 @@ pub enum PointerKind {
     ///
     /// **macOS:** Unsupported.
     Touch(FingerId),
-    TabletTool(TabletToolKind),
     Unknown,
 }
 
@@ -509,13 +485,6 @@ 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,
 }
 
@@ -524,7 +493,6 @@ 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,
         }
     }
@@ -534,21 +502,8 @@ impl From<PointerSource> for PointerKind {
 ///
 /// **Wayland/X11:** [`Unknown`](Self::Unknown) device types are converted to known variants by the
 /// system.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, 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.
     ///
@@ -559,27 +514,25 @@ 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 {
-    /// Try to convert a [`ButtonSource`] to an equivalent [`MouseButton`]. If a pointer type has no
+    /// Convert any [`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) -> Option<MouseButton> {
+    pub fn mouse_button(self) -> MouseButton {
         match self {
-            ButtonSource::Mouse(mouse) => Some(mouse),
+            ButtonSource::Mouse(mouse) => mouse,
-            ButtonSource::Touch { .. } => Some(MouseButton::Left),
+            ButtonSource::Touch { .. } => MouseButton::Left,
-            ButtonSource::TabletTool { button, .. } => button.into(),
+            ButtonSource::Unknown(button) => match button {
-            ButtonSource::Unknown(_) => None,
+                0 => MouseButton::Left,
+                1 => MouseButton::Middle,
+                2 => MouseButton::Right,
+                3 => MouseButton::Back,
+                4 => MouseButton::Forward,
+                _ => MouseButton::Other(button),
+            },
         }
     }
 }
@@ -792,7 +745,7 @@ pub struct KeyEvent {
     ///
     /// # Example
     ///
-    /// In games, you often want to ignore repeated key events - this can be
+    /// In games, you often want to ignore repated key events - this can be
     /// done by ignoring events where this property is set.
     ///
     /// ```no_run
@@ -817,14 +770,13 @@ pub struct KeyEvent {
     /// ```
     pub repeat: bool,
 
-    /// Similar to [`text`][Self::text], except that this is affected by <kbd>Ctrl</kbd> and may
+    /// Similar to [`text`][Self::text], except that this is affected by <kbd>Ctrl</kbd>.
-    /// produce ASCII control characters.
     ///
-    /// For example, pressing <kbd>Ctrl</kbd>+<kbd>space</kbd> produces `Some("\x00")`.
+    /// For example, pressing <kbd>Ctrl</kbd>+<kbd>a</kbd> produces `Some("\x01")`.
     ///
     /// ## Platform-specific
     ///
-    /// - **Android:** This field is always the same value as `text`.
+    /// - **Android:** Unimplemented, 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>,
@@ -1020,24 +972,15 @@ 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
@@ -1048,7 +991,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 [`TabletToolAngle::altitude`] value.
+        /// calculate this value using the `altitude_angle` value.
         force: f64,
         /// The maximum possible force for a touch.
         ///
@@ -1069,17 +1012,9 @@ 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::Calibrated { force, max_possible_force } => force / max_possible_force,
-                let force = match angle {
-                    Some(TabletToolAngle { altitude, .. }) => force / altitude.sin(),
-                    None => *force,
-                };
-                force / max_possible_force
-            },
             Force::Normalized(force) => *force,
         }
     }
@@ -1091,260 +1026,6 @@ 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))]
@@ -1360,138 +1041,23 @@ impl ElementState {
     }
 }
 
-/// Identifies a button of a mouse controller.
+/// Describes a button of a mouse controller.
 ///
 /// ## Platform-specific
 ///
-/// The first three buttons should be supported on all platforms.
+/// **macOS:** `Back` and `Forward` might not work with all hardware.
-/// [`Self::Back`] and [`Self::Forward`] are supported on most platforms
+/// **Orbital:** `Back` and `Forward` are unsupported due to orbital not supporting them.
-/// (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 {
-    /// The primary (usually left) button
+    Left,
-    Left = 0,
+    Right,
-    /// The secondary (usually right) button
+    Middle,
-    Right = 1,
+    Back,
-    /// The tertiary (usually middle) button
+    Forward,
-    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))]
@@ -1622,7 +1188,7 @@ mod tests {
                 primary: true,
                 state: event::ElementState::Pressed,
                 position: (0, 0).into(),
-                button: event::ButtonSource::Unknown(0),
+                button: event::MouseButton::Other(0).into(),
             });
             with_window_event(PointerButton {
                 device_id: None,
@@ -1675,85 +1241,16 @@ 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(None), 0.0);
+        assert_eq!(force.normalized(), 0.0);
 
         let force2 = event::Force::Calibrated { force: 5.0, max_possible_force: 2.5 };
-        assert_eq!(force2.normalized(None), 2.0);
+        assert_eq!(force2.normalized(), 2.0);
 
         let force3 = event::Force::Calibrated { force: 5.0, max_possible_force: 2.5 };
-        assert_eq!(
+        assert_eq!(force3.normalized(), 2.0);
-            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,21 +1,20 @@
-pub mod never_return;
 pub mod pump_events;
-pub mod register;
 pub mod run_on_demand;
 
 use std::fmt::{self, Debug};
-use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+use std::task::Waker;
 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
@@ -152,6 +151,13 @@ impl EventLoopProxy {
         self.proxy.wake_up();
     }
 
+    /// Get a [`Waker`] that calls [`wake_up`] on the proxy when awoken.
+    ///
+    /// This may be useful to `async` code or otherwise interoperating with `std`.
+    pub fn waker(&self) -> Waker {
+        self.proxy.waker()
+    }
+
     pub fn new(proxy: Arc<dyn EventLoopProxyProvider>) -> Self {
         Self { proxy }
     }
@@ -160,6 +166,9 @@ impl EventLoopProxy {
 pub trait EventLoopProxyProvider: Send + Sync + Debug {
     /// See [`EventLoopProxy::wake_up`] for details.
     fn wake_up(&self);
+
+    /// See [`EventLoopProxy::waker`] for details.
+    fn waker(&self) -> Waker;
 }
 
 /// A proxy for the underlying display handle.
@@ -176,11 +185,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 + Send + Sync>,
+    pub(crate) handle: Arc<dyn HasDisplayHandle>,
 }
 
 impl OwnedDisplayHandle {
-    pub fn new(handle: Arc<dyn HasDisplayHandle + Send + Sync>) -> Self {
+    pub fn new(handle: Arc<dyn HasDisplayHandle>) -> Self {
         Self { handle }
     }
 }

winit-core/src/event_loop/never_return.rs

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

@@ -1,17 +0,0 @@
-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,17 +2,19 @@ use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
 #[cfg(doc)]
 use crate::{
-    event_loop::{ActiveEventLoop, pump_events::EventLoopExtPumpEvents},
+    event_loop::{pump_events::EventLoopExtPumpEvents, ActiveEventLoop},
     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`)
-    /// state and it is possible to return control back to the caller without consuming the
+    /// closures and it is possible to return control back to the caller without
-    /// `EventLoop` (by using [`exit()`]) and so the event loop can be re-run after it has exit.
+    /// 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
@@ -29,7 +31,8 @@ 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).
+    ///   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).
     /// - 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
@@ -48,6 +51,8 @@ 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::AsAny;
+use crate::as_any::{impl_dyn_casting, AsAny};
 
 pub(crate) const PIXEL_SIZE: usize = mem::size_of::<u32>();
 

winit-core/src/keyboard.rs

@@ -29,13 +29,11 @@ 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, Ohos, Unidentified, Windows, Xkb};
+        use NativeKeyCode::{Android, MacOS, Unidentified, Windows, Xkb};
         let mut debug_tuple;
         match self {
             Unidentified => {
@@ -57,10 +55,6 @@ 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()
     }
@@ -91,13 +85,11 @@ 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, Ohos, Unidentified, Web, Windows, Xkb};
+        use NativeKey::{Android, MacOS, Unidentified, Web, Windows, Xkb};
         let mut debug_tuple;
         match self {
             Unidentified => {
@@ -123,10 +115,6 @@ 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()
     }
@@ -141,7 +129,6 @@ 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),
         }
     }
 }
@@ -206,7 +193,7 @@ impl PartialEq<KeyCode> for PhysicalKey {
     #[inline]
     fn eq(&self, rhs: &KeyCode) -> bool {
         match self {
-            PhysicalKey::Code(code) => code == rhs,
+            PhysicalKey::Code(ref code) => code == rhs,
             _ => false,
         }
     }
@@ -223,7 +210,7 @@ impl PartialEq<NativeKeyCode> for PhysicalKey {
     #[inline]
     fn eq(&self, rhs: &NativeKeyCode) -> bool {
         match self {
-            PhysicalKey::Unidentified(code) => code == rhs,
+            PhysicalKey::Unidentified(ref code) => code == rhs,
             _ => false,
         }
     }
@@ -288,7 +275,7 @@ impl<Str> PartialEq<NamedKey> for Key<Str> {
     #[inline]
     fn eq(&self, rhs: &NamedKey) -> bool {
         match self {
-            Key::Named(a) => a == rhs,
+            Key::Named(ref a) => a == rhs,
             _ => false,
         }
     }
@@ -298,7 +285,7 @@ impl<Str: PartialEq<str>> PartialEq<str> for Key<Str> {
     #[inline]
     fn eq(&self, rhs: &str) -> bool {
         match self {
-            Key::Character(s) => s == rhs,
+            Key::Character(ref s) => s == rhs,
             _ => false,
         }
     }
@@ -315,7 +302,7 @@ impl<Str> PartialEq<NativeKey> for Key<Str> {
     #[inline]
     fn eq(&self, rhs: &NativeKey) -> bool {
         match self {
-            Key::Unidentified(code) => code == rhs,
+            Key::Unidentified(ref 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::AsAny;
+use crate::as_any::{impl_dyn_casting, 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;
@@ -834,7 +834,7 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Web / Orbital:** Always returns [`None`].
+    /// - **iOS / Android / Web / Wayland / Orbital:** Always returns [`None`].
     fn surface_resize_increments(&self) -> Option<PhysicalSize<u32>>;
 
     /// Sets resize increments of the surface.
@@ -846,6 +846,7 @@ 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>);
 
@@ -880,8 +881,7 @@ 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` or
+    /// - **Wayland:** Only works with org_kde_kwin_blur_manager protocol.
-    ///   `ext_background_effect_manager_v1` protocol.
     fn set_blur(&self, blur: bool);
 
     /// Modifies the window's visibility.
@@ -996,8 +996,7 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///   separate spaces are not preferred.
     ///
     ///   The dock and the menu bar are disabled in exclusive fullscreen mode.
-    /// - **Orbital / Wayland:** Does not support exclusive fullscreen mode and will no-op a
+    /// - **Wayland:** Does not support exclusive fullscreen mode and will no-op a request.
-    ///   request.
     /// - **Windows:** Screen saver is disabled in fullscreen mode.
     /// - **Web:** Passing a [`MonitorHandle`] or [`VideoMode`] that was not created with detailed
     ///   monitor permissions or calling without a [transient activation] does nothing.
@@ -1010,9 +1009,9 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///
     /// ## Platform-specific
     ///
-    /// - **Android:** Will always return `None`.
+    /// - **Android / Orbital:** Will always return `None`.
-    /// - **Orbital / Web:** Can only return `None` or `Borderless(None)`.
     /// - **Wayland:** Can return `Borderless(None)` when there are no monitors.
+    /// - **Web:** Can only return `None` or `Borderless(None)`.
     fn fullscreen(&self) -> Option<Fullscreen>;
 
     /// Turn window decorations on or off.
@@ -1136,9 +1135,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_hint_and_purpose().with_cursor_area();
+            let ime_caps = ImeCapabilities::new().with_purpose().with_cursor_area();
             let request_data = ImeRequestData {
-                hint_and_purpose: Some((ImeHint::NONE, ImePurpose::Normal)),
+                purpose: Some(ImePurpose::Normal),
                 // WARNING: there's nothing sensible to use here by default.
                 cursor_area: Some((position.into(), size.into())),
                 ..ImeRequestData::default()
@@ -1160,9 +1159,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.hint_and_purpose()).unwrap_or(false) {
+        if self.ime_capabilities().map(|caps| caps.purpose()).unwrap_or(false) {
             let _ = self.request_ime_update(ImeRequest::Update(ImeRequestData {
-                hint_and_purpose: Some((ImeHint::NONE, purpose)),
+                purpose: Some(purpose),
                 ..ImeRequestData::default()
             }));
         }
@@ -1186,14 +1185,14 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     ///
     /// ```no_run
     /// # use dpi::{Position, Size};
-    /// # use winit_core::window::{Window, ImeHint, ImePurpose, ImeRequest, ImeCapabilities, ImeRequestData, ImeEnableRequest};
+    /// # use winit_core::window::{Window, 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_hint_and_purpose();
+    /// let ime_caps = ImeCapabilities::new().with_cursor_area().with_purpose();
     /// let request_data = ImeRequestData::default()
-    ///                          .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+    ///                          .with_purpose(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");
@@ -1598,86 +1597,29 @@ 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, Default)]
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum ImePurpose {
-    /// No special purpose for the IME (default).
+    /// No special hints 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,
 }
 
-bitflags! {
+impl Default for ImePurpose {
-    /// IME hints
+    fn default() -> Self {
-    ///
+        Self::Normal
-    /// 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;
     }
 }
 
@@ -1691,22 +1633,6 @@ 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))]
@@ -1801,7 +1727,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
-    /// applies to both [`ImeRequest::Enable`] and [`ImeRequest::Update`]. For details on
+    /// appiles 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.
@@ -1832,7 +1758,7 @@ impl ImeEnableRequest {
             return None;
         }
 
-        if capabilities.hint_and_purpose() ^ request_data.hint_and_purpose.is_some() {
+        if capabilities.purpose() ^ request_data.purpose.is_some() {
             return None;
         }
 
@@ -1877,23 +1803,23 @@ impl ImeCapabilities {
         Self::default()
     }
 
-    /// Marks `hint and purpose` as supported.
+    /// Marks `purpose` as supported.
     ///
-    /// For more details see [`ImeRequestData::with_hint_and_purpose`].
+    /// For more details see [`ImeRequestData::with_purpose`].
-    pub const fn with_hint_and_purpose(self) -> Self {
+    pub const fn with_purpose(self) -> Self {
-        Self(self.0.union(ImeCapabilitiesFlags::HINT_AND_PURPOSE))
+        Self(self.0.union(ImeCapabilitiesFlags::PURPOSE))
     }
 
-    /// Marks `hint and purpose` as unsupported.
+    /// Marks `purpose` as unsupported.
     ///
-    /// For more details see [`ImeRequestData::with_hint_and_purpose`].
+    /// For more details see [`ImeRequestData::with_purpose`].
-    pub const fn without_hint_and_purpose(self) -> Self {
+    pub const fn without_purpose(self) -> Self {
-        Self(self.0.difference(ImeCapabilitiesFlags::HINT_AND_PURPOSE))
+        Self(self.0.difference(ImeCapabilitiesFlags::PURPOSE))
     }
 
-    /// Returns `true` if `hint and purpose` is supported.
+    /// Returns `true` if `purpose` is supported.
-    pub const fn hint_and_purpose(&self) -> bool {
+    pub const fn purpose(&self) -> bool {
-        self.0.contains(ImeCapabilitiesFlags::HINT_AND_PURPOSE)
+        self.0.contains(ImeCapabilitiesFlags::PURPOSE)
     }
 
     /// Marks `cursor_area` as supported.
@@ -1938,8 +1864,8 @@ impl ImeCapabilities {
 bitflags! {
     #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
     pub(crate) struct ImeCapabilitiesFlags : u8 {
-        /// Client supports setting IME hint and purpose.
+        /// Client supports setting IME purpose.
-        const HINT_AND_PURPOSE = 1 << 0;
+        const PURPOSE = 1 << 0;
         /// Client supports reporting cursor area for IME popup to
         /// appear.
         const CURSOR_AREA = 1 << 1;
@@ -1957,24 +1883,24 @@ bitflags! {
 #[derive(Debug, PartialEq, Clone, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct ImeRequestData {
-    /// Text input hint and purpose.
+    /// Text input purpose.
     ///
-    /// To support updating it, enable [`ImeCapabilities::hint_and_purpose()`].
+    /// To support updating it, enable [`ImeCapabilities::PURPOSE`].
-    pub hint_and_purpose: Option<(ImeHint, ImePurpose)>,
+    pub purpose: Option<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 hint and purpose of the current text input content.
+    /// Sets the purpose hint of the current text input.
-    pub fn with_hint_and_purpose(self, hint: ImeHint, purpose: ImePurpose) -> Self {
+    pub fn with_purpose(self, purpose: ImePurpose) -> Self {
-        Self { hint_and_purpose: Some((hint, purpose)), ..self }
+        Self { purpose: Some(purpose), ..self }
     }
 
     /// Sets the IME cursor editing area.
@@ -2100,73 +2026,59 @@ mod tests {
         ImeCapabilities, ImeEnableRequest, ImeRequestData, ImeSurroundingText,
         ImeSurroundingTextError,
     };
-    use crate::window::{ImeHint, ImePurpose};
+    use crate::window::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!(
+        assert!(ImeEnableRequest::new(
-            ImeEnableRequest::new(
             ImeCapabilities::new().with_cursor_area(),
             ImeRequestData::default()
         )
-            .is_none()
+        .is_none());
-        );
+        assert!(ImeEnableRequest::new(
-        assert!(
+            ImeCapabilities::new().with_purpose(),
-            ImeEnableRequest::new(
-                ImeCapabilities::new().with_hint_and_purpose(),
             ImeRequestData::default()
         )
-            .is_none()
+        .is_none());
-        );
 
-        assert!(
+        assert!(ImeEnableRequest::new(
-            ImeEnableRequest::new(
             ImeCapabilities::new().with_cursor_area(),
-                ImeRequestData::default().with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+            ImeRequestData::default().with_purpose(ImePurpose::Normal)
         )
-            .is_none()
+        .is_none());
-        );
 
-        assert!(
+        assert!(ImeEnableRequest::new(
-            ImeEnableRequest::new(
             ImeCapabilities::new(),
             ImeRequestData::default()
-                    .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+                .with_purpose(ImePurpose::Normal)
                 .with_cursor_area(position, size)
         )
-            .is_none()
+        .is_none());
-        );
 
-        assert!(
+        assert!(ImeEnableRequest::new(
-            ImeEnableRequest::new(
             ImeCapabilities::new().with_cursor_area(),
             ImeRequestData::default()
-                    .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+                .with_purpose(ImePurpose::Normal)
                 .with_cursor_area(position, size)
         )
-            .is_none()
+        .is_none());
-        );
 
-        assert!(
+        assert!(ImeEnableRequest::new(
-            ImeEnableRequest::new(
             ImeCapabilities::new().with_cursor_area(),
             ImeRequestData::default().with_cursor_area(position, size)
         )
-            .is_some()
+        .is_some());
-        );
 
-        assert!(
+        assert!(ImeEnableRequest::new(
-            ImeEnableRequest::new(
+            ImeCapabilities::new().with_purpose().with_cursor_area(),
-                ImeCapabilities::new().with_hint_and_purpose().with_cursor_area(),
             ImeRequestData::default()
-                    .with_hint_and_purpose(ImeHint::NONE, ImePurpose::Normal)
+                .with_purpose(ImePurpose::Normal)
                 .with_cursor_area(position, size)
         )
-            .is_some()
+        .is_some());
-        );
 
         let text: &[u8] = ['a' as u8; 8000].as_slice();
         let text = std::str::from_utf8(text).unwrap();

winit-orbital/Cargo.toml

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

winit-orbital/src/event_loop.rs

@@ -1,7 +1,8 @@
 use std::cell::Cell;
 use std::collections::VecDeque;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex, mpsc};
+use std::sync::{mpsc, Arc, Mutex};
+use std::task::Waker;
 use std::time::Instant;
 use std::{iter, mem, slice};
 
@@ -10,7 +11,6 @@ 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};
@@ -101,7 +101,6 @@ 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),
@@ -112,20 +111,12 @@ 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),
@@ -137,27 +128,17 @@ 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! {
@@ -296,7 +277,6 @@ impl EventState {
 pub struct EventLoop {
     windows: Vec<(Arc<RedoxSocket>, EventState)>,
     window_target: ActiveEventLoop,
-    user_events_receiver: mpsc::Receiver<()>,
 }
 
 impl EventLoop {
@@ -312,12 +292,16 @@ impl EventLoop {
         let (user_events_sender, user_events_receiver) = mpsc::sync_channel(1);
 
         let event_socket =
-            Arc::new(EventQueue::new().map_err(|error| os_error!(format!("{error}")))?);
+            Arc::new(RedoxSocket::event().map_err(|error| os_error!(format!("{error}")))?);
 
         let wake_socket = TimeSocket::open().map_err(|error| os_error!(format!("{error}")))?;
 
         event_socket
-            .subscribe(wake_socket.0.fd(), EventSource::Time, EventFlags::READ)
+            .write(&syscall::Event {
+                id: wake_socket.0.fd,
+                flags: syscall::EventFlags::EVENT_READ,
+                data: wake_socket.0.fd,
+            })
             .map_err(|error| os_error!(format!("{error}")))?;
 
         Ok(Self {
@@ -501,10 +485,7 @@ impl EventLoop {
         }
     }
 
-    pub fn run_app_on_demand<A: ApplicationHandler>(
+    pub fn run_app<A: ApplicationHandler>(mut self, mut app: A) -> Result<(), EventLoopError> {
-        &mut self,
-        mut app: A,
-    ) -> Result<(), EventLoopError> {
         let mut start_cause = StartCause::Init;
         loop {
             app.new_events(&self.window_target, start_cause);
@@ -518,7 +499,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");
@@ -542,18 +523,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 = libredox::call::read(window.fd(), &mut event_buf)
+                let count =
-                    .expect("failed to read window events");
+                    syscall::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 {
@@ -596,7 +577,7 @@ impl EventLoop {
                 i += 1;
             }
 
-            while self.user_events_receiver.try_recv().is_ok() {
+            if self.wake_up.swap(false, Ordering::Relaxed) {
                 app.proxy_wake_up(&self.window_target);
             }
 
@@ -633,7 +614,11 @@ impl EventLoop {
 
             self.window_target
                 .event_socket
-                .subscribe(timeout_socket.0.fd(), EventSource::Time, EventFlags::READ)
+                .write(&syscall::Event {
+                    id: timeout_socket.0.fd,
+                    flags: syscall::EventFlags::EVENT_READ,
+                    data: 0,
+                })
                 .unwrap();
 
             let start = Instant::now();
@@ -642,7 +627,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 i64;
+                    time.tv_nsec += duration.subsec_nanos() as i32;
                     // Normalize timespec so tv_nsec is not greater than one second.
                     while time.tv_nsec >= 1_000_000_000 {
                         time.tv_sec += 1;
@@ -654,22 +639,12 @@ impl EventLoop {
             }
 
             // Wait for event if needed.
-            let event = loop {
+            let mut event = syscall::Event::default();
-                match self.window_target.event_socket.next_event() {
+            self.window_target.event_socket.read(&mut event).unwrap();
-                    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)
+                Some(requested_resume) if event.id == timeout_socket.0.fd => {
-                    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 };
@@ -691,29 +666,31 @@ impl EventLoop {
 
 #[derive(Debug)]
 pub struct EventLoopProxy {
-    user_events_sender: mpsc::SyncSender<()>,
+    waker: Waker,
-    pub(super) wake_socket: TimeSocket,
 }
 
 impl EventLoopProxyProvider for EventLoopProxy {
     fn wake_up(&self) {
-        // When we fail to send the event it means that we haven't woken up to read the previous
+        self.waker.wake_by_ref();
-        // event.
-        if self.user_events_sender.try_send(()).is_ok() {
-            self.wake_socket.wake().unwrap();
     }
+
+    fn into_waker(self) -> Waker {
+        self.waker
+    }
+}
+
+impl std::task::Wake for TimeSocket {
+    fn wake(self: Arc<TimeSocket>) {
+        TimeSocket::wake(&*self).unwrap();
+    }
+
+    fn wake_by_ref(self: &Arc<TimeSocket>) {
+        TimeSocket::wake(&**self).unwrap();
     }
 }
 
 impl Unpin for EventLoopProxy {}
 
-redox_event::user_data! {
-    pub enum EventSource {
-        Orbital,
-        Time,
-    }
-}
-
 #[derive(Debug)]
 pub struct ActiveEventLoop {
     control_flow: Cell<ControlFlow>,
@@ -721,7 +698,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<EventQueue<EventSource>>,
+    pub(super) event_socket: Arc<RedoxSocket>,
     pub(super) event_loop_proxy: Arc<EventLoopProxy>,
 }
 

winit-orbital/src/lib.rs

@@ -3,17 +3,14 @@
 //! Redox OS has some functionality not yet present that will be implemented
 //! when its orbital display server provides it.
 
-use std::fs::{File, OpenOptions};
+use std::{fmt, str};
-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;
@@ -21,11 +18,15 @@ pub mod window;
 
 #[derive(Debug)]
 struct RedoxSocket {
-    fd: File,
+    fd: usize,
 }
 
 impl RedoxSocket {
-    fn orbital(properties: &WindowProperties<'_>) -> Result<Self> {
+    fn event() -> syscall::Result<Self> {
+        Self::open_raw("/scheme/event")
+    }
+
+    fn orbital(properties: &WindowProperties<'_>) -> syscall::Result<Self> {
         Self::open_raw(&format!("{properties}"))
     }
 
@@ -33,27 +34,38 @@ 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) -> Result<Self> {
+    fn open_raw(path: &str) -> syscall::Result<Self> {
-        let fd = OpenOptions::new().read(true).write(true).open(path)?;
+        let fd = syscall::open(path, syscall::O_RDWR | syscall::O_CLOEXEC)?;
         Ok(Self { fd })
     }
 
-    fn fd(&self) -> usize {
+    fn read(&self, buf: &mut [u8]) -> syscall::Result<()> {
-        self.fd.as_raw_fd() as usize
+        let count = syscall::read(self.fd, buf)?;
+        if count == buf.len() {
+            Ok(())
+        } else {
+            Err(syscall::Error::new(syscall::EINVAL))
+        }
     }
 
-    fn read(&self, buf: &mut [u8]) -> Result<()> {
+    fn write(&self, buf: &[u8]) -> syscall::Result<()> {
-        (&self.fd).read_exact(buf)
+        let count = syscall::write(self.fd, buf)?;
+        if count == buf.len() {
+            Ok(())
+        } else {
+            Err(syscall::Error::new(syscall::EINVAL))
+        }
     }
 
-    fn write(&self, buf: &[u8]) -> Result<()> {
+    fn fpath<'a>(&self, buf: &'a mut [u8]) -> syscall::Result<&'a str> {
-        (&self.fd).write_all(buf)
+        let count = syscall::fpath(self.fd, buf)?;
+        str::from_utf8(&buf[..count]).map_err(|_err| syscall::Error::new(syscall::EINVAL))
+    }
 }
 
-    fn fpath<'a>(&self, buf: &'a mut [u8]) -> Result<&'a str> {
+impl Drop for RedoxSocket {
-        let count = libredox::call::fpath(self.fd(), buf)?;
+    fn drop(&mut self) {
-        str::from_utf8(&buf[..count])
+        let _ = syscall::close(self.fd);
-            .map_err(|_| std::io::Error::from(std::io::ErrorKind::InvalidData))
     }
 }
 
@@ -61,36 +73,26 @@ impl RedoxSocket {
 struct TimeSocket(RedoxSocket);
 
 impl TimeSocket {
-    fn open() -> Result<Self> {
+    fn open() -> syscall::Result<Self> {
         RedoxSocket::open_raw("/scheme/time/4").map(Self)
     }
 
     // Read current time.
-    fn current_time(&self) -> Result<TimeSpec> {
+    fn current_time(&self) -> syscall::Result<syscall::TimeSpec> {
-        let mut timespec: libredox::data::TimeSpec = unsafe { mem::zeroed() };
+        let mut timespec = syscall::TimeSpec::default();
-        let timespec_bytes = unsafe {
+        self.0.read(&mut timespec)?;
-            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: &TimeSpec) -> Result<()> {
+    fn timeout(&self, timespec: &syscall::TimeSpec) -> syscall::Result<()> {
-        let timespec_bytes = unsafe {
+        self.0.write(timespec)
-            slice::from_raw_parts(timespec as *const _ as *const u8, mem::size_of::<TimeSpec>())
-        };
-        self.0.write(timespec_bytes)
     }
 
     // Wake immediately.
-    fn wake(&self) -> Result<()> {
+    fn wake(&self) -> syscall::Result<()> {
         // Writing a default TimeSpec will always trigger a time event.
-        let timespec: TimeSpec = unsafe { mem::zeroed() };
+        self.timeout(&syscall::TimeSpec::default())
-        self.timeout(&timespec)
     }
 }
 
@@ -105,7 +107,7 @@ struct WindowProperties<'a> {
 
 impl<'a> WindowProperties<'a> {
     fn new(path: &'a str) -> Self {
-        // /scheme/orbital/flags/x/y/w/h/t
+        // 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,12 @@ use std::iter;
 use std::sync::{Arc, Mutex};
 
 use dpi::{PhysicalInsets, PhysicalPosition, PhysicalSize, Position, Size};
-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, EventSource};
+use crate::event_loop::{ActiveEventLoop, EventLoopProxy};
 use crate::{RedoxSocket, WindowProperties};
 
 // These values match the values uses in the `window_new` function in orbital:
@@ -20,7 +19,6 @@ const ORBITAL_FLAG_FRONT: char = 'f';
 const ORBITAL_FLAG_HIDDEN: char = 'h';
 const ORBITAL_FLAG_BORDERLESS: char = 'l';
 const ORBITAL_FLAG_MAXIMIZED: char = 'm';
-const ORBITAL_FLAG_FULLSCREEN: char = 'M';
 const ORBITAL_FLAG_RESIZABLE: char = 'r';
 const ORBITAL_FLAG_TRANSPARENT: char = 't';
 
@@ -57,10 +55,7 @@ impl Window {
         // Async by default.
         let mut flag_str = ORBITAL_FLAG_ASYNC.to_string();
 
-        // Fullscreen takes precedence over maximize
+        if attrs.maximized {
-        if let Some(Fullscreen::Borderless(_)) = attrs.fullscreen {
-            flag_str.push(ORBITAL_FLAG_FULLSCREEN);
-        } else if attrs.maximized {
             flag_str.push(ORBITAL_FLAG_MAXIMIZED);
         }
 
@@ -68,6 +63,8 @@ impl Window {
             flag_str.push(ORBITAL_FLAG_RESIZABLE);
         }
 
+        // TODO: fullscreen
+
         if attrs.transparent {
             flag_str.push(ORBITAL_FLAG_TRANSPARENT);
         }
@@ -104,7 +101,13 @@ impl Window {
         .expect("failed to open window");
 
         // Add to event socket.
-        el.event_socket.subscribe(window.fd(), EventSource::Orbital, EventFlags::READ).unwrap();
+        el.event_socket
+            .write(&syscall::Event {
+                id: window.fd,
+                flags: syscall::EventFlags::EVENT_READ,
+                data: window.fd,
+            })
+            .unwrap();
 
         let window_socket = Arc::new(window);
 
@@ -141,7 +144,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))
@@ -155,7 +158,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> {
@@ -320,29 +323,11 @@ impl CoreWindow for Window {
         self.get_flag(ORBITAL_FLAG_MAXIMIZED).unwrap_or(false)
     }
 
-    fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
+    fn set_fullscreen(&self, _monitor: Option<Fullscreen>) {}
-        match fullscreen {
-            Some(Fullscreen::Exclusive(..)) => {
-                // TODO: exclusive fullscreen not supported on orbital
-            },
-            Some(Fullscreen::Borderless(_monitor)) => {
-                // TODO: monitor selection not supported on orbital
-                let _ = self.set_flag(ORBITAL_FLAG_FULLSCREEN, true);
-            },
-            None => {
-                let _ = self.set_flag(ORBITAL_FLAG_FULLSCREEN, false);
-            },
-        }
-    }
 
     fn fullscreen(&self) -> Option<Fullscreen> {
-        if self.get_flag(ORBITAL_FLAG_FULLSCREEN).unwrap_or(false) {
-            // TODO: monitor selection not supported on orbital
-            Some(Fullscreen::Borderless(None))
-        } else {
         None
     }
-    }
 
     #[inline]
     fn set_decorations(&self, decorations: bool) {

winit-uikit/Cargo.toml

@@ -18,6 +18,7 @@ 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
@@ -69,7 +70,6 @@ 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::MainThreadMarker;
 use objc2::rc::Retained;
+use objc2::MainThreadMarker;
 use objc2_core_foundation::{
-    CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, CGRect, CGSize,
+    kCFRunLoopCommonModes, CFAbsoluteTimeGetCurrent, CFRetained, CFRunLoop, CFRunLoopTimer, CGRect,
-    kCFRunLoopCommonModes,
+    CGSize,
 };
 use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView};
 use winit_common::core_foundation::EventLoopProxy;

winit-uikit/src/event_loop.rs

@@ -1,9 +1,13 @@
+use std::ffi::c_void;
+use std::ptr;
 use std::sync::Arc;
 
 use objc2::rc::Retained;
 use objc2::runtime::ProtocolObject;
-use objc2::{ClassType, MainThreadMarker, msg_send};
+use objc2::{msg_send, ClassType, MainThreadMarker};
-use objc2_core_foundation::{CFIndex, CFRunLoopActivity, kCFRunLoopDefaultMode};
+use objc2_core_foundation::{
+    kCFRunLoopDefaultMode, CFIndex, CFRunLoop, CFRunLoopActivity, CFRunLoopObserver,
+};
 use objc2_foundation::{NSNotificationCenter, NSObjectProtocol};
 use objc2_ui_kit::{
     UIApplication, UIApplicationDidBecomeActiveNotification,
@@ -12,9 +16,6 @@ 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};
@@ -25,7 +26,8 @@ use winit_core::event_loop::{
 use winit_core::monitor::MonitorHandle as CoreMonitorHandle;
 use winit_core::window::{Theme, Window as CoreWindow};
 
-use super::app_state::{AppState, send_occluded_event_for_all_windows};
+use super::app_state::{send_occluded_event_for_all_windows, AppState};
+use super::notification_center::create_observer;
 use crate::monitor::MonitorHandle;
 use crate::window::Window;
 use crate::{app_state, monitor};
@@ -134,11 +136,6 @@ 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)]
@@ -154,14 +151,16 @@ impl EventLoop {
             return Err(EventLoopError::RecreationAttempt);
         }
 
-        let center = NSNotificationCenter::defaultCenter();
+        // this line sets up the main run loop before `UIApplicationMain`
+        setup_control_flow_observers();
+
+        let center = unsafe { NSNotificationCenter::defaultCenter() };
 
         let _did_finish_launching_observer = create_observer(
             &center,
             // `application:didFinishLaunchingWithOptions:`
             unsafe { UIApplicationDidFinishLaunchingNotification },
             move |_| {
-                let _entered = debug_span!("UIApplicationDidFinishLaunchingNotification").entered();
                 app_state::did_finish_launching(mtm);
             },
         );
@@ -169,28 +168,20 @@ impl EventLoop {
             &center,
             // `applicationDidBecomeActive:`
             unsafe { UIApplicationDidBecomeActiveNotification },
-            move |_| {
+            move |_| app_state::handle_resumed(mtm),
-                let _entered = debug_span!("UIApplicationDidBecomeActiveNotification").entered();
-                app_state::handle_resumed(mtm)
-            },
         );
         let _will_resign_active_observer = create_observer(
             &center,
             // `applicationWillResignActive:`
             unsafe { UIApplicationWillResignActiveNotification },
-            move |_| {
+            move |_| app_state::handle_suspended(mtm),
-                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 _entered =
+                let app = unsafe { notification.object() }.expect(
-                    debug_span!("UIApplicationWillEnterForegroundNotification").entered();
-                let app = notification.object().expect(
                     "UIApplicationWillEnterForegroundNotification to have application object",
                 );
                 // The `object` in `UIApplicationWillEnterForegroundNotification` is documented to
@@ -204,8 +195,7 @@ impl EventLoop {
             // `applicationDidEnterBackground:`
             unsafe { UIApplicationDidEnterBackgroundNotification },
             move |notification| {
-                let _entered = debug_span!("UIApplicationDidEnterBackgroundNotification").entered();
+                let app = unsafe { notification.object() }.expect(
-                let app = notification.object().expect(
                     "UIApplicationDidEnterBackgroundNotification to have application object",
                 );
                 // The `object` in `UIApplicationDidEnterBackgroundNotification` is documented to be
@@ -219,9 +209,7 @@ impl EventLoop {
             // `applicationWillTerminate:`
             unsafe { UIApplicationWillTerminateNotification },
             move |notification| {
-                let _entered = debug_span!("UIApplicationWillTerminateNotification").entered();
+                let app = unsafe { notification.object() }
-                let app = notification
-                    .object()
                     .expect("UIApplicationWillTerminateNotification to have application object");
                 // The `object` in `UIApplicationWillTerminateNotification` is (somewhat) documented
                 // to be `UIApplication`.
@@ -233,65 +221,9 @@ impl EventLoop {
             &center,
             // `applicationDidReceiveMemoryWarning:`
             unsafe { UIApplicationDidReceiveMemoryWarningNotification },
-            move |_| {
+            move |_| app_state::handle_memory_warning(mtm),
-                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 },
@@ -302,15 +234,10 @@ 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,
         })
     }
 
-    // Require `'static` for correctness, we won't be able to `Drop` the user's state otherwise.
+    pub fn run_app<A: ApplicationHandler>(self, app: A) -> ! {
-    pub fn run_app_never_return<A: ApplicationHandler + 'static>(self, app: A) -> ! {
         let application: Option<Retained<UIApplication>> =
             unsafe { msg_send![UIApplication::class(), sharedApplication] };
         assert!(
@@ -322,10 +249,6 @@ 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))
     }
 
@@ -333,3 +256,97 @@ 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,6 +103,7 @@
 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::{MainThreadBound, run_on_main};
+use dispatch2::{run_on_main, MainThreadBound};
 use dpi::PhysicalPosition;
 use objc2::rc::Retained;
-use objc2::{MainThreadMarker, Message, available};
+use objc2::{available, MainThreadMarker, Message};
 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> + 'static {
+    pub fn video_modes_handles(&self) -> impl Iterator<Item = VideoModeHandle> {
         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> + 'static {
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
         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!(
+        assert!(unsafe {
             NSSet::setWithArray(&UIScreen::screens(mtm)).containsObject(&UIScreen::mainScreen(mtm))
-        );
+        });
     }
 }

winit-uikit/src/notification_center.rs

@@ -0,0 +1 @@
+../../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::{DefinedClass, MainThreadMarker, available, define_class, msg_send, sel};
+use objc2::{available, define_class, msg_send, sel, DefinedClass, MainThreadMarker};
 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, debug_span, trace_span};
+use tracing::debug;
 use winit_core::event::{
-    ButtonSource, ElementState, FingerId, Force, KeyEvent, PointerKind, PointerSource,
+    ButtonSource, ElementState, FingerId, Force, KeyEvent, PointerKind, PointerSource, TouchPhase,
-    TabletToolAngle, TabletToolButton, TabletToolData, TabletToolKind, TouchPhase, WindowEvent,
+    WindowEvent,
 };
 use winit_core::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKeyCode, PhysicalKey};
 
@@ -48,7 +48,6 @@ 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 {
@@ -60,7 +59,6 @@ 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] };
 
@@ -81,7 +79,6 @@ 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] };
@@ -127,7 +124,6 @@ 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();
@@ -135,31 +131,26 @@ 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() {
@@ -194,7 +185,6 @@ 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 {
@@ -210,7 +200,6 @@ 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() {
@@ -255,7 +244,6 @@ 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));
@@ -308,7 +296,6 @@ define_class!(
 
         #[unsafe(method(canBecomeFirstResponder))]
         fn can_become_first_responder(&self) -> bool {
-            let _entered = trace_span!("canBecomeFirstResponder").entered();
             true
         }
     }
@@ -322,10 +309,6 @@ define_class!(
             _gesture_recognizer: &UIGestureRecognizer,
             _other_gesture_recognizer: &UIGestureRecognizer,
         ) -> bool {
-            let _entered = trace_span!(
-                "gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:"
-            )
-            .entered();
             true
         }
     }
@@ -335,19 +318,16 @@ 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()
         }
     }
@@ -483,16 +463,13 @@ impl WinitView {
         for touch in touches {
             let logical_location = touch.locationInView(None);
             let touch_type = touch.r#type();
-            let force = if available!(ios = 9.0, tvos = 9.0, visionos = 1.0) {
+            let force = if let UITouchType::Pencil = touch_type {
-                let use_force = match touch_type {
+                None
-                    UITouchType::Pencil => true,
+            } else if available!(ios = 9.0, tvos = 9.0, visionos = 1.0) {
-                    _ => {
                 let trait_collection = self.traitCollection();
-                        trait_collection.forceTouchCapability() == UIForceTouchCapability::Available
+                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 {
-
-                if use_force {
                     let force = touch.force();
                     let max_possible_force = touch.maximumPossibleForce();
                     Some(Force::Calibrated {
@@ -548,7 +525,7 @@ impl WinitView {
                             primary,
                             position,
                             kind: if let UITouchType::Pencil = touch_type {
-                                PointerKind::TabletTool(TabletToolKind::Pencil)
+                                PointerKind::Unknown
                             } else {
                                 PointerKind::Touch(finger_id)
                             },
@@ -562,12 +539,7 @@ impl WinitView {
                             state: ElementState::Pressed,
                             position,
                             button: if let UITouchType::Pencil = touch_type {
-                                let tool_data = self.tablet_tool_data_for_pencil(&touch);
+                                ButtonSource::Unknown(0)
-                                ButtonSource::TabletTool {
-                                    kind: TabletToolKind::Pencil,
-                                    button: TabletToolButton::Contact,
-                                    data: tool_data,
-                                }
                             } else {
                                 ButtonSource::Touch { finger_id, force }
                             },
@@ -576,11 +548,7 @@ impl WinitView {
                 },
                 UITouchPhase::Moved => {
                     let (primary, source) = if let UITouchType::Pencil = touch_type {
-                        let tool_data = self.tablet_tool_data_for_pencil(&touch);
+                        (true, PointerSource::Unknown)
-                        (true, PointerSource::TabletTool {
-                            kind: TabletToolKind::Pencil,
-                            data: tool_data,
-                        })
                     } else {
                         (ivars.primary_finger.get().unwrap() == finger_id, PointerSource::Touch {
                             finger_id,
@@ -620,12 +588,7 @@ impl WinitView {
                                 state: ElementState::Released,
                                 position,
                                 button: if let UITouchType::Pencil = touch_type {
-                                    let tool_data = self.tablet_tool_data_for_pencil(&touch);
+                                    ButtonSource::Unknown(0)
-                                    ButtonSource::TabletTool {
-                                        kind: TabletToolKind::Pencil,
-                                        button: TabletToolButton::Contact,
-                                        data: tool_data,
-                                    }
                                 } else {
                                     ButtonSource::Touch { finger_id, force }
                                 },
@@ -640,7 +603,7 @@ impl WinitView {
                             primary,
                             position: Some(position),
                             kind: if let UITouchType::Pencil = touch_type {
-                                PointerKind::TabletTool(TabletToolKind::Pencil)
+                                PointerKind::Unknown
                             } else {
                                 PointerKind::Touch(finger_id)
                             },
@@ -654,32 +617,6 @@ 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,13 +1,12 @@
 use std::cell::Cell;
 
 use objc2::rc::Retained;
-use objc2::{DefinedClass, MainThreadMarker, available, define_class, msg_send};
+use objc2::{available, define_class, msg_send, DefinedClass, MainThreadMarker};
 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};
 
@@ -29,37 +28,31 @@ 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::{MainThreadMarker, available, class, define_class, msg_send};
+use objc2::{available, class, define_class, msg_send, MainThreadMarker};
 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, debug_span, warn};
+use tracing::{debug, warn};
 use winit_core::cursor::Cursor;
 use winit_core::error::{NotSupportedError, RequestError};
 use winit_core::event::WindowEvent;
@@ -46,7 +46,6 @@ 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(),
@@ -57,7 +56,6 @@ 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(),
@@ -163,7 +161,8 @@ impl Inner {
 
     pub fn surface_position(&self) -> PhysicalPosition<i32> {
         let view_position = self.view.frame().origin;
-        let position = self.window.convertPoint_fromView(view_position, Some(&self.view));
+        let position =
+            unsafe { self.window.convertPoint_fromView(view_position, Some(&self.view)) };
         let position = LogicalPosition::new(position.x, position.y);
         position.to_physical(self.scale_factor())
     }
@@ -394,7 +393,9 @@ impl Inner {
                 }
                 *current_caps = Some(capabilities);
 
+                unsafe {
                     self.view.becomeFirstResponder();
+                }
             },
             ImeRequest::Update(_) => {
                 if current_caps.is_none() {
@@ -403,7 +404,9 @@ impl Inner {
             },
             ImeRequest::Disable => {
                 *current_caps = None;
+                unsafe {
                     self.view.resignFirstResponder();
+                }
             },
         }
 

winit-wayland/Cargo.toml

@@ -14,7 +14,6 @@ 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"]
 
@@ -29,19 +28,17 @@ 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 = { package = "smithay-client-toolkit", version = "0.20.0", default-features = false, features = [
+sctk.workspace = true
-    "calloop",
+sctk-adwaita = { workspace = true, optional = true }
-] }
+wayland-backend.workspace = true
-sctk-adwaita = { version = "0.11.0", default-features = false, optional = true }
+wayland-client.workspace = true
-wayland-backend = { version = "0.3.10", default-features = false, features = ["client_system"] }
+wayland-protocols.workspace = true
-wayland-client = "0.31.10"
+wayland-protocols-plasma.workspace = true
-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::{Connection, QueueHandle, globals};
+use sctk::reexports::client::{globals, Connection, QueueHandle};
 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::{WindowId, logical_to_physical_rounded};
+use super::{logical_to_physical_rounded, WindowId};
 
 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;
 
@@ -169,6 +169,10 @@ 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,
@@ -635,7 +639,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,16 +13,12 @@
 //! * `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::Proxy;
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::Proxy;
 use sctk::shm::slot::{Buffer, CreateBufferError, SlotPool};
 use wayland_client::protocol::wl_shm::Format;
 use winit_core::event_loop::ActiveEventLoop as CoreActiveEventLoop;
@@ -31,7 +27,9 @@ 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;
@@ -63,7 +61,7 @@ pub trait EventLoopExtWayland {
     fn is_wayland(&self) -> bool;
 }
 
-/// Additional methods when building event loop that are specific to Wayland.
+/// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
 pub trait EventLoopBuilderExtWayland {
     /// Force using Wayland.
     fn with_wayland(&mut self) -> &mut Self;
@@ -101,7 +99,6 @@ 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 {
@@ -123,18 +120,6 @@ 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::Proxy;
 use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::client::Proxy;
 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,23 +129,20 @@ impl Dispatch<WlKeyboard, KeyboardData, WinitState> for WinitState {
                     state.events_sink.push_window_event(WindowEvent::Focused(false), window_id);
                 }
             },
-            WlKeyboardEvent::Key { key, state: WEnum::Value(key_state), .. }
+            WlKeyboardEvent::Key { key, state: WEnum::Value(WlKeyState::Pressed), .. } => {
-                if matches!(key_state, WlKeyState::Repeated | WlKeyState::Pressed) =>
-            {
                 let key = key + 8;
+
                 key_input(
                     keyboard_state,
                     &mut state.events_sink,
                     data,
                     key,
                     ElementState::Pressed,
-                    key_state == WlKeyState::Repeated,
+                    false,
                 );
 
                 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 foldhash::HashMap;
+use ahash::AHashMap;
 use sctk::reexports::client::backend::ObjectId;
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
 use sctk::reexports::client::protocol::wl_touch::WlTouch;
@@ -12,9 +12,6 @@ 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;
 
@@ -26,7 +23,6 @@ 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;
@@ -44,7 +40,7 @@ pub struct WinitSeatState {
     touch: Option<WlTouch>,
 
     /// The mapping from touched points to the surfaces they're present.
-    touch_map: HashMap<i32, TouchPoint>,
+    touch_map: AHashMap<i32, TouchPoint>,
 
     /// Id of the first touch event.
     first_touch_id: Option<i32>,
@@ -52,18 +48,9 @@ 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>,
 
@@ -137,22 +124,6 @@ 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.
@@ -172,12 +143,6 @@ 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(
@@ -199,11 +164,6 @@ 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() {
@@ -217,14 +177,6 @@ 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,13 +30,12 @@ use sctk::seat::SeatState;
 use dpi::{LogicalPosition, PhysicalPosition};
 use winit_core::event::{
     ElementState, MouseButton, MouseScrollDelta, PointerKind, PointerSource, TouchPhase,
-    WindowEvent, ButtonSource,
+    WindowEvent,
 };
 
 use crate::state::WinitState;
 use crate::WindowId;
 
-pub mod pointer_gesture;
 pub mod relative_pointer;
 
 impl PointerHandler for WinitState {
@@ -108,8 +107,8 @@ impl PointerHandler for WinitState {
                     if parent_surface != surface =>
                 {
                     let click = match wayland_button_to_winit(button) {
-                        ButtonSource::Mouse(MouseButton::Left) => FrameClick::Normal,
+                        MouseButton::Left => FrameClick::Normal,
-                        ButtonSource::Mouse(MouseButton::Right) => FrameClick::Alternate,
+                        MouseButton::Right => FrameClick::Alternate,
                         _ => continue,
                     };
                     let pressed = matches!(kind, PointerEventKind::Press { .. });
@@ -186,7 +185,7 @@ impl PointerHandler for WinitState {
                             device_id: None,
                             state,
                             position,
-                            button,
+                            button: button.into(),
                         },
                         window_id,
                     );
@@ -195,7 +194,6 @@ 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.
@@ -207,7 +205,7 @@ impl PointerHandler for WinitState {
                     } else {
                         match pointer_data.phase {
                             // Discrete scroll only results in moved events.
-                            _ if has_value120_scroll || has_discrete_scroll => TouchPhase::Moved,
+                            _ if has_discrete_scroll => TouchPhase::Moved,
                             TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
                             _ => TouchPhase::Started,
                         }
@@ -218,13 +216,7 @@ 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_value120_scroll {
+                    let delta = if has_discrete_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,
@@ -409,16 +401,23 @@ impl Default for WinitPointerDataInner {
 }
 
 /// Convert the Wayland button into winit.
-fn wayland_button_to_winit(button: u32) -> ButtonSource {
+fn wayland_button_to_winit(button: u32) -> MouseButton {
     // These values are coming from <linux/input-event-codes.h>.
-    const BTN_MOUSE: u32 = 0x110;
+    const BTN_LEFT: u32 = 0x110;
-    const BTN_JOYSTICK: u32 = 0x120;
+    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;
 
-    if (BTN_MOUSE..BTN_JOYSTICK).contains(&button) {
+    match button {
-        // Mapping orders match
+        BTN_LEFT => MouseButton::Left,
-        MouseButton::try_from_u8((button - BTN_MOUSE) as u8).unwrap().into()
+        BTN_RIGHT => MouseButton::Right,
-    } else {
+        BTN_MIDDLE => MouseButton::Middle,
-        ButtonSource::Unknown(button as u16)
+        BTN_BACK | BTN_SIDE => MouseButton::Back,
+        BTN_FORWARD | BTN_EXTRA => MouseButton::Forward,
+        button => MouseButton::Other(button as u16),
     }
 }
 

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

@@ -1,204 +0,0 @@
-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,16 +4,14 @@ 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::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
 use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::{
     ContentHint, ContentPurpose, Event as TextInputEvent, ZwpTextInputV3,
 };
 use tracing::warn;
 use winit_core::event::{Ime, WindowEvent};
-use winit_core::window::{
+use winit_core::window::{ImeCapabilities, ImePurpose, ImeRequestData, ImeSurroundingText};
-    ImeCapabilities, ImeHint, ImePurpose, ImeRequestData, ImeSurroundingText,
-};
 
 use crate::state::WinitState;
 
@@ -84,7 +82,6 @@ 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();
@@ -130,13 +127,6 @@ 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:
@@ -150,7 +140,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.take()
+                    text_input_data.pending_delete
                 {
                     state.events_sink.push_window_event(
                         WindowEvent::Ime(Ime::DeleteSurrounding {
@@ -161,17 +151,14 @@ impl Dispatch<ZwpTextInputV3, TextInputData, WinitState> for TextInputState {
                     );
                 }
 
-                // Clear preedit, unless all we'll be doing next is sending a new preedit and
+                // Clear preedit, unless all we'll be doing next is sending a new preedit.
-                // 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`.
@@ -186,7 +173,6 @@ 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,
@@ -250,6 +236,7 @@ pub struct TextInputData {
     inner: std::sync::Mutex<TextInputDataInner>,
 }
 
+#[derive(Default)]
 pub struct TextInputDataInner {
     /// The `WlSurface` we're performing input to.
     surface: Option<WlSurface>,
@@ -262,21 +249,6 @@ 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.
@@ -306,7 +278,9 @@ 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>),
 
@@ -328,10 +302,8 @@ impl ClientState {
             surrounding_text: ImeSurroundingText::new(String::new(), 0, 0).unwrap(),
         };
 
-        let unsupported_flags = capabilities
+        let unsupported_flags =
-            .without_hint_and_purpose()
+            capabilities.without_purpose().without_cursor_area().without_surrounding_text();
-            .without_cursor_area()
-            .without_surrounding_text();
 
         if unsupported_flags != ImeCapabilities::new() {
             warn!(
@@ -350,10 +322,12 @@ 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((hint, purpose)) =
+        if let Some(purpose) = request_data.purpose {
-            request_data.hint_and_purpose.filter(|_| self.capabilities.hint_and_purpose())
+            if self.capabilities.purpose() {
-        {
+                self.content_type = purpose.into();
-            self.content_type = (hint, purpose).into();
+            } else {
+                warn!("discarding ImePurpose update without capability enabled.");
+            }
         }
 
         if let Some((position, size)) = request_data.cursor_area {
@@ -376,7 +350,7 @@ impl ClientState {
     }
 
     pub fn content_type(&self) -> Option<ContentType> {
-        self.capabilities.hint_and_purpose().then_some(self.content_type)
+        self.capabilities.purpose().then_some(self.content_type)
     }
 
     pub fn cursor_area(&self) -> Option<(LogicalPosition<u32>, LogicalSize<u32>)> {
@@ -391,69 +365,20 @@ impl ClientState {
 /// Arguments to content_type
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ContentType {
-    /// Text input hint.
+    /// Text input purpose
-    hint: ContentHint,
-    /// Text input purpose.
     purpose: ContentPurpose,
+    hint: ContentHint,
 }
 
-/// The two options influence each other, so they must be converted together.
+impl From<ImePurpose> for ContentType {
-impl From<(ImeHint, ImePurpose)> for ContentType {
+    fn from(purpose: ImePurpose) -> Self {
-    fn from((hint, purpose): (ImeHint, ImePurpose)) -> Self {
+        let (hint, purpose) = match purpose {
-        let purpose = match purpose {
+            ImePurpose::Password => (ContentHint::SensitiveData, ContentPurpose::Password),
-            ImePurpose::Password => ContentPurpose::Password,
+            ImePurpose::Terminal => (ContentHint::None, ContentPurpose::Terminal),
-            ImePurpose::Terminal => ContentPurpose::Terminal,
+            _ => return Default::default(),
-            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,
         };
 
-        let base_hint = match purpose {
+        Self { hint, 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 foldhash::HashMap;
+use ahash::AHashMap;
 use sctk::compositor::{CompositorHandler, CompositorState};
 use sctk::output::{OutputHandler, OutputState};
 use sctk::reexports::calloop::LoopHandle;
@@ -12,30 +12,29 @@ 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::SeatState;
 use sctk::seat::pointer::ThemedPointer;
-use sctk::shell::WaylandSurface;
+use sctk::seat::SeatState;
-use sctk::shell::xdg::XdgShell;
 use sctk::shell::xdg::window::{Window, WindowConfigure, WindowHandler};
+use sctk::shell::xdg::XdgShell;
+use sctk::shell::WaylandSurface;
 use sctk::shm::slot::SlotPool;
 use sctk::shm::{Shm, ShmHandler};
 use sctk::subcompositor::SubcompositorState;
 use winit_core::error::OsError;
 
-use crate::WindowId;
 use crate::event_loop::sink::EventSink;
 use crate::output::MonitorHandle;
 use crate::seat::{
-    PointerConstraintsState, PointerGesturesState, RelativePointerState, TextInputState,
+    PointerConstraintsState, RelativePointerState, TextInputState, WinitPointerData,
-    WinitPointerData, WinitPointerDataExt, WinitSeatState,
+    WinitPointerDataExt, WinitSeatState,
 };
-use crate::types::bgr_effects::BgrEffectManager;
+use crate::types::kwin_blur::KWinBlurManager;
 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)]
@@ -62,10 +61,10 @@ pub struct WinitState {
     pub xdg_shell: XdgShell,
 
     /// The currently present windows.
-    pub windows: RefCell<HashMap<WindowId, Arc<Mutex<WindowState>>>>,
+    pub windows: RefCell<AHashMap<WindowId, Arc<Mutex<WindowState>>>>,
 
     /// The requests from the `Window` to EventLoop, such as close operations and redraw requests.
-    pub window_requests: RefCell<HashMap<WindowId, Arc<WindowRequests>>>,
+    pub window_requests: RefCell<AHashMap<WindowId, Arc<WindowRequests>>>,
 
     /// The events that were generated directly from the window.
     pub window_events_sink: Arc<Mutex<EventSink>>,
@@ -74,10 +73,10 @@ pub struct WinitState {
     pub window_compositor_updates: Vec<WindowCompositorUpdate>,
 
     /// Currently handled seats.
-    pub seats: HashMap<ObjectId, WinitSeatState>,
+    pub seats: AHashMap<ObjectId, WinitSeatState>,
 
     /// Currently present cursor surfaces.
-    pub pointer_surfaces: HashMap<ObjectId, Arc<ThemedPointer<WinitPointerData>>>,
+    pub pointer_surfaces: AHashMap<ObjectId, Arc<ThemedPointer<WinitPointerData>>>,
 
     /// The state of the text input on the client.
     pub text_input_state: Option<TextInputState>,
@@ -101,23 +100,17 @@ 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>,
 
-    /// Blur manager.
+    /// KWin blur manager.
-    pub blur_manager: Option<BgrEffectManager>,
+    pub kwin_blur_manager: Option<KWinBlurManager>,
 
     /// Loop handle to re-register event sources, such as keyboard repeat.
     pub loop_handle: LoopHandle<'static, Self>,
@@ -156,7 +149,7 @@ impl WinitState {
 
         let seat_state = SeatState::new(globals, queue_handle);
 
-        let mut seats = HashMap::default();
+        let mut seats = AHashMap::default();
         for seat in seat_state.seats() {
             seats.insert(seat.id(), WinitSeatState::new());
         }
@@ -192,18 +185,16 @@ impl WinitState {
             window_events_sink: Default::default(),
             viewporter_state,
             fractional_scaling_manager,
-            blur_manager: BgrEffectManager::new(globals, queue_handle).ok(),
+            kwin_blur_manager: KWinBlurManager::new(globals, queue_handle).ok(),
 
             seats,
             text_input_state: TextInputState::new(globals, queue_handle).ok(),
 
             relative_pointer: RelativePointerState::new(globals, queue_handle).ok(),
-            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

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

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

winit-wayland/src/types/wp_tablet_input_v2.rs

@@ -1,412 +0,0 @@
-//! 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::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 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::Weak;
 use std::sync::atomic::AtomicBool;
+use std::sync::Weak;
 
 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 sctk::reexports::client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 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::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use wayland_client::{delegate_dispatch, Connection, Dispatch, Proxy, QueueHandle};
 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};