Only run observers in the default run loop mode

Introduced in 3a7350c with unclear motivation.

Nowadays, this feature is incomplete and unsound, and the equivalent
functionality can be trivially achieved outside of `winit` using
`objc2-ui-kit`.

.cargo/config.toml

@@ -1,6 +1,3 @@
-[alias]
-run-wasm = ["run", "--release", "--package", "run-wasm", "--"]
-
 # Allow rust-analyzer and local `cargo doc` invocations to pick up unreleased changelog entries
 #
 # Note that these flags are (intentionally) not included when building from the downloaded crate.

.git-blame-ignore-revs

@@ -0,0 +1,4 @@
+# $ git config blame.ignoreRevsFile .git-blame-ignore-revs
+
+# chore(rustfmt): use nightly
+7b0c7b6cb2c62767ca0c73c857b299883f55a883

.github/CODEOWNERS

@@ -1,10 +1,11 @@
 # Android
-/src/platform/android.rs            @msiglreith @MarijnS95
-/src/platform_impl/android          @msiglreith @MarijnS95
+/src/platform/android.rs            @MarijnS95
+/src/platform_impl/android          @MarijnS95
 
-# iOS
+# Apple (AppKit + UIKit)
 /src/platform/ios.rs                @madsmtm
-/src/platform_impl/ios              @madsmtm
+/src/platform/macos.rs              @madsmtm
+/src/platform_impl/apple            @madsmtm
 
 # Unix
 /src/platform_impl/linux/mod.rs     @kchibisov
@@ -17,17 +18,13 @@
 /src/platform/x11.rs                @kchibisov @notgull
 /src/platform_impl/linux/x11        @kchibisov @notgull
 
-# macOS
-/src/platform/macos.rs              @madsmtm
-/src/platform_impl/macos            @madsmtm
-
 # Web
 /src/platform/web.rs                @daxpedda
 /src/platform_impl/web              @daxpedda
 
 # Windows
-/src/platform/windows.rs            @msiglreith
-/src/platform_impl/windows          @msiglreith
+/src/platform/windows.rs            @notgull
+/src/platform_impl/windows          @notgull
 
 # Orbital (Redox OS)
 /src/platform/orbital.rs            @jackpot51

.github/workflows/ci.yml

@@ -10,8 +10,8 @@ jobs:
     name: Check formatting
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-    - uses: dtolnay/rust-toolchain@stable
+    - uses: taiki-e/checkout-action@v1
+    - uses: dtolnay/rust-toolchain@nightly
       with:
         components: rustfmt
     - name: Check Formatting
@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 30
     steps:
-      - uses: actions/checkout@v4
+      - uses: taiki-e/checkout-action@v1
       - uses: taiki-e/install-action@v2
         with:
           tool: typos-cli
@@ -42,7 +42,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        toolchain: [stable, nightly, '1.70.0']
+        toolchain: [stable, nightly, '1.73']
         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,  }
@@ -61,10 +61,10 @@ jobs:
           - { name: 'web',                target: wasm32-unknown-unknown,   os: ubuntu-latest,   }
         exclude:
           # Android is tested on stable-3
-          - toolchain: '1.70.0'
+          - toolchain: '1.73'
             platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
         include:
-          - toolchain: '1.70.0'
+          - toolchain: '1.73'
             platform: { name: 'Android', target: aarch64-linux-android, os: ubuntu-latest, options: '--package=winit --features=android-native-activity', cmd: 'apk --' }
           - toolchain: 'nightly'
             platform: {
@@ -88,7 +88,7 @@ jobs:
       CMD: ${{ matrix.platform.cmd }}
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: taiki-e/checkout-action@v1
 
     - name: Restore cache of cargo folder
       # We use `restore` and later `save`, so that we can create the key after
@@ -149,13 +149,13 @@ jobs:
     - name: Test dpi crate
       if: >
         contains(matrix.platform.name, 'Linux 64bit') &&
-        matrix.toolchain != '1.70.0'
+        matrix.toolchain != '1.73'
       run: cargo test -p dpi
 
     - name: Build tests
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
+        matrix.toolchain != '1.73'
       run: cargo $CMD test --no-run $OPTIONS
 
     - name: Run tests
@@ -164,7 +164,7 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
+        matrix.toolchain != '1.73'
       run: cargo $CMD test $OPTIONS
 
     - name: Lint with clippy
@@ -174,7 +174,7 @@ jobs:
     - name: Build tests with serde enabled
       if: >
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
+        matrix.toolchain != '1.73'
       run: cargo $CMD test --no-run $OPTIONS --features serde
 
     - name: Run tests with serde enabled
@@ -183,7 +183,7 @@ jobs:
         !contains(matrix.platform.target, 'ios') &&
         !contains(matrix.platform.target, 'wasm32') &&
         !contains(matrix.platform.target, 'redox') &&
-        matrix.toolchain != '1.70.0'
+        matrix.toolchain != '1.73'
       run: cargo $CMD test $OPTIONS --features serde
 
     - name: Check docs.rs documentation
@@ -220,9 +220,24 @@ jobs:
           - { name: 'Windows', target: x86_64-pc-windows-gnu }
 
     steps:
-    - uses: actions/checkout@v3
+    - uses: taiki-e/checkout-action@v1
     - uses: EmbarkStudios/cargo-deny-action@v1
       with:
         command: check
         log-level: error
         arguments: --all-features --target ${{ matrix.platform.target }}
+
+  swc:
+    name: Minimize JavaScript
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: taiki-e/checkout-action@v1
+      - name: Install SWC
+        run: sudo npm i -g @swc/cli
+      - name: Run SWC
+        run: |
+          swc src/platform_impl/web/web_sys/worker.js -o src/platform_impl/web/web_sys/worker.min.js
+      - name: Check for diff
+        run: |
+          [[ -z $(git status -s) ]]

.github/workflows/docs.yml

@@ -19,7 +19,7 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - uses: dtolnay/rust-toolchain@master
         with:

.gitignore

@@ -3,8 +3,5 @@ target/
 rls/
 .vscode/
 *~
-*.wasm
-*.ts
-*.js
 #*#
 .DS_Store

.swcrc

@@ -0,0 +1,12 @@
+{
+	"minify": true,
+	"jsc": {
+		"target": "es2022",
+		"minify": {
+			"compress": {
+				"unused": true
+			},
+			"mangle": true
+		}
+	}
+}

CONTRIBUTING.md

@@ -1,52 +1,122 @@
-# Winit Contributing Guidelines
+# Contribution Guidelines
 
-## Scope
-[See `FEATURES.md`](./FEATURES.md). When requesting or implementing a new Winit feature, you should
-consider whether or not it's directly related to window creation or input handling. If it isn't, it
-may be worth creating a separate crate that extends Winit's API to add that functionality.
+This document contains guidelines for contributing code to winit. It has to be
+followed in order for your patch to be approved and applied.
 
+## Contributing
 
-## Reporting an issue
+Anyone can contribute to winit, however given that it's a cross platform
+windowing toolkit getting certain changes incorporated could be challenging.
 
-When reporting an issue, in order to help the maintainers understand what the problem is, please make
-your description of the issue as detailed as possible:
+To save your time it's wise to check already opened [pull requests][prs] and
+[issues][issues]. In general, bug fixes and missing implementations are always
+accepted, however larger new API proposals should go into the issue first. When
+in doubt contact us on [Matrix][matrix] or via opening an issue.
 
-- if it is a bug, please provide a clear explanation of what happens, what should happen, and how to
-  reproduce the issue, ideally by providing a minimal program exhibiting the problem
-- if it is a feature request, please provide a clear argumentation about why you believe this feature
-  should be supported by winit
+### Submitting your work and handling review
 
-## Making a pull request
+All patches have to be sent on Github as [pull requests][prs]. To simplify your
+life during review it's recommended to check the "give contributors write access
+to the branch" checkbox.
 
-When making a code contribution to winit, before opening your pull request, please make sure that:
+#### Handling review
 
-- your patch builds with Winit's minimal supported rust version - Rust 1.70.
-- you tested your modifications on all the platforms impacted, or if not possible, detail which platforms
-  were not tested, and what should be tested, so that a maintainer or another contributor can test them
-- you updated any relevant documentation in winit
-- you left comments in your code explaining any part that is not straightforward, so that the
-  maintainers and future contributors don't have to try to guess what your code is supposed to do
-- your PR adds an entry to the current changelog if the introduced change is relevant to winit users.
+During the review process certain events could require an action from your side,
+common patterns and reactions are described below.
 
-  You needn't worry about the added entry causing conflicts, the maintainer that merges the PR will
-  handle those for you when merging (see below).
-- if your PR affects the platform compatibility of one or more features or adds another feature, the
-  relevant sections in [`FEATURES.md`](https://github.com/rust-windowing/winit/blob/master/FEATURES.md#features)
-  should be updated.
+_Event:_ The CI fails to build, but it looks like it is not your fault. Not
+communicating so could result in maintainers not looking into your patch,
+since they may assume that you're still working on it.\
+_Desired behaviour:_ Write a message saying roughly the following "The CI
+failure is unrelated", so that the maintainers will fix it for you.
 
-Once your PR is open, you can ask for a review by a maintainer of your platform. Winit's merging policy
-is that a PR must be approved by at least two maintainers of winit before being merged, including
-at least a maintainer of the platform (a maintainer making a PR themselves counts as approving it).
+_Event:_ Maintainer requested changes to your PR.\
+_Desired behavior:_ Once you address the request, you should re-request a review
+with GitHub's UI. If you don't agree with what maintainer suggested, you
+should state your objections and re-request the review. That will indicate that
+the ball is on maintainer's side.
 
-Once your PR is deemed ready, the merging maintainer will take care of resolving conflicts in the
-`changelog` module (but you must resolve other conflicts yourself). Doing this requires that you check the
-"give contributors write access to the branch" checkbox when creating the PR.
+_Event:_ You've opened a PR, but maintainer shortly after commented that they
+want to work on that themselves.\
+_Desired behavior:_ Discuss with the maintainer regarding their plans if they
+were not outlined in the initial response, because such response means that they
+are not interested in reviewing your code. Such thing could happen when
+underestimating complexity of the task you're solving or when your patch
+mandate certain downstream designs. In general, the maintainer will likely
+close your PR in order to prevent work being done on it.
+
+[prs]: https://github.com/rust-windowing/winit/pulls
+[issues]: https://github.com/rust-windowing/winit/issues
+[matrix]: https://matrix.to/#/#rust-windowing:matrix.org
 
 ## Maintainers
 
-The current maintainers for each platform are listed in the [CODEOWNERS](.github/CODEOWNERS) file.
+Winit has plenty of maintainers with different backgrounds, different time
+available to work on Winit, and reasons to be winit maintainer in the first
+place. To ensure that Winit's code quality does not decrease over time and to
+make it easier to teach new maintainers the "winit way of doing things" the
+common policies and routines are defined in this section.
 
-## Release process
+The current maintainers for each platform are listed in [this file][CODEOWNERS].
+
+### Contributions handling
+
+The maintainers must ensure that the external contributions meet Winit's
+quality standards. If it's not, it **is the maintainer's responsibility** to
+bring it on par, which includes:
+
+  - Ensure that formatting is consistent and `CHANGELOG` messages are clear
+    for the end users.
+  - Improve the commit message, so it'll be easier for other maintainers to
+    understand the motivation without going through all the discussions on the
+    particular patch/PR.
+  - Ensure that the proposed patch doesn't break platform parity. If the
+    breakage is desired by contributor, an issue should be opened to discuss
+    with other maintainers before merging.
+  - Always fix CI issues before merging if they don't originate from the
+    submitted work.
+
+However, maintainers should give some leeway for external contributors, so they
+don't feel discouraged contributing, for example:
+
+  - Suggest a patch to resolve style issues, if it's the only issue with the
+    submitted work. Keep in mind that pushing the resolution yourself is not
+    desired, because the contributor might not agree with what you did.
+  - Be more explicit on how things should be done if you don't like the
+    approach.
+  - Suggest to finish the PR for them if they're absent for a while and you need
+    the proposed changes to move forward with something. In such cases the
+    maintainer must preserve attribution with `Co-authored-by`, `Suggested-by`,
+    or keep the original committer.
+  - Rebase their work for them when massive changes to the Winit codebase were
+    introduced.
+
+When reviewing code of other maintainers all of the above is on the maintainer
+who submitted the patch. Interested maintainers could help push the work over
+the finish line, but teaching other maintainers should be preferred.
+
+For a _regular_ contributor to winit, the maintainer should slowly start
+requiring contributor to match *maintainer* quality standards when writing
+patches and commit messages.
+
+### Contributing
+
+When submitting a patch, the maintainer should follow the general contributing
+guidelines, however greater attention to detail is expected in this case.
+
+To make life simpler for other maintainers it's suggested to create your branch
+under the project repository instead of your own fork. The naming scheme is
+`github_user_name/branch_name`. Doing so will make your work easier to rebase
+for other maintainers when you're absent.
+
+### Administrative Actions
+
+Some things (such as changing required CI steps, adding contributors, ...)
+require administrative permissions. If you don't have those, ask about the
+change in an issue. If you have the permissions, discuss it with at least one
+other admin before making the change.
+
+### Release process
 
 Given that winit is a widely used library, we should be able to make a patch
 releases at any time we want without blocking the development of new features.
@@ -58,7 +128,8 @@ The exact steps for an exemplary `0.2.0` release might look like this:
   1. Initially, the version on the latest master is `0.1.0`
   2. A new `v0.2.x` branch is created for the release
   3. Update released `cfg_attr` in `src/changelog/mod.rs` to `v0.2.md`
-  4. Move entries from `src/changelog/unreleased.md` into `src/changelog/v0.2.md`
+  4. Move entries from `src/changelog/unreleased.md` into
+     `src/changelog/v0.2.md`
   5. In the branch, the version is bumped to `v0.2.0`
   6. The new commit in the branch is tagged `v0.2.0`
   7. The version is pushed to crates.io
@@ -70,3 +141,5 @@ When doing a patch release, the process is similar:
   2. Checkout the `v0.2.x` branch
   3. Cherry-pick the required non-breaking changes into the `v0.2.x`
   4. Follow steps 4-9 of the regular release example
+
+[CODEOWNERS]: .github/CODEOWNERS

Cargo.toml

@@ -1,7 +1,10 @@
 [package]
 name = "winit"
-version = "0.29.15"
-authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
+version = "0.30.3"
+authors = [
+    "The winit contributors",
+    "Pierre Krieger <pierre.krieger1708@gmail.com>",
+]
 description = "Cross-platform window creation library."
 keywords = ["windowing"]
 readme = "README.md"
@@ -11,6 +14,7 @@ rust-version.workspace = true
 repository.workspace = true
 license.workspace = true
 edition.workspace = true
+exclude = ["/.cargo"]
 
 [package.metadata.docs.rs]
 features = [
@@ -45,7 +49,15 @@ rustdoc-args = ["--cfg", "docsrs"]
 [features]
 default = ["rwh_06", "x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
 x11 = ["x11-dl", "bytemuck", "percent-encoding", "xkbcommon-dl/x11", "x11rb"]
-wayland = ["wayland-client", "wayland-backend", "wayland-protocols", "wayland-protocols-plasma", "sctk", "ahash", "memmap2"]
+wayland = [
+    "wayland-client",
+    "wayland-backend",
+    "wayland-protocols",
+    "wayland-protocols-plasma",
+    "sctk",
+    "ahash",
+    "memmap2",
+]
 wayland-dlopen = ["wayland-backend/dlopen"]
 wayland-csd-adwaita = ["sctk-adwaita", "sctk-adwaita/ab_glyph"]
 wayland-csd-adwaita-crossfont = ["sctk-adwaita", "sctk-adwaita/crossfont"]
@@ -59,95 +71,137 @@ rwh_05 = ["dep:rwh_05", "ndk/rwh_05"]
 rwh_06 = ["dep:rwh_06", "ndk/rwh_06"]
 
 [build-dependencies]
-cfg_aliases = "0.2.0"
+cfg_aliases = "0.2.1"
 
 [dependencies]
 bitflags = "2"
 cursor-icon = "1.1.0"
 dpi = { version = "0.1.1", path = "dpi" }
 rwh_04 = { package = "raw-window-handle", version = "0.4", optional = true }
-rwh_05 = { package = "raw-window-handle", version = "0.5.2", features = ["std"], optional = true }
-rwh_06 = { package = "raw-window-handle", version = "0.6", features = ["std"], optional = true }
+rwh_05 = { package = "raw-window-handle", version = "0.5.2", features = [
+    "std",
+], optional = true }
+rwh_06 = { package = "raw-window-handle", version = "0.6", features = [
+    "std",
+], optional = true }
 serde = { workspace = true, optional = true }
 smol_str = "0.2.0"
-tracing = { version = "0.1.40", default_features = false }
+tracing = { version = "0.1.40", default-features = false }
 
 [dev-dependencies]
-image = { version = "0.24.0", default-features = false, features = ["png"] }
-tracing = { version = "0.1.40", default_features = false, features = ["log"] }
+image = { version = "0.25.0", default-features = false, features = ["png"] }
+tracing = { version = "0.1.40", default-features = false, features = ["log"] }
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
 winit = { path = ".", features = ["rwh_05"] }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dev-dependencies]
-softbuffer = { version = "0.3.0", default-features = false, features = ["x11", "x11-dlopen", "wayland", "wayland-dlopen"] }
+softbuffer = { version = "0.4.0", default-features = false, features = [
+    "x11",
+    "x11-dlopen",
+    "wayland",
+    "wayland-dlopen",
+] }
 
+# Android
 [target.'cfg(target_os = "android")'.dependencies]
-android-activity = "0.5.0"
-ndk = { version = "0.8.0", default-features = false }
-ndk-sys = "0.5.0"
+android-activity = "0.6.0"
+ndk = { version = "0.9.0", default-features = false }
 
-[target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
+# AppKit or UIKit
+[target.'cfg(target_vendor = "apple")'.dependencies]
 core-foundation = "0.9.3"
-objc2 = "0.5.0"
+objc2 = "0.5.2"
 
+# AppKit
 [target.'cfg(target_os = "macos")'.dependencies]
 core-graphics = "0.23.1"
-
-[target.'cfg(target_os = "macos")'.dependencies.icrate]
-version = "0.1.0"
-features = [
+block2 = "0.5.1"
+objc2-foundation = { version = "0.2.2", features = [
+    "block2",
     "dispatch",
-    "Foundation",
-    "Foundation_NSArray",
-    "Foundation_NSAttributedString",
-    "Foundation_NSMutableAttributedString",
-    "Foundation_NSData",
-    "Foundation_NSDictionary",
-    "Foundation_NSString",
-    "Foundation_NSProcessInfo",
-    "Foundation_NSThread",
-    "Foundation_NSNumber",
-    "AppKit",
-    "AppKit_NSAppearance",
-    "AppKit_NSApplication",
-    "AppKit_NSBitmapImageRep",
-    "AppKit_NSButton",
-    "AppKit_NSColor",
-    "AppKit_NSControl",
-    "AppKit_NSCursor",
-    "AppKit_NSEvent",
-    "AppKit_NSGraphicsContext",
-    "AppKit_NSImage",
-    "AppKit_NSImageRep",
-    "AppKit_NSMenu",
-    "AppKit_NSMenuItem",
-    "AppKit_NSPasteboard",
-    "AppKit_NSResponder",
-    "AppKit_NSScreen",
-    "AppKit_NSTextInputContext",
-    "AppKit_NSView",
-    "AppKit_NSWindow",
-    "AppKit_NSWindowTabGroup",
-]
+    "NSArray",
+    "NSAttributedString",
+    "NSData",
+    "NSDictionary",
+    "NSDistributedNotificationCenter",
+    "NSEnumerator",
+    "NSKeyValueObserving",
+    "NSNotification",
+    "NSObjCRuntime",
+    "NSPathUtilities",
+    "NSProcessInfo",
+    "NSRunLoop",
+    "NSString",
+    "NSThread",
+    "NSValue",
+] }
+objc2-app-kit = { version = "0.2.2", features = [
+    "NSAppearance",
+    "NSApplication",
+    "NSBitmapImageRep",
+    "NSButton",
+    "NSColor",
+    "NSControl",
+    "NSCursor",
+    "NSDragging",
+    "NSEvent",
+    "NSGraphics",
+    "NSGraphicsContext",
+    "NSImage",
+    "NSImageRep",
+    "NSMenu",
+    "NSMenuItem",
+    "NSOpenGLView",
+    "NSPasteboard",
+    "NSResponder",
+    "NSRunningApplication",
+    "NSScreen",
+    "NSTextInputClient",
+    "NSTextInputContext",
+    "NSView",
+    "NSWindow",
+    "NSWindowScripting",
+    "NSWindowTabGroup",
+] }
 
-[target.'cfg(target_os = "ios")'.dependencies.icrate]
-version = "0.1.0"
-features = [
+# UIKit
+[target.'cfg(all(target_vendor = "apple", not(target_os = "macos")))'.dependencies]
+objc2-foundation = { version = "0.2.2", features = [
     "dispatch",
-    "Foundation",
-    "Foundation_NSArray",
-    "Foundation_NSString",
-    "Foundation_NSProcessInfo",
-    "Foundation_NSThread",
-    "Foundation_NSSet",
-]
+    "NSArray",
+    "NSEnumerator",
+    "NSGeometry",
+    "NSObjCRuntime",
+    "NSString",
+    "NSProcessInfo",
+    "NSThread",
+    "NSSet",
+] }
+objc2-ui-kit = { version = "0.2.2", features = [
+    "UIApplication",
+    "UIDevice",
+    "UIEvent",
+    "UIGeometry",
+    "UIGestureRecognizer",
+    "UIOrientation",
+    "UIPanGestureRecognizer",
+    "UIPinchGestureRecognizer",
+    "UIResponder",
+    "UIRotationGestureRecognizer",
+    "UIScreen",
+    "UIScreenMode",
+    "UITapGestureRecognizer",
+    "UITouch",
+    "UITraitCollection",
+    "UIView",
+    "UIViewController",
+    "UIWindow",
+] }
 
+# Windows
 [target.'cfg(target_os = "windows")'.dependencies]
 unicode-segmentation = "1.7.1"
-
-[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
-version = "0.48"
-features = [
+windows-sys = { version = "0.52.0", features = [
     "Win32_Devices_HumanInterfaceDevice",
     "Win32_Foundation",
     "Win32_Globalization",
@@ -172,37 +226,59 @@ features = [
     "Win32_UI_Shell",
     "Win32_UI_TextServices",
     "Win32_UI_WindowsAndMessaging",
-]
+] }
 
-[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies]
+# Linux
+[target.'cfg(all(unix, not(any(target_os = "redox", target_family = "wasm", target_os = "android", target_vendor = "apple"))))'.dependencies]
 ahash = { version = "0.8.7", features = ["no-rng"], optional = true }
 bytemuck = { version = "1.13.1", default-features = false, optional = true }
 calloop = "0.12.3"
 libc = "0.2.64"
 memmap2 = { version = "0.9.0", optional = true }
 percent-encoding = { version = "2.0", optional = true }
-rustix = { version = "0.38.4", default-features = false, features = ["std", "system", "thread", "process"] }
-sctk = { package = "smithay-client-toolkit", version = "0.18.0", default-features = false, features = ["calloop"], optional = true }
-sctk-adwaita = { version = "0.8.0", default_features = false, optional = true }
-wayland-backend = { version = "0.3.0", default_features = false, features = ["client_system"], optional = true }
+rustix = { version = "0.38.4", default-features = false, features = [
+    "std",
+    "system",
+    "thread",
+    "process",
+] }
+sctk = { package = "smithay-client-toolkit", version = "0.18.0", default-features = false, features = [
+    "calloop",
+], optional = true }
+sctk-adwaita = { version = "0.9.0", default-features = false, optional = true }
+wayland-backend = { version = "0.3.0", default-features = false, features = [
+    "client_system",
+], optional = true }
 wayland-client = { version = "0.31.1", optional = true }
-wayland-protocols = { version = "0.31.0", features = [ "staging"], optional = true }
-wayland-protocols-plasma = { version = "0.2.0", features = [ "client" ], optional = true }
+wayland-protocols = { version = "0.31.0", features = [
+    "staging",
+], optional = true }
+wayland-protocols-plasma = { version = "0.2.0", features = [
+    "client",
+], optional = true }
 x11-dl = { version = "2.19.1", optional = true }
-x11rb = { version = "0.13.0", default-features = false, features = ["allow-unsafe-code", "dl-libxcb", "randr", "resource_manager", "xinput", "xkb"], optional = true }
+x11rb = { version = "0.13.0", default-features = false, features = [
+    "allow-unsafe-code",
+    "dl-libxcb",
+    "randr",
+    "resource_manager",
+    "xinput",
+    "xkb",
+], optional = true }
 xkbcommon-dl = "0.4.2"
 
+# Orbital
 [target.'cfg(target_os = "redox")'.dependencies]
 orbclient = { version = "0.3.47", default-features = false }
 redox_syscall = "0.4.1"
 
-[target.'cfg(target_family = "wasm")'.dependencies.web_sys]
-package = "web-sys"
-version = "0.3.64"
-features = [
+# Web
+[target.'cfg(target_family = "wasm")'.dependencies]
+web_sys = { package = "web-sys", version = "0.3.64", features = [
     'AbortController',
     'AbortSignal',
     'Blob',
+    'BlobPropertyBag',
     'console',
     'CssStyleDeclaration',
     'Document',
@@ -238,10 +314,9 @@ features = [
     'VisibilityState',
     'Window',
     'WheelEvent',
+    'Worker',
     'Url',
-]
-
-[target.'cfg(target_family = "wasm")'.dependencies]
+] }
 js-sys = "0.3.64"
 pin-project = "1"
 wasm-bindgen = "0.2"
@@ -253,8 +328,8 @@ atomic-waker = "1"
 concurrent-queue = { version = "2", default-features = false }
 
 [target.'cfg(target_family = "wasm")'.dev-dependencies]
-console_log = "1"
-web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }
+console_error_panic_hook = "0.1"
+tracing-web = "0.1"
 
 [[example]]
 doc-scrape-examples = true
@@ -262,13 +337,10 @@ name = "window"
 
 [workspace]
 resolver = "2"
-members = [
-    "dpi",
-    "run-wasm",
-]
+members = ["dpi"]
 
 [workspace.package]
-rust-version = "1.70.0"
+rust-version = "1.73"
 repository = "https://github.com/rust-windowing/winit"
 license = "Apache-2.0"
 edition = "2021"

FEATURES.md

@@ -154,7 +154,6 @@ If your PR makes notable changes to Winit's features, please update this section
 * Home indicator visibility
 * Status bar visibility and style
 * Deferring system gestures
-* Getting the device idiom
 * Getting the preferred video mode
 
 ### Web
@@ -179,7 +178,7 @@ Legend:
 |Window decorations               |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|✔️      |
 |Window decorations toggle        |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
 |Window resizing                  |✔️     |✔️     |✔️         |✔️        |**N/A**|**N/A**|✔️        |✔️      |
-|Window resize increments         |❌     |✔️     |✔️         |❌             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Window resize increments         |✔️     |✔️     |✔️         |❌             |**N/A**|**N/A**|**N/A**|**N/A** |
 |Window transparency              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|N/A        |✔️      |
 |Window blur                      |❌    |❌    |❌        |✔️             |**N/A**|**N/A**|N/A        |❌     |
 |Window maximization              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |

README.md

@@ -8,7 +8,7 @@
 
 ```toml
 [dependencies]
-winit = "0.29.15"
+winit = "0.30.3"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -35,7 +35,7 @@ another library.
 
 ## MSRV Policy
 
-This crate's Minimum Supported Rust Version (MSRV) is **1.70**. Changes to
+This crate's Minimum Supported Rust Version (MSRV) is **1.73**. 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

build.rs

@@ -1,19 +1,18 @@
 use cfg_aliases::cfg_aliases;
 
 fn main() {
-    // The script doesn't depend on our code
+    // The script doesn't depend on our code.
     println!("cargo:rerun-if-changed=build.rs");
 
-    // Setup cfg aliases
+    // Setup cfg aliases.
     cfg_aliases! {
         // Systems.
         android_platform: { target_os = "android" },
         web_platform: { all(target_family = "wasm", target_os = "unknown") },
         macos_platform: { target_os = "macos" },
-        ios_platform: { target_os = "ios" },
+        ios_platform: { all(target_vendor = "apple", not(target_os = "macos")) },
         windows_platform: { target_os = "windows" },
-        apple: { any(target_os = "ios", target_os = "macos") },
-        free_unix: { all(unix, not(apple), not(android_platform), not(target_os = "emscripten")) },
+        free_unix: { all(unix, not(target_vendor = "apple"), not(android_platform), not(target_os = "emscripten")) },
         redox: { target_os = "redox" },
 
         // Native displays.
@@ -21,4 +20,7 @@ fn main() {
         wayland_platform: { all(feature = "wayland", free_unix, not(redox)) },
         orbital_platform: { redox },
     }
+
+    // Winit defined cfgs.
+    println!("cargo:rustc-check-cfg=cfg(unreleased_changelogs)");
 }

clippy.toml

@@ -10,6 +10,8 @@ disallowed-methods = [
     { path = "web_sys::Element::request_fullscreen", reason = "Doesn't account for compatibility with Safari" },
     { path = "web_sys::Document::exit_fullscreen", reason = "Doesn't account for compatibility with Safari" },
     { path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },
-    { path = "icrate::AppKit::NSView::visibleRect", reason = "We expose a render target to the user, and visibility is not really relevant to that (and can break if you don't use the rectangle position as well). Use `frame` instead." },
-    { path = "icrate::AppKit::NSWindow::setFrameTopLeftPoint", reason = "Not sufficient when working with Winit's coordinate system, use `flip_window_screen_coordinates` instead" },
+    { path = "objc2_app_kit::NSView::visibleRect", reason = "We expose a render target to the user, and visibility is not really relevant to that (and can break if you don't use the rectangle position as well). Use `frame` instead." },
+    { path = "objc2_app_kit::NSWindow::setFrameTopLeftPoint", reason = "Not sufficient when working with Winit's coordinate system, use `flip_window_screen_coordinates` instead" },
+    { path = "core_foundation::runloop::kCFRunLoopCommonModes", reason = "Using the common modes includes the modal panel mode, which we usually want to avoid" },
+    { path = "objc2_foundation::NSRunLoopCommonModes", reason = "Using the common modes includes the modal panel mode, which we usually want to avoid" }
 ]

dpi/src/lib.rs

@@ -35,9 +35,9 @@
 //!
 //! ### Position and Size types
 //!
-//! The [`PhysicalPosition`] / [`PhysicalSize`] / [`PhysicalUnit`] types correspond with the actual pixels on the
-//! device, and the [`LogicalPosition`] / [`LogicalSize`] / [`LogicalUnit`] types correspond to the physical pixels
-//! divided by the scale factor.
+//! The [`PhysicalPosition`] / [`PhysicalSize`] / [`PhysicalUnit`] types correspond with the actual
+//! pixels on the device, and the [`LogicalPosition`] / [`LogicalSize`] / [`LogicalUnit`] types
+//! correspond to the physical pixels divided by the scale factor.
 //!
 //! The position and size types are generic over their exact pixel type, `P`, to allow the
 //! API to have integer precision where appropriate (e.g. most window manipulation functions) and
@@ -52,19 +52,14 @@
 //!
 //! This crate provides the following Cargo features:
 //!
-//! * `serde`: Enables serialization/deserialization of certain types with
-//!   [Serde](https://crates.io/crates/serde).
+//! * `serde`: Enables serialization/deserialization of certain types with [Serde](https://crates.io/crates/serde).
 //! * `mint`: Enables mint (math interoperability standard types) conversions.
 //!
 //!
 //! [points]: https://en.wikipedia.org/wiki/Point_(typography)
 //! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)
 
-#![cfg_attr(
-    docsrs,
-    feature(doc_auto_cfg, doc_cfg_hide),
-    doc(cfg_hide(doc, docsrs))
-)]
+#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
 #![forbid(unsafe_code)]
 
 #[cfg(feature = "serde")]
@@ -120,9 +115,9 @@ impl Pixel for f64 {
 
 /// Checks that the scale factor is a normal positive `f64`.
 ///
-/// All functions that take a scale factor assert that this will return `true`. If you're sourcing scale factors from
-/// anywhere other than winit, it's recommended to validate them using this function before passing them to winit;
-/// otherwise, you risk panics.
+/// All functions that take a scale factor assert that this will return `true`. If you're sourcing
+/// scale factors from anywhere other than winit, it's recommended to validate them using this
+/// function before passing them to winit; otherwise, you risk panics.
 #[inline]
 pub fn validate_scale_factor(scale_factor: f64) -> bool {
     scale_factor.is_sign_positive() && scale_factor.is_normal()
@@ -134,12 +129,12 @@ pub fn validate_scale_factor(scale_factor: f64) -> bool {
 pub struct LogicalUnit<P>(pub P);
 
 impl<P> LogicalUnit<P> {
+    /// Represents a maximum logical unit that is equal to [`f64::MAX`].
+    pub const MAX: LogicalUnit<f64> = LogicalUnit::new(f64::MAX);
     /// Represents a minimum logical unit of [`f64::MAX`].
     pub const MIN: LogicalUnit<f64> = LogicalUnit::new(f64::MIN);
     /// Represents a logical unit of `0_f64`.
     pub const ZERO: LogicalUnit<f64> = LogicalUnit::new(0.0);
-    /// Represents a maximum logical unit that is equal to [`f64::MAX`].
-    pub const MAX: LogicalUnit<f64> = LogicalUnit::new(f64::MAX);
 
     #[inline]
     pub const fn new(v: P) -> Self {
@@ -228,12 +223,12 @@ impl<P: Pixel> From<LogicalUnit<P>> for f64 {
 pub struct PhysicalUnit<P>(pub P);
 
 impl<P> PhysicalUnit<P> {
+    /// Represents a maximum physical unit that is equal to [`f64::MAX`].
+    pub const MAX: LogicalUnit<f64> = LogicalUnit::new(f64::MAX);
     /// Represents a minimum physical unit of [`f64::MAX`].
     pub const MIN: LogicalUnit<f64> = LogicalUnit::new(f64::MIN);
     /// Represents a physical unit of `0_f64`.
     pub const ZERO: LogicalUnit<f64> = LogicalUnit::new(0.0);
-    /// Represents a maximum physical unit that is equal to [`f64::MAX`].
-    pub const MAX: LogicalUnit<f64> = LogicalUnit::new(f64::MAX);
 
     #[inline]
     pub const fn new(v: P) -> Self {
@@ -322,12 +317,12 @@ pub enum PixelUnit {
 }
 
 impl PixelUnit {
+    /// Represents a maximum logical unit that is equal to [`f64::MAX`].
+    pub const MAX: PixelUnit = PixelUnit::Logical(LogicalUnit::new(f64::MAX));
     /// Represents a minimum logical unit of [`f64::MAX`].
     pub const MIN: PixelUnit = PixelUnit::Logical(LogicalUnit::new(f64::MIN));
     /// Represents a logical unit of `0_f64`.
     pub const ZERO: PixelUnit = PixelUnit::Logical(LogicalUnit::new(0.0));
-    /// Represents a maximum logical unit that is equal to [`f64::MAX`].
-    pub const MAX: PixelUnit = PixelUnit::Logical(LogicalUnit::new(f64::MAX));
 
     pub fn new<S: Into<PixelUnit>>(unit: S) -> PixelUnit {
         unit.into()
@@ -400,10 +395,7 @@ impl<P: Pixel> LogicalPosition<P> {
 
     #[inline]
     pub fn cast<X: Pixel>(&self) -> LogicalPosition<X> {
-        LogicalPosition {
-            x: self.x.cast(),
-            y: self.y.cast(),
-        }
+        LogicalPosition { x: self.x.cast(), y: self.y.cast() }
     }
 }
 
@@ -479,10 +471,7 @@ impl<P: Pixel> PhysicalPosition<P> {
 
     #[inline]
     pub fn cast<X: Pixel>(&self) -> PhysicalPosition<X> {
-        PhysicalPosition {
-            x: self.x.cast(),
-            y: self.y.cast(),
-        }
+        PhysicalPosition { x: self.x.cast(), y: self.y.cast() }
     }
 }
 
@@ -558,10 +547,7 @@ impl<P: Pixel> LogicalSize<P> {
 
     #[inline]
     pub fn cast<X: Pixel>(&self) -> LogicalSize<X> {
-        LogicalSize {
-            width: self.width.cast(),
-            height: self.height.cast(),
-        }
+        LogicalSize { width: self.width.cast(), height: self.height.cast() }
     }
 }
 
@@ -599,10 +585,7 @@ impl<P: Pixel> From<mint::Vector2<P>> for LogicalSize<P> {
 #[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,
-        }
+        mint::Vector2 { x: s.width, y: s.height }
     }
 }
 
@@ -637,10 +620,7 @@ impl<P: Pixel> PhysicalSize<P> {
 
     #[inline]
     pub fn cast<X: Pixel>(&self) -> PhysicalSize<X> {
-        PhysicalSize {
-            width: self.width.cast(),
-            height: self.height.cast(),
-        }
+        PhysicalSize { width: self.width.cast(), height: self.height.cast() }
     }
 }
 
@@ -678,10 +658,7 @@ impl<P: Pixel> From<mint::Vector2<P>> for PhysicalSize<P> {
 #[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,
-        }
+        mint::Vector2 { x: s.width, y: s.height }
     }
 }
 
@@ -846,12 +823,7 @@ mod tests {
 
     macro_rules! assert_approx_eq {
         ($a:expr, $b:expr $(,)?) => {
-            assert!(
-                ($a - $b).abs() < 0.001,
-                "{} is not approximately equal to {}",
-                $a,
-                $b
-            );
+            assert!(($a - $b).abs() < 0.001, "{} is not approximately equal to {}", $a, $b);
         };
     }
 
@@ -970,14 +942,8 @@ mod tests {
         assert_eq!(log_unit.to_physical::<u32>(1.0), PhysicalUnit::new(1));
         assert_eq!(log_unit.to_physical::<u32>(2.0), PhysicalUnit::new(2));
         assert_eq!(log_unit.cast::<u32>(), LogicalUnit::new(1));
-        assert_eq!(
-            log_unit,
-            LogicalUnit::from_physical(PhysicalUnit::new(1.0), 1.0)
-        );
-        assert_eq!(
-            log_unit,
-            LogicalUnit::from_physical(PhysicalUnit::new(2.0), 2.0)
-        );
+        assert_eq!(log_unit, LogicalUnit::from_physical(PhysicalUnit::new(1.0), 1.0));
+        assert_eq!(log_unit, LogicalUnit::from_physical(PhysicalUnit::new(2.0), 2.0));
         assert_eq!(LogicalUnit::from(2.0), LogicalUnit::new(2.0));
 
         let x: f64 = log_unit.into();
@@ -986,14 +952,8 @@ mod tests {
 
     #[test]
     fn test_physical_unit() {
-        assert_eq!(
-            PhysicalUnit::from_logical(LogicalUnit::new(1.0), 1.0),
-            PhysicalUnit::new(1)
-        );
-        assert_eq!(
-            PhysicalUnit::from_logical(LogicalUnit::new(2.0), 0.5),
-            PhysicalUnit::new(1)
-        );
+        assert_eq!(PhysicalUnit::from_logical(LogicalUnit::new(1.0), 1.0), PhysicalUnit::new(1));
+        assert_eq!(PhysicalUnit::from_logical(LogicalUnit::new(2.0), 0.5), PhysicalUnit::new(1));
         assert_eq!(PhysicalUnit::from(2.0), PhysicalUnit::new(2.0,));
         assert_eq!(PhysicalUnit::from(2.0), PhysicalUnit::new(2.0));
 
@@ -1007,22 +967,10 @@ mod tests {
         assert_eq!(log_pos.to_physical::<u32>(1.0), PhysicalPosition::new(1, 2));
         assert_eq!(log_pos.to_physical::<u32>(2.0), PhysicalPosition::new(2, 4));
         assert_eq!(log_pos.cast::<u32>(), LogicalPosition::new(1, 2));
-        assert_eq!(
-            log_pos,
-            LogicalPosition::from_physical(PhysicalPosition::new(1.0, 2.0), 1.0)
-        );
-        assert_eq!(
-            log_pos,
-            LogicalPosition::from_physical(PhysicalPosition::new(2.0, 4.0), 2.0)
-        );
-        assert_eq!(
-            LogicalPosition::from((2.0, 2.0)),
-            LogicalPosition::new(2.0, 2.0)
-        );
-        assert_eq!(
-            LogicalPosition::from([2.0, 3.0]),
-            LogicalPosition::new(2.0, 3.0)
-        );
+        assert_eq!(log_pos, LogicalPosition::from_physical(PhysicalPosition::new(1.0, 2.0), 1.0));
+        assert_eq!(log_pos, LogicalPosition::from_physical(PhysicalPosition::new(2.0, 4.0), 2.0));
+        assert_eq!(LogicalPosition::from((2.0, 2.0)), LogicalPosition::new(2.0, 2.0));
+        assert_eq!(LogicalPosition::from([2.0, 3.0]), LogicalPosition::new(2.0, 3.0));
 
         let x: (f64, f64) = log_pos.into();
         assert_eq!(x, (1.0, 2.0));
@@ -1040,14 +988,8 @@ mod tests {
             PhysicalPosition::from_logical(LogicalPosition::new(2.0, 4.0), 0.5),
             PhysicalPosition::new(1, 2)
         );
-        assert_eq!(
-            PhysicalPosition::from((2.0, 2.0)),
-            PhysicalPosition::new(2.0, 2.0)
-        );
-        assert_eq!(
-            PhysicalPosition::from([2.0, 3.0]),
-            PhysicalPosition::new(2.0, 3.0)
-        );
+        assert_eq!(PhysicalPosition::from((2.0, 2.0)), PhysicalPosition::new(2.0, 2.0));
+        assert_eq!(PhysicalPosition::from([2.0, 3.0]), PhysicalPosition::new(2.0, 3.0));
 
         let x: (f64, f64) = PhysicalPosition::new(1, 2).into();
         assert_eq!(x, (1.0, 2.0));
@@ -1061,14 +1003,8 @@ mod tests {
         assert_eq!(log_size.to_physical::<u32>(1.0), PhysicalSize::new(1, 2));
         assert_eq!(log_size.to_physical::<u32>(2.0), PhysicalSize::new(2, 4));
         assert_eq!(log_size.cast::<u32>(), LogicalSize::new(1, 2));
-        assert_eq!(
-            log_size,
-            LogicalSize::from_physical(PhysicalSize::new(1.0, 2.0), 1.0)
-        );
-        assert_eq!(
-            log_size,
-            LogicalSize::from_physical(PhysicalSize::new(2.0, 4.0), 2.0)
-        );
+        assert_eq!(log_size, LogicalSize::from_physical(PhysicalSize::new(1.0, 2.0), 1.0));
+        assert_eq!(log_size, LogicalSize::from_physical(PhysicalSize::new(2.0, 4.0), 2.0));
         assert_eq!(LogicalSize::from((2.0, 2.0)), LogicalSize::new(2.0, 2.0));
         assert_eq!(LogicalSize::from([2.0, 3.0]), LogicalSize::new(2.0, 3.0));
 
@@ -1099,10 +1035,7 @@ mod tests {
 
     #[test]
     fn test_size() {
-        assert_eq!(
-            Size::new(PhysicalSize::new(1, 2)),
-            Size::Physical(PhysicalSize::new(1, 2))
-        );
+        assert_eq!(Size::new(PhysicalSize::new(1, 2)), Size::Physical(PhysicalSize::new(1, 2)));
         assert_eq!(
             Size::new(LogicalSize::new(1.0, 2.0)),
             Size::Logical(LogicalSize::new(1.0, 2.0))

examples/child_window.rs

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

examples/control_flow.rs

@@ -4,6 +4,7 @@ use std::thread;
 #[cfg(not(web_platform))]
 use std::time;
 
+use ::tracing::{info, warn};
 #[cfg(web_platform)]
 use web_time as time;
 
@@ -15,6 +16,8 @@ use winit::window::{Window, WindowId};
 
 #[path = "util/fill.rs"]
 mod fill;
+#[path = "util/tracing.rs"]
+mod tracing;
 
 const WAIT_TIME: time::Duration = time::Duration::from_millis(100);
 const POLL_SLEEP_TIME: time::Duration = time::Duration::from_millis(100);
@@ -28,13 +31,16 @@ enum Mode {
 }
 
 fn main() -> Result<(), impl std::error::Error> {
-    tracing_subscriber::fmt::init();
+    #[cfg(web_platform)]
+    console_error_panic_hook::set_once();
 
-    println!("Press '1' to switch to Wait mode.");
-    println!("Press '2' to switch to WaitUntil mode.");
-    println!("Press '3' to switch to Poll mode.");
-    println!("Press 'R' to toggle request_redraw() calls.");
-    println!("Press 'Esc' to close the window.");
+    tracing::init();
+
+    info!("Press '1' to switch to Wait mode.");
+    info!("Press '2' to switch to WaitUntil mode.");
+    info!("Press '3' to switch to Poll mode.");
+    info!("Press 'R' to toggle request_redraw() calls.");
+    info!("Press 'Esc' to close the window.");
 
     let event_loop = EventLoop::new().unwrap();
 
@@ -53,7 +59,7 @@ struct ControlFlowDemo {
 
 impl ApplicationHandler for ControlFlowDemo {
     fn new_events(&mut self, _event_loop: &ActiveEventLoop, cause: StartCause) {
-        println!("new_events: {cause:?}");
+        info!("new_events: {cause:?}");
 
         self.wait_cancelled = match cause {
             StartCause::WaitCancelled { .. } => self.mode == Mode::WaitUntil,
@@ -74,49 +80,44 @@ impl ApplicationHandler for ControlFlowDemo {
         _window_id: WindowId,
         event: WindowEvent,
     ) {
-        println!("{event:?}");
+        info!("{event:?}");
 
         match event {
             WindowEvent::CloseRequested => {
                 self.close_requested = true;
-            }
+            },
             WindowEvent::KeyboardInput {
-                event:
-                    KeyEvent {
-                        logical_key: key,
-                        state: ElementState::Pressed,
-                        ..
-                    },
+                event: KeyEvent { logical_key: key, state: ElementState::Pressed, .. },
                 ..
             } => match key.as_ref() {
                 // WARNING: Consider using `key_without_modifiers()` if available on your platform.
                 // See the `key_binding` example
                 Key::Character("1") => {
                     self.mode = Mode::Wait;
-                    println!("\nmode: {:?}\n", self.mode);
-                }
+                    warn!("mode: {:?}", self.mode);
+                },
                 Key::Character("2") => {
                     self.mode = Mode::WaitUntil;
-                    println!("\nmode: {:?}\n", self.mode);
-                }
+                    warn!("mode: {:?}", self.mode);
+                },
                 Key::Character("3") => {
                     self.mode = Mode::Poll;
-                    println!("\nmode: {:?}\n", self.mode);
-                }
+                    warn!("mode: {:?}", self.mode);
+                },
                 Key::Character("r") => {
                     self.request_redraw = !self.request_redraw;
-                    println!("\nrequest_redraw: {}\n", self.request_redraw);
-                }
+                    warn!("request_redraw: {}", self.request_redraw);
+                },
                 Key::Named(NamedKey::Escape) => {
                     self.close_requested = true;
-                }
+                },
                 _ => (),
             },
             WindowEvent::RedrawRequested => {
                 let window = self.window.as_ref().unwrap();
                 window.pre_present_notify();
                 fill::fill_window(window);
-            }
+            },
             _ => (),
         }
     }
@@ -133,11 +134,11 @@ impl ApplicationHandler for ControlFlowDemo {
                     event_loop
                         .set_control_flow(ControlFlow::WaitUntil(time::Instant::now() + WAIT_TIME));
                 }
-            }
+            },
             Mode::Poll => {
                 thread::sleep(POLL_SLEEP_TIME);
                 event_loop.set_control_flow(ControlFlow::Poll);
-            }
+            },
         };
 
         if self.close_requested {

examples/pump_events.rs

@@ -1,15 +1,11 @@
 #![allow(clippy::single_match)]
 
 // Limit this example to only compatible platforms.
-#[cfg(any(
-    windows_platform,
-    macos_platform,
-    x11_platform,
-    wayland_platform,
-    android_platform,
-))]
+#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform, android_platform,))]
 fn main() -> std::process::ExitCode {
-    use std::{process::ExitCode, thread::sleep, time::Duration};
+    use std::process::ExitCode;
+    use std::thread::sleep;
+    use std::time::Duration;
 
     use winit::application::ApplicationHandler;
     use winit::event::WindowEvent;
@@ -49,7 +45,7 @@ fn main() -> std::process::ExitCode {
                 WindowEvent::RedrawRequested => {
                     fill::fill_window(window);
                     window.request_redraw();
-                }
+                },
                 _ => (),
             }
         }

examples/run_on_demand.rs

@@ -60,13 +60,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
             match event {
                 WindowEvent::CloseRequested => {
-                    println!("--------------------------------------------------------- Window {} CloseRequested", self.idx);
+                    println!(
+                        "--------------------------------------------------------- Window {} \
+                         CloseRequested",
+                        self.idx
+                    );
                     fill::cleanup_window(window);
                     self.window = None;
-                }
+                },
                 WindowEvent::RedrawRequested => {
                     fill::fill_window(window);
-                }
+                },
                 _ => (),
             }
         }
@@ -76,10 +80,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let mut event_loop = EventLoop::new().unwrap();
 
-    let mut app = App {
-        idx: 1,
-        ..Default::default()
-    };
+    let mut app = App { idx: 1, ..Default::default() };
     event_loop.run_app_on_demand(&mut app)?;
 
     println!("--------------------------------------------------------- Finished first loop");

examples/util/fill.rs

@@ -15,12 +15,12 @@ pub use platform::fill_window;
 mod platform {
     use std::cell::RefCell;
     use std::collections::HashMap;
+    use std::mem;
     use std::mem::ManuallyDrop;
     use std::num::NonZeroU32;
 
     use softbuffer::{Context, Surface};
-    use winit::window::Window;
-    use winit::window::WindowId;
+    use winit::window::{Window, WindowId};
 
     thread_local! {
         // NOTE: You should never do things like that, create context and drop it before
@@ -34,24 +34,32 @@ mod platform {
     /// The graphics context used to draw to a window.
     struct GraphicsContext {
         /// The global softbuffer context.
-        context: Context,
+        context: RefCell<Context<&'static Window>>,
 
         /// The hash map of window IDs to surfaces.
-        surfaces: HashMap<WindowId, Surface>,
+        surfaces: HashMap<WindowId, Surface<&'static Window, &'static Window>>,
     }
 
     impl GraphicsContext {
         fn new(w: &Window) -> Self {
             Self {
-                context: unsafe { Context::new(w) }.expect("Failed to create a softbuffer context"),
+                context: RefCell::new(
+                    Context::new(unsafe { mem::transmute::<&'_ Window, &'static Window>(w) })
+                        .expect("Failed to create a softbuffer context"),
+                ),
                 surfaces: HashMap::new(),
             }
         }
 
-        fn create_surface(&mut self, window: &Window) -> &mut Surface {
+        fn create_surface(
+            &mut self,
+            window: &Window,
+        ) -> &mut Surface<&'static Window, &'static Window> {
             self.surfaces.entry(window.id()).or_insert_with(|| {
-                unsafe { Surface::new(&self.context, window) }
-                    .expect("Failed to create a softbuffer surface")
+                Surface::new(&self.context.borrow(), unsafe {
+                    mem::transmute::<&'_ Window, &'static Window>(window)
+                })
+                .expect("Failed to create a softbuffer surface")
             })
         }
 
@@ -71,24 +79,17 @@ mod platform {
 
             // 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);
+            let surface =
+                gc.get_or_insert_with(|| GraphicsContext::new(window)).create_surface(window);
 
             // Fill a buffer with a solid color.
-            const DARK_GRAY: u32 = 0xFF181818;
+            const DARK_GRAY: u32 = 0xff181818;
 
-            surface
-                .resize(width, height)
-                .expect("Failed to resize the softbuffer surface");
+            surface.resize(width, height).expect("Failed to resize the softbuffer surface");
 
-            let mut buffer = surface
-                .buffer_mut()
-                .expect("Failed to get the softbuffer buffer");
+            let mut buffer = surface.buffer_mut().expect("Failed to get the softbuffer buffer");
             buffer.fill(DARK_GRAY);
-            buffer
-                .present()
-                .expect("Failed to present the softbuffer buffer");
+            buffer.present().expect("Failed to present the softbuffer buffer");
         })
     }
 

examples/util/tracing.rs

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

examples/window.rs

@@ -2,29 +2,28 @@
 
 use std::collections::HashMap;
 use std::error::Error;
-use std::fmt;
 use std::fmt::Debug;
 #[cfg(not(any(android_platform, ios_platform)))]
 use std::num::NonZeroU32;
-use std::path::Path;
+use std::sync::Arc;
+use std::{fmt, mem};
 
+use ::tracing::{error, info};
 use cursor_icon::CursorIcon;
 #[cfg(not(any(android_platform, ios_platform)))]
-use rwh_05::HasRawDisplayHandle;
+use rwh_06::{DisplayHandle, HasDisplayHandle};
 #[cfg(not(any(android_platform, ios_platform)))]
 use softbuffer::{Context, Surface};
 
 use winit::application::ApplicationHandler;
 use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
-use winit::event::{DeviceEvent, DeviceId, Ime, WindowEvent};
-use winit::event::{MouseButton, MouseScrollDelta};
+use winit::event::{DeviceEvent, DeviceId, Ime, MouseButton, MouseScrollDelta, WindowEvent};
 use winit::event_loop::{ActiveEventLoop, EventLoop};
 use winit::keyboard::{Key, ModifiersState};
 use winit::window::{
     Cursor, CursorGrabMode, CustomCursor, CustomCursorSource, Fullscreen, Icon, ResizeDirection,
-    Theme,
+    Theme, Window, WindowId,
 };
-use winit::window::{Window, WindowId};
 
 #[cfg(macos_platform)]
 use winit::platform::macos::{OptionAsAlt, WindowAttributesExtMacOS, WindowExtMacOS};
@@ -33,11 +32,19 @@ use winit::platform::startup_notify::{
     self, EventLoopExtStartupNotify, WindowAttributesExtStartupNotify, WindowExtStartupNotify,
 };
 
+#[path = "util/tracing.rs"]
+mod tracing;
+
 /// The amount of points to around the window for drag resize direction calculations.
 const BORDER_SIZE: f64 = 20.;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let event_loop = EventLoop::<UserEvent>::with_user_event().build()?;
+    #[cfg(web_platform)]
+    console_error_panic_hook::set_once();
+
+    tracing::init();
+
+    let event_loop = EventLoop::new()?;
     let _event_loop_proxy = event_loop.create_proxy();
 
     // Wire the user event from another thread.
@@ -45,9 +52,9 @@ fn main() -> Result<(), Box<dyn Error>> {
     std::thread::spawn(move || {
         // Wake up the `event_loop` once every second and dispatch a custom event
         // from a different thread.
-        println!("Starting to send user event every second");
+        info!("Starting to send user event every second");
         loop {
-            let _ = _event_loop_proxy.send_event(UserEvent::WakeUp);
+            _event_loop_proxy.wake_up();
             std::thread::sleep(std::time::Duration::from_secs(1));
         }
     });
@@ -57,12 +64,6 @@ fn main() -> Result<(), Box<dyn Error>> {
     event_loop.run_app(&mut state).map_err(Into::into)
 }
 
-#[allow(dead_code)]
-#[derive(Debug, Clone, Copy)]
-enum UserEvent {
-    WakeUp,
-}
-
 /// Application state and event handling.
 struct Application {
     /// Custom cursors assets.
@@ -74,24 +75,30 @@ struct Application {
     ///
     /// With OpenGL it could be EGLDisplay.
     #[cfg(not(any(android_platform, ios_platform)))]
-    context: Option<Context>,
+    context: Option<Context<DisplayHandle<'static>>>,
 }
 
 impl Application {
-    fn new<T>(event_loop: &EventLoop<T>) -> Self {
+    fn new(event_loop: &EventLoop) -> Self {
         // SAFETY: we drop the context right before the event loop is stopped, thus making it safe.
         #[cfg(not(any(android_platform, ios_platform)))]
-        let context = Some(unsafe { Context::from_raw(event_loop.raw_display_handle()).unwrap() });
+        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 we use 32px,
-        // since it seems to work well enough in most cases. Be careful about going too high, or
-        // you'll be bitten by the low-quality downscaling built into the WM.
-        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/data/icon.png");
+        // 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
+        // we use 32px, since it seems to work well enough in most cases. Be careful about
+        // going too high, or you'll be bitten by the low-quality downscaling built into the
+        // WM.
+        let icon = load_icon(include_bytes!("data/icon.png"));
 
-        let icon = load_icon(Path::new(path));
-
-        println!("Loading cursor assets");
+        info!("Loading cursor assets");
         let custom_cursors = vec![
             event_loop.create_custom_cursor(decode_cursor(include_bytes!("data/cross.png"))),
             event_loop.create_custom_cursor(decode_cursor(include_bytes!("data/cross2.png"))),
@@ -123,7 +130,7 @@ impl Application {
         #[cfg(any(x11_platform, wayland_platform))]
         if let Some(token) = event_loop.read_token_from_env() {
             startup_notify::reset_activation_token_env();
-            println!("Using token {:?} to activate a window", token);
+            info!("Using token {:?} to activate a window", token);
             window_attributes = window_attributes.with_activation_token(token);
         }
 
@@ -132,6 +139,12 @@ impl Application {
             window_attributes = window_attributes.with_tabbing_identifier(&tab_id);
         }
 
+        #[cfg(web_platform)]
+        {
+            use winit::platform::web::WindowAttributesExtWebSys;
+            window_attributes = window_attributes.with_append(true);
+        }
+
         let window = event_loop.create_window(window_attributes)?;
 
         #[cfg(ios_platform)]
@@ -140,11 +153,12 @@ impl Application {
             window.recognize_doubletap_gesture(true);
             window.recognize_pinch_gesture(true);
             window.recognize_rotation_gesture(true);
+            window.recognize_pan_gesture(true, 2, 2);
         }
 
         let window_state = WindowState::new(self, window)?;
         let window_id = window_state.window.id();
-        println!("Created new window with id={window_id:?}");
+        info!("Created new window with id={window_id:?}");
         self.windows.insert(window_id, window_state);
         Ok(window_id)
     }
@@ -152,23 +166,23 @@ impl Application {
     fn handle_action(&mut self, event_loop: &ActiveEventLoop, window_id: WindowId, action: Action) {
         // let cursor_position = self.cursor_position;
         let window = self.windows.get_mut(&window_id).unwrap();
-        println!("Executing action: {action:?}");
+        info!("Executing action: {action:?}");
         match action {
             Action::CloseWindow => {
                 let _ = self.windows.remove(&window_id);
-            }
+            },
             Action::CreateNewWindow => {
                 #[cfg(any(x11_platform, wayland_platform))]
                 if let Err(err) = window.window.request_activation_token() {
-                    println!("Failed to get activation token: {err}");
+                    info!("Failed to get activation token: {err}");
                 } else {
                     return;
                 }
 
                 if let Err(err) = self.create_window(event_loop, None) {
-                    eprintln!("Error creating new window: {err}");
+                    error!("Error creating new window: {err}");
                 }
-            }
+            },
             Action::ToggleResizeIncrements => window.toggle_resize_increments(),
             Action::ToggleCursorVisibility => window.toggle_cursor_visibility(),
             Action::ToggleResizable => window.toggle_resizable(),
@@ -179,6 +193,12 @@ impl Application {
             Action::Minimize => window.minimize(),
             Action::NextCursor => window.next_cursor(),
             Action::NextCustomCursor => window.next_custom_cursor(&self.custom_cursors),
+            #[cfg(web_platform)]
+            Action::UrlCustomCursor => window.url_custom_cursor(event_loop),
+            #[cfg(web_platform)]
+            Action::AnimationCustomCursor => {
+                window.animation_custom_cursor(event_loop, &self.custom_cursors)
+            },
             Action::CycleCursorGrab => window.cycle_cursor_grab(),
             Action::DragWindow => window.drag_window(),
             Action::DragResizeWindow => window.drag_resize_window(),
@@ -186,18 +206,25 @@ impl Application {
             Action::PrintHelp => self.print_help(),
             #[cfg(macos_platform)]
             Action::CycleOptionAsAlt => window.cycle_option_as_alt(),
+            Action::SetTheme(theme) => {
+                window.window.set_theme(theme);
+                // Get the resulting current theme to draw with
+                let actual_theme = theme.or_else(|| window.window.theme()).unwrap_or(Theme::Dark);
+                window.set_draw_theme(actual_theme);
+            },
             #[cfg(macos_platform)]
             Action::CreateNewTab => {
                 let tab_id = window.window.tabbing_identifier();
                 if let Err(err) = self.create_window(event_loop, Some(tab_id)) {
-                    eprintln!("Error creating new window: {err}");
+                    error!("Error creating new window: {err}");
                 }
-            }
+            },
+            Action::RequestResize => window.swap_dimensions(),
         }
     }
 
     fn dump_monitors(&self, event_loop: &ActiveEventLoop) {
-        println!("Monitors information");
+        info!("Monitors information");
         let primary_monitor = event_loop.primary_monitor();
         for monitor in event_loop.available_monitors() {
             let intro = if primary_monitor.as_ref() == Some(&monitor) {
@@ -207,60 +234,54 @@ impl Application {
             };
 
             if let Some(name) = monitor.name() {
-                println!("{intro}: {name}");
+                info!("{intro}: {name}");
             } else {
-                println!("{intro}: [no name]");
+                info!("{intro}: [no name]");
             }
 
             let PhysicalSize { width, height } = monitor.size();
-            print!("  Current mode: {width}x{height}");
-            if let Some(m_hz) = monitor.refresh_rate_millihertz() {
-                println!(" @ {}.{} Hz", m_hz / 1000, m_hz % 1000);
-            } else {
-                println!();
-            }
+            info!(
+                "  Current mode: {width}x{height}{}",
+                if let Some(m_hz) = monitor.refresh_rate_millihertz() {
+                    format!(" @ {}.{} Hz", m_hz / 1000, m_hz % 1000)
+                } else {
+                    String::new()
+                }
+            );
 
             let PhysicalPosition { x, y } = monitor.position();
-            println!("  Position: {x},{y}");
+            info!("  Position: {x},{y}");
 
-            println!("  Scale factor: {}", monitor.scale_factor());
+            info!("  Scale factor: {}", monitor.scale_factor());
 
-            println!("  Available modes (width x height x bit-depth):");
+            info!("  Available modes (width x height x bit-depth):");
             for mode in monitor.video_modes() {
                 let PhysicalSize { width, height } = mode.size();
                 let bits = mode.bit_depth();
                 let m_hz = mode.refresh_rate_millihertz();
-                println!(
-                    "    {width}x{height}x{bits} @ {}.{} Hz",
-                    m_hz / 1000,
-                    m_hz % 1000
-                );
+                info!("    {width}x{height}x{bits} @ {}.{} Hz", m_hz / 1000, m_hz % 1000);
             }
         }
     }
 
     /// Process the key binding.
     fn process_key_binding(key: &str, mods: &ModifiersState) -> Option<Action> {
-        KEY_BINDINGS.iter().find_map(|binding| {
-            binding
-                .is_triggered_by(&key, mods)
-                .then_some(binding.action)
-        })
+        KEY_BINDINGS
+            .iter()
+            .find_map(|binding| binding.is_triggered_by(&key, mods).then_some(binding.action))
     }
 
     /// Process mouse binding.
     fn process_mouse_binding(button: MouseButton, mods: &ModifiersState) -> Option<Action> {
-        MOUSE_BINDINGS.iter().find_map(|binding| {
-            binding
-                .is_triggered_by(&button, mods)
-                .then_some(binding.action)
-        })
+        MOUSE_BINDINGS
+            .iter()
+            .find_map(|binding| binding.is_triggered_by(&button, mods).then_some(binding.action))
     }
 
     fn print_help(&self) {
-        println!("Keyboard bindings:");
+        info!("Keyboard bindings:");
         for binding in KEY_BINDINGS {
-            println!(
+            info!(
                 "{}{:<10} - {} ({})",
                 modifiers_to_string(binding.mods),
                 binding.trigger,
@@ -268,9 +289,9 @@ impl Application {
                 binding.action.help(),
             );
         }
-        println!("Mouse bindings:");
+        info!("Mouse bindings:");
         for binding in MOUSE_BINDINGS {
-            println!(
+            info!(
                 "{}{:<10} - {} ({})",
                 modifiers_to_string(binding.mods),
                 mouse_button_to_string(binding.trigger),
@@ -281,9 +302,9 @@ impl Application {
     }
 }
 
-impl ApplicationHandler<UserEvent> for Application {
-    fn user_event(&mut self, _event_loop: &ActiveEventLoop, event: UserEvent) {
-        println!("User event: {event:?}");
+impl ApplicationHandler for Application {
+    fn proxy_wake_up(&mut self, _event_loop: &ActiveEventLoop) {
+        info!("User wake up");
     }
 
     fn window_event(
@@ -300,50 +321,46 @@ impl ApplicationHandler<UserEvent> for Application {
         match event {
             WindowEvent::Resized(size) => {
                 window.resize(size);
-            }
+            },
             WindowEvent::Focused(focused) => {
                 if focused {
-                    println!("Window={window_id:?} fosused");
+                    info!("Window={window_id:?} focused");
                 } else {
-                    println!("Window={window_id:?} unfosused");
-                }
-            }
-            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
-                println!("Window={window_id:?} changed scale to {scale_factor}");
-            }
-            WindowEvent::ThemeChanged(theme) => {
-                println!("Theme changed to {theme:?}");
-                window.set_theme(theme);
-            }
-            WindowEvent::RedrawRequested => {
-                if let Err(err) = window.draw() {
-                    eprintln!("Error drawing window: {err}");
-                }
-            }
-            WindowEvent::Occluded(occluded) => {
-                window.set_occluded(occluded);
-            }
-            WindowEvent::CloseRequested => {
-                println!("Closing Window={window_id:?}");
-                self.windows.remove(&window_id);
-            }
-            WindowEvent::ModifiersChanged(modifiers) => {
-                window.modifiers = modifiers.state();
-                println!("Modifiers changed to {:?}", window.modifiers);
-            }
-            WindowEvent::MouseWheel { delta, .. } => match delta {
-                MouseScrollDelta::LineDelta(x, y) => {
-                    println!("Mouse wheel Line Delta: ({x},{y})");
-                }
-                MouseScrollDelta::PixelDelta(px) => {
-                    println!("Mouse wheel Pixel Delta: ({},{})", px.x, px.y);
+                    info!("Window={window_id:?} unfocused");
                 }
             },
-            WindowEvent::KeyboardInput {
-                event,
-                is_synthetic: false,
-                ..
-            } => {
+            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
+                info!("Window={window_id:?} changed scale to {scale_factor}");
+            },
+            WindowEvent::ThemeChanged(theme) => {
+                info!("Theme changed to {theme:?}");
+                window.set_draw_theme(theme);
+            },
+            WindowEvent::RedrawRequested => {
+                if let Err(err) = window.draw() {
+                    error!("Error drawing window: {err}");
+                }
+            },
+            WindowEvent::Occluded(occluded) => {
+                window.set_occluded(occluded);
+            },
+            WindowEvent::CloseRequested => {
+                info!("Closing Window={window_id:?}");
+                self.windows.remove(&window_id);
+            },
+            WindowEvent::ModifiersChanged(modifiers) => {
+                window.modifiers = modifiers.state();
+                info!("Modifiers changed to {:?}", window.modifiers);
+            },
+            WindowEvent::MouseWheel { delta, .. } => match delta {
+                MouseScrollDelta::LineDelta(x, y) => {
+                    info!("Mouse wheel Line Delta: ({x},{y})");
+                },
+                MouseScrollDelta::PixelDelta(px) => {
+                    info!("Mouse wheel Pixel Delta: ({},{})", px.x, px.y);
+                },
+            },
+            WindowEvent::KeyboardInput { event, is_synthetic: false, .. } => {
                 let mods = window.modifiers;
 
                 // Dispatch actions only on press.
@@ -358,65 +375,68 @@ impl ApplicationHandler<UserEvent> for Application {
                         self.handle_action(event_loop, window_id, action);
                     }
                 }
-            }
+            },
             WindowEvent::MouseInput { button, state, .. } => {
                 let mods = window.modifiers;
-                if let Some(action) = state
-                    .is_pressed()
-                    .then(|| Self::process_mouse_binding(button, &mods))
-                    .flatten()
+                if let Some(action) =
+                    state.is_pressed().then(|| Self::process_mouse_binding(button, &mods)).flatten()
                 {
                     self.handle_action(event_loop, window_id, action);
                 }
-            }
+            },
             WindowEvent::CursorLeft { .. } => {
-                println!("Cursor left Window={window_id:?}");
+                info!("Cursor left Window={window_id:?}");
                 window.cursor_left();
-            }
+            },
             WindowEvent::CursorMoved { position, .. } => {
-                println!("Moved cursor to {position:?}");
+                info!("Moved cursor to {position:?}");
                 window.cursor_moved(position);
-            }
+            },
             WindowEvent::ActivationTokenDone { token: _token, .. } => {
                 #[cfg(any(x11_platform, wayland_platform))]
                 {
                     startup_notify::set_activation_token_env(_token);
                     if let Err(err) = self.create_window(event_loop, None) {
-                        eprintln!("Error creating new window: {err}");
+                        error!("Error creating new window: {err}");
                     }
                 }
-            }
+            },
             WindowEvent::Ime(event) => match event {
-                Ime::Enabled => println!("IME enabled for Window={window_id:?}"),
+                Ime::Enabled => info!("IME enabled for Window={window_id:?}"),
                 Ime::Preedit(text, caret_pos) => {
-                    println!("Preedit: {}, with caret at {:?}", text, caret_pos);
-                }
+                    info!("Preedit: {}, with caret at {:?}", text, caret_pos);
+                },
                 Ime::Commit(text) => {
-                    println!("Committed: {}", text);
-                }
-                Ime::Disabled => println!("IME disabled for Window={window_id:?}"),
+                    info!("Committed: {}", text);
+                },
+                Ime::Disabled => info!("IME disabled for Window={window_id:?}"),
             },
             WindowEvent::PinchGesture { delta, .. } => {
                 window.zoom += delta;
                 let zoom = window.zoom;
                 if delta > 0.0 {
-                    println!("Zoomed in {delta:.5} (now: {zoom:.5})");
+                    info!("Zoomed in {delta:.5} (now: {zoom:.5})");
                 } else {
-                    println!("Zoomed out {delta:.5} (now: {zoom:.5})");
+                    info!("Zoomed out {delta:.5} (now: {zoom:.5})");
                 }
-            }
+            },
             WindowEvent::RotationGesture { delta, .. } => {
                 window.rotated += delta;
                 let rotated = window.rotated;
                 if delta > 0.0 {
-                    println!("Rotated counterclockwise {delta:.5} (now: {rotated:.5})");
+                    info!("Rotated counterclockwise {delta:.5} (now: {rotated:.5})");
                 } else {
-                    println!("Rotated clockwise {delta:.5} (now: {rotated:.5})");
+                    info!("Rotated clockwise {delta:.5} (now: {rotated:.5})");
                 }
-            }
+            },
+            WindowEvent::PanGesture { delta, phase, .. } => {
+                window.panned.x += delta.x;
+                window.panned.y += delta.y;
+                info!("Panned ({delta:?})) (now: {:?}), {phase:?}", window.panned);
+            },
             WindowEvent::DoubleTapGesture { .. } => {
-                println!("Smart zoom");
-            }
+                info!("Smart zoom");
+            },
             WindowEvent::TouchpadPressure { .. }
             | WindowEvent::HoveredFileCancelled
             | WindowEvent::KeyboardInput { .. }
@@ -436,23 +456,22 @@ impl ApplicationHandler<UserEvent> for Application {
         device_id: DeviceId,
         event: DeviceEvent,
     ) {
-        println!("Device {device_id:?} event: {event:?}");
+        info!("Device {device_id:?} event: {event:?}");
     }
 
     fn resumed(&mut self, event_loop: &ActiveEventLoop) {
-        println!("Resumed the event loop");
+        info!("Resumed the event loop");
         self.dump_monitors(event_loop);
 
         // Create initial window.
-        self.create_window(event_loop, None)
-            .expect("failed to create initial window");
+        self.create_window(event_loop, None).expect("failed to create initial window");
 
         self.print_help();
     }
 
     fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
         if self.windows.is_empty() {
-            println!("No windows left, exiting...");
+            info!("No windows left, exiting...");
             event_loop.exit();
         }
     }
@@ -472,9 +491,9 @@ struct WindowState {
     ///
     /// NOTE: This surface must be dropped before the `Window`.
     #[cfg(not(any(android_platform, ios_platform)))]
-    surface: Surface,
+    surface: Surface<DisplayHandle<'static>, Arc<Window>>,
     /// The actual winit Window.
-    window: Window,
+    window: Arc<Window>,
     /// The window theme we're drawing with.
     theme: Theme,
     /// Cursor position over the window.
@@ -489,6 +508,8 @@ struct WindowState {
     zoom: f64,
     /// The amount of rotation of the window.
     rotated: f32,
+    /// The amount of pan of the window.
+    panned: PhysicalPosition<f32>,
 
     #[cfg(macos_platform)]
     option_as_alt: OptionAsAlt,
@@ -501,13 +522,15 @@ struct WindowState {
 
 impl WindowState {
     fn new(app: &Application, window: Window) -> Result<Self, Box<dyn Error>> {
+        let window = Arc::new(window);
+
         // SAFETY: the surface is dropped before the `window` which provided it with handle, thus
         // it doesn't outlive it.
         #[cfg(not(any(android_platform, ios_platform)))]
-        let surface = unsafe { Surface::new(app.context.as_ref().unwrap(), &window)? };
+        let surface = Surface::new(app.context.as_ref().unwrap(), Arc::clone(&window))?;
 
         let theme = window.theme().unwrap_or(Theme::Dark);
-        println!("Theme: {theme:?}");
+        info!("Theme: {theme:?}");
         let named_idx = 0;
         window.set_cursor(CURSORS[named_idx]);
 
@@ -532,6 +555,7 @@ impl WindowState {
             modifiers: Default::default(),
             occluded: Default::default(),
             rotated: Default::default(),
+            panned: Default::default(),
             zoom: Default::default(),
         };
 
@@ -543,8 +567,7 @@ impl WindowState {
         self.ime = !self.ime;
         self.window.set_ime_allowed(self.ime);
         if let Some(position) = self.ime.then_some(self.cursor_position).flatten() {
-            self.window
-                .set_ime_cursor_area(position, PhysicalSize::new(20, 20));
+            self.window.set_ime_cursor_area(position, PhysicalSize::new(20, 20));
         }
     }
 
@@ -555,8 +578,7 @@ impl WindowState {
     pub fn cursor_moved(&mut self, position: PhysicalPosition<f64>) {
         self.cursor_position = Some(position);
         if self.ime {
-            self.window
-                .set_ime_cursor_area(position, PhysicalSize::new(20, 20));
+            self.window.set_ime_cursor_area(position, PhysicalSize::new(20, 20));
         }
     }
 
@@ -594,7 +616,7 @@ impl WindowState {
             Some(_) => None,
             None => Some(LogicalSize::new(25.0, 25.0)),
         };
-        println!("Had increments: {}", new_increments.is_none());
+        info!("Had increments: {}", new_increments.is_none());
         self.window.set_resize_increments(new_increments);
     }
 
@@ -616,9 +638,9 @@ impl WindowState {
             CursorGrabMode::Confined => CursorGrabMode::Locked,
             CursorGrabMode::Locked => CursorGrabMode::None,
         };
-        println!("Changing cursor grab mode to {:?}", self.cursor_grab);
+        info!("Changing cursor grab mode to {:?}", self.cursor_grab);
         if let Err(err) = self.window.set_cursor_grab(self.cursor_grab) {
-            eprintln!("Error setting cursor grab: {err}");
+            error!("Error setting cursor grab: {err}");
         }
     }
 
@@ -630,16 +652,34 @@ impl WindowState {
             OptionAsAlt::OnlyRight => OptionAsAlt::Both,
             OptionAsAlt::Both => OptionAsAlt::None,
         };
-        println!("Setting option as alt {:?}", self.option_as_alt);
+        info!("Setting option as alt {:?}", self.option_as_alt);
         self.window.set_option_as_alt(self.option_as_alt);
     }
 
+    /// Swap the window dimensions with `request_inner_size`.
+    fn swap_dimensions(&mut self) {
+        let old_inner_size = self.window.inner_size();
+        let mut inner_size = old_inner_size;
+
+        mem::swap(&mut inner_size.width, &mut inner_size.height);
+        info!("Requesting resize from {old_inner_size:?} to {inner_size:?}");
+
+        if let Some(new_inner_size) = self.window.request_inner_size(inner_size) {
+            if old_inner_size == new_inner_size {
+                info!("Inner size change got ignored");
+            } else {
+                self.resize(new_inner_size);
+            }
+        } else {
+            info!("Request inner size is asynchronous");
+        }
+    }
+
     /// Pick the next cursor.
     fn next_cursor(&mut self) {
         self.named_idx = (self.named_idx + 1) % CURSORS.len();
-        println!("Setting cursor to \"{:?}\"", CURSORS[self.named_idx]);
-        self.window
-            .set_cursor(Cursor::Icon(CURSORS[self.named_idx]));
+        info!("Setting cursor to \"{:?}\"", CURSORS[self.named_idx]);
+        self.window.set_cursor(Cursor::Icon(CURSORS[self.named_idx]));
     }
 
     /// Pick the next custom cursor.
@@ -649,24 +689,52 @@ impl WindowState {
         self.window.set_cursor(cursor);
     }
 
+    /// Custom cursor from an URL.
+    #[cfg(web_platform)]
+    fn url_custom_cursor(&mut self, event_loop: &ActiveEventLoop) {
+        let cursor = event_loop.create_custom_cursor(url_custom_cursor());
+
+        self.window.set_cursor(cursor);
+    }
+
+    /// Custom cursor from a URL.
+    #[cfg(web_platform)]
+    fn animation_custom_cursor(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        custom_cursors: &[CustomCursor],
+    ) {
+        use std::time::Duration;
+        use winit::platform::web::CustomCursorExtWebSys;
+
+        let cursors = vec![
+            custom_cursors[0].clone(),
+            custom_cursors[1].clone(),
+            event_loop.create_custom_cursor(url_custom_cursor()),
+        ];
+        let cursor = CustomCursor::from_animation(Duration::from_secs(3), cursors).unwrap();
+        let cursor = event_loop.create_custom_cursor(cursor);
+
+        self.window.set_cursor(cursor);
+    }
+
     /// Resize the window to the new size.
-    fn resize(&mut self, _size: PhysicalSize<u32>) {
+    fn resize(&mut self, size: PhysicalSize<u32>) {
+        info!("Resized to {size:?}");
         #[cfg(not(any(android_platform, ios_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");
+            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();
     }
 
-    /// Change the theme.
-    fn set_theme(&mut self, theme: Theme) {
+    /// Change the theme that things are drawn in.
+    fn set_draw_theme(&mut self, theme: Theme) {
         self.theme = theme;
         self.window.request_redraw();
     }
@@ -681,9 +749,9 @@ impl WindowState {
     /// Drag the window.
     fn drag_window(&self) {
         if let Err(err) = self.window.drag_window() {
-            println!("Error starting window drag: {err}");
+            info!("Error starting window drag: {err}");
         } else {
-            println!("Dragging window Window={:?}", self.window.id());
+            info!("Dragging window Window={:?}", self.window.id());
         }
     }
 
@@ -692,9 +760,9 @@ impl WindowState {
         let position = match self.cursor_position {
             Some(position) => position,
             None => {
-                println!("Drag-resize requires cursor to be inside the window");
+                info!("Drag-resize requires cursor to be inside the window");
                 return;
-            }
+            },
         };
 
         let win_size = self.window.inner_size();
@@ -731,9 +799,9 @@ impl WindowState {
         };
 
         if let Err(err) = self.window.drag_resize_window(direction) {
-            println!("Error starting window drag-resize: {err}");
+            info!("Error starting window drag-resize: {err}");
         } else {
-            println!("Drag-resizing window Window={:?}", self.window.id());
+            info!("Drag-resizing window Window={:?}", self.window.id());
         }
     }
 
@@ -749,12 +817,12 @@ impl WindowState {
     #[cfg(not(any(android_platform, ios_platform)))]
     fn draw(&mut self) -> Result<(), Box<dyn Error>> {
         if self.occluded {
-            println!("Skipping drawing occluded window={:?}", self.window.id());
+            info!("Skipping drawing occluded window={:?}", self.window.id());
             return Ok(());
         }
 
-        const WHITE: u32 = 0xFFFFFFFF;
-        const DARK_GRAY: u32 = 0xFF181818;
+        const WHITE: u32 = 0xffffffff;
+        const DARK_GRAY: u32 = 0xff181818;
 
         let color = match self.theme {
             Theme::Light => WHITE,
@@ -770,7 +838,7 @@ impl WindowState {
 
     #[cfg(any(android_platform, ios_platform))]
     fn draw(&mut self) -> Result<(), Box<dyn Error>> {
-        println!("Drawing but without rendering...");
+        info!("Drawing but without rendering...");
         Ok(())
     }
 }
@@ -783,11 +851,7 @@ struct Binding<T: Eq> {
 
 impl<T: Eq> Binding<T> {
     const fn new(trigger: T, mods: ModifiersState, action: Action) -> Self {
-        Self {
-            trigger,
-            mods,
-            action,
-        }
+        Self { trigger, mods, action }
     }
 
     fn is_triggered_by(&self, trigger: &T, mods: &ModifiersState) -> bool {
@@ -809,6 +873,10 @@ enum Action {
     Minimize,
     NextCursor,
     NextCustomCursor,
+    #[cfg(web_platform)]
+    UrlCustomCursor,
+    #[cfg(web_platform)]
+    AnimationCustomCursor,
     CycleCursorGrab,
     PrintHelp,
     DragWindow,
@@ -816,8 +884,10 @@ enum Action {
     ShowWindowMenu,
     #[cfg(macos_platform)]
     CycleOptionAsAlt,
+    SetTheme(Option<Theme>),
     #[cfg(macos_platform)]
     CreateNewTab,
+    RequestResize,
 }
 
 impl Action {
@@ -835,6 +905,10 @@ impl Action {
             Action::ToggleResizeIncrements => "Use resize increments when resizing window",
             Action::NextCursor => "Advance the cursor to the next value",
             Action::NextCustomCursor => "Advance custom cursor to the next value",
+            #[cfg(web_platform)]
+            Action::UrlCustomCursor => "Custom cursor from an URL",
+            #[cfg(web_platform)]
+            Action::AnimationCustomCursor => "Custom cursor from an animation",
             Action::CycleCursorGrab => "Cycle through cursor grab mode",
             Action::PrintHelp => "Print help",
             Action::DragWindow => "Start window drag",
@@ -842,8 +916,12 @@ impl Action {
             Action::ShowWindowMenu => "Show window menu",
             #[cfg(macos_platform)]
             Action::CycleOptionAsAlt => "Cycle option as alt mode",
+            Action::SetTheme(None) => "Change to the system theme",
+            Action::SetTheme(Some(Theme::Light)) => "Change to a light theme",
+            Action::SetTheme(Some(Theme::Dark)) => "Change to a dark theme",
             #[cfg(macos_platform)]
             Action::CreateNewTab => "Create new tab",
+            Action::RequestResize => "Request a resize",
         }
     }
 }
@@ -862,11 +940,24 @@ fn decode_cursor(bytes: &[u8]) -> CustomCursorSource {
     CustomCursor::from_rgba(samples.samples, w, h, w / 2, h / 2).unwrap()
 }
 
-fn load_icon(path: &Path) -> Icon {
+#[cfg(web_platform)]
+fn url_custom_cursor() -> CustomCursorSource {
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    use winit::platform::web::CustomCursorExtWebSys;
+
+    static URL_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+    CustomCursor::from_url(
+        format!("https://picsum.photos/128?random={}", URL_COUNTER.fetch_add(1, Ordering::Relaxed)),
+        64,
+        64,
+    )
+}
+
+fn load_icon(bytes: &[u8]) -> Icon {
     let (icon_rgba, icon_width, icon_height) = {
-        let image = image::open(path)
-            .expect("Failed to open icon path")
-            .into_rgba8();
+        let image = image::load_from_memory(bytes).unwrap().into_rgba8();
         let (width, height) = image.dimensions();
         let rgba = image.into_raw();
         (rgba, width, height)
@@ -950,6 +1041,7 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
     Binding::new("L", ModifiersState::CONTROL, Action::CycleCursorGrab),
     Binding::new("P", ModifiersState::CONTROL, Action::ToggleResizeIncrements),
     Binding::new("R", ModifiersState::CONTROL, Action::ToggleResizable),
+    Binding::new("R", ModifiersState::ALT, Action::RequestResize),
     // M.
     Binding::new("M", ModifiersState::CONTROL, Action::ToggleMaximize),
     Binding::new("M", ModifiersState::ALT, Action::Minimize),
@@ -958,7 +1050,23 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
     // C.
     Binding::new("C", ModifiersState::CONTROL, Action::NextCursor),
     Binding::new("C", ModifiersState::ALT, Action::NextCustomCursor),
+    #[cfg(web_platform)]
+    Binding::new(
+        "C",
+        ModifiersState::CONTROL.union(ModifiersState::SHIFT),
+        Action::UrlCustomCursor,
+    ),
+    #[cfg(web_platform)]
+    Binding::new(
+        "C",
+        ModifiersState::ALT.union(ModifiersState::SHIFT),
+        Action::AnimationCustomCursor,
+    ),
     Binding::new("Z", ModifiersState::CONTROL, Action::ToggleCursorVisibility),
+    // K.
+    Binding::new("K", ModifiersState::empty(), Action::SetTheme(None)),
+    Binding::new("K", ModifiersState::SUPER, Action::SetTheme(Some(Theme::Light))),
+    Binding::new("K", ModifiersState::CONTROL, Action::SetTheme(Some(Theme::Dark))),
     #[cfg(macos_platform)]
     Binding::new("T", ModifiersState::SUPER, Action::CreateNewTab),
     #[cfg(macos_platform)]
@@ -966,19 +1074,7 @@ const KEY_BINDINGS: &[Binding<&'static str>] = &[
 ];
 
 const MOUSE_BINDINGS: &[Binding<MouseButton>] = &[
-    Binding::new(
-        MouseButton::Left,
-        ModifiersState::ALT,
-        Action::DragResizeWindow,
-    ),
-    Binding::new(
-        MouseButton::Left,
-        ModifiersState::CONTROL,
-        Action::DragWindow,
-    ),
-    Binding::new(
-        MouseButton::Right,
-        ModifiersState::CONTROL,
-        Action::ShowWindowMenu,
-    ),
+    Binding::new(MouseButton::Left, ModifiersState::ALT, Action::DragResizeWindow),
+    Binding::new(MouseButton::Left, ModifiersState::CONTROL, Action::DragWindow),
+    Binding::new(MouseButton::Right, ModifiersState::CONTROL, Action::ShowWindowMenu),
 ];

examples/x11_embed.rs

@@ -39,7 +39,7 @@ fn main() -> Result<(), Box<dyn Error>> {
                 WindowEvent::RedrawRequested => {
                     window.pre_present_notify();
                     fill::fill_window(window);
-                }
+                },
                 _ => (),
             }
         }
@@ -58,10 +58,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     tracing_subscriber::fmt::init();
     let event_loop = EventLoop::new()?;
 
-    let mut app = XEmbedDemo {
-        parent_window_id,
-        window: None,
-    };
+    let mut app = XEmbedDemo { parent_window_id, window: None };
     event_loop.run_app(&mut app).map_err(Into::into)
 }
 

run-wasm/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "run-wasm"
-version = "0.1.0"
-rust-version.workspace = true
-repository.workspace = true
-license.workspace = true
-edition.workspace = true
-publish = false
-
-[dependencies]
-cargo-run-wasm = "0.2.0"

run-wasm/src/main.rs

@@ -1,3 +0,0 @@
-fn main() {
-    cargo_run_wasm::run_wasm_with_css("body { margin: 0px; }");
-}

rustfmt.toml

@@ -1,3 +1,19 @@
-force_explicit_abi=true
-use_field_init_shorthand=true
-# merge_imports=true
+format_code_in_doc_comments = true
+match_block_trailing_comma = true
+condense_wildcard_suffixes = true
+use_field_init_shorthand = true
+normalize_doc_attributes = true
+overflow_delimited_expr = true
+imports_granularity = "Module"
+use_small_heuristics = "Max"
+format_macro_matchers = true
+error_on_unformatted = true
+format_macro_bodies = true
+hex_literal_case = "Lower"
+normalize_comments = true
+# Some macros break with this.
+reorder_impl_items = false
+newline_style = "Unix"
+format_strings = true
+wrap_comments = true
+comment_width = 100

src/application.rs

@@ -5,13 +5,13 @@ use crate::event_loop::ActiveEventLoop;
 use crate::window::WindowId;
 
 /// The handler of the application events.
-pub trait ApplicationHandler<T: 'static = ()> {
+pub trait ApplicationHandler {
     /// Emitted when new events arrive from the OS to be processed.
     ///
     /// This is a useful place to put code that should be done before you start processing
     /// events, such as updating frame timing information for benchmarking or checking the
     /// [`StartCause`] to see if a timer set by
-    /// [`ControlFlow::WaitUntil`](crate::event_loop::ControlFlow::WaitUntil) has elapsed.
+    /// [`ControlFlow::WaitUntil`][crate::event_loop::ControlFlow::WaitUntil] has elapsed.
     fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
         let _ = (event_loop, cause);
     }
@@ -20,8 +20,8 @@ pub trait ApplicationHandler<T: 'static = ()> {
     ///
     /// For consistency, all platforms emit a `Resumed` event even if they don't themselves have a
     /// formal suspend/resume lifecycle. For systems without a formal suspend/resume lifecycle
-    /// the `Resumed` event is always emitted after the [`NewEvents(StartCause::Init)`][StartCause::Init]
-    /// event.
+    /// the `Resumed` event is always emitted after the
+    /// [`NewEvents(StartCause::Init)`][StartCause::Init] event.
     ///
     /// # Portability
     ///
@@ -33,15 +33,16 @@ pub trait ApplicationHandler<T: 'static = ()> {
     /// Considering that the implementation of [`Suspended`] and `Resumed` events may be internally
     /// driven by multiple platform-specific events, and that there may be subtle differences across
     /// platforms with how these internal events are delivered, it's recommended that applications
-    /// be able to gracefully handle redundant (i.e. back-to-back) [`Suspended`] or `Resumed` events.
+    /// be able to gracefully handle redundant (i.e. back-to-back) [`Suspended`] or `Resumed`
+    /// events.
     ///
     /// Also see [`Suspended`] notes.
     ///
     /// ## Android
     ///
     /// On Android, the `Resumed` event is sent when a new [`SurfaceView`] has been created. This is
-    /// expected to closely correlate with the [`onResume`] lifecycle event but there may technically
-    /// be a discrepancy.
+    /// expected to closely correlate with the [`onResume`] lifecycle event but there may
+    /// technically be a discrepancy.
     ///
     /// [`onResume`]: https://developer.android.com/reference/android/app/Activity#onResume()
     ///
@@ -81,11 +82,95 @@ pub trait ApplicationHandler<T: 'static = ()> {
     /// [`Suspended`]: Self::suspended
     fn resumed(&mut self, event_loop: &ActiveEventLoop);
 
-    /// Emitted when an event is sent from [`EventLoopProxy::send_event`].
+    /// Called after a wake up is requested using [`EventLoopProxy::wake_up()`].
     ///
-    /// [`EventLoopProxy::send_event`]: crate::event_loop::EventLoopProxy::send_event
-    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: T) {
-        let _ = (event_loop, event);
+    /// Multiple calls to the aforementioned method will be merged, and will only wake the event
+    /// loop once; however, due to the nature of multi-threading some wake ups may appear
+    /// spuriously. For these reasons, you should not rely on the number of times that this was
+    /// called.
+    ///
+    /// The order in which this is emitted in relation to other events is not guaranteed. The time
+    /// at which this will be emitted is not guaranteed, only that it will happen "soon". That is,
+    /// there may be several executions of the event loop, including multiple redraws to windows,
+    /// between [`EventLoopProxy::wake_up()`] being called and the event being delivered.
+    ///
+    /// [`EventLoopProxy::wake_up()`]: crate::event_loop::EventLoopProxy::wake_up
+    ///
+    /// # Example
+    ///
+    /// Use a [`std::sync::mpsc`] channel to handle events from a different thread.
+    ///
+    /// ```no_run
+    /// use std::sync::mpsc;
+    /// use std::thread;
+    /// use std::time::Duration;
+    ///
+    /// use winit::application::ApplicationHandler;
+    /// use winit::event_loop::{ActiveEventLoop, EventLoop};
+    ///
+    /// struct MyApp {
+    ///     receiver: mpsc::Receiver<u64>,
+    /// }
+    ///
+    /// impl ApplicationHandler for MyApp {
+    ///     # fn window_event(
+    ///     #     &mut self,
+    ///     #     _event_loop: &ActiveEventLoop,
+    ///     #     _window_id: winit::window::WindowId,
+    ///     #     _event: winit::event::WindowEvent,
+    ///     # ) {
+    ///     # }
+    ///     #
+    ///     # fn resumed(&mut self, _event_loop: &ActiveEventLoop) {}
+    ///     #
+    ///     fn proxy_wake_up(&mut self, _event_loop: &ActiveEventLoop) {
+    ///         // Iterate current events, since wake-ups may have been merged.
+    ///         //
+    ///         // Note: We take care not to use `recv` or `iter` here, as those are blocking,
+    ///         // and that would be bad for performance and might lead to a deadlock.
+    ///         for i in self.receiver.try_iter() {
+    ///             println!("received: {i}");
+    ///         }
+    ///     }
+    ///
+    ///     // Rest of `ApplicationHandler`
+    /// }
+    ///
+    /// fn main() -> Result<(), Box<dyn std::error::Error>> {
+    ///     let event_loop = EventLoop::new()?;
+    ///
+    ///     let (sender, receiver) = mpsc::channel();
+    ///
+    ///     let mut app = MyApp { receiver };
+    ///
+    ///     // Send an event in a loop
+    ///     let proxy = event_loop.create_proxy();
+    ///     let background_thread = thread::spawn(move || {
+    ///         let mut i = 0;
+    ///         loop {
+    ///             println!("sending: {i}");
+    ///             if sender.send(i).is_err() {
+    ///                 // Stop sending once `MyApp` is dropped
+    ///                 break;
+    ///             }
+    ///             // Trigger the wake-up _after_ we placed the event in the channel.
+    ///             // Otherwise, `proxy_wake_up` might be triggered prematurely.
+    ///             proxy.wake_up();
+    ///             i += 1;
+    ///             thread::sleep(Duration::from_secs(1));
+    ///         }
+    ///     });
+    ///
+    ///     event_loop.run_app(&mut app)?;
+    ///
+    ///     drop(app);
+    ///     background_thread.join().unwrap();
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    fn proxy_wake_up(&mut self, event_loop: &ActiveEventLoop) {
+        let _ = event_loop;
     }
 
     /// Emitted when the OS sends an event to a winit window.
@@ -109,7 +194,8 @@ pub trait ApplicationHandler<T: 'static = ()> {
     /// Emitted when the event loop is about to block and wait for new events.
     ///
     /// Most applications shouldn't need to hook into this event since there is no real relationship
-    /// between how often the event loop needs to wake up and the dispatching of any specific events.
+    /// between how often the event loop needs to wake up and the dispatching of any specific
+    /// events.
     ///
     /// High frequency event sources, such as input devices could potentially lead to lots of wake
     /// ups and also lots of corresponding `AboutToWait` events.
@@ -133,7 +219,8 @@ pub trait ApplicationHandler<T: 'static = ()> {
     /// Considering that the implementation of `Suspended` and [`Resumed`] events may be internally
     /// driven by multiple platform-specific events, and that there may be subtle differences across
     /// platforms with how these internal events are delivered, it's recommended that applications
-    /// be able to gracefully handle redundant (i.e. back-to-back) `Suspended` or [`Resumed`] events.
+    /// be able to gracefully handle redundant (i.e. back-to-back) `Suspended` or [`Resumed`]
+    /// events.
     ///
     /// Also see [`Resumed`] notes.
     ///
@@ -150,7 +237,8 @@ pub trait ApplicationHandler<T: 'static = ()> {
     /// created outside of Winit (such as an `EGLSurface`, [`VkSurfaceKHR`] or [`wgpu::Surface`]).
     ///
     /// After being `Suspended` on Android applications must drop all render surfaces before
-    /// the event callback completes, which may be re-created when the application is next [`Resumed`].
+    /// the event callback completes, which may be re-created when the application is next
+    /// [`Resumed`].
     ///
     /// [`SurfaceView`]: https://developer.android.com/reference/android/view/SurfaceView
     /// [Activity lifecycle]: https://developer.android.com/guide/components/activities/activity-lifecycle
@@ -186,7 +274,7 @@ pub trait ApplicationHandler<T: 'static = ()> {
     /// Emitted when the event loop is being shut down.
     ///
     /// This is irreversible - if this method is called, it is guaranteed that the event loop
-    /// will exist right after.
+    /// will exit right after.
     fn exiting(&mut self, event_loop: &ActiveEventLoop) {
         let _ = event_loop;
     }
@@ -197,17 +285,17 @@ pub trait ApplicationHandler<T: 'static = ()> {
     ///
     /// ### Android
     ///
-    /// On Android, the `MemoryWarning` event is sent when [`onLowMemory`] was called. The application
-    /// must [release memory] or risk being killed.
+    /// On Android, the `MemoryWarning` event is sent when [`onLowMemory`] was called. The
+    /// application must [release memory] or risk being killed.
     ///
     /// [`onLowMemory`]: https://developer.android.com/reference/android/app/Application.html#onLowMemory()
     /// [release memory]: https://developer.android.com/topic/performance/memory#release
     ///
     /// ### iOS
     ///
-    /// On iOS, the `MemoryWarning` event is emitted in response to an [`applicationDidReceiveMemoryWarning`]
-    /// callback. The application must free as much memory as possible or risk being terminated, see
-    /// [how to respond to memory warnings].
+    /// On iOS, the `MemoryWarning` event is emitted in response to an
+    /// [`applicationDidReceiveMemoryWarning`] callback. The application must free as much
+    /// memory as possible or risk being terminated, see [how to respond to memory warnings].
     ///
     /// [`applicationDidReceiveMemoryWarning`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1623063-applicationdidreceivememorywarni
     /// [how to respond to memory warnings]: https://developer.apple.com/documentation/uikit/app_and_environment/managing_your_app_s_life_cycle/responding_to_memory_warnings
@@ -219,3 +307,117 @@ pub trait ApplicationHandler<T: 'static = ()> {
         let _ = event_loop;
     }
 }
+
+impl<A: ?Sized + ApplicationHandler> ApplicationHandler for &mut A {
+    #[inline]
+    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
+        (**self).new_events(event_loop, cause);
+    }
+
+    #[inline]
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).resumed(event_loop);
+    }
+
+    #[inline]
+    fn proxy_wake_up(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).proxy_wake_up(event_loop);
+    }
+
+    #[inline]
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        (**self).window_event(event_loop, window_id, event);
+    }
+
+    #[inline]
+    fn device_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        device_id: DeviceId,
+        event: DeviceEvent,
+    ) {
+        (**self).device_event(event_loop, device_id, event);
+    }
+
+    #[inline]
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).about_to_wait(event_loop);
+    }
+
+    #[inline]
+    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).suspended(event_loop);
+    }
+
+    #[inline]
+    fn exiting(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).exiting(event_loop);
+    }
+
+    #[inline]
+    fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).memory_warning(event_loop);
+    }
+}
+
+impl<A: ?Sized + ApplicationHandler> ApplicationHandler for Box<A> {
+    #[inline]
+    fn new_events(&mut self, event_loop: &ActiveEventLoop, cause: StartCause) {
+        (**self).new_events(event_loop, cause);
+    }
+
+    #[inline]
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).resumed(event_loop);
+    }
+
+    #[inline]
+    fn proxy_wake_up(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).proxy_wake_up(event_loop);
+    }
+
+    #[inline]
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        event: WindowEvent,
+    ) {
+        (**self).window_event(event_loop, window_id, event);
+    }
+
+    #[inline]
+    fn device_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        device_id: DeviceId,
+        event: DeviceEvent,
+    ) {
+        (**self).device_event(event_loop, device_id, event);
+    }
+
+    #[inline]
+    fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).about_to_wait(event_loop);
+    }
+
+    #[inline]
+    fn suspended(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).suspended(event_loop);
+    }
+
+    #[inline]
+    fn exiting(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).exiting(event_loop);
+    }
+
+    #[inline]
+    fn memory_warning(&mut self, event_loop: &ActiveEventLoop) {
+        (**self).memory_warning(event_loop);
+    }
+}

src/changelog/mod.rs

@@ -2,11 +2,13 @@
 //!
 //! All notable changes to this project will be documented in this module,
 //! along with migration instructions for larger changes.
-//!
 // Put the current entry at the top of this page, for discoverability.
 // See `.cargo/config.toml` for details about `unreleased_changelogs`.
 #![cfg_attr(unreleased_changelogs, doc = include_str!("unreleased.md"))]
-#![cfg_attr(not(unreleased_changelogs), doc = include_str!("v0.29.md"))]
+#![cfg_attr(not(unreleased_changelogs), doc = include_str!("v0.30.md"))]
+
+#[doc = include_str!("v0.30.md")]
+pub mod v0_30 {}
 
 #[doc = include_str!("v0.29.md")]
 pub mod v0_29 {}

src/changelog/unreleased.md

@@ -1,42 +1,65 @@
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+The sections should follow the order `Added`, `Changed`, `Deprecated`,
+`Removed`, and `Fixed`.
+
+Platform specific changed should be added to the end of the section and grouped
+by platform name. Common API additions should have `, implemented` at the end
+for platforms where the API was initially implemented. See the following example
+on how to add them:
+
+```md
+### Added
+
+- Add `Window::turbo()`, implemented on X11, Wayland, and Web.
+- On X11, add `Window::some_rare_api`.
+- On X11, add `Window::even_more_rare_api`.
+- On Wayland, add `Window::common_api`.
+- On Windows, add `Window::some_rare_api`.
+```
+
+When the change requires non-trivial amount of work for users to comply
+with it, the migration guide should be added below the entry, like:
+
+```md
+- Deprecate `Window` creation outside of `EventLoop::run`
+
+  This was done to simply migration in the future. Consider the
+  following code:
+
+  // Code snippet.
+
+  To migrate it we should do X, Y, and then Z, for example:
+
+  // Code snippet.
+
+```
+
+The migration guide could reference other migration examples in the current
+changelog entry.
+
 ## Unreleased
 
-- Deprecate `EventLoop::run` in favor of `EventLoop::run_app`.
-- Deprecate `EventLoopExtRunOnDemand::run_on_demand` in favor of `EventLoop::run_app_on_demand`.
-- Deprecate `EventLoopExtPumpEvents::pump_events` in favor of `EventLoopExtPumpEvents::pump_app_events`.
-- Add `ApplicationHandler<T>` trait which mimics `Event<T>`.
-- Move `dpi` types to its own crate, and re-export it from the root crate.
-- Implement `Sync` for `EventLoopProxy<T: Send>`.
-- **Breaking:** Move `Window::new` to `ActiveEventLoop::create_window` and `EventLoop::create_window` (with the latter being deprecated).
-- **Breaking:** Rename `EventLoopWindowTarget` to `ActiveEventLoop`.
-- **Breaking:** Remove `Deref` implementation for `EventLoop` that gave `EventLoopWindowTarget`.
-- **Breaking**: Remove `WindowBuilder` in favor of `WindowAttributes`.
-- **Breaking:** Removed unnecessary generic parameter `T` from `EventLoopWindowTarget`.
-- On Windows, macOS, X11, Wayland and Web, implement setting images as cursors. See the `custom_cursors.rs` example.
-  - **Breaking:** Remove `Window::set_cursor_icon`
-  - Add `WindowBuilder::with_cursor` and `Window::set_cursor` which takes a `CursorIcon` or `CustomCursor`
-  - Add `CustomCursor::from_rgba` to allow creating cursor images from RGBA data.
-  - Add `CustomCursorExtWebSys::from_url` to allow loading cursor images from URLs.
-  - Add `CustomCursorExtWebSys::from_animation` to allow creating animated cursors from other `CustomCursor`s.
-  - Add `{Active,}EventLoop::create_custom_cursor` to load custom cursor image sources.
-- On macOS, add services menu.
-- **Breaking:** On Web, remove queuing fullscreen request in absence of transient activation.
-- On Web, fix setting cursor icon overriding cursor visibility.
-- **Breaking:** On Web, return `RawWindowHandle::WebCanvas` instead of `RawWindowHandle::Web`.
-- **Breaking:** On Web, macOS and iOS, return `HandleError::Unavailable` when a window handle is not available.
-- **Breaking:** Bump MSRV from `1.65` to `1.70`.
-- On Web, add the ability to toggle calling `Event.preventDefault()` on `Window`.
-- **Breaking:** Remove `WindowAttributes::fullscreen()` and expose as field directly.
-- **Breaking:** Rename `VideoMode` to `VideoModeHandle` to represent that it doesn't hold static data.
-- **Breaking:** No longer export `platform::x11::XNotSupported`.
-- **Breaking:** Renamed `platform::x11::XWindowType` to `platform::x11::WindowType`.
-- Add the `OwnedDisplayHandle` type for allowing safe display handle usage outside of trivial cases.
-- **Breaking:** Rename `TouchpadMagnify` to `PinchGesture`, `SmartMagnify` to `DoubleTapGesture` and `TouchpadRotate` to `RotationGesture` to represent the action rather than the intent.
-- on iOS, add detection support for `PinchGesture`, `DoubleTapGesture` and `RotationGesture`.
-- on Windows: add `with_system_backdrop`, `with_border_color`, `with_title_background_color`, `with_title_text_color` and `with_corner_preference`
-- On Windows, Remove `WS_CAPTION`, `WS_BORDER` and `WS_EX_WINDOWEDGE` styles for child windows without decorations.
-- **Breaking:** Removed `EventLoopError::AlreadyRunning`, which can't happen as it is already prevented by the type system.
-- Added `EventLoop::builder`, which is intended to replace the (now deprecated) `EventLoopBuilder::new`.
-- **Breaking:** Changed the signature of `EventLoop::with_user_event` to return a builder.
-- **Breaking:** Removed `EventLoopBuilder::with_user_event`, the functionality is now available in `EventLoop::with_user_event`.
-- Add `Window::default_attributes` to get default `WindowAttributes`.
-- `log` has been replaced with `tracing`. The old behavior can be emulated by setting the `log` feature on the `tracing` crate.
+### Changed
+
+- On Web, let events wake up event loop immediately when using `ControlFlow::Poll`.
+- Bump MSRV from `1.70` to `1.73`.
+- Changed `ApplicationHandler::user_event` to `user_wake_up`, removing the
+  generic user event.
+
+  Winit will now only indicate that wake up happened, you will have to pair
+  this with an external mechanism like `std::sync::mpsc::channel` if you want
+  to send specific data to be processed on the main thread.
+- Changed `EventLoopProxy::send_event` to `EventLoopProxy::wake_up`, it now
+  only wakes up the loop.
+
+### Removed
+
+- Remove `EventLoop::run`.
+- Remove `EventLoopExtRunOnDemand::run_on_demand`.
+- Remove `EventLoopExtPumpEvents::pump_events`.
+- Remove `Event`.
+- On iOS, remove `platform::ios::EventLoopExtIOS` and related `platform::ios::Idiom` type.
+
+  This feature was incomplete, and the equivalent functionality can be trivially achieved outside
+  of `winit` using `objc2-ui-kit` and calling `UIDevice::currentDevice().userInterfaceIdiom()`.

src/changelog/v0.30.md

@@ -0,0 +1,271 @@
+## 0.30.3
+
+### Added
+
+- On Web, add `EventLoopExtWebSys::(set_)poll_strategy()` to allow setting
+  control flow strategies before starting the event loop.
+- On Web, add `WaitUntilStrategy`, which allows to set different strategies for
+  `ControlFlow::WaitUntil`. By default the Prioritized Task Scheduling API is
+  used, with a fallback to `setTimeout()` with a trick to circumvent throttling
+  to 4ms. But an option to use a Web worker to schedule the timer is available
+  as well, which commonly prevents any throttling when the window is not focused.
+
+### Changed
+
+- On macOS, set the window theme on the `NSWindow` instead of application-wide.
+
+### Fixed
+
+- On X11, build on arm platforms.
+- On macOS, fixed `WindowBuilder::with_theme` not having any effect on the window.
+
+## 0.30.2
+
+### Fixed
+
+- On Web, fix `EventLoopProxy::send_event()` triggering event loop immediately
+  when not called from inside the event loop. Now queues a microtask instead.
+- On Web, stop overwriting default cursor with `CursorIcon::Default`.
+- On Web, prevent crash when using `InnerSizeWriter::request_inner_size()`.
+- On macOS, fix not working opacity for entire window.
+
+## 0.30.1
+
+### Added
+
+- Reexport `raw-window-handle` versions 0.4 and 0.5 as `raw_window_handle_04` and `raw_window_handle_05`.
+- Implement `ApplicationHandler` for `&mut` references and heap allocations to something that implements `ApplicationHandler`.
+- Add traits `EventLoopExtWayland` and `EventLoopExtX11`, providing methods `is_wayland` and `is_x11` on `EventLoop`.
+
+### Fixed
+
+- On macOS, fix panic on exit when dropping windows outside the event loop.
+- On macOS, fix window dragging glitches when dragging across a monitor boundary with different scale factor.
+- On macOS, fix the range in `Ime::Preedit`.
+- On macOS, use the system's internal mechanisms for queuing events.
+- On macOS, handle events directly instead of queuing when possible.
+
+## 0.30.0
+
+### Added
+
+- Add `OwnedDisplayHandle` type for allowing safe display handle usage outside of
+  trivial cases.
+- Add `ApplicationHandler<T>` trait which mimics `Event<T>`.
+- Add `WindowBuilder::with_cursor` and `Window::set_cursor` which takes a
+  `CursorIcon` or `CustomCursor`.
+- Add `Sync` implementation for `EventLoopProxy<T: Send>`.
+- Add `Window::default_attributes` to get default `WindowAttributes`.
+- Add `EventLoop::builder` to get `EventLoopBuilder` without export.
+- Add `CustomCursor::from_rgba` to allow creating cursor images from RGBA data.
+- Add `CustomCursorExtWebSys::from_url` to allow loading cursor images from URLs.
+- Add `CustomCursorExtWebSys::from_animation` to allow creating animated
+  cursors from other `CustomCursor`s.
+- Add `{Active,}EventLoop::create_custom_cursor` to load custom cursor image sources.
+- Add `ActiveEventLoop::create_window` and `EventLoop::create_window`.
+- Add `CustomCursor` which could be set via `Window::set_cursor`, implemented on
+  Windows, macOS, X11, Wayland, and Web.
+- On Web, add to toggle calling `Event.preventDefault()` on `Window`.
+- On iOS, add `PinchGesture`, `DoubleTapGesture`, `PanGesture` and `RotationGesture`.
+- on iOS, use `UIGestureRecognizerDelegate` for fine grained control of gesture recognizers.
+- On macOS, add services menu.
+- On Windows, add `with_title_text_color`, and `with_corner_preference` on
+  `WindowAttributesExtWindows`.
+- On Windows, implement resize increments.
+- On Windows, add `AnyThread` API to access window handle off the main thread.
+
+### Changed
+
+- Bump MSRV from `1.65` to `1.70`.
+- On Wayland, bump `sctk-adwaita` to `0.9.0`, which changed system library
+  crates. This change is a **cascading breaking change**, you must do breaking
+  change as well, even if you don't expose winit.
+- Rename `TouchpadMagnify` to `PinchGesture`.
+- Rename `SmartMagnify` to `DoubleTapGesture`.
+- Rename `TouchpadRotate` to `RotationGesture`.
+- Rename `EventLoopWindowTarget` to `ActiveEventLoop`.
+- Rename `platform::x11::XWindowType` to `platform::x11::WindowType`.
+- Rename `VideoMode` to `VideoModeHandle` to represent that it doesn't hold
+  static data.
+- Make `Debug` formatting of `WindowId` more concise.
+- Move `dpi` types to its own crate, and re-export it from the root crate.
+- Replace `log` with `tracing`, use `log` feature on `tracing` to restore old
+  behavior.
+- `EventLoop::with_user_event` now returns `EventLoopBuilder`.
+- On Web, return `HandleError::Unavailable` when a window handle is not available.
+- On Web, return `RawWindowHandle::WebCanvas` instead of `RawWindowHandle::Web`.
+- On Web, remove queuing fullscreen request in absence of transient activation.
+- On iOS, return `HandleError::Unavailable` when a window handle is not available.
+- On macOS, return `HandleError::Unavailable` when a window handle is not available.
+- On Windows, remove `WS_CAPTION`, `WS_BORDER`, and `WS_EX_WINDOWEDGE` styles
+  for child windows without decorations.
+- On Android, bump `ndk` to `0.9.0` and `android-activity` to `0.6.0`,
+  and remove unused direct dependency on `ndk-sys`.
+
+### Deprecated
+
+- Deprecate `EventLoop::run`, use `EventLoop::run_app`.
+- Deprecate `EventLoopExtRunOnDemand::run_on_demand`, use `EventLoop::run_app_on_demand`.
+- Deprecate `EventLoopExtPumpEvents::pump_events`, use `EventLoopExtPumpEvents::pump_app_events`.
+
+  The new `app` APIs accept a newly added `ApplicationHandler<T>` instead of
+  `Fn`. The semantics are mostly the same, given that the capture list of the
+  closure is your new `State`. Consider the following code:
+
+  ```rust,no_run,ignore
+  use winit::event::Event;
+  use winit::event_loop::EventLoop;
+  use winit::window::Window;
+
+  struct MyUserEvent;
+
+  let event_loop = EventLoop::<MyUserEvent>::with_user_event().build().unwrap();
+  let window = event_loop.create_window(Window::default_attributes()).unwrap();
+  let mut counter = 0;
+
+  let _ = event_loop.run(move |event, event_loop| {
+      match event {
+          Event::AboutToWait => {
+              window.request_redraw();
+              counter += 1;
+          }
+          Event::WindowEvent { window_id, event } => {
+              // Handle window event.
+          }
+          Event::UserEvent(event) => {
+              // Handle user event.
+          }
+          Event::DeviceEvent { device_id, event } => {
+              // Handle device event.
+          }
+          _ => (),
+      }
+  });
+  ```
+
+  To migrate this code, you should move all the captured values into some
+  newtype `State` and implement `ApplicationHandler` for this type. Finally,
+  we move particular `match event` arms into methods on `ApplicationHandler`,
+  for example:
+
+  ```rust,no_run,ignore
+  use winit::application::ApplicationHandler;
+  use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
+  use winit::event_loop::{EventLoop, ActiveEventLoop};
+  use winit::window::{Window, WindowId};
+
+  struct MyUserEvent;
+
+  struct State {
+      window: Window,
+      counter: i32,
+  }
+
+  impl ApplicationHandler<MyUserEvent> for State {
+      fn user_event(&mut self, event_loop: &ActiveEventLoop, user_event: MyUserEvent) {
+          // Handle user event.
+      }
+
+      fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+          // Your application got resumed.
+      }
+
+      fn window_event(&mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent) {
+          // Handle window event.
+      }
+
+      fn device_event(&mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent) {
+          // Handle device event.
+      }
+
+      fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+          self.window.request_redraw();
+          self.counter += 1;
+      }
+  }
+
+  let event_loop = EventLoop::<MyUserEvent>::with_user_event().build().unwrap();
+  #[allow(deprecated)]
+  let window = event_loop.create_window(Window::default_attributes()).unwrap();
+  let mut state = State { window, counter: 0 };
+
+  let _ = event_loop.run_app(&mut state);
+  ```
+
+  Please submit your feedback after migrating in [this issue](https://github.com/rust-windowing/winit/issues/3626).
+
+- Deprecate `Window::set_cursor_icon`, use `Window::set_cursor`.
+
+### Removed
+
+- Remove `Window::new`, use `ActiveEventLoop::create_window` instead.
+
+  You now have to create your windows inside the actively running event loop
+  (usually the `new_events(cause: StartCause::Init)` or `resumed()` events),
+  and can no longer do it before the application has properly launched.
+  This change is done to fix many long-standing issues on iOS and macOS, and
+  will improve things on Wayland once fully implemented.
+
+  To ease migration, we provide the deprecated `EventLoop::create_window` that
+  will allow you to bypass this restriction in this release.
+
+  Using the migration example from above, you can change your code as follows:
+
+  ```rust,no_run,ignore
+  use winit::application::ApplicationHandler;
+  use winit::event::{Event, WindowEvent, DeviceEvent, DeviceId};
+  use winit::event_loop::{EventLoop, ActiveEventLoop};
+  use winit::window::{Window, WindowId};
+
+  #[derive(Default)]
+  struct State {
+      // Use an `Option` to allow the window to not be available until the
+      // application is properly running.
+      window: Option<Window>,
+      counter: i32,
+  }
+
+  impl ApplicationHandler for State {
+      // This is a common indicator that you can create a window.
+      fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+          self.window = Some(event_loop.create_window(Window::default_attributes()).unwrap());
+      }
+      fn window_event(&mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent) {
+          // `unwrap` is fine, the window will always be available when
+          // receiving a window event.
+          let window = self.window.as_ref().unwrap();
+          // Handle window event.
+      }
+      fn device_event(&mut self, event_loop: &ActiveEventLoop, device_id: DeviceId, event: DeviceEvent) {
+          // Handle window event.
+      }
+      fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+          if let Some(window) = self.window.as_ref() {
+              window.request_redraw();
+              self.counter += 1;
+          }
+      }
+  }
+
+  let event_loop = EventLoop::new().unwrap();
+  let mut state = State::default();
+  let _ = event_loop.run_app(&mut state);
+  ```
+
+- Remove `Deref` implementation for `EventLoop` that gave `EventLoopWindowTarget`.
+- Remove `WindowBuilder` in favor of `WindowAttributes`.
+- Remove Generic parameter `T` from `ActiveEventLoop`.
+- Remove `EventLoopBuilder::with_user_event`, use `EventLoop::with_user_event`.
+- Remove Redundant `EventLoopError::AlreadyRunning`.
+- Remove `WindowAttributes::fullscreen` and expose as field directly.
+- On X11, remove `platform::x11::XNotSupported` export.
+
+### Fixed
+
+- On Web, fix setting cursor icon overriding cursor visibility.
+- On Windows, fix cursor not confined to center of window when grabbed and hidden.
+- On macOS, fix sequence of mouse events being out of order when dragging on the trackpad.
+- On Wayland, fix decoration glitch on close with some compositors.
+- On Android, fix a regression introduced in #2748 to allow volume key events to be received again.
+- On Windows, don't return a valid window handle outside of the GUI thread.
+- On macOS, don't set the background color when initializing a window with transparency.

src/cursor.rs

@@ -1,7 +1,7 @@
 use core::fmt;
-use std::hash::Hasher;
+use std::error::Error;
+use std::hash::{Hash, Hasher};
 use std::sync::Arc;
-use std::{error::Error, hash::Hash};
 
 use cursor_icon::CursorIcon;
 
@@ -12,7 +12,7 @@ pub const MAX_CURSOR_SIZE: u16 = 2048;
 
 const PIXEL_SIZE: usize = 4;
 
-/// See [`Window::set_cursor()`](crate::window::Window::set_cursor) for more details.
+/// See [`Window::set_cursor()`][crate::window::Window::set_cursor] for more details.
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum Cursor {
     Icon(CursorIcon),
@@ -88,14 +88,9 @@ impl CustomCursor {
         hotspot_x: u16,
         hotspot_y: u16,
     ) -> Result<CustomCursorSource, BadImage> {
-        let _span = tracing::debug_span!(
-            "winit::Cursor::from_rgba",
-            width,
-            height,
-            hotspot_x,
-            hotspot_y
-        )
-        .entered();
+        let _span =
+            tracing::debug_span!("winit::Cursor::from_rgba", width, height, hotspot_x, hotspot_y)
+                .entered();
 
         Ok(CustomCursorSource {
             inner: PlatformCustomCursorSource::from_rgba(
@@ -129,45 +124,36 @@ pub enum BadImage {
     ByteCountNotDivisibleBy4 { byte_count: usize },
     /// Produced when the number of pixels (`rgba.len() / 4`) isn't equal to `width * height`.
     /// At least one of your arguments is incorrect.
-    DimensionsVsPixelCount {
-        width: u16,
-        height: u16,
-        width_x_height: u64,
-        pixel_count: u64,
-    },
+    DimensionsVsPixelCount { width: u16, height: u16, width_x_height: u64, pixel_count: u64 },
     /// Produced when the hotspot is outside the image bounds
-    HotspotOutOfBounds {
-        width: u16,
-        height: u16,
-        hotspot_x: u16,
-        hotspot_y: u16,
-    },
+    HotspotOutOfBounds { width: u16, height: u16, hotspot_x: u16, hotspot_y: u16 },
 }
 
 impl fmt::Display for BadImage {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            BadImage::TooLarge { width, height } => write!(f,
-                "The specified dimensions ({width:?}x{height:?}) are too large. The maximum is {MAX_CURSOR_SIZE:?}x{MAX_CURSOR_SIZE:?}.",
+            BadImage::TooLarge { width, height } => write!(
+                f,
+                "The specified dimensions ({width:?}x{height:?}) are too large. The maximum is \
+                 {MAX_CURSOR_SIZE:?}x{MAX_CURSOR_SIZE:?}.",
             ),
-            BadImage::ByteCountNotDivisibleBy4 { byte_count } => write!(f,
-                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
+            BadImage::ByteCountNotDivisibleBy4 { byte_count } => write!(
+                f,
+                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making \
+                 it impossible to interpret as 32bpp RGBA pixels.",
             ),
-            BadImage::DimensionsVsPixelCount {
-                width,
-                height,
-                width_x_height,
-                pixel_count,
-            } => write!(f,
-                "The specified dimensions ({width:?}x{height:?}) don't match the number of pixels supplied by the `rgba` argument ({pixel_count:?}). For those dimensions, the expected pixel count is {width_x_height:?}.",
-            ),
-            BadImage::HotspotOutOfBounds {
-                width,
-                height,
-                hotspot_x,
-                hotspot_y,
-            } => write!(f,
-                "The specified hotspot ({hotspot_x:?}, {hotspot_y:?}) is outside the image bounds ({width:?}x{height:?}).",
+            BadImage::DimensionsVsPixelCount { width, height, width_x_height, pixel_count } => {
+                write!(
+                    f,
+                    "The specified dimensions ({width:?}x{height:?}) don't match the number of \
+                     pixels supplied by the `rgba` argument ({pixel_count:?}). For those \
+                     dimensions, the expected pixel count is {width_x_height:?}.",
+                )
+            },
+            BadImage::HotspotOutOfBounds { width, height, hotspot_x, hotspot_y } => write!(
+                f,
+                "The specified hotspot ({hotspot_x:?}, {hotspot_y:?}) is outside the image bounds \
+                 ({width:?}x{height:?}).",
             ),
         }
     }
@@ -236,9 +222,7 @@ impl CursorImage {
         }
 
         if rgba.len() % PIXEL_SIZE != 0 {
-            return Err(BadImage::ByteCountNotDivisibleBy4 {
-                byte_count: rgba.len(),
-            });
+            return Err(BadImage::ByteCountNotDivisibleBy4 { byte_count: rgba.len() });
         }
 
         let pixel_count = (rgba.len() / PIXEL_SIZE) as u64;
@@ -253,21 +237,10 @@ impl CursorImage {
         }
 
         if hotspot_x >= width || hotspot_y >= height {
-            return Err(BadImage::HotspotOutOfBounds {
-                width,
-                height,
-                hotspot_x,
-                hotspot_y,
-            });
+            return Err(BadImage::HotspotOutOfBounds { width, height, hotspot_x, hotspot_y });
         }
 
-        Ok(CursorImage {
-            rgba,
-            width,
-            height,
-            hotspot_x,
-            hotspot_y,
-        })
+        Ok(CursorImage { rgba, width, height, hotspot_x, hotspot_y })
     }
 }
 

src/error.rs

@@ -71,10 +71,7 @@ macro_rules! os_error {
 
 impl fmt::Display for OsError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
-        f.pad(&format!(
-            "os error at {}:{}: {}",
-            self.file, self.line, self.error
-        ))
+        f.pad(&format!("os error at {}:{}: {}", self.file, self.line, self.error))
     }
 }
 
@@ -117,19 +114,14 @@ impl error::Error for NotSupportedError {}
 impl error::Error for EventLoopError {}
 
 #[cfg(test)]
+#[allow(clippy::redundant_clone)]
 mod tests {
-    #![allow(clippy::redundant_clone)]
-
     use super::*;
 
     // Eat attributes for testing
     #[test]
     fn ensure_fmt_does_not_panic() {
-        let _ = format!(
-            "{:?}, {}",
-            NotSupportedError::new(),
-            NotSupportedError::new().clone()
-        );
+        let _ = format!("{:?}, {}", NotSupportedError::new(), NotSupportedError::new().clone());
         let _ = format!(
             "{:?}, {}",
             ExternalError::NotSupported(NotSupportedError::new()),

src/event.rs

@@ -1,7 +1,8 @@
-//! The [`Event`] enum and assorted supporting types.
+//! The event enums and assorted supporting types.
 //!
 //! These are sent to the closure given to [`EventLoop::run_app(...)`], where they get
-//! processed and used to modify the program state. For more details, see the root-level documentation.
+//! processed and used to modify the program state. For more details, see the root-level
+//! documentation.
 //!
 //! Some of these events represent different "parts" of a traditional event-handling loop. You could
 //! approximate the basic ordering loop of [`EventLoop::run_app(...)`] like this:
@@ -44,22 +45,24 @@ use smol_str::SmolStr;
 #[cfg(web_platform)]
 use web_time::Instant;
 
+use crate::dpi::{PhysicalPosition, PhysicalSize};
 use crate::error::ExternalError;
+use crate::event_loop::AsyncRequestSerial;
+use crate::keyboard::{self, ModifiersKeyState, ModifiersKeys, ModifiersState};
+use crate::platform_impl;
 #[cfg(doc)]
 use crate::window::Window;
-use crate::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    event_loop::AsyncRequestSerial,
-    keyboard::{self, ModifiersKeyState, ModifiersKeys, ModifiersState},
-    platform_impl,
-    window::{ActivationToken, Theme, WindowId},
-};
+use crate::window::{ActivationToken, Theme, WindowId};
 
+// TODO: Remove once the backends can call `ApplicationHandler` methods directly. For now backends
+// like Windows and Web require `Event` to wire user events, otherwise each backend will have to
+// wrap `Event` in some other structure.
 /// Describes a generic event.
 ///
 /// See the module-level docs for more information on the event loop manages each event.
+#[allow(dead_code)]
 #[derive(Debug, Clone, PartialEq)]
-pub enum Event<T: 'static> {
+pub(crate) enum Event {
     /// See [`ApplicationHandler::new_events`] for details.
     ///
     /// [`ApplicationHandler::new_events`]: crate::application::ApplicationHandler::new_events
@@ -68,23 +71,14 @@ pub enum Event<T: 'static> {
     /// See [`ApplicationHandler::window_event`] for details.
     ///
     /// [`ApplicationHandler::window_event`]: crate::application::ApplicationHandler::window_event
-    WindowEvent {
-        window_id: WindowId,
-        event: WindowEvent,
-    },
+    #[allow(clippy::enum_variant_names)]
+    WindowEvent { window_id: WindowId, event: WindowEvent },
 
     /// See [`ApplicationHandler::device_event`] for details.
     ///
     /// [`ApplicationHandler::device_event`]: crate::application::ApplicationHandler::device_event
-    DeviceEvent {
-        device_id: DeviceId,
-        event: DeviceEvent,
-    },
-
-    /// See [`ApplicationHandler::user_event`] for details.
-    ///
-    /// [`ApplicationHandler::user_event`]: crate::application::ApplicationHandler::user_event
-    UserEvent(T),
+    #[allow(clippy::enum_variant_names)]
+    DeviceEvent { device_id: DeviceId, event: DeviceEvent },
 
     /// See [`ApplicationHandler::suspended`] for details.
     ///
@@ -110,24 +104,9 @@ pub enum Event<T: 'static> {
     ///
     /// [`ApplicationHandler::memory_warning`]: crate::application::ApplicationHandler::memory_warning
     MemoryWarning,
-}
 
-impl<T> Event<T> {
-    #[allow(clippy::result_large_err)]
-    pub fn map_nonuser_event<U>(self) -> Result<Event<U>, Event<T>> {
-        use self::Event::*;
-        match self {
-            UserEvent(_) => Err(self),
-            WindowEvent { window_id, event } => Ok(WindowEvent { window_id, event }),
-            DeviceEvent { device_id, event } => Ok(DeviceEvent { device_id, event }),
-            NewEvents(cause) => Ok(NewEvents(cause)),
-            AboutToWait => Ok(AboutToWait),
-            LoopExiting => Ok(LoopExiting),
-            Suspended => Ok(Suspended),
-            Resumed => Ok(Resumed),
-            MemoryWarning => Ok(MemoryWarning),
-        }
-    }
+    /// User requested a wake up.
+    UserWakeUp,
 }
 
 /// Describes the reason the event loop is resuming.
@@ -138,17 +117,11 @@ pub enum StartCause {
     /// guaranteed to be equal to or after the requested resume time.
     ///
     /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
-    ResumeTimeReached {
-        start: Instant,
-        requested_resume: Instant,
-    },
+    ResumeTimeReached { start: Instant, requested_resume: Instant },
 
     /// Sent if the OS has new events to send to the window, after a wait was requested. Contains
     /// the moment the wait was requested and the resume time, if requested.
-    WaitCancelled {
-        start: Instant,
-        requested_resume: Option<Instant>,
-    },
+    WaitCancelled { start: Instant, requested_resume: Option<Instant> },
 
     /// Sent if the event loop is being resumed after the loop's control flow was set to
     /// [`ControlFlow::Poll`].
@@ -164,18 +137,11 @@ pub enum StartCause {
 #[derive(Debug, Clone, PartialEq)]
 pub enum WindowEvent {
     /// The activation token was delivered back and now could be used.
-    ///
-    #[cfg_attr(
-        not(any(x11_platform, wayland_platform)),
-        allow(rustdoc::broken_intra_doc_links)
-    )]
+    #[cfg_attr(not(any(x11_platform, wayland_platform)), allow(rustdoc::broken_intra_doc_links))]
     /// Delivered in response to [`request_activation_token`].
     ///
     /// [`request_activation_token`]: crate::platform::startup_notify::WindowExtStartupNotify::request_activation_token
-    ActivationTokenDone {
-        serial: AsyncRequestSerial,
-        token: ActivationToken,
-    },
+    ActivationTokenDone { serial: AsyncRequestSerial, token: ActivationToken },
 
     /// The size of the window has changed. Contains the client area's new dimensions.
     Resized(PhysicalSize<u32>),
@@ -229,10 +195,10 @@ pub enum WindowEvent {
         /// If `true`, the event was generated synthetically by winit
         /// in one of the following circumstances:
         ///
-        /// * Synthetic key press events are generated for all keys pressed
-        ///   when a window gains focus. Likewise, synthetic key release events
-        ///   are generated for all keys pressed when a window goes out of focus.
-        ///   ***Currently, this is only functional on X11 and Windows***
+        /// * Synthetic key press events are generated for all keys pressed when a window gains
+        ///   focus. Likewise, synthetic key release events are generated for all keys pressed when
+        ///   a window goes out of focus. ***Currently, this is only functional on X11 and
+        ///   Windows***
         ///
         /// Otherwise, this value is always `false`.
         is_synthetic: bool,
@@ -262,9 +228,10 @@ pub enum WindowEvent {
     CursorMoved {
         device_id: DeviceId,
 
-        /// (x,y) coords in pixels relative to the top-left corner of the window. Because the range of this data is
-        /// limited by the display area and it may have been transformed by the OS to implement effects such as cursor
-        /// acceleration, it should not be used to implement non-cursor-like interactions such as 3D camera control.
+        /// (x,y) coords in pixels relative to the top-left corner of the window. Because the range
+        /// of this data is limited by the display area and it may have been transformed by
+        /// the OS to implement effects such as cursor acceleration, it should not be used
+        /// to implement non-cursor-like interactions such as 3D camera control.
         position: PhysicalPosition<f64>,
     },
 
@@ -291,18 +258,10 @@ pub enum WindowEvent {
     CursorLeft { device_id: DeviceId },
 
     /// A mouse wheel movement or touchpad scroll occurred.
-    MouseWheel {
-        device_id: DeviceId,
-        delta: MouseScrollDelta,
-        phase: TouchPhase,
-    },
+    MouseWheel { device_id: DeviceId, delta: MouseScrollDelta, phase: TouchPhase },
 
     /// An mouse button press has been received.
-    MouseInput {
-        device_id: DeviceId,
-        state: ElementState,
-        button: MouseButton,
-    },
+    MouseInput { device_id: DeviceId, state: ElementState, button: MouseButton },
 
     /// Two-finger pinch gesture, often used for magnification.
     ///
@@ -320,6 +279,19 @@ pub enum WindowEvent {
         phase: TouchPhase,
     },
 
+    /// N-finger pan gesture
+    ///
+    /// ## Platform-specific
+    ///
+    /// - Only available on **iOS**.
+    /// - On iOS, not recognized by default. It must be enabled when needed.
+    PanGesture {
+        device_id: DeviceId,
+        /// Change in pixels of pan gesture from last update.
+        delta: PhysicalPosition<f32>,
+        phase: TouchPhase,
+    },
+
     /// Double tap gesture.
     ///
     /// On a Mac, smart magnification is triggered by a double tap with two fingers
@@ -351,6 +323,7 @@ pub enum WindowEvent {
     /// - On iOS, not recognized by default. It must be enabled when needed.
     RotationGesture {
         device_id: DeviceId,
+        /// change in rotation in degrees
         delta: f32,
         phase: TouchPhase,
     },
@@ -358,20 +331,12 @@ pub enum WindowEvent {
     /// Touchpad pressure event.
     ///
     /// At the moment, only supported on Apple forcetouch-capable macbooks.
-    /// The parameters are: pressure level (value between 0 and 1 representing how hard the touchpad
-    /// is being pressed) and stage (integer representing the click level).
-    TouchpadPressure {
-        device_id: DeviceId,
-        pressure: f32,
-        stage: i64,
-    },
+    /// The parameters are: pressure level (value between 0 and 1 representing how hard the
+    /// touchpad is being pressed) and stage (integer representing the click level).
+    TouchpadPressure { device_id: DeviceId, pressure: f32, stage: i64 },
 
     /// Motion on some analog axis. May report data redundant to other, more specific events.
-    AxisMotion {
-        device_id: DeviceId,
-        axis: AxisId,
-        value: f64,
-    },
+    AxisMotion { device_id: DeviceId, axis: AxisId, value: f64 },
 
     /// Touch event has been received
     ///
@@ -393,8 +358,8 @@ pub enum WindowEvent {
     /// * Changing the display's scale factor (e.g. in Control Panel on Windows).
     /// * Moving the window to a display with a different scale factor.
     ///
-    /// To update the window size, use the provided [`InnerSizeWriter`] handle. By default, the window is
-    /// resized to the value suggested by the OS, but it can be changed to any value.
+    /// To update the window size, use the provided [`InnerSizeWriter`] handle. By default, the
+    /// window is resized to the value suggested by the OS, but it can be changed to any value.
     ///
     /// For more information about DPI in general, see the [`dpi`] crate.
     ScaleFactorChanged {
@@ -410,6 +375,8 @@ pub enum WindowEvent {
     /// Applications might wish to react to this to change the theme of the content of the window
     /// when the system changes the window theme.
     ///
+    /// This only reports a change if the window theme was not overridden by [`Window::set_theme`].
+    ///
     /// ## Platform-specific
     ///
     /// - **iOS / Android / X11 / Wayland / Orbital:** Unsupported.
@@ -424,10 +391,11 @@ pub enum WindowEvent {
     ///
     /// ### iOS
     ///
-    /// On iOS, the `Occluded(false)` event is emitted in response to an [`applicationWillEnterForeground`]
-    /// callback which means the application should start preparing its data. The `Occluded(true)` event is
-    /// emitted in response to an [`applicationDidEnterBackground`] callback which means the application
-    /// should free resources (according to the [iOS application lifecycle]).
+    /// On iOS, the `Occluded(false)` event is emitted in response to an
+    /// [`applicationWillEnterForeground`] callback which means the application should start
+    /// preparing its data. The `Occluded(true)` event is emitted in response to an
+    /// [`applicationDidEnterBackground`] callback which means the application should free
+    /// resources (according to the [iOS application lifecycle]).
     ///
     /// [`applicationWillEnterForeground`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1623076-applicationwillenterforeground
     /// [`applicationDidEnterBackground`]: https://developer.apple.com/documentation/uikit/uiapplicationdelegate/1622997-applicationdidenterbackground
@@ -457,9 +425,10 @@ pub enum WindowEvent {
 
 /// Identifier of an input device.
 ///
-/// Whenever you receive an event arising from a particular input device, this event contains a `DeviceId` which
-/// identifies its origin. Note that devices may be virtual (representing an on-screen cursor and keyboard focus) or
-/// physical. Virtual devices typically aggregate inputs from multiple physical devices.
+/// Whenever you receive an event arising from a particular input device, this event contains a
+/// `DeviceId` which identifies its origin. Note that devices may be virtual (representing an
+/// on-screen cursor and keyboard focus) or physical. Virtual devices typically aggregate inputs
+/// from multiple physical devices.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId(pub(crate) platform_impl::DeviceId);
 
@@ -481,10 +450,10 @@ impl DeviceId {
 
 /// Represents raw hardware events that are not associated with any particular window.
 ///
-/// Useful for interactions that diverge significantly from a conventional 2D GUI, such as 3D camera or first-person
-/// game controls. Many physical actions, such as mouse movement, can produce both device and window events. Because
-/// window events typically arise from virtual devices (corresponding to GUI cursors and keyboard focus) the device IDs
-/// may not match.
+/// Useful for interactions that diverge significantly from a conventional 2D GUI, such as 3D camera
+/// or first-person game controls. Many physical actions, such as mouse movement, can produce both
+/// device and window events. Because window events typically arise from virtual devices
+/// (corresponding to GUI cursors and keyboard focus) the device IDs may not match.
 ///
 /// Note that these events are delivered regardless of input focus.
 #[derive(Clone, Debug, PartialEq)]
@@ -494,7 +463,8 @@ pub enum DeviceEvent {
 
     /// Change in physical position of a pointing device.
     ///
-    /// This represents raw, unfiltered physical motion. Not to be confused with [`WindowEvent::CursorMoved`].
+    /// This represents raw, unfiltered physical motion. Not to be confused with
+    /// [`WindowEvent::CursorMoved`].
     MouseMotion {
         /// (x, y) change in position in unspecified units.
         ///
@@ -615,13 +585,13 @@ pub struct KeyEvent {
 
     /// Contains the location of this key on the keyboard.
     ///
-    /// Certain keys on the keyboard may appear in more than once place. For example, the "Shift" key
-    /// appears on the left side of the QWERTY keyboard as well as the right side. However, both keys
-    /// have the same symbolic value. Another example of this phenomenon is the "1" key, which appears
-    /// both above the "Q" key and as the "Keypad 1" key.
+    /// Certain keys on the keyboard may appear in more than once place. For example, the "Shift"
+    /// key appears on the left side of the QWERTY keyboard as well as the right side. However,
+    /// both keys have the same symbolic value. Another example of this phenomenon is the "1"
+    /// key, which appears both above the "Q" key and as the "Keypad 1" key.
     ///
-    /// This field allows the user to differentiate between keys like this that have the same symbolic
-    /// value but different locations on the keyboard.
+    /// This field allows the user to differentiate between keys like this that have the same
+    /// symbolic value but different locations on the keyboard.
     ///
     /// See the [`KeyLocation`] type for more details.
     ///
@@ -636,8 +606,8 @@ pub struct KeyEvent {
     /// Whether or not this key is a key repeat event.
     ///
     /// On some systems, holding down a key for some period of time causes that key to be repeated
-    /// as though it were being pressed and released repeatedly. This field is `true` if and only if
-    /// this event is the result of one of those repeats.
+    /// as though it were being pressed and released repeatedly. This field is `true` if and only
+    /// if this event is the result of one of those repeats.
     ///
     /// # Example
     ///
@@ -645,30 +615,31 @@ pub struct KeyEvent {
     /// done by ignoring events where this property is set.
     ///
     /// ```
-    /// use winit::event::{WindowEvent, KeyEvent, ElementState};
+    /// use winit::event::{ElementState, KeyEvent, WindowEvent};
     /// use winit::keyboard::{KeyCode, PhysicalKey};
     /// # let window_event = WindowEvent::RedrawRequested; // To make the example compile
     /// match window_event {
     ///     WindowEvent::KeyboardInput {
-    ///         event: KeyEvent {
-    ///             physical_key: PhysicalKey::Code(KeyCode::KeyW),
-    ///             state: ElementState::Pressed,
-    ///             repeat: false,
-    ///             ..
-    ///         },
+    ///         event:
+    ///             KeyEvent {
+    ///                 physical_key: PhysicalKey::Code(KeyCode::KeyW),
+    ///                 state: ElementState::Pressed,
+    ///                 repeat: false,
+    ///                 ..
+    ///             },
     ///         ..
     ///     } => {
-    ///          // The physical key `W` was pressed, and it was not a repeat
-    ///     }
-    ///     _ => {} // Handle other events
+    ///         // The physical key `W` was pressed, and it was not a repeat
+    ///     },
+    ///     _ => {}, // Handle other events
     /// }
     /// ```
     pub repeat: bool,
 
     /// Platform-specific key event information.
     ///
-    /// On Windows, Linux and macOS, this type contains the key without modifiers and the text with all
-    /// modifiers applied.
+    /// On Windows, Linux and macOS, this type contains the key without modifiers and the text with
+    /// all modifiers applied.
     ///
     /// On Android, iOS, Redox and Web, this type is a no-op.
     pub(crate) platform_specific: platform_impl::KeyEventExtra,
@@ -742,10 +713,7 @@ impl Modifiers {
 
 impl From<ModifiersState> for Modifiers {
     fn from(value: ModifiersState) -> Self {
-        Self {
-            state: value,
-            pressed_mods: Default::default(),
-        }
+        Self { state: value, pressed_mods: Default::default() }
     }
 }
 
@@ -753,12 +721,16 @@ impl From<ModifiersState> for Modifiers {
 ///
 /// This is also called a "composition event".
 ///
-/// Most keypresses using a latin-like keyboard layout simply generate a [`WindowEvent::KeyboardInput`].
-/// However, one couldn't possibly have a key for every single unicode character that the user might want to type
-/// - so the solution operating systems employ is to allow the user to type these using _a sequence of keypresses_ instead.
+/// Most keypresses using a latin-like keyboard layout simply generate a
+/// [`WindowEvent::KeyboardInput`]. However, one couldn't possibly have a key for every single
+/// unicode character that the user might want to type
+/// - so the solution operating systems employ is to allow the user to type these using _a sequence
+///   of keypresses_ instead.
+///
+/// A prominent example of this is accents - many keyboard layouts allow you to first click the
+/// "accent key", and then the character you want to apply the accent to. In this case, some
+/// platforms will generate the following event sequence:
 ///
-/// A prominent example of this is accents - many keyboard layouts allow you to first click the "accent key", and then
-/// the character you want to apply the accent to. In this case, some platforms will generate the following event sequence:
 /// ```ignore
 /// // Press "`" key
 /// Ime::Preedit("`", Some((0, 0)))
@@ -767,11 +739,13 @@ impl From<ModifiersState> for Modifiers {
 /// Ime::Commit("é")
 /// ```
 ///
-/// Additionally, certain input devices are configured to display a candidate box that allow the user to select the
-/// desired character interactively. (To properly position this box, you must use [`Window::set_ime_cursor_area`].)
+/// Additionally, certain input devices are configured to display a candidate box that allow the
+/// user to select the desired character interactively. (To properly position this box, you must use
+/// [`Window::set_ime_cursor_area`].)
+///
+/// An example of a keyboard layout which uses candidate boxes is pinyin. On a latin keyboard the
+/// following event sequence could be obtained:
 ///
-/// An example of a keyboard layout which uses candidate boxes is pinyin. On a latin keyboard the following event
-/// sequence could be obtained:
 /// ```ignore
 /// // Press "A" key
 /// Ime::Preedit("a", Some((1, 1)))
@@ -790,8 +764,8 @@ impl From<ModifiersState> for Modifiers {
 pub enum Ime {
     /// Notifies when the IME was enabled.
     ///
-    /// After getting this event you could receive [`Preedit`](Self::Preedit) and
-    /// [`Commit`](Self::Commit) events. You should also start performing IME related requests
+    /// After getting this event you could receive [`Preedit`][Self::Preedit] and
+    /// [`Commit`][Self::Commit] events. You should also start performing IME related requests
     /// like [`Window::set_ime_cursor_area`].
     Enabled,
 
@@ -811,10 +785,10 @@ pub enum Ime {
 
     /// Notifies when the IME was disabled.
     ///
-    /// After receiving this event you won't get any more [`Preedit`](Self::Preedit) or
-    /// [`Commit`](Self::Commit) events until the next [`Enabled`](Self::Enabled) event. You should
-    /// also stop issuing IME related requests like [`Window::set_ime_cursor_area`] and clear pending
-    /// preedit text.
+    /// After receiving this event you won't get any more [`Preedit`][Self::Preedit] or
+    /// [`Commit`][Self::Commit] events until the next [`Enabled`][Self::Enabled] event. You should
+    /// also stop issuing IME related requests like [`Window::set_ime_cursor_area`] and clear
+    /// pending preedit text.
     Disabled,
 }
 
@@ -913,17 +887,13 @@ impl Force {
     /// consistent across devices.
     pub fn normalized(&self) -> f64 {
         match self {
-            Force::Calibrated {
-                force,
-                max_possible_force,
-                altitude_angle,
-            } => {
+            Force::Calibrated { force, max_possible_force, altitude_angle } => {
                 let force = match altitude_angle {
                     Some(altitude_angle) => force / altitude_angle.sin(),
                     None => *force,
                 };
                 force / max_possible_force
-            }
+            },
             Force::Normalized(force) => *force,
         }
     }
@@ -1029,6 +999,7 @@ impl PartialEq for InnerSizeWriter {
 
 #[cfg(test)]
 mod tests {
+    use crate::dpi::PhysicalPosition;
     use crate::event;
     use std::collections::{BTreeSet, HashSet};
 
@@ -1040,12 +1011,13 @@ mod tests {
 
             #[allow(deprecated)]
             {
-                use crate::event::{Event::*, Ime::Enabled, WindowEvent::*};
+                use crate::event::Event::*;
+                use crate::event::Ime::Enabled;
+                use crate::event::WindowEvent::*;
                 use crate::window::WindowId;
 
                 // Mainline events.
                 let wid = unsafe { WindowId::dummy() };
-                x(UserEvent(()));
                 x(NewEvents(event::StartCause::Init));
                 x(AboutToWait);
                 x(LoopExiting);
@@ -1053,12 +1025,7 @@ mod tests {
                 x(Resumed);
 
                 // Window events.
-                let with_window_event = |wev| {
-                    x(WindowEvent {
-                        window_id: wid,
-                        event: wev,
-                    })
-                };
+                let with_window_event = |wev| x(WindowEvent { window_id: wid, event: wev });
 
                 with_window_event(CloseRequested);
                 with_window_event(Destroyed);
@@ -1069,10 +1036,7 @@ mod tests {
                 with_window_event(HoveredFile("x.txt".into()));
                 with_window_event(HoveredFileCancelled);
                 with_window_event(Ime(Enabled));
-                with_window_event(CursorMoved {
-                    device_id: did,
-                    position: (0, 0).into(),
-                });
+                with_window_event(CursorMoved { device_id: did, position: (0, 0).into() });
                 with_window_event(ModifiersChanged(event::Modifiers::default()));
                 with_window_event(CursorEntered { device_id: did });
                 with_window_event(CursorLeft { device_id: did });
@@ -1097,16 +1061,13 @@ mod tests {
                     delta: 0.0,
                     phase: event::TouchPhase::Started,
                 });
-                with_window_event(TouchpadPressure {
+                with_window_event(PanGesture {
                     device_id: did,
-                    pressure: 0.0,
-                    stage: 0,
-                });
-                with_window_event(AxisMotion {
-                    device_id: did,
-                    axis: 0,
-                    value: 0.0,
+                    delta: PhysicalPosition::<f32>::new(0.0, 0.0),
+                    phase: event::TouchPhase::Started,
                 });
+                with_window_event(TouchpadPressure { device_id: did, pressure: 0.0, stage: 0 });
+                with_window_event(AxisMotion { device_id: did, axis: 0, value: 0.0 });
                 with_window_event(Touch(event::Touch {
                     device_id: did,
                     phase: event::TouchPhase::Started,
@@ -1122,29 +1083,17 @@ mod tests {
             {
                 use event::DeviceEvent::*;
 
-                let with_device_event = |dev_ev| {
-                    x(event::Event::DeviceEvent {
-                        device_id: did,
-                        event: dev_ev,
-                    })
-                };
+                let with_device_event =
+                    |dev_ev| x(event::Event::DeviceEvent { device_id: did, event: dev_ev });
 
                 with_device_event(Added);
                 with_device_event(Removed);
-                with_device_event(MouseMotion {
-                    delta: (0.0, 0.0).into(),
-                });
+                with_device_event(MouseMotion { delta: (0.0, 0.0).into() });
                 with_device_event(MouseWheel {
                     delta: event::MouseScrollDelta::LineDelta(0.0, 0.0),
                 });
-                with_device_event(Motion {
-                    axis: 0,
-                    value: 0.0,
-                });
-                with_device_event(Button {
-                    button: 0,
-                    state: event::ElementState::Pressed,
-                });
+                with_device_event(Motion { axis: 0, value: 0.0 });
+                with_device_event(Button { button: 0, state: event::ElementState::Pressed });
             }
         }};
     }
@@ -1152,35 +1101,19 @@ mod tests {
     #[allow(clippy::redundant_clone)]
     #[test]
     fn test_event_clone() {
-        foreach_event!(|event: event::Event<()>| {
+        foreach_event!(|event: event::Event| {
             let event2 = event.clone();
             assert_eq!(event, event2);
         })
     }
 
-    #[test]
-    fn test_map_nonuser_event() {
-        foreach_event!(|event: event::Event<()>| {
-            let is_user = matches!(event, event::Event::UserEvent(()));
-            let event2 = event.map_nonuser_event::<()>();
-            if is_user {
-                assert_eq!(event2, Err(event::Event::UserEvent(())));
-            } else {
-                assert!(event2.is_ok());
-            }
-        })
-    }
-
     #[test]
     fn test_force_normalize() {
         let force = event::Force::Normalized(0.0);
         assert_eq!(force.normalized(), 0.0);
 
-        let force2 = event::Force::Calibrated {
-            force: 5.0,
-            max_possible_force: 2.5,
-            altitude_angle: None,
-        };
+        let force2 =
+            event::Force::Calibrated { force: 5.0, max_possible_force: 2.5, altitude_angle: None };
         assert_eq!(force2.normalized(), 2.0);
 
         let force3 = event::Force::Calibrated {
@@ -1194,7 +1127,7 @@ mod tests {
     #[allow(clippy::clone_on_copy)]
     #[test]
     fn ensure_attrs_do_not_panic() {
-        foreach_event!(|event: event::Event<()>| {
+        foreach_event!(|event: event::Event| {
             let _ = format!("{:?}", event);
         });
         let _ = event::StartCause::Init.clone();
@@ -1219,11 +1152,8 @@ mod tests {
             force: Some(event::Force::Normalized(0.0)),
         }
         .clone();
-        let _ = event::Force::Calibrated {
-            force: 0.0,
-            max_possible_force: 0.0,
-            altitude_angle: None,
-        }
-        .clone();
+        let _ =
+            event::Force::Calibrated { force: 0.0, max_possible_force: 0.0, altitude_angle: None }
+                .clone();
     }
 }

src/event_loop.rs

@@ -3,15 +3,16 @@
 //!
 //! If you want to send custom events to the event loop, use
 //! [`EventLoop::create_proxy`] to acquire an [`EventLoopProxy`] and call its
-//! [`send_event`](`EventLoopProxy::send_event`) method.
+//! [`wake_up`][EventLoopProxy::wake_up] method. Then during handling the wake up
+//! you can poll your event sources.
 //!
 //! See the root-level documentation for information on how to create and use an event loop to
 //! handle events.
+use std::fmt;
 use std::marker::PhantomData;
 #[cfg(any(x11_platform, wayland_platform))]
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::{error, fmt};
 
 #[cfg(not(web_platform))]
 use std::time::{Duration, Instant};
@@ -20,8 +21,9 @@ use web_time::{Duration, Instant};
 
 use crate::application::ApplicationHandler;
 use crate::error::{EventLoopError, OsError};
+use crate::monitor::MonitorHandle;
+use crate::platform_impl;
 use crate::window::{CustomCursor, CustomCursorSource, Window, WindowAttributes};
-use crate::{event::Event, monitor::MonitorHandle, platform_impl};
 
 /// Provides a way to retrieve events from the system and from the windows that were registered to
 /// the events loop.
@@ -33,13 +35,13 @@ use crate::{event::Event, monitor::MonitorHandle, platform_impl};
 /// To wake up an `EventLoop` from a another thread, see the [`EventLoopProxy`] docs.
 ///
 /// Note that this cannot be shared across threads (due to platform-dependant logic
-/// forbidding it), as such it is neither [`Send`] nor [`Sync`]. If you need cross-thread access, the
-/// [`Window`] created from this _can_ be sent to an other thread, and the
+/// forbidding it), as such it is neither [`Send`] nor [`Sync`]. If you need cross-thread access,
+/// the [`Window`] created from this _can_ be sent to an other thread, and the
 /// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread.
 ///
 /// [`Window`]: crate::window::Window
-pub struct EventLoop<T: 'static> {
-    pub(crate) event_loop: platform_impl::EventLoop<T>,
+pub struct EventLoop {
+    pub(crate) event_loop: platform_impl::EventLoop,
     pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
 }
 
@@ -57,16 +59,15 @@ pub struct ActiveEventLoop {
 /// This is used to make specifying options that affect the whole application
 /// easier. But note that constructing multiple event loops is not supported.
 ///
-/// This can be created using [`EventLoop::new`] or [`EventLoop::with_user_event`].
+/// This can be created using [`EventLoop::builder`].
 #[derive(Default)]
-pub struct EventLoopBuilder<T: 'static> {
+pub struct EventLoopBuilder {
     pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
-    _p: PhantomData<T>,
 }
 
 static EVENT_LOOP_CREATED: AtomicBool = AtomicBool::new(false);
 
-impl EventLoopBuilder<()> {
+impl EventLoopBuilder {
     /// Start building a new event loop.
     #[inline]
     #[deprecated = "use `EventLoop::builder` instead"]
@@ -75,7 +76,7 @@ impl EventLoopBuilder<()> {
     }
 }
 
-impl<T> EventLoopBuilder<T> {
+impl EventLoopBuilder {
     /// Builds a new event loop.
     ///
     /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
@@ -94,22 +95,23 @@ impl<T> EventLoopBuilder<T> {
     ///
     /// ## Platform-specific
     ///
-    /// - **Wayland/X11:** to prevent running under `Wayland` or `X11` unset `WAYLAND_DISPLAY`
-    ///                    or `DISPLAY` respectively when building the event loop.
+    /// - **Wayland/X11:** to prevent running under `Wayland` or `X11` unset `WAYLAND_DISPLAY` or
+    ///   `DISPLAY` respectively when building the event loop.
     /// - **Android:** must be configured with an `AndroidApp` from `android_main()` by calling
-    ///     [`.with_android_app(app)`] before calling `.build()`, otherwise it'll panic.
+    ///   [`.with_android_app(app)`] before calling `.build()`, otherwise it'll panic.
     ///
     /// [`platform`]: crate::platform
     #[cfg_attr(
-        android,
-        doc = "[`.with_android_app(app)`]: crate::platform::android::EventLoopBuilderExtAndroid::with_android_app"
+        android_platform,
+        doc = "[`.with_android_app(app)`]: \
+               crate::platform::android::EventLoopBuilderExtAndroid::with_android_app"
     )]
     #[cfg_attr(
-        not(android),
+        not(android_platform),
         doc = "[`.with_android_app(app)`]: #only-available-on-android"
     )]
     #[inline]
-    pub fn build(&mut self) -> Result<EventLoop<T>, EventLoopError> {
+    pub fn build(&mut self) -> Result<EventLoop, EventLoopError> {
         let _span = tracing::debug_span!("winit::EventLoopBuilder::build").entered();
 
         if EVENT_LOOP_CREATED.swap(true, Ordering::Relaxed) {
@@ -130,7 +132,7 @@ impl<T> EventLoopBuilder<T> {
     }
 }
 
-impl<T> fmt::Debug for EventLoop<T> {
+impl fmt::Debug for EventLoop {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("EventLoop { .. }")
     }
@@ -144,11 +146,12 @@ impl fmt::Debug for ActiveEventLoop {
 
 /// Set through [`ActiveEventLoop::set_control_flow()`].
 ///
-/// Indicates the desired behavior of the event loop after [`Event::AboutToWait`] is emitted.
+/// Indicates the desired behavior of the event loop after [`about_to_wait`] is called.
 ///
 /// Defaults to [`Wait`].
 ///
 /// [`Wait`]: Self::Wait
+/// [`about_to_wait`]: crate::application::ApplicationHandler::about_to_wait
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 pub enum ControlFlow {
     /// When the current loop iteration finishes, immediately begin a new iteration regardless of
@@ -162,9 +165,9 @@ pub enum ControlFlow {
     /// When the current loop iteration finishes, suspend the thread until either another event
     /// arrives or the given time is reached.
     ///
-    /// Useful for implementing efficient timers. Applications which want to render at the display's
-    /// native refresh rate should instead use [`Poll`] and the VSync functionality of a graphics API
-    /// to reduce odds of missed frames.
+    /// Useful for implementing efficient timers. Applications which want to render at the
+    /// display's native refresh rate should instead use [`Poll`] and the VSync functionality
+    /// of a graphics API to reduce odds of missed frames.
     ///
     /// [`Poll`]: Self::Poll
     WaitUntil(Instant),
@@ -186,12 +189,12 @@ impl ControlFlow {
     }
 }
 
-impl EventLoop<()> {
+impl EventLoop {
     /// Create the event loop.
     ///
     /// This is an alias of `EventLoop::builder().build()`.
     #[inline]
-    pub fn new() -> Result<EventLoop<()>, EventLoopError> {
+    pub fn new() -> Result<EventLoop, EventLoopError> {
         Self::builder().build()
     }
 
@@ -201,36 +204,12 @@ impl EventLoop<()> {
     ///
     /// To get the actual event loop, call [`build`][EventLoopBuilder::build] on that.
     #[inline]
-    pub fn builder() -> EventLoopBuilder<()> {
-        Self::with_user_event()
+    pub fn builder() -> EventLoopBuilder {
+        EventLoopBuilder { platform_specific: Default::default() }
     }
 }
 
-impl<T> EventLoop<T> {
-    /// Start building a new event loop, with the given type as the user event
-    /// type.
-    pub fn with_user_event() -> EventLoopBuilder<T> {
-        EventLoopBuilder {
-            platform_specific: Default::default(),
-            _p: PhantomData,
-        }
-    }
-
-    /// See [`run_app`].
-    ///
-    /// [`run_app`]: Self::run_app
-    #[inline]
-    #[deprecated = "use `EventLoop::run_app` instead"]
-    #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
-    pub fn run<F>(self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &ActiveEventLoop),
-    {
-        let _span = tracing::debug_span!("winit::EventLoop::run").entered();
-
-        self.event_loop.run(event_handler)
-    }
-
+impl EventLoop {
     /// Run the application with the event loop on the calling thread.
     ///
     /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
@@ -239,9 +218,9 @@ impl<T> EventLoop<T> {
     ///
     /// - **iOS:** Will never return to the caller and so values not passed to this function will
     ///   *not* be dropped before the process exits.
-    /// - **Web:** Will _act_ as if it never returns to the caller by throwing a Javascript exception
-    ///   (that Rust doesn't see) that will also mean that the rest of the function is never executed
-    ///   and any values not passed to this function will *not* be dropped.
+    /// - **Web:** Will _act_ as if it never returns to the caller by throwing a Javascript
+    ///   exception (that Rust doesn't see) that will also mean that the rest of the function is
+    ///   never executed and any values not passed to this function will *not* be dropped.
     ///
     ///   Web applications are recommended to use
     #[cfg_attr(
@@ -261,26 +240,21 @@ impl<T> EventLoop<T> {
     /// [^1]: `EventLoopExtWebSys::spawn_app()` is only available on Web.
     #[inline]
     #[cfg(not(all(web_platform, target_feature = "exception-handling")))]
-    pub fn run_app<A: ApplicationHandler<T>>(self, app: &mut A) -> Result<(), EventLoopError> {
-        self.event_loop
-            .run(|event, event_loop| dispatch_event_for_app(app, event_loop, event))
+    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> Result<(), EventLoopError> {
+        self.event_loop.run_app(app)
     }
 
     /// Creates an [`EventLoopProxy`] that can be used to dispatch user events
     /// to the main event loop, possibly from another thread.
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy {
-            event_loop_proxy: self.event_loop.create_proxy(),
-        }
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        EventLoopProxy { event_loop_proxy: self.event_loop.create_proxy() }
     }
 
     /// Gets a persistent reference to the underlying platform display.
     ///
     /// See the [`OwnedDisplayHandle`] type for more information.
     pub fn owned_display_handle(&self) -> OwnedDisplayHandle {
-        OwnedDisplayHandle {
-            platform: self.event_loop.window_target().p.owned_display_handle(),
-        }
+        OwnedDisplayHandle { platform: self.event_loop.window_target().p.owned_display_handle() }
     }
 
     /// Change if or when [`DeviceEvent`]s are captured.
@@ -295,18 +269,12 @@ impl<T> EventLoop<T> {
         )
         .entered();
 
-        self.event_loop
-            .window_target()
-            .p
-            .listen_device_events(allowed);
+        self.event_loop.window_target().p.listen_device_events(allowed);
     }
 
     /// Sets the [`ControlFlow`].
     pub fn set_control_flow(&self, control_flow: ControlFlow) {
-        self.event_loop
-            .window_target()
-            .p
-            .set_control_flow(control_flow)
+        self.event_loop.window_target().p.set_control_flow(control_flow)
     }
 
     /// Create a window.
@@ -329,22 +297,19 @@ impl<T> EventLoop<T> {
 
     /// Create custom cursor.
     pub fn create_custom_cursor(&self, custom_cursor: CustomCursorSource) -> CustomCursor {
-        self.event_loop
-            .window_target()
-            .p
-            .create_custom_cursor(custom_cursor)
+        self.event_loop.window_target().p.create_custom_cursor(custom_cursor)
     }
 }
 
 #[cfg(feature = "rwh_06")]
-impl<T> rwh_06::HasDisplayHandle for EventLoop<T> {
+impl rwh_06::HasDisplayHandle for EventLoop {
     fn display_handle(&self) -> Result<rwh_06::DisplayHandle<'_>, rwh_06::HandleError> {
         rwh_06::HasDisplayHandle::display_handle(self.event_loop.window_target())
     }
 }
 
 #[cfg(feature = "rwh_05")]
-unsafe impl<T> rwh_05::HasRawDisplayHandle for EventLoop<T> {
+unsafe impl rwh_05::HasRawDisplayHandle for EventLoop {
     /// Returns a [`rwh_05::RawDisplayHandle`] for the event loop.
     fn raw_display_handle(&self) -> rwh_05::RawDisplayHandle {
         rwh_05::HasRawDisplayHandle::raw_display_handle(self.event_loop.window_target())
@@ -352,7 +317,7 @@ unsafe impl<T> rwh_05::HasRawDisplayHandle for EventLoop<T> {
 }
 
 #[cfg(any(x11_platform, wayland_platform))]
-impl<T> AsFd for EventLoop<T> {
+impl AsFd for EventLoop {
     /// Get the underlying [EventLoop]'s `fd` which you can register
     /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
     /// loop must be polled with the [`pump_app_events`] API.
@@ -366,7 +331,7 @@ impl<T> AsFd for EventLoop<T> {
 }
 
 #[cfg(any(x11_platform, wayland_platform))]
-impl<T> AsRawFd for EventLoop<T> {
+impl AsRawFd for EventLoop {
     /// Get the underlying [EventLoop]'s raw `fd` which you can register
     /// into other event loop, like [`calloop`] or [`mio`]. When doing so, the
     /// loop must be polled with the [`pump_app_events`] API.
@@ -413,10 +378,7 @@ impl ActiveEventLoop {
         let _span = tracing::debug_span!("winit::ActiveEventLoop::available_monitors",).entered();
 
         #[allow(clippy::useless_conversion)] // false positive on some platforms
-        self.p
-            .available_monitors()
-            .into_iter()
-            .map(|inner| MonitorHandle { inner })
+        self.p.available_monitors().into_iter().map(|inner| MonitorHandle { inner })
     }
 
     /// Returns the primary monitor of the system.
@@ -430,9 +392,7 @@ impl ActiveEventLoop {
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
         let _span = tracing::debug_span!("winit::ActiveEventLoop::primary_monitor",).entered();
 
-        self.p
-            .primary_monitor()
-            .map(|inner| MonitorHandle { inner })
+        self.p.primary_monitor().map(|inner| MonitorHandle { inner })
     }
 
     /// Change if or when [`DeviceEvent`]s are captured.
@@ -468,7 +428,7 @@ impl ActiveEventLoop {
 
     /// This exits the event loop.
     ///
-    /// See [`LoopExiting`](Event::LoopExiting).
+    /// See [`exiting`][crate::application::ApplicationHandler::exiting].
     pub fn exit(&self) {
         let _span = tracing::debug_span!("winit::ActiveEventLoop::exit",).entered();
 
@@ -477,7 +437,7 @@ impl ActiveEventLoop {
 
     /// Returns if the [`EventLoop`] is about to stop.
     ///
-    /// See [`exit()`](Self::exit).
+    /// See [`exit()`][Self::exit].
     pub fn exiting(&self) -> bool {
         self.p.exiting()
     }
@@ -486,9 +446,7 @@ impl ActiveEventLoop {
     ///
     /// See the [`OwnedDisplayHandle`] type for more information.
     pub fn owned_display_handle(&self) -> OwnedDisplayHandle {
-        OwnedDisplayHandle {
-            platform: self.p.owned_display_handle(),
-        }
+        OwnedDisplayHandle { platform: self.p.owned_display_handle() }
     }
 }
 
@@ -555,55 +513,39 @@ unsafe impl rwh_05::HasRawDisplayHandle for OwnedDisplayHandle {
     }
 }
 
-/// Used to send custom events to [`EventLoop`].
-pub struct EventLoopProxy<T: 'static> {
-    event_loop_proxy: platform_impl::EventLoopProxy<T>,
+/// Control the [`EventLoop`], possibly from a different thread, without referencing it directly.
+#[derive(Clone)]
+pub struct EventLoopProxy {
+    event_loop_proxy: platform_impl::EventLoopProxy,
 }
 
-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        Self {
-            event_loop_proxy: self.event_loop_proxy.clone(),
-        }
+impl EventLoopProxy {
+    /// Wake up the [`EventLoop`], resulting in [`ApplicationHandler::proxy_wake_up()`] being
+    /// called.
+    ///
+    /// Calls to this method are coalesced into a single call to [`proxy_wake_up`], see the
+    /// documentation on that for details.
+    ///
+    /// If the event loop is no longer running, this is a no-op.
+    ///
+    /// [`proxy_wake_up`]: ApplicationHandler::proxy_wake_up
+    ///
+    /// # Platform-specific
+    ///
+    /// - **Windows**: The wake-up may be ignored under high contention, see [#3687].
+    ///
+    /// [#3687]: https://github.com/rust-windowing/winit/pull/3687
+    pub fn wake_up(&self) {
+        self.event_loop_proxy.wake_up();
     }
 }
 
-impl<T: 'static> EventLoopProxy<T> {
-    /// Send an event to the [`EventLoop`] from which this proxy was created. This emits a
-    /// `UserEvent(event)` event in the event loop, where `event` is the value passed to this
-    /// function.
-    ///
-    /// Returns an `Err` if the associated [`EventLoop`] no longer exists.
-    ///
-    /// [`UserEvent(event)`]: Event::UserEvent
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        let _span = tracing::debug_span!("winit::EventLoopProxy::send_event",).entered();
-
-        self.event_loop_proxy.send_event(event)
-    }
-}
-
-impl<T: 'static> fmt::Debug for EventLoopProxy<T> {
+impl fmt::Debug for EventLoopProxy {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.pad("EventLoopProxy { .. }")
     }
 }
 
-/// The error that is returned when an [`EventLoopProxy`] attempts to wake up an [`EventLoop`] that
-/// no longer exists.
-///
-/// Contains the original event given to [`EventLoopProxy::send_event`].
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
-pub struct EventLoopClosed<T>(pub T);
-
-impl<T> fmt::Display for EventLoopClosed<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("Tried to wake up a closed `EventLoop`")
-    }
-}
-
-impl<T: fmt::Debug> error::Error for EventLoopClosed<T> {}
-
 /// Control when device events are captured.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
 pub enum DeviceEvents {
@@ -641,23 +583,3 @@ impl AsyncRequestSerial {
         Self { serial }
     }
 }
-
-/// Shim for various run APIs.
-#[inline(always)]
-pub(crate) fn dispatch_event_for_app<T: 'static, A: ApplicationHandler<T>>(
-    app: &mut A,
-    event_loop: &ActiveEventLoop,
-    event: Event<T>,
-) {
-    match event {
-        Event::NewEvents(cause) => app.new_events(event_loop, cause),
-        Event::WindowEvent { window_id, event } => app.window_event(event_loop, window_id, event),
-        Event::DeviceEvent { device_id, event } => app.device_event(event_loop, device_id, event),
-        Event::UserEvent(event) => app.user_event(event_loop, event),
-        Event::Suspended => app.suspended(event_loop),
-        Event::Resumed => app.resumed(event_loop),
-        Event::AboutToWait => app.about_to_wait(event_loop),
-        Event::LoopExiting => app.exiting(event_loop),
-        Event::MemoryWarning => app.memory_warning(event_loop),
-    }
-}

src/icon.rs

@@ -1,5 +1,6 @@
 use crate::platform_impl::PlatformIcon;
-use std::{error::Error, fmt, io, mem};
+use std::error::Error;
+use std::{fmt, io, mem};
 
 #[repr(C)]
 #[derive(Debug)]
@@ -20,12 +21,7 @@ pub enum BadIcon {
     ByteCountNotDivisibleBy4 { byte_count: usize },
     /// Produced when the number of pixels (`rgba.len() / 4`) isn't equal to `width * height`.
     /// At least one of your arguments is incorrect.
-    DimensionsVsPixelCount {
-        width: u32,
-        height: u32,
-        width_x_height: usize,
-        pixel_count: usize,
-    },
+    DimensionsVsPixelCount { width: u32, height: u32, width_x_height: usize, pixel_count: usize },
     /// Produced when underlying OS functionality failed to create the icon
     OsError(io::Error),
 }
@@ -33,17 +29,19 @@ pub enum BadIcon {
 impl fmt::Display for BadIcon {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            BadIcon::ByteCountNotDivisibleBy4 { byte_count } => write!(f,
-                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
-            ),
-            BadIcon::DimensionsVsPixelCount {
-                width,
-                height,
-                width_x_height,
-                pixel_count,
-            } => write!(f,
-                "The specified dimensions ({width:?}x{height:?}) don't match the number of pixels supplied by the `rgba` argument ({pixel_count:?}). For those dimensions, the expected pixel count is {width_x_height:?}.",
+            BadIcon::ByteCountNotDivisibleBy4 { byte_count } => write!(
+                f,
+                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making \
+                 it impossible to interpret as 32bpp RGBA pixels.",
             ),
+            BadIcon::DimensionsVsPixelCount { width, height, width_x_height, pixel_count } => {
+                write!(
+                    f,
+                    "The specified dimensions ({width:?}x{height:?}) don't match the number of \
+                     pixels supplied by the `rgba` argument ({pixel_count:?}). For those \
+                     dimensions, the expected pixel count is {width_x_height:?}.",
+                )
+            },
             BadIcon::OsError(e) => write!(f, "OS error when instantiating the icon: {e:?}"),
         }
     }
@@ -69,9 +67,7 @@ mod constructors {
     impl RgbaIcon {
         pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
             if rgba.len() % PIXEL_SIZE != 0 {
-                return Err(BadIcon::ByteCountNotDivisibleBy4 {
-                    byte_count: rgba.len(),
-                });
+                return Err(BadIcon::ByteCountNotDivisibleBy4 { byte_count: rgba.len() });
             }
             let pixel_count = rgba.len() / PIXEL_SIZE;
             if pixel_count != (width * height) as usize {
@@ -82,11 +78,7 @@ mod constructors {
                     pixel_count,
                 })
             } else {
-                Ok(RgbaIcon {
-                    rgba,
-                    width,
-                    height,
-                })
+                Ok(RgbaIcon { rgba, width, height })
             }
         }
     }
@@ -120,8 +112,6 @@ impl Icon {
     pub fn from_rgba(rgba: Vec<u8>, width: u32, height: u32) -> Result<Self, BadIcon> {
         let _span = tracing::debug_span!("winit::Icon::from_rgba", width, height).entered();
 
-        Ok(Icon {
-            inner: PlatformIcon::from_rgba(rgba, width, height)?,
-        })
+        Ok(Icon { inner: PlatformIcon::from_rgba(rgba, width, height)? })
     }
 }

src/keyboard.rs

@@ -106,23 +106,23 @@ impl std::fmt::Debug for NativeKeyCode {
         match self {
             Unidentified => {
                 debug_tuple = f.debug_tuple("Unidentified");
-            }
+            },
             Android(code) => {
                 debug_tuple = f.debug_tuple("Android");
                 debug_tuple.field(&format_args!("0x{code:04X}"));
-            }
+            },
             MacOS(code) => {
                 debug_tuple = f.debug_tuple("MacOS");
                 debug_tuple.field(&format_args!("0x{code:04X}"));
-            }
+            },
             Windows(code) => {
                 debug_tuple = f.debug_tuple("Windows");
                 debug_tuple.field(&format_args!("0x{code:04X}"));
-            }
+            },
             Xkb(code) => {
                 debug_tuple = f.debug_tuple("Xkb");
                 debug_tuple.field(&format_args!("0x{code:04X}"));
-            }
+            },
         }
         debug_tuple.finish()
     }
@@ -162,27 +162,27 @@ impl std::fmt::Debug for NativeKey {
         match self {
             Unidentified => {
                 debug_tuple = f.debug_tuple("Unidentified");
-            }
+            },
             Android(code) => {
                 debug_tuple = f.debug_tuple("Android");
                 debug_tuple.field(&format_args!("0x{code:04X}"));
-            }
+            },
             MacOS(code) => {
                 debug_tuple = f.debug_tuple("MacOS");
                 debug_tuple.field(&format_args!("0x{code:04X}"));
-            }
+            },
             Windows(code) => {
                 debug_tuple = f.debug_tuple("Windows");
                 debug_tuple.field(&format_args!("0x{code:04X}"));
-            }
+            },
             Xkb(code) => {
                 debug_tuple = f.debug_tuple("Xkb");
                 debug_tuple.field(&format_args!("0x{code:04X}"));
-            }
+            },
             Web(code) => {
                 debug_tuple = f.debug_tuple("Web");
                 debug_tuple.field(code);
-            }
+            },
         }
         debug_tuple.finish()
     }
@@ -218,7 +218,7 @@ impl PartialEq<NativeKeyCode> for NativeKey {
 
 /// Represents the location of a physical key.
 ///
-/// This type is a superset of [`KeyCode`], including an [`Unidentified`](Self::Unidentified)
+/// This type is a superset of [`KeyCode`], including an [`Unidentified`][Self::Unidentified]
 /// variant.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -442,7 +442,8 @@ pub enum KeyCode {
     Tab,
     /// Japanese: <kbd>変</kbd> (henkan)
     Convert,
-    /// Japanese: <kbd>カタカナ</kbd>/<kbd>ひらがな</kbd>/<kbd>ローマ字</kbd> (katakana/hiragana/romaji)
+    /// Japanese: <kbd>カタカナ</kbd>/<kbd>ひらがな</kbd>/<kbd>ローマ字</kbd>
+    /// (katakana/hiragana/romaji)
     KanaMode,
     /// Korean: HangulMode <kbd>한/영</kbd> (han/yeong)
     ///
@@ -490,7 +491,8 @@ pub enum KeyCode {
     NumLock,
     /// <kbd>0 Ins</kbd> on a keyboard. <kbd>0</kbd> on a phone or remote control
     Numpad0,
-    /// <kbd>1 End</kbd> on a keyboard. <kbd>1</kbd> or <kbd>1 QZ</kbd> on a phone or remote control
+    /// <kbd>1 End</kbd> on a keyboard. <kbd>1</kbd> or <kbd>1 QZ</kbd> on a phone or remote
+    /// control
     Numpad1,
     /// <kbd>2 ↓</kbd> on a keyboard. <kbd>2 ABC</kbd> on a phone or remote control
     Numpad2,
@@ -794,13 +796,14 @@ pub enum NamedKey {
     // Legacy modifier key.
     Hyper,
     /// Used to enable "super" modifier function for interpreting concurrent or subsequent keyboard
-    /// input. This key value is used for the "Windows Logo" key and the Apple `Command` or `⌘` key.
+    /// input. This key value is used for the "Windows Logo" key and the Apple `Command` or `⌘`
+    /// key.
     ///
     /// Note: In some contexts (e.g. the Web) this is referred to as the "Meta" key.
     Super,
-    /// The `Enter` or `↵` key. Used to activate current selection or accept current input. This key
-    /// value is also used for the `Return` (Macintosh numpad) key. This key value is also used for
-    /// the Android `KEYCODE_DPAD_CENTER`.
+    /// The `Enter` or `↵` key. Used to activate current selection or accept current input. This
+    /// key value is also used for the `Return` (Macintosh numpad) key. This key value is also
+    /// used for the Android `KEYCODE_DPAD_CENTER`.
     Enter,
     /// The Horizontal Tabulation `Tab` key.
     Tab,
@@ -836,8 +839,8 @@ pub enum NamedKey {
     CrSel,
     /// Cut the current selection. (`APPCOMMAND_CUT`)
     Cut,
-    /// Used to delete the character to the right of the cursor. This key value is also used for the
-    /// key labeled `Delete` on MacOS keyboards when `Fn` is active.
+    /// Used to delete the character to the right of the cursor. This key value is also used for
+    /// the key labeled `Delete` on MacOS keyboards when `Fn` is active.
     Delete,
     /// The Erase to End of Field key. This key deletes all characters from the current cursor
     /// position to the end of the current field.
@@ -921,8 +924,8 @@ pub enum NamedKey {
     /// their code points.
     CodeInput,
     /// The Compose key, also known as "Multi_key" on the X Window System. This key acts in a
-    /// manner similar to a dead key, triggering a mode where subsequent key presses are combined to
-    /// produce a different character.
+    /// manner similar to a dead key, triggering a mode where subsequent key presses are combined
+    /// to produce a different character.
     Compose,
     /// Convert the current input method sequence.
     Convert,
@@ -961,9 +964,9 @@ pub enum NamedKey {
     /// The Kana Mode (Kana Lock) key. This key is used to enter hiragana mode (typically from
     /// romaji mode).
     KanaMode,
-    /// The Kanji (Japanese name for ideographic characters of Chinese origin) Mode key. This key is
-    /// typically used to switch to a hiragana keyboard for the purpose of converting input into
-    /// kanji. (`KEYCODE_KANA`)
+    /// The Kanji (Japanese name for ideographic characters of Chinese origin) Mode key. This key
+    /// is typically used to switch to a hiragana keyboard for the purpose of converting input
+    /// into kanji. (`KEYCODE_KANA`)
     KanjiMode,
     /// The Katakana (Japanese Kana characters) key.
     Katakana,
@@ -1588,7 +1591,7 @@ impl Key {
     /// # Examples
     ///
     /// ```
-    /// use winit::keyboard::{NamedKey, Key};
+    /// use winit::keyboard::{Key, NamedKey};
     ///
     /// assert_eq!(Key::Character("a".into()).to_text(), Some("a"));
     /// assert_eq!(Key::Named(NamedKey::Enter).to_text(), Some("\r"));
@@ -1610,7 +1613,8 @@ impl Key {
 /// keys can be above the letters or on the numpad. This enum allows the user to differentiate
 /// them.
 ///
-/// See the documentation for the [`location`] field on the [`KeyEvent`] struct for more information.
+/// See the documentation for the [`location`] field on the [`KeyEvent`] struct for more
+/// information.
 ///
 /// [`location`]: ../event/struct.KeyEvent.html#structfield.location
 /// [`KeyEvent`]: crate::event::KeyEvent
@@ -1619,8 +1623,8 @@ impl Key {
 pub enum KeyLocation {
     /// The key is in its "normal" location on the keyboard.
     ///
-    /// For instance, the "1" key above the "Q" key on a QWERTY keyboard will use this location. This
-    /// invariant is also returned when the location of the key cannot be identified.
+    /// For instance, the "1" key above the "Q" key on a QWERTY keyboard will use this location.
+    /// This invariant is also returned when the location of the key cannot be identified.
     ///
     /// ![Standard 1 key](https://raw.githubusercontent.com/rust-windowing/winit/master/docs/res/keyboard_standard_1_key.svg)
     ///
@@ -1703,14 +1707,17 @@ impl ModifiersState {
     pub fn shift_key(&self) -> bool {
         self.intersects(Self::SHIFT)
     }
+
     /// Returns `true` if the control key is pressed.
     pub fn control_key(&self) -> bool {
         self.intersects(Self::CONTROL)
     }
+
     /// Returns `true` if the alt key is pressed.
     pub fn alt_key(&self) -> bool {
         self.intersects(Self::ALT)
     }
+
     /// Returns `true` if the super key is pressed.
     pub fn super_key(&self) -> bool {
         self.intersects(Self::SUPER)
@@ -1784,12 +1791,8 @@ mod modifiers_serde {
         where
             D: Deserializer<'de>,
         {
-            let ModifiersStateSerialize {
-                shift_key,
-                control_key,
-                alt_key,
-                super_key,
-            } = ModifiersStateSerialize::deserialize(deserializer)?;
+            let ModifiersStateSerialize { shift_key, control_key, alt_key, super_key } =
+                ModifiersStateSerialize::deserialize(deserializer)?;
             let mut m = ModifiersState::empty();
             m.set(ModifiersState::SHIFT, shift_key);
             m.set(ModifiersState::CONTROL, control_key);

src/lib.rs

@@ -19,33 +19,21 @@
 //! window or a key getting pressed while the window is focused. Devices can generate
 //! [`DeviceEvent`]s, which contain unfiltered event data that isn't specific to a certain window.
 //! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
-//! [`DeviceEvent`]. You can also create and handle your own custom [`Event::UserEvent`]s, if desired.
+//! [`DeviceEvent`].
 //!
 //! You can retrieve events by calling [`EventLoop::run_app()`]. This function will
 //! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
-//! will run until [`exit()`] is used, at which point [`Event::LoopExiting`].
+//! will run until [`exit()`] is used, at which point [`exiting()`] is called.
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
-//! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works poorly on
-//! most other platforms. However, this model can be re-implemented to an extent with
+//! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works
+//! poorly on most other platforms. However, this model can be re-implemented to an extent with
 #![cfg_attr(
-    any(
-        windows_platform,
-        macos_platform,
-        android_platform,
-        x11_platform,
-        wayland_platform
-    ),
+    any(windows_platform, macos_platform, android_platform, x11_platform, wayland_platform),
     doc = "[`EventLoopExtPumpEvents::pump_app_events()`][platform::pump_events::EventLoopExtPumpEvents::pump_app_events()]"
 )]
 #![cfg_attr(
-    not(any(
-        windows_platform,
-        macos_platform,
-        android_platform,
-        x11_platform,
-        wayland_platform
-    )),
+    not(any(windows_platform, macos_platform, android_platform, x11_platform, wayland_platform)),
     doc = "`EventLoopExtPumpEvents::pump_app_events()`"
 )]
 //! [^1]. See that method's documentation for more reasons about why
@@ -116,16 +104,16 @@
 //!
 //! # Drawing on the window
 //!
-//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However, it allows you to
-//! retrieve the raw handle of the window and display (see the [`platform`] module and/or the
+//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However, it allows you
+//! to retrieve the raw handle of the window and display (see the [`platform`] module and/or the
 //! [`raw_window_handle`] and [`raw_display_handle`] methods), which in turn allows
 //! you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
 //!
 //! Note that many platforms will display garbage data in the window's client area if the
 //! application doesn't render anything to the window by the time the desktop compositor is ready to
 //! display the window to the user. If you notice this happening, you should create the window with
-//! [`visible` set to `false`](crate::window::WindowAttributes::with_visible) and explicitly make the
-//! window visible only once you're ready to render into it.
+//! [`visible` set to `false`][crate::window::WindowAttributes::with_visible] and explicitly make
+//! the window visible only once you're ready to render into it.
 //!
 //! # UI scaling
 //!
@@ -151,13 +139,11 @@
 //! Winit provides the following Cargo features:
 //!
 //! * `x11` (enabled by default): On Unix platforms, enables the X11 backend.
-//! * `wayland` (enabled by default): On Unix platforms, enables the Wayland
-//!   backend.
+//! * `wayland` (enabled by default): On Unix platforms, enables the Wayland backend.
 //! * `rwh_04`: Implement `raw-window-handle v0.4` traits.
 //! * `rwh_05`: Implement `raw-window-handle v0.5` traits.
 //! * `rwh_06`: Implement `raw-window-handle v0.6` traits.
-//! * `serde`: Enables serialization/deserialization of certain types with
-//!   [Serde](https://crates.io/crates/serde).
+//! * `serde`: Enables serialization/deserialization of certain types with [Serde](https://crates.io/crates/serde).
 //! * `mint`: Enables mint (math interoperability standard types) conversions.
 //!
 //! See the [`platform`] module for documentation on platform-specific cargo
@@ -176,7 +162,7 @@
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
 //! [`Event::UserEvent`]: event::Event::UserEvent
-//! [`Event::LoopExiting`]: event::Event::LoopExiting
+//! [`exiting()`]: crate::application::ApplicationHandler::exiting
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 //! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
 //! [^1]: `EventLoopExtPumpEvents::pump_app_events()` is only available on Windows, macOS, Android, X11 and Wayland.
@@ -186,14 +172,15 @@
 #![deny(clippy::all)]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![cfg_attr(clippy, deny(warnings))]
-// Doc feature labels can be tested locally by running RUSTDOCFLAGS="--cfg=docsrs" cargo +nightly doc
-#![cfg_attr(
-    docsrs,
-    feature(doc_auto_cfg, doc_cfg_hide),
-    doc(cfg_hide(doc, docsrs))
-)]
+// Doc feature labels can be tested locally by running RUSTDOCFLAGS="--cfg=docsrs" cargo +nightly
+// doc
+#![cfg_attr(docsrs, feature(doc_auto_cfg, doc_cfg_hide), doc(cfg_hide(doc, docsrs)))]
 #![allow(clippy::missing_safety_doc)]
 
+#[cfg(feature = "rwh_04")]
+pub use rwh_04 as raw_window_handle_04;
+#[cfg(feature = "rwh_05")]
+pub use rwh_05 as raw_window_handle_05;
 #[cfg(feature = "rwh_06")]
 pub use rwh_06 as raw_window_handle;
 

src/monitor.rs

@@ -3,12 +3,10 @@
 //! If you want to get basic information about a monitor, you can use the
 //! [`MonitorHandle`] type. This is retrieved from one of the following
 //! methods, which return an iterator of [`MonitorHandle`]:
-//! - [`ActiveEventLoop::available_monitors`](crate::event_loop::ActiveEventLoop::available_monitors).
-//! - [`Window::available_monitors`](crate::window::Window::available_monitors).
-use crate::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    platform_impl,
-};
+//! - [`ActiveEventLoop::available_monitors`][crate::event_loop::ActiveEventLoop::available_monitors].
+//! - [`Window::available_monitors`][crate::window::Window::available_monitors].
+use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::platform_impl;
 
 /// Deprecated! Use `VideoModeHandle` instead.
 #[deprecated = "Renamed to `VideoModeHandle`"]
@@ -79,9 +77,7 @@ impl VideoModeHandle {
     /// a separate set of valid video modes.
     #[inline]
     pub fn monitor(&self) -> MonitorHandle {
-        MonitorHandle {
-            inner: self.video_mode.monitor(),
-        }
+        MonitorHandle { inner: self.video_mode.monitor() }
     }
 }
 
@@ -166,8 +162,6 @@ impl MonitorHandle {
     /// - **Web:** Always returns an empty iterator
     #[inline]
     pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
-        self.inner
-            .video_modes()
-            .map(|video_mode| VideoModeHandle { video_mode })
+        self.inner.video_modes().map(|video_mode| VideoModeHandle { video_mode })
     }
 }

src/platform/android.rs

@@ -19,6 +19,7 @@
 //!
 //! | winit |       ndk-glue               |
 //! | :---: | :--------------------------: |
+//! | 0.30  | `android-activity = "0.6"`   |
 //! | 0.29  | `android-activity = "0.5"`   |
 //! | 0.28  | `android-activity = "0.4"`   |
 //! | 0.27  | `ndk-glue = "0.7"`           |
@@ -58,23 +59,26 @@
 //!
 //! ## Converting from `ndk-glue` to `android-activity`
 //!
-//! If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building with `cargo apk`, then the minimal changes would be:
+//! If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building
+//! with `cargo apk`, then the minimal changes would be:
 //! 1. Remove `ndk-glue` from your `Cargo.toml`
-//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.15", features = [ "android-native-activity" ] }`
-//! 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize logging as above).
-//! 4. Pass a clone of the `AndroidApp` that your application receives to Winit when building your event loop (as shown above).
+//! 2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.30.3",
+//!    features = [ "android-native-activity" ] }`
+//! 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc
+//!    macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize
+//!    logging as above).
+//! 4. Pass a clone of the `AndroidApp` that your application receives to Winit when building your
+//!    event loop (as shown above).
 
-use crate::{
-    event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder},
-    window::{Window, WindowAttributes},
-};
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
+use crate::window::{Window, WindowAttributes};
 
 use self::activity::{AndroidApp, ConfigurationRef, Rect};
 
 /// Additional methods on [`EventLoop`] that are specific to Android.
 pub trait EventLoopExtAndroid {}
 
-impl<T> EventLoopExtAndroid for EventLoop<T> {}
+impl EventLoopExtAndroid for EventLoop {}
 
 /// Additional methods on [`ActiveEventLoop`] that are specific to Android.
 pub trait ActiveEventLoopExtAndroid {}
@@ -115,7 +119,7 @@ pub trait EventLoopBuilderExtAndroid {
     fn handle_volume_keys(&mut self) -> &mut Self;
 }
 
-impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
+impl EventLoopBuilderExtAndroid for EventLoopBuilder {
     fn with_android_app(&mut self, app: AndroidApp) -> &mut Self {
         self.platform_specific.android_app = Some(app);
         self
@@ -146,7 +150,7 @@ impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
 /// For compatibility applications should then import the `AndroidApp` type for
 /// their `android_main(app: AndroidApp)` function like:
 /// ```rust
-/// #[cfg(target_os="android")]
+/// #[cfg(target_os = "android")]
 /// use winit::platform::android::activity::AndroidApp;
 /// ```
 pub mod activity {

src/platform/ios.rs

@@ -66,23 +66,8 @@
 
 use std::os::raw::c_void;
 
-use crate::{
-    event_loop::EventLoop,
-    monitor::{MonitorHandle, VideoModeHandle},
-    window::{Window, WindowAttributes},
-};
-
-/// Additional methods on [`EventLoop`] that are specific to iOS.
-pub trait EventLoopExtIOS {
-    /// Returns the [`Idiom`] (phone/tablet/tv/etc) for the current device.
-    fn idiom(&self) -> Idiom;
-}
-
-impl<T: 'static> EventLoopExtIOS for EventLoop<T> {
-    fn idiom(&self) -> Idiom {
-        self.event_loop.idiom()
-    }
-}
+use crate::monitor::{MonitorHandle, VideoModeHandle};
+use crate::window::{Window, WindowAttributes};
 
 /// Additional methods on [`Window`] that are specific to iOS.
 pub trait WindowExtIOS {
@@ -157,6 +142,21 @@ pub trait WindowExtIOS {
     /// The default is to not recognize gestures.
     fn recognize_pinch_gesture(&self, should_recognize: bool);
 
+    /// Sets whether the [`Window`] should recognize pan gestures.
+    ///
+    /// The default is to not recognize gestures.
+    /// Installs [`UIPanGestureRecognizer`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer) onto view
+    ///
+    /// Set the minimum number of touches required: [`minimumNumberOfTouches`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer/1621208-minimumnumberoftouches)
+    ///
+    /// Set the maximum number of touches recognized: [`maximumNumberOfTouches`](https://developer.apple.com/documentation/uikit/uipangesturerecognizer/1621208-maximumnumberoftouches)
+    fn recognize_pan_gesture(
+        &self,
+        should_recognize: bool,
+        minimum_number_of_touches: u8,
+        maximum_number_of_touches: u8,
+    );
+
     /// Sets whether the [`Window`] should recognize double tap gestures.
     ///
     /// The default is to not recognize gestures.
@@ -171,20 +171,17 @@ pub trait WindowExtIOS {
 impl WindowExtIOS for Window {
     #[inline]
     fn set_scale_factor(&self, scale_factor: f64) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_scale_factor(scale_factor))
+        self.window.maybe_queue_on_main(move |w| w.set_scale_factor(scale_factor))
     }
 
     #[inline]
     fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_valid_orientations(valid_orientations))
+        self.window.maybe_queue_on_main(move |w| w.set_valid_orientations(valid_orientations))
     }
 
     #[inline]
     fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_prefers_home_indicator_hidden(hidden))
+        self.window.maybe_queue_on_main(move |w| w.set_prefers_home_indicator_hidden(hidden))
     }
 
     #[inline]
@@ -196,32 +193,43 @@ impl WindowExtIOS for Window {
 
     #[inline]
     fn set_prefers_status_bar_hidden(&self, hidden: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_prefers_status_bar_hidden(hidden))
+        self.window.maybe_queue_on_main(move |w| w.set_prefers_status_bar_hidden(hidden))
     }
 
     #[inline]
     fn set_preferred_status_bar_style(&self, status_bar_style: StatusBarStyle) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_preferred_status_bar_style(status_bar_style))
+        self.window.maybe_queue_on_main(move |w| w.set_preferred_status_bar_style(status_bar_style))
     }
 
     #[inline]
     fn recognize_pinch_gesture(&self, should_recognize: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.recognize_pinch_gesture(should_recognize));
+        self.window.maybe_queue_on_main(move |w| w.recognize_pinch_gesture(should_recognize));
+    }
+
+    #[inline]
+    fn recognize_pan_gesture(
+        &self,
+        should_recognize: bool,
+        minimum_number_of_touches: u8,
+        maximum_number_of_touches: u8,
+    ) {
+        self.window.maybe_queue_on_main(move |w| {
+            w.recognize_pan_gesture(
+                should_recognize,
+                minimum_number_of_touches,
+                maximum_number_of_touches,
+            )
+        });
     }
 
     #[inline]
     fn recognize_doubletap_gesture(&self, should_recognize: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.recognize_doubletap_gesture(should_recognize));
+        self.window.maybe_queue_on_main(move |w| w.recognize_doubletap_gesture(should_recognize));
     }
 
     #[inline]
     fn recognize_rotation_gesture(&self, should_recognize: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.recognize_rotation_gesture(should_recognize));
+        self.window.maybe_queue_on_main(move |w| w.recognize_rotation_gesture(should_recognize));
     }
 }
 
@@ -301,8 +309,7 @@ impl WindowAttributesExtIOS for WindowAttributes {
 
     #[inline]
     fn with_preferred_screen_edges_deferring_system_gestures(mut self, edges: ScreenEdge) -> Self {
-        self.platform_specific
-            .preferred_screen_edges_deferring_system_gestures = edges;
+        self.platform_specific.preferred_screen_edges_deferring_system_gestures = edges;
         self
     }
 
@@ -336,15 +343,13 @@ impl MonitorHandleExtIOS for MonitorHandle {
     #[inline]
     fn ui_screen(&self) -> *mut c_void {
         // SAFETY: The marker is only used to get the pointer of the screen
-        let mtm = unsafe { icrate::Foundation::MainThreadMarker::new_unchecked() };
-        objc2::rc::Id::as_ptr(self.inner.ui_screen(mtm)) as *mut c_void
+        let mtm = unsafe { objc2_foundation::MainThreadMarker::new_unchecked() };
+        objc2::rc::Retained::as_ptr(self.inner.ui_screen(mtm)) as *mut c_void
     }
 
     #[inline]
     fn preferred_video_mode(&self) -> VideoModeHandle {
-        VideoModeHandle {
-            video_mode: self.inner.preferred_video_mode(),
-        }
+        VideoModeHandle { video_mode: self.inner.preferred_video_mode() }
     }
 }
 
@@ -361,24 +366,6 @@ pub enum ValidOrientations {
     Portrait,
 }
 
-/// The device [idiom].
-///
-/// [idiom]: https://developer.apple.com/documentation/uikit/uidevice/1620037-userinterfaceidiom?language=objc
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum Idiom {
-    Unspecified,
-
-    /// iPhone and iPod touch.
-    Phone,
-
-    /// iPad.
-    Pad,
-
-    /// tvOS and Apple TV.
-    TV,
-    CarPlay,
-}
-
 bitflags::bitflags! {
     /// The [edges] of a screen.
     ///

src/platform/macos.rs

@@ -19,11 +19,9 @@ use std::os::raw::c_void;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use crate::{
-    event_loop::{ActiveEventLoop, EventLoopBuilder},
-    monitor::MonitorHandle,
-    window::{Window, WindowAttributes},
-};
+use crate::event_loop::{ActiveEventLoop, EventLoopBuilder};
+use crate::monitor::MonitorHandle;
+use crate::window::{Window, WindowAttributes};
 
 /// Additional methods on [`Window`] that are specific to MacOS.
 pub trait WindowExtMacOS {
@@ -106,8 +104,7 @@ impl WindowExtMacOS for Window {
 
     #[inline]
     fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
-        self.window
-            .maybe_wait_on_main(move |w| w.set_simple_fullscreen(fullscreen))
+        self.window.maybe_wait_on_main(move |w| w.set_simple_fullscreen(fullscreen))
     }
 
     #[inline]
@@ -117,14 +114,12 @@ impl WindowExtMacOS for Window {
 
     #[inline]
     fn set_has_shadow(&self, has_shadow: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_has_shadow(has_shadow))
+        self.window.maybe_queue_on_main(move |w| w.set_has_shadow(has_shadow))
     }
 
     #[inline]
     fn set_tabbing_identifier(&self, identifier: &str) {
-        self.window
-            .maybe_wait_on_main(|w| w.set_tabbing_identifier(identifier))
+        self.window.maybe_wait_on_main(|w| w.set_tabbing_identifier(identifier))
     }
 
     #[inline]
@@ -144,8 +139,7 @@ impl WindowExtMacOS for Window {
 
     #[inline]
     fn select_tab_at_index(&self, index: usize) {
-        self.window
-            .maybe_queue_on_main(move |w| w.select_tab_at_index(index))
+        self.window.maybe_queue_on_main(move |w| w.select_tab_at_index(index))
     }
 
     #[inline]
@@ -160,14 +154,12 @@ impl WindowExtMacOS for Window {
 
     #[inline]
     fn set_document_edited(&self, edited: bool) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_document_edited(edited))
+        self.window.maybe_queue_on_main(move |w| w.set_document_edited(edited))
     }
 
     #[inline]
     fn set_option_as_alt(&self, option_as_alt: OptionAsAlt) {
-        self.window
-            .maybe_queue_on_main(move |w| w.set_option_as_alt(option_as_alt))
+        self.window.maybe_queue_on_main(move |w| w.set_option_as_alt(option_as_alt))
     }
 
     #[inline]
@@ -192,7 +184,8 @@ pub enum ActivationPolicy {
 
 /// Additional methods on [`WindowAttributes`] that are specific to MacOS.
 ///
-/// **Note:** Properties dealing with the titlebar will be overwritten by the [`WindowAttributes::with_decorations`] method:
+/// **Note:** Properties dealing with the titlebar will be overwritten by the
+/// [`WindowAttributes::with_decorations`] method:
 /// - `with_titlebar_transparent`
 /// - `with_title_hidden`
 /// - `with_titlebar_hidden`
@@ -282,9 +275,7 @@ impl WindowAttributesExtMacOS for WindowAttributes {
 
     #[inline]
     fn with_tabbing_identifier(mut self, tabbing_identifier: &str) -> Self {
-        self.platform_specific
-            .tabbing_identifier
-            .replace(tabbing_identifier.to_string());
+        self.platform_specific.tabbing_identifier.replace(tabbing_identifier.to_string());
         self
     }
 
@@ -307,7 +298,7 @@ pub trait EventLoopBuilderExtMacOS {
     /// ```
     /// use winit::event_loop::EventLoopBuilder;
     /// #[cfg(target_os = "macos")]
-    /// use winit::platform::macos::{EventLoopBuilderExtMacOS, ActivationPolicy};
+    /// use winit::platform::macos::{ActivationPolicy, EventLoopBuilderExtMacOS};
     ///
     /// let mut builder = EventLoopBuilder::new();
     /// #[cfg(target_os = "macos")]
@@ -347,7 +338,7 @@ pub trait EventLoopBuilderExtMacOS {
     fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self;
 }
 
-impl<T> EventLoopBuilderExtMacOS for EventLoopBuilder<T> {
+impl EventLoopBuilderExtMacOS for EventLoopBuilder {
     #[inline]
     fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self {
         self.platform_specific.activation_policy = activation_policy;
@@ -383,18 +374,18 @@ impl MonitorHandleExtMacOS for MonitorHandle {
 
     fn ns_screen(&self) -> Option<*mut c_void> {
         // SAFETY: We only use the marker to get a pointer
-        let mtm = unsafe { icrate::Foundation::MainThreadMarker::new_unchecked() };
-        self.inner
-            .ns_screen(mtm)
-            .map(|s| objc2::rc::Id::as_ptr(&s) as _)
+        let mtm = unsafe { objc2_foundation::MainThreadMarker::new_unchecked() };
+        self.inner.ns_screen(mtm).map(|s| objc2::rc::Retained::as_ptr(&s) as _)
     }
 }
 
 /// Additional methods on [`ActiveEventLoop`] that are specific to macOS.
 pub trait ActiveEventLoopExtMacOS {
-    /// Hide the entire application. In most applications this is typically triggered with Command-H.
+    /// Hide the entire application. In most applications this is typically triggered with
+    /// Command-H.
     fn hide_application(&self);
-    /// Hide the other applications. In most applications this is typically triggered with Command+Option-H.
+    /// Hide the other applications. In most applications this is typically triggered with
+    /// Command+Option-H.
     fn hide_other_applications(&self);
     /// Set whether the system can automatically organize windows into tabs.
     ///

src/platform/mod.rs

@@ -51,11 +51,5 @@ pub mod pump_events;
 ))]
 pub mod modifier_supplement;
 
-#[cfg(any(
-    windows_platform,
-    macos_platform,
-    x11_platform,
-    wayland_platform,
-    docsrs
-))]
+#[cfg(any(windows_platform, macos_platform, x11_platform, wayland_platform, docsrs))]
 pub mod scancode;

src/platform/modifier_supplement.rs

@@ -25,10 +25,7 @@ pub trait KeyEventExtModifierSupplement {
 impl KeyEventExtModifierSupplement for KeyEvent {
     #[inline]
     fn text_with_all_modifiers(&self) -> Option<&str> {
-        self.platform_specific
-            .text_with_all_modifiers
-            .as_ref()
-            .map(|s| s.as_str())
+        self.platform_specific.text_with_all_modifiers.as_ref().map(|s| s.as_str())
     }
 
     #[inline]

src/platform/pump_events.rs

@@ -1,14 +1,10 @@
 use std::time::Duration;
 
 use crate::application::ApplicationHandler;
-use crate::event::Event;
-use crate::event_loop::{self, ActiveEventLoop, EventLoop};
+use crate::event_loop::EventLoop;
 
 /// Additional methods on [`EventLoop`] for pumping events within an external event loop
 pub trait EventLoopExtPumpEvents {
-    /// A type provided by the user that can be passed through [`Event::UserEvent`].
-    type UserEvent: 'static;
-
     /// Pump the `EventLoop` to check for and dispatch pending events.
     ///
     /// This API is designed to enable applications to integrate Winit into an
@@ -84,12 +80,11 @@ pub trait EventLoopExtPumpEvents {
     ///
     /// ## Platform-specific
     ///
-    /// - **Windows**: The implementation will use `PeekMessage` when checking for
-    ///   window messages to avoid blocking your external event loop.
+    /// - **Windows**: The implementation will use `PeekMessage` when checking for window messages
+    ///   to avoid blocking your external event loop.
     ///
-    /// - **MacOS**: The implementation works in terms of stopping the global application
-    ///   whenever the application `RunLoop` indicates that it is preparing to block
-    ///   and wait for new events.
+    /// - **MacOS**: The implementation works in terms of stopping the global application whenever
+    ///   the application `RunLoop` indicates that it is preparing to block and wait for new events.
     ///
     ///   This is very different to the polling APIs that are available on other
     ///   platforms (the lower level polling primitives on MacOS are private
@@ -104,34 +99,20 @@ pub trait EventLoopExtPumpEvents {
     ///   If you render outside of Winit you are likely to see window resizing artifacts
     ///   since MacOS expects applications to render synchronously during any `drawRect`
     ///   callback.
-    fn pump_app_events<A: ApplicationHandler<Self::UserEvent>>(
+    fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus;
+}
+
+impl EventLoopExtPumpEvents for EventLoop {
+    fn pump_app_events<A: ApplicationHandler>(
         &mut self,
         timeout: Option<Duration>,
         app: &mut A,
     ) -> PumpStatus {
-        #[allow(deprecated)]
-        self.pump_events(timeout, |event, event_loop| {
-            event_loop::dispatch_event_for_app(app, event_loop, event)
-        })
-    }
-
-    /// See [`pump_app_events`].
-    ///
-    /// [`pump_app_events`]: Self::pump_app_events
-    #[deprecated = "use EventLoopExtPumpEvents::pump_app_events"]
-    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
-}
-
-impl<T> EventLoopExtPumpEvents for EventLoop<T> {
-    type UserEvent = T;
-
-    fn pump_events<F>(&mut self, timeout: Option<Duration>, event_handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
-    {
-        self.event_loop.pump_events(timeout, event_handler)
+        self.event_loop.pump_app_events(timeout, app)
     }
 }
 

src/platform/run_on_demand.rs

@@ -1,28 +1,16 @@
 use crate::application::ApplicationHandler;
 use crate::error::EventLoopError;
-use crate::event::Event;
-use crate::event_loop::{self, ActiveEventLoop, EventLoop};
+use crate::event_loop::{ActiveEventLoop, EventLoop};
 
 #[cfg(doc)]
 use crate::{platform::pump_events::EventLoopExtPumpEvents, window::Window};
 
 /// Additional methods on [`EventLoop`] to return control flow to the caller.
 pub trait EventLoopExtRunOnDemand {
-    /// A type provided by the user that can be passed through [`Event::UserEvent`].
-    type UserEvent: 'static;
-
-    /// See [`run_app_on_demand`].
-    ///
-    /// [`run_app_on_demand`]: Self::run_app_on_demand
-    #[deprecated = "use EventLoopExtRunOnDemand::run_app_on_demand"]
-    fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
-
     /// Run the application with the event loop on the calling thread.
     ///
-    /// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`) closures
-    /// and it is possible to return control back to the caller without
+    /// Unlike [`EventLoop::run_app`], this function accepts non-`'static` (i.e. non-`move`)
+    /// closures and it is possible to return control back to the caller without
     /// consuming the `EventLoop` (by using [`exit()`]) and
     /// so the event loop can be re-run after it has exit.
     ///
@@ -55,40 +43,29 @@ pub trait EventLoopExtRunOnDemand {
     /// - Android
     ///
     /// # Unsupported Platforms
-    /// - **Web:**  This API is fundamentally incompatible with the event-based way in which
-    ///   Web browsers work because it's not possible to have a long-running external
-    ///   loop that would block the browser and there is nothing that can be
-    ///   polled to ask for new events. Events are delivered via callbacks based
-    ///   on an event loop that is internal to the browser itself.
+    /// - **Web:**  This API is fundamentally incompatible with the event-based way in which Web
+    ///   browsers work because it's not possible to have a long-running external loop that would
+    ///   block the browser and there is nothing that can be polled to ask for new events. Events
+    ///   are delivered via callbacks based on an event loop that is internal to the browser itself.
     /// - **iOS:** It's not possible to stop and start an `UIApplication` repeatedly on iOS.
-    ///
-    #[cfg_attr(
-        not(web_platform),
-        doc = "[^1]: `spawn()` is only available on `wasm` platforms."
-    )]
+    #[cfg_attr(not(web_platform), doc = "[^1]: `spawn()` is only available on `wasm` platforms.")]
+    #[rustfmt::skip]
     ///
     /// [`exit()`]: ActiveEventLoop::exit()
     /// [`set_control_flow()`]: ActiveEventLoop::set_control_flow()
-    fn run_app_on_demand<A: ApplicationHandler<Self::UserEvent>>(
+    fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError>;
+}
+
+impl EventLoopExtRunOnDemand for EventLoop {
+    fn run_app_on_demand<A: ApplicationHandler>(
         &mut self,
         app: &mut A,
     ) -> Result<(), EventLoopError> {
-        #[allow(deprecated)]
-        self.run_on_demand(|event, event_loop| {
-            event_loop::dispatch_event_for_app(app, event_loop, event)
-        })
-    }
-}
-
-impl<T> EventLoopExtRunOnDemand for EventLoop<T> {
-    type UserEvent = T;
-
-    fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
-    {
         self.event_loop.window_target().clear_exit();
-        self.event_loop.run_on_demand(event_handler)
+        self.event_loop.run_app_on_demand(app)
     }
 }
 

src/platform/scancode.rs

@@ -2,8 +2,8 @@ use crate::keyboard::{KeyCode, PhysicalKey};
 
 // TODO: Describe what this value contains for each platform
 
-/// Additional methods for the [`PhysicalKey`] type that allow the user to access the platform-specific
-/// scancode.
+/// Additional methods for the [`PhysicalKey`] type that allow the user to access the
+/// platform-specific scancode.
 ///
 /// [`PhysicalKey`]: crate::keyboard::PhysicalKey
 pub trait PhysicalKeyExtScancode {
@@ -23,7 +23,7 @@ pub trait PhysicalKeyExtScancode {
     ///
     /// ## Platform-specific
     /// - **Wayland/X11**: A 32-bit linux scancode. When building from X11/Wayland keycode subtract
-    ///                    `8` to get the value you wanted.
+    ///   `8` to get the value you wanted.
     fn from_scancode(scancode: u32) -> PhysicalKey;
 }
 

src/platform/wayland.rs

@@ -13,11 +13,9 @@
 //! * `wayland-csd-adwaita` (default).
 //! * `wayland-csd-adwaita-crossfont`.
 //! * `wayland-csd-adwaita-notitle`.
-use crate::{
-    event_loop::{ActiveEventLoop, EventLoopBuilder},
-    monitor::MonitorHandle,
-    window::{Window, WindowAttributes},
-};
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
+use crate::monitor::MonitorHandle;
+use crate::window::{Window, WindowAttributes};
 
 pub use crate::window::Theme;
 
@@ -34,6 +32,19 @@ impl ActiveEventLoopExtWayland for ActiveEventLoop {
     }
 }
 
+/// Additional methods on [`EventLoop`] that are specific to Wayland.
+pub trait EventLoopExtWayland {
+    /// True if the [`EventLoop`] uses Wayland.
+    fn is_wayland(&self) -> bool;
+}
+
+impl EventLoopExtWayland for EventLoop {
+    #[inline]
+    fn is_wayland(&self) -> bool {
+        self.event_loop.is_wayland()
+    }
+}
+
 /// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
 pub trait EventLoopBuilderExtWayland {
     /// Force using Wayland.
@@ -46,7 +57,7 @@ pub trait EventLoopBuilderExtWayland {
     fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
 }
 
-impl<T> EventLoopBuilderExtWayland for EventLoopBuilder<T> {
+impl EventLoopBuilderExtWayland for EventLoopBuilder {
     #[inline]
     fn with_wayland(&mut self) -> &mut Self {
         self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::Wayland);
@@ -80,10 +91,8 @@ pub trait WindowAttributesExtWayland {
 impl WindowAttributesExtWayland for WindowAttributes {
     #[inline]
     fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
-        self.platform_specific.name = Some(crate::platform_impl::ApplicationName::new(
-            general.into(),
-            instance.into(),
-        ));
+        self.platform_specific.name =
+            Some(crate::platform_impl::ApplicationName::new(general.into(), instance.into()));
         self
     }
 }

src/platform/web.rs

@@ -30,8 +30,8 @@
 //! The following APIs can't take them into account and will therefore provide inaccurate results:
 //! - [`WindowEvent::Resized`] and [`Window::(set_)inner_size()`]
 //! - [`WindowEvent::Occluded`]
-//! - [`WindowEvent::CursorMoved`], [`WindowEvent::CursorEntered`], [`WindowEvent::CursorLeft`],
-//!   and [`WindowEvent::Touch`].
+//! - [`WindowEvent::CursorMoved`], [`WindowEvent::CursorEntered`], [`WindowEvent::CursorLeft`], and
+//!   [`WindowEvent::Touch`].
 //! - [`Window::set_outer_position()`]
 //!
 //! [`WindowEvent::Resized`]: crate::event::WindowEvent::Resized
@@ -55,8 +55,7 @@ use web_sys::HtmlCanvasElement;
 
 use crate::application::ApplicationHandler;
 use crate::cursor::CustomCursorSource;
-use crate::event::Event;
-use crate::event_loop::{self, ActiveEventLoop, EventLoop};
+use crate::event_loop::{ActiveEventLoop, EventLoop};
 #[cfg(web_platform)]
 use crate::platform_impl::CustomCursorFuture as PlatformCustomCursorFuture;
 use crate::platform_impl::PlatformCustomCursorSource;
@@ -109,11 +108,7 @@ pub trait WindowAttributesExtWebSys {
     /// In any case, the canvas won't be automatically inserted into the web page.
     ///
     /// [`None`] by default.
-    #[cfg_attr(
-        not(web_platform),
-        doc = "",
-        doc = "[`HtmlCanvasElement`]: #only-available-on-wasm"
-    )]
+    #[cfg_attr(not(web_platform), doc = "", doc = "[`HtmlCanvasElement`]: #only-available-on-wasm")]
     fn with_canvas(self, canvas: Option<HtmlCanvasElement>) -> Self;
 
     /// Sets whether `event.preventDefault()` should be called on events on the
@@ -160,16 +155,10 @@ impl WindowAttributesExtWebSys for WindowAttributes {
 
 /// Additional methods on `EventLoop` that are specific to the web.
 pub trait EventLoopExtWebSys {
-    /// A type provided by the user that can be passed through `Event::UserEvent`.
-    type UserEvent: 'static;
-
     /// Initializes the winit event loop.
     ///
     /// Unlike
-    #[cfg_attr(
-        all(web_platform, target_feature = "exception-handling"),
-        doc = "`run_app()`"
-    )]
+    #[cfg_attr(all(web_platform, target_feature = "exception-handling"), doc = "`run_app()`")]
     #[cfg_attr(
         not(all(web_platform, target_feature = "exception-handling")),
         doc = "[`run_app()`]"
@@ -181,37 +170,63 @@ pub trait EventLoopExtWebSys {
     /// by calling this function again. This can be useful if you want to recreate the event loop
     /// while the WebAssembly module is still loaded. For example, this can be used to recreate the
     /// event loop when switching between tabs on a single page application.
+    #[rustfmt::skip]
     ///
     #[cfg_attr(
         not(all(web_platform, target_feature = "exception-handling")),
         doc = "[`run_app()`]: EventLoop::run_app()"
     )]
     /// [^1]: `run_app()` is _not_ available on WASM when the target supports `exception-handling`.
-    fn spawn_app<A: ApplicationHandler<Self::UserEvent> + 'static>(self, app: A);
+    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A);
 
-    /// See [`spawn_app`].
+    /// Sets the strategy for [`ControlFlow::Poll`].
     ///
-    /// [`spawn_app`]: Self::spawn_app
-    #[deprecated = "use EventLoopExtWebSys::spawn_app"]
-    fn spawn<F>(self, event_handler: F)
-    where
-        F: 'static + FnMut(Event<Self::UserEvent>, &ActiveEventLoop);
+    /// See [`PollStrategy`].
+    ///
+    /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
+    fn set_poll_strategy(&self, strategy: PollStrategy);
+
+    /// Gets the strategy for [`ControlFlow::Poll`].
+    ///
+    /// See [`PollStrategy`].
+    ///
+    /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
+    fn poll_strategy(&self) -> PollStrategy;
+
+    /// Sets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy);
+
+    /// Gets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn wait_until_strategy(&self) -> WaitUntilStrategy;
 }
 
-impl<T> EventLoopExtWebSys for EventLoop<T> {
-    type UserEvent = T;
-
-    fn spawn_app<A: ApplicationHandler<Self::UserEvent> + 'static>(self, mut app: A) {
-        self.event_loop.spawn(move |event, event_loop| {
-            event_loop::dispatch_event_for_app(&mut app, event_loop, event)
-        });
+impl EventLoopExtWebSys for EventLoop {
+    fn spawn_app<A: ApplicationHandler + 'static>(self, app: A) {
+        self.event_loop.spawn_app(app);
     }
 
-    fn spawn<F>(self, event_handler: F)
-    where
-        F: 'static + FnMut(Event<Self::UserEvent>, &ActiveEventLoop),
-    {
-        self.event_loop.spawn(event_handler)
+    fn set_poll_strategy(&self, strategy: PollStrategy) {
+        self.event_loop.set_poll_strategy(strategy);
+    }
+
+    fn poll_strategy(&self) -> PollStrategy {
+        self.event_loop.poll_strategy()
+    }
+
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.event_loop.set_wait_until_strategy(strategy);
+    }
+
+    fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.event_loop.wait_until_strategy()
     }
 }
 
@@ -230,6 +245,20 @@ pub trait ActiveEventLoopExtWebSys {
     /// [`ControlFlow::Poll`]: crate::event_loop::ControlFlow::Poll
     fn poll_strategy(&self) -> PollStrategy;
 
+    /// Sets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy);
+
+    /// Gets the strategy for [`ControlFlow::WaitUntil`].
+    ///
+    /// See [`WaitUntilStrategy`].
+    ///
+    /// [`ControlFlow::WaitUntil`]: crate::event_loop::ControlFlow::WaitUntil
+    fn wait_until_strategy(&self) -> WaitUntilStrategy;
+
     /// Async version of [`ActiveEventLoop::create_custom_cursor()`] which waits until the
     /// cursor has completely finished loading.
     fn create_custom_cursor_async(&self, source: CustomCursorSource) -> CustomCursorFuture;
@@ -250,9 +279,19 @@ impl ActiveEventLoopExtWebSys for ActiveEventLoop {
     fn poll_strategy(&self) -> PollStrategy {
         self.p.poll_strategy()
     }
+
+    #[inline]
+    fn set_wait_until_strategy(&self, strategy: WaitUntilStrategy) {
+        self.p.set_wait_until_strategy(strategy);
+    }
+
+    #[inline]
+    fn wait_until_strategy(&self) -> WaitUntilStrategy {
+        self.p.wait_until_strategy()
+    }
 }
 
-/// Strategy used for [`ControlFlow::Poll`](crate::event_loop::ControlFlow::Poll).
+/// Strategy used for [`ControlFlow::Poll`][crate::event_loop::ControlFlow::Poll].
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
 pub enum PollStrategy {
     /// Uses [`Window.requestIdleCallback()`] to queue the next event loop. If not available
@@ -278,6 +317,29 @@ pub enum PollStrategy {
     Scheduler,
 }
 
+/// Strategy used for [`ControlFlow::WaitUntil`][crate::event_loop::ControlFlow::WaitUntil].
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub enum WaitUntilStrategy {
+    /// Uses the [Prioritized Task Scheduling API] to queue the next event loop. If not available
+    /// this will fallback to [`setTimeout()`].
+    ///
+    /// This strategy is commonly not affected by browser throttling unless the window is not
+    /// focused.
+    ///
+    /// This is the default strategy.
+    ///
+    /// [Prioritized Task Scheduling API]: https://developer.mozilla.org/en-US/docs/Web/API/Prioritized_Task_Scheduling_API
+    /// [`setTimeout()`]: https://developer.mozilla.org/en-US/docs/Web/API/setTimeout
+    #[default]
+    Scheduler,
+    /// Equal to [`Scheduler`][Self::Scheduler] but wakes up the event loop from a [worker].
+    ///
+    /// This strategy is commonly not affected by browser throttling regardless of window focus.
+    ///
+    /// [worker]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API
+    Worker,
+}
+
 pub trait CustomCursorExtWebSys {
     /// Returns if this cursor is an animation.
     fn is_animation(&self) -> bool;
@@ -303,13 +365,7 @@ impl CustomCursorExtWebSys for CustomCursor {
     }
 
     fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> CustomCursorSource {
-        CustomCursorSource {
-            inner: PlatformCustomCursorSource::Url {
-                url,
-                hotspot_x,
-                hotspot_y,
-            },
-        }
+        CustomCursorSource { inner: PlatformCustomCursorSource::Url { url, hotspot_x, hotspot_y } }
     }
 
     fn from_animation(
@@ -360,9 +416,7 @@ impl Future for CustomCursorFuture {
     type Output = Result<CustomCursor, CustomCursorError>;
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        Pin::new(&mut self.0)
-            .poll(cx)
-            .map_ok(|cursor| CustomCursor { inner: cursor })
+        Pin::new(&mut self.0).poll(cx).map_ok(|cursor| CustomCursor { inner: cursor })
     }
 }
 
@@ -378,10 +432,9 @@ impl Display for CustomCursorError {
         match self {
             Self::Blob => write!(f, "failed to create `Blob`"),
             Self::Decode(error) => write!(f, "failed to decode image: {error}"),
-            Self::Animation => write!(
-                f,
-                "found `CustomCursor` that is an animation when building an animation"
-            ),
+            Self::Animation => {
+                write!(f, "found `CustomCursor` that is an animation when building an animation")
+            },
         }
     }
 }

src/platform/windows.rs

@@ -2,15 +2,15 @@
 //!
 //! The supported OS version is Windows 7 or higher, though Windows 10 is
 //! tested regularly.
-use std::{ffi::c_void, path::Path};
+use std::borrow::Borrow;
+use std::ffi::c_void;
+use std::path::Path;
 
-use crate::{
-    dpi::PhysicalSize,
-    event::DeviceId,
-    event_loop::EventLoopBuilder,
-    monitor::MonitorHandle,
-    window::{BadIcon, Icon, Window, WindowAttributes},
-};
+use crate::dpi::PhysicalSize;
+use crate::event::DeviceId;
+use crate::event_loop::EventLoopBuilder;
+use crate::monitor::MonitorHandle;
+use crate::window::{BadIcon, Icon, Window, WindowAttributes};
 
 /// Window Handle type used by Win32 API
 pub type HWND = isize;
@@ -57,11 +57,11 @@ pub enum BackdropType {
 pub struct Color(u32);
 
 impl Color {
+    // Special constant only valid for the window border and therefore modeled using Option<Color>
+    // for user facing code
+    const NONE: Color = Color(0xfffffffe);
     /// Use the system's default color
-    pub const SYSTEM_DEFAULT: Color = Color(0xFFFFFFFF);
-
-    //Special constant only valid for the window border and therefore modeled using Option<Color> for user facing code
-    const NONE: Color = Color(0xFFFFFFFE);
+    pub const SYSTEM_DEFAULT: Color = Color(0xffffffff);
 
     /// Create a new color from the given RGB values
     pub const fn from_rgb(r: u8, g: u8, b: u8) -> Self {
@@ -105,6 +105,60 @@ pub enum CornerPreference {
     RoundSmall = 3,
 }
 
+/// A wrapper around a [`Window`] that ignores thread-specific window handle limitations.
+///
+/// See [`WindowBorrowExtWindows::any_thread`] for more information.
+#[derive(Debug)]
+pub struct AnyThread<W>(W);
+
+impl<W: Borrow<Window>> AnyThread<W> {
+    /// Get a reference to the inner window.
+    #[inline]
+    pub fn get_ref(&self) -> &Window {
+        self.0.borrow()
+    }
+
+    /// Get a reference to the inner object.
+    #[inline]
+    pub fn inner(&self) -> &W {
+        &self.0
+    }
+
+    /// Unwrap and get the inner window.
+    #[inline]
+    pub fn into_inner(self) -> W {
+        self.0
+    }
+}
+
+impl<W: Borrow<Window>> AsRef<Window> for AnyThread<W> {
+    fn as_ref(&self) -> &Window {
+        self.get_ref()
+    }
+}
+
+impl<W: Borrow<Window>> Borrow<Window> for AnyThread<W> {
+    fn borrow(&self) -> &Window {
+        self.get_ref()
+    }
+}
+
+impl<W: Borrow<Window>> std::ops::Deref for AnyThread<W> {
+    type Target = Window;
+
+    fn deref(&self) -> &Self::Target {
+        self.get_ref()
+    }
+}
+
+#[cfg(feature = "rwh_06")]
+impl<W: Borrow<Window>> rwh_06::HasWindowHandle for AnyThread<W> {
+    fn window_handle(&self) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        // SAFETY: The top level user has asserted this is only used safely.
+        unsafe { self.get_ref().window_handle_any_thread() }
+    }
+}
+
 /// Additional methods on `EventLoop` that are specific to Windows.
 pub trait EventLoopBuilderExtWindows {
     /// Whether to allow the event loop to be created off of the main thread.
@@ -173,7 +227,7 @@ pub trait EventLoopBuilderExtWindows {
         F: FnMut(*const c_void) -> bool + 'static;
 }
 
-impl<T> EventLoopBuilderExtWindows for EventLoopBuilder<T> {
+impl EventLoopBuilderExtWindows for EventLoopBuilder {
     #[inline]
     fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
         self.platform_specific.any_thread = any_thread;
@@ -202,8 +256,8 @@ pub trait WindowExtWindows {
     ///
     /// A window must be enabled before it can be activated.
     /// If an application has create a modal dialog box by disabling its owner window
-    /// (as described in [`WindowAttributesExtWindows::with_owner_window`]), the application must enable
-    /// the owner window before destroying the dialog box.
+    /// (as described in [`WindowAttributesExtWindows::with_owner_window`]), the application must
+    /// enable the owner window before destroying the dialog box.
     /// Otherwise, another window will receive the keyboard focus and be activated.
     ///
     /// If a child window is disabled, it is ignored when the system tries to determine which
@@ -248,6 +302,60 @@ pub trait WindowExtWindows {
     ///
     /// Supported starting with Windows 11 Build 22000.
     fn set_corner_preference(&self, preference: CornerPreference);
+
+    /// Get the raw window handle for this [`Window`] without checking for thread affinity.
+    ///
+    /// Window handles in Win32 have a property called "thread affinity" that ties them to their
+    /// origin thread. Some operations can only happen on the window's origin thread, while others
+    /// can be called from any thread. For example, [`SetWindowSubclass`] is not thread safe while
+    /// [`GetDC`] is thread safe.
+    ///
+    /// In Rust terms, the window handle is `Send` sometimes but `!Send` other times.
+    ///
+    /// Therefore, in order to avoid confusing threading errors, [`Window`] only returns the
+    /// window handle when the [`window_handle`] function is called from the thread that created
+    /// the window. In other cases, it returns an [`Unavailable`] error.
+    ///
+    /// However in some cases you may already know that you are using the window handle for
+    /// operations that are guaranteed to be thread-safe. In which case this function aims
+    /// to provide an escape hatch so these functions are still accessible from other threads.
+    ///
+    /// # Safety
+    ///
+    /// It is the responsibility of the user to only pass the window handle into thread-safe
+    /// Win32 APIs.
+    ///
+    /// [`SetWindowSubclass`]: https://learn.microsoft.com/en-us/windows/win32/api/commctrl/nf-commctrl-setwindowsubclass
+    /// [`GetDC`]: https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getdc
+    /// [`Window`]: crate::window::Window
+    /// [`window_handle`]: https://docs.rs/raw-window-handle/latest/raw_window_handle/trait.HasWindowHandle.html#tymethod.window_handle
+    /// [`Unavailable`]: https://docs.rs/raw-window-handle/latest/raw_window_handle/enum.HandleError.html#variant.Unavailable
+    ///
+    /// ## Example
+    ///
+    /// ```no_run
+    /// # use winit::window::Window;
+    /// # fn scope(window: Window) {
+    /// use std::thread;
+    /// use winit::platform::windows::WindowExtWindows;
+    /// use winit::raw_window_handle::HasWindowHandle;
+    ///
+    /// // We can get the window handle on the current thread.
+    /// let handle = window.window_handle().unwrap();
+    ///
+    /// // However, on another thread, we can't!
+    /// thread::spawn(move || {
+    ///     assert!(window.window_handle().is_err());
+    ///
+    ///     // We can use this function as an escape hatch.
+    ///     let handle = unsafe { window.window_handle_any_thread().unwrap() };
+    /// });
+    /// # }
+    /// ```
+    #[cfg(feature = "rwh_06")]
+    unsafe fn window_handle_any_thread(
+        &self,
+    ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError>;
 }
 
 impl WindowExtWindows for Window {
@@ -283,10 +391,10 @@ impl WindowExtWindows for Window {
 
     #[inline]
     fn set_title_background_color(&self, color: Option<Color>) {
-        // The windows docs don't mention NONE as a valid options but it works in practice and is useful
-        // to circumvent the Windows option "Show accent color on title bars and window borders"
-        self.window
-            .set_title_background_color(color.unwrap_or(Color::NONE))
+        // The windows docs don't mention NONE as a valid options but it works in practice and is
+        // useful to circumvent the Windows option "Show accent color on title bars and
+        // window borders"
+        self.window.set_title_background_color(color.unwrap_or(Color::NONE))
     }
 
     #[inline]
@@ -298,15 +406,57 @@ impl WindowExtWindows for Window {
     fn set_corner_preference(&self, preference: CornerPreference) {
         self.window.set_corner_preference(preference)
     }
+
+    #[cfg(feature = "rwh_06")]
+    unsafe fn window_handle_any_thread(
+        &self,
+    ) -> Result<rwh_06::WindowHandle<'_>, rwh_06::HandleError> {
+        unsafe {
+            let handle = self.window.rwh_06_no_thread_check()?;
+
+            // SAFETY: The handle is valid in this context.
+            Ok(rwh_06::WindowHandle::borrow_raw(handle))
+        }
+    }
 }
 
+/// Additional methods for anything that dereference to [`Window`].
+///
+/// [`Window`]: crate::window::Window
+pub trait WindowBorrowExtWindows: Borrow<Window> + Sized {
+    /// Create an object that allows accessing the inner window handle in a thread-unsafe way.
+    ///
+    /// It is possible to call [`window_handle_any_thread`] to get around Windows's thread
+    /// affinity limitations. However, it may be desired to pass the [`Window`] into something
+    /// that requires the [`HasWindowHandle`] trait, while ignoring thread affinity limitations.
+    ///
+    /// This function wraps anything that implements `Borrow<Window>` into a structure that
+    /// uses the inner window handle as a mean of implementing [`HasWindowHandle`]. It wraps
+    /// `Window`, `&Window`, `Arc<Window>`, and other reference types.
+    ///
+    /// # Safety
+    ///
+    /// It is the responsibility of the user to only pass the window handle into thread-safe
+    /// Win32 APIs.
+    ///
+    /// [`window_handle_any_thread`]: WindowExtWindows::window_handle_any_thread
+    /// [`Window`]: crate::window::Window
+    /// [`HasWindowHandle`]: rwh_06::HasWindowHandle
+    unsafe fn any_thread(self) -> AnyThread<Self> {
+        AnyThread(self)
+    }
+}
+
+impl<W: Borrow<Window> + Sized> WindowBorrowExtWindows for W {}
+
 /// Additional methods on `WindowAttributes` that are specific to Windows.
 #[allow(rustdoc::broken_intra_doc_links)]
 pub trait WindowAttributesExtWindows {
     /// Set an owner to the window to be created. Can be used to create a dialog box, for example.
     /// This only works when [`WindowAttributes::with_parent_window`] isn't called or set to `None`.
-    /// Can be used in combination with [`WindowExtWindows::set_enable(false)`](WindowExtWindows::set_enable)
-    /// on the owner window to create a modal dialog box.
+    /// Can be used in combination with
+    /// [`WindowExtWindows::set_enable(false)`][WindowExtWindows::set_enable] on the owner
+    /// window to create a modal dialog box.
     ///
     /// From MSDN:
     /// - An owned window is always above its owner in the z-order.
@@ -322,17 +472,14 @@ pub trait WindowAttributesExtWindows {
     ///
     /// The menu must have been manually created beforehand with [`CreateMenu`] or similar.
     ///
-    /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how the menus look.
-    /// If you use this, it is recommended that you combine it with `with_theme(Some(Theme::Light))` to avoid a jarring effect.
-    ///
+    /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how
+    /// the menus look. If you use this, it is recommended that you combine it with
+    /// `with_theme(Some(Theme::Light))` to avoid a jarring effect.
     #[cfg_attr(
-        platform_windows,
+        windows_platform,
         doc = "[`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu"
     )]
-    #[cfg_attr(
-        not(platform_windows),
-        doc = "[`CreateMenu`]: #only-available-on-windows"
-    )]
+    #[cfg_attr(not(windows_platform), doc = "[`CreateMenu`]: #only-available-on-windows")]
     fn with_menu(self, menu: HMENU) -> Self;
 
     /// This sets `ICON_BIG`. A good ceiling here is 256x256.
@@ -341,12 +488,12 @@ pub trait WindowAttributesExtWindows {
     /// This sets `WS_EX_NOREDIRECTIONBITMAP`.
     fn with_no_redirection_bitmap(self, flag: bool) -> Self;
 
-    /// Enables or disables drag and drop support (enabled by default). Will interfere with other crates
-    /// that use multi-threaded COM API (`CoInitializeEx` with `COINIT_MULTITHREADED` instead of
-    /// `COINIT_APARTMENTTHREADED`) on the same thread. Note that winit may still attempt to initialize
-    /// COM API regardless of this option. Currently only fullscreen mode does that, but there may be more in the future.
-    /// If you need COM API with `COINIT_MULTITHREADED` you must initialize it before calling any winit functions.
-    /// See <https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks> for more information.
+    /// Enables or disables drag and drop support (enabled by default). Will interfere with other
+    /// crates that use multi-threaded COM API (`CoInitializeEx` with `COINIT_MULTITHREADED`
+    /// instead of `COINIT_APARTMENTTHREADED`) on the same thread. Note that winit may still
+    /// attempt to initialize COM API regardless of this option. Currently only fullscreen mode
+    /// does that, but there may be more in the future. If you need COM API with
+    /// `COINIT_MULTITHREADED` you must initialize it before calling any winit functions. See <https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks> for more information.
     fn with_drag_and_drop(self, flag: bool) -> Self;
 
     /// Whether show or hide the window icon in the taskbar.

src/platform/x11.rs

@@ -2,11 +2,9 @@
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
-use crate::{
-    event_loop::{ActiveEventLoop, EventLoopBuilder},
-    monitor::MonitorHandle,
-    window::{Window, WindowAttributes},
-};
+use crate::event_loop::{ActiveEventLoop, EventLoop, EventLoopBuilder};
+use crate::monitor::MonitorHandle;
+use crate::window::{Window, WindowAttributes};
 
 use crate::dpi::Size;
 
@@ -15,11 +13,12 @@ use crate::dpi::Size;
 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum WindowType {
-    /// A desktop feature. This can include a single window containing desktop icons with the same dimensions as the
-    /// screen, allowing the desktop environment to have full control of the desktop, without the need for proxying
-    /// root window clicks.
+    /// A desktop feature. This can include a single window containing desktop icons with the same
+    /// dimensions as the screen, allowing the desktop environment to have full control of the
+    /// desktop, without the need for proxying root window clicks.
     Desktop,
-    /// A dock or panel feature. Typically a Window Manager would keep such windows on top of all other windows.
+    /// A dock or panel feature. Typically a Window Manager would keep such windows on top of all
+    /// other windows.
     Dock,
     /// Toolbar windows. "Torn off" from the main application.
     Toolbar,
@@ -37,8 +36,8 @@ pub enum WindowType {
     /// A popup menu that usually appears when the user right clicks on an object.
     /// This property is typically used on override-redirect windows.
     PopupMenu,
-    /// A tooltip window. Usually used to show additional information when hovering over an object with the cursor.
-    /// This property is typically used on override-redirect windows.
+    /// A tooltip window. Usually used to show additional information when hovering over an object
+    /// with the cursor. This property is typically used on override-redirect windows.
     Tooltip,
     /// The window is a notification.
     /// This property is typically used on override-redirect windows.
@@ -46,7 +45,7 @@ pub enum WindowType {
     /// This should be used on the windows that are popped up by combo boxes.
     /// This property is typically used on override-redirect windows.
     Combo,
-    /// This indicates the the window is being dragged.
+    /// This indicates the window is being dragged.
     /// This property is typically used on override-redirect windows.
     Dnd,
     /// This is a normal, top-level window.
@@ -83,10 +82,7 @@ pub type XWindow = u32;
 pub fn register_xlib_error_hook(hook: XlibErrorHook) {
     // Append new hook.
     unsafe {
-        crate::platform_impl::XLIB_ERROR_HOOKS
-            .lock()
-            .unwrap()
-            .push(hook);
+        crate::platform_impl::XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
     }
 }
 
@@ -103,6 +99,19 @@ impl ActiveEventLoopExtX11 for ActiveEventLoop {
     }
 }
 
+/// Additional methods on [`EventLoop`] that are specific to X11.
+pub trait EventLoopExtX11 {
+    /// True if the [`EventLoop`] uses X11.
+    fn is_x11(&self) -> bool;
+}
+
+impl EventLoopExtX11 for EventLoop {
+    #[inline]
+    fn is_x11(&self) -> bool {
+        !self.event_loop.is_wayland()
+    }
+}
+
 /// Additional methods on [`EventLoopBuilder`] that are specific to X11.
 pub trait EventLoopBuilderExtX11 {
     /// Force using X11.
@@ -115,7 +124,7 @@ pub trait EventLoopBuilderExtX11 {
     fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
 }
 
-impl<T> EventLoopBuilderExtX11 for EventLoopBuilder<T> {
+impl EventLoopBuilderExtX11 for EventLoopBuilder {
     #[inline]
     fn with_x11(&mut self) -> &mut Self {
         self.platform_specific.forced_backend = Some(crate::platform_impl::Backend::X);
@@ -144,7 +153,8 @@ pub trait WindowAttributesExtX11 {
     /// Build window with the given `general` and `instance` names.
     ///
     /// The `general` sets general class of `WM_CLASS(STRING)`, while `instance` set the
-    /// instance part of it. The resulted property looks like `WM_CLASS(STRING) = "instance", "general"`.
+    /// instance part of it. The resulted property looks like `WM_CLASS(STRING) = "instance",
+    /// "general"`.
     ///
     /// For details about application ID conventions, see the
     /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
@@ -202,10 +212,8 @@ impl WindowAttributesExtX11 for WindowAttributes {
 
     #[inline]
     fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
-        self.platform_specific.name = Some(crate::platform_impl::ApplicationName::new(
-            general.into(),
-            instance.into(),
-        ));
+        self.platform_specific.name =
+            Some(crate::platform_impl::ApplicationName::new(general.into(), instance.into()));
         self
     }
 

src/platform_impl/android/keycodes.rs

@@ -1,7 +1,5 @@
-use android_activity::{
-    input::{KeyAction, KeyEvent, KeyMapChar, Keycode},
-    AndroidApp,
-};
+use android_activity::input::{KeyAction, KeyEvent, KeyMapChar, Keycode};
+use android_activity::AndroidApp;
 
 use crate::keyboard::{Key, KeyCode, KeyLocation, NamedKey, NativeKey, NativeKeyCode, PhysicalKey};
 
@@ -105,7 +103,7 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         Keycode::VolumeUp => KeyCode::AudioVolumeUp,
         Keycode::VolumeDown => KeyCode::AudioVolumeDown,
         Keycode::VolumeMute => KeyCode::AudioVolumeMute,
-        //Keycode::Mute => None, // Microphone mute
+        // Keycode::Mute => None, // Microphone mute
         Keycode::MediaPlayPause => KeyCode::MediaPlayPause,
         Keycode::MediaStop => KeyCode::MediaStop,
         Keycode::MediaNext => KeyCode::MediaTrackNext,
@@ -176,7 +174,7 @@ pub fn character_map_and_combine_key(
         Err(err) => {
             tracing::warn!("Failed to look up `KeyCharacterMap` for device {device_id}: {err:?}");
             return None;
-        }
+        },
     };
 
     match key_map.get(key_event.key_code(), key_event.meta_state()) {
@@ -188,9 +186,12 @@ pub fn character_map_and_combine_key(
                         Ok(Some(key)) => Some(key),
                         Ok(None) => None,
                         Err(err) => {
-                            tracing::warn!("KeyEvent: Failed to combine 'dead key' accent '{accent}' with '{unicode}': {err:?}");
+                            tracing::warn!(
+                                "KeyEvent: Failed to combine 'dead key' accent '{accent}' with \
+                                 '{unicode}': {err:?}"
+                            );
                             None
-                        }
+                        },
                     }
                 } else {
                     Some(unicode)
@@ -200,23 +201,23 @@ pub fn character_map_and_combine_key(
             } else {
                 Some(KeyMapChar::Unicode(unicode))
             }
-        }
+        },
         Ok(KeyMapChar::CombiningAccent(accent)) => {
             if key_event.action() == KeyAction::Down {
                 *combining_accent = Some(accent);
             }
             Some(KeyMapChar::CombiningAccent(accent))
-        }
+        },
         Ok(KeyMapChar::None) => {
             // Leave any combining_accent state in tact (seems to match how other
             // Android apps work)
             None
-        }
+        },
         Err(err) => {
             tracing::warn!("KeyEvent: Failed to get key map character: {err:?}");
             *combining_accent = None;
             None
-        }
+        },
     }
 }
 

src/platform_impl/android/mod.rs

@@ -1,16 +1,10 @@
-#![cfg(android_platform)]
-
-use std::{
-    cell::Cell,
-    collections::VecDeque,
-    hash::Hash,
-    marker::PhantomData,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        mpsc, Arc, Mutex,
-    },
-    time::{Duration, Instant},
-};
+use std::cell::Cell;
+use std::collections::VecDeque;
+use std::hash::Hash;
+use std::marker::PhantomData;
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
 
 use android_activity::input::{InputEvent, KeyAction, Keycode, MotionAction};
 use android_activity::{
@@ -18,24 +12,25 @@ use android_activity::{
 };
 use tracing::{debug, trace, warn};
 
-use crate::{
-    cursor::Cursor,
-    dpi::{PhysicalPosition, PhysicalSize, Position, Size},
-    error,
-    event::{self, Force, InnerSizeWriter, StartCause},
-    event_loop::{self, ActiveEventLoop as RootAEL, ControlFlow, DeviceEvents},
-    platform::pump_events::PumpStatus,
-    window::{
-        self, CursorGrabMode, CustomCursor, CustomCursorSource, ImePurpose, ResizeDirection, Theme,
-        WindowButtons, WindowLevel,
-    },
+use crate::application::ApplicationHandler;
+use crate::cursor::Cursor;
+use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
+use crate::error;
+use crate::error::EventLoopError;
+use crate::event::{self, Force, InnerSizeWriter, StartCause};
+use crate::event_loop::{self, ControlFlow, DeviceEvents};
+use crate::platform::pump_events::PumpStatus;
+use crate::platform_impl::Fullscreen;
+use crate::window::{
+    self, CursorGrabMode, CustomCursor, CustomCursorSource, ImePurpose, ResizeDirection, Theme,
+    WindowButtons, WindowLevel,
 };
-use crate::{error::EventLoopError, platform_impl::Fullscreen};
 
 mod keycodes;
 
-pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursor;
-pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursorSource;
+pub(crate) use crate::cursor::{
+    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
+};
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 
 static HAS_FOCUS: AtomicBool = AtomicBool::new(true);
@@ -44,42 +39,7 @@ static HAS_FOCUS: AtomicBool = AtomicBool::new(true);
 /// equates to an infinite timeout, not a zero timeout (so can't just use
 /// `Option::min`)
 fn min_timeout(a: Option<Duration>, b: Option<Duration>) -> Option<Duration> {
-    a.map_or(b, |a_timeout| {
-        b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout)))
-    })
-}
-
-struct PeekableReceiver<T> {
-    recv: mpsc::Receiver<T>,
-    first: Option<T>,
-}
-
-impl<T> PeekableReceiver<T> {
-    pub fn from_recv(recv: mpsc::Receiver<T>) -> Self {
-        Self { recv, first: None }
-    }
-    pub fn has_incoming(&mut self) -> bool {
-        if self.first.is_some() {
-            return true;
-        }
-        match self.recv.try_recv() {
-            Ok(v) => {
-                self.first = Some(v);
-                true
-            }
-            Err(mpsc::TryRecvError::Empty) => false,
-            Err(mpsc::TryRecvError::Disconnected) => {
-                warn!("Channel was disconnected when checking incoming");
-                false
-            }
-        }
-    }
-    pub fn try_recv(&mut self) -> Result<T, mpsc::TryRecvError> {
-        if let Some(first) = self.first.take() {
-            return Ok(first);
-        }
-        self.recv.try_recv()
-    }
+    a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
 }
 
 #[derive(Clone)]
@@ -88,9 +48,7 @@ struct SharedFlagSetter {
 }
 impl SharedFlagSetter {
     pub fn set(&self) -> bool {
-        self.flag
-            .compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed)
-            .is_ok()
+        self.flag.compare_exchange(false, true, Ordering::AcqRel, Ordering::Relaxed).is_ok()
     }
 }
 
@@ -104,15 +62,13 @@ struct SharedFlag {
 // was queued and be able to read and clear the state atomically)
 impl SharedFlag {
     pub fn new() -> Self {
-        Self {
-            flag: Arc::new(AtomicBool::new(false)),
-        }
+        Self { flag: Arc::new(AtomicBool::new(false)) }
     }
+
     pub fn setter(&self) -> SharedFlagSetter {
-        SharedFlagSetter {
-            flag: self.flag.clone(),
-        }
+        SharedFlagSetter { flag: self.flag.clone() }
     }
+
     pub fn get_and_reset(&self) -> bool {
         self.flag.swap(false, std::sync::atomic::Ordering::AcqRel)
     }
@@ -126,11 +82,9 @@ pub struct RedrawRequester {
 
 impl RedrawRequester {
     fn new(flag: &SharedFlag, waker: AndroidAppWaker) -> Self {
-        RedrawRequester {
-            flag: flag.setter(),
-            waker,
-        }
+        RedrawRequester { flag: flag.setter(), waker }
     }
+
     pub fn request_redraw(&self) {
         if self.flag.set() {
             // Only explicitly try to wake up the main loop when the flag
@@ -143,13 +97,12 @@ impl RedrawRequester {
 #[derive(Debug, Clone, Eq, PartialEq, Hash)]
 pub struct KeyEventExtra {}
 
-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
     android_app: AndroidApp,
     window_target: event_loop::ActiveEventLoop,
     redraw_flag: SharedFlag,
-    user_events_sender: mpsc::Sender<T>,
-    user_events_receiver: PeekableReceiver<T>, //must wake looper whenever something gets sent
-    loop_running: bool,                        // Dispatched `NewEvents<Init>`
+    proxy_wake_up: Arc<AtomicBool>,
+    loop_running: bool, // Dispatched `NewEvents<Init>`
     running: bool,
     pending_redraw: bool,
     cause: StartCause,
@@ -165,20 +118,20 @@ pub(crate) struct PlatformSpecificEventLoopAttributes {
 
 impl Default for PlatformSpecificEventLoopAttributes {
     fn default() -> Self {
-        Self {
-            android_app: Default::default(),
-            ignore_volume_keys: true,
-        }
+        Self { android_app: Default::default(), ignore_volume_keys: true }
     }
 }
 
-impl<T: 'static> EventLoop<T> {
+impl EventLoop {
     pub(crate) fn new(
         attributes: &PlatformSpecificEventLoopAttributes,
     ) -> Result<Self, EventLoopError> {
-        let (user_events_sender, user_events_receiver) = mpsc::channel();
+        let proxy_wake_up = Arc::new(AtomicBool::new(false));
 
-        let android_app = attributes.android_app.as_ref().expect("An `AndroidApp` as passed to android_main() is required to create an `EventLoop` on Android");
+        let android_app = attributes.android_app.as_ref().expect(
+            "An `AndroidApp` as passed to android_main() is required to create an `EventLoop` on \
+             Android",
+        );
         let redraw_flag = SharedFlag::new();
 
         Ok(Self {
@@ -196,8 +149,7 @@ impl<T: 'static> EventLoop<T> {
                 _marker: PhantomData,
             },
             redraw_flag,
-            user_events_sender,
-            user_events_receiver: PeekableReceiver::from_recv(user_events_receiver),
+            proxy_wake_up,
             loop_running: false,
             running: false,
             pending_redraw: false,
@@ -207,53 +159,46 @@ impl<T: 'static> EventLoop<T> {
         })
     }
 
-    fn single_iteration<F>(&mut self, main_event: Option<MainEvent<'_>>, callback: &mut F)
-    where
-        F: FnMut(event::Event<T>, &RootAEL),
-    {
+    fn single_iteration<A: ApplicationHandler>(
+        &mut self,
+        main_event: Option<MainEvent<'_>>,
+        app: &mut A,
+    ) {
         trace!("Mainloop iteration");
 
         let cause = self.cause;
         let mut pending_redraw = self.pending_redraw;
         let mut resized = false;
 
-        callback(event::Event::NewEvents(cause), self.window_target());
+        app.new_events(self.window_target(), cause);
 
         if let Some(event) = main_event {
             trace!("Handling main event {:?}", event);
 
             match event {
                 MainEvent::InitWindow { .. } => {
-                    callback(event::Event::Resumed, self.window_target());
-                }
+                    app.resumed(self.window_target());
+                },
                 MainEvent::TerminateWindow { .. } => {
-                    callback(event::Event::Suspended, self.window_target());
-                }
+                    app.suspended(self.window_target());
+                },
                 MainEvent::WindowResized { .. } => resized = true,
                 MainEvent::RedrawNeeded { .. } => pending_redraw = true,
                 MainEvent::ContentRectChanged { .. } => {
                     warn!("TODO: find a way to notify application of content rect change");
-                }
+                },
                 MainEvent::GainedFocus => {
                     HAS_FOCUS.store(true, Ordering::Relaxed);
-                    callback(
-                        event::Event::WindowEvent {
-                            window_id: window::WindowId(WindowId),
-                            event: event::WindowEvent::Focused(true),
-                        },
-                        self.window_target(),
-                    );
-                }
+                    let window_id = window::WindowId(WindowId);
+                    let event = event::WindowEvent::Focused(true);
+                    app.window_event(self.window_target(), window_id, event);
+                },
                 MainEvent::LostFocus => {
                     HAS_FOCUS.store(false, Ordering::Relaxed);
-                    callback(
-                        event::Event::WindowEvent {
-                            window_id: window::WindowId(WindowId),
-                            event: event::WindowEvent::Focused(false),
-                        },
-                        self.window_target(),
-                    );
-                }
+                    let window_id = window::WindowId(WindowId);
+                    let event = event::WindowEvent::Focused(false);
+                    app.window_event(self.window_target(), window_id, event);
+                },
                 MainEvent::ConfigChanged { .. } => {
                     let monitor = MonitorHandle::new(self.android_app.clone());
                     let old_scale_factor = monitor.scale_factor();
@@ -262,54 +207,53 @@ impl<T: 'static> EventLoop<T> {
                         let new_inner_size = Arc::new(Mutex::new(
                             MonitorHandle::new(self.android_app.clone()).size(),
                         ));
-                        let event = event::Event::WindowEvent {
-                            window_id: window::WindowId(WindowId),
-                            event: event::WindowEvent::ScaleFactorChanged {
-                                inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                                    &new_inner_size,
-                                )),
-                                scale_factor,
-                            },
+                        let window_id = window::WindowId(WindowId);
+                        let event = event::WindowEvent::ScaleFactorChanged {
+                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
+                                &new_inner_size,
+                            )),
+                            scale_factor,
                         };
-                        callback(event, self.window_target());
+
+                        app.window_event(self.window_target(), window_id, event);
                     }
-                }
+                },
                 MainEvent::LowMemory => {
-                    callback(event::Event::MemoryWarning, self.window_target());
-                }
+                    app.memory_warning(self.window_target());
+                },
                 MainEvent::Start => {
                     // XXX: how to forward this state to applications?
                     warn!("TODO: forward onStart notification to application");
-                }
+                },
                 MainEvent::Resume { .. } => {
                     debug!("App Resumed - is running");
                     self.running = true;
-                }
+                },
                 MainEvent::SaveState { .. } => {
                     // XXX: how to forward this state to applications?
                     // XXX: also how do we expose state restoration to apps?
                     warn!("TODO: forward saveState notification to application");
-                }
+                },
                 MainEvent::Pause => {
                     debug!("App Paused - stopped running");
                     self.running = false;
-                }
+                },
                 MainEvent::Stop => {
                     // XXX: how to forward this state to applications?
                     warn!("TODO: forward onStop notification to application");
-                }
+                },
                 MainEvent::Destroy => {
                     // XXX: maybe exit mainloop to drop things before being
                     // killed by the OS?
                     warn!("TODO: forward onDestroy notification to application");
-                }
+                },
                 MainEvent::InsetsChanged { .. } => {
                     // XXX: how to forward this state to applications?
                     warn!("TODO: handle Android InsetsChanged notification");
-                }
+                },
                 unknown => {
                     trace!("Unknown MainEvent {unknown:?} (ignored)");
-                }
+                },
             }
         } else {
             trace!("No main event to handle");
@@ -323,7 +267,7 @@ impl<T: 'static> EventLoop<T> {
         match android_app.input_events_iter() {
             Ok(mut input_iter) => loop {
                 let read_event =
-                    input_iter.next(|event| self.handle_input_event(&android_app, event, callback));
+                    input_iter.next(|event| self.handle_input_event(&android_app, event, app));
 
                 if !read_event {
                     break;
@@ -331,14 +275,11 @@ impl<T: 'static> EventLoop<T> {
             },
             Err(err) => {
                 tracing::warn!("Failed to get input events iterator: {err:?}");
-            }
+            },
         }
 
-        // Empty the user event buffer
-        {
-            while let Ok(event) = self.user_events_receiver.try_recv() {
-                callback(crate::event::Event::UserEvent(event), self.window_target());
-            }
+        if self.proxy_wake_up.swap(false, Ordering::Relaxed) {
+            app.proxy_wake_up(self.window_target());
         }
 
         if self.running {
@@ -350,39 +291,32 @@ impl<T: 'static> EventLoop<T> {
                 } else {
                     PhysicalSize::new(0, 0)
                 };
-                let event = event::Event::WindowEvent {
-                    window_id: window::WindowId(WindowId),
-                    event: event::WindowEvent::Resized(size),
-                };
-                callback(event, self.window_target());
+                let window_id = window::WindowId(WindowId);
+                let event = event::WindowEvent::Resized(size);
+                app.window_event(self.window_target(), window_id, event);
             }
 
             pending_redraw |= self.redraw_flag.get_and_reset();
             if pending_redraw {
                 pending_redraw = false;
-                let event = event::Event::WindowEvent {
-                    window_id: window::WindowId(WindowId),
-                    event: event::WindowEvent::RedrawRequested,
-                };
-                callback(event, self.window_target());
+                let window_id = window::WindowId(WindowId);
+                let event = event::WindowEvent::RedrawRequested;
+                app.window_event(self.window_target(), window_id, event);
             }
         }
 
         // This is always the last event we dispatch before poll again
-        callback(event::Event::AboutToWait, self.window_target());
+        app.about_to_wait(self.window_target());
 
         self.pending_redraw = pending_redraw;
     }
 
-    fn handle_input_event<F>(
+    fn handle_input_event<A: ApplicationHandler>(
         &mut self,
         android_app: &AndroidApp,
         event: &InputEvent<'_>,
-        callback: &mut F,
-    ) -> InputStatus
-    where
-        F: FnMut(event::Event<T>, &RootAEL),
-    {
+        app: &mut A,
+    ) -> InputStatus {
         let mut input_status = InputStatus::Handled;
         match event {
             InputEvent::MotionEvent(motion_event) => {
@@ -392,13 +326,13 @@ impl<T: 'static> EventLoop<T> {
                 let phase = match motion_event.action() {
                     MotionAction::Down | MotionAction::PointerDown => {
                         Some(event::TouchPhase::Started)
-                    }
+                    },
                     MotionAction::Up | MotionAction::PointerUp => Some(event::TouchPhase::Ended),
                     MotionAction::Move => Some(event::TouchPhase::Moved),
                     MotionAction::Cancel => Some(event::TouchPhase::Cancelled),
                     _ => {
                         None // TODO mouse events
-                    }
+                    },
                 };
                 if let Some(phase) = phase {
                     let pointers: Box<dyn Iterator<Item = android_activity::input::Pointer<'_>>> =
@@ -407,42 +341,43 @@ impl<T: 'static> EventLoop<T> {
                                 Box::new(std::iter::once(
                                     motion_event.pointer_at_index(motion_event.pointer_index()),
                                 ))
-                            }
+                            },
                             event::TouchPhase::Moved | event::TouchPhase::Cancelled => {
                                 Box::new(motion_event.pointers())
-                            }
+                            },
                         };
 
                     for pointer in pointers {
-                        let location = PhysicalPosition {
-                            x: pointer.x() as _,
-                            y: pointer.y() as _,
-                        };
-                        trace!("Input event {device_id:?}, {phase:?}, loc={location:?}, pointer={pointer:?}");
-                        let event = event::Event::WindowEvent {
-                            window_id,
-                            event: event::WindowEvent::Touch(event::Touch {
-                                device_id,
-                                phase,
-                                location,
-                                id: pointer.pointer_id() as u64,
-                                force: Some(Force::Normalized(pointer.pressure() as f64)),
-                            }),
-                        };
-                        callback(event, self.window_target());
+                        let location =
+                            PhysicalPosition { x: pointer.x() as _, y: pointer.y() as _ };
+                        trace!(
+                            "Input event {device_id:?}, {phase:?}, loc={location:?}, \
+                             pointer={pointer:?}"
+                        );
+
+                        let event = event::WindowEvent::Touch(event::Touch {
+                            device_id,
+                            phase,
+                            location,
+                            id: pointer.pointer_id() as u64,
+                            force: Some(Force::Normalized(pointer.pressure() as f64)),
+                        });
+
+                        app.window_event(self.window_target(), window_id, event);
                     }
                 }
-            }
+            },
             InputEvent::KeyEvent(key) => {
                 match key.key_code() {
-                    // Flag keys related to volume as unhandled. While winit does not have a way for applications
-                    // to configure what keys to flag as handled, this appears to be a good default until winit
+                    // Flag keys related to volume as unhandled. While winit does not have a way for
+                    // applications to configure what keys to flag as handled,
+                    // this appears to be a good default until winit
                     // can be configured.
-                    Keycode::VolumeUp | Keycode::VolumeDown | Keycode::VolumeMute => {
-                        if self.ignore_volume_keys {
-                            input_status = InputStatus::Unhandled
-                        }
-                    }
+                    Keycode::VolumeUp | Keycode::VolumeDown | Keycode::VolumeMute
+                        if self.ignore_volume_keys =>
+                    {
+                        input_status = InputStatus::Unhandled
+                    },
                     keycode => {
                         let state = match key.action() {
                             KeyAction::Down => event::ElementState::Pressed,
@@ -456,64 +391,61 @@ impl<T: 'static> EventLoop<T> {
                             &mut self.combining_accent,
                         );
 
-                        let event = event::Event::WindowEvent {
-                            window_id: window::WindowId(WindowId),
-                            event: event::WindowEvent::KeyboardInput {
-                                device_id: event::DeviceId(DeviceId(key.device_id())),
-                                event: event::KeyEvent {
-                                    state,
-                                    physical_key: keycodes::to_physical_key(keycode),
-                                    logical_key: keycodes::to_logical(key_char, keycode),
-                                    location: keycodes::to_location(keycode),
-                                    repeat: key.repeat_count() > 0,
-                                    text: None,
-                                    platform_specific: KeyEventExtra {},
-                                },
-                                is_synthetic: false,
+                        let window_id = window::WindowId(WindowId);
+                        let event = event::WindowEvent::KeyboardInput {
+                            device_id: event::DeviceId(DeviceId(key.device_id())),
+                            event: event::KeyEvent {
+                                state,
+                                physical_key: keycodes::to_physical_key(keycode),
+                                logical_key: keycodes::to_logical(key_char, keycode),
+                                location: keycodes::to_location(keycode),
+                                repeat: key.repeat_count() > 0,
+                                text: None,
+                                platform_specific: KeyEventExtra {},
                             },
+                            is_synthetic: false,
                         };
-                        callback(event, self.window_target());
-                    }
+
+                        app.window_event(self.window_target(), window_id, event);
+                    },
                 }
-            }
+            },
             _ => {
                 warn!("Unknown android_activity input event {event:?}")
-            }
+            },
         }
 
         input_status
     }
 
-    pub fn run<F>(mut self, event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(event::Event<T>, &event_loop::ActiveEventLoop),
-    {
-        self.run_on_demand(event_handler)
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
     }
 
-    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(event::Event<T>, &event_loop::ActiveEventLoop),
-    {
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
         loop {
-            match self.pump_events(None, &mut event_handler) {
+            match self.pump_app_events(None, app) {
                 PumpStatus::Exit(0) => {
                     break Ok(());
-                }
+                },
                 PumpStatus::Exit(code) => {
                     break Err(EventLoopError::ExitFailure(code));
-                }
+                },
                 _ => {
                     continue;
-                }
+                },
             }
         }
     }
 
-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
-    where
-        F: FnMut(event::Event<T>, &RootAEL),
-    {
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
         if !self.loop_running {
             self.loop_running = true;
 
@@ -524,18 +456,18 @@ impl<T: 'static> EventLoop<T> {
             self.cause = StartCause::Init;
 
             // run the initial loop iteration
-            self.single_iteration(None, &mut callback);
+            self.single_iteration(None, app);
         }
 
         // Consider the possibility that the `StartCause::Init` iteration could
         // request to Exit
         if !self.exiting() {
-            self.poll_events_with_timeout(timeout, &mut callback);
+            self.poll_events_with_timeout(timeout, app);
         }
         if self.exiting() {
             self.loop_running = false;
 
-            callback(event::Event::LoopExiting, self.window_target());
+            app.exiting(self.window_target());
 
             PumpStatus::Exit(0)
         } else {
@@ -543,81 +475,75 @@ impl<T: 'static> EventLoop<T> {
         }
     }
 
-    fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
-    where
-        F: FnMut(event::Event<T>, &RootAEL),
-    {
+    fn poll_events_with_timeout<A: ApplicationHandler>(
+        &mut self,
+        mut timeout: Option<Duration>,
+        app: &mut A,
+    ) {
         let start = Instant::now();
 
         self.pending_redraw |= self.redraw_flag.get_and_reset();
 
-        timeout =
-            if self.running && (self.pending_redraw || self.user_events_receiver.has_incoming()) {
-                // If we already have work to do then we don't want to block on the next poll
-                Some(Duration::ZERO)
-            } else {
-                let control_flow_timeout = match self.control_flow() {
-                    ControlFlow::Wait => None,
-                    ControlFlow::Poll => Some(Duration::ZERO),
-                    ControlFlow::WaitUntil(wait_deadline) => {
-                        Some(wait_deadline.saturating_duration_since(start))
-                    }
-                };
-
-                min_timeout(control_flow_timeout, timeout)
+        timeout = if self.running
+            && (self.pending_redraw || self.proxy_wake_up.load(Ordering::Relaxed))
+        {
+            // If we already have work to do then we don't want to block on the next poll
+            Some(Duration::ZERO)
+        } else {
+            let control_flow_timeout = match self.control_flow() {
+                ControlFlow::Wait => None,
+                ControlFlow::Poll => Some(Duration::ZERO),
+                ControlFlow::WaitUntil(wait_deadline) => {
+                    Some(wait_deadline.saturating_duration_since(start))
+                },
             };
 
-        let app = self.android_app.clone(); // Don't borrow self as part of poll expression
-        app.poll_events(timeout, |poll_event| {
+            min_timeout(control_flow_timeout, timeout)
+        };
+
+        let android_app = self.android_app.clone(); // Don't borrow self as part of poll expression
+        android_app.poll_events(timeout, |poll_event| {
             let mut main_event = None;
 
             match poll_event {
                 android_activity::PollEvent::Wake => {
                     // In the X11 backend it's noted that too many false-positive wake ups
-                    // would cause the event loop to run continuously. They handle this by re-checking
-                    // for pending events (assuming they cover all valid reasons for a wake up).
+                    // would cause the event loop to run continuously. They handle this by
+                    // re-checking for pending events (assuming they cover all
+                    // valid reasons for a wake up).
                     //
                     // For now, user_events and redraw_requests are the only reasons to expect
                     // a wake up here so we can ignore the wake up if there are no events/requests.
                     // We also ignore wake ups while suspended.
                     self.pending_redraw |= self.redraw_flag.get_and_reset();
                     if !self.running
-                        || (!self.pending_redraw && !self.user_events_receiver.has_incoming())
+                        || (!self.pending_redraw && !self.proxy_wake_up.load(Ordering::Relaxed))
                     {
                         return;
                     }
-                }
-                android_activity::PollEvent::Timeout => {}
+                },
+                android_activity::PollEvent::Timeout => {},
                 android_activity::PollEvent::Main(event) => {
                     main_event = Some(event);
-                }
+                },
                 unknown_event => {
                     warn!("Unknown poll event {unknown_event:?} (ignored)");
-                }
+                },
             }
 
             self.cause = match self.control_flow() {
                 ControlFlow::Poll => StartCause::Poll,
-                ControlFlow::Wait => StartCause::WaitCancelled {
-                    start,
-                    requested_resume: None,
-                },
+                ControlFlow::Wait => StartCause::WaitCancelled { start, requested_resume: None },
                 ControlFlow::WaitUntil(deadline) => {
                     if Instant::now() < deadline {
-                        StartCause::WaitCancelled {
-                            start,
-                            requested_resume: Some(deadline),
-                        }
+                        StartCause::WaitCancelled { start, requested_resume: Some(deadline) }
                     } else {
-                        StartCause::ResumeTimeReached {
-                            start,
-                            requested_resume: deadline,
-                        }
+                        StartCause::ResumeTimeReached { start, requested_resume: deadline }
                     }
-                }
+                },
             };
 
-            self.single_iteration(main_event, &mut callback);
+            self.single_iteration(main_event, app);
         });
     }
 
@@ -625,9 +551,9 @@ impl<T: 'static> EventLoop<T> {
         &self.window_target
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+    pub fn create_proxy(&self) -> EventLoopProxy {
         EventLoopProxy {
-            user_events_sender: self.user_events_sender.clone(),
+            proxy_wake_up: self.proxy_wake_up.clone(),
             waker: self.android_app.create_waker(),
         }
     }
@@ -641,27 +567,16 @@ impl<T: 'static> EventLoop<T> {
     }
 }
 
-pub struct EventLoopProxy<T: 'static> {
-    user_events_sender: mpsc::Sender<T>,
+#[derive(Clone)]
+pub struct EventLoopProxy {
+    proxy_wake_up: Arc<AtomicBool>,
     waker: AndroidAppWaker,
 }
 
-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        EventLoopProxy {
-            user_events_sender: self.user_events_sender.clone(),
-            waker: self.waker.clone(),
-        }
-    }
-}
-
-impl<T> EventLoopProxy<T> {
-    pub fn send_event(&self, event: T) -> Result<(), event_loop::EventLoopClosed<T>> {
-        self.user_events_sender
-            .send(event)
-            .map_err(|err| event_loop::EventLoopClosed(err.0))?;
+impl EventLoopProxy {
+    pub fn wake_up(&self) {
+        self.proxy_wake_up.store(true, Ordering::Relaxed);
         self.waker.wake();
-        Ok(())
     }
 }
 
@@ -679,9 +594,7 @@ impl ActiveEventLoop {
 
     pub fn create_custom_cursor(&self, source: CustomCursorSource) -> CustomCursor {
         let _ = source.inner;
-        CustomCursor {
-            inner: PlatformCustomCursor,
-        }
+        CustomCursor { inner: PlatformCustomCursor }
     }
 
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
@@ -704,9 +617,7 @@ impl ActiveEventLoop {
     pub fn raw_display_handle_rwh_06(
         &self,
     ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::RawDisplayHandle::Android(
-            rwh_06::AndroidDisplayHandle::new(),
-        ))
+        Ok(rwh_06::RawDisplayHandle::Android(rwh_06::AndroidDisplayHandle::new()))
     }
 
     pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
@@ -798,10 +709,7 @@ impl Window {
     ) -> Result<Self, error::OsError> {
         // FIXME this ignores requested window attributes
 
-        Ok(Self {
-            app: el.app.clone(),
-            redraw_requester: el.redraw_requester.clone(),
-        })
+        Ok(Self { app: el.app.clone(), redraw_requester: el.redraw_requester.clone() })
     }
 
     pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Self) + Send + 'static) {
@@ -941,41 +849,31 @@ impl Window {
     pub fn set_cursor(&self, _: Cursor) {}
 
     pub fn set_cursor_position(&self, _: Position) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(
-            error::NotSupportedError::new(),
-        ))
+        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
     }
 
     pub fn set_cursor_grab(&self, _: CursorGrabMode) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(
-            error::NotSupportedError::new(),
-        ))
+        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
     }
 
     pub fn set_cursor_visible(&self, _: bool) {}
 
     pub fn drag_window(&self) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(
-            error::NotSupportedError::new(),
-        ))
+        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
     }
 
     pub fn drag_resize_window(
         &self,
         _direction: ResizeDirection,
     ) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(
-            error::NotSupportedError::new(),
-        ))
+        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
     }
 
     #[inline]
     pub fn show_window_menu(&self, _position: Position) {}
 
     pub fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), error::ExternalError> {
-        Err(error::ExternalError::NotSupported(
-            error::NotSupportedError::new(),
-        ))
+        Err(error::ExternalError::NotSupported(error::NotSupportedError::new()))
     }
 
     #[cfg(feature = "rwh_04")]
@@ -985,7 +883,11 @@ impl Window {
         if let Some(native_window) = self.app.native_window().as_ref() {
             native_window.raw_window_handle()
         } else {
-            panic!("Cannot get the native window, it's null and will always be null before Event::Resumed and after Event::Suspended. Make sure you only call this function between those events.");
+            panic!(
+                "Cannot get the native window, it's null and will always be null before \
+                 Event::Resumed and after Event::Suspended. Make sure you only call this function \
+                 between those events."
+            );
         }
     }
 
@@ -996,7 +898,11 @@ impl Window {
         if let Some(native_window) = self.app.native_window().as_ref() {
             native_window.raw_window_handle()
         } else {
-            panic!("Cannot get the native window, it's null and will always be null before Event::Resumed and after Event::Suspended. Make sure you only call this function between those events.");
+            panic!(
+                "Cannot get the native window, it's null and will always be null before \
+                 Event::Resumed and after Event::Suspended. Make sure you only call this function \
+                 between those events."
+            );
         }
     }
 
@@ -1014,7 +920,11 @@ impl Window {
         if let Some(native_window) = self.app.native_window().as_ref() {
             native_window.raw_window_handle()
         } else {
-            tracing::error!("Cannot get the native window, it's null and will always be null before Event::Resumed and after Event::Suspended. Make sure you only call this function between those events.");
+            tracing::error!(
+                "Cannot get the native window, it's null and will always be null before \
+                 Event::Resumed and after Event::Suspended. Make sure you only call this function \
+                 between those events."
+            );
             Err(rwh_06::HandleError::Unavailable)
         }
     }
@@ -1023,9 +933,7 @@ impl Window {
     pub fn raw_display_handle_rwh_06(
         &self,
     ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::RawDisplayHandle::Android(
-            rwh_06::AndroidDisplayHandle::new(),
-        ))
+        Ok(rwh_06::RawDisplayHandle::Android(rwh_06::AndroidDisplayHandle::new()))
     }
 
     pub fn config(&self) -> ConfigurationRef {
@@ -1102,11 +1010,7 @@ impl MonitorHandle {
     }
 
     pub fn scale_factor(&self) -> f64 {
-        self.app
-            .config()
-            .density()
-            .map(|dpi| dpi as f64 / 160.0)
-            .unwrap_or(1.0)
+        self.app.config().density().map(|dpi| dpi as f64 / 160.0).unwrap_or(1.0)
     }
 
     pub fn refresh_rate_millihertz(&self) -> Option<u32> {

src/platform_impl/apple/appkit/app.rs

@@ -1,16 +1,11 @@
 #![allow(clippy::unnecessary_cast)]
 
-use icrate::AppKit::{
-    NSApplication, NSEvent, NSEventModifierFlagCommand, NSEventTypeKeyUp, NSEventTypeLeftMouseDown,
-    NSEventTypeLeftMouseDragged, NSEventTypeLeftMouseUp, NSEventTypeMouseMoved,
-    NSEventTypeOtherMouseDown, NSEventTypeOtherMouseDragged, NSEventTypeOtherMouseUp,
-    NSEventTypeRightMouseDown, NSEventTypeRightMouseDragged, NSEventTypeRightMouseUp, NSResponder,
-};
-use icrate::Foundation::{MainThreadMarker, NSObject};
 use objc2::{declare_class, msg_send, mutability, ClassType, DeclaredClass};
+use objc2_app_kit::{NSApplication, NSEvent, NSEventModifierFlags, NSEventType, NSResponder};
+use objc2_foundation::{MainThreadMarker, NSObject};
 
-use super::app_delegate::ApplicationDelegate;
-use super::event::flags_contains;
+use super::app_state::ApplicationDelegate;
+use super::DEVICE_ID;
 use crate::event::{DeviceEvent, ElementState};
 
 declare_class!(
@@ -36,8 +31,8 @@ declare_class!(
             // but that doesn't really matter here.
             let event_type = unsafe { event.r#type() };
             let modifier_flags = unsafe { event.modifierFlags() };
-            if event_type == NSEventTypeKeyUp
-                && flags_contains(modifier_flags, NSEventModifierFlagCommand)
+            if event_type == NSEventType::KeyUp
+                && modifier_flags.contains(NSEventModifierFlags::NSEventModifierFlagCommand)
             {
                 if let Some(key_window) = self.keyWindow() {
                     key_window.sendEvent(event);
@@ -55,45 +50,57 @@ fn maybe_dispatch_device_event(delegate: &ApplicationDelegate, event: &NSEvent)
     let event_type = unsafe { event.r#type() };
     #[allow(non_upper_case_globals)]
     match event_type {
-        NSEventTypeMouseMoved
-        | NSEventTypeLeftMouseDragged
-        | NSEventTypeOtherMouseDragged
-        | NSEventTypeRightMouseDragged => {
+        NSEventType::MouseMoved
+        | NSEventType::LeftMouseDragged
+        | NSEventType::OtherMouseDragged
+        | NSEventType::RightMouseDragged => {
             let delta_x = unsafe { event.deltaX() } as f64;
             let delta_y = unsafe { event.deltaY() } as f64;
 
             if delta_x != 0.0 {
-                delegate.queue_device_event(DeviceEvent::Motion {
-                    axis: 0,
-                    value: delta_x,
+                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::Motion {
+                        axis: 0,
+                        value: delta_x,
+                    });
                 });
             }
 
             if delta_y != 0.0 {
-                delegate.queue_device_event(DeviceEvent::Motion {
-                    axis: 1,
-                    value: delta_y,
+                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::Motion {
+                        axis: 1,
+                        value: delta_y,
+                    });
                 })
             }
 
             if delta_x != 0.0 || delta_y != 0.0 {
-                delegate.queue_device_event(DeviceEvent::MouseMotion {
-                    delta: (delta_x, delta_y),
+                delegate.maybe_queue_with_handler(move |app, event_loop| {
+                    app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseMotion {
+                        delta: (delta_x, delta_y),
+                    });
                 });
             }
-        }
-        NSEventTypeLeftMouseDown | NSEventTypeRightMouseDown | NSEventTypeOtherMouseDown => {
-            delegate.queue_device_event(DeviceEvent::Button {
-                button: unsafe { event.buttonNumber() } as u32,
-                state: ElementState::Pressed,
+        },
+        NSEventType::LeftMouseDown | NSEventType::RightMouseDown | NSEventType::OtherMouseDown => {
+            let button = unsafe { event.buttonNumber() } as u32;
+            delegate.maybe_queue_with_handler(move |app, event_loop| {
+                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
+                    button,
+                    state: ElementState::Pressed,
+                });
             });
-        }
-        NSEventTypeLeftMouseUp | NSEventTypeRightMouseUp | NSEventTypeOtherMouseUp => {
-            delegate.queue_device_event(DeviceEvent::Button {
-                button: unsafe { event.buttonNumber() } as u32,
-                state: ElementState::Released,
+        },
+        NSEventType::LeftMouseUp | NSEventType::RightMouseUp | NSEventType::OtherMouseUp => {
+            let button = unsafe { event.buttonNumber() } as u32;
+            delegate.maybe_queue_with_handler(move |app, event_loop| {
+                app.device_event(event_loop, DEVICE_ID, DeviceEvent::Button {
+                    button,
+                    state: ElementState::Released,
+                });
             });
-        }
+        },
         _ => (),
     }
 }

src/platform_impl/apple/appkit/app_state.rs

@@ -1,31 +1,32 @@
 use std::cell::{Cell, RefCell};
-use std::collections::VecDeque;
 use std::mem;
 use std::rc::Weak;
-use std::sync::{Arc, Mutex};
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
+use std::sync::Arc;
 use std::time::Instant;
 
-use icrate::AppKit::{NSApplication, NSApplicationActivationPolicy, NSApplicationDelegate};
-use icrate::Foundation::{MainThreadMarker, NSObject, NSObjectProtocol, NSSize};
-use objc2::rc::Id;
-use objc2::runtime::AnyObject;
+use objc2::rc::Retained;
 use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
+use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSApplicationDelegate};
+use objc2_foundation::{MainThreadMarker, NSNotification, NSObject, NSObjectProtocol};
+
+use crate::application::ApplicationHandler;
+use crate::event::{StartCause, WindowEvent};
+use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
+use crate::window::WindowId as RootWindowId;
 
 use super::event_handler::EventHandler;
 use super::event_loop::{stop_app_immediately, ActiveEventLoop, PanicInfo};
 use super::observer::{EventLoopWaker, RunLoop};
-use super::window::WinitWindow;
-use super::{menu, WindowId, DEVICE_ID};
-use crate::dpi::PhysicalSize;
-use crate::event::{DeviceEvent, Event, InnerSizeWriter, StartCause, WindowEvent};
-use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
-use crate::window::WindowId as RootWindowId;
+use super::{menu, WindowId};
 
-#[derive(Debug, Default)]
-pub(super) struct State {
+#[derive(Debug)]
+pub(super) struct AppState {
     activation_policy: NSApplicationActivationPolicy,
     default_menu: bool,
     activate_ignoring_other_apps: bool,
+    run_loop: RunLoop,
+    proxy_wake_up: Arc<AtomicBool>,
     event_handler: EventHandler,
     stop_on_launch: Cell<bool>,
     stop_before_wait: Cell<bool>,
@@ -41,8 +42,9 @@ pub(super) struct State {
     waker: RefCell<EventLoopWaker>,
     start_time: Cell<Option<Instant>>,
     wait_timeout: Cell<Option<Instant>>,
-    pending_events: RefCell<VecDeque<QueuedEvent>>,
     pending_redraw: RefCell<Vec<WindowId>>,
+    // NOTE: This is strongly referenced by our `NSWindowDelegate` and our `NSView` subclass, and
+    // as such should be careful to not add fields that, in turn, strongly reference those.
 }
 
 declare_class!(
@@ -56,62 +58,20 @@ declare_class!(
     }
 
     impl DeclaredClass for ApplicationDelegate {
-        type Ivars = State;
+        type Ivars = AppState;
     }
 
     unsafe impl NSObjectProtocol for ApplicationDelegate {}
 
     unsafe impl NSApplicationDelegate for ApplicationDelegate {
-        // Note: This will, globally, only be run once, no matter how many
-        // `EventLoop`s the user creates.
         #[method(applicationDidFinishLaunching:)]
-        fn did_finish_launching(&self, _sender: Option<&AnyObject>) {
-            trace_scope!("applicationDidFinishLaunching:");
-            self.ivars().is_launched.set(true);
-
-            let mtm = MainThreadMarker::from(self);
-            let app = NSApplication::sharedApplication(mtm);
-            // We need to delay setting the activation policy and activating the app
-            // until `applicationDidFinishLaunching` has been called. Otherwise the
-            // menu bar is initially unresponsive on macOS 10.15.
-            app.setActivationPolicy(self.ivars().activation_policy);
-
-            window_activation_hack(&app);
-            #[allow(deprecated)]
-            app.activateIgnoringOtherApps(self.ivars().activate_ignoring_other_apps);
-
-            if self.ivars().default_menu {
-                // The menubar initialization should be before the `NewEvents` event, to allow
-                // overriding of the default menu even if it's created
-                menu::initialize(&app);
-            }
-
-            self.ivars().waker.borrow_mut().start();
-
-            self.set_is_running(true);
-            self.dispatch_init_events();
-
-            // If the application is being launched via `EventLoop::pump_app_events()` then we'll
-            // want to stop the app once it is launched (and return to the external loop)
-            //
-            // In this case we still want to consider Winit's `EventLoop` to be "running",
-            // so we call `start_running()` above.
-            if self.ivars().stop_on_launch.get() {
-                // Note: the original idea had been to only stop the underlying `RunLoop`
-                // for the app but that didn't work as expected (`-[NSApplication run]`
-                // effectively ignored the attempt to stop the RunLoop and re-started it).
-                //
-                // So we return from `pump_events` by stopping the application.
-                let app = NSApplication::sharedApplication(mtm);
-                stop_app_immediately(&app);
-            }
+        fn app_did_finish_launching(&self, notification: &NSNotification) {
+            self.did_finish_launching(notification)
         }
 
         #[method(applicationWillTerminate:)]
-        fn will_terminate(&self, _sender: Option<&AnyObject>) {
-            trace_scope!("applicationWillTerminate:");
-            // TODO: Notify every window that it will be destroyed, like done in iOS?
-            self.internal_exit();
+        fn app_will_terminate(&self, notification: &NSNotification) {
+            self.will_terminate(notification)
         }
     }
 );
@@ -120,25 +80,90 @@ impl ApplicationDelegate {
     pub(super) fn new(
         mtm: MainThreadMarker,
         activation_policy: NSApplicationActivationPolicy,
+        proxy_wake_up: Arc<AtomicBool>,
         default_menu: bool,
         activate_ignoring_other_apps: bool,
-    ) -> Id<Self> {
-        let this = mtm.alloc().set_ivars(State {
+    ) -> Retained<Self> {
+        let this = mtm.alloc().set_ivars(AppState {
             activation_policy,
+            proxy_wake_up,
             default_menu,
             activate_ignoring_other_apps,
-            ..Default::default()
+            run_loop: RunLoop::main(mtm),
+            event_handler: EventHandler::new(),
+            stop_on_launch: Cell::new(false),
+            stop_before_wait: Cell::new(false),
+            stop_after_wait: Cell::new(false),
+            stop_on_redraw: Cell::new(false),
+            is_launched: Cell::new(false),
+            is_running: Cell::new(false),
+            exit: Cell::new(false),
+            control_flow: Cell::new(ControlFlow::default()),
+            waker: RefCell::new(EventLoopWaker::new()),
+            start_time: Cell::new(None),
+            wait_timeout: Cell::new(None),
+            pending_redraw: RefCell::new(vec![]),
         });
         unsafe { msg_send_id![super(this), init] }
     }
 
-    pub fn get(mtm: MainThreadMarker) -> Id<Self> {
+    // NOTE: This will, globally, only be run once, no matter how many
+    // `EventLoop`s the user creates.
+    fn did_finish_launching(&self, _notification: &NSNotification) {
+        trace_scope!("applicationDidFinishLaunching:");
+        self.ivars().is_launched.set(true);
+
+        let mtm = MainThreadMarker::from(self);
+        let app = NSApplication::sharedApplication(mtm);
+        // We need to delay setting the activation policy and activating the app
+        // until `applicationDidFinishLaunching` has been called. Otherwise the
+        // menu bar is initially unresponsive on macOS 10.15.
+        app.setActivationPolicy(self.ivars().activation_policy);
+
+        window_activation_hack(&app);
+        #[allow(deprecated)]
+        app.activateIgnoringOtherApps(self.ivars().activate_ignoring_other_apps);
+
+        if self.ivars().default_menu {
+            // The menubar initialization should be before the `NewEvents` event, to allow
+            // overriding of the default menu even if it's created
+            menu::initialize(&app);
+        }
+
+        self.ivars().waker.borrow_mut().start();
+
+        self.set_is_running(true);
+        self.dispatch_init_events();
+
+        // If the application is being launched via `EventLoop::pump_app_events()` then we'll
+        // want to stop the app once it is launched (and return to the external loop)
+        //
+        // In this case we still want to consider Winit's `EventLoop` to be "running",
+        // so we call `start_running()` above.
+        if self.ivars().stop_on_launch.get() {
+            // NOTE: the original idea had been to only stop the underlying `RunLoop`
+            // for the app but that didn't work as expected (`-[NSApplication run]`
+            // effectively ignored the attempt to stop the RunLoop and re-started it).
+            //
+            // So we return from `pump_events` by stopping the application.
+            let app = NSApplication::sharedApplication(mtm);
+            stop_app_immediately(&app);
+        }
+    }
+
+    fn will_terminate(&self, _notification: &NSNotification) {
+        trace_scope!("applicationWillTerminate:");
+        // TODO: Notify every window that it will be destroyed, like done in iOS?
+        self.internal_exit();
+    }
+
+    pub fn get(mtm: MainThreadMarker) -> Retained<Self> {
         let app = NSApplication::sharedApplication(mtm);
         let delegate =
             unsafe { app.delegate() }.expect("a delegate was not configured on the application");
         if delegate.is_kind_of::<Self>() {
             // SAFETY: Just checked that the delegate is an instance of `ApplicationDelegate`
-            unsafe { Id::cast(delegate) }
+            unsafe { Retained::cast(delegate) }
         } else {
             panic!("tried to get a delegate that was not the one Winit has registered")
         }
@@ -148,7 +173,7 @@ impl ApplicationDelegate {
     /// of the given closure.
     pub fn set_event_handler<R>(
         &self,
-        handler: impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop),
+        handler: &mut dyn ApplicationHandler,
         closure: impl FnOnce() -> R,
     ) -> R {
         self.ivars().event_handler.set(handler, closure)
@@ -179,10 +204,12 @@ impl ApplicationDelegate {
 
     /// Clears the `running` state and resets the `control_flow` state when an `EventLoop` exits.
     ///
-    /// Note: that if the `NSApplication` has been launched then that state is preserved,
+    /// NOTE: that if the `NSApplication` has been launched then that state is preserved,
     /// and we won't need to re-launch the app if subsequent EventLoops are run.
     pub fn internal_exit(&self) {
-        self.handle_event(Event::LoopExiting);
+        self.with_handler(|app, event_loop| {
+            app.exiting(event_loop);
+        });
 
         self.set_is_running(false);
         self.set_stop_on_redraw(false);
@@ -223,48 +250,18 @@ impl ApplicationDelegate {
         self.ivars().control_flow.get()
     }
 
-    pub fn queue_window_event(&self, window_id: WindowId, event: WindowEvent) {
-        self.ivars()
-            .pending_events
-            .borrow_mut()
-            .push_back(QueuedEvent::WindowEvent(window_id, event));
-    }
-
-    pub fn queue_device_event(&self, event: DeviceEvent) {
-        self.ivars()
-            .pending_events
-            .borrow_mut()
-            .push_back(QueuedEvent::DeviceEvent(event));
-    }
-
-    pub fn queue_static_scale_factor_changed_event(
-        &self,
-        window: Id<WinitWindow>,
-        suggested_size: PhysicalSize<u32>,
-        scale_factor: f64,
-    ) {
-        self.ivars()
-            .pending_events
-            .borrow_mut()
-            .push_back(QueuedEvent::ScaleFactorChanged {
-                window,
-                suggested_size,
-                scale_factor,
-            });
-    }
-
     pub fn handle_redraw(&self, window_id: WindowId) {
         let mtm = MainThreadMarker::from(self);
         // Redraw request might come out of order from the OS.
         // -> Don't go back into the event handler when our callstack originates from there
         if !self.ivars().event_handler.in_use() {
-            self.handle_event(Event::WindowEvent {
-                window_id: RootWindowId(window_id),
-                event: WindowEvent::RedrawRequested,
+            self.with_handler(|app, event_loop| {
+                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
             });
 
-            // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested events
-            // as a way to ensure that `pump_events` can't block an external loop indefinitely
+            // `pump_events` will request to stop immediately _after_ dispatching RedrawRequested
+            // events as a way to ensure that `pump_events` can't block an external loop
+            // indefinitely
             if self.ivars().stop_on_redraw.get() {
                 let app = NSApplication::sharedApplication(mtm);
                 stop_app_immediately(&app);
@@ -277,21 +274,46 @@ impl ApplicationDelegate {
         if !pending_redraw.contains(&window_id) {
             pending_redraw.push(window_id);
         }
-        unsafe { RunLoop::get() }.wakeup();
+        self.ivars().run_loop.wakeup();
     }
 
-    fn handle_event(&self, event: Event<HandlePendingUserEvents>) {
-        self.ivars()
-            .event_handler
-            .handle_event(event, &ActiveEventLoop::new_root(self.retain()))
+    #[track_caller]
+    pub fn maybe_queue_with_handler(
+        &self,
+        callback: impl FnOnce(&mut dyn ApplicationHandler, &RootActiveEventLoop) + 'static,
+    ) {
+        // Most programmer actions in AppKit (e.g. change window fullscreen, set focused, etc.)
+        // result in an event being queued, and applied at a later point.
+        //
+        // However, it is not documented which actions do this, and which ones are done immediately,
+        // so to make sure that we don't encounter re-entrancy issues, we first check if we're
+        // currently handling another event, and if we are, we queue the event instead.
+        if !self.ivars().event_handler.in_use() {
+            self.with_handler(callback);
+        } else {
+            tracing::debug!("had to queue event since another is currently being handled");
+            let this = self.retain();
+            self.ivars().run_loop.queue_closure(move || {
+                this.with_handler(callback);
+            });
+        }
+    }
+
+    #[track_caller]
+    fn with_handler(
+        &self,
+        callback: impl FnOnce(&mut dyn ApplicationHandler, &RootActiveEventLoop),
+    ) {
+        let event_loop = ActiveEventLoop::new_root(self.retain());
+        self.ivars().event_handler.handle(callback, &event_loop);
     }
 
     /// dispatch `NewEvents(Init)` + `Resumed`
     pub fn dispatch_init_events(&self) {
-        self.handle_event(Event::NewEvents(StartCause::Init));
+        self.with_handler(|app, event_loop| app.new_events(event_loop, StartCause::Init));
         // NB: For consistency all platforms must emit a 'resumed' event even though macOS
         // applications don't themselves have a formal suspend/resume lifecycle.
-        self.handle_event(Event::Resumed);
+        self.with_handler(|app, event_loop| app.resumed(event_loop));
     }
 
     // Called by RunLoopObserver after finishing waiting for new events
@@ -301,8 +323,7 @@ impl ApplicationDelegate {
             .upgrade()
             .expect("The panic info must exist here. This failure indicates a developer error.");
 
-        // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        if panic_info.is_panicking() || !self.ivars().event_handler.ready() || !self.is_running() {
+        if panic_info.is_panicking() || !self.is_running() {
             return;
         }
 
@@ -314,26 +335,17 @@ impl ApplicationDelegate {
         let start = self.ivars().start_time.get().unwrap();
         let cause = match self.control_flow() {
             ControlFlow::Poll => StartCause::Poll,
-            ControlFlow::Wait => StartCause::WaitCancelled {
-                start,
-                requested_resume: None,
-            },
+            ControlFlow::Wait => StartCause::WaitCancelled { start, requested_resume: None },
             ControlFlow::WaitUntil(requested_resume) => {
                 if Instant::now() >= requested_resume {
-                    StartCause::ResumeTimeReached {
-                        start,
-                        requested_resume,
-                    }
+                    StartCause::ResumeTimeReached { start, requested_resume }
                 } else {
-                    StartCause::WaitCancelled {
-                        start,
-                        requested_resume: Some(requested_resume),
-                    }
+                    StartCause::WaitCancelled { start, requested_resume: Some(requested_resume) }
                 }
-            }
+            },
         };
 
-        self.handle_event(Event::NewEvents(cause));
+        self.with_handler(|app, event_loop| app.new_events(event_loop, cause));
     }
 
     // Called by RunLoopObserver before waiting for new events
@@ -343,72 +355,23 @@ impl ApplicationDelegate {
             .upgrade()
             .expect("The panic info must exist here. This failure indicates a developer error.");
 
-        // Return when in event handler due to https://github.com/rust-windowing/winit/issues/1779
-        // XXX: how does it make sense that `event_handler.ready()` can ever return `false` here if
-        // we're about to return to the `CFRunLoop` to poll for new events?
-        if panic_info.is_panicking() || !self.ivars().event_handler.ready() || !self.is_running() {
+        if panic_info.is_panicking() || !self.is_running() {
             return;
         }
 
-        self.handle_event(Event::UserEvent(HandlePendingUserEvents));
-
-        let events = mem::take(&mut *self.ivars().pending_events.borrow_mut());
-        for event in events {
-            match event {
-                QueuedEvent::WindowEvent(window_id, event) => {
-                    self.handle_event(Event::WindowEvent {
-                        window_id: RootWindowId(window_id),
-                        event,
-                    });
-                }
-                QueuedEvent::DeviceEvent(event) => {
-                    self.handle_event(Event::DeviceEvent {
-                        device_id: DEVICE_ID,
-                        event,
-                    });
-                }
-                QueuedEvent::ScaleFactorChanged {
-                    window,
-                    suggested_size,
-                    scale_factor,
-                } => {
-                    let new_inner_size = Arc::new(Mutex::new(suggested_size));
-                    let scale_factor_changed_event = Event::WindowEvent {
-                        window_id: RootWindowId(window.id()),
-                        event: WindowEvent::ScaleFactorChanged {
-                            scale_factor,
-                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                                &new_inner_size,
-                            )),
-                        },
-                    };
-
-                    self.handle_event(scale_factor_changed_event);
-
-                    let physical_size = *new_inner_size.lock().unwrap();
-                    drop(new_inner_size);
-                    let logical_size = physical_size.to_logical(scale_factor);
-                    let size = NSSize::new(logical_size.width, logical_size.height);
-                    window.setContentSize(size);
-
-                    let resized_event = Event::WindowEvent {
-                        window_id: RootWindowId(window.id()),
-                        event: WindowEvent::Resized(physical_size),
-                    };
-                    self.handle_event(resized_event);
-                }
-            }
+        if self.ivars().proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
+            self.with_handler(|app, event_loop| app.proxy_wake_up(event_loop));
         }
 
         let redraw = mem::take(&mut *self.ivars().pending_redraw.borrow_mut());
         for window_id in redraw {
-            self.handle_event(Event::WindowEvent {
-                window_id: RootWindowId(window_id),
-                event: WindowEvent::RedrawRequested,
+            self.with_handler(|app, event_loop| {
+                app.window_event(event_loop, RootWindowId(window_id), WindowEvent::RedrawRequested);
             });
         }
-
-        self.handle_event(Event::AboutToWait);
+        self.with_handler(|app, event_loop| {
+            app.about_to_wait(event_loop);
+        });
 
         if self.exiting() {
             let app = NSApplication::sharedApplication(mtm);
@@ -426,34 +389,15 @@ impl ApplicationDelegate {
             ControlFlow::Poll => Some(Instant::now()),
             ControlFlow::WaitUntil(instant) => Some(instant),
         };
-        self.ivars()
-            .waker
-            .borrow_mut()
-            .start_at(min_timeout(wait_timeout, app_timeout));
+        self.ivars().waker.borrow_mut().start_at(min_timeout(wait_timeout, app_timeout));
     }
 }
 
-#[derive(Debug)]
-pub(crate) enum QueuedEvent {
-    WindowEvent(WindowId, WindowEvent),
-    DeviceEvent(DeviceEvent),
-    ScaleFactorChanged {
-        window: Id<WinitWindow>,
-        suggested_size: PhysicalSize<u32>,
-        scale_factor: f64,
-    },
-}
-
-#[derive(Debug)]
-pub(crate) struct HandlePendingUserEvents;
-
 /// Returns the minimum `Option<Instant>`, taking into account that `None`
 /// equates to an infinite timeout, not a zero timeout (so can't just use
 /// `Option::min`)
 fn min_timeout(a: Option<Instant>, b: Option<Instant>) -> Option<Instant> {
-    a.map_or(b, |a_timeout| {
-        b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout)))
-    })
+    a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
 }
 
 /// A hack to make activation of multiple windows work when creating them before

src/platform_impl/apple/appkit/cursor.rs

@@ -2,24 +2,23 @@ use std::ffi::c_uchar;
 use std::slice;
 use std::sync::OnceLock;
 
-use icrate::AppKit::{NSBitmapImageRep, NSCursor, NSDeviceRGBColorSpace, NSImage};
-use icrate::Foundation::{
+use objc2::rc::Retained;
+use objc2::runtime::Sel;
+use objc2::{msg_send_id, sel, ClassType};
+use objc2_app_kit::{NSBitmapImageRep, NSCursor, NSDeviceRGBColorSpace, NSImage};
+use objc2_foundation::{
     ns_string, NSData, NSDictionary, NSNumber, NSObject, NSObjectProtocol, NSPoint, NSSize,
     NSString,
 };
-use objc2::rc::Id;
-use objc2::runtime::Sel;
-use objc2::{msg_send_id, sel, ClassType};
 
-use crate::cursor::CursorImage;
-use crate::cursor::OnlyCursorImageSource;
+use crate::cursor::{CursorImage, OnlyCursorImageSource};
 use crate::window::CursorIcon;
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct CustomCursor(pub(crate) Id<NSCursor>);
+pub struct CustomCursor(pub(crate) Retained<NSCursor>);
 
 // SAFETY: NSCursor is immutable and thread-safe
-// TODO(madsmtm): Put this logic in icrate itself
+// TODO(madsmtm): Put this logic in objc2-app-kit itself
 unsafe impl Send for CustomCursor {}
 unsafe impl Sync for CustomCursor {}
 
@@ -29,7 +28,7 @@ impl CustomCursor {
     }
 }
 
-pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Id<NSCursor> {
+pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Retained<NSCursor> {
     let width = cursor.width;
     let height = cursor.height;
 
@@ -61,14 +60,14 @@ pub(crate) fn cursor_from_image(cursor: &CursorImage) -> Id<NSCursor> {
     NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
 }
 
-pub(crate) fn default_cursor() -> Id<NSCursor> {
+pub(crate) fn default_cursor() -> Retained<NSCursor> {
     NSCursor::arrowCursor()
 }
 
-unsafe fn try_cursor_from_selector(sel: Sel) -> Option<Id<NSCursor>> {
+unsafe fn try_cursor_from_selector(sel: Sel) -> Option<Retained<NSCursor>> {
     let cls = NSCursor::class();
     if cls.responds_to(sel) {
-        let cursor: Id<NSCursor> = unsafe { msg_send_id![cls, performSelector: sel] };
+        let cursor: Retained<NSCursor> = unsafe { msg_send_id![cls, performSelector: sel] };
         Some(cursor)
     } else {
         tracing::warn!("cursor `{sel}` appears to be invalid");
@@ -83,7 +82,7 @@ macro_rules! def_undocumented_cursor {
     )*} => {$(
         $(#[$($m)*])*
         #[allow(non_snake_case)]
-        fn $name() -> Id<NSCursor> {
+        fn $name() -> Retained<NSCursor> {
             unsafe { try_cursor_from_selector(sel!($name)).unwrap_or_else(|| default_cursor()) }
         }
     )*};
@@ -113,12 +112,15 @@ def_undocumented_cursor!(
 
 // Note that loading `busybutclickable` with this code won't animate
 // the frames; instead you'll just get them all in a column.
-unsafe fn load_webkit_cursor(name: &NSString) -> Id<NSCursor> {
+unsafe fn load_webkit_cursor(name: &NSString) -> Retained<NSCursor> {
     // Snatch a cursor from WebKit; They fit the style of the native
     // cursors, and will seem completely standard to macOS users.
     //
     // https://stackoverflow.com/a/21786835/5435443
-    let root = ns_string!("/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/HIServices.framework/Versions/A/Resources/cursors");
+    let root = ns_string!(
+        "/System/Library/Frameworks/ApplicationServices.framework/Versions/A/Frameworks/\
+         HIServices.framework/Versions/A/Resources/cursors"
+    );
     let cursor_path = root.stringByAppendingPathComponent(name);
 
     let pdf_path = cursor_path.stringByAppendingPathComponent(ns_string!("cursor.pdf"));
@@ -126,7 +128,7 @@ unsafe fn load_webkit_cursor(name: &NSString) -> Id<NSCursor> {
 
     // TODO: Handle PLists better
     let info_path = cursor_path.stringByAppendingPathComponent(ns_string!("info.plist"));
-    let info: Id<NSDictionary<NSObject, NSObject>> = unsafe {
+    let info: Retained<NSDictionary<NSObject, NSObject>> = unsafe {
         msg_send_id![
             <NSDictionary<NSObject, NSObject>>::class(),
             dictionaryWithContentsOfFile: &*info_path,
@@ -153,26 +155,26 @@ unsafe fn load_webkit_cursor(name: &NSString) -> Id<NSCursor> {
     NSCursor::initWithImage_hotSpot(NSCursor::alloc(), &image, hotspot)
 }
 
-fn webkit_move() -> Id<NSCursor> {
+fn webkit_move() -> Retained<NSCursor> {
     unsafe { load_webkit_cursor(ns_string!("move")) }
 }
 
-fn webkit_cell() -> Id<NSCursor> {
+fn webkit_cell() -> Retained<NSCursor> {
     unsafe { load_webkit_cursor(ns_string!("cell")) }
 }
 
-pub(crate) fn invisible_cursor() -> Id<NSCursor> {
+pub(crate) fn invisible_cursor() -> Retained<NSCursor> {
     // 16x16 GIF data for invisible cursor
     // You can reproduce this via ImageMagick.
     // $ convert -size 16x16 xc:none cursor.gif
     static CURSOR_BYTES: &[u8] = &[
-        0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x10, 0x00, 0x10, 0x00, 0xF0, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x21, 0xF9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x00, 0x00,
-        0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x0E, 0x84, 0x8F, 0xA9, 0xCB, 0xED, 0x0F,
-        0xA3, 0x9C, 0xB4, 0xDA, 0x8B, 0xB3, 0x3E, 0x05, 0x00, 0x3B,
+        0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x10, 0x00, 0x10, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x21, 0xf9, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00,
+        0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x00, 0x02, 0x0e, 0x84, 0x8f, 0xa9, 0xcb, 0xed, 0x0f,
+        0xa3, 0x9c, 0xb4, 0xda, 0x8b, 0xb3, 0x3e, 0x05, 0x00, 0x3b,
     ];
 
-    fn new_invisible() -> Id<NSCursor> {
+    fn new_invisible() -> Retained<NSCursor> {
         // TODO: Consider using `dataWithBytesNoCopy:`
         let data = NSData::with_bytes(CURSOR_BYTES);
         let image = NSImage::initWithData(NSImage::alloc(), &data).unwrap();
@@ -182,13 +184,10 @@ pub(crate) fn invisible_cursor() -> Id<NSCursor> {
 
     // Cache this for efficiency
     static CURSOR: OnceLock<CustomCursor> = OnceLock::new();
-    CURSOR
-        .get_or_init(|| CustomCursor(new_invisible()))
-        .0
-        .clone()
+    CURSOR.get_or_init(|| CustomCursor(new_invisible())).0.clone()
 }
 
-pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Id<NSCursor> {
+pub(crate) fn cursor_from_icon(icon: CursorIcon) -> Retained<NSCursor> {
     match icon {
         CursorIcon::Default => default_cursor(),
         CursorIcon::Pointer => NSCursor::pointingHandCursor(),

src/platform_impl/apple/appkit/event.rs

@@ -1,25 +1,17 @@
 use std::ffi::c_void;
 
-use core_foundation::{
-    base::CFRelease,
-    data::{CFDataGetBytePtr, CFDataRef},
-};
-use icrate::AppKit::{
-    NSEvent, NSEventModifierFlagCommand, NSEventModifierFlagControl, NSEventModifierFlagOption,
-    NSEventModifierFlagShift, NSEventModifierFlags, NSEventSubtypeWindowExposed,
-    NSEventTypeApplicationDefined,
-};
-use icrate::Foundation::{MainThreadMarker, NSPoint};
-use objc2::rc::Id;
+use core_foundation::base::CFRelease;
+use core_foundation::data::{CFDataGetBytePtr, CFDataRef};
+use objc2::rc::Retained;
+use objc2_app_kit::{NSEvent, NSEventModifierFlags, NSEventSubtype, NSEventType};
+use objc2_foundation::{run_on_main, NSPoint};
 use smol_str::SmolStr;
 
-use crate::{
-    event::{ElementState, KeyEvent, Modifiers},
-    keyboard::{
-        Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey,
-        NativeKeyCode, PhysicalKey,
-    },
-    platform_impl::platform::ffi,
+use super::ffi;
+use crate::event::{ElementState, KeyEvent, Modifiers};
+use crate::keyboard::{
+    Key, KeyCode, KeyLocation, ModifiersKeys, ModifiersState, NamedKey, NativeKey, NativeKeyCode,
+    PhysicalKey,
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -48,7 +40,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
         }
         layout = CFDataGetBytePtr(layout_data as CFDataRef) as *const ffi::UCKeyboardLayout;
     }
-    let keyboard_type = MainThreadMarker::run_on_main(|_mtm| unsafe { ffi::LMGetKbdType() });
+    let keyboard_type = run_on_main(|_mtm| unsafe { ffi::LMGetKbdType() });
 
     let mut result_len = 0;
     let mut dead_keys = 0;
@@ -71,10 +63,7 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
         CFRelease(input_source as *mut c_void);
     }
     if translate_result != 0 {
-        tracing::error!(
-            "`UCKeyTranslate` returned with the non-zero value: {}",
-            translate_result
-        );
+        tracing::error!("`UCKeyTranslate` returned with the non-zero value: {}", translate_result);
         return Key::Unidentified(NativeKey::MacOS(scancode));
     }
     if result_len == 0 {
@@ -125,9 +114,8 @@ pub(crate) fn create_key_event(
     let text_with_all_modifiers: Option<SmolStr> = if key_override.is_some() {
         None
     } else {
-        let characters = unsafe { 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();
         if characters.is_empty() {
             None
         } else {
@@ -145,8 +133,8 @@ pub(crate) fn create_key_event(
         let key_without_modifiers = get_modifierless_char(scancode);
 
         let modifiers = unsafe { ns_event.modifierFlags() };
-        let has_ctrl = flags_contains(modifiers, NSEventModifierFlagControl);
-        let has_cmd = flags_contains(modifiers, NSEventModifierFlagCommand);
+        let has_ctrl = modifiers.contains(NSEventModifierFlags::NSEventModifierFlagControl);
+        let has_cmd = modifiers.contains(NSEventModifierFlags::NSEventModifierFlagCommand);
 
         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
@@ -157,7 +145,7 @@ pub(crate) fn create_key_event(
             Some(text) if !has_ctrl && !has_cmd => {
                 // Character heeding both SHIFT and ALT.
                 Key::Character(text.clone())
-            }
+            },
 
             _ => match key_without_modifiers.as_ref() {
                 // Character heeding just SHIFT, ignoring ALT.
@@ -173,11 +161,7 @@ pub(crate) fn create_key_event(
         (key_from_code.clone(), key_from_code)
     };
 
-    let text = if is_press {
-        logical_key.to_text().map(SmolStr::new)
-    } else {
-        None
-    };
+    let text = if is_press { logical_key.to_text().map(SmolStr::new) } else { None };
 
     let location = code_to_location(physical_key);
 
@@ -188,10 +172,7 @@ pub(crate) fn create_key_event(
         repeat: is_repeat,
         state,
         text,
-        platform_specific: KeyEventExtra {
-            text_with_all_modifiers,
-            key_without_modifiers,
-        },
+        platform_specific: KeyEventExtra { text_with_all_modifiers, key_without_modifiers },
     }
 }
 
@@ -315,25 +296,21 @@ pub fn extra_function_key_to_code(scancode: u16, string: &str) -> PhysicalKey {
 }
 
 // The values are from the https://github.com/apple-oss-distributions/IOHIDFamily/blob/19666c840a6d896468416ff0007040a10b7b46b8/IOHIDSystem/IOKit/hidsystem/IOLLEvent.h#L258-L259
-const NX_DEVICELCTLKEYMASK: NSEventModifierFlags = 0x00000001;
-const NX_DEVICELSHIFTKEYMASK: NSEventModifierFlags = 0x00000002;
-const NX_DEVICERSHIFTKEYMASK: NSEventModifierFlags = 0x00000004;
-const NX_DEVICELCMDKEYMASK: NSEventModifierFlags = 0x00000008;
-const NX_DEVICERCMDKEYMASK: NSEventModifierFlags = 0x00000010;
-const NX_DEVICELALTKEYMASK: NSEventModifierFlags = 0x00000020;
-const NX_DEVICERALTKEYMASK: NSEventModifierFlags = 0x00000040;
-const NX_DEVICERCTLKEYMASK: NSEventModifierFlags = 0x00002000;
-
-pub(super) fn flags_contains(flags: NSEventModifierFlags, value: NSEventModifierFlags) -> bool {
-    flags & value == value
-}
+const NX_DEVICELCTLKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00000001);
+const NX_DEVICELSHIFTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00000002);
+const NX_DEVICERSHIFTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00000004);
+const NX_DEVICELCMDKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00000008);
+const NX_DEVICERCMDKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00000010);
+const NX_DEVICELALTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00000020);
+const NX_DEVICERALTKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00000040);
+const NX_DEVICERCTLKEYMASK: NSEventModifierFlags = NSEventModifierFlags(0x00002000);
 
 pub(super) fn lalt_pressed(event: &NSEvent) -> bool {
-    flags_contains(unsafe { event.modifierFlags() }, NX_DEVICELALTKEYMASK)
+    unsafe { event.modifierFlags() }.contains(NX_DEVICELALTKEYMASK)
 }
 
 pub(super) fn ralt_pressed(event: &NSEvent) -> bool {
-    flags_contains(unsafe { event.modifierFlags() }, NX_DEVICERALTKEYMASK)
+    unsafe { event.modifierFlags() }.contains(NX_DEVICERALTKEYMASK)
 }
 
 pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
@@ -341,74 +318,42 @@ pub(super) fn event_mods(event: &NSEvent) -> Modifiers {
     let mut state = ModifiersState::empty();
     let mut pressed_mods = ModifiersKeys::empty();
 
-    state.set(
-        ModifiersState::SHIFT,
-        flags_contains(flags, NSEventModifierFlagShift),
-    );
-    pressed_mods.set(
-        ModifiersKeys::LSHIFT,
-        flags_contains(flags, NX_DEVICELSHIFTKEYMASK),
-    );
-    pressed_mods.set(
-        ModifiersKeys::RSHIFT,
-        flags_contains(flags, NX_DEVICERSHIFTKEYMASK),
-    );
+    state
+        .set(ModifiersState::SHIFT, flags.contains(NSEventModifierFlags::NSEventModifierFlagShift));
+    pressed_mods.set(ModifiersKeys::LSHIFT, flags.contains(NX_DEVICELSHIFTKEYMASK));
+    pressed_mods.set(ModifiersKeys::RSHIFT, flags.contains(NX_DEVICERSHIFTKEYMASK));
 
     state.set(
         ModifiersState::CONTROL,
-        flags_contains(flags, NSEventModifierFlagControl),
-    );
-    pressed_mods.set(
-        ModifiersKeys::LCONTROL,
-        flags_contains(flags, NX_DEVICELCTLKEYMASK),
-    );
-    pressed_mods.set(
-        ModifiersKeys::RCONTROL,
-        flags_contains(flags, NX_DEVICERCTLKEYMASK),
+        flags.contains(NSEventModifierFlags::NSEventModifierFlagControl),
     );
+    pressed_mods.set(ModifiersKeys::LCONTROL, flags.contains(NX_DEVICELCTLKEYMASK));
+    pressed_mods.set(ModifiersKeys::RCONTROL, flags.contains(NX_DEVICERCTLKEYMASK));
 
-    state.set(
-        ModifiersState::ALT,
-        flags_contains(flags, NSEventModifierFlagOption),
-    );
-    pressed_mods.set(
-        ModifiersKeys::LALT,
-        flags_contains(flags, NX_DEVICELALTKEYMASK),
-    );
-    pressed_mods.set(
-        ModifiersKeys::RALT,
-        flags_contains(flags, NX_DEVICERALTKEYMASK),
-    );
+    state.set(ModifiersState::ALT, flags.contains(NSEventModifierFlags::NSEventModifierFlagOption));
+    pressed_mods.set(ModifiersKeys::LALT, flags.contains(NX_DEVICELALTKEYMASK));
+    pressed_mods.set(ModifiersKeys::RALT, flags.contains(NX_DEVICERALTKEYMASK));
 
     state.set(
         ModifiersState::SUPER,
-        flags_contains(flags, NSEventModifierFlagCommand),
-    );
-    pressed_mods.set(
-        ModifiersKeys::LSUPER,
-        flags_contains(flags, NX_DEVICELCMDKEYMASK),
-    );
-    pressed_mods.set(
-        ModifiersKeys::RSUPER,
-        flags_contains(flags, NX_DEVICERCMDKEYMASK),
+        flags.contains(NSEventModifierFlags::NSEventModifierFlagCommand),
     );
+    pressed_mods.set(ModifiersKeys::LSUPER, flags.contains(NX_DEVICELCMDKEYMASK));
+    pressed_mods.set(ModifiersKeys::RSUPER, flags.contains(NX_DEVICERCMDKEYMASK));
 
-    Modifiers {
-        state,
-        pressed_mods,
-    }
+    Modifiers { state, pressed_mods }
 }
 
-pub(super) fn dummy_event() -> Option<Id<NSEvent>> {
+pub(super) fn dummy_event() -> Option<Retained<NSEvent>> {
     unsafe {
         NSEvent::otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2(
-            NSEventTypeApplicationDefined,
+            NSEventType::ApplicationDefined,
             NSPoint::new(0.0, 0.0),
-            0, // Empty NSEventModifierFlags
+            NSEventModifierFlags(0),
             0.0,
             0,
             None,
-            NSEventSubtypeWindowExposed,
+            NSEventSubtype::WindowExposed.0,
             0,
             0,
         )
@@ -549,7 +494,7 @@ pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         0x07 => KeyCode::KeyX,
         0x08 => KeyCode::KeyC,
         0x09 => KeyCode::KeyV,
-        //0x0a => World 1,
+        // 0x0a => World 1,
         0x0b => KeyCode::KeyB,
         0x0c => KeyCode::KeyQ,
         0x0d => KeyCode::KeyW,
@@ -591,7 +536,7 @@ pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         0x31 => KeyCode::Space,
         0x32 => KeyCode::Backquote,
         0x33 => KeyCode::Backspace,
-        //0x34 => unknown,
+        // 0x34 => unknown,
         0x35 => KeyCode::Escape,
         0x36 => KeyCode::SuperRight,
         0x37 => KeyCode::SuperLeft,
@@ -605,22 +550,23 @@ pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         0x3f => KeyCode::Fn,
         0x40 => KeyCode::F17,
         0x41 => KeyCode::NumpadDecimal,
-        //0x42 -> unknown,
+        // 0x42 -> unknown,
         0x43 => KeyCode::NumpadMultiply,
-        //0x44 => unknown,
+        // 0x44 => unknown,
         0x45 => KeyCode::NumpadAdd,
-        //0x46 => unknown,
+        // 0x46 => unknown,
         0x47 => KeyCode::NumLock,
-        //0x48 => KeyCode::NumpadClear,
+        // 0x48 => KeyCode::NumpadClear,
 
         // TODO: (Artur) for me, kVK_VolumeUp is 0x48
         // macOS 10.11
-        // /System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/HIToolbox.framework/Versions/A/Headers/Events.h
+        // /System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/HIToolbox.framework/
+        // Versions/A/Headers/Events.h
         0x49 => KeyCode::AudioVolumeUp,
         0x4a => KeyCode::AudioVolumeDown,
         0x4b => KeyCode::NumpadDivide,
         0x4c => KeyCode::NumpadEnter,
-        //0x4d => unknown,
+        // 0x4d => unknown,
         0x4e => KeyCode::NumpadSubtract,
         0x4f => KeyCode::F18,
         0x50 => KeyCode::F19,
@@ -637,25 +583,25 @@ pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         0x5b => KeyCode::Numpad8,
         0x5c => KeyCode::Numpad9,
         0x5d => KeyCode::IntlYen,
-        //0x5e => JIS Ro,
-        //0x5f => unknown,
+        // 0x5e => JIS Ro,
+        // 0x5f => unknown,
         0x60 => KeyCode::F5,
         0x61 => KeyCode::F6,
         0x62 => KeyCode::F7,
         0x63 => KeyCode::F3,
         0x64 => KeyCode::F8,
         0x65 => KeyCode::F9,
-        //0x66 => JIS Eisuu (macOS),
+        // 0x66 => JIS Eisuu (macOS),
         0x67 => KeyCode::F11,
-        //0x68 => JIS Kanna (macOS),
+        // 0x68 => JIS Kanna (macOS),
         0x69 => KeyCode::F13,
         0x6a => KeyCode::F16,
         0x6b => KeyCode::F14,
-        //0x6c => unknown,
+        // 0x6c => unknown,
         0x6d => KeyCode::F10,
-        //0x6e => unknown,
+        // 0x6e => unknown,
         0x6f => KeyCode::F12,
-        //0x70 => unknown,
+        // 0x70 => unknown,
         0x71 => KeyCode::F15,
         0x72 => KeyCode::Insert,
         0x73 => KeyCode::Home,
@@ -670,7 +616,7 @@ pub(crate) fn scancode_to_physicalkey(scancode: u32) -> PhysicalKey {
         0x7c => KeyCode::ArrowRight,
         0x7d => KeyCode::ArrowDown,
         0x7e => KeyCode::ArrowUp,
-        //0x7f =>  unknown,
+        // 0x7f =>  unknown,
 
         // 0xA is the caret (^) an macOS's German QERTZ layout. This key is at the same location as
         // backquote (`) on Windows' US layout.

src/platform_impl/apple/appkit/event_handler.rs

@@ -1,32 +1,34 @@
 use std::cell::RefCell;
-use std::fmt;
-use std::mem;
+use std::{fmt, mem};
 
-use super::app_delegate::HandlePendingUserEvents;
-use crate::event::Event;
+use crate::application::ApplicationHandler;
 use crate::event_loop::ActiveEventLoop as RootActiveEventLoop;
 
-struct EventHandlerData {
-    #[allow(clippy::type_complexity)]
-    handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
-}
-
-impl fmt::Debug for EventHandlerData {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("EventHandlerData").finish_non_exhaustive()
-    }
-}
-
-#[derive(Debug, Default)]
+#[derive(Default)]
 pub(crate) struct EventHandler {
     /// This can be in the following states:
     /// - Not registered by the event loop (None).
     /// - Present (Some(handler)).
     /// - Currently executing the handler / in use (RefCell borrowed).
-    inner: RefCell<Option<EventHandlerData>>,
+    inner: RefCell<Option<&'static mut dyn ApplicationHandler>>,
+}
+
+impl fmt::Debug for EventHandler {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let state = match self.inner.try_borrow().as_deref() {
+            Ok(Some(_)) => "<available>",
+            Ok(None) => "<not set>",
+            Err(_) => "<in use>",
+        };
+        f.debug_struct("EventHandler").field("state", &state).finish_non_exhaustive()
+    }
 }
 
 impl EventHandler {
+    pub(crate) fn new() -> Self {
+        Self { inner: RefCell::new(None) }
+    }
+
     /// Set the event loop handler for the duration of the given closure.
     ///
     /// This is similar to using the `scoped-tls` or `scoped-tls-hkt` crates
@@ -34,7 +36,7 @@ impl EventHandler {
     /// from within the closure.
     pub(crate) fn set<'handler, R>(
         &self,
-        handler: impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler,
+        app: &'handler mut dyn ApplicationHandler,
         closure: impl FnOnce() -> R,
     ) -> R {
         // SAFETY: We extend the lifetime of the handler here so that we can
@@ -45,21 +47,21 @@ impl EventHandler {
         // extended beyond `'handler`.
         let handler = unsafe {
             mem::transmute::<
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'handler>,
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) + 'static>,
-            >(Box::new(handler))
+                &'handler mut dyn ApplicationHandler,
+                &'static mut dyn ApplicationHandler,
+            >(app)
         };
 
         match self.inner.try_borrow_mut().as_deref_mut() {
             Ok(Some(_)) => {
                 unreachable!("tried to set handler while another was already set");
-            }
+            },
             Ok(data @ None) => {
-                *data = Some(EventHandlerData { handler });
-            }
+                *data = Some(handler);
+            },
             Err(_) => {
                 unreachable!("tried to set handler that is currently in use");
-            }
+            },
         }
 
         struct ClearOnDrop<'a>(&'a EventHandler);
@@ -69,10 +71,10 @@ impl EventHandler {
                 match self.0.inner.try_borrow_mut().as_deref_mut() {
                     Ok(data @ Some(_)) => {
                         *data = None;
-                    }
+                    },
                     Ok(None) => {
                         tracing::error!("tried to clear handler, but no handler was set");
-                    }
+                    },
                     Err(_) => {
                         // Note: This is not expected to ever happen, this
                         // module generally controls the `RefCell`, and
@@ -83,7 +85,7 @@ impl EventHandler {
                         // weren't able to unset the handler.
                         eprintln!("tried to clear handler that is currently in use");
                         std::process::abort();
-                    }
+                    },
                 }
             }
         }
@@ -102,35 +104,31 @@ impl EventHandler {
         self.inner.try_borrow().is_err()
     }
 
-    pub(crate) fn ready(&self) -> bool {
-        matches!(self.inner.try_borrow().as_deref(), Ok(Some(_)))
-    }
-
-    pub(crate) fn handle_event(
+    pub(crate) fn handle(
         &self,
-        event: Event<HandlePendingUserEvents>,
+        callback: impl FnOnce(&mut dyn ApplicationHandler, &RootActiveEventLoop),
         event_loop: &RootActiveEventLoop,
     ) {
         match self.inner.try_borrow_mut().as_deref_mut() {
-            Ok(Some(EventHandlerData { handler })) => {
+            Ok(Some(user_app)) => {
                 // It is important that we keep the reference borrowed here,
                 // so that `in_use` can properly detect that the handler is
                 // still in use.
                 //
                 // If the handler unwinds, the `RefMut` will ensure that the
                 // handler is no longer borrowed.
-                (handler)(event, event_loop);
-            }
+                callback(*user_app, event_loop);
+            },
             Ok(None) => {
                 // `NSApplication`, our app delegate and this handler are all
                 // global state and so it's not impossible that we could get
                 // an event after the application has exited the `EventLoop`.
                 tracing::error!("tried to run event handler, but no handler was set");
-            }
+            },
             Err(_) => {
                 // Prevent re-entrancy.
                 panic!("tried to handle event while another event is currently being handled");
-            }
+            },
         }
     }
 }

src/platform_impl/apple/appkit/event_loop.rs

@@ -1,47 +1,38 @@
-use std::{
-    any::Any,
-    cell::Cell,
-    collections::VecDeque,
-    marker::PhantomData,
-    os::raw::c_void,
-    panic::{catch_unwind, resume_unwind, RefUnwindSafe, UnwindSafe},
-    ptr,
-    rc::{Rc, Weak},
-    sync::mpsc,
-    time::{Duration, Instant},
-};
+use std::any::Any;
+use std::cell::Cell;
+use std::collections::VecDeque;
+use std::marker::PhantomData;
+use std::os::raw::c_void;
+use std::panic::{catch_unwind, resume_unwind, RefUnwindSafe, UnwindSafe};
+use std::ptr;
+use std::rc::{Rc, Weak};
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
 
 use core_foundation::base::{CFIndex, CFRelease};
 use core_foundation::runloop::{
-    kCFRunLoopCommonModes, CFRunLoopAddSource, CFRunLoopGetMain, CFRunLoopSourceContext,
+    kCFRunLoopDefaultMode, CFRunLoopAddSource, CFRunLoopGetMain, CFRunLoopSourceContext,
     CFRunLoopSourceCreate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
 };
-use icrate::AppKit::{
-    NSApplication, NSApplicationActivationPolicyAccessory, NSApplicationActivationPolicyProhibited,
-    NSApplicationActivationPolicyRegular, NSWindow,
-};
-use icrate::Foundation::{MainThreadMarker, NSObjectProtocol};
+use objc2::rc::{autoreleasepool, Retained};
+use objc2::runtime::ProtocolObject;
 use objc2::{msg_send_id, ClassType};
-use objc2::{
-    rc::{autoreleasepool, Id},
-    runtime::ProtocolObject,
-};
+use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSWindow};
+use objc2_foundation::{MainThreadMarker, NSObjectProtocol};
 
+use super::app::WinitApplication;
+use super::app_state::ApplicationDelegate;
+use super::cursor::CustomCursor;
 use super::event::dummy_event;
-use super::{
-    app::WinitApplication,
-    app_delegate::{ApplicationDelegate, HandlePendingUserEvents},
-    monitor::{self, MonitorHandle},
-    observer::setup_control_flow_observers,
-};
-use crate::platform_impl::platform::cursor::CustomCursor;
+use super::monitor::{self, MonitorHandle};
+use super::observer::setup_control_flow_observers;
+use crate::application::ApplicationHandler;
+use crate::error::EventLoopError;
+use crate::event_loop::{ActiveEventLoop as RootWindowTarget, ControlFlow, DeviceEvents};
+use crate::platform::macos::ActivationPolicy;
+use crate::platform::pump_events::PumpStatus;
 use crate::window::{CustomCursor as RootCustomCursor, CustomCursorSource};
-use crate::{
-    error::EventLoopError,
-    event::Event,
-    event_loop::{ActiveEventLoop as RootWindowTarget, ControlFlow, DeviceEvents, EventLoopClosed},
-    platform::{macos::ActivationPolicy, pump_events::PumpStatus},
-};
 
 #[derive(Default)]
 pub struct PanicInfo {
@@ -60,12 +51,14 @@ impl PanicInfo {
         self.inner.set(inner);
         result
     }
-    /// Overwrites the curret state if the current state is not panicking
+
+    /// Overwrites the current state if the current state is not panicking
     pub fn set_panic(&self, p: Box<dyn Any + Send + 'static>) {
         if !self.is_panicking() {
             self.inner.set(Some(p));
         }
     }
+
     pub fn take(&self) -> Option<Box<dyn Any + Send + 'static>> {
         self.inner.take()
     }
@@ -73,24 +66,23 @@ impl PanicInfo {
 
 #[derive(Debug)]
 pub struct ActiveEventLoop {
-    delegate: Id<ApplicationDelegate>,
+    delegate: Retained<ApplicationDelegate>,
     pub(super) mtm: MainThreadMarker,
 }
 
 impl ActiveEventLoop {
-    pub(super) fn new_root(delegate: Id<ApplicationDelegate>) -> RootWindowTarget {
+    pub(super) fn new_root(delegate: Retained<ApplicationDelegate>) -> RootWindowTarget {
         let mtm = MainThreadMarker::from(&*delegate);
         let p = Self { delegate, mtm };
-        RootWindowTarget {
-            p,
-            _marker: PhantomData,
-        }
+        RootWindowTarget { p, _marker: PhantomData }
+    }
+
+    pub(super) fn app_delegate(&self) -> &ApplicationDelegate {
+        &self.delegate
     }
 
     pub fn create_custom_cursor(&self, source: CustomCursorSource) -> RootCustomCursor {
-        RootCustomCursor {
-            inner: CustomCursor::new(source.inner),
-        }
+        RootCustomCursor { inner: CustomCursor::new(source.inner) }
     }
 
     #[inline]
@@ -118,9 +110,7 @@ impl ActiveEventLoop {
     pub fn raw_display_handle_rwh_06(
         &self,
     ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::RawDisplayHandle::AppKit(
-            rwh_06::AppKitDisplayHandle::new(),
-        ))
+        Ok(rwh_06::RawDisplayHandle::AppKit(rwh_06::AppKitDisplayHandle::new()))
     }
 
     pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
@@ -146,9 +136,7 @@ impl ActiveEventLoop {
     pub(crate) fn owned_display_handle(&self) -> OwnedDisplayHandle {
         OwnedDisplayHandle
     }
-}
 
-impl ActiveEventLoop {
     pub(crate) fn hide_application(&self) {
         NSApplication::sharedApplication(self.mtm).hide(None)
     }
@@ -166,35 +154,19 @@ impl ActiveEventLoop {
     }
 }
 
-fn map_user_event<T: 'static>(
-    mut handler: impl FnMut(Event<T>, &RootWindowTarget),
-    receiver: Rc<mpsc::Receiver<T>>,
-) -> impl FnMut(Event<HandlePendingUserEvents>, &RootWindowTarget) {
-    move |event, window_target| match event.map_nonuser_event() {
-        Ok(event) => (handler)(event, window_target),
-        Err(_) => {
-            for event in receiver.try_iter() {
-                (handler)(Event::UserEvent(event), window_target);
-            }
-        }
-    }
-}
-
-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
     /// Store a reference to the application for convenience.
     ///
     /// We intentionally don't store `WinitApplication` since we want to have
     /// the possibility of swapping that out at some point.
-    app: Id<NSApplication>,
+    app: Retained<NSApplication>,
     /// The application delegate that we've registered.
     ///
     /// The delegate is only weakly referenced by NSApplication, so we must
     /// keep it around here as well.
-    delegate: Id<ApplicationDelegate>,
+    delegate: Retained<ApplicationDelegate>,
 
-    // Event sender and receiver, used for EventLoopProxy.
-    sender: mpsc::Sender<T>,
-    receiver: Rc<mpsc::Receiver<T>>,
+    proxy_wake_up: Arc<AtomicBool>,
 
     window_target: RootWindowTarget,
     panic_info: Rc<PanicInfo>,
@@ -217,28 +189,35 @@ impl Default for PlatformSpecificEventLoopAttributes {
     }
 }
 
-impl<T> EventLoop<T> {
+impl EventLoop {
     pub(crate) fn new(
         attributes: &PlatformSpecificEventLoopAttributes,
     ) -> Result<Self, EventLoopError> {
         let mtm = MainThreadMarker::new()
             .expect("on macOS, `EventLoop` must be created on the main thread!");
 
-        let app: Id<NSApplication> =
+        let app: Retained<NSApplication> =
             unsafe { msg_send_id![WinitApplication::class(), sharedApplication] };
 
         if !app.is_kind_of::<WinitApplication>() {
-            panic!("`winit` requires control over the principal class. You must create the event loop before other parts of your application initialize NSApplication");
+            panic!(
+                "`winit` requires control over the principal class. You must create the event \
+                 loop before other parts of your application initialize NSApplication"
+            );
         }
 
         let activation_policy = match attributes.activation_policy {
-            ActivationPolicy::Regular => NSApplicationActivationPolicyRegular,
-            ActivationPolicy::Accessory => NSApplicationActivationPolicyAccessory,
-            ActivationPolicy::Prohibited => NSApplicationActivationPolicyProhibited,
+            ActivationPolicy::Regular => NSApplicationActivationPolicy::Regular,
+            ActivationPolicy::Accessory => NSApplicationActivationPolicy::Accessory,
+            ActivationPolicy::Prohibited => NSApplicationActivationPolicy::Prohibited,
         };
+
+        let proxy_wake_up = Arc::new(AtomicBool::new(false));
+
         let delegate = ApplicationDelegate::new(
             mtm,
             activation_policy,
+            proxy_wake_up.clone(),
             attributes.default_menu,
             attributes.activate_ignoring_other_apps,
         );
@@ -248,18 +227,16 @@ impl<T> EventLoop<T> {
         });
 
         let panic_info: Rc<PanicInfo> = Default::default();
-        setup_control_flow_observers(Rc::downgrade(&panic_info));
+        setup_control_flow_observers(mtm, Rc::downgrade(&panic_info));
 
-        let (sender, receiver) = mpsc::channel();
         Ok(EventLoop {
             app,
             delegate: delegate.clone(),
-            sender,
-            receiver: Rc::new(receiver),
             window_target: RootWindowTarget {
                 p: ActiveEventLoop { delegate, mtm },
                 _marker: PhantomData,
             },
+            proxy_wake_up,
             panic_info,
         })
     }
@@ -268,24 +245,19 @@ impl<T> EventLoop<T> {
         &self.window_target
     }
 
-    pub fn run<F>(mut self, handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &RootWindowTarget),
-    {
-        self.run_on_demand(handler)
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
     }
 
     // NB: we don't base this on `pump_events` because for `MacOs` we can't support
     // `pump_events` elegantly (we just ask to run the loop for a "short" amount of
     // time and so a layered implementation would end up using a lot of CPU due to
     // redundant wake ups.
-    pub fn run_on_demand<F>(&mut self, handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &RootWindowTarget),
-    {
-        let handler = map_user_event(handler, self.receiver.clone());
-
-        self.delegate.set_event_handler(handler, || {
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
+        self.delegate.set_event_handler(app, || {
             autoreleasepool(|_| {
                 // clear / normalize pump_events state
                 self.delegate.set_wait_timeout(None);
@@ -318,16 +290,15 @@ impl<T> EventLoop<T> {
         Ok(())
     }
 
-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, handler: F) -> PumpStatus
-    where
-        F: FnMut(Event<T>, &RootWindowTarget),
-    {
-        let handler = map_user_event(handler, self.receiver.clone());
-
-        self.delegate.set_event_handler(handler, || {
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
+        self.delegate.set_event_handler(app, || {
             autoreleasepool(|_| {
-                // As a special case, if the application hasn't been launched yet then we at least run
-                // the loop until it has fully launched.
+                // As a special case, if the application hasn't been launched yet then we at least
+                // run the loop until it has fully launched.
                 if !self.delegate.is_launched() {
                     debug_assert!(!self.delegate.is_running());
 
@@ -335,31 +306,34 @@ impl<T> EventLoop<T> {
                     // SAFETY: We do not run the application re-entrantly
                     unsafe { self.app.run() };
 
-                    // Note: we dispatch `NewEvents(Init)` + `Resumed` events after the application has launched
+                    // Note: we dispatch `NewEvents(Init)` + `Resumed` events after the application
+                    // has launched
                 } else if !self.delegate.is_running() {
-                    // Even though the application may have been launched, it's possible we aren't running
-                    // if the `EventLoop` was run before and has since exited. This indicates that
-                    // we just starting to re-run the same `EventLoop` again.
+                    // Even though the application may have been launched, it's possible we aren't
+                    // running if the `EventLoop` was run before and has since
+                    // exited. This indicates that we just starting to re-run
+                    // the same `EventLoop` again.
                     self.delegate.set_is_running(true);
                     self.delegate.dispatch_init_events();
                 } else {
-                    // Only run for as long as the given `Duration` allows so we don't block the external loop.
+                    // Only run for as long as the given `Duration` allows so we don't block the
+                    // external loop.
                     match timeout {
                         Some(Duration::ZERO) => {
                             self.delegate.set_wait_timeout(None);
                             self.delegate.set_stop_before_wait(true);
-                        }
+                        },
                         Some(duration) => {
                             self.delegate.set_stop_before_wait(false);
                             let timeout = Instant::now() + duration;
                             self.delegate.set_wait_timeout(Some(timeout));
                             self.delegate.set_stop_after_wait(true);
-                        }
+                        },
                         None => {
                             self.delegate.set_wait_timeout(None);
                             self.delegate.set_stop_before_wait(false);
                             self.delegate.set_stop_after_wait(true);
-                        }
+                        },
                     }
                     self.delegate.set_stop_on_redraw(true);
                     // SAFETY: We do not run the application re-entrantly
@@ -385,8 +359,8 @@ impl<T> EventLoop<T> {
         })
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.sender.clone())
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        EventLoopProxy::new(self.proxy_wake_up.clone())
     }
 }
 
@@ -440,19 +414,19 @@ pub fn stop_app_on_panic<F: FnOnce() -> R + UnwindSafe, R>(
             let app = NSApplication::sharedApplication(mtm);
             stop_app_immediately(&app);
             None
-        }
+        },
     }
 }
 
-pub struct EventLoopProxy<T> {
-    sender: mpsc::Sender<T>,
+pub struct EventLoopProxy {
+    proxy_wake_up: Arc<AtomicBool>,
     source: CFRunLoopSourceRef,
 }
 
-unsafe impl<T: Send> Send for EventLoopProxy<T> {}
-unsafe impl<T: Send> Sync for EventLoopProxy<T> {}
+unsafe impl Send for EventLoopProxy {}
+unsafe impl Sync for EventLoopProxy {}
 
-impl<T> Drop for EventLoopProxy<T> {
+impl Drop for EventLoopProxy {
     fn drop(&mut self) {
         unsafe {
             CFRelease(self.source as _);
@@ -460,14 +434,14 @@ impl<T> Drop for EventLoopProxy<T> {
     }
 }
 
-impl<T> Clone for EventLoopProxy<T> {
+impl Clone for EventLoopProxy {
     fn clone(&self) -> Self {
-        EventLoopProxy::new(self.sender.clone())
+        EventLoopProxy::new(self.proxy_wake_up.clone())
     }
 }
 
-impl<T> EventLoopProxy<T> {
-    fn new(sender: mpsc::Sender<T>) -> Self {
+impl EventLoopProxy {
+    fn new(proxy_wake_up: Arc<AtomicBool>) -> Self {
         unsafe {
             // just wake up the eventloop
             extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
@@ -487,25 +461,21 @@ impl<T> EventLoopProxy<T> {
                 cancel: None,
                 perform: event_loop_proxy_handler,
             };
-            let source =
-                CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
-            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+            let source = CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::MAX - 1, &mut context);
+            CFRunLoopAddSource(rl, source, kCFRunLoopDefaultMode);
             CFRunLoopWakeUp(rl);
 
-            EventLoopProxy { sender, source }
+            EventLoopProxy { proxy_wake_up, source }
         }
     }
 
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.sender
-            .send(event)
-            .map_err(|mpsc::SendError(x)| EventLoopClosed(x))?;
+    pub fn wake_up(&self) {
+        self.proxy_wake_up.store(true, AtomicOrdering::Relaxed);
         unsafe {
             // let the main thread know there's a new event
             CFRunLoopSourceSignal(self.source);
             let rl = CFRunLoopGetMain();
             CFRunLoopWakeUp(rl);
         }
-        Ok(())
     }
 }

src/platform_impl/apple/appkit/ffi.rs

@@ -4,14 +4,14 @@
 
 use std::ffi::c_void;
 
-use core_foundation::{
-    array::CFArrayRef, dictionary::CFDictionaryRef, string::CFStringRef, uuid::CFUUIDRef,
-};
-use core_graphics::{
-    base::CGError,
-    display::{CGDirectDisplayID, CGDisplayConfigRef},
-};
-use objc2::{ffi::NSInteger, runtime::AnyObject};
+use core_foundation::array::CFArrayRef;
+use core_foundation::dictionary::CFDictionaryRef;
+use core_foundation::string::CFStringRef;
+use core_foundation::uuid::CFUUIDRef;
+use core_graphics::base::CGError;
+use core_graphics::display::{CGDirectDisplayID, CGDisplayConfigRef};
+use objc2::ffi::NSInteger;
+use objc2::runtime::AnyObject;
 
 pub type CGDisplayFadeInterval = f32;
 pub type CGDisplayReservationInterval = f32;

src/platform_impl/apple/appkit/menu.rs

@@ -1,11 +1,8 @@
-use icrate::AppKit::{
-    NSApplication, NSEventModifierFlagCommand, NSEventModifierFlagOption, NSEventModifierFlags,
-    NSMenu, NSMenuItem,
-};
-use icrate::Foundation::{ns_string, MainThreadMarker, NSProcessInfo, NSString};
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::runtime::Sel;
 use objc2::sel;
+use objc2_app_kit::{NSApplication, NSEventModifierFlags, NSMenu, NSMenuItem};
+use objc2_foundation::{ns_string, MainThreadMarker, NSProcessInfo, NSString};
 
 struct KeyEquivalent<'a> {
     key: &'a NSString,
@@ -23,12 +20,8 @@ pub fn initialize(app: &NSApplication) {
 
     // About menu item
     let about_item_title = ns_string!("About ").stringByAppendingString(&process_name);
-    let about_item = menu_item(
-        mtm,
-        &about_item_title,
-        Some(sel!(orderFrontStandardAboutPanel:)),
-        None,
-    );
+    let about_item =
+        menu_item(mtm, &about_item_title, Some(sel!(orderFrontStandardAboutPanel:)), None);
 
     // Services menu item
     let services_menu = NSMenu::new(mtm);
@@ -44,10 +37,7 @@ pub fn initialize(app: &NSApplication) {
         mtm,
         &hide_item_title,
         Some(sel!(hide:)),
-        Some(KeyEquivalent {
-            key: ns_string!("h"),
-            masks: None,
-        }),
+        Some(KeyEquivalent { key: ns_string!("h"), masks: None }),
     );
 
     // Hide other applications menu item
@@ -58,18 +48,17 @@ pub fn initialize(app: &NSApplication) {
         Some(sel!(hideOtherApplications:)),
         Some(KeyEquivalent {
             key: ns_string!("h"),
-            masks: Some(NSEventModifierFlagOption | NSEventModifierFlagCommand),
+            masks: Some(
+                NSEventModifierFlags::NSEventModifierFlagOption
+                    | NSEventModifierFlags::NSEventModifierFlagCommand,
+            ),
         }),
     );
 
     // Show applications menu item
     let show_all_item_title = ns_string!("Show All");
-    let show_all_item = menu_item(
-        mtm,
-        show_all_item_title,
-        Some(sel!(unhideAllApplications:)),
-        None,
-    );
+    let show_all_item =
+        menu_item(mtm, show_all_item_title, Some(sel!(unhideAllApplications:)), None);
 
     // Separator menu item
     let sep = NSMenuItem::separatorItem(mtm);
@@ -80,10 +69,7 @@ pub fn initialize(app: &NSApplication) {
         mtm,
         &quit_item_title,
         Some(sel!(terminate:)),
-        Some(KeyEquivalent {
-            key: ns_string!("q"),
-            masks: None,
-        }),
+        Some(KeyEquivalent { key: ns_string!("q"), masks: None }),
     );
 
     app_menu.addItem(&about_item);
@@ -105,7 +91,7 @@ fn menu_item(
     title: &NSString,
     selector: Option<Sel>,
     key_equivalent: Option<KeyEquivalent<'_>>,
-) -> Id<NSMenuItem> {
+) -> Retained<NSMenuItem> {
     let (key, masks) = match key_equivalent {
         Some(ke) => (ke.key, ke.masks),
         None => (ns_string!(""), None),

src/platform_impl/apple/appkit/mod.rs

@@ -2,7 +2,7 @@
 mod util;
 
 mod app;
-mod app_delegate;
+mod app_state;
 mod cursor;
 mod event;
 mod event_handler;
@@ -17,16 +17,14 @@ mod window_delegate;
 
 use std::fmt;
 
-pub(crate) use self::{
-    event::{physicalkey_to_scancode, scancode_to_physicalkey, KeyEventExtra},
-    event_loop::{
-        ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
-        PlatformSpecificEventLoopAttributes,
-    },
-    monitor::{MonitorHandle, VideoModeHandle},
-    window::WindowId,
-    window_delegate::PlatformSpecificWindowAttributes,
+pub(crate) use self::event::{physicalkey_to_scancode, scancode_to_physicalkey, KeyEventExtra};
+pub(crate) use self::event_loop::{
+    ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
+    PlatformSpecificEventLoopAttributes,
 };
+pub(crate) use self::monitor::{MonitorHandle, VideoModeHandle};
+pub(crate) use self::window::WindowId;
+pub(crate) use self::window_delegate::PlatformSpecificWindowAttributes;
 use crate::event::DeviceId as RootDeviceId;
 
 pub(crate) use self::cursor::CustomCursor as PlatformCustomCursor;

src/platform_impl/apple/appkit/monitor.rs

@@ -1,18 +1,18 @@
 #![allow(clippy::unnecessary_cast)]
 
-use std::{collections::VecDeque, fmt};
+use std::collections::VecDeque;
+use std::fmt;
 
-use core_foundation::{
-    array::{CFArrayGetCount, CFArrayGetValueAtIndex},
-    base::{CFRelease, TCFType},
-    string::CFString,
-};
+use core_foundation::array::{CFArrayGetCount, CFArrayGetValueAtIndex};
+use core_foundation::base::{CFRelease, TCFType};
+use core_foundation::string::CFString;
 use core_graphics::display::{
     CGDirectDisplayID, CGDisplay, CGDisplayBounds, CGDisplayCopyDisplayMode,
 };
-use icrate::AppKit::NSScreen;
-use icrate::Foundation::{ns_string, MainThreadMarker, NSNumber, NSPoint, NSRect};
-use objc2::{rc::Id, runtime::AnyObject};
+use objc2::rc::Retained;
+use objc2::runtime::AnyObject;
+use objc2_app_kit::NSScreen;
+use objc2_foundation::{ns_string, run_on_main, MainThreadMarker, NSNumber, NSPoint, NSRect};
 
 use super::ffi;
 use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
@@ -203,7 +203,7 @@ impl MonitorHandle {
     }
 
     pub fn scale_factor(&self) -> f64 {
-        MainThreadMarker::run_on_main(|mtm| {
+        run_on_main(|mtm| {
             match self.ns_screen(mtm) {
                 Some(screen) => screen.backingScaleFactor() as f64,
                 None => 1.0, // default to 1.0 when we can't find the screen
@@ -233,9 +233,7 @@ impl MonitorHandle {
                 return None;
             }
 
-            (time.time_scale as i64)
-                .checked_div(time.time_value)
-                .map(|v| (v * 1000) as u32)
+            (time.time_scale as i64).checked_div(time.time_value).map(|v| (v * 1000) as u32)
         }
     }
 
@@ -297,7 +295,7 @@ impl MonitorHandle {
         }
     }
 
-    pub(crate) fn ns_screen(&self, mtm: MainThreadMarker) -> Option<Id<NSScreen>> {
+    pub(crate) fn ns_screen(&self, mtm: MainThreadMarker) -> Option<Retained<NSScreen>> {
         let uuid = unsafe { ffi::CGDisplayCreateUUIDFromDisplayID(self.0) };
         NSScreen::screens(mtm).into_iter().find(|screen| {
             let other_native_id = get_display_id(screen);

src/platform_impl/apple/appkit/observer.rs

@@ -1,27 +1,30 @@
-use std::{
-    ffi::c_void,
-    panic::{AssertUnwindSafe, UnwindSafe},
-    ptr,
-    rc::Weak,
-    time::Instant,
-};
+//! 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::panic::{AssertUnwindSafe, UnwindSafe};
+use std::ptr;
+use std::rc::Weak;
+use std::time::Instant;
 
-use core_foundation::base::{CFIndex, CFOptionFlags, CFRelease};
+use block2::Block;
+use core_foundation::base::{CFIndex, CFOptionFlags, CFRelease, CFTypeRef};
 use core_foundation::date::CFAbsoluteTimeGetCurrent;
 use core_foundation::runloop::{
-    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes, kCFRunLoopExit,
+    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopDefaultMode, kCFRunLoopExit,
     CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddTimer, CFRunLoopGetMain,
     CFRunLoopObserverCallBack, CFRunLoopObserverContext, CFRunLoopObserverCreate,
     CFRunLoopObserverRef, CFRunLoopRef, CFRunLoopTimerCreate, CFRunLoopTimerInvalidate,
     CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate, CFRunLoopWakeUp,
 };
-use icrate::Foundation::MainThreadMarker;
+use objc2_foundation::MainThreadMarker;
+use tracing::error;
 
+use super::app_state::ApplicationDelegate;
+use super::event_loop::{stop_app_on_panic, PanicInfo};
 use super::ffi;
-use super::{
-    app_delegate::ApplicationDelegate,
-    event_loop::{stop_app_on_panic, PanicInfo},
-};
 
 unsafe fn control_flow_handler<F>(panic_info: *mut c_void, f: F)
 where
@@ -55,10 +58,10 @@ extern "C" fn control_flow_begin_handler(
             #[allow(non_upper_case_globals)]
             match activity {
                 kCFRunLoopAfterWaiting => {
-                    //trace!("Triggered `CFRunLoopAfterWaiting`");
+                    // trace!("Triggered `CFRunLoopAfterWaiting`");
                     ApplicationDelegate::get(MainThreadMarker::new().unwrap()).wakeup(panic_info);
-                    //trace!("Completed `CFRunLoopAfterWaiting`");
-                }
+                    // trace!("Completed `CFRunLoopAfterWaiting`");
+                },
                 _ => unreachable!(),
             }
         });
@@ -77,21 +80,31 @@ extern "C" fn control_flow_end_handler(
             #[allow(non_upper_case_globals)]
             match activity {
                 kCFRunLoopBeforeWaiting => {
-                    //trace!("Triggered `CFRunLoopBeforeWaiting`");
+                    // trace!("Triggered `CFRunLoopBeforeWaiting`");
                     ApplicationDelegate::get(MainThreadMarker::new().unwrap()).cleared(panic_info);
-                    //trace!("Completed `CFRunLoopBeforeWaiting`");
-                }
-                kCFRunLoopExit => (), //unimplemented!(), // not expected to ever happen
+                    // trace!("Completed `CFRunLoopBeforeWaiting`");
+                },
+                kCFRunLoopExit => (), // unimplemented!(), // not expected to ever happen
                 _ => unreachable!(),
             }
         });
     }
 }
 
+#[derive(Debug)]
 pub struct RunLoop(CFRunLoopRef);
 
+impl Default for RunLoop {
+    fn default() -> Self {
+        Self(ptr::null_mut())
+    }
+}
+
 impl RunLoop {
-    pub unsafe fn get() -> Self {
+    pub fn main(mtm: MainThreadMarker) -> Self {
+        // SAFETY: We have a MainThreadMarker here, which means we know we're on the main thread, so
+        // scheduling (and scheduling a non-`Send` block) to that thread is allowed.
+        let _ = mtm;
         RunLoop(unsafe { CFRunLoopGetMain() })
     }
 
@@ -116,11 +129,81 @@ impl RunLoop {
                 context,
             )
         };
-        unsafe { CFRunLoopAddObserver(self.0, observer, kCFRunLoopCommonModes) };
+        unsafe { CFRunLoopAddObserver(self.0, observer, kCFRunLoopDefaultMode) };
+    }
+
+    /// 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) {
+        extern "C" {
+            fn CFRunLoopPerformBlock(rl: CFRunLoopRef, mode: CFTypeRef, block: &Block<dyn Fn()>);
+        }
+
+        // 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 as CFTypeRef };
+
+        // SAFETY: The runloop is valid, the mode is a `CFStringRef`, and the block is `'static`.
+        unsafe { CFRunLoopPerformBlock(self.0, mode, &block) }
     }
 }
 
-pub fn setup_control_flow_observers(panic_info: Weak<PanicInfo>) {
+pub fn setup_control_flow_observers(mtm: MainThreadMarker, panic_info: Weak<PanicInfo>) {
+    let run_loop = RunLoop::main(mtm);
     unsafe {
         let mut context = CFRunLoopObserverContext {
             info: Weak::into_raw(panic_info) as *mut _,
@@ -129,16 +212,15 @@ pub fn setup_control_flow_observers(panic_info: Weak<PanicInfo>) {
             release: None,
             copyDescription: None,
         };
-        let run_loop = RunLoop::get();
         run_loop.add_observer(
             kCFRunLoopAfterWaiting,
-            CFIndex::min_value(),
+            CFIndex::MIN,
             control_flow_begin_handler,
             &mut context as *mut _,
         );
         run_loop.add_observer(
             kCFRunLoopExit | kCFRunLoopBeforeWaiting,
-            CFIndex::max_value(),
+            CFIndex::MAX,
             control_flow_end_handler,
             &mut context as *mut _,
         );
@@ -169,8 +251,8 @@ impl Drop for EventLoopWaker {
     }
 }
 
-impl Default for EventLoopWaker {
-    fn default() -> EventLoopWaker {
+impl EventLoopWaker {
+    pub(crate) fn new() -> Self {
         extern "C" fn wakeup_main_loop(_timer: CFRunLoopTimerRef, _info: *mut c_void) {}
         unsafe {
             // Create a timer with a 0.1µs interval (1ns does not work) to mimic polling.
@@ -178,35 +260,29 @@ impl Default for EventLoopWaker {
             // future, but that gets changed to fire immediately in did_finish_launching
             let timer = CFRunLoopTimerCreate(
                 ptr::null_mut(),
-                std::f64::MAX,
+                f64::MAX,
                 0.000_000_1,
                 0,
                 0,
                 wakeup_main_loop,
                 ptr::null_mut(),
             );
-            CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopCommonModes);
-            EventLoopWaker {
-                timer,
-                start_instant: Instant::now(),
-                next_fire_date: None,
-            }
+            CFRunLoopAddTimer(CFRunLoopGetMain(), timer, kCFRunLoopDefaultMode);
+            Self { timer, start_instant: Instant::now(), next_fire_date: None }
         }
     }
-}
 
-impl EventLoopWaker {
     pub fn stop(&mut self) {
         if self.next_fire_date.is_some() {
             self.next_fire_date = None;
-            unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MAX) }
+            unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MAX) }
         }
     }
 
     pub fn start(&mut self) {
         if self.next_fire_date != Some(self.start_instant) {
             self.next_fire_date = Some(self.start_instant);
-            unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MIN) }
+            unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MIN) }
         }
     }
 
@@ -215,7 +291,7 @@ impl EventLoopWaker {
         match instant {
             Some(instant) if now >= instant => {
                 self.start();
-            }
+            },
             Some(instant) => {
                 if self.next_fire_date != Some(instant) {
                     self.next_fire_date = Some(instant);
@@ -227,10 +303,10 @@ impl EventLoopWaker {
                         CFRunLoopTimerSetNextFireDate(self.timer, current + fsecs)
                     }
                 }
-            }
+            },
             None => {
                 self.stop();
-            }
+            },
         }
     }
 }

src/platform_impl/apple/appkit/util.rs

@@ -0,0 +1,28 @@
+use tracing::trace;
+
+macro_rules! trace_scope {
+    ($s:literal) => {
+        let _crate =
+            $crate::platform_impl::platform::appkit::util::TraceGuard::new(module_path!(), $s);
+    };
+}
+
+pub(crate) struct TraceGuard {
+    module_path: &'static str,
+    called_from_fn: &'static str,
+}
+
+impl TraceGuard {
+    #[inline]
+    pub(crate) fn new(module_path: &'static str, called_from_fn: &'static str) -> Self {
+        trace!(target = module_path, "Triggered `{}`", called_from_fn);
+        Self { module_path, called_from_fn }
+    }
+}
+
+impl Drop for TraceGuard {
+    #[inline]
+    fn drop(&mut self) {
+        trace!(target = self.module_path, "Completed `{}`", self.called_from_fn);
+    }
+}

src/platform_impl/apple/appkit/view.rs

@@ -3,52 +3,45 @@ use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, VecDeque};
 use std::ptr;
 
-use icrate::AppKit::{
-    NSApplication, NSCursor, NSEvent, NSEventPhaseBegan, NSEventPhaseCancelled,
-    NSEventPhaseChanged, NSEventPhaseEnded, NSEventPhaseMayBegin, NSResponder, NSTextInputClient,
-    NSTrackingRectTag, NSView,
-};
-use icrate::Foundation::{
-    MainThreadMarker, NSArray, NSAttributedString, NSAttributedStringKey, NSCopying,
-    NSMutableAttributedString, NSObject, NSObjectProtocol, NSPoint, NSRange, NSRect, NSSize,
-    NSString, NSUInteger,
-};
-use objc2::rc::{Id, WeakId};
+use objc2::rc::{Retained, WeakId};
 use objc2::runtime::{AnyObject, Sel};
-use objc2::{
-    class, declare_class, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass,
+use objc2::{declare_class, msg_send_id, mutability, sel, ClassType, DeclaredClass};
+use objc2_app_kit::{
+    NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient,
+    NSTrackingRectTag, NSView, NSViewFrameDidChangeNotification,
+};
+use objc2_foundation::{
+    MainThreadMarker, NSArray, NSAttributedString, NSAttributedStringKey, NSCopying,
+    NSMutableAttributedString, NSNotFound, NSNotificationCenter, NSObject, NSObjectProtocol,
+    NSPoint, NSRange, NSRect, NSSize, NSString, NSUInteger,
 };
 
-use super::app_delegate::ApplicationDelegate;
+use super::app_state::ApplicationDelegate;
 use super::cursor::{default_cursor, invisible_cursor};
 use super::event::{
     code_to_key, code_to_location, create_key_event, event_mods, lalt_pressed, ralt_pressed,
     scancode_to_physicalkey,
 };
 use super::window::WinitWindow;
-use super::{util, DEVICE_ID};
-use crate::{
-    dpi::{LogicalPosition, LogicalSize},
-    event::{
-        DeviceEvent, ElementState, Ime, Modifiers, MouseButton, MouseScrollDelta, TouchPhase,
-        WindowEvent,
-    },
-    keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey},
-    platform::macos::OptionAsAlt,
+use super::DEVICE_ID;
+use crate::dpi::{LogicalPosition, LogicalSize};
+use crate::event::{
+    DeviceEvent, ElementState, Ime, Modifiers, MouseButton, MouseScrollDelta, TouchPhase,
+    WindowEvent,
 };
+use crate::keyboard::{Key, KeyCode, KeyLocation, ModifiersState, NamedKey};
+use crate::platform::macos::OptionAsAlt;
+use crate::window::WindowId as RootWindowId;
 
 #[derive(Debug)]
 struct CursorState {
     visible: bool,
-    cursor: Id<NSCursor>,
+    cursor: Retained<NSCursor>,
 }
 
 impl Default for CursorState {
     fn default() -> Self {
-        Self {
-            visible: true,
-            cursor: default_cursor(),
-        }
+        Self { visible: true, cursor: default_cursor() }
     }
 }
 
@@ -116,8 +109,11 @@ fn get_left_modifier_code(key: &Key) -> KeyCode {
     }
 }
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct ViewState {
+    /// Strong reference to the global application state.
+    app_delegate: Retained<ApplicationDelegate>,
+
     cursor_state: RefCell<CursorState>,
     ime_position: Cell<NSPoint>,
     ime_size: Cell<NSSize>,
@@ -136,7 +132,7 @@ pub struct ViewState {
     /// to the application, even during IME
     forward_key_to_app: Cell<bool>,
 
-    marked_text: RefCell<Id<NSMutableAttributedString>>,
+    marked_text: RefCell<Retained<NSMutableAttributedString>>,
     accepts_first_mouse: bool,
 
     // Weak reference because the window keeps a strong reference to the view
@@ -175,7 +171,9 @@ declare_class!(
             }
 
             let rect = self.frame();
-            let tracking_rect = unsafe { self.addTrackingRect_owner_userData_assumeInside(rect, self, ptr::null_mut(), false) };
+            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));
         }
@@ -188,7 +186,9 @@ declare_class!(
             }
 
             let rect = self.frame();
-            let tracking_rect = unsafe { self.addTrackingRect_owner_userData_assumeInside(rect, self, ptr::null_mut(), false) };
+            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));
 
@@ -201,19 +201,15 @@ declare_class!(
         }
 
         #[method(drawRect:)]
-        fn draw_rect(&self, rect: NSRect) {
+        fn draw_rect(&self, _rect: NSRect) {
             trace_scope!("drawRect:");
 
             // It's a workaround for https://github.com/rust-windowing/winit/issues/2640, don't replace with `self.window_id()`.
             if let Some(window) = self.ivars()._ns_window.load() {
-                let app_delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-                app_delegate.handle_redraw(window.id());
+                self.ivars().app_delegate.handle_redraw(window.id());
             }
 
-            #[allow(clippy::let_unit_value)]
-            unsafe {
-                let _: () = msg_send![super(self), drawRect: rect];
-            }
+            // This is a direct subclass of NSView, no need to call superclass' drawRect:
         }
 
         #[method(acceptsFirstResponder)]
@@ -226,7 +222,7 @@ declare_class!(
         // IMKInputSession [0x7fc573576ff0 presentFunctionRowItemTextInputViewWithEndpoint:completionHandler:] : [self textInputContext]=0x7fc573558e10 *NO* NSRemoteViewController to client, NSError=Error Domain=NSCocoaErrorDomain Code=4099 "The connection from pid 0 was invalidated from this process." UserInfo={NSDebugDescription=The connection from pid 0 was invalidated from this process.}, com.apple.inputmethod.EmojiFunctionRowItem
         // TODO: Add an API extension for using `NSTouchBar`
         #[method_id(touchBar)]
-        fn touch_bar(&self) -> Option<Id<NSObject>> {
+        fn touch_bar(&self) -> Option<Retained<NSObject>> {
             trace_scope!("touchBar");
             None
         }
@@ -259,33 +255,36 @@ declare_class!(
             if length > 0 {
                 NSRange::new(0, length)
             } else {
-                util::EMPTY_RANGE
+                // Documented to return `{NSNotFound, 0}` if there is no marked range.
+                NSRange::new(NSNotFound as NSUInteger, 0)
             }
         }
 
         #[method(selectedRange)]
         fn selected_range(&self) -> NSRange {
             trace_scope!("selectedRange");
-            util::EMPTY_RANGE
+            // Documented to return `{NSNotFound, 0}` if there is no selection.
+            NSRange::new(NSNotFound as NSUInteger, 0)
         }
 
         #[method(setMarkedText:selectedRange:replacementRange:)]
         fn set_marked_text(
             &self,
             string: &NSObject,
-            _selected_range: NSRange,
+            selected_range: NSRange,
             _replacement_range: NSRange,
         ) {
+            // TODO: Use _replacement_range, requires changing the event to report surrounding text.
             trace_scope!("setMarkedText:selectedRange:replacementRange:");
 
             // SAFETY: This method is guaranteed to get either a `NSString` or a `NSAttributedString`.
-            let (marked_text, preedit_string) = if string.is_kind_of::<NSAttributedString>() {
+            let (marked_text, string) = if string.is_kind_of::<NSAttributedString>() {
                 let string: *const NSObject = string;
                 let string: *const NSAttributedString = string.cast();
                 let string = unsafe { &*string };
                 (
                     NSMutableAttributedString::from_attributed_nsstring(string),
-                    string.string().to_string(),
+                    string.string(),
                 )
             } else {
                 let string: *const NSObject = string;
@@ -293,7 +292,7 @@ declare_class!(
                 let string = unsafe { &*string };
                 (
                     NSMutableAttributedString::from_nsstring(string),
-                    string.to_string(),
+                    string.copy(),
                 )
             };
 
@@ -313,16 +312,21 @@ declare_class!(
                 self.ivars().ime_state.set(ImeState::Ground);
             }
 
-            // Empty string basically means that there's no preedit, so indicate that by sending
-            // `None` cursor range.
-            let cursor_range = if preedit_string.is_empty() {
+            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 {
-                Some((preedit_string.len(), preedit_string.len()))
+                // Convert the selected range from UTF-16 indices to UTF-8 indices.
+                let sub_string_a = unsafe { string.substringToIndex(selected_range.location) };
+                let sub_string_b = unsafe { string.substringToIndex(selected_range.end()) };
+                let lowerbound_utf8 = sub_string_a.len();
+                let upperbound_utf8 = sub_string_b.len();
+                Some((lowerbound_utf8, upperbound_utf8))
             };
 
             // Send WindowEvent for updating marked text
-            self.queue_event(WindowEvent::Ime(Ime::Preedit(preedit_string, cursor_range)));
+            self.queue_event(WindowEvent::Ime(Ime::Preedit(string.to_string(), cursor_range)));
         }
 
         #[method(unmarkText)]
@@ -343,7 +347,7 @@ declare_class!(
         }
 
         #[method_id(validAttributesForMarkedText)]
-        fn valid_attributes_for_marked_text(&self) -> Id<NSArray<NSAttributedStringKey>> {
+        fn valid_attributes_for_marked_text(&self) -> Retained<NSArray<NSAttributedStringKey>> {
             trace_scope!("validAttributesForMarkedText");
             NSArray::new()
         }
@@ -353,7 +357,7 @@ declare_class!(
             &self,
             _range: NSRange,
             _actual_range: *mut NSRange,
-        ) -> Option<Id<NSAttributedString>> {
+        ) -> Option<Retained<NSAttributedString>> {
             trace_scope!("attributedSubstringForProposedRange:actualRange:");
             None
         }
@@ -371,13 +375,18 @@ declare_class!(
             _actual_range: *mut NSRange,
         ) -> NSRect {
             trace_scope!("firstRectForCharacterRange:actualRange:");
-            let rect = dbg!(NSRect::new(self.ivars().ime_position.get(), self.ivars().ime_size.get()));
+            let rect = NSRect::new(
+                self.ivars().ime_position.get(),
+                self.ivars().ime_size.get()
+            );
             // Return value is expected to be in screen coordinates, so we need a conversion here
-            unsafe { self.window().convertRectToScreen(self.convertRect_toView(rect, None)) }
+            self.window()
+                .convertRectToScreen(self.convertRect_toView(rect, None))
         }
 
         #[method(insertText:replacementRange:)]
         fn insert_text(&self, string: &NSObject, _replacement_range: NSRange) {
+            // TODO: Use _replacement_range, requires changing the event to report surrounding text.
             trace_scope!("insertText:replacementRange:");
 
             // SAFETY: This method is guaranteed to get either a `NSString` or a `NSAttributedString`.
@@ -415,7 +424,8 @@ declare_class!(
 
             self.ivars().forward_key_to_app.set(true);
 
-            if unsafe { 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);
             }
@@ -552,6 +562,17 @@ declare_class!(
             });
         }
 
+        // In the past (?), `mouseMoved:` events were not generated when the
+        // user hovered over a window from a separate window, and as such the
+        // application might not know the location of the mouse in the event.
+        //
+        // To fix this, we emit `mouse_motion` inside of mouse click, mouse
+        // scroll, magnify and other gesture event handlers, to ensure that
+        // the application's state of where the mouse click was located is up
+        // to date.
+        //
+        // See https://github.com/rust-windowing/winit/pull/1490 for history.
+
         #[method(mouseDown:)]
         fn mouse_down(&self, event: &NSEvent) {
             trace_scope!("mouseDown:");
@@ -655,26 +676,20 @@ declare_class!(
             // report the touch phase.
             #[allow(non_upper_case_globals)]
             let phase = match unsafe { event.momentumPhase() } {
-                NSEventPhaseMayBegin | NSEventPhaseBegan => {
-                    TouchPhase::Started
-                }
-                NSEventPhaseEnded | NSEventPhaseCancelled => {
-                    TouchPhase::Ended
-                }
+                NSEventPhase::MayBegin | NSEventPhase::Began => TouchPhase::Started,
+                NSEventPhase::Ended | NSEventPhase::Cancelled => TouchPhase::Ended,
                 _ => match unsafe { event.phase() } {
-                    NSEventPhaseMayBegin | NSEventPhaseBegan => {
-                        TouchPhase::Started
-                    }
-                    NSEventPhaseEnded | NSEventPhaseCancelled => {
-                        TouchPhase::Ended
-                    }
+                    NSEventPhase::MayBegin | NSEventPhase::Began => TouchPhase::Started,
+                    NSEventPhase::Ended | NSEventPhase::Cancelled => TouchPhase::Ended,
                     _ => TouchPhase::Moved,
                 },
             };
 
             self.update_modifiers(event, false);
 
-            self.queue_device_event(DeviceEvent::MouseWheel { delta });
+            self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop|
+                app.device_event(event_loop, DEVICE_ID, DeviceEvent::MouseWheel { delta })
+            );
             self.queue_event(WindowEvent::MouseWheel {
                 device_id: DEVICE_ID,
                 delta,
@@ -686,12 +701,14 @@ declare_class!(
         fn magnify_with_event(&self, event: &NSEvent) {
             trace_scope!("magnifyWithEvent:");
 
+            self.mouse_motion(event);
+
             #[allow(non_upper_case_globals)]
             let phase = match unsafe { event.phase() } {
-                NSEventPhaseBegan => TouchPhase::Started,
-                NSEventPhaseChanged => TouchPhase::Moved,
-                NSEventPhaseCancelled => TouchPhase::Cancelled,
-                NSEventPhaseEnded => TouchPhase::Ended,
+                NSEventPhase::Began => TouchPhase::Started,
+                NSEventPhase::Changed => TouchPhase::Moved,
+                NSEventPhase::Cancelled => TouchPhase::Cancelled,
+                NSEventPhase::Ended => TouchPhase::Ended,
                 _ => return,
             };
 
@@ -703,9 +720,11 @@ declare_class!(
         }
 
         #[method(smartMagnifyWithEvent:)]
-        fn smart_magnify_with_event(&self, _event: &NSEvent) {
+        fn smart_magnify_with_event(&self, event: &NSEvent) {
             trace_scope!("smartMagnifyWithEvent:");
 
+            self.mouse_motion(event);
+
             self.queue_event(WindowEvent::DoubleTapGesture {
                 device_id: DEVICE_ID,
             });
@@ -715,12 +734,14 @@ declare_class!(
         fn rotate_with_event(&self, event: &NSEvent) {
             trace_scope!("rotateWithEvent:");
 
+            self.mouse_motion(event);
+
             #[allow(non_upper_case_globals)]
             let phase = match unsafe { event.phase() } {
-                NSEventPhaseBegan => TouchPhase::Started,
-                NSEventPhaseChanged => TouchPhase::Moved,
-                NSEventPhaseCancelled => TouchPhase::Cancelled,
-                NSEventPhaseEnded => TouchPhase::Ended,
+                NSEventPhase::Began => TouchPhase::Started,
+                NSEventPhase::Changed => TouchPhase::Moved,
+                NSEventPhase::Cancelled => TouchPhase::Cancelled,
+                NSEventPhase::Ended => TouchPhase::Ended,
                 _ => return,
             };
 
@@ -735,8 +756,6 @@ declare_class!(
         fn pressure_change_with_event(&self, event: &NSEvent) {
             trace_scope!("pressureChangeWithEvent:");
 
-            self.mouse_motion(event);
-
             self.queue_event(WindowEvent::TouchpadPressure {
                 device_id: DEVICE_ID,
                 pressure: unsafe { event.pressure() },
@@ -763,34 +782,40 @@ declare_class!(
 
 impl WinitView {
     pub(super) fn new(
+        app_delegate: &ApplicationDelegate,
         window: &WinitWindow,
         accepts_first_mouse: bool,
         option_as_alt: OptionAsAlt,
-    ) -> Id<Self> {
+    ) -> Retained<Self> {
         let mtm = MainThreadMarker::from(window);
         let this = mtm.alloc().set_ivars(ViewState {
+            app_delegate: app_delegate.retain(),
+            cursor_state: Default::default(),
+            ime_position: Default::default(),
+            ime_size: Default::default(),
+            modifiers: Default::default(),
+            phys_modifiers: Default::default(),
+            tracking_rect: Default::default(),
+            ime_state: Default::default(),
+            input_source: Default::default(),
+            ime_allowed: Default::default(),
+            forward_key_to_app: Default::default(),
+            marked_text: Default::default(),
             accepts_first_mouse,
             _ns_window: WeakId::new(&window.retain()),
             option_as_alt: Cell::new(option_as_alt),
-            ..Default::default()
         });
-        let this: Id<Self> = unsafe { msg_send_id![super(this), init] };
+        let this: Retained<Self> = unsafe { msg_send_id![super(this), init] };
 
         this.setPostsFrameChangedNotifications(true);
-        let notification_center: &AnyObject =
-            unsafe { msg_send![class!(NSNotificationCenter), defaultCenter] };
-        // About frame change
-        let frame_did_change_notification_name =
-            NSString::from_str("NSViewFrameDidChangeNotification");
-        #[allow(clippy::let_unit_value)]
+        let notification_center = unsafe { NSNotificationCenter::defaultCenter() };
         unsafe {
-            let _: () = msg_send![
-                notification_center,
-                addObserver: &*this,
-                selector: sel!(frameDidChange:),
-                name: &*frame_did_change_notification_name,
-                object: &*this,
-            ];
+            notification_center.addObserver_selector_name_object(
+                &this,
+                sel!(frameDidChange:),
+                Some(NSViewFrameDidChangeNotification),
+                Some(&this),
+            )
         }
 
         *this.ivars().input_source.borrow_mut() = this.current_input_source();
@@ -798,26 +823,20 @@ impl WinitView {
         this
     }
 
-    fn window(&self) -> Id<WinitWindow> {
+    fn window(&self) -> Retained<WinitWindow> {
         // TODO: Simply use `window` property on `NSView`.
         // That only returns a window _after_ the view has been attached though!
         // (which is incompatible with `frameDidChange:`)
         //
         // unsafe { msg_send_id![self, window] }
-        self.ivars()
-            ._ns_window
-            .load()
-            .expect("view to have a window")
+        self.ivars()._ns_window.load().expect("view to have a window")
     }
 
     fn queue_event(&self, event: WindowEvent) {
-        let app_delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-        app_delegate.queue_window_event(self.window().id(), event);
-    }
-
-    fn queue_device_event(&self, event: DeviceEvent) {
-        let app_delegate = ApplicationDelegate::get(MainThreadMarker::from(self));
-        app_delegate.queue_device_event(event);
+        let window_id = RootWindowId(self.window().id());
+        self.ivars().app_delegate.maybe_queue_with_handler(move |app, event_loop| {
+            app.window_event(event_loop, window_id, event);
+        });
     }
 
     fn scale_factor(&self) -> f64 {
@@ -836,11 +855,11 @@ impl WinitView {
             .unwrap_or_default()
     }
 
-    pub(super) fn cursor_icon(&self) -> Id<NSCursor> {
+    pub(super) fn cursor_icon(&self) -> Retained<NSCursor> {
         self.ivars().cursor_state.borrow().cursor.clone()
     }
 
-    pub(super) fn set_cursor_icon(&self, icon: Id<NSCursor>) {
+    pub(super) fn set_cursor_icon(&self, icon: Retained<NSCursor>) {
         let mut cursor_state = self.ivars().cursor_state.borrow_mut();
         cursor_state.cursor = icon;
     }
@@ -935,9 +954,7 @@ impl WinitView {
                 let location_mask = ModLocationMask::from_location(event.location);
 
                 let mut phys_mod_state = self.ivars().phys_modifiers.borrow_mut();
-                let phys_mod = phys_mod_state
-                    .entry(key)
-                    .or_insert(ModLocationMask::empty());
+                let phys_mod = phys_mod_state.entry(key).or_insert(ModLocationMask::empty());
 
                 let is_active = current_modifiers.state().contains(event_modifier);
                 let mut events = VecDeque::with_capacity(2);
@@ -1075,7 +1092,7 @@ fn mouse_button(event: &NSEvent) -> MouseButton {
 // NOTE: to get option as alt working we need to rewrite events
 // we're getting from the operating system, which makes it
 // impossible to provide such events as extra in `KeyEvent`.
-fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Id<NSEvent> {
+fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEvent> {
     let ev_mods = event_mods(event).state;
     let ignore_alt_characters = match option_as_alt {
         OptionAsAlt::OnlyLeft if lalt_pressed(event) => true,
@@ -1087,9 +1104,7 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Id<NSEvent> {
 
     if ignore_alt_characters {
         let ns_chars = unsafe {
-            event
-                .charactersIgnoringModifiers()
-                .expect("expected characters to be non-null")
+            event.charactersIgnoringModifiers().expect("expected characters to be non-null")
         };
 
         unsafe {

src/platform_impl/apple/appkit/window.rs

@@ -1,9 +1,9 @@
 #![allow(clippy::unnecessary_cast)]
 
-use icrate::AppKit::{NSResponder, NSWindow};
-use icrate::Foundation::{MainThreadBound, MainThreadMarker, NSObject};
-use objc2::rc::{autoreleasepool, Id};
+use objc2::rc::{autoreleasepool, Retained};
 use objc2::{declare_class, mutability, ClassType, DeclaredClass};
+use objc2_app_kit::{NSResponder, NSWindow};
+use objc2_foundation::{MainThreadBound, MainThreadMarker, NSObject};
 
 use super::event_loop::ActiveEventLoop;
 use super::window_delegate::WindowDelegate;
@@ -11,15 +11,14 @@ use crate::error::OsError as RootOsError;
 use crate::window::WindowAttributes;
 
 pub(crate) struct Window {
-    window: MainThreadBound<Id<WinitWindow>>,
+    window: MainThreadBound<Retained<WinitWindow>>,
     /// The window only keeps a weak reference to this, so we must keep it around here.
-    delegate: MainThreadBound<Id<WindowDelegate>>,
+    delegate: MainThreadBound<Retained<WindowDelegate>>,
 }
 
 impl Drop for Window {
     fn drop(&mut self) {
-        self.window
-            .get_on_main(|window| autoreleasepool(|_| window.close()))
+        self.window.get_on_main(|window| autoreleasepool(|_| window.close()))
     }
 }
 
@@ -29,7 +28,9 @@ impl Window {
         attributes: WindowAttributes,
     ) -> Result<Self, RootOsError> {
         let mtm = window_target.mtm;
-        let delegate = autoreleasepool(|_| WindowDelegate::new(attributes, mtm))?;
+        let delegate = autoreleasepool(|_| {
+            WindowDelegate::new(window_target.app_delegate(), attributes, mtm)
+        })?;
         Ok(Window {
             window: MainThreadBound::new(delegate.window().retain(), mtm),
             delegate: MainThreadBound::new(delegate, mtm),
@@ -65,9 +66,7 @@ impl Window {
     pub(crate) fn raw_display_handle_rwh_06(
         &self,
     ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::RawDisplayHandle::AppKit(
-            rwh_06::AppKitDisplayHandle::new(),
-        ))
+        Ok(rwh_06::RawDisplayHandle::AppKit(rwh_06::AppKitDisplayHandle::new()))
     }
 }
 

src/platform_impl/apple/mod.rs

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

src/platform_impl/apple/uikit/app_delegate.rs

@@ -0,0 +1,60 @@
+use objc2::{declare_class, mutability, ClassType, DeclaredClass};
+use objc2_foundation::{MainThreadMarker, NSObject};
+use objc2_ui_kit::UIApplication;
+
+use super::app_state::{self, send_occluded_event_for_all_windows, EventWrapper};
+use crate::event::Event;
+
+declare_class!(
+    pub struct AppDelegate;
+
+    unsafe impl ClassType for AppDelegate {
+        type Super = NSObject;
+        type Mutability = mutability::InteriorMutable;
+        const NAME: &'static str = "WinitApplicationDelegate";
+    }
+
+    impl DeclaredClass for AppDelegate {}
+
+    // UIApplicationDelegate protocol
+    unsafe impl AppDelegate {
+        #[method(application:didFinishLaunchingWithOptions:)]
+        fn did_finish_launching(&self, _application: &UIApplication, _: *mut NSObject) -> bool {
+            app_state::did_finish_launching(MainThreadMarker::new().unwrap());
+            true
+        }
+
+        #[method(applicationDidBecomeActive:)]
+        fn did_become_active(&self, _application: &UIApplication) {
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Resumed))
+        }
+
+        #[method(applicationWillResignActive:)]
+        fn will_resign_active(&self, _application: &UIApplication) {
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Suspended))
+        }
+
+        #[method(applicationWillEnterForeground:)]
+        fn will_enter_foreground(&self, application: &UIApplication) {
+            send_occluded_event_for_all_windows(application, false);
+        }
+
+        #[method(applicationDidEnterBackground:)]
+        fn did_enter_background(&self, application: &UIApplication) {
+            send_occluded_event_for_all_windows(application, true);
+        }
+
+        #[method(applicationWillTerminate:)]
+        fn will_terminate(&self, application: &UIApplication) {
+            app_state::terminated(application);
+        }
+
+        #[method(applicationDidReceiveMemoryWarning:)]
+        fn did_receive_memory_warning(&self, _application: &UIApplication) {
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::MemoryWarning))
+        }
+    }
+);

src/platform_impl/apple/uikit/app_state.rs

@@ -1,36 +1,32 @@
 #![deny(unused_results)]
 
-use std::{
-    cell::{RefCell, RefMut},
-    collections::HashSet,
-    fmt, mem,
-    os::raw::c_void,
-    ptr,
-    sync::{Arc, Mutex, OnceLock},
-    time::Instant,
-};
+use std::cell::{RefCell, RefMut};
+use std::collections::HashSet;
+use std::os::raw::c_void;
+use std::sync::{Arc, Mutex, OnceLock};
+use std::time::Instant;
+use std::{fmt, mem, ptr};
 
 use core_foundation::base::CFRelease;
 use core_foundation::date::CFAbsoluteTimeGetCurrent;
 use core_foundation::runloop::{
-    kCFRunLoopCommonModes, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
+    kCFRunLoopDefaultMode, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
     CFRunLoopTimerInvalidate, CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate,
 };
-use icrate::Foundation::{
-    CGRect, CGSize, MainThreadMarker, NSInteger, NSOperatingSystemVersion, NSProcessInfo,
-};
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::runtime::AnyObject;
 use objc2::{msg_send, sel};
-
-use super::uikit::UIView;
-use super::window::WinitUIWindow;
-use crate::{
-    dpi::PhysicalSize,
-    event::{Event, InnerSizeWriter, StartCause, WindowEvent},
-    event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow},
-    window::WindowId as RootWindowId,
+use objc2_foundation::{
+    CGRect, CGSize, MainThreadMarker, NSInteger, NSObjectProtocol, NSOperatingSystemVersion,
+    NSProcessInfo,
 };
+use objc2_ui_kit::{UIApplication, UICoordinateSpace, UIView, UIWindow};
+
+use super::window::WinitUIWindow;
+use crate::dpi::PhysicalSize;
+use crate::event::{Event, InnerSizeWriter, StartCause, WindowEvent};
+use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow};
+use crate::window::WindowId as RootWindowId;
 
 macro_rules! bug {
     ($($msg:tt)*) => {
@@ -44,12 +40,9 @@ macro_rules! bug_assert {
     };
 }
 
-#[derive(Debug)]
-pub(crate) struct HandlePendingUserEvents;
-
 pub(crate) struct EventLoopHandler {
     #[allow(clippy::type_complexity)]
-    pub(crate) handler: Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
+    pub(crate) handler: Box<dyn FnMut(Event, &RootActiveEventLoop)>,
     pub(crate) event_loop: RootActiveEventLoop,
 }
 
@@ -63,20 +56,20 @@ impl fmt::Debug for EventLoopHandler {
 }
 
 impl EventLoopHandler {
-    fn handle_event(&mut self, event: Event<HandlePendingUserEvents>) {
+    fn handle_event(&mut self, event: Event) {
         (self.handler)(event, &self.event_loop)
     }
 }
 
 #[derive(Debug)]
 pub(crate) enum EventWrapper {
-    StaticEvent(Event<HandlePendingUserEvents>),
+    StaticEvent(Event),
     ScaleFactorChanged(ScaleFactorChanged),
 }
 
 #[derive(Debug)]
 pub struct ScaleFactorChanged {
-    pub(super) window: Id<WinitUIWindow>,
+    pub(super) window: Retained<WinitUIWindow>,
     pub(super) suggested_size: PhysicalSize<u32>,
     pub(super) scale_factor: f64,
 }
@@ -92,15 +85,9 @@ enum UserCallbackTransitionResult<'a> {
     },
 }
 
-impl Event<HandlePendingUserEvents> {
+impl Event {
     fn is_redraw(&self) -> bool {
-        matches!(
-            self,
-            Event::WindowEvent {
-                event: WindowEvent::RedrawRequested,
-                ..
-            }
-        )
+        matches!(self, Event::WindowEvent { event: WindowEvent::RedrawRequested, .. })
     }
 }
 
@@ -109,25 +96,25 @@ impl Event<HandlePendingUserEvents> {
 #[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"]
 enum AppStateImpl {
     NotLaunched {
-        queued_windows: Vec<Id<WinitUIWindow>>,
+        queued_windows: Vec<Retained<WinitUIWindow>>,
         queued_events: Vec<EventWrapper>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
     },
     Launching {
-        queued_windows: Vec<Id<WinitUIWindow>>,
+        queued_windows: Vec<Retained<WinitUIWindow>>,
         queued_events: Vec<EventWrapper>,
         queued_handler: EventLoopHandler,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
     },
     ProcessingEvents {
         handler: EventLoopHandler,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
         active_control_flow: ControlFlow,
     },
     // special state to deal with reentrancy and prevent mutable aliasing.
     InUserCallback {
         queued_events: Vec<EventWrapper>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow>>,
+        queued_gpu_redraws: HashSet<Retained<WinitUIWindow>>,
     },
     ProcessingRedraws {
         handler: EventLoopHandler,
@@ -216,10 +203,7 @@ impl AppState {
     }
 
     fn has_launched(&self) -> bool {
-        !matches!(
-            self.state(),
-            AppStateImpl::NotLaunched { .. } | AppStateImpl::Launching { .. }
-        )
+        !matches!(self.state(), AppStateImpl::NotLaunched { .. } | AppStateImpl::Launching { .. })
     }
 
     fn has_terminated(&self) -> bool {
@@ -228,11 +212,9 @@ impl AppState {
 
     fn will_launch_transition(&mut self, queued_handler: EventLoopHandler) {
         let (queued_windows, queued_events, queued_gpu_redraws) = match self.take_state() {
-            AppStateImpl::NotLaunched {
-                queued_windows,
-                queued_events,
-                queued_gpu_redraws,
-            } => (queued_windows, queued_events, queued_gpu_redraws),
+            AppStateImpl::NotLaunched { queued_windows, queued_events, queued_gpu_redraws } => {
+                (queued_windows, queued_events, queued_gpu_redraws)
+            },
             s => bug!("unexpected state {:?}", s),
         };
         self.set_state(AppStateImpl::Launching {
@@ -243,19 +225,16 @@ impl AppState {
         });
     }
 
-    fn did_finish_launching_transition(&mut self) -> (Vec<Id<WinitUIWindow>>, Vec<EventWrapper>) {
+    fn did_finish_launching_transition(
+        &mut self,
+    ) -> (Vec<Retained<WinitUIWindow>>, Vec<EventWrapper>) {
         let (windows, events, handler, queued_gpu_redraws) = match self.take_state() {
             AppStateImpl::Launching {
                 queued_windows,
                 queued_events,
                 queued_handler,
                 queued_gpu_redraws,
-            } => (
-                queued_windows,
-                queued_events,
-                queued_handler,
-                queued_gpu_redraws,
-            ),
+            } => (queued_windows, queued_events, queued_handler, queued_gpu_redraws),
             s => bug!("unexpected state {:?}", s),
         };
         self.set_state(AppStateImpl::ProcessingEvents {
@@ -274,17 +253,10 @@ impl AppState {
         }
 
         let (handler, event) = match (self.control_flow, self.take_state()) {
-            (ControlFlow::Poll, AppStateImpl::PollFinished { waiting_handler }) => (
-                waiting_handler,
-                EventWrapper::StaticEvent(Event::NewEvents(StartCause::Poll)),
-            ),
-            (
-                ControlFlow::Wait,
-                AppStateImpl::Waiting {
-                    waiting_handler,
-                    start,
-                },
-            ) => (
+            (ControlFlow::Poll, AppStateImpl::PollFinished { waiting_handler }) => {
+                (waiting_handler, EventWrapper::StaticEvent(Event::NewEvents(StartCause::Poll)))
+            },
+            (ControlFlow::Wait, AppStateImpl::Waiting { waiting_handler, start }) => (
                 waiting_handler,
                 EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled {
                     start,
@@ -293,10 +265,7 @@ impl AppState {
             ),
             (
                 ControlFlow::WaitUntil(requested_resume),
-                AppStateImpl::Waiting {
-                    waiting_handler,
-                    start,
-                },
+                AppStateImpl::Waiting { waiting_handler, start },
             ) => {
                 let event = if Instant::now() >= requested_resume {
                     EventWrapper::StaticEvent(Event::NewEvents(StartCause::ResumeTimeReached {
@@ -310,7 +279,7 @@ impl AppState {
                     }))
                 };
                 (waiting_handler, event)
-            }
+            },
             s => bug!("`EventHandler` unexpectedly woke up {:?}", s),
         };
 
@@ -326,18 +295,9 @@ impl AppState {
         // If we're not able to process an event due to recursion or `Init` not having been sent out
         // yet, then queue the events up.
         match self.state_mut() {
-            &mut AppStateImpl::Launching {
-                ref mut queued_events,
-                ..
-            }
-            | &mut AppStateImpl::NotLaunched {
-                ref mut queued_events,
-                ..
-            }
-            | &mut AppStateImpl::InUserCallback {
-                ref mut queued_events,
-                ..
-            } => {
+            &mut AppStateImpl::Launching { ref mut queued_events, .. }
+            | &mut AppStateImpl::NotLaunched { ref mut queued_events, .. }
+            | &mut AppStateImpl::InUserCallback { ref mut queued_events, .. } => {
                 // A lifetime cast: early returns are not currently handled well with NLL, but
                 // polonius handles them well. This transmute is a safe workaround.
                 return unsafe {
@@ -348,60 +308,49 @@ impl AppState {
                         queued_events,
                     })
                 };
-            }
+            },
 
             &mut AppStateImpl::ProcessingEvents { .. }
-            | &mut AppStateImpl::ProcessingRedraws { .. } => {}
+            | &mut AppStateImpl::ProcessingRedraws { .. } => {},
 
             s @ &mut AppStateImpl::PollFinished { .. }
             | s @ &mut AppStateImpl::Waiting { .. }
             | s @ &mut AppStateImpl::Terminated => {
                 bug!("unexpected attempted to process an event {:?}", s)
-            }
+            },
         }
 
-        let (handler, queued_gpu_redraws, active_control_flow, processing_redraws) =
-            match self.take_state() {
-                AppStateImpl::Launching { .. }
-                | AppStateImpl::NotLaunched { .. }
-                | AppStateImpl::InUserCallback { .. } => unreachable!(),
-                AppStateImpl::ProcessingEvents {
-                    handler,
-                    queued_gpu_redraws,
-                    active_control_flow,
-                } => (handler, queued_gpu_redraws, active_control_flow, false),
-                AppStateImpl::ProcessingRedraws {
-                    handler,
-                    active_control_flow,
-                } => (handler, Default::default(), active_control_flow, true),
-                AppStateImpl::PollFinished { .. }
-                | AppStateImpl::Waiting { .. }
-                | AppStateImpl::Terminated => unreachable!(),
-            };
+        let (handler, queued_gpu_redraws, active_control_flow, processing_redraws) = match self
+            .take_state()
+        {
+            AppStateImpl::Launching { .. }
+            | AppStateImpl::NotLaunched { .. }
+            | AppStateImpl::InUserCallback { .. } => unreachable!(),
+            AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow } => {
+                (handler, queued_gpu_redraws, active_control_flow, false)
+            },
+            AppStateImpl::ProcessingRedraws { handler, active_control_flow } => {
+                (handler, Default::default(), active_control_flow, true)
+            },
+            AppStateImpl::PollFinished { .. }
+            | AppStateImpl::Waiting { .. }
+            | AppStateImpl::Terminated => unreachable!(),
+        };
         self.set_state(AppStateImpl::InUserCallback {
             queued_events: Vec::new(),
             queued_gpu_redraws,
         });
-        UserCallbackTransitionResult::Success {
-            handler,
-            active_control_flow,
-            processing_redraws,
-        }
+        UserCallbackTransitionResult::Success { handler, active_control_flow, processing_redraws }
     }
 
-    fn main_events_cleared_transition(&mut self) -> HashSet<Id<WinitUIWindow>> {
+    fn main_events_cleared_transition(&mut self) -> HashSet<Retained<WinitUIWindow>> {
         let (handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
-            AppStateImpl::ProcessingEvents {
-                handler,
-                queued_gpu_redraws,
-                active_control_flow,
-            } => (handler, queued_gpu_redraws, active_control_flow),
+            AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow } => {
+                (handler, queued_gpu_redraws, active_control_flow)
+            },
             s => bug!("unexpected state {:?}", s),
         };
-        self.set_state(AppStateImpl::ProcessingRedraws {
-            handler,
-            active_control_flow,
-        });
+        self.set_state(AppStateImpl::ProcessingRedraws { handler, active_control_flow });
         queued_gpu_redraws
     }
 
@@ -410,10 +359,9 @@ impl AppState {
             return;
         }
         let (waiting_handler, old) = match self.take_state() {
-            AppStateImpl::ProcessingRedraws {
-                handler,
-                active_control_flow,
-            } => (handler, active_control_flow),
+            AppStateImpl::ProcessingRedraws { handler, active_control_flow } => {
+                (handler, active_control_flow)
+            },
             s => bug!("unexpected state {:?}", s),
         };
 
@@ -421,41 +369,29 @@ impl AppState {
         match (old, new) {
             (ControlFlow::Wait, ControlFlow::Wait) => {
                 let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting {
-                    waiting_handler,
-                    start,
-                });
-            }
+                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+            },
             (ControlFlow::WaitUntil(old_instant), ControlFlow::WaitUntil(new_instant))
                 if old_instant == new_instant =>
             {
                 let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting {
-                    waiting_handler,
-                    start,
-                });
-            }
+                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
+            },
             (_, ControlFlow::Wait) => {
                 let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting {
-                    waiting_handler,
-                    start,
-                });
+                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
                 self.waker.stop()
-            }
+            },
             (_, ControlFlow::WaitUntil(new_instant)) => {
                 let start = Instant::now();
-                self.set_state(AppStateImpl::Waiting {
-                    waiting_handler,
-                    start,
-                });
+                self.set_state(AppStateImpl::Waiting { waiting_handler, start });
                 self.waker.start_at(new_instant)
-            }
+            },
             // Unlike on macOS, handle Poll to Poll transition here to call the waker
             (_, ControlFlow::Poll) => {
                 self.set_state(AppStateImpl::PollFinished { waiting_handler });
                 self.waker.start()
-            }
+            },
         }
     }
 
@@ -475,54 +411,41 @@ impl AppState {
     }
 }
 
-pub(crate) fn set_key_window(mtm: MainThreadMarker, window: &Id<WinitUIWindow>) {
+pub(crate) fn set_key_window(mtm: MainThreadMarker, window: &Retained<WinitUIWindow>) {
     let mut this = AppState::get_mut(mtm);
     match this.state_mut() {
-        &mut AppStateImpl::NotLaunched {
-            ref mut queued_windows,
-            ..
-        } => return queued_windows.push(window.clone()),
+        &mut AppStateImpl::NotLaunched { ref mut queued_windows, .. } => {
+            return queued_windows.push(window.clone())
+        },
         &mut AppStateImpl::ProcessingEvents { .. }
         | &mut AppStateImpl::InUserCallback { .. }
-        | &mut AppStateImpl::ProcessingRedraws { .. } => {}
+        | &mut AppStateImpl::ProcessingRedraws { .. } => {},
         s @ &mut AppStateImpl::Launching { .. }
         | s @ &mut AppStateImpl::Waiting { .. }
         | s @ &mut AppStateImpl::PollFinished { .. } => bug!("unexpected state {:?}", s),
         &mut AppStateImpl::Terminated => {
             panic!("Attempt to create a `Window` after the app has terminated")
-        }
+        },
     }
     drop(this);
     window.makeKeyAndVisible();
 }
 
-pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Id<WinitUIWindow>) {
+pub(crate) fn queue_gl_or_metal_redraw(mtm: MainThreadMarker, window: Retained<WinitUIWindow>) {
     let mut this = AppState::get_mut(mtm);
     match this.state_mut() {
-        &mut AppStateImpl::NotLaunched {
-            ref mut queued_gpu_redraws,
-            ..
-        }
-        | &mut AppStateImpl::Launching {
-            ref mut queued_gpu_redraws,
-            ..
-        }
-        | &mut AppStateImpl::ProcessingEvents {
-            ref mut queued_gpu_redraws,
-            ..
-        }
-        | &mut AppStateImpl::InUserCallback {
-            ref mut queued_gpu_redraws,
-            ..
-        } => {
+        &mut AppStateImpl::NotLaunched { ref mut queued_gpu_redraws, .. }
+        | &mut AppStateImpl::Launching { ref mut queued_gpu_redraws, .. }
+        | &mut AppStateImpl::ProcessingEvents { ref mut queued_gpu_redraws, .. }
+        | &mut AppStateImpl::InUserCallback { ref mut queued_gpu_redraws, .. } => {
             let _ = queued_gpu_redraws.insert(window);
-        }
+        },
         s @ &mut AppStateImpl::ProcessingRedraws { .. }
         | s @ &mut AppStateImpl::Waiting { .. }
         | s @ &mut AppStateImpl::PollFinished { .. } => bug!("unexpected state {:?}", s),
         &mut AppStateImpl::Terminated => {
             panic!("Attempt to create a `Window` after the app has terminated")
-        }
+        },
     }
 }
 
@@ -566,10 +489,8 @@ pub fn did_finish_launching(mtm: MainThreadMarker) {
 
     let (windows, events) = AppState::get_mut(mtm).did_finish_launching_transition();
 
-    let events = std::iter::once(EventWrapper::StaticEvent(Event::NewEvents(
-        StartCause::Init,
-    )))
-    .chain(events);
+    let events = std::iter::once(EventWrapper::StaticEvent(Event::NewEvents(StartCause::Init)))
+        .chain(events);
     handle_nonuser_events(mtm, events);
 
     // the above window dance hack, could possibly trigger new windows to be created.
@@ -609,7 +530,7 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
             UserCallbackTransitionResult::ReentrancyPrevented { queued_events } => {
                 queued_events.extend(events);
                 return;
-            }
+            },
             UserCallbackTransitionResult::Success {
                 handler,
                 active_control_flow,
@@ -630,7 +551,7 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
                     );
                 }
                 handler.handle_event(event)
-            }
+            },
             EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
         }
     }
@@ -638,18 +559,16 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
     loop {
         let mut this = AppState::get_mut(mtm);
         let queued_events = match this.state_mut() {
-            &mut AppStateImpl::InUserCallback {
-                ref mut queued_events,
-                queued_gpu_redraws: _,
-            } => mem::take(queued_events),
+            &mut AppStateImpl::InUserCallback { ref mut queued_events, queued_gpu_redraws: _ } => {
+                mem::take(queued_events)
+            },
             s => bug!("unexpected state {:?}", s),
         };
         if queued_events.is_empty() {
             let queued_gpu_redraws = match this.take_state() {
-                AppStateImpl::InUserCallback {
-                    queued_events: _,
-                    queued_gpu_redraws,
-                } => queued_gpu_redraws,
+                AppStateImpl::InUserCallback { queued_events: _, queued_gpu_redraws } => {
+                    queued_gpu_redraws
+                },
                 _ => unreachable!(),
             };
             this.app_state = Some(if processing_redraws {
@@ -657,16 +576,9 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
                     queued_gpu_redraws.is_empty(),
                     "redraw queued while processing redraws"
                 );
-                AppStateImpl::ProcessingRedraws {
-                    handler,
-                    active_control_flow,
-                }
+                AppStateImpl::ProcessingRedraws { handler, active_control_flow }
             } else {
-                AppStateImpl::ProcessingEvents {
-                    handler,
-                    queued_gpu_redraws,
-                    active_control_flow,
-                }
+                AppStateImpl::ProcessingEvents { handler, queued_gpu_redraws, active_control_flow }
             });
             break;
         }
@@ -679,12 +591,13 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
                         tracing::info!("processing `RedrawRequested` during the main event loop");
                     } else if processing_redraws && !event.is_redraw() {
                         tracing::warn!(
-                            "processing non-`RedrawRequested` event after the main event loop: {:#?}",
+                            "processing non-`RedrawRequested` event after the main event loop: \
+                             {:#?}",
                             event
                         );
                     }
                     handler.handle_event(event)
-                }
+                },
                 EventWrapper::ScaleFactorChanged(event) => handle_hidpi_proxy(&mut handler, event),
             }
         }
@@ -697,7 +610,7 @@ fn handle_user_events(mtm: MainThreadMarker) {
         match this.try_user_callback_transition() {
             UserCallbackTransitionResult::ReentrancyPrevented { .. } => {
                 bug!("unexpected attempted to process an event")
-            }
+            },
             UserCallbackTransitionResult::Success {
                 handler,
                 active_control_flow,
@@ -709,23 +622,21 @@ fn handle_user_events(mtm: MainThreadMarker) {
     }
     drop(this);
 
-    handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
+    handler.handle_event(Event::UserWakeUp);
 
     loop {
         let mut this = AppState::get_mut(mtm);
         let queued_events = match this.state_mut() {
-            &mut AppStateImpl::InUserCallback {
-                ref mut queued_events,
-                queued_gpu_redraws: _,
-            } => mem::take(queued_events),
+            &mut AppStateImpl::InUserCallback { ref mut queued_events, queued_gpu_redraws: _ } => {
+                mem::take(queued_events)
+            },
             s => bug!("unexpected state {:?}", s),
         };
         if queued_events.is_empty() {
             let queued_gpu_redraws = match this.take_state() {
-                AppStateImpl::InUserCallback {
-                    queued_events: _,
-                    queued_gpu_redraws,
-                } => queued_gpu_redraws,
+                AppStateImpl::InUserCallback { queued_events: _, queued_gpu_redraws } => {
+                    queued_gpu_redraws
+                },
                 _ => unreachable!(),
             };
             this.app_state = Some(AppStateImpl::ProcessingEvents {
@@ -744,17 +655,39 @@ fn handle_user_events(mtm: MainThreadMarker) {
             }
         }
 
-        handler.handle_event(Event::UserEvent(HandlePendingUserEvents));
+        handler.handle_event(Event::UserWakeUp);
     }
 }
 
+pub(crate) fn send_occluded_event_for_all_windows(application: &UIApplication, occluded: bool) {
+    let mtm = MainThreadMarker::from(application);
+
+    let mut events = Vec::new();
+    #[allow(deprecated)]
+    for window in application.windows().iter() {
+        if window.is_kind_of::<WinitUIWindow>() {
+            // SAFETY: We just checked that the window is a `winit` window
+            let window = unsafe {
+                let ptr: *const UIWindow = window;
+                let ptr: *const WinitUIWindow = ptr.cast();
+                &*ptr
+            };
+            events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::Occluded(occluded),
+            }));
+        }
+    }
+    handle_nonuser_events(mtm, events);
+}
+
 pub fn handle_main_events_cleared(mtm: MainThreadMarker) {
     let mut this = AppState::get_mut(mtm);
     if !this.has_launched() || this.has_terminated() {
         return;
     }
     match this.state_mut() {
-        AppStateImpl::ProcessingEvents { .. } => {}
+        AppStateImpl::ProcessingEvents { .. } => {},
         _ => bug!("`ProcessingRedraws` happened unexpectedly"),
     };
     drop(this);
@@ -782,7 +715,27 @@ pub fn handle_events_cleared(mtm: MainThreadMarker) {
     AppState::get_mut(mtm).events_cleared_transition();
 }
 
-pub fn terminated(mtm: MainThreadMarker) {
+pub(crate) fn terminated(application: &UIApplication) {
+    let mtm = MainThreadMarker::from(application);
+
+    let mut events = Vec::new();
+    #[allow(deprecated)]
+    for window in application.windows().iter() {
+        if window.is_kind_of::<WinitUIWindow>() {
+            // SAFETY: We just checked that the window is a `winit` window
+            let window = unsafe {
+                let ptr: *const UIWindow = window;
+                let ptr: *const WinitUIWindow = ptr.cast();
+                &*ptr
+            };
+            events.push(EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::Destroyed,
+            }));
+        }
+    }
+    handle_nonuser_events(mtm, events);
+
     let mut this = AppState::get_mut(mtm);
     let mut handler = this.terminated_transition();
     drop(this);
@@ -791,11 +744,7 @@ pub fn terminated(mtm: MainThreadMarker) {
 }
 
 fn handle_hidpi_proxy(handler: &mut EventLoopHandler, event: ScaleFactorChanged) {
-    let ScaleFactorChanged {
-        suggested_size,
-        scale_factor,
-        window,
-    } = event;
+    let ScaleFactorChanged { suggested_size, scale_factor, window } = event;
     let new_inner_size = Arc::new(Mutex::new(suggested_size));
     let event = Event::WindowEvent {
         window_id: RootWindowId(window.id()),
@@ -814,7 +763,7 @@ fn handle_hidpi_proxy(handler: &mut EventLoopHandler, event: ScaleFactorChanged)
     view.setFrame(new_frame);
 }
 
-fn get_view_and_screen_frame(window: &WinitUIWindow) -> (Id<UIView>, CGRect) {
+fn get_view_and_screen_frame(window: &WinitUIWindow) -> (Retained<UIView>, CGRect) {
     let view_controller = window.rootViewController().unwrap();
     let view = view_controller.view().unwrap();
     let bounds = window.bounds();
@@ -846,25 +795,25 @@ impl EventLoopWaker {
             // future, but that gets changed to fire immediately in did_finish_launching
             let timer = CFRunLoopTimerCreate(
                 ptr::null_mut(),
-                std::f64::MAX,
+                f64::MAX,
                 0.000_000_1,
                 0,
                 0,
                 wakeup_main_loop,
                 ptr::null_mut(),
             );
-            CFRunLoopAddTimer(rl, timer, kCFRunLoopCommonModes);
+            CFRunLoopAddTimer(rl, timer, kCFRunLoopDefaultMode);
 
             EventLoopWaker { timer }
         }
     }
 
     fn stop(&mut self) {
-        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MAX) }
+        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MAX) }
     }
 
     fn start(&mut self) {
-        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, std::f64::MIN) }
+        unsafe { CFRunLoopTimerSetNextFireDate(self.timer, f64::MIN) }
     }
 
     fn start_at(&mut self, instant: Instant) {
@@ -950,28 +899,21 @@ fn meets_requirements(
 }
 
 fn get_version() -> NSOperatingSystemVersion {
-    unsafe {
-        let process_info = NSProcessInfo::processInfo();
-        let atleast_ios_8: bool = msg_send![
-            &process_info,
-            respondsToSelector: sel!(operatingSystemVersion)
-        ];
-        // winit requires atleast iOS 8 because no one has put the time into supporting earlier os versions.
-        // Older iOS versions are increasingly difficult to test. For example, Xcode 11 does not support
-        // debugging on devices with an iOS version of less than 8. Another example, in order to use an iOS
-        // simulator older than iOS 8, you must download an older version of Xcode (<9), and at least Xcode 7
-        // has been tested to not even run on macOS 10.15 - Xcode 8 might?
-        //
-        // The minimum required iOS version is likely to grow in the future.
-        assert!(atleast_ios_8, "`winit` requires iOS version 8 or greater");
-        process_info.operatingSystemVersion()
-    }
+    let process_info = NSProcessInfo::processInfo();
+    let atleast_ios_8 = process_info.respondsToSelector(sel!(operatingSystemVersion));
+    // Winit requires atleast iOS 8 because no one has put the time into supporting earlier os
+    // versions. Older iOS versions are increasingly difficult to test. For example, Xcode 11 does
+    // not support debugging on devices with an iOS version of less than 8. Another example, in
+    // order to use an iOS simulator older than iOS 8, you must download an older version of Xcode
+    // (<9), and at least Xcode 7 has been tested to not even run on macOS 10.15 - Xcode 8 might?
+    //
+    // The minimum required iOS version is likely to grow in the future.
+    assert!(atleast_ios_8, "`winit` requires iOS version 8 or greater");
+    process_info.operatingSystemVersion()
 }
 
 pub fn os_capabilities() -> OSCapabilities {
     // Cache the version lookup for efficiency
     static OS_CAPABILITIES: OnceLock<OSCapabilities> = OnceLock::new();
-    OS_CAPABILITIES
-        .get_or_init(|| OSCapabilities::from_os_version(get_version()))
-        .clone()
+    OS_CAPABILITIES.get_or_init(|| OSCapabilities::from_os_version(get_version())).clone()
 }

src/platform_impl/apple/uikit/event_loop.rs

@@ -1,38 +1,32 @@
-use std::{
-    collections::VecDeque,
-    ffi::c_void,
-    marker::PhantomData,
-    ptr,
-    sync::mpsc::{self, Receiver, Sender},
-};
+use std::collections::VecDeque;
+use std::ffi::{c_char, c_int, c_void};
+use std::marker::PhantomData;
+use std::ptr::{self, NonNull};
+use std::sync::atomic::{AtomicBool, Ordering as AtomicOrdering};
+use std::sync::Arc;
 
 use core_foundation::base::{CFIndex, CFRelease};
 use core_foundation::runloop::{
-    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes, kCFRunLoopDefaultMode,
-    kCFRunLoopExit, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
+    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopDefaultMode, kCFRunLoopExit,
+    CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
     CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext, CFRunLoopSourceCreate,
     CFRunLoopSourceInvalidate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
 };
-use icrate::Foundation::{MainThreadMarker, NSString};
-use objc2::ClassType;
+use objc2::rc::Retained;
+use objc2::{msg_send_id, ClassType};
+use objc2_foundation::{MainThreadMarker, NSString};
+use objc2_ui_kit::{UIApplication, UIApplicationMain, UIScreen};
 
-use crate::{
-    error::EventLoopError,
-    event::Event,
-    event_loop::{
-        ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents, EventLoopClosed,
-    },
-    platform::ios::Idiom,
-    platform_impl::platform::app_state::{EventLoopHandler, HandlePendingUserEvents},
-    window::{CustomCursor, CustomCursorSource},
-};
+use super::app_state::EventLoopHandler;
+use crate::application::ApplicationHandler;
+use crate::error::EventLoopError;
+use crate::event::Event;
+use crate::event_loop::{ActiveEventLoop as RootActiveEventLoop, ControlFlow, DeviceEvents};
+use crate::window::{CustomCursor, CustomCursorSource};
 
-use super::{app_delegate::AppDelegate, uikit::UIUserInterfaceIdiom};
+use super::app_delegate::AppDelegate;
+use super::app_state::AppState;
 use super::{app_state, monitor, MonitorHandle};
-use super::{
-    app_state::AppState,
-    uikit::{UIApplication, UIApplicationMain, UIDevice, UIScreen},
-};
 
 #[derive(Debug)]
 pub struct ActiveEventLoop {
@@ -42,9 +36,7 @@ pub struct ActiveEventLoop {
 impl ActiveEventLoop {
     pub fn create_custom_cursor(&self, source: CustomCursorSource) -> CustomCursor {
         let _ = source.inner;
-        CustomCursor {
-            inner: super::PlatformCustomCursor,
-        }
+        CustomCursor { inner: super::PlatformCustomCursor }
     }
 
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
@@ -52,7 +44,8 @@ impl ActiveEventLoop {
     }
 
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle::new(UIScreen::main(self.mtm)))
+        #[allow(deprecated)]
+        Some(MonitorHandle::new(UIScreen::mainScreen(self.mtm)))
     }
 
     #[inline]
@@ -69,9 +62,7 @@ impl ActiveEventLoop {
     pub fn raw_display_handle_rwh_06(
         &self,
     ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::RawDisplayHandle::UiKit(
-            rwh_06::UiKitDisplayHandle::new(),
-        ))
+        Ok(rwh_06::RawDisplayHandle::UiKit(rwh_06::UiKitDisplayHandle::new()))
     }
 
     pub(crate) fn set_control_flow(&self, control_flow: ControlFlow) {
@@ -116,34 +107,44 @@ impl OwnedDisplayHandle {
     }
 }
 
-fn map_user_event<T: 'static>(
-    mut handler: impl FnMut(Event<T>, &RootActiveEventLoop),
-    receiver: mpsc::Receiver<T>,
-) -> impl FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop) {
-    move |event, window_target| match event.map_nonuser_event() {
-        Ok(event) => (handler)(event, window_target),
-        Err(_) => {
-            for event in receiver.try_iter() {
-                (handler)(Event::UserEvent(event), window_target);
+fn map_user_event<A: ApplicationHandler>(
+    app: &mut A,
+    proxy_wake_up: Arc<AtomicBool>,
+) -> impl FnMut(Event, &RootActiveEventLoop) + '_ {
+    move |event, window_target| match event {
+        Event::NewEvents(cause) => app.new_events(window_target, cause),
+        Event::WindowEvent { window_id, event } => {
+            app.window_event(window_target, window_id, event)
+        },
+        Event::DeviceEvent { device_id, event } => {
+            app.device_event(window_target, device_id, event)
+        },
+        Event::UserWakeUp => {
+            if proxy_wake_up.swap(false, AtomicOrdering::Relaxed) {
+                app.proxy_wake_up(window_target);
             }
-        }
+        },
+        Event::Suspended => app.suspended(window_target),
+        Event::Resumed => app.resumed(window_target),
+        Event::AboutToWait => app.about_to_wait(window_target),
+        Event::LoopExiting => app.exiting(window_target),
+        Event::MemoryWarning => app.memory_warning(window_target),
     }
 }
 
-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
     mtm: MainThreadMarker,
-    sender: Sender<T>,
-    receiver: Receiver<T>,
+    proxy_wake_up: Arc<AtomicBool>,
     window_target: RootActiveEventLoop,
 }
 
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct PlatformSpecificEventLoopAttributes {}
 
-impl<T: 'static> EventLoop<T> {
+impl EventLoop {
     pub(crate) fn new(
         _: &PlatformSpecificEventLoopAttributes,
-    ) -> Result<EventLoop<T>, EventLoopError> {
+    ) -> Result<EventLoop, EventLoopError> {
         let mtm = MainThreadMarker::new()
             .expect("On iOS, `EventLoop` must be created on the main thread");
 
@@ -151,63 +152,59 @@ impl<T: 'static> EventLoop<T> {
         unsafe {
             assert!(
                 !SINGLETON_INIT,
-                "Only one `EventLoop` is supported on iOS. \
-                 `EventLoopProxy` might be helpful"
+                "Only one `EventLoop` is supported on iOS. `EventLoopProxy` might be helpful"
             );
             SINGLETON_INIT = true;
         }
 
-        let (sender, receiver) = mpsc::channel();
-
         // this line sets up the main run loop before `UIApplicationMain`
         setup_control_flow_observers();
 
+        let proxy_wake_up = Arc::new(AtomicBool::new(false));
+
         Ok(EventLoop {
             mtm,
-            sender,
-            receiver,
-            window_target: RootActiveEventLoop {
-                p: ActiveEventLoop { mtm },
-                _marker: PhantomData,
-            },
+            proxy_wake_up,
+            window_target: RootActiveEventLoop { p: ActiveEventLoop { mtm }, _marker: PhantomData },
         })
     }
 
-    pub fn run<F>(self, handler: F) -> !
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
-        let application = UIApplication::shared(self.mtm);
+    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> ! {
+        let application: Option<Retained<UIApplication>> =
+            unsafe { msg_send_id![UIApplication::class(), sharedApplication] };
         assert!(
             application.is_none(),
             "\
-                `EventLoop` cannot be `run` after a call to `UIApplicationMain` on iOS\n\
-                 Note: `EventLoop::run_app` calls `UIApplicationMain` on iOS",
+                `EventLoop` cannot be `run` after a call to `UIApplicationMain` on iOS\nNote: \
+             `EventLoop::run_app` calls `UIApplicationMain` on iOS",
         );
 
-        let handler = map_user_event(handler, self.receiver);
+        let handler = map_user_event(app, self.proxy_wake_up.clone());
 
         let handler = unsafe {
             std::mem::transmute::<
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
-                Box<dyn FnMut(Event<HandlePendingUserEvents>, &RootActiveEventLoop)>,
+                Box<dyn FnMut(Event, &RootActiveEventLoop)>,
+                Box<dyn FnMut(Event, &RootActiveEventLoop)>,
             >(Box::new(handler))
         };
 
-        let handler = EventLoopHandler {
-            handler,
-            event_loop: self.window_target,
-        };
+        let handler = EventLoopHandler { handler, event_loop: self.window_target };
 
         app_state::will_launch(self.mtm, handler);
 
         // Ensure application delegate is initialized
         let _ = AppDelegate::class();
 
+        extern "C" {
+            // These functions are in crt_externs.h.
+            fn _NSGetArgc() -> *mut c_int;
+            fn _NSGetArgv() -> *mut *mut *mut c_char;
+        }
+
         unsafe {
             UIApplicationMain(
-                0,
-                ptr::null(),
+                *_NSGetArgc(),
+                NonNull::new(*_NSGetArgv()).unwrap(),
                 None,
                 Some(&NSString::from_str(AppDelegate::NAME)),
             )
@@ -215,8 +212,8 @@ impl<T: 'static> EventLoop<T> {
         unreachable!()
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.sender.clone())
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        EventLoopProxy::new(self.proxy_wake_up.clone())
     }
 
     pub fn window_target(&self) -> &RootActiveEventLoop {
@@ -224,35 +221,21 @@ impl<T: 'static> EventLoop<T> {
     }
 }
 
-// EventLoopExtIOS
-impl<T: 'static> EventLoop<T> {
-    pub fn idiom(&self) -> Idiom {
-        match UIDevice::current(self.mtm).userInterfaceIdiom() {
-            UIUserInterfaceIdiom::Unspecified => Idiom::Unspecified,
-            UIUserInterfaceIdiom::Phone => Idiom::Phone,
-            UIUserInterfaceIdiom::Pad => Idiom::Pad,
-            UIUserInterfaceIdiom::TV => Idiom::TV,
-            UIUserInterfaceIdiom::CarPlay => Idiom::CarPlay,
-            _ => Idiom::Unspecified,
-        }
-    }
-}
-
-pub struct EventLoopProxy<T> {
-    sender: Sender<T>,
+pub struct EventLoopProxy {
+    proxy_wake_up: Arc<AtomicBool>,
     source: CFRunLoopSourceRef,
 }
 
-unsafe impl<T: Send> Send for EventLoopProxy<T> {}
-unsafe impl<T: Send> Sync for EventLoopProxy<T> {}
+unsafe impl Send for EventLoopProxy {}
+unsafe impl Sync for EventLoopProxy {}
 
-impl<T> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.sender.clone())
+impl Clone for EventLoopProxy {
+    fn clone(&self) -> EventLoopProxy {
+        EventLoopProxy::new(self.proxy_wake_up.clone())
     }
 }
 
-impl<T> Drop for EventLoopProxy<T> {
+impl Drop for EventLoopProxy {
     fn drop(&mut self) {
         unsafe {
             CFRunLoopSourceInvalidate(self.source);
@@ -261,8 +244,8 @@ impl<T> Drop for EventLoopProxy<T> {
     }
 }
 
-impl<T> EventLoopProxy<T> {
-    fn new(sender: Sender<T>) -> EventLoopProxy<T> {
+impl EventLoopProxy {
+    fn new(proxy_wake_up: Arc<AtomicBool>) -> EventLoopProxy {
         unsafe {
             // just wake up the eventloop
             extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
@@ -282,32 +265,29 @@ impl<T> EventLoopProxy<T> {
                 cancel: None,
                 perform: event_loop_proxy_handler,
             };
-            let source =
-                CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
-            CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
+            let source = CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::MAX - 1, &mut context);
+            CFRunLoopAddSource(rl, source, kCFRunLoopDefaultMode);
             CFRunLoopWakeUp(rl);
 
-            EventLoopProxy { sender, source }
+            EventLoopProxy { proxy_wake_up, source }
         }
     }
 
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.sender
-            .send(event)
-            .map_err(|::std::sync::mpsc::SendError(x)| EventLoopClosed(x))?;
+    pub fn wake_up(&self) {
+        self.proxy_wake_up.store(true, AtomicOrdering::Relaxed);
         unsafe {
             // let the main thread know there's a new event
             CFRunLoopSourceSignal(self.source);
             let rl = CFRunLoopGetMain();
             CFRunLoopWakeUp(rl);
         }
-        Ok(())
     }
 }
 
 fn setup_control_flow_observers() {
     unsafe {
-        // begin is queued with the highest priority to ensure it is processed before other observers
+        // begin is queued with the highest priority to ensure it is processed before other
+        // observers
         extern "C" fn control_flow_begin_handler(
             _: CFRunLoopObserverRef,
             activity: CFRunLoopActivity,
@@ -341,7 +321,7 @@ fn setup_control_flow_observers() {
             #[allow(non_upper_case_globals)]
             match activity {
                 kCFRunLoopBeforeWaiting => app_state::handle_main_events_cleared(mtm),
-                kCFRunLoopExit => {} // may happen when running on macOS
+                kCFRunLoopExit => {}, // may happen when running on macOS
                 _ => unreachable!(),
             }
         }
@@ -356,7 +336,7 @@ fn setup_control_flow_observers() {
             #[allow(non_upper_case_globals)]
             match activity {
                 kCFRunLoopBeforeWaiting => app_state::handle_events_cleared(mtm),
-                kCFRunLoopExit => {} // may happen when running on macOS
+                kCFRunLoopExit => {}, // may happen when running on macOS
                 _ => unreachable!(),
             }
         }
@@ -367,7 +347,7 @@ fn setup_control_flow_observers() {
             ptr::null_mut(),
             kCFRunLoopAfterWaiting,
             1, // repeat = true
-            CFIndex::min_value(),
+            CFIndex::MIN,
             control_flow_begin_handler,
             ptr::null_mut(),
         );
@@ -387,7 +367,7 @@ fn setup_control_flow_observers() {
             ptr::null_mut(),
             kCFRunLoopExit | kCFRunLoopBeforeWaiting,
             1, // repeat = true
-            CFIndex::max_value(),
+            CFIndex::MAX,
             control_flow_end_handler,
             ptr::null_mut(),
         );

src/platform_impl/apple/uikit/mod.rs

@@ -1,11 +1,9 @@
-#![cfg(ios_platform)]
 #![allow(clippy::let_unit_value)]
 
 mod app_delegate;
 mod app_state;
 mod event_loop;
 mod monitor;
-mod uikit;
 mod view;
 mod view_controller;
 mod window;
@@ -14,16 +12,15 @@ use std::fmt;
 
 use crate::event::DeviceId as RootDeviceId;
 
-pub(crate) use self::{
-    event_loop::{
-        ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
-        PlatformSpecificEventLoopAttributes,
-    },
-    monitor::{MonitorHandle, VideoModeHandle},
-    window::{PlatformSpecificWindowAttributes, Window, WindowId},
+pub(crate) use self::event_loop::{
+    ActiveEventLoop, EventLoop, EventLoopProxy, OwnedDisplayHandle,
+    PlatformSpecificEventLoopAttributes,
+};
+pub(crate) use self::monitor::{MonitorHandle, VideoModeHandle};
+pub(crate) use self::window::{PlatformSpecificWindowAttributes, Window, WindowId};
+pub(crate) use crate::cursor::{
+    NoCustomCursor as PlatformCustomCursor, NoCustomCursor as PlatformCustomCursorSource,
 };
-pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursor;
-pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursorSource;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
 

src/platform_impl/apple/uikit/monitor.rs

@@ -1,31 +1,25 @@
 #![allow(clippy::unnecessary_cast)]
 
-use std::{
-    collections::{BTreeSet, VecDeque},
-    fmt, hash, ptr,
-};
+use std::collections::{BTreeSet, VecDeque};
+use std::{fmt, hash, ptr};
 
-use icrate::Foundation::{MainThreadBound, MainThreadMarker, NSInteger};
 use objc2::mutability::IsRetainable;
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::Message;
+use objc2_foundation::{run_on_main, MainThreadBound, MainThreadMarker, NSInteger};
+use objc2_ui_kit::{UIScreen, UIScreenMode};
 
-use super::uikit::{UIScreen, UIScreenMode};
-use crate::{
-    dpi::{PhysicalPosition, PhysicalSize},
-    monitor::VideoModeHandle as RootVideoModeHandle,
-    platform_impl::platform::app_state,
-};
+use super::app_state;
+use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::monitor::VideoModeHandle as RootVideoModeHandle;
 
 // Workaround for `MainThreadBound` implementing almost no traits
 #[derive(Debug)]
-struct MainThreadBoundDelegateImpls<T>(MainThreadBound<Id<T>>);
+struct MainThreadBoundDelegateImpls<T>(MainThreadBound<Retained<T>>);
 
 impl<T: IsRetainable + Message> Clone for MainThreadBoundDelegateImpls<T> {
     fn clone(&self) -> Self {
-        Self(MainThreadMarker::run_on_main(|mtm| {
-            MainThreadBound::new(Id::clone(self.0.get(mtm)), mtm)
-        }))
+        Self(run_on_main(|mtm| MainThreadBound::new(Retained::clone(self.0.get(mtm)), mtm)))
     }
 }
 
@@ -33,7 +27,7 @@ impl<T: IsRetainable + Message> hash::Hash for MainThreadBoundDelegateImpls<T> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         // SAFETY: Marker only used to get the pointer
         let mtm = unsafe { MainThreadMarker::new_unchecked() };
-        Id::as_ptr(self.0.get(mtm)).hash(state);
+        Retained::as_ptr(self.0.get(mtm)).hash(state);
     }
 }
 
@@ -41,7 +35,7 @@ impl<T: IsRetainable + Message> PartialEq for MainThreadBoundDelegateImpls<T> {
     fn eq(&self, other: &Self) -> bool {
         // SAFETY: Marker only used to get the pointer
         let mtm = unsafe { MainThreadMarker::new_unchecked() };
-        Id::as_ptr(self.0.get(mtm)) == Id::as_ptr(other.0.get(mtm))
+        Retained::as_ptr(self.0.get(mtm)) == Retained::as_ptr(other.0.get(mtm))
     }
 }
 
@@ -58,8 +52,8 @@ pub struct VideoModeHandle {
 
 impl VideoModeHandle {
     fn new(
-        uiscreen: Id<UIScreen>,
-        screen_mode: Id<UIScreenMode>,
+        uiscreen: Retained<UIScreen>,
+        screen_mode: Retained<UIScreenMode>,
         mtm: MainThreadMarker,
     ) -> VideoModeHandle {
         let refresh_rate_millihertz = refresh_rate_millihertz(&uiscreen);
@@ -89,18 +83,18 @@ impl VideoModeHandle {
         self.monitor.clone()
     }
 
-    pub(super) fn screen_mode(&self, mtm: MainThreadMarker) -> &Id<UIScreenMode> {
+    pub(super) fn screen_mode(&self, mtm: MainThreadMarker) -> &Retained<UIScreenMode> {
         self.screen_mode.0.get(mtm)
     }
 }
 
 pub struct MonitorHandle {
-    ui_screen: MainThreadBound<Id<UIScreen>>,
+    ui_screen: MainThreadBound<Retained<UIScreen>>,
 }
 
 impl Clone for MonitorHandle {
     fn clone(&self) -> Self {
-        MainThreadMarker::run_on_main(|mtm| Self {
+        run_on_main(|mtm| Self {
             ui_screen: MainThreadBound::new(self.ui_screen.get(mtm).clone(), mtm),
         })
     }
@@ -146,22 +140,22 @@ impl fmt::Debug for MonitorHandle {
 }
 
 impl MonitorHandle {
-    pub(crate) fn new(ui_screen: Id<UIScreen>) -> Self {
-        // Holding `Id<UIScreen>` implies we're on the main thread.
+    pub(crate) fn new(ui_screen: Retained<UIScreen>) -> Self {
+        // Holding `Retained<UIScreen>` implies we're on the main thread.
         let mtm = MainThreadMarker::new().unwrap();
-        Self {
-            ui_screen: MainThreadBound::new(ui_screen, mtm),
-        }
+        Self { ui_screen: MainThreadBound::new(ui_screen, mtm) }
     }
 
     pub fn name(&self) -> Option<String> {
-        MainThreadMarker::run_on_main(|mtm| {
-            let main = UIScreen::main(mtm);
+        run_on_main(|mtm| {
+            #[allow(deprecated)]
+            let main = UIScreen::mainScreen(mtm);
             if *self.ui_screen(mtm) == main {
                 Some("Primary".to_string())
-            } else if *self.ui_screen(mtm) == main.mirroredScreen() {
+            } else if Some(self.ui_screen(mtm)) == main.mirroredScreen().as_ref() {
                 Some("Mirrored".to_string())
             } else {
+                #[allow(deprecated)]
                 UIScreen::screens(mtm)
                     .iter()
                     .position(|rhs| rhs == &**self.ui_screen(mtm))
@@ -171,33 +165,25 @@ impl MonitorHandle {
     }
 
     pub fn size(&self) -> PhysicalSize<u32> {
-        let bounds = self
-            .ui_screen
-            .get_on_main(|ui_screen| ui_screen.nativeBounds());
+        let bounds = self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeBounds());
         PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
     }
 
     pub fn position(&self) -> PhysicalPosition<i32> {
-        let bounds = self
-            .ui_screen
-            .get_on_main(|ui_screen| ui_screen.nativeBounds());
+        let bounds = self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeBounds());
         (bounds.origin.x as f64, bounds.origin.y as f64).into()
     }
 
     pub fn scale_factor(&self) -> f64 {
-        self.ui_screen
-            .get_on_main(|ui_screen| ui_screen.nativeScale()) as f64
+        self.ui_screen.get_on_main(|ui_screen| ui_screen.nativeScale()) as f64
     }
 
     pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        Some(
-            self.ui_screen
-                .get_on_main(|ui_screen| refresh_rate_millihertz(ui_screen)),
-        )
+        Some(self.ui_screen.get_on_main(|ui_screen| refresh_rate_millihertz(ui_screen)))
     }
 
     pub fn video_modes(&self) -> impl Iterator<Item = VideoModeHandle> {
-        MainThreadMarker::run_on_main(|mtm| {
+        run_on_main(|mtm| {
             let ui_screen = self.ui_screen(mtm);
             // Use Ord impl of RootVideoModeHandle
 
@@ -213,12 +199,12 @@ impl MonitorHandle {
         })
     }
 
-    pub(crate) fn ui_screen(&self, mtm: MainThreadMarker) -> &Id<UIScreen> {
+    pub(crate) fn ui_screen(&self, mtm: MainThreadMarker) -> &Retained<UIScreen> {
         self.ui_screen.get(mtm)
     }
 
     pub fn preferred_video_mode(&self) -> VideoModeHandle {
-        MainThreadMarker::run_on_main(|mtm| {
+        run_on_main(|mtm| {
             VideoModeHandle::new(
                 self.ui_screen(mtm).clone(),
                 self.ui_screen(mtm).preferredMode().unwrap(),
@@ -253,8 +239,6 @@ fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
 }
 
 pub fn uiscreens(mtm: MainThreadMarker) -> VecDeque<MonitorHandle> {
-    UIScreen::screens(mtm)
-        .into_iter()
-        .map(MonitorHandle::new)
-        .collect()
+    #[allow(deprecated)]
+    UIScreen::screens(mtm).into_iter().map(MonitorHandle::new).collect()
 }

src/platform_impl/apple/uikit/view.rs

@@ -1,31 +1,34 @@
 #![allow(clippy::unnecessary_cast)]
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 
-use icrate::Foundation::{CGFloat, CGRect, MainThreadMarker, NSObject, NSSet};
-use objc2::rc::Id;
-use objc2::runtime::AnyClass;
-use objc2::{
-    declare_class, extern_methods, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass,
+use objc2::rc::Retained;
+use objc2::runtime::{NSObjectProtocol, ProtocolObject};
+use objc2::{declare_class, msg_send, msg_send_id, mutability, sel, ClassType, DeclaredClass};
+use objc2_foundation::{CGFloat, CGPoint, CGRect, MainThreadMarker, NSObject, NSSet};
+use objc2_ui_kit::{
+    UICoordinateSpace, UIEvent, UIForceTouchCapability, UIGestureRecognizer,
+    UIGestureRecognizerDelegate, UIGestureRecognizerState, UIPanGestureRecognizer,
+    UIPinchGestureRecognizer, UIResponder, UIRotationGestureRecognizer, UITapGestureRecognizer,
+    UITouch, UITouchPhase, UITouchType, UITraitEnvironment, UIView,
 };
 
 use super::app_state::{self, EventWrapper};
-use super::uikit::{
-    UIEvent, UIForceTouchCapability, UIGestureRecognizerState, UIPinchGestureRecognizer,
-    UIResponder, UIRotationGestureRecognizer, UITapGestureRecognizer, UITouch, UITouchPhase,
-    UITouchType, UITraitCollection, UIView,
-};
 use super::window::WinitUIWindow;
-use crate::{
-    dpi::PhysicalPosition,
-    event::{Event, Force, Touch, TouchPhase, WindowEvent},
-    platform_impl::platform::DEVICE_ID,
-    window::{WindowAttributes, WindowId as RootWindowId},
-};
+use super::DEVICE_ID;
+use crate::dpi::PhysicalPosition;
+use crate::event::{Event, Force, Touch, TouchPhase, WindowEvent};
+use crate::window::{WindowAttributes, WindowId as RootWindowId};
 
 pub struct WinitViewState {
-    pinch_gesture_recognizer: RefCell<Option<Id<UIPinchGestureRecognizer>>>,
-    doubletap_gesture_recognizer: RefCell<Option<Id<UITapGestureRecognizer>>>,
-    rotation_gesture_recognizer: RefCell<Option<Id<UIRotationGestureRecognizer>>>,
+    pinch_gesture_recognizer: RefCell<Option<Retained<UIPinchGestureRecognizer>>>,
+    doubletap_gesture_recognizer: RefCell<Option<Retained<UITapGestureRecognizer>>>,
+    rotation_gesture_recognizer: RefCell<Option<Retained<UIRotationGestureRecognizer>>>,
+    pan_gesture_recognizer: RefCell<Option<Retained<UIPanGestureRecognizer>>>,
+
+    // for iOS delta references the start of the Gesture
+    rotation_last_delta: Cell<CGFloat>,
+    pinch_last_delta: Cell<CGFloat>,
+    pan_last_delta: Cell<CGPoint>,
 }
 
 declare_class!(
@@ -34,7 +37,7 @@ declare_class!(
     unsafe impl ClassType for WinitView {
         #[inherits(UIResponder, NSObject)]
         type Super = UIView;
-        type Mutability = mutability::InteriorMutable;
+        type Mutability = mutability::MainThreadOnly;
         const NAME: &'static str = "WinitUIView";
     }
 
@@ -167,12 +170,23 @@ declare_class!(
         fn pinch_gesture(&self, recognizer: &UIPinchGestureRecognizer) {
             let window = self.window().unwrap();
 
-            let phase = match recognizer.state() {
-                UIGestureRecognizerState::Began => TouchPhase::Started,
-                UIGestureRecognizerState::Changed => TouchPhase::Moved,
-                UIGestureRecognizerState::Ended => TouchPhase::Ended,
+            let (phase, delta) = match recognizer.state() {
+                UIGestureRecognizerState::Began => {
+                    self.ivars().pinch_last_delta.set(recognizer.scale());
+                    (TouchPhase::Started, 0.0)
+                }
+                UIGestureRecognizerState::Changed => {
+                    let last_scale: f64 = self.ivars().pinch_last_delta.replace(recognizer.scale());
+                    (TouchPhase::Moved, recognizer.scale() - last_scale)
+                }
+                UIGestureRecognizerState::Ended => {
+                    let last_scale: f64 = self.ivars().pinch_last_delta.replace(0.0);
+                    (TouchPhase::Moved, recognizer.scale() - last_scale)
+                }
                 UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => {
-                    TouchPhase::Cancelled
+                    self.ivars().rotation_last_delta.set(0.0);
+                    // Pass -delta so that action is reversed
+                    (TouchPhase::Cancelled, -recognizer.scale())
                 }
                 state => panic!("unexpected recognizer state: {:?}", state),
             };
@@ -181,7 +195,7 @@ declare_class!(
                 window_id: RootWindowId(window.id()),
                 event: WindowEvent::PinchGesture {
                     device_id: DEVICE_ID,
-                    delta: recognizer.velocity() as _,
+                    delta: delta as f64,
                     phase,
                 },
             });
@@ -211,23 +225,88 @@ declare_class!(
         fn rotation_gesture(&self, recognizer: &UIRotationGestureRecognizer) {
             let window = self.window().unwrap();
 
-            let phase = match recognizer.state() {
-                UIGestureRecognizerState::Began => TouchPhase::Started,
-                UIGestureRecognizerState::Changed => TouchPhase::Moved,
-                UIGestureRecognizerState::Ended => TouchPhase::Ended,
+            let (phase, delta) = match recognizer.state() {
+                UIGestureRecognizerState::Began => {
+                    self.ivars().rotation_last_delta.set(0.0);
+
+                    (TouchPhase::Started, 0.0)
+                }
+                UIGestureRecognizerState::Changed => {
+                    let last_rotation = self.ivars().rotation_last_delta.replace(recognizer.rotation());
+
+                    (TouchPhase::Moved, recognizer.rotation() - last_rotation)
+                }
+                UIGestureRecognizerState::Ended => {
+                    let last_rotation = self.ivars().rotation_last_delta.replace(0.0);
+
+                    (TouchPhase::Ended, recognizer.rotation() - last_rotation)
+                }
                 UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => {
-                    TouchPhase::Cancelled
+                    self.ivars().rotation_last_delta.set(0.0);
+
+                    // Pass -delta so that action is reversed
+                    (TouchPhase::Cancelled, -recognizer.rotation())
                 }
                 state => panic!("unexpected recognizer state: {:?}", state),
             };
 
-            // Flip the velocity to match macOS.
-            let delta = -recognizer.velocity() as _;
+            // Make delta negative to match macos, convert to degrees
             let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
                 window_id: RootWindowId(window.id()),
                 event: WindowEvent::RotationGesture {
                     device_id: DEVICE_ID,
-                    delta,
+                    delta: -delta.to_degrees() as _,
+                    phase,
+                },
+            });
+
+            let mtm = MainThreadMarker::new().unwrap();
+            app_state::handle_nonuser_event(mtm, gesture_event);
+        }
+
+        #[method(panGesture:)]
+        fn pan_gesture(&self, recognizer: &UIPanGestureRecognizer) {
+            let window = self.window().unwrap();
+
+            let translation = recognizer.translationInView(Some(self));
+
+            let (phase, dx, dy) = match recognizer.state() {
+                UIGestureRecognizerState::Began => {
+                    self.ivars().pan_last_delta.set(translation);
+
+                    (TouchPhase::Started, 0.0, 0.0)
+                }
+                UIGestureRecognizerState::Changed => {
+                    let last_pan: CGPoint = self.ivars().pan_last_delta.replace(translation);
+
+                    let dx = translation.x - last_pan.x;
+                    let dy = translation.y - last_pan.y;
+
+                    (TouchPhase::Moved, dx, dy)
+                }
+                UIGestureRecognizerState::Ended => {
+                    let last_pan: CGPoint = self.ivars().pan_last_delta.replace(CGPoint{x:0.0, y:0.0});
+
+                    let dx = translation.x - last_pan.x;
+                    let dy = translation.y - last_pan.y;
+
+                    (TouchPhase::Ended, dx, dy)
+                }
+                UIGestureRecognizerState::Cancelled | UIGestureRecognizerState::Failed => {
+                    let last_pan: CGPoint = self.ivars().pan_last_delta.replace(CGPoint{x:0.0, y:0.0});
+
+                    // Pass -delta so that action is reversed
+                    (TouchPhase::Cancelled, -last_pan.x, -last_pan.y)
+                }
+                state => panic!("unexpected recognizer state: {:?}", state),
+            };
+
+
+            let gesture_event = EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: RootWindowId(window.id()),
+                event: WindowEvent::PanGesture {
+                    device_id: DEVICE_ID,
+                    delta: PhysicalPosition::new(dx as _, dy as _),
                     phase,
                 },
             });
@@ -236,37 +315,34 @@ declare_class!(
             app_state::handle_nonuser_event(mtm, gesture_event);
         }
     }
-);
 
-extern_methods!(
-    #[allow(non_snake_case)]
-    unsafe impl WinitView {
-        fn window(&self) -> Option<Id<WinitUIWindow>> {
-            unsafe { msg_send_id![self, window] }
+    unsafe impl NSObjectProtocol for WinitView {}
+
+    unsafe impl UIGestureRecognizerDelegate for WinitView {
+        #[method(gestureRecognizer:shouldRecognizeSimultaneouslyWithGestureRecognizer:)]
+        fn should_recognize_simultaneously(&self, _gesture_recognizer: &UIGestureRecognizer, _other_gesture_recognizer: &UIGestureRecognizer) -> bool {
+            true
         }
-
-        unsafe fn traitCollection(&self) -> Id<UITraitCollection> {
-            msg_send_id![self, traitCollection]
-        }
-
-        // TODO: Allow the user to customize this
-        #[method(layerClass)]
-        pub(crate) fn layerClass() -> &'static AnyClass;
     }
 );
 
 impl WinitView {
     pub(crate) fn new(
-        _mtm: MainThreadMarker,
+        mtm: MainThreadMarker,
         window_attributes: &WindowAttributes,
         frame: CGRect,
-    ) -> Id<Self> {
-        let this = Self::alloc().set_ivars(WinitViewState {
+    ) -> Retained<Self> {
+        let this = mtm.alloc().set_ivars(WinitViewState {
             pinch_gesture_recognizer: RefCell::new(None),
             doubletap_gesture_recognizer: RefCell::new(None),
             rotation_gesture_recognizer: RefCell::new(None),
+            pan_gesture_recognizer: RefCell::new(None),
+
+            rotation_last_delta: Cell::new(0.0),
+            pinch_last_delta: Cell::new(0.0),
+            pan_last_delta: Cell::new(CGPoint { x: 0.0, y: 0.0 }),
         });
-        let this: Id<Self> = unsafe { msg_send_id![super(this), initWithFrame: frame] };
+        let this: Retained<Self> = unsafe { msg_send_id![super(this), initWithFrame: frame] };
 
         this.setMultipleTouchEnabled(true);
 
@@ -277,12 +353,23 @@ impl WinitView {
         this
     }
 
+    fn window(&self) -> Option<Retained<WinitUIWindow>> {
+        // SAFETY: `WinitView`s are always installed in a `WinitUIWindow`
+        (**self).window().map(|window| unsafe { Retained::cast(window) })
+    }
+
     pub(crate) fn recognize_pinch_gesture(&self, should_recognize: bool) {
+        let mtm = MainThreadMarker::from(self);
         if should_recognize {
             if self.ivars().pinch_gesture_recognizer.borrow().is_none() {
-                let pinch: Id<UIPinchGestureRecognizer> = unsafe {
-                    msg_send_id![UIPinchGestureRecognizer::alloc(), initWithTarget: self, action: sel!(pinchGesture:)]
+                let pinch = unsafe {
+                    UIPinchGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(pinchGesture:)),
+                    )
                 };
+                pinch.setDelegate(Some(ProtocolObject::from_ref(self)));
                 self.addGestureRecognizer(&pinch);
                 self.ivars().pinch_gesture_recognizer.replace(Some(pinch));
             }
@@ -291,12 +378,45 @@ impl WinitView {
         }
     }
 
+    pub(crate) fn recognize_pan_gesture(
+        &self,
+        should_recognize: bool,
+        minimum_number_of_touches: u8,
+        maximum_number_of_touches: u8,
+    ) {
+        let mtm = MainThreadMarker::from(self);
+        if should_recognize {
+            if self.ivars().pan_gesture_recognizer.borrow().is_none() {
+                let pan = unsafe {
+                    UIPanGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(panGesture:)),
+                    )
+                };
+                pan.setDelegate(Some(ProtocolObject::from_ref(self)));
+                pan.setMinimumNumberOfTouches(minimum_number_of_touches as _);
+                pan.setMaximumNumberOfTouches(maximum_number_of_touches as _);
+                self.addGestureRecognizer(&pan);
+                self.ivars().pan_gesture_recognizer.replace(Some(pan));
+            }
+        } else if let Some(recognizer) = self.ivars().pan_gesture_recognizer.take() {
+            self.removeGestureRecognizer(&recognizer);
+        }
+    }
+
     pub(crate) fn recognize_doubletap_gesture(&self, should_recognize: bool) {
+        let mtm = MainThreadMarker::from(self);
         if should_recognize {
             if self.ivars().doubletap_gesture_recognizer.borrow().is_none() {
-                let tap: Id<UITapGestureRecognizer> = unsafe {
-                    msg_send_id![UITapGestureRecognizer::alloc(), initWithTarget: self, action: sel!(doubleTapGesture:)]
+                let tap = unsafe {
+                    UITapGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(doubleTapGesture:)),
+                    )
                 };
+                tap.setDelegate(Some(ProtocolObject::from_ref(self)));
                 tap.setNumberOfTapsRequired(2);
                 tap.setNumberOfTouchesRequired(1);
                 self.addGestureRecognizer(&tap);
@@ -308,15 +428,19 @@ impl WinitView {
     }
 
     pub(crate) fn recognize_rotation_gesture(&self, should_recognize: bool) {
+        let mtm = MainThreadMarker::from(self);
         if should_recognize {
             if self.ivars().rotation_gesture_recognizer.borrow().is_none() {
-                let rotation: Id<UIRotationGestureRecognizer> = unsafe {
-                    msg_send_id![UIRotationGestureRecognizer::alloc(), initWithTarget: self, action: sel!(rotationGesture:)]
+                let rotation = unsafe {
+                    UIRotationGestureRecognizer::initWithTarget_action(
+                        mtm.alloc(),
+                        Some(self),
+                        Some(sel!(rotationGesture:)),
+                    )
                 };
+                rotation.setDelegate(Some(ProtocolObject::from_ref(self)));
                 self.addGestureRecognizer(&rotation);
-                self.ivars()
-                    .rotation_gesture_recognizer
-                    .replace(Some(rotation));
+                self.ivars().rotation_gesture_recognizer.replace(Some(rotation));
             }
         } else if let Some(recognizer) = self.ivars().rotation_gesture_recognizer.take() {
             self.removeGestureRecognizer(&recognizer);
@@ -329,9 +453,9 @@ impl WinitView {
         let os_supports_force = app_state::os_capabilities().force_touch;
         for touch in touches {
             let logical_location = touch.locationInView(None);
-            let touch_type = touch.type_();
+            let touch_type = touch.r#type();
             let force = if os_supports_force {
-                let trait_collection = unsafe { self.traitCollection() };
+                let trait_collection = self.traitCollection();
                 let touch_capability = trait_collection.forceTouchCapability();
                 // Both the OS _and_ the device need to be checked for force touch support.
                 if touch_capability == UIForceTouchCapability::Available
@@ -364,7 +488,7 @@ impl WinitView {
                 // 2 is UITouchPhase::Stationary and is not expected here
                 UITouchPhase::Ended => TouchPhase::Ended,
                 UITouchPhase::Cancelled => TouchPhase::Cancelled,
-                _ => panic!("unexpected touch phase: {:?}", phase as i32),
+                _ => panic!("unexpected touch phase: {phase:?}"),
             };
 
             let physical_location = {

src/platform_impl/apple/uikit/view_controller.rs

@@ -1,16 +1,16 @@
 use std::cell::Cell;
 
-use icrate::Foundation::{MainThreadMarker, NSObject};
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::{declare_class, msg_send_id, mutability, ClassType, DeclaredClass};
-
-use super::app_state::{self};
-use super::uikit::{
+use objc2_foundation::{MainThreadMarker, NSObject};
+use objc2_ui_kit::{
     UIDevice, UIInterfaceOrientationMask, UIRectEdge, UIResponder, UIStatusBarStyle,
     UIUserInterfaceIdiom, UIView, UIViewController,
 };
-use crate::platform::ios::{ScreenEdge, StatusBarStyle};
-use crate::{platform::ios::ValidOrientations, window::WindowAttributes};
+
+use super::app_state::{self};
+use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
+use crate::window::WindowAttributes;
 
 pub struct ViewControllerState {
     prefers_status_bar_hidden: Cell<bool>,
@@ -26,7 +26,7 @@ declare_class!(
     unsafe impl ClassType for WinitViewController {
         #[inherits(UIResponder, NSObject)]
         type Super = UIViewController;
-        type Mutability = mutability::InteriorMutable;
+        type Mutability = mutability::MainThreadOnly;
         const NAME: &'static str = "WinitUIViewController";
     }
 
@@ -97,16 +97,10 @@ impl WinitViewController {
 
     pub(crate) fn set_preferred_screen_edges_deferring_system_gestures(&self, val: ScreenEdge) {
         let val = {
-            assert_eq!(
-                val.bits() & !ScreenEdge::ALL.bits(),
-                0,
-                "invalid `ScreenEdge`"
-            );
+            assert_eq!(val.bits() & !ScreenEdge::ALL.bits(), 0, "invalid `ScreenEdge`");
             UIRectEdge(val.bits().into())
         };
-        self.ivars()
-            .preferred_screen_edges_deferring_system_gestures
-            .set(val);
+        self.ivars().preferred_screen_edges_deferring_system_gestures.set(val);
         let os_capabilities = app_state::os_capabilities();
         if os_capabilities.defer_system_gestures {
             self.setNeedsUpdateOfScreenEdgesDeferringSystemGestures();
@@ -120,52 +114,46 @@ impl WinitViewController {
         mtm: MainThreadMarker,
         valid_orientations: ValidOrientations,
     ) {
-        let mask = match (
-            valid_orientations,
-            UIDevice::current(mtm).userInterfaceIdiom(),
-        ) {
+        let mask = match (valid_orientations, UIDevice::currentDevice(mtm).userInterfaceIdiom()) {
             (ValidOrientations::LandscapeAndPortrait, UIUserInterfaceIdiom::Phone) => {
                 UIInterfaceOrientationMask::AllButUpsideDown
-            }
+            },
             (ValidOrientations::LandscapeAndPortrait, _) => UIInterfaceOrientationMask::All,
             (ValidOrientations::Landscape, _) => UIInterfaceOrientationMask::Landscape,
             (ValidOrientations::Portrait, UIUserInterfaceIdiom::Phone) => {
                 UIInterfaceOrientationMask::Portrait
-            }
+            },
             (ValidOrientations::Portrait, _) => {
                 UIInterfaceOrientationMask::Portrait
                     | UIInterfaceOrientationMask::PortraitUpsideDown
-            }
+            },
         };
         self.ivars().supported_orientations.set(mask);
-        UIViewController::attemptRotationToDeviceOrientation();
+        #[allow(deprecated)]
+        UIViewController::attemptRotationToDeviceOrientation(mtm);
     }
 
     pub(crate) fn new(
         mtm: MainThreadMarker,
         window_attributes: &WindowAttributes,
         view: &UIView,
-    ) -> Id<Self> {
+    ) -> Retained<Self> {
         // These are set properly below, we just to set them to something in the meantime.
-        let this = Self::alloc().set_ivars(ViewControllerState {
+        let this = mtm.alloc().set_ivars(ViewControllerState {
             prefers_status_bar_hidden: Cell::new(false),
             preferred_status_bar_style: Cell::new(UIStatusBarStyle::Default),
             prefers_home_indicator_auto_hidden: Cell::new(false),
             supported_orientations: Cell::new(UIInterfaceOrientationMask::All),
-            preferred_screen_edges_deferring_system_gestures: Cell::new(UIRectEdge::NONE),
+            preferred_screen_edges_deferring_system_gestures: Cell::new(UIRectEdge::empty()),
         });
-        let this: Id<Self> = unsafe { msg_send_id![super(this), init] };
+        let this: Retained<Self> = unsafe { msg_send_id![super(this), init] };
 
         this.set_prefers_status_bar_hidden(
-            window_attributes
-                .platform_specific
-                .prefers_status_bar_hidden,
+            window_attributes.platform_specific.prefers_status_bar_hidden,
         );
 
         this.set_preferred_status_bar_style(
-            window_attributes
-                .platform_specific
-                .preferred_status_bar_style,
+            window_attributes.platform_specific.preferred_status_bar_style,
         );
 
         this.set_supported_interface_orientations(
@@ -174,15 +162,11 @@ impl WinitViewController {
         );
 
         this.set_prefers_home_indicator_auto_hidden(
-            window_attributes
-                .platform_specific
-                .prefers_home_indicator_hidden,
+            window_attributes.platform_specific.prefers_home_indicator_hidden,
         );
 
         this.set_preferred_screen_edges_deferring_system_gestures(
-            window_attributes
-                .platform_specific
-                .preferred_screen_edges_deferring_system_gestures,
+            window_attributes.platform_specific.preferred_screen_edges_deferring_system_gestures,
         );
 
         this.setView(Some(view));

src/platform_impl/apple/uikit/window.rs

@@ -2,30 +2,31 @@
 
 use std::collections::VecDeque;
 
-use icrate::Foundation::{CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker};
-use objc2::rc::Id;
+use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, NSObject};
 use objc2::{class, declare_class, msg_send, msg_send_id, mutability, ClassType, DeclaredClass};
+use objc2_foundation::{
+    CGFloat, CGPoint, CGRect, CGSize, MainThreadBound, MainThreadMarker, NSObjectProtocol,
+};
+use objc2_ui_kit::{
+    UIApplication, UICoordinateSpace, UIResponder, UIScreen, UIScreenOverscanCompensation,
+    UIViewController, UIWindow,
+};
 use tracing::{debug, warn};
 
 use super::app_state::EventWrapper;
-use super::uikit::{
-    UIApplication, UIResponder, UIScreen, UIScreenOverscanCompensation, UIViewController, UIWindow,
-};
 use super::view::WinitView;
 use super::view_controller::WinitViewController;
-use crate::{
-    cursor::Cursor,
-    dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size},
-    error::{ExternalError, NotSupportedError, OsError as RootOsError},
-    event::{Event, WindowEvent},
-    icon::Icon,
-    platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations},
-    platform_impl::platform::{app_state, monitor, ActiveEventLoop, Fullscreen, MonitorHandle},
-    window::{
-        CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, WindowAttributes,
-        WindowButtons, WindowId as RootWindowId, WindowLevel,
-    },
+use super::{app_state, monitor, ActiveEventLoop, Fullscreen, MonitorHandle};
+use crate::cursor::Cursor;
+use crate::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
+use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
+use crate::event::{Event, WindowEvent};
+use crate::icon::Icon;
+use crate::platform::ios::{ScreenEdge, StatusBarStyle, ValidOrientations};
+use crate::window::{
+    CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, WindowAttributes,
+    WindowButtons, WindowId as RootWindowId, WindowLevel,
 };
 
 declare_class!(
@@ -35,7 +36,7 @@ declare_class!(
     unsafe impl ClassType for WinitUIWindow {
         #[inherits(UIResponder, NSObject)]
         type Super = UIWindow;
-        type Mutability = mutability::InteriorMutable;
+        type Mutability = mutability::MainThreadOnly;
         const NAME: &'static str = "WinitUIWindow";
     }
 
@@ -76,8 +77,8 @@ impl WinitUIWindow {
         window_attributes: &WindowAttributes,
         frame: CGRect,
         view_controller: &UIViewController,
-    ) -> Id<Self> {
-        let this: Id<Self> = unsafe { msg_send_id![Self::alloc(), initWithFrame: frame] };
+    ) -> Retained<Self> {
+        let this: Retained<Self> = unsafe { msg_send_id![mtm.alloc(), initWithFrame: frame] };
 
         this.setRootViewController(Some(view_controller));
 
@@ -87,11 +88,11 @@ impl WinitUIWindow {
                 let screen = monitor.ui_screen(mtm);
                 screen.setCurrentMode(Some(video_mode.screen_mode(mtm)));
                 this.setScreen(screen);
-            }
+            },
             Some(Fullscreen::Borderless(Some(ref monitor))) => {
                 let screen = monitor.ui_screen(mtm);
                 this.setScreen(screen);
-            }
+            },
             _ => (),
         }
 
@@ -104,9 +105,9 @@ impl WinitUIWindow {
 }
 
 pub struct Inner {
-    window: Id<WinitUIWindow>,
-    view_controller: Id<WinitViewController>,
-    view: Id<WinitView>,
+    window: Retained<WinitUIWindow>,
+    view_controller: Retained<WinitViewController>,
+    view: Retained<WinitView>,
     gl_or_metal_backed: bool,
 }
 
@@ -135,12 +136,13 @@ impl Inner {
     pub fn request_redraw(&self) {
         if self.gl_or_metal_backed {
             let mtm = MainThreadMarker::new().unwrap();
-            // `setNeedsDisplay` does nothing on UIViews which are directly backed by CAEAGLLayer or CAMetalLayer.
-            // Ordinarily the OS sets up a bunch of UIKit state before calling drawRect: on a UIView, but when using
-            // raw or gl/metal for drawing this work is completely avoided.
+            // `setNeedsDisplay` does nothing on UIViews which are directly backed by CAEAGLLayer or
+            // CAMetalLayer. Ordinarily the OS sets up a bunch of UIKit state before
+            // calling drawRect: on a UIView, but when using raw or gl/metal for drawing
+            // this work is completely avoided.
             //
-            // The docs for `setNeedsDisplay` don't mention `CAMetalLayer`; however, this has been confirmed via
-            // testing.
+            // The docs for `setNeedsDisplay` don't mention `CAMetalLayer`; however, this has been
+            // confirmed via testing.
             //
             // https://developer.apple.com/documentation/uikit/uiview/1622437-setneedsdisplay?language=objc
             app_state::queue_gl_or_metal_redraw(mtm, self.window.clone());
@@ -153,20 +155,16 @@ impl Inner {
 
     pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         let safe_area = self.safe_area_screen_space();
-        let position = LogicalPosition {
-            x: safe_area.origin.x as f64,
-            y: safe_area.origin.y as f64,
-        };
+        let position =
+            LogicalPosition { x: safe_area.origin.x as f64, y: safe_area.origin.y as f64 };
         let scale_factor = self.scale_factor();
         Ok(position.to_physical(scale_factor))
     }
 
     pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         let screen_frame = self.screen_frame();
-        let position = LogicalPosition {
-            x: screen_frame.origin.x as f64,
-            y: screen_frame.origin.y as f64,
-        };
+        let position =
+            LogicalPosition { x: screen_frame.origin.x as f64, y: screen_frame.origin.y as f64 };
         let scale_factor = self.scale_factor();
         Ok(position.to_physical(scale_factor))
     }
@@ -176,10 +174,7 @@ impl Inner {
         let position = physical_position.to_logical::<f64>(scale_factor);
         let screen_frame = self.screen_frame();
         let new_screen_frame = CGRect {
-            origin: CGPoint {
-                x: position.x as _,
-                y: position.y as _,
-            },
+            origin: CGPoint { x: position.x as _, y: position.y as _ },
             size: screen_frame.size,
         };
         let bounds = self.rect_from_screen_space(new_screen_frame);
@@ -307,15 +302,15 @@ impl Inner {
                 let uiscreen = video_mode.monitor.ui_screen(mtm);
                 uiscreen.setCurrentMode(Some(video_mode.screen_mode(mtm)));
                 uiscreen.clone()
-            }
+            },
             Some(Fullscreen::Borderless(Some(monitor))) => monitor.ui_screen(mtm).clone(),
             Some(Fullscreen::Borderless(None)) => {
                 self.current_monitor_inner().ui_screen(mtm).clone()
-            }
+            },
             None => {
                 warn!("`Window::set_fullscreen(None)` ignored on iOS");
                 return;
-            }
+            },
         };
 
         // this is pretty slow on iOS, so avoid doing it if we can
@@ -400,9 +395,8 @@ impl Inner {
     }
 
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle::new(UIScreen::main(
-            MainThreadMarker::new().unwrap(),
-        )))
+        #[allow(deprecated)]
+        Some(MonitorHandle::new(UIScreen::mainScreen(MainThreadMarker::new().unwrap())))
     }
 
     pub fn id(&self) -> WindowId {
@@ -412,18 +406,18 @@ impl Inner {
     #[cfg(feature = "rwh_04")]
     pub fn raw_window_handle_rwh_04(&self) -> rwh_04::RawWindowHandle {
         let mut window_handle = rwh_04::UiKitHandle::empty();
-        window_handle.ui_window = Id::as_ptr(&self.window) as _;
-        window_handle.ui_view = Id::as_ptr(&self.view) as _;
-        window_handle.ui_view_controller = Id::as_ptr(&self.view_controller) as _;
+        window_handle.ui_window = Retained::as_ptr(&self.window) as _;
+        window_handle.ui_view = Retained::as_ptr(&self.view) as _;
+        window_handle.ui_view_controller = Retained::as_ptr(&self.view_controller) as _;
         rwh_04::RawWindowHandle::UiKit(window_handle)
     }
 
     #[cfg(feature = "rwh_05")]
     pub fn raw_window_handle_rwh_05(&self) -> rwh_05::RawWindowHandle {
         let mut window_handle = rwh_05::UiKitWindowHandle::empty();
-        window_handle.ui_window = Id::as_ptr(&self.window) as _;
-        window_handle.ui_view = Id::as_ptr(&self.view) as _;
-        window_handle.ui_view_controller = Id::as_ptr(&self.view_controller) as _;
+        window_handle.ui_window = Retained::as_ptr(&self.window) as _;
+        window_handle.ui_view = Retained::as_ptr(&self.view) as _;
+        window_handle.ui_view_controller = Retained::as_ptr(&self.view_controller) as _;
         rwh_05::RawWindowHandle::UiKit(window_handle)
     }
 
@@ -435,11 +429,11 @@ impl Inner {
     #[cfg(feature = "rwh_06")]
     pub fn raw_window_handle_rwh_06(&self) -> rwh_06::RawWindowHandle {
         let mut window_handle = rwh_06::UiKitWindowHandle::new({
-            let ui_view = Id::as_ptr(&self.view) as _;
-            std::ptr::NonNull::new(ui_view).expect("Id<T> should never be null")
+            let ui_view = Retained::as_ptr(&self.view) as _;
+            std::ptr::NonNull::new(ui_view).expect("Retained<T> should never be null")
         });
         window_handle.ui_view_controller =
-            std::ptr::NonNull::new(Id::as_ptr(&self.view_controller) as _);
+            std::ptr::NonNull::new(Retained::as_ptr(&self.view_controller) as _);
         rwh_06::RawWindowHandle::UiKit(window_handle)
     }
 
@@ -489,7 +483,8 @@ impl Window {
 
         // TODO: transparency, visible
 
-        let main_screen = UIScreen::main(mtm);
+        #[allow(deprecated)]
+        let main_screen = UIScreen::mainScreen(mtm);
         let fullscreen = window_attributes.fullscreen.clone().map(Into::into);
         let screen = match fullscreen {
             Some(Fullscreen::Exclusive(ref video_mode)) => video_mode.monitor.ui_screen(mtm),
@@ -505,23 +500,16 @@ impl Window {
                 let size = dim.to_logical::<f64>(scale_factor as f64);
                 CGRect {
                     origin: screen_bounds.origin,
-                    size: CGSize {
-                        width: size.width as _,
-                        height: size.height as _,
-                    },
+                    size: CGSize { width: size.width as _, height: size.height as _ },
                 }
-            }
+            },
             None => screen_bounds,
         };
 
         let view = WinitView::new(mtm, &window_attributes, frame);
 
-        let gl_or_metal_backed = unsafe {
-            let layer_class = WinitView::layerClass();
-            let is_metal = msg_send![layer_class, isSubclassOfClass: class!(CAMetalLayer)];
-            let is_gl = msg_send![layer_class, isSubclassOfClass: class!(CAEAGLLayer)];
-            is_metal || is_gl
-        };
+        let gl_or_metal_backed =
+            view.isKindOfClass(class!(CAMetalLayer)) || view.isKindOfClass(class!(CAEAGLLayer));
 
         let view_controller = WinitViewController::new(mtm, &window_attributes, &view);
         let window = WinitUIWindow::new(mtm, &window_attributes, frame, &view_controller);
@@ -544,13 +532,11 @@ impl Window {
             let window_id = RootWindowId(window.id());
             app_state::handle_nonuser_events(
                 mtm,
-                std::iter::once(EventWrapper::ScaleFactorChanged(
-                    app_state::ScaleFactorChanged {
-                        window: window.clone(),
-                        scale_factor,
-                        suggested_size: size.to_physical(scale_factor),
-                    },
-                ))
+                std::iter::once(EventWrapper::ScaleFactorChanged(app_state::ScaleFactorChanged {
+                    window: window.clone(),
+                    scale_factor,
+                    suggested_size: size.to_physical(scale_factor),
+                }))
                 .chain(std::iter::once(EventWrapper::StaticEvent(
                     Event::WindowEvent {
                         window_id,
@@ -560,15 +546,8 @@ impl Window {
             );
         }
 
-        let inner = Inner {
-            window,
-            view_controller,
-            view,
-            gl_or_metal_backed,
-        };
-        Ok(Window {
-            inner: MainThreadBound::new(inner, mtm),
-        })
+        let inner = Inner { window, view_controller, view, gl_or_metal_backed };
+        Ok(Window { inner: MainThreadBound::new(inner, mtm) })
     }
 
     pub(crate) fn maybe_queue_on_main(&self, f: impl FnOnce(&Inner) + Send + 'static) {
@@ -597,9 +576,7 @@ impl Window {
     pub(crate) fn raw_display_handle_rwh_06(
         &self,
     ) -> Result<rwh_06::RawDisplayHandle, rwh_06::HandleError> {
-        Ok(rwh_06::RawDisplayHandle::UiKit(
-            rwh_06::UiKitDisplayHandle::new(),
-        ))
+        Ok(rwh_06::RawDisplayHandle::UiKit(rwh_06::UiKitDisplayHandle::new()))
     }
 }
 
@@ -622,13 +599,11 @@ impl Inner {
     }
 
     pub fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
-        self.view_controller
-            .set_prefers_home_indicator_auto_hidden(hidden);
+        self.view_controller.set_prefers_home_indicator_auto_hidden(hidden);
     }
 
     pub fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
-        self.view_controller
-            .set_preferred_screen_edges_deferring_system_gestures(edges);
+        self.view_controller.set_preferred_screen_edges_deferring_system_gestures(edges);
     }
 
     pub fn set_prefers_status_bar_hidden(&self, hidden: bool) {
@@ -636,14 +611,26 @@ impl Inner {
     }
 
     pub fn set_preferred_status_bar_style(&self, status_bar_style: StatusBarStyle) {
-        self.view_controller
-            .set_preferred_status_bar_style(status_bar_style);
+        self.view_controller.set_preferred_status_bar_style(status_bar_style);
     }
 
     pub fn recognize_pinch_gesture(&self, should_recognize: bool) {
         self.view.recognize_pinch_gesture(should_recognize);
     }
 
+    pub fn recognize_pan_gesture(
+        &self,
+        should_recognize: bool,
+        minimum_number_of_touches: u8,
+        maximum_number_of_touches: u8,
+    ) {
+        self.view.recognize_pan_gesture(
+            should_recognize,
+            minimum_number_of_touches,
+            maximum_number_of_touches,
+        );
+    }
+
     pub fn recognize_doubletap_gesture(&self, should_recognize: bool) {
         self.view.recognize_doubletap_gesture(should_recognize);
     }
@@ -660,14 +647,12 @@ impl Inner {
 
     fn rect_to_screen_space(&self, rect: CGRect) -> CGRect {
         let screen_space = self.window.screen().coordinateSpace();
-        self.window
-            .convertRect_toCoordinateSpace(rect, &screen_space)
+        self.window.convertRect_toCoordinateSpace(rect, &screen_space)
     }
 
     fn rect_from_screen_space(&self, rect: CGRect) -> CGRect {
         let screen_space = self.window.screen().coordinateSpace();
-        self.window
-            .convertRect_fromCoordinateSpace(rect, &screen_space)
+        self.window.convertRect_fromCoordinateSpace(rect, &screen_space)
     }
 
     fn safe_area_screen_space(&self) -> CGRect {
@@ -688,9 +673,8 @@ impl Inner {
         } else {
             let screen_frame = self.rect_to_screen_space(bounds);
             let status_bar_frame = {
-                let app = UIApplication::shared(MainThreadMarker::new().unwrap()).expect(
-                    "`Window::get_inner_position` cannot be called before `EventLoop::run_app` on iOS",
-                );
+                let app = UIApplication::sharedApplication(MainThreadMarker::new().unwrap());
+                #[allow(deprecated)]
                 app.statusBarFrame()
             };
             let (y, height) = if screen_frame.origin.y > status_bar_frame.size.height {
@@ -702,14 +686,8 @@ impl Inner {
                 (y, height)
             };
             CGRect {
-                origin: CGPoint {
-                    x: screen_frame.origin.x,
-                    y,
-                },
-                size: CGSize {
-                    width: screen_frame.size.width,
-                    height,
-                },
+                origin: CGPoint { x: screen_frame.origin.x, y },
+                size: CGSize { width: screen_frame.size.width, height },
             }
         }
     }
@@ -722,9 +700,7 @@ pub struct WindowId {
 
 impl WindowId {
     pub const unsafe fn dummy() -> Self {
-        WindowId {
-            window: std::ptr::null_mut(),
-        }
+        WindowId { window: std::ptr::null_mut() }
     }
 }
 
@@ -736,9 +712,7 @@ impl From<WindowId> for u64 {
 
 impl From<u64> for WindowId {
     fn from(raw_id: u64) -> Self {
-        Self {
-            window: raw_id as _,
-        }
+        Self { window: raw_id as _ }
     }
 }
 
@@ -747,9 +721,7 @@ unsafe impl Sync for WindowId {}
 
 impl From<&AnyObject> for WindowId {
     fn from(window: &AnyObject) -> WindowId {
-        WindowId {
-            window: window as *const _ as _,
-        }
+        WindowId { window: window as *const _ as _ }
     }
 }
 

src/platform_impl/ios/app_delegate.rs

@@ -1,103 +0,0 @@
-use icrate::Foundation::{MainThreadMarker, NSObject, NSObjectProtocol};
-use objc2::{declare_class, mutability, ClassType, DeclaredClass};
-
-use super::app_state::{self, EventWrapper};
-use super::uikit::{UIApplication, UIWindow};
-use super::window::WinitUIWindow;
-use crate::{
-    event::{Event, WindowEvent},
-    window::WindowId as RootWindowId,
-};
-
-declare_class!(
-    pub struct AppDelegate;
-
-    unsafe impl ClassType for AppDelegate {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-        const NAME: &'static str = "WinitApplicationDelegate";
-    }
-
-    impl DeclaredClass for AppDelegate {}
-
-    // UIApplicationDelegate protocol
-    unsafe impl AppDelegate {
-        #[method(application:didFinishLaunchingWithOptions:)]
-        fn did_finish_launching(&self, _application: &UIApplication, _: *mut NSObject) -> bool {
-            app_state::did_finish_launching(MainThreadMarker::new().unwrap());
-            true
-        }
-
-        #[method(applicationDidBecomeActive:)]
-        fn did_become_active(&self, _application: &UIApplication) {
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Resumed))
-        }
-
-        #[method(applicationWillResignActive:)]
-        fn will_resign_active(&self, _application: &UIApplication) {
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::Suspended))
-        }
-
-        #[method(applicationWillEnterForeground:)]
-        fn will_enter_foreground(&self, application: &UIApplication) {
-            self.send_occluded_event_for_all_windows(application, false);
-        }
-
-        #[method(applicationDidEnterBackground:)]
-        fn did_enter_background(&self, application: &UIApplication) {
-            self.send_occluded_event_for_all_windows(application, true);
-        }
-
-        #[method(applicationWillTerminate:)]
-        fn will_terminate(&self, application: &UIApplication) {
-            let mut events = Vec::new();
-            for window in application.windows().iter() {
-                if window.is_kind_of::<WinitUIWindow>() {
-                    // SAFETY: We just checked that the window is a `winit` window
-                    let window = unsafe {
-                        let ptr: *const UIWindow = window;
-                        let ptr: *const WinitUIWindow = ptr.cast();
-                        &*ptr
-                    };
-                    events.push(EventWrapper::StaticEvent(Event::WindowEvent {
-                        window_id: RootWindowId(window.id()),
-                        event: WindowEvent::Destroyed,
-                    }));
-                }
-            }
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_events(mtm, events);
-            app_state::terminated(mtm);
-        }
-
-        #[method(applicationDidReceiveMemoryWarning:)]
-        fn did_receive_memory_warning(&self, _application: &UIApplication) {
-            let mtm = MainThreadMarker::new().unwrap();
-            app_state::handle_nonuser_event(mtm, EventWrapper::StaticEvent(Event::MemoryWarning))
-        }
-    }
-);
-
-impl AppDelegate {
-    fn send_occluded_event_for_all_windows(&self, application: &UIApplication, occluded: bool) {
-        let mut events = Vec::new();
-        for window in application.windows().iter() {
-            if window.is_kind_of::<WinitUIWindow>() {
-                // SAFETY: We just checked that the window is a `winit` window
-                let window = unsafe {
-                    let ptr: *const UIWindow = window;
-                    let ptr: *const WinitUIWindow = ptr.cast();
-                    &*ptr
-                };
-                events.push(EventWrapper::StaticEvent(Event::WindowEvent {
-                    window_id: RootWindowId(window.id()),
-                    event: WindowEvent::Occluded(occluded),
-                }));
-            }
-        }
-        let mtm = MainThreadMarker::new().unwrap();
-        app_state::handle_nonuser_events(mtm, events);
-    }
-}

src/platform_impl/ios/uikit/application.rs

@@ -1,31 +0,0 @@
-use icrate::Foundation::{CGRect, MainThreadMarker, NSArray, NSObject};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-
-use super::{UIResponder, UIWindow};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIApplication;
-
-    unsafe impl ClassType for UIApplication {
-        #[inherits(NSObject)]
-        type Super = UIResponder;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIApplication {
-        pub fn shared(_mtm: MainThreadMarker) -> Option<Id<Self>> {
-            unsafe { msg_send_id![Self::class(), sharedApplication] }
-        }
-
-        pub fn windows(&self) -> Id<NSArray<UIWindow>> {
-            unsafe { msg_send_id![self, windows] }
-        }
-
-        #[method(statusBarFrame)]
-        pub fn statusBarFrame(&self) -> CGRect;
-    }
-);

src/platform_impl/ios/uikit/coordinate_space.rs

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

src/platform_impl/ios/uikit/device.rs

@@ -1,41 +0,0 @@
-use icrate::Foundation::{MainThreadMarker, NSInteger, NSObject};
-use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIDevice;
-
-    unsafe impl ClassType for UIDevice {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIDevice {
-        pub fn current(_mtm: MainThreadMarker) -> Id<Self> {
-            unsafe { msg_send_id![Self::class(), currentDevice] }
-        }
-
-        #[method(userInterfaceIdiom)]
-        pub fn userInterfaceIdiom(&self) -> UIUserInterfaceIdiom;
-    }
-);
-
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIUserInterfaceIdiom(NSInteger);
-
-unsafe impl Encode for UIUserInterfaceIdiom {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
-
-impl UIUserInterfaceIdiom {
-    pub const Unspecified: UIUserInterfaceIdiom = UIUserInterfaceIdiom(-1);
-    pub const Phone: UIUserInterfaceIdiom = UIUserInterfaceIdiom(0);
-    pub const Pad: UIUserInterfaceIdiom = UIUserInterfaceIdiom(1);
-    pub const TV: UIUserInterfaceIdiom = UIUserInterfaceIdiom(2);
-    pub const CarPlay: UIUserInterfaceIdiom = UIUserInterfaceIdiom(3);
-}

src/platform_impl/ios/uikit/event.rs

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

src/platform_impl/ios/uikit/geometry.rs

@@ -1,14 +0,0 @@
-use icrate::Foundation::NSUInteger;
-use objc2::encode::{Encode, Encoding};
-
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIRectEdge(pub NSUInteger);
-
-impl UIRectEdge {
-    pub const NONE: Self = Self(0);
-}
-
-unsafe impl Encode for UIRectEdge {
-    const ENCODING: Encoding = NSUInteger::ENCODING;
-}

src/platform_impl/ios/uikit/gesture_recognizer.rs

@@ -1,121 +0,0 @@
-use icrate::Foundation::{CGFloat, NSInteger, NSObject, NSUInteger};
-use objc2::{
-    encode::{Encode, Encoding},
-    extern_class, extern_methods, mutability, ClassType,
-};
-
-// https://developer.apple.com/documentation/uikit/uigesturerecognizer
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIGestureRecognizer;
-
-    unsafe impl ClassType for UIGestureRecognizer {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIGestureRecognizer {
-        #[method(state)]
-        pub fn state(&self) -> UIGestureRecognizerState;
-    }
-);
-
-unsafe impl Encode for UIGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-// https://developer.apple.com/documentation/uikit/uigesturerecognizer/state
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIGestureRecognizerState(NSInteger);
-
-unsafe impl Encode for UIGestureRecognizerState {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
-
-#[allow(dead_code)]
-impl UIGestureRecognizerState {
-    pub const Possible: Self = Self(0);
-    pub const Began: Self = Self(1);
-    pub const Changed: Self = Self(2);
-    pub const Ended: Self = Self(3);
-    pub const Cancelled: Self = Self(4);
-    pub const Failed: Self = Self(5);
-}
-
-// https://developer.apple.com/documentation/uikit/uipinchgesturerecognizer
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIPinchGestureRecognizer;
-
-    unsafe impl ClassType for UIPinchGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIPinchGestureRecognizer {
-        #[method(scale)]
-        pub fn scale(&self) -> CGFloat;
-
-        #[method(velocity)]
-        pub fn velocity(&self) -> CGFloat;
-    }
-);
-
-unsafe impl Encode for UIPinchGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-// https://developer.apple.com/documentation/uikit/uirotationgesturerecognizer
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIRotationGestureRecognizer;
-
-    unsafe impl ClassType for UIRotationGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIRotationGestureRecognizer {
-        #[method(rotation)]
-        pub fn rotation(&self) -> CGFloat;
-
-        #[method(velocity)]
-        pub fn velocity(&self) -> CGFloat;
-    }
-);
-
-unsafe impl Encode for UIRotationGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}
-
-// https://developer.apple.com/documentation/uikit/uitapgesturerecognizer
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UITapGestureRecognizer;
-
-    unsafe impl ClassType for UITapGestureRecognizer {
-        type Super = UIGestureRecognizer;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UITapGestureRecognizer {
-        #[method(setNumberOfTapsRequired:)]
-        pub fn setNumberOfTapsRequired(&self, number_of_taps_required: NSUInteger);
-
-        #[method(setNumberOfTouchesRequired:)]
-        pub fn setNumberOfTouchesRequired(&self, number_of_touches_required: NSUInteger);
-    }
-);
-
-unsafe impl Encode for UITapGestureRecognizer {
-    const ENCODING: Encoding = Encoding::Object;
-}

src/platform_impl/ios/uikit/mod.rs

@@ -1,52 +0,0 @@
-#![allow(non_snake_case)]
-#![allow(non_upper_case_globals)]
-
-use std::os::raw::{c_char, c_int};
-
-use icrate::Foundation::NSString;
-
-mod application;
-mod coordinate_space;
-mod device;
-mod event;
-mod geometry;
-mod gesture_recognizer;
-mod responder;
-mod screen;
-mod screen_mode;
-mod status_bar_style;
-mod touch;
-mod trait_collection;
-mod view;
-mod view_controller;
-mod window;
-
-pub(crate) use self::application::UIApplication;
-pub(crate) use self::coordinate_space::UICoordinateSpace;
-pub(crate) use self::device::{UIDevice, UIUserInterfaceIdiom};
-pub(crate) use self::event::UIEvent;
-pub(crate) use self::geometry::UIRectEdge;
-pub(crate) use self::gesture_recognizer::{
-    UIGestureRecognizer, UIGestureRecognizerState, UIPinchGestureRecognizer,
-    UIRotationGestureRecognizer, UITapGestureRecognizer,
-};
-pub(crate) use self::responder::UIResponder;
-pub(crate) use self::screen::{UIScreen, UIScreenOverscanCompensation};
-pub(crate) use self::screen_mode::UIScreenMode;
-pub(crate) use self::status_bar_style::UIStatusBarStyle;
-pub(crate) use self::touch::{UITouch, UITouchPhase, UITouchType};
-pub(crate) use self::trait_collection::{UIForceTouchCapability, UITraitCollection};
-#[allow(unused_imports)]
-pub(crate) use self::view::{UIEdgeInsets, UIView};
-pub(crate) use self::view_controller::{UIInterfaceOrientationMask, UIViewController};
-pub(crate) use self::window::UIWindow;
-
-#[link(name = "UIKit", kind = "framework")]
-extern "C" {
-    pub fn UIApplicationMain(
-        argc: c_int,
-        argv: *const c_char,
-        principalClassName: Option<&NSString>,
-        delegateClassName: Option<&NSString>,
-    ) -> c_int;
-}

src/platform_impl/ios/uikit/responder.rs

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

src/platform_impl/ios/uikit/screen.rs

@@ -1,80 +0,0 @@
-use icrate::Foundation::{CGFloat, CGRect, MainThreadMarker, NSArray, NSInteger, NSObject};
-use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-
-use super::{UICoordinateSpace, UIScreenMode};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIScreen;
-
-    unsafe impl ClassType for UIScreen {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIScreen {
-        pub fn main(_mtm: MainThreadMarker) -> Id<Self> {
-            unsafe { msg_send_id![Self::class(), mainScreen] }
-        }
-
-        pub fn screens(_mtm: MainThreadMarker) -> Id<NSArray<Self>> {
-            unsafe { msg_send_id![Self::class(), screens] }
-        }
-
-        #[method(bounds)]
-        pub fn bounds(&self) -> CGRect;
-
-        #[method(scale)]
-        pub fn scale(&self) -> CGFloat;
-
-        #[method(nativeBounds)]
-        pub fn nativeBounds(&self) -> CGRect;
-
-        #[method(nativeScale)]
-        pub fn nativeScale(&self) -> CGFloat;
-
-        #[method(maximumFramesPerSecond)]
-        pub fn maximumFramesPerSecond(&self) -> NSInteger;
-
-        pub fn mirroredScreen(&self) -> Id<Self> {
-            unsafe { msg_send_id![Self::class(), mirroredScreen] }
-        }
-
-        pub fn preferredMode(&self) -> Option<Id<UIScreenMode>> {
-            unsafe { msg_send_id![self, preferredMode] }
-        }
-
-        #[method(setCurrentMode:)]
-        pub fn setCurrentMode(&self, mode: Option<&UIScreenMode>);
-
-        pub fn availableModes(&self) -> Id<NSArray<UIScreenMode>> {
-            unsafe { msg_send_id![self, availableModes] }
-        }
-
-        #[method(setOverscanCompensation:)]
-        pub fn setOverscanCompensation(&self, overscanCompensation: UIScreenOverscanCompensation);
-
-        pub fn coordinateSpace(&self) -> Id<UICoordinateSpace> {
-            unsafe { msg_send_id![self, coordinateSpace] }
-        }
-    }
-);
-
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIScreenOverscanCompensation(NSInteger);
-
-unsafe impl Encode for UIScreenOverscanCompensation {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
-
-#[allow(dead_code)]
-impl UIScreenOverscanCompensation {
-    pub const Scale: Self = Self(0);
-    pub const InsetBounds: Self = Self(1);
-    pub const None: Self = Self(2);
-}

src/platform_impl/ios/uikit/screen_mode.rs

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

src/platform_impl/ios/uikit/status_bar_style.rs

@@ -1,16 +0,0 @@
-use icrate::Foundation::NSInteger;
-use objc2::encode::{Encode, Encoding};
-
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UIStatusBarStyle {
-    #[default]
-    Default = 0,
-    LightContent = 1,
-    DarkContent = 3,
-}
-
-unsafe impl Encode for UIStatusBarStyle {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}

src/platform_impl/ios/uikit/touch.rs

@@ -1,65 +0,0 @@
-use icrate::Foundation::{CGFloat, CGPoint, NSInteger, NSObject};
-use objc2::encode::{Encode, Encoding};
-use objc2::{extern_class, extern_methods, mutability, ClassType};
-
-use super::UIView;
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UITouch;
-
-    unsafe impl ClassType for UITouch {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UITouch {
-        #[method(locationInView:)]
-        pub fn locationInView(&self, view: Option<&UIView>) -> CGPoint;
-
-        #[method(type)]
-        pub fn type_(&self) -> UITouchType;
-
-        #[method(force)]
-        pub fn force(&self) -> CGFloat;
-
-        #[method(maximumPossibleForce)]
-        pub fn maximumPossibleForce(&self) -> CGFloat;
-
-        #[method(altitudeAngle)]
-        pub fn altitudeAngle(&self) -> CGFloat;
-
-        #[method(phase)]
-        pub fn phase(&self) -> UITouchPhase;
-    }
-);
-
-#[derive(Debug, PartialEq, Eq)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UITouchType {
-    Direct = 0,
-    Indirect,
-    Pencil,
-}
-
-unsafe impl Encode for UITouchType {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}
-
-#[derive(Debug)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UITouchPhase {
-    Began = 0,
-    Moved,
-    Stationary,
-    Ended,
-    Cancelled,
-}
-
-unsafe impl Encode for UITouchPhase {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}

src/platform_impl/ios/uikit/trait_collection.rs

@@ -1,33 +0,0 @@
-use icrate::Foundation::{NSInteger, NSObject};
-use objc2::encode::{Encode, Encoding};
-use objc2::{extern_class, extern_methods, mutability, ClassType};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UITraitCollection;
-
-    unsafe impl ClassType for UITraitCollection {
-        type Super = NSObject;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UITraitCollection {
-        #[method(forceTouchCapability)]
-        pub fn forceTouchCapability(&self) -> UIForceTouchCapability;
-    }
-);
-
-#[derive(Debug, PartialEq, Eq)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UIForceTouchCapability {
-    Unknown = 0,
-    Unavailable,
-    Available,
-}
-
-unsafe impl Encode for UIForceTouchCapability {
-    const ENCODING: Encoding = NSInteger::ENCODING;
-}

src/platform_impl/ios/uikit/view.rs

@@ -1,96 +0,0 @@
-use icrate::Foundation::{CGFloat, CGRect, NSObject};
-use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-
-use super::{UICoordinateSpace, UIGestureRecognizer, UIResponder, UIViewController};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIView;
-
-    unsafe impl ClassType for UIView {
-        #[inherits(NSObject)]
-        type Super = UIResponder;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIView {
-        #[method(bounds)]
-        pub fn bounds(&self) -> CGRect;
-
-        #[method(setBounds:)]
-        pub fn setBounds(&self, value: CGRect);
-
-        #[method(frame)]
-        pub fn frame(&self) -> CGRect;
-
-        #[method(setFrame:)]
-        pub fn setFrame(&self, value: CGRect);
-
-        #[method(contentScaleFactor)]
-        pub fn contentScaleFactor(&self) -> CGFloat;
-
-        #[method(setContentScaleFactor:)]
-        pub fn setContentScaleFactor(&self, val: CGFloat);
-
-        #[method(setMultipleTouchEnabled:)]
-        pub fn setMultipleTouchEnabled(&self, val: bool);
-
-        pub fn rootViewController(&self) -> Option<Id<UIViewController>> {
-            unsafe { msg_send_id![self, rootViewController] }
-        }
-
-        #[method(setRootViewController:)]
-        pub fn setRootViewController(&self, rootViewController: Option<&UIViewController>);
-
-        #[method(convertRect:toCoordinateSpace:)]
-        pub fn convertRect_toCoordinateSpace(
-            &self,
-            rect: CGRect,
-            coordinateSpace: &UICoordinateSpace,
-        ) -> CGRect;
-
-        #[method(convertRect:fromCoordinateSpace:)]
-        pub fn convertRect_fromCoordinateSpace(
-            &self,
-            rect: CGRect,
-            coordinateSpace: &UICoordinateSpace,
-        ) -> CGRect;
-
-        #[method(safeAreaInsets)]
-        pub fn safeAreaInsets(&self) -> UIEdgeInsets;
-
-        #[method(setNeedsDisplay)]
-        pub fn setNeedsDisplay(&self);
-
-        #[method(addGestureRecognizer:)]
-        pub fn addGestureRecognizer(&self, gestureRecognizer: &UIGestureRecognizer);
-
-        #[method(removeGestureRecognizer:)]
-        pub fn removeGestureRecognizer(&self, gestureRecognizer: &UIGestureRecognizer);
-    }
-);
-
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct UIEdgeInsets {
-    pub top: CGFloat,
-    pub left: CGFloat,
-    pub bottom: CGFloat,
-    pub right: CGFloat,
-}
-
-unsafe impl Encode for UIEdgeInsets {
-    const ENCODING: Encoding = Encoding::Struct(
-        "UIEdgeInsets",
-        &[
-            CGFloat::ENCODING,
-            CGFloat::ENCODING,
-            CGFloat::ENCODING,
-            CGFloat::ENCODING,
-        ],
-    );
-}

src/platform_impl/ios/uikit/view_controller.rs

@@ -1,57 +0,0 @@
-use icrate::Foundation::{NSObject, NSUInteger};
-use objc2::encode::{Encode, Encoding};
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-
-use super::{UIResponder, UIView};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIViewController;
-
-    unsafe impl ClassType for UIViewController {
-        #[inherits(NSObject)]
-        type Super = UIResponder;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIViewController {
-        #[method(attemptRotationToDeviceOrientation)]
-        pub fn attemptRotationToDeviceOrientation();
-
-        #[method(setNeedsStatusBarAppearanceUpdate)]
-        pub fn setNeedsStatusBarAppearanceUpdate(&self);
-
-        #[method(setNeedsUpdateOfHomeIndicatorAutoHidden)]
-        pub fn setNeedsUpdateOfHomeIndicatorAutoHidden(&self);
-
-        #[method(setNeedsUpdateOfScreenEdgesDeferringSystemGestures)]
-        pub fn setNeedsUpdateOfScreenEdgesDeferringSystemGestures(&self);
-
-        pub fn view(&self) -> Option<Id<UIView>> {
-            unsafe { msg_send_id![self, view] }
-        }
-
-        #[method(setView:)]
-        pub fn setView(&self, view: Option<&UIView>);
-    }
-);
-
-bitflags::bitflags! {
-    #[derive(Clone, Copy)]
-    pub struct UIInterfaceOrientationMask: NSUInteger {
-        const Portrait = 1 << 1;
-        const PortraitUpsideDown = 1 << 2;
-        const LandscapeRight = 1 << 3;
-        const LandscapeLeft = 1 << 4;
-        const Landscape = Self::LandscapeLeft.bits() | Self::LandscapeRight.bits();
-        const AllButUpsideDown = Self::Landscape.bits() | Self::Portrait.bits();
-        const All = Self::AllButUpsideDown.bits() | Self::PortraitUpsideDown.bits();
-    }
-}
-
-unsafe impl Encode for UIInterfaceOrientationMask {
-    const ENCODING: Encoding = NSUInteger::ENCODING;
-}

src/platform_impl/ios/uikit/window.rs

@@ -1,36 +0,0 @@
-use icrate::Foundation::NSObject;
-use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
-
-use super::{UIResponder, UIScreen, UIView};
-
-extern_class!(
-    #[derive(Debug, PartialEq, Eq, Hash)]
-    pub(crate) struct UIWindow;
-
-    unsafe impl ClassType for UIWindow {
-        #[inherits(UIResponder, NSObject)]
-        type Super = UIView;
-        type Mutability = mutability::InteriorMutable;
-    }
-);
-
-extern_methods!(
-    unsafe impl UIWindow {
-        pub fn screen(&self) -> Id<UIScreen> {
-            unsafe { msg_send_id![self, screen] }
-        }
-
-        #[method(setScreen:)]
-        pub fn setScreen(&self, screen: &UIScreen);
-
-        #[method(setHidden:)]
-        pub fn setHidden(&self, flag: bool);
-
-        #[method(makeKeyAndVisible)]
-        pub fn makeKeyAndVisible(&self);
-
-        #[method(isKeyWindow)]
-        pub fn isKeyWindow(&self) -> bool;
-    }
-);

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

@@ -6,8 +6,7 @@ use std::ops::Deref;
 use std::os::unix::ffi::OsStringExt;
 use std::ptr::NonNull;
 
-use super::XkbContext;
-use super::XKBCH;
+use super::{XkbContext, XKBCH};
 use smol_str::SmolStr;
 use xkbcommon_dl::{
     xkb_compose_compile_flags, xkb_compose_feed_result, xkb_compose_state, xkb_compose_state_flags,
@@ -91,7 +90,7 @@ impl XkbComposeState {
             xkb_compose_feed_result::XKB_COMPOSE_FEED_IGNORED => ComposeStatus::Ignored,
             xkb_compose_feed_result::XKB_COMPOSE_FEED_ACCEPTED => {
                 ComposeStatus::Accepted(self.status())
-            }
+            },
         }
     }
 

src/platform_impl/linux/common/xkb/keymap.rs

@@ -296,7 +296,7 @@ pub fn physicalkey_to_scancode(key: PhysicalKey) -> Option<u32> {
                 NativeKeyCode::Xkb(raw) => Some(raw),
                 _ => None,
             };
-        }
+        },
     };
 
     match code {
@@ -627,7 +627,6 @@ pub fn keysym_to_key(keysym: u32) -> Key {
         // keysyms::ISO_First_Group_Lock => NamedKey::GroupFirstLock,
         keysyms::ISO_Last_Group => NamedKey::GroupLast,
         // keysyms::ISO_Last_Group_Lock => NamedKey::GroupLastLock,
-        //
         keysyms::ISO_Left_Tab => NamedKey::Tab,
         // keysyms::ISO_Move_Line_Up => NamedKey::IsoMoveLineUp,
         // keysyms::ISO_Move_Line_Down => NamedKey::IsoMoveLineDown,
@@ -809,18 +808,15 @@ pub fn keysym_to_key(keysym: u32) -> Key {
         keysyms::XF86_Music => NamedKey::LaunchMusicPlayer,
 
         // XF86_Battery..XF86_UWB
-        //
         keysyms::XF86_AudioForward => NamedKey::MediaFastForward,
         // XF86_AudioRepeat
         keysyms::XF86_AudioRandomPlay => NamedKey::RandomToggle,
         keysyms::XF86_Subtitle => NamedKey::Subtitle,
         keysyms::XF86_AudioCycleTrack => NamedKey::MediaAudioTrack,
         // XF86_CycleAngle..XF86_Blue
-        //
         keysyms::XF86_Suspend => NamedKey::Standby,
         keysyms::XF86_Hibernate => NamedKey::Hibernate,
         // XF86_TouchpadToggle..XF86_TouchpadOff
-        //
         keysyms::XF86_AudioMute => NamedKey::AudioVolumeMute,
 
         // XF86_Switch_VT_1..XF86_Switch_VT_12
@@ -853,7 +849,6 @@ pub fn keysym_to_key(keysym: u32) -> Key {
         keysyms::SUN_VideoLowerBrightness => NamedKey::BrightnessDown,
         keysyms::SUN_VideoRaiseBrightness => NamedKey::BrightnessUp,
         // SunPowerSwitchShift
-        //
         0 => return Key::Unidentified(NativeKey::Unidentified),
         _ => return Key::Unidentified(NativeKey::Xkb(keysym)),
     })
@@ -968,11 +963,7 @@ impl XkbKeymap {
             mod5: mod_index_for_name(keymap, b"Mod5\0"),
         };
 
-        Self {
-            keymap,
-            _mods_indices: mods_indices,
-            _core_keyboard_id,
-        }
+        Self { keymap, _mods_indices: mods_indices, _core_keyboard_id }
     }
 
     #[cfg(x11_platform)]
@@ -1020,12 +1011,14 @@ impl Drop for XkbKeymap {
 
 impl Deref for XkbKeymap {
     type Target = NonNull<xkb_keymap>;
+
     fn deref(&self) -> &Self::Target {
         &self.keymap
     }
 }
 
 /// Modifier index in the keymap.
+#[cfg_attr(not(x11_platform), allow(dead_code))]
 #[derive(Default, Debug, Clone, Copy)]
 pub struct ModsIndices {
     pub shift: Option<xkb_mod_index_t>,

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

@@ -15,8 +15,7 @@ use xkbcommon_dl::{
 #[cfg(x11_platform)]
 use {x11_dl::xlib_xcb::xcb_connection_t, xkbcommon_dl::x11::xkbcommon_x11_handle};
 
-use crate::event::ElementState;
-use crate::event::KeyEvent;
+use crate::event::{ElementState, KeyEvent};
 use crate::keyboard::{Key, KeyLocation};
 use crate::platform_impl::KeyEventExtra;
 
@@ -143,9 +142,7 @@ impl Context {
     #[cfg(x11_platform)]
     pub fn set_keymap_from_x11(&mut self, xcb: *mut xcb_connection_t) {
         let keymap = XkbKeymap::from_x11_keymap(&self.context, xcb, self.core_keyboard_id);
-        let state = keymap
-            .as_ref()
-            .and_then(|keymap| XkbState::new_x11(xcb, keymap));
+        let state = keymap.as_ref().and_then(|keymap| XkbState::new_x11(xcb, keymap));
         if keymap.is_none() || state.is_none() {
             warn!("failed to update xkb keymap");
         }
@@ -160,13 +157,7 @@ impl Context {
         let compose_state1 = self.compose_state1.as_mut();
         let compose_state2 = self.compose_state2.as_mut();
         let scratch_buffer = &mut self.scratch_buffer;
-        Some(KeyContext {
-            state,
-            keymap,
-            compose_state1,
-            compose_state2,
-            scratch_buffer,
-        })
+        Some(KeyContext { state, keymap, compose_state1, compose_state2, scratch_buffer })
     }
 
     /// Key builder context with the user provided xkb state.
@@ -181,13 +172,7 @@ impl Context {
         let compose_state1 = self.compose_state1.as_mut();
         let compose_state2 = self.compose_state2.as_mut();
         let scratch_buffer = &mut self.scratch_buffer;
-        Some(KeyContext {
-            state,
-            keymap,
-            compose_state1,
-            compose_state2,
-            scratch_buffer,
-        })
+        Some(KeyContext { state, keymap, compose_state1, compose_state2, scratch_buffer })
     }
 }
 
@@ -214,20 +199,9 @@ impl<'a> KeyContext<'a> {
         let (key_without_modifiers, _) = event.key_without_modifiers();
         let text_with_all_modifiers = event.text_with_all_modifiers();
 
-        let platform_specific = KeyEventExtra {
-            text_with_all_modifiers,
-            key_without_modifiers,
-        };
+        let platform_specific = KeyEventExtra { text_with_all_modifiers, key_without_modifiers };
 
-        KeyEvent {
-            physical_key,
-            logical_key,
-            text,
-            location,
-            state,
-            repeat,
-            platform_specific,
-        }
+        KeyEvent { physical_key, logical_key, text, location, state, repeat, platform_specific }
     }
 
     fn keysym_to_utf8_raw(&mut self, keysym: u32) -> Option<SmolStr> {
@@ -246,10 +220,7 @@ impl<'a> KeyContext<'a> {
             } else if bytes_written == -1 {
                 self.scratch_buffer.reserve(8);
             } else {
-                unsafe {
-                    self.scratch_buffer
-                        .set_len(bytes_written.try_into().unwrap())
-                };
+                unsafe { self.scratch_buffer.set_len(bytes_written.try_into().unwrap()) };
                 break;
             }
         }
@@ -281,12 +252,7 @@ impl<'a, 'b> KeyEventResults<'a, 'b> {
             ComposeStatus::None
         };
 
-        KeyEventResults {
-            context,
-            keycode,
-            keysym,
-            compose,
-        }
+        KeyEventResults { context, keycode, keysym, compose }
     }
 
     pub fn key(&mut self) -> (Key, KeyLocation) {
@@ -323,23 +289,18 @@ impl<'a, 'b> KeyEventResults<'a, 'b> {
     }
 
     pub fn key_without_modifiers(&mut self) -> (Key, KeyLocation) {
-        // This will become a pointer to an array which libxkbcommon owns, so we don't need to deallocate it.
+        // This will become a pointer to an array which libxkbcommon owns, so we don't need to
+        // deallocate it.
         let layout = self.context.state.layout(self.keycode);
-        let keysym = self
-            .context
-            .keymap
-            .first_keysym_by_level(layout, self.keycode);
+        let keysym = self.context.keymap.first_keysym_by_level(layout, self.keycode);
 
         match self.keysym_to_key(keysym) {
             Ok((key, location)) => (key, location),
             Err((key, location)) => {
-                let key = self
-                    .context
-                    .keysym_to_utf8_raw(keysym)
-                    .map(Key::Character)
-                    .unwrap_or(key);
+                let key =
+                    self.context.keysym_to_utf8_raw(keysym).map(Key::Character).unwrap_or(key);
                 (key, location)
-            }
+            },
         }
     }
 
@@ -354,8 +315,7 @@ impl<'a, 'b> KeyEventResults<'a, 'b> {
     }
 
     pub fn text(&mut self) -> Option<SmolStr> {
-        self.composed_text()
-            .unwrap_or_else(|_| self.context.keysym_to_utf8_raw(self.keysym))
+        self.composed_text().unwrap_or_else(|_| self.context.keysym_to_utf8_raw(self.keysym))
     }
 
     // The current behaviour makes it so composing a character overrides attempts to input a
@@ -364,10 +324,7 @@ impl<'a, 'b> KeyEventResults<'a, 'b> {
     pub fn text_with_all_modifiers(&mut self) -> Option<SmolStr> {
         match self.composed_text() {
             Ok(text) => text,
-            Err(_) => self
-                .context
-                .state
-                .get_utf8_raw(self.keycode, self.context.scratch_buffer),
+            Err(_) => self.context.state.get_utf8_raw(self.keycode, self.context.scratch_buffer),
         }
     }
 
@@ -377,7 +334,7 @@ impl<'a, 'b> KeyEventResults<'a, 'b> {
                 xkb_compose_status::XKB_COMPOSE_COMPOSED => {
                     let state = self.context.compose_state1.as_mut().unwrap();
                     Ok(state.get_string(self.context.scratch_buffer))
-                }
+                },
                 xkb_compose_status::XKB_COMPOSE_COMPOSING
                 | xkb_compose_status::XKB_COMPOSE_CANCELLED => Ok(None),
                 xkb_compose_status::XKB_COMPOSE_NOTHING => Err(()),
@@ -436,10 +393,7 @@ where
     // The allocated buffer must include space for the null-terminator.
     scratch_buffer.reserve(size + 1);
     unsafe {
-        let written = f(
-            scratch_buffer.as_mut_ptr().cast(),
-            scratch_buffer.capacity(),
-        );
+        let written = f(scratch_buffer.as_mut_ptr().cast(), scratch_buffer.capacity());
         if usize::try_from(written).unwrap() != size {
             // This will likely never happen.
             return None;
@@ -456,10 +410,7 @@ fn byte_slice_to_smol_str(bytes: &[u8]) -> Option<SmolStr> {
     std::str::from_utf8(bytes)
         .map(SmolStr::new)
         .map_err(|e| {
-            tracing::warn!(
-                "UTF-8 received from libxkbcommon ({:?}) was invalid: {e}",
-                bytes
-            )
+            tracing::warn!("UTF-8 received from libxkbcommon ({:?}) was invalid: {e}", bytes)
         })
         .ok()
 }

src/platform_impl/linux/mod.rs

@@ -3,35 +3,32 @@
 #[cfg(all(not(x11_platform), not(wayland_platform)))]
 compile_error!("Please select a feature to build for unix: `x11`, `wayland`");
 
+use std::collections::VecDeque;
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
 use std::sync::Arc;
 use std::time::Duration;
-use std::{collections::VecDeque, env, fmt};
+use std::{env, fmt};
 #[cfg(x11_platform)]
 use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Mutex};
 
+use crate::application::ApplicationHandler;
+use crate::platform::pump_events::PumpStatus;
 #[cfg(x11_platform)]
 use crate::utils::Lazy;
 use smol_str::SmolStr;
 
 #[cfg(x11_platform)]
 use self::x11::{X11Error, XConnection, XError, XNotSupported};
+use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
+use crate::error::{EventLoopError, ExternalError, NotSupportedError, OsError as RootOsError};
+use crate::event_loop::{AsyncRequestSerial, ControlFlow, DeviceEvents};
+use crate::icon::Icon;
+use crate::keyboard::Key;
 #[cfg(x11_platform)]
 use crate::platform::x11::{WindowType as XWindowType, XlibErrorHook};
-use crate::window::{CustomCursor, CustomCursorSource};
-use crate::{
-    dpi::{PhysicalPosition, PhysicalSize, Position, Size},
-    error::{EventLoopError, ExternalError, NotSupportedError, OsError as RootOsError},
-    event_loop::{
-        ActiveEventLoop as RootELW, AsyncRequestSerial, ControlFlow, DeviceEvents, EventLoopClosed,
-    },
-    icon::Icon,
-    keyboard::Key,
-    platform::pump_events::PumpStatus,
-    window::{
-        ActivationToken, Cursor, CursorGrabMode, ImePurpose, ResizeDirection, Theme,
-        UserAttentionType, WindowAttributes, WindowButtons, WindowLevel,
-    },
+use crate::window::{
+    ActivationToken, Cursor, CursorGrabMode, CustomCursor, CustomCursorSource, ImePurpose,
+    ResizeDirection, Theme, UserAttentionType, WindowAttributes, WindowButtons, WindowLevel,
 };
 
 pub(crate) use self::common::xkb::{physicalkey_to_scancode, scancode_to_physicalkey};
@@ -92,6 +89,7 @@ pub struct X11WindowAttributes {
     pub embed_window: Option<x11rb::protocol::xproto::Window>,
 }
 
+#[cfg_attr(not(x11_platform), allow(clippy::derivable_impls))]
 impl Default for PlatformSpecificWindowAttributes {
     fn default() -> Self {
         Self {
@@ -293,11 +291,11 @@ impl Window {
             #[cfg(wayland_platform)]
             ActiveEventLoop::Wayland(ref window_target) => {
                 wayland::Window::new(window_target, attribs).map(Window::Wayland)
-            }
+            },
             #[cfg(x11_platform)]
             ActiveEventLoop::X(ref window_target) => {
                 x11::Window::new(window_target, attribs).map(Window::X)
-            }
+            },
         }
     }
 
@@ -533,6 +531,7 @@ impl Window {
     pub fn focus_window(&self) {
         x11_or_wayland!(match self; Window(w) => w.focus_window())
     }
+
     pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
         x11_or_wayland!(match self; Window(w) => w.request_user_attention(request_type))
     }
@@ -556,17 +555,13 @@ impl Window {
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
         match self {
             #[cfg(x11_platform)]
-            Window::X(ref window) => window
-                .available_monitors()
-                .into_iter()
-                .map(MonitorHandle::X)
-                .collect(),
+            Window::X(ref window) => {
+                window.available_monitors().into_iter().map(MonitorHandle::X).collect()
+            },
             #[cfg(wayland_platform)]
-            Window::Wayland(ref window) => window
-                .available_monitors()
-                .into_iter()
-                .map(MonitorHandle::Wayland)
-                .collect(),
+            Window::Wayland(ref window) => {
+                window.available_monitors().into_iter().map(MonitorHandle::Wayland).collect()
+            },
         }
     }
 
@@ -696,27 +691,22 @@ unsafe extern "C" fn x_error_callback(
     0
 }
 
-pub enum EventLoop<T: 'static> {
+pub enum EventLoop {
     #[cfg(wayland_platform)]
-    Wayland(Box<wayland::EventLoop<T>>),
+    Wayland(Box<wayland::EventLoop>),
     #[cfg(x11_platform)]
-    X(x11::EventLoop<T>),
+    X(x11::EventLoop),
 }
 
-pub enum EventLoopProxy<T: 'static> {
+#[derive(Clone)]
+pub enum EventLoopProxy {
     #[cfg(x11_platform)]
-    X(x11::EventLoopProxy<T>),
+    X(x11::EventLoopProxy),
     #[cfg(wayland_platform)]
-    Wayland(wayland::EventLoopProxy<T>),
+    Wayland(wayland::EventLoopProxy),
 }
 
-impl<T: 'static> Clone for EventLoopProxy<T> {
-    fn clone(&self) -> Self {
-        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.clone(); as EventLoopProxy)
-    }
-}
-
-impl<T: 'static> EventLoop<T> {
+impl EventLoop {
     pub(crate) fn new(
         attributes: &PlatformSpecificEventLoopAttributes,
     ) -> Result<Self, EventLoopError> {
@@ -725,7 +715,8 @@ impl<T: 'static> EventLoop<T> {
                 "Initializing the event loop outside of the main thread is a significant \
                  cross-platform compatibility hazard. If you absolutely need to create an \
                  EventLoop on a different thread, you can use the \
-                 `EventLoopBuilderExtUnix::any_thread` function."
+                 `EventLoopBuilderExtX11::any_thread` or `EventLoopBuilderExtWayland::any_thread` \
+                 functions."
             );
         }
 
@@ -739,12 +730,10 @@ impl<T: 'static> EventLoop<T> {
                 .or_else(|| env::var("WAYLAND_SOCKET").ok())
                 .filter(|var| !var.is_empty())
                 .is_some(),
-            env::var("DISPLAY")
-                .map(|var| !var.is_empty())
-                .unwrap_or(false),
+            env::var("DISPLAY").map(|var| !var.is_empty()).unwrap_or(false),
         ) {
             // User is forcing a backend.
-            (Some(backend), _, _) => backend,
+            (Some(backend), ..) => backend,
             // Wayland is present.
             #[cfg(wayland_platform)]
             (None, true, _) => Backend::Wayland,
@@ -754,14 +743,16 @@ impl<T: 'static> EventLoop<T> {
             // No backend is present.
             (_, wayland_display, x11_display) => {
                 let msg = if wayland_display && !cfg!(wayland_platform) {
-                    "DISPLAY is not set; note: enable the `winit/wayland` feature to support Wayland"
+                    "DISPLAY is not set; note: enable the `winit/wayland` feature to support \
+                     Wayland"
                 } else if x11_display && !cfg!(x11_platform) {
-                    "neither WAYLAND_DISPLAY nor WAYLAND_SOCKET is set; note: enable the `winit/x11` feature to support X11"
+                    "neither WAYLAND_DISPLAY nor WAYLAND_SOCKET is set; note: enable the \
+                     `winit/x11` feature to support X11"
                 } else {
                     "neither WAYLAND_DISPLAY nor WAYLAND_SOCKET nor DISPLAY is set."
                 };
                 return Err(EventLoopError::Os(os_error!(OsError::Misc(msg))));
-            }
+            },
         };
 
         // Create the display based on the backend.
@@ -774,12 +765,12 @@ impl<T: 'static> EventLoop<T> {
     }
 
     #[cfg(wayland_platform)]
-    fn new_wayland_any_thread() -> Result<EventLoop<T>, EventLoopError> {
+    fn new_wayland_any_thread() -> Result<EventLoop, EventLoopError> {
         wayland::EventLoop::new().map(|evlp| EventLoop::Wayland(Box::new(evlp)))
     }
 
     #[cfg(x11_platform)]
-    fn new_x11_any_thread() -> Result<EventLoop<T>, EventLoopError> {
+    fn new_x11_any_thread() -> Result<EventLoop, EventLoopError> {
         let xconn = match X11_BACKEND.lock().unwrap().as_ref() {
             Ok(xconn) => xconn.clone(),
             Err(_) => return Err(EventLoopError::NotSupported(NotSupportedError::new())),
@@ -788,29 +779,37 @@ impl<T: 'static> EventLoop<T> {
         Ok(EventLoop::X(x11::EventLoop::new(xconn)))
     }
 
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+    #[inline]
+    pub fn is_wayland(&self) -> bool {
+        match *self {
+            #[cfg(wayland_platform)]
+            EventLoop::Wayland(_) => true,
+            #[cfg(x11_platform)]
+            _ => false,
+        }
+    }
+
+    pub fn create_proxy(&self) -> EventLoopProxy {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.create_proxy(); as EventLoopProxy)
     }
 
-    pub fn run<F>(mut self, callback: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(crate::event::Event<T>, &RootELW),
-    {
-        self.run_on_demand(callback)
+    pub fn run_app<A: ApplicationHandler>(self, app: &mut A) -> Result<(), EventLoopError> {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app(app))
     }
 
-    pub fn run_on_demand<F>(&mut self, callback: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(crate::event::Event<T>, &RootELW),
-    {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_on_demand(callback))
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.run_app_on_demand(app))
     }
 
-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, callback: F) -> PumpStatus
-    where
-        F: FnMut(crate::event::Event<T>, &RootELW),
-    {
-        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_events(timeout, callback))
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
+        x11_or_wayland!(match self; EventLoop(evlp) => evlp.pump_app_events(timeout, app))
     }
 
     pub fn window_target(&self) -> &crate::event_loop::ActiveEventLoop {
@@ -818,21 +817,21 @@ impl<T: 'static> EventLoop<T> {
     }
 }
 
-impl<T> AsFd for EventLoop<T> {
+impl AsFd for EventLoop {
     fn as_fd(&self) -> BorrowedFd<'_> {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_fd())
     }
 }
 
-impl<T> AsRawFd for EventLoop<T> {
+impl AsRawFd for EventLoop {
     fn as_raw_fd(&self) -> RawFd {
         x11_or_wayland!(match self; EventLoop(evlp) => evlp.as_raw_fd())
     }
 }
 
-impl<T: 'static> EventLoopProxy<T> {
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.send_event(event))
+impl EventLoopProxy {
+    pub fn wake_up(&self) {
+        x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.wake_up())
     }
 }
 
@@ -862,14 +861,13 @@ impl ActiveEventLoop {
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
         match *self {
             #[cfg(wayland_platform)]
-            ActiveEventLoop::Wayland(ref evlp) => evlp
-                .available_monitors()
-                .map(MonitorHandle::Wayland)
-                .collect(),
+            ActiveEventLoop::Wayland(ref evlp) => {
+                evlp.available_monitors().map(MonitorHandle::Wayland).collect()
+            },
             #[cfg(x11_platform)]
             ActiveEventLoop::X(ref evlp) => {
                 evlp.available_monitors().map(MonitorHandle::X).collect()
-            }
+            },
         }
     }
 
@@ -959,7 +957,7 @@ impl OwnedDisplayHandle {
                 xlib_handle.display = xconn.display.cast();
                 xlib_handle.screen = xconn.default_screen_index() as _;
                 xlib_handle.into()
-            }
+            },
 
             #[cfg(wayland_platform)]
             Self::Wayland(conn) => {
@@ -968,7 +966,7 @@ impl OwnedDisplayHandle {
                 let mut wayland_handle = rwh_05::WaylandDisplayHandle::empty();
                 wayland_handle.display = conn.display().id().as_ptr() as *mut _;
                 wayland_handle.into()
-            }
+            },
         }
     }
 
@@ -995,7 +993,7 @@ impl OwnedDisplayHandle {
                     NonNull::new(conn.display().id().as_ptr().cast()).unwrap(),
                 )
                 .into())
-            }
+            },
         }
     }
 }
@@ -1004,9 +1002,7 @@ impl OwnedDisplayHandle {
 /// equates to an infinite timeout, not a zero timeout (so can't just use
 /// `Option::min`)
 fn min_timeout(a: Option<Duration>, b: Option<Duration>) -> Option<Duration> {
-    a.map_or(b, |a_timeout| {
-        b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout)))
-    })
+    a.map_or(b, |a_timeout| b.map_or(Some(a_timeout), |b_timeout| Some(a_timeout.min(b_timeout))))
 }
 
 #[cfg(target_os = "linux")]

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

@@ -5,16 +5,15 @@ use std::io::Result as IOResult;
 use std::marker::PhantomData;
 use std::mem;
 use std::os::unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd};
-use std::rc::Rc;
 use std::sync::atomic::Ordering;
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 
 use sctk::reexports::calloop::Error as CalloopError;
 use sctk::reexports::calloop_wayland_source::WaylandSource;
-use sctk::reexports::client::globals;
-use sctk::reexports::client::{Connection, QueueHandle};
+use sctk::reexports::client::{globals, Connection, QueueHandle};
 
+use crate::application::ApplicationHandler;
 use crate::cursor::OnlyCursorImage;
 use crate::dpi::LogicalSize;
 use crate::error::{EventLoopError, OsError as RootOsError};
@@ -40,7 +39,7 @@ use super::{logical_to_physical_rounded, DeviceId, WaylandError, WindowId};
 type WaylandDispatcher = calloop::Dispatcher<'static, WaylandSource<WinitState>, WinitState>;
 
 /// The Wayland event loop.
-pub struct EventLoop<T: 'static> {
+pub struct EventLoop {
     /// Has `run` or `run_on_demand` been called or a call to `pump_events` that starts the loop
     loop_running: bool,
 
@@ -48,13 +47,8 @@ pub struct EventLoop<T: 'static> {
     compositor_updates: Vec<WindowCompositorUpdate>,
     window_ids: Vec<WindowId>,
 
-    /// Sender of user events.
-    user_events_sender: calloop::channel::Sender<T>,
-
-    // XXX can't remove RefCell out of here, unless we can plumb generics into the `Window`, which
-    // we don't really want, since it'll break public API by a lot.
-    /// Pending events from the user.
-    pending_user_events: Rc<RefCell<Vec<T>>>,
+    /// Event loop proxy
+    event_loop_proxy: EventLoopProxy,
 
     /// The Wayland dispatcher to has raw access to the queue when needed, such as
     /// when creating a new window.
@@ -71,8 +65,8 @@ pub struct EventLoop<T: 'static> {
     event_loop: calloop::EventLoop<'static, WinitState>,
 }
 
-impl<T: 'static> EventLoop<T> {
-    pub fn new() -> Result<EventLoop<T>, EventLoopError> {
+impl EventLoop {
+    pub fn new() -> Result<EventLoop, EventLoopError> {
         macro_rules! map_err {
             ($e:expr, $err:expr) => {
                 $e.map_err(|error| os_error!($err(error).into()))
@@ -81,26 +75,19 @@ impl<T: 'static> EventLoop<T> {
 
         let connection = map_err!(Connection::connect_to_env(), WaylandError::Connection)?;
 
-        let (globals, mut event_queue) = map_err!(
-            globals::registry_queue_init(&connection),
-            WaylandError::Global
-        )?;
+        let (globals, mut event_queue) =
+            map_err!(globals::registry_queue_init(&connection), WaylandError::Global)?;
         let queue_handle = event_queue.handle();
 
-        let event_loop = map_err!(
-            calloop::EventLoop::<WinitState>::try_new(),
-            WaylandError::Calloop
-        )?;
+        let event_loop =
+            map_err!(calloop::EventLoop::<WinitState>::try_new(), WaylandError::Calloop)?;
 
         let mut winit_state = WinitState::new(&globals, &queue_handle, event_loop.handle())
             .map_err(|error| os_error!(error))?;
 
         // NOTE: do a roundtrip after binding the globals to prevent potential
         // races with the server.
-        map_err!(
-            event_queue.roundtrip(&mut winit_state),
-            WaylandError::Dispatch
-        )?;
+        map_err!(event_queue.roundtrip(&mut winit_state), WaylandError::Dispatch)?;
 
         // Register Wayland source.
         let wayland_source = WaylandSource::new(connection.clone(), event_queue);
@@ -117,27 +104,18 @@ impl<T: 'static> EventLoop<T> {
             });
 
         map_err!(
-            event_loop
-                .handle()
-                .register_dispatcher(wayland_dispatcher.clone()),
+            event_loop.handle().register_dispatcher(wayland_dispatcher.clone()),
             WaylandError::Calloop
         )?;
 
         // Setup the user proxy.
-        let pending_user_events = Rc::new(RefCell::new(Vec::new()));
-        let pending_user_events_clone = pending_user_events.clone();
-        let (user_events_sender, user_events_channel) = calloop::channel::channel();
+        let (ping, ping_source) = calloop::ping::make_ping().unwrap();
         let result = event_loop
             .handle()
-            .insert_source(
-                user_events_channel,
-                move |event, _, winit_state: &mut WinitState| {
-                    if let calloop::channel::Event::Msg(msg) = event {
-                        winit_state.dispatched_events = true;
-                        pending_user_events_clone.borrow_mut().push(msg);
-                    }
-                },
-            )
+            .insert_source(ping_source, move |_, _, winit_state: &mut WinitState| {
+                winit_state.dispatched_events = true;
+                winit_state.proxy_wake_up = true;
+            })
             .map_err(|error| error.error);
         map_err!(result, WaylandError::Calloop)?;
 
@@ -150,13 +128,10 @@ impl<T: 'static> EventLoop<T> {
 
         let result = event_loop
             .handle()
-            .insert_source(
-                event_loop_awakener_source,
-                move |_, _, winit_state: &mut WinitState| {
-                    // Mark that we have something to dispatch.
-                    winit_state.dispatched_events = true;
-                },
-            )
+            .insert_source(event_loop_awakener_source, move |_, _, winit_state: &mut WinitState| {
+                // Mark that we have something to dispatch.
+                winit_state.dispatched_events = true;
+            })
             .map_err(|error| error.error);
         map_err!(result, WaylandError::Calloop)?;
 
@@ -177,8 +152,7 @@ impl<T: 'static> EventLoop<T> {
             window_ids: Vec::new(),
             connection,
             wayland_dispatcher,
-            user_events_sender,
-            pending_user_events,
+            event_loop_proxy: EventLoopProxy::new(ping),
             event_loop,
             window_target: RootActiveEventLoop {
                 p: PlatformActiveEventLoop::Wayland(window_target),
@@ -189,21 +163,25 @@ impl<T: 'static> EventLoop<T> {
         Ok(event_loop)
     }
 
-    pub fn run_on_demand<F>(&mut self, mut event_handler: F) -> Result<(), EventLoopError>
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    pub fn run_app<A: ApplicationHandler>(mut self, app: &mut A) -> Result<(), EventLoopError> {
+        self.run_app_on_demand(app)
+    }
+
+    pub fn run_app_on_demand<A: ApplicationHandler>(
+        &mut self,
+        app: &mut A,
+    ) -> Result<(), EventLoopError> {
         let exit = loop {
-            match self.pump_events(None, &mut event_handler) {
+            match self.pump_app_events(None, app) {
                 PumpStatus::Exit(0) => {
                     break Ok(());
-                }
+                },
                 PumpStatus::Exit(code) => {
                     break Err(EventLoopError::ExitFailure(code));
-                }
+                },
                 _ => {
                     continue;
-                }
+                },
             }
         };
 
@@ -216,26 +194,27 @@ impl<T: 'static> EventLoop<T> {
         exit
     }
 
-    pub fn pump_events<F>(&mut self, timeout: Option<Duration>, mut callback: F) -> PumpStatus
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    pub fn pump_app_events<A: ApplicationHandler>(
+        &mut self,
+        timeout: Option<Duration>,
+        app: &mut A,
+    ) -> PumpStatus {
         if !self.loop_running {
             self.loop_running = true;
 
             // Run the initial loop iteration.
-            self.single_iteration(&mut callback, StartCause::Init);
+            self.single_iteration(app, StartCause::Init);
         }
 
         // Consider the possibility that the `StartCause::Init` iteration could
         // request to Exit.
         if !self.exiting() {
-            self.poll_events_with_timeout(timeout, &mut callback);
+            self.poll_events_with_timeout(timeout, app);
         }
         if let Some(code) = self.exit_code() {
             self.loop_running = false;
 
-            callback(Event::LoopExiting, self.window_target());
+            app.exiting(&self.window_target);
 
             PumpStatus::Exit(code)
         } else {
@@ -243,10 +222,11 @@ impl<T: 'static> EventLoop<T> {
         }
     }
 
-    pub fn poll_events_with_timeout<F>(&mut self, mut timeout: Option<Duration>, mut callback: F)
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    pub fn poll_events_with_timeout<A: ApplicationHandler>(
+        &mut self,
+        mut timeout: Option<Duration>,
+        app: &mut A,
+    ) {
         let cause = loop {
             let start = Instant::now();
 
@@ -256,7 +236,7 @@ impl<T: 'static> EventLoop<T> {
                     ControlFlow::Poll => Some(Duration::ZERO),
                     ControlFlow::WaitUntil(wait_deadline) => {
                         Some(wait_deadline.saturating_duration_since(start))
-                    }
+                    },
                 };
                 min_timeout(control_flow_timeout, timeout)
             };
@@ -274,11 +254,12 @@ impl<T: 'static> EventLoop<T> {
 
             if let Err(error) = self.loop_dispatch(timeout) {
                 // NOTE We exit on errors from dispatches, since if we've got protocol error
-                // libwayland-client/wayland-rs will inform us anyway, but crashing downstream is not
-                // really an option. Instead we inform that the event loop got destroyed. We may
-                // communicate an error that something was terminated, but winit doesn't provide us
-                // with an API to do that via some event.
-                // Still, we set the exit code to the error's OS error code, or to 1 if not possible.
+                // libwayland-client/wayland-rs will inform us anyway, but crashing downstream is
+                // not really an option. Instead we inform that the event loop got
+                // destroyed. We may communicate an error that something was
+                // terminated, but winit doesn't provide us with an API to do that
+                // via some event. Still, we set the exit code to the error's OS
+                // error code, or to 1 if not possible.
                 let exit_code = error.raw_os_error().unwrap_or(1);
                 self.set_exit_code(exit_code);
                 return;
@@ -288,23 +269,14 @@ impl<T: 'static> EventLoop<T> {
             // to be considered here
             let cause = match self.control_flow() {
                 ControlFlow::Poll => StartCause::Poll,
-                ControlFlow::Wait => StartCause::WaitCancelled {
-                    start,
-                    requested_resume: None,
-                },
+                ControlFlow::Wait => StartCause::WaitCancelled { start, requested_resume: None },
                 ControlFlow::WaitUntil(deadline) => {
                     if Instant::now() < deadline {
-                        StartCause::WaitCancelled {
-                            start,
-                            requested_resume: Some(deadline),
-                        }
+                        StartCause::WaitCancelled { start, requested_resume: Some(deadline) }
                     } else {
-                        StartCause::ResumeTimeReached {
-                            start,
-                            requested_resume: deadline,
-                        }
+                        StartCause::ResumeTimeReached { start, requested_resume: deadline }
                     }
-                }
+                },
             };
 
             // Reduce spurious wake-ups.
@@ -316,13 +288,10 @@ impl<T: 'static> EventLoop<T> {
             break cause;
         };
 
-        self.single_iteration(&mut callback, cause);
+        self.single_iteration(app, cause);
     }
 
-    fn single_iteration<F>(&mut self, callback: &mut F, cause: StartCause)
-    where
-        F: FnMut(Event<T>, &RootActiveEventLoop),
-    {
+    fn single_iteration<A: ApplicationHandler>(&mut self, app: &mut A, cause: StartCause) {
         // NOTE currently just indented to simplify the diff
 
         // We retain these grow-only scratch buffers as part of the EventLoop
@@ -333,18 +302,17 @@ impl<T: 'static> EventLoop<T> {
         let mut buffer_sink = std::mem::take(&mut self.buffer_sink);
         let mut window_ids = std::mem::take(&mut self.window_ids);
 
-        callback(Event::NewEvents(cause), &self.window_target);
+        app.new_events(&self.window_target, cause);
 
         // NB: For consistency all platforms must emit a 'resumed' event even though Wayland
         // applications don't themselves have a formal suspend/resume lifecycle.
         if cause == StartCause::Init {
-            callback(Event::Resumed, &self.window_target);
+            app.resumed(&self.window_target);
         }
 
-        // Handle pending user events. We don't need back buffer, since we can't dispatch
-        // user events indirectly via callback to the user.
-        for user_event in self.pending_user_events.borrow_mut().drain(..) {
-            callback(Event::UserEvent(user_event), &self.window_target);
+        // Indicate user wake up.
+        if self.with_state(|state| mem::take(&mut state.proxy_wake_up)) {
+            app.proxy_wake_up(&self.window_target);
         }
 
         // Drain the pending compositor updates.
@@ -365,18 +333,13 @@ impl<T: 'static> EventLoop<T> {
                 let old_physical_size = physical_size;
 
                 let new_inner_size = Arc::new(Mutex::new(physical_size));
-                callback(
-                    Event::WindowEvent {
-                        window_id: crate::window::WindowId(window_id),
-                        event: WindowEvent::ScaleFactorChanged {
-                            scale_factor,
-                            inner_size_writer: InnerSizeWriter::new(Arc::downgrade(
-                                &new_inner_size,
-                            )),
-                        },
-                    },
-                    &self.window_target,
-                );
+                let root_window_id = crate::window::WindowId(window_id);
+                let event = WindowEvent::ScaleFactorChanged {
+                    scale_factor,
+                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&new_inner_size)),
+                };
+
+                app.window_event(&self.window_target, root_window_id, event);
 
                 let physical_size = *new_inner_size.lock().unwrap();
                 drop(new_inner_size);
@@ -419,23 +382,14 @@ impl<T: 'static> EventLoop<T> {
                     size
                 });
 
-                callback(
-                    Event::WindowEvent {
-                        window_id: crate::window::WindowId(window_id),
-                        event: WindowEvent::Resized(physical_size),
-                    },
-                    &self.window_target,
-                );
+                let window_id = crate::window::WindowId(window_id);
+                let event = WindowEvent::Resized(physical_size);
+                app.window_event(&self.window_target, window_id, event);
             }
 
             if compositor_update.close_window {
-                callback(
-                    Event::WindowEvent {
-                        window_id: crate::window::WindowId(window_id),
-                        event: WindowEvent::CloseRequested,
-                    },
-                    &self.window_target,
-                );
+                let window_id = crate::window::WindowId(window_id);
+                app.window_event(&self.window_target, window_id, WindowEvent::CloseRequested);
             }
         }
 
@@ -444,8 +398,15 @@ impl<T: 'static> EventLoop<T> {
             buffer_sink.append(&mut state.window_events_sink.lock().unwrap());
         });
         for event in buffer_sink.drain() {
-            let event = event.map_nonuser_event().unwrap();
-            callback(event, &self.window_target);
+            match event {
+                Event::WindowEvent { window_id, event } => {
+                    app.window_event(&self.window_target, window_id, event)
+                },
+                Event::DeviceEvent { device_id, event } => {
+                    app.device_event(&self.window_target, device_id, event)
+                },
+                _ => unreachable!("event which is neither device nor window event."),
+            }
         }
 
         // Handle non-synthetic events.
@@ -453,8 +414,15 @@ impl<T: 'static> EventLoop<T> {
             buffer_sink.append(&mut state.events_sink);
         });
         for event in buffer_sink.drain() {
-            let event = event.map_nonuser_event().unwrap();
-            callback(event, &self.window_target);
+            match event {
+                Event::WindowEvent { window_id, event } => {
+                    app.window_event(&self.window_target, window_id, event)
+                },
+                Event::DeviceEvent { device_id, event } => {
+                    app.device_event(&self.window_target, device_id, event)
+                },
+                _ => unreachable!("event which is neither device nor window event."),
+            }
         }
 
         // Collect the window ids
@@ -471,13 +439,8 @@ impl<T: 'static> EventLoop<T> {
                     return Some(WindowEvent::Destroyed);
                 }
 
-                let mut window = state
-                    .windows
-                    .get_mut()
-                    .get_mut(window_id)
-                    .unwrap()
-                    .lock()
-                    .unwrap();
+                let mut window =
+                    state.windows.get_mut().get_mut(window_id).unwrap().lock().unwrap();
 
                 if window.frame_callback_state() == FrameCallbackState::Requested {
                     return None;
@@ -485,10 +448,8 @@ impl<T: 'static> EventLoop<T> {
 
                 // Reset the frame callbacks state.
                 window.frame_callback_reset();
-                let mut redraw_requested = window_requests
-                    .get(window_id)
-                    .unwrap()
-                    .take_redraw_requested();
+                let mut redraw_requested =
+                    window_requests.get(window_id).unwrap().take_redraw_requested();
 
                 // Redraw the frame while at it.
                 redraw_requested |= window.refresh_frame();
@@ -497,13 +458,8 @@ impl<T: 'static> EventLoop<T> {
             });
 
             if let Some(event) = event {
-                callback(
-                    Event::WindowEvent {
-                        window_id: crate::window::WindowId(*window_id),
-                        event,
-                    },
-                    &self.window_target,
-                );
+                let window_id = crate::window::WindowId(*window_id);
+                app.window_event(&self.window_target, window_id, event);
             }
         }
 
@@ -513,7 +469,7 @@ impl<T: 'static> EventLoop<T> {
         });
 
         // This is always the last event we dispatch before poll again
-        callback(Event::AboutToWait, &self.window_target);
+        app.about_to_wait(&self.window_target);
 
         // Update the window frames and schedule redraws.
         let mut wake_up = false;
@@ -532,7 +488,7 @@ impl<T: 'static> EventLoop<T> {
                     }
 
                     refresh
-                }
+                },
                 None => false,
             });
         }
@@ -545,7 +501,7 @@ impl<T: 'static> EventLoop<T> {
             match &self.window_target.p {
                 PlatformActiveEventLoop::Wayland(window_target) => {
                     window_target.event_loop_awakener.ping();
-                }
+                },
                 #[cfg(x11_platform)]
                 PlatformActiveEventLoop::X(_) => unreachable!(),
             }
@@ -557,8 +513,8 @@ impl<T: 'static> EventLoop<T> {
     }
 
     #[inline]
-    pub fn create_proxy(&self) -> EventLoopProxy<T> {
-        EventLoopProxy::new(self.user_events_sender.clone())
+    pub fn create_proxy(&self) -> EventLoopProxy {
+        self.event_loop_proxy.clone()
     }
 
     #[inline]
@@ -599,9 +555,7 @@ impl<T: 'static> EventLoop<T> {
         let mut wayland_source = self.wayland_dispatcher.as_source_mut();
         let event_queue = wayland_source.queue();
         event_queue.roundtrip(state).map_err(|error| {
-            os_error!(OsError::WaylandError(Arc::new(WaylandError::Dispatch(
-                error
-            ))))
+            os_error!(OsError::WaylandError(Arc::new(WaylandError::Dispatch(error))))
         })
     }
 
@@ -622,13 +576,13 @@ impl<T: 'static> EventLoop<T> {
     }
 }
 
-impl<T> AsFd for EventLoop<T> {
+impl AsFd for EventLoop {
     fn as_fd(&self) -> BorrowedFd<'_> {
         self.event_loop.as_fd()
     }
 }
 
-impl<T> AsRawFd for EventLoop<T> {
+impl AsRawFd for EventLoop {
     fn as_raw_fd(&self) -> RawFd {
         self.event_loop.as_raw_fd()
     }

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

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

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

@@ -12,7 +12,7 @@ use super::{DeviceId, WindowId};
 /// to the winit's user.
 #[derive(Default)]
 pub struct EventSink {
-    pub window_events: Vec<Event<()>>,
+    pub(crate) window_events: Vec<Event>,
 }
 
 impl EventSink {
@@ -38,10 +38,7 @@ impl EventSink {
     /// Add new window event to a queue.
     #[inline]
     pub fn push_window_event(&mut self, event: WindowEvent, window_id: WindowId) {
-        self.window_events.push(Event::WindowEvent {
-            event,
-            window_id: RootWindowId(window_id),
-        });
+        self.window_events.push(Event::WindowEvent { event, window_id: RootWindowId(window_id) });
     }
 
     #[inline]
@@ -50,7 +47,7 @@ impl EventSink {
     }
 
     #[inline]
-    pub fn drain(&mut self) -> Drain<'_, Event<()>> {
+    pub(crate) fn drain(&mut self) -> Drain<'_, Event> {
         self.window_events.drain(..)
     }
 }

src/platform_impl/linux/wayland/mod.rs

@@ -1,5 +1,3 @@
-#![cfg(wayland_platform)]
-
 //! Winit's Wayland backend.
 
 use std::fmt::Display;