Winit version 0.28.3

* Use a weak reference from WinitView to WinitWindow

* Allow patched objc2 version

* Add changelog entry

.cargo/config.toml

@@ -0,0 +1,2 @@
+[alias]
+run-wasm = ["run", "--release", "--package", "run-wasm", "--"]

.gitattributes

@@ -20,5 +20,3 @@
 *.PDF	 diff=astextplain
 *.rtf	 diff=astextplain
 *.RTF	 diff=astextplain
-
-/CHANGELOG.md merge=union

.github/CODEOWNERS

@@ -0,0 +1,40 @@
+# Core maintainers:
+# - @msiglreith
+# - @kchibisov
+# - @madsmtm
+# - @maroider
+
+# Android
+/src/platform/android.rs            @msiglreith
+/src/platform_impl/android          @msiglreith
+
+# iOS
+/src/platform/ios.rs                @madsmtm
+/src/platform_impl/ios              @madsmtm
+
+# Unix
+/src/platform_impl/linux/mod.rs     @kchibisov
+
+# Wayland
+/src/platform/wayland.rs            @kchibisov
+/src/platform_impl/linux/wayland    @kchibisov
+
+# X11
+/src/platform/x11.rs                @kchibisov
+/src/platform_impl/linux/x11        @kchibisov
+
+# macOS
+/src/platform/macos.rs              @madsmtm
+/src/platform_impl/macos            @madsmtm
+
+# Web (no maintainer)
+/src/platform/web.rs
+/src/platform_impl/web
+
+# Windows
+/src/platform/windows.rs            @msiglreith
+/src/platform_impl/windows          @msiglreith
+
+# Orbital (Redox OS)
+/src/platform/orbital.rs            @jackpot51
+/src/platform_impl/orbital          @jackpot51

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,6 +1,4 @@
 - [ ] Tested on all platforms changed
-- [ ] Compilation warnings were addressed
-- [ ] `cargo fmt` has been run on this branch
 - [ ] Added an entry to `CHANGELOG.md` if knowledge of this change could be valuable to users
 - [ ] Updated documentation to reflect any user-facing changes, including notes of platform-specific behavior
 - [ ] Created or updated an example program if it would help users understand this functionality

.github/workflows/ci.yml

@@ -0,0 +1,121 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [master]
+
+jobs:
+  Check_Formatting:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: hecrj/setup-rust-action@v1
+      with:
+        rust-version: stable
+        components: rustfmt
+    - name: Check Formatting
+      run: cargo +stable fmt --all -- --check
+
+  tests:
+    name: Tests
+    strategy:
+      fail-fast: false
+      matrix:
+        rust_version: ['1.60.0', stable, nightly]
+        platform:
+          # Note: Make sure that we test all the `docs.rs` targets defined in Cargo.toml!
+          - { target: x86_64-pc-windows-msvc,   os: windows-latest,  }
+          - { target: i686-pc-windows-msvc,     os: windows-latest,  }
+          - { target: x86_64-pc-windows-gnu,    os: windows-latest, host: -x86_64-pc-windows-gnu }
+          - { target: i686-pc-windows-gnu,      os: windows-latest, host: -i686-pc-windows-gnu }
+          - { target: i686-unknown-linux-gnu,   os: ubuntu-latest,   }
+          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest,   }
+          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: --no-default-features, features: x11 }
+          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: --no-default-features, features: "wayland,wayland-dlopen" }
+          - { target: aarch64-linux-android,    os: ubuntu-latest, options: -p winit, cmd: 'apk --', features: "android-native-activity" }
+          - { target: x86_64-unknown-redox,     os: ubuntu-latest,   }
+          - { target: x86_64-apple-darwin,      os: macos-latest,    }
+          - { target: x86_64-apple-ios,         os: macos-latest,    }
+          - { target: aarch64-apple-ios,        os: macos-latest,    }
+          # We're using Windows rather than Ubuntu to run the wasm tests because caching cargo-web
+          # doesn't currently work on Linux.
+          - { target: wasm32-unknown-unknown,   os: windows-latest,  }
+
+    env:
+      RUST_BACKTRACE: 1
+      CARGO_INCREMENTAL: 0
+      RUSTFLAGS: "-C debuginfo=0 --deny warnings"
+      OPTIONS: ${{ matrix.platform.options }}
+      FEATURES: ${{ format(',{0}', matrix.platform.features ) }}
+      CMD: ${{ matrix.platform.cmd }}
+      RUSTDOCFLAGS: -Dwarnings
+
+    runs-on: ${{ matrix.platform.os }}
+    steps:
+    - uses: actions/checkout@v2
+    # Used to cache cargo-web
+    - name: Cache cargo folder
+      uses: actions/cache@v1
+      with:
+        path: ~/.cargo
+        key: ${{ matrix.platform.target }}-cargo-${{ matrix.rust_version }}
+
+    - uses: hecrj/setup-rust-action@v1
+      with:
+        rust-version: ${{ matrix.rust_version }}${{ matrix.platform.host }}
+        targets: ${{ matrix.platform.target }}
+        components: clippy
+
+    - name: Install GCC Multilib
+      if: (matrix.platform.os == 'ubuntu-latest') && contains(matrix.platform.target, 'i686')
+      run: sudo apt-get update && sudo apt-get install gcc-multilib
+    - name: Install cargo-apk
+      if: contains(matrix.platform.target, 'android')
+      run: cargo install cargo-apk
+
+    - name: Check documentation
+      shell: bash
+      run: cargo doc --no-deps --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES --document-private-items
+
+    - name: Build crate
+      shell: bash
+      run: cargo $CMD build --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
+
+    - name: Build tests
+      shell: bash
+      if: >
+        !contains(matrix.platform.target, 'redox') &&
+        matrix.rust_version != '1.60.0'
+      run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
+
+    - name: Run tests
+      shell: bash
+      if: >
+        !contains(matrix.platform.target, 'android') &&
+        !contains(matrix.platform.target, 'ios') &&
+        !contains(matrix.platform.target, 'wasm32') &&
+        !contains(matrix.platform.target, 'redox') &&
+        matrix.rust_version != '1.60.0'
+      run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
+
+    - name: Lint with clippy
+      shell: bash
+      if: (matrix.rust_version == 'stable') && !contains(matrix.platform.options, '--no-default-features')
+      run: cargo clippy --all-targets --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES -- -Dwarnings
+
+    - name: Build tests with serde enabled
+      shell: bash
+      if: >
+        !contains(matrix.platform.target, 'redox') &&
+        matrix.rust_version != '1.60.0'
+      run: cargo $CMD test --no-run --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES
+    - name: Run tests with serde enabled
+      shell: bash
+      if: >
+        !contains(matrix.platform.target, 'android') &&
+        !contains(matrix.platform.target, 'ios') &&
+        !contains(matrix.platform.target, 'wasm32') &&
+        !contains(matrix.platform.target, 'redox') &&
+        matrix.rust_version != '1.60.0'
+      run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES

.gitignore

@@ -2,9 +2,9 @@ Cargo.lock
 target/
 rls/
 .vscode/
-util/
 *~
 *.wasm
 *.ts
 *.js
 #*#
+.DS_Store

.travis.yml

@@ -1,102 +0,0 @@
-language: rust
-
-matrix:
-  include:
-    # Linux 32bit
-    - env: TARGET=i686-unknown-linux-gnu
-      os: linux
-      rust: nightly
-      addons:
-        apt:
-          # Cross compiler and cross compiled C libraries
-          packages: &i686_packages
-            - gcc-multilib
-    - env: TARGET=i686-unknown-linux-gnu
-      os: linux
-      rust: stable
-      addons:
-        apt:
-          packages: *i686_packages
-
-    # Linux 64bit
-    - env: TARGET=x86_64-unknown-linux-gnu
-      os: linux
-      rust: nightly
-    - env: TARGET=x86_64-unknown-linux-gnu
-      os: linux
-      rust: stable
-
-    # macOS
-    - env: TARGET=x86_64-apple-darwin
-      os: osx
-      rust: nightly
-    - env: TARGET=x86_64-apple-darwin
-      os: osx
-      rust: stable
-
-    # iOS x86_64
-    - env: TARGET=x86_64-apple-ios
-      os: osx
-      rust: nightly
-    - env: TARGET=x86_64-apple-ios
-      os: osx
-      rust: stable
-
-    # iOS armv7
-    - env: TARGET=armv7-apple-ios
-      os: osx
-      rust: nightly
-    - env: TARGET=armv7-apple-ios
-      os: osx
-      rust: stable
-
-    # iOS arm64
-    - env: TARGET=aarch64-apple-ios
-      os: osx
-      rust: nightly
-    - env: TARGET=aarch64-apple-ios
-      os: osx
-      rust: stable
-
-    # wasm stdweb
-    - env: TARGET=wasm32-unknown-unknown WEB=web FEATURES=stdweb
-      os: linux
-      rust: stable
-    - env: TARGET=wasm32-unknown-unknown WEB=web FEATURES=stdweb
-      os: linux
-      rust: nightly
-    # wasm web-sys
-    - env: TARGET=wasm32-unknown-unknown FEATURES=web-sys
-      os: linux
-      rust: stable
-    - env: TARGET=wasm32-unknown-unknown FEATURES=web-sys
-      os: linux
-      rust: nightly
-
-install:
-  - rustup self update
-  - rustup target add $TARGET; true
-  - rustup toolchain install stable
-  - rustup component add rustfmt --toolchain stable
-
-script:
-  - cargo +stable fmt --all -- --check
-  # Install cargo-web to build stdweb
-  - if [[ $WEB = "web" ]]; then cargo install -f cargo-web; fi
-  # Build without serde then with serde
-  - if [[ -z "$FEATURES" ]]; then
-      cargo $WEB build --target $TARGET --verbose;
-    else
-      cargo $WEB build --target $TARGET --features $FEATURES --verbose;
-    fi
-  - cargo $WEB build --target $TARGET --features serde,$FEATURES --verbose
-  # Running iOS apps on macOS requires the Simulator so we skip that for now
-  # The web targets also don't support running tests
-  - if [[ $TARGET != *-apple-ios && $TARGET != wasm32-* ]]; then cargo test --target $TARGET --verbose; fi
-  - if [[ $TARGET != *-apple-ios && $TARGET != wasm32-* ]]; then cargo test --target $TARGET --features serde --verbose; fi
-
-after_success:
-  - |
-      [ $TRAVIS_BRANCH = master ] &&
-      [ $TRAVIS_PULL_REQUEST = false ] &&
-      cargo publish --token ${CRATESIO_TOKEN}

CHANGELOG.md

@@ -1,5 +1,480 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+Please keep one empty line before and after all headers. (This is required for `git` to produce a conflict when a release is made while a PR is open and the PR's changelog entry would go into the wrong section).
+
+And please only add new entries to the top of this list, right below the `# Unreleased` header.
+
 # Unreleased
 
+# 0.28.3
+
+- Fix macOS memory leaks.
+
+# 0.28.2
+
+- Implement `HasRawDisplayHandle` for `EventLoop`.
+- On macOS, set resize increments only for live resizes.
+- On Wayland, fix rare crash on DPI change
+- Web: Added support for `Window::theme`.
+- On Wayland, fix rounding issues when doing resize.
+- On macOS, fix wrong focused state on startup.
+- On Windows, fix crash on setting taskbar when using Visual Studio debugger.
+- On macOS, resize simple fullscreen windows on windowDidChangeScreen events.
+
+# 0.28.1
+
+- On Wayland, fix crash when dropping a window in multi-window setup.
+
+# 0.28.0
+
+- On macOS, fixed `Ime::Commit` persisting for all input after interacting with `Ime`.
+- On macOS, added `WindowExtMacOS::option_as_alt` and `WindowExtMacOS::set_option_as_alt`.
+- On Windows, fix window size for maximized, undecorated windows.
+- On Windows and macOS, add `WindowBuilder::with_active`.
+- Add `Window::is_minimized`.
+- On X11, fix errors handled during `register_xlib_error_hook` invocation bleeding into winit.
+- Add `Window::has_focus`.
+- On Windows, fix `Window::set_minimized(false)` not working for windows minimized by `Win + D` hotkey.
+- **Breaking:** On Web, touch input no longer fires `WindowEvent::Cursor*`, `WindowEvent::MouseInput`, or `DeviceEvent::MouseMotion` like other platforms, but instead it fires `WindowEvent::Touch`.
+- **Breaking:** Removed platform specific `WindowBuilder::with_parent` API in favor of `WindowBuilder::with_parent_window`.
+- On Windows, retain `WS_MAXIMIZE` window style when un-minimizing a maximized window.
+- On Windows, fix left mouse button release event not being sent after `Window::drag_window`.
+- On macOS, run most actions on the main thread, which is strictly more correct, but might make multithreaded applications block slightly more.
+- On macOS, fix panic when getting current monitor without any monitor attached.
+- On Windows and MacOS, add API to enable/disable window buttons (close, minimize, ...etc).
+- On Windows, macOS, X11 and Wayland, add `Window::set_theme`.
+- **Breaking:** Remove `WindowExtWayland::wayland_set_csd_theme` and `WindowBuilderExtX11::with_gtk_theme_variant`.
+- On Windows, revert window background to an empty brush to avoid white flashes when changing scaling.
+- **Breaking:** Removed `Window::set_always_on_top` and related APIs in favor of `Window::set_window_level`.
+- On Windows, MacOS and X11, add always on bottom APIs.
+- On Windows, fix the value in `MouseButton::Other`.
+- On macOS, add `WindowExtMacOS::is_document_edited` and `WindowExtMacOS::set_document_edited` APIs.
+- **Breaking:** Removed `WindowBuilderExtIOS::with_root_view_class`; instead, you should use `[[view layer] addSublayer: ...]` to add an instance of the desired layer class (e.g. `CAEAGLLayer` or `CAMetalLayer`). See `vulkano-win` or `wgpu` for examples of this.
+- On MacOS and Windows, add `Window::set_content_protected`.
+- On MacOS, add `EventLoopBuilderExtMacOS::with_activate_ignoring_other_apps`.
+- On Windows, fix icons specified on `WindowBuilder` not taking effect for windows created after the first one.
+- On Windows and macOS, add `Window::title` to query the current window title.
+- On Windows, fix focusing menubar when pressing `Alt`.
+- On MacOS, made `accepts_first_mouse` configurable.
+- Migrated `WindowBuilderExtUnix::with_resize_increments` to `WindowBuilder`.
+- Added `Window::resize_increments`/`Window::set_resize_increments` to update resize increments at runtime for X11/macOS.
+- macOS/iOS: Use `objc2` instead of `objc` internally.
+- **Breaking:** Bump MSRV from `1.57` to `1.60`.
+- **Breaking:** Split the `platform::unix` module into `platform::x11` and `platform::wayland`. The extension types are similarly renamed.
+- **Breaking:**: Removed deprecated method `platform::unix::WindowExtUnix::is_ready`.
+- Removed `parking_lot` dependency.
+- **Breaking:** On macOS, add support for two-finger touchpad magnification and rotation gestures with new events `WindowEvent::TouchpadMagnify` and `WindowEvent::TouchpadRotate`. Also add support for touchpad smart-magnification gesture with a new event `WindowEvent::SmartMagnify`.
+- **Breaking:** On web, the `WindowBuilderExtWebSys::with_prevent_default` setting (enabled by default), now additionally prevents scrolling of the webpage in mobile browsers, previously it only disabled scrolling on desktop.
+- On Wayland, `wayland-csd-adwaita` now uses `ab_glyph` instead of `crossfont` to render the title for decorations.
+- On Wayland, a new `wayland-csd-adwaita-crossfont` feature was added to use `crossfont` instead of `ab_glyph` for decorations.
+- On Wayland, if not otherwise specified use upstream automatic CSD theme selection.
+- On X11, added `WindowExtX11::with_parent` to create child windows.
+- Added support for `WindowBuilder::with_theme` and `Window::theme` to support per-window dark/light/system theme configuration on macos, windows and wayland.
+- On macOS, added support for `WindowEvent::ThemeChanged`.
+- **Breaking:** Removed `WindowBuilderExtWindows::with_theme` and `WindowBuilderExtWayland::with_wayland_csd_theme` in favour of `WindowBuilder::with_theme`.
+- **Breaking:** Removed `WindowExtWindows::theme` in favour of `Window::theme`.
+- Enabled `doc_auto_cfg` when generating docs on docs.rs for feature labels.
+- **Breaking:** On Android, switched to using [`android-activity`](https://github.com/rib/android-activity) crate as a glue layer instead of [`ndk-glue`](https://github.com/rust-windowing/android-ndk-rs/tree/master/ndk-glue). See [README.md#Android](https://github.com/rust-windowing/winit#Android) for more details. ([#2444](https://github.com/rust-windowing/winit/pull/2444))
+- **Breaking:** Removed support for `raw-window-handle` version `0.4`
+- On Wayland, `RedrawRequested` not emitted during resize.
+- Add a `set_wait_timeout` function to `ControlFlow` to allow waiting for a `Duration`.
+- **Breaking:** Remove the unstable `xlib_xconnection()` function from the private interface.
+- Added Orbital support for Redox OS
+- On X11, added `drag_resize_window` method.
+- Added `Window::set_transparent` to provide a hint about transparency of the window on Wayland and macOS.
+- On macOS, fix the mouse buttons other than left/right/middle being reported as middle.
+- On Wayland, support fractional scaling via the wp-fractional-scale protocol.
+- On web, fix removal of mouse event listeners from the global object upon window distruction.
+- Add WindowAttributes getter to WindowBuilder to allow introspection of default values.
+- Added `Window::set_ime_purpose` for setting the IME purpose, currently implemented on Wayland only.
+
+# 0.27.5
+
+- On Wayland, fix byte offset in `Ime::Preedit` pointing to invalid bytes.
+
+# 0.27.4
+
+- On Windows, emit `ReceivedCharacter` events on system keybindings.
+- On Windows, fixed focus event emission on minimize.
+- On X11, fixed IME crashing during reload.
+
+# 0.27.3
+
+- On Windows, added `WindowExtWindows::set_undecorated_shadow` and `WindowBuilderExtWindows::with_undecorated_shadow` to draw the drop shadow behind a borderless window.
+- On Windows, fixed default window features (ie snap, animations, shake, etc.) when decorations are disabled.
+- On Windows, fixed ALT+Space shortcut to open window menu.
+- On Wayland, fixed `Ime::Preedit` not being sent on IME reset.
+- Fixed unbound version specified for `raw-window-handle` leading to compilation failures.
+- Empty `Ime::Preedit` event will be sent before `Ime::Commit` to help clearing preedit.
+- On X11, fixed IME context picking by querying for supported styles beforehand.
+
+# 0.27.2 (2022-8-12)
+
+- On macOS, fixed touch phase reporting when scrolling.
+- On X11, fix min, max and resize increment hints not persisting for resizable windows (e.g. on DPI change).
+- On Windows, respect min/max inner sizes when creating the window.
+- For backwards compatibility, `Window` now (additionally) implements the old version (`0.4`) of the `HasRawWindowHandle` trait
+- On Windows, added support for `EventLoopWindowTarget::set_device_event_filter`.
+- On Wayland, fix user requested `WindowEvent::RedrawRequested` being delayed by a frame.
+
+# 0.27.1 (2022-07-30)
+
+- The minimum supported Rust version was lowered to `1.57.0` and now explicitly tested.
+- On X11, fix crash on start due to inability to create an IME context without any preedit.
+
+# 0.27.0 (2022-07-26)
+
+- On Windows, fix hiding a maximized window.
+- On Android, `ndk-glue`'s `NativeWindow` lock is now held between `Event::Resumed` and `Event::Suspended`.
+- On Web, added `EventLoopExtWebSys` with a `spawn` method to start the event loop without throwing an exception.
+- Added `WindowEvent::Occluded(bool)`, currently implemented on macOS and X11.
+- On X11, fix events for caps lock key not being sent
+- Build docs on `docs.rs` for iOS and Android as well.
+- **Breaking:** Removed the `WindowAttributes` struct, since all its functionality is accessible from `WindowBuilder`.
+- Added `WindowBuilder::transparent` getter to check if the user set `transparent` attribute.
+- On macOS, Fix emitting `Event::LoopDestroyed` on CMD+Q.
+- On macOS, fixed an issue where having multiple windows would prevent run_return from ever returning.
+- On Wayland, fix bug where the cursor wouldn't hide in GNOME.
+- On macOS, Windows, and Wayland, add `set_cursor_hittest` to let the window ignore mouse events.
+- On Windows, added `WindowExtWindows::set_skip_taskbar` and `WindowBuilderExtWindows::with_skip_taskbar`.
+- On Windows, added `EventLoopBuilderExtWindows::with_msg_hook`.
+- On Windows, remove internally unique DC per window.
+- On macOS, remove the need to call `set_ime_position` after moving the window.
+- Added `Window::is_visible`.
+- Added `Window::is_resizable`.
+- Added `Window::is_decorated`.
+- On X11, fix for repeated event loop iteration when `ControlFlow` was `Wait`
+- On X11, fix scale factor calculation when the only monitor is reconnected
+- On Wayland, report unaccelerated mouse deltas in `DeviceEvent::MouseMotion`.
+- On Web, a focused event is manually generated when a click occurs to emulate behaviour of other backends.
+- **Breaking:** Bump `ndk` version to 0.6, ndk-sys to `v0.3`, `ndk-glue` to `0.6`.
+- Remove no longer needed `WINIT_LINK_COLORSYNC` environment variable.
+- **Breaking:** Rename the `Exit` variant of `ControlFlow` to `ExitWithCode`, which holds a value to control the exit code after running. Add an `Exit` constant which aliases to `ExitWithCode(0)` instead to avoid major breakage. This shouldn't affect most existing programs.
+- Add `EventLoopBuilder`, which allows you to create and tweak the settings of an event loop before creating it.
+- Deprecated `EventLoop::with_user_event`; use `EventLoopBuilder::with_user_event` instead.
+- **Breaking:** Replaced `EventLoopExtMacOS` with `EventLoopBuilderExtMacOS` (which also has renamed methods).
+- **Breaking:** Replaced `EventLoopExtWindows` with `EventLoopBuilderExtWindows` (which also has renamed methods).
+- **Breaking:** Replaced `EventLoopExtUnix` with `EventLoopBuilderExtUnix` (which also has renamed methods).
+- **Breaking:** The platform specific extensions for Windows `winit::platform::windows` have changed. All `HANDLE`-like types e.g. `HWND` and `HMENU` were converted from winapi types or `*mut c_void` to `isize`. This was done to be consistent with the type definitions in windows-sys and to not expose internal dependencies.
+- The internal bindings to the [Windows API](https://docs.microsoft.com/en-us/windows/) were changed from the unofficial [winapi](https://github.com/retep998/winapi-rs) bindings to the official Microsoft [windows-sys](https://github.com/microsoft/windows-rs) bindings.
+- On Wayland, fix polling during consecutive `EventLoop::run_return` invocations.
+- On Windows, fix race issue creating fullscreen windows with `WindowBuilder::with_fullscreen`
+- On Android, `virtual_keycode` for `KeyboardInput` events is now filled in where a suitable match is found.
+- Added helper methods on `ControlFlow` to set its value.
+- On Wayland, fix `TouchPhase::Ended` always reporting the location of the first touch down, unless the compositor
+  sent a cancel or frame event.
+- On iOS, send `RedrawEventsCleared` even if there are no redraw events, consistent with other platforms.
+- **Breaking:** Replaced `Window::with_app_id` and `Window::with_class` with `Window::with_name` on `WindowBuilderExtUnix`.
+- On Wayland, fallback CSD was replaced with proper one:
+  - `WindowBuilderExtUnix::with_wayland_csd_theme` to set color theme in builder.
+  - `WindowExtUnix::wayland_set_csd_theme` to set color theme when creating a window.
+  - `WINIT_WAYLAND_CSD_THEME` env variable was added, it can be used to set "dark"/"light" theme in apps that don't expose theme setting.
+  - `wayland-csd-adwaita` feature that enables proper CSD with title rendering using FreeType system library.
+  - `wayland-csd-adwaita-notitle` feature that enables CSD but without title rendering.
+- On Wayland and X11, fix window not resizing with `Window::set_inner_size` after calling `Window:set_resizable(false)`.
+- On Windows, fix wrong fullscreen monitors being recognized when handling WM_WINDOWPOSCHANGING messages
+- **Breaking:** Added new `WindowEvent::Ime` supported on desktop platforms.
+- Added `Window::set_ime_allowed` supported on desktop platforms.
+- **Breaking:** IME input on desktop platforms won't be received unless it's explicitly allowed via `Window::set_ime_allowed` and new `WindowEvent::Ime` events are handled.
+- On macOS, `WindowEvent::Resized` is now emitted in `frameDidChange` instead of `windowDidResize`.
+- **Breaking:** On X11, device events are now ignored for unfocused windows by default, use `EventLoopWindowTarget::set_device_event_filter` to set the filter level.
+- Implemented `Default` on `EventLoop<()>`.
+- Implemented `Eq` for `Fullscreen`, `Theme`, and `UserAttentionType`.
+- **Breaking:** `Window::set_cursor_grab` now accepts `CursorGrabMode` to control grabbing behavior.
+- On Wayland, add support for `Window::set_cursor_position`.
+- Fix on macOS `WindowBuilder::with_disallow_hidpi`, setting true or false by the user no matter the SO default value.
+- `EventLoopBuilder::build` will now panic when the `EventLoop` is being created more than once.
+- Added `From<u64>` for `WindowId` and `From<WindowId>` for `u64`.
+- Added `MonitorHandle::refresh_rate_millihertz` to get monitor's refresh rate.
+- **Breaking**, Replaced `VideoMode::refresh_rate` with `VideoMode::refresh_rate_millihertz` providing better precision.
+- On Web, add `with_prevent_default` and `with_focusable` to `WindowBuilderExtWebSys` to control whether events should be propagated.
+- On Windows, fix focus events being sent to inactive windows.
+- **Breaking**, update `raw-window-handle` to `v0.5` and implement `HasRawDisplayHandle` for `Window` and `EventLoopWindowTarget`.
+- On X11, add function `register_xlib_error_hook` into `winit::platform::unix` to subscribe for errors comming from Xlib.
+- On Android, upgrade `ndk` and `ndk-glue` dependencies to the recently released `0.7.0`.
+- All platforms can now be relied on to emit a `Resumed` event. Applications are recommended to lazily initialize graphics state and windows on first resume for portability.
+- **Breaking:**: Reverse horizontal scrolling sign in `MouseScrollDelta` to match the direction of vertical scrolling. A positive X value now means moving the content to the right. The meaning of vertical scrolling stays the same: a positive Y value means moving the content down.
+- On MacOS, fix deadlock when calling `set_maximized` from event loop.
+
+# 0.26.1 (2022-01-05)
+
+- Fix linking to the `ColorSync` framework on macOS 10.7, and in newer Rust versions.
+- On Web, implement cursor grabbing through the pointer lock API.
+- On X11, add mappings for numpad comma, numpad enter, numlock and pause.
+- On macOS, fix Pinyin IME input by reverting a change that intended to improve IME.
+- On Windows, fix a crash with transparent windows on Windows 11.
+
+# 0.26.0 (2021-12-01)
+
+- Update `raw-window-handle` to `v0.4`. This is _not_ a breaking change, we still implement `HasRawWindowHandle` from `v0.3`, see [rust-windowing/raw-window-handle#74](https://github.com/rust-windowing/raw-window-handle/pull/74). Note that you might have to run `cargo update -p raw-window-handle` after upgrading.
+- On X11, bump `mio` to 0.8.
+- On Android, fixed `WindowExtAndroid::config` initially returning an empty `Configuration`.
+- On Android, fixed `Window::scale_factor` and `MonitorHandle::scale_factor` initially always returning 1.0.
+- On X11, select an appropriate visual for transparency if is requested
+- On Wayland and X11, fix diagonal window resize cursor orientation.
+- On macOS, drop the event callback before exiting.
+- On Android, implement `Window::request_redraw`
+- **Breaking:** On Web, remove the `stdweb` backend.
+- Added `Window::focus_window`to bring the window to the front and set input focus.
+- On Wayland and X11, implement `is_maximized` method on `Window`.
+- On Windows, prevent ghost window from showing up in the taskbar after either several hours of use or restarting `explorer.exe`.
+- On macOS, fix issue where `ReceivedCharacter` was not being emitted during some key repeat events.
+- On Wayland, load cursor icons `hand2` and `hand1` for `CursorIcon::Hand`.
+- **Breaking:** On Wayland, Theme trait and its support types are dropped.
+- On Wayland, bump `smithay-client-toolkit` to 0.15.1.
+- On Wayland, implement `request_user_attention` with `xdg_activation_v1`.
+- On X11, emit missing `WindowEvent::ScaleFactorChanged` when the only monitor gets reconnected.
+- On X11, if RANDR based scale factor is higher than 20 reset it to 1
+- On Wayland, add an enabled-by-default feature called `wayland-dlopen` so users can opt out of using `dlopen` to load system libraries.
+- **Breaking:** On Android, bump `ndk` and `ndk-glue` to 0.5.
+- On Windows, increase wait timer resolution for more accurate timing when using `WaitUntil`.
+- On macOS, fix native file dialogs hanging the event loop.
+- On Wayland, implement a workaround for wrong configure size when using `xdg_decoration` in `kwin_wayland`
+- On macOS, fix an issue that prevented the menu bar from showing in borderless fullscreen mode.
+- On X11, EINTR while polling for events no longer causes a panic. Instead it will be treated as a spurious wakeup.
+
+# 0.25.0 (2021-05-15)
+
+- **Breaking:** On macOS, replace `WindowBuilderExtMacOS::with_activation_policy` with `EventLoopExtMacOS::set_activation_policy`
+- On macOS, wait with activating the application until the application has initialized.
+- On macOS, fix creating new windows when the application has a main menu.
+- On Windows, fix fractional deltas for mouse wheel device events.
+- On macOS, fix segmentation fault after dropping the main window.
+- On Android, `InputEvent::KeyEvent` is partially implemented providing the key scancode.
+- Added `is_maximized` method to `Window`.
+- On Windows, fix bug where clicking the decoration bar would make the cursor blink.
+- On Windows, fix bug causing newly created windows to erroneously display the "wait" (spinning) cursor.
+- On macOS, wake up the event loop immediately when a redraw is requested.
+- On Windows, change the default window size (1024x768) to match the default on other desktop platforms (800x600).
+- On Windows, fix bug causing mouse capture to not be released.
+- On Windows, fix fullscreen not preserving minimized/maximized state.
+- On Android, unimplemented events are marked as unhandled on the native event loop.
+- On Windows, added `WindowBuilderExtWindows::with_menu` to set a custom menu at window creation time.
+- On Android, bump `ndk` and `ndk-glue` to 0.3: use predefined constants for event `ident`.
+- On macOS, fix objects captured by the event loop closure not being dropped on panic.
+- On Windows, fixed `WindowEvent::ThemeChanged` not properly firing and fixed `Window::theme` returning the wrong theme.
+- On Web, added support for `DeviceEvent::MouseMotion` to listen for relative mouse movements.
+- Added `WindowBuilder::with_position` to allow setting the position of a `Window` on creation. Supported on Windows, macOS and X11.
+- Added `Window::drag_window`. Implemented on Windows, macOS, X11 and Wayland.
+- On X11, bump `mio` to 0.7.
+- On Windows, added `WindowBuilderExtWindows::with_owner_window` to allow creating popup windows.
+- On Windows, added `WindowExtWindows::set_enable` to allow creating modal popup windows.
+- On macOS, emit `RedrawRequested` events immediately while the window is being resized.
+- Implement `Default`, `Hash`, and `Eq` for `LogicalPosition`, `PhysicalPosition`, `LogicalSize`, and `PhysicalSize`.
+- On macOS, initialize the Menu Bar with minimal defaults. (Can be prevented using `enable_default_menu_creation`)
+- On macOS, change the default behavior for first click when the window was unfocused. Now the window becomes focused and then emits a `MouseInput` event on a "first mouse click".
+- Implement mint (math interoperability standard types) conversions (under feature flag `mint`).
+
+# 0.24.0 (2020-12-09)
+
+- On Windows, fix applications not exiting gracefully due to thread_event_target_callback accessing corrupted memory.
+- On Windows, implement `Window::set_ime_position`.
+- **Breaking:** On Windows, Renamed `WindowBuilderExtWindows`'s `is_dark_mode` to `theme`.
+- **Breaking:** On Windows, renamed `WindowBuilderExtWindows::is_dark_mode` to `theme`.
+- On Windows, add `WindowBuilderExtWindows::with_theme` to set a preferred theme.
+- On Windows, fix bug causing message boxes to appear delayed.
+- On Android, calling `WindowEvent::Focused` now works properly instead of always returning false.
+- On Windows, fix Alt-Tab behaviour by removing borderless fullscreen "always on top" flag.
+- On Windows, fix bug preventing windows with transparency enabled from having fully-opaque regions.
+- **Breaking:** On Windows, include prefix byte in scancodes.
+- On Wayland, fix window not being resizeable when using `WindowBuilder::with_min_inner_size`.
+- On Unix, fix cross-compiling to wasm32 without enabling X11 or Wayland.
+- On Windows, fix use-after-free crash during window destruction.
+- On Web, fix `WindowEvent::ReceivedCharacter` never being sent on key input.
+- On macOS, fix compilation when targeting aarch64.
+- On X11, fix `Window::request_redraw` not waking the event loop.
+- On Wayland, the keypad arrow keys are now recognized.
+- **Breaking** Rename `desktop::EventLoopExtDesktop` to `run_return::EventLoopExtRunReturn`.
+- Added `request_user_attention` method to `Window`.
+- **Breaking:** On macOS, removed `WindowExt::request_user_attention`, use `Window::request_user_attention`.
+- **Breaking:** On X11, removed `WindowExt::set_urgent`, use `Window::request_user_attention`.
+- On Wayland, default font size in CSD increased from 11 to 17.
+- On Windows, fix bug causing message boxes to appear delayed.
+- On Android, support multi-touch.
+- On Wayland, extra mouse buttons are not dropped anymore.
+- **Breaking**: `MouseButton::Other` now uses `u16`.
+
+# 0.23.0 (2020-10-02)
+
+- On iOS, fixed support for the "Debug View Heirarchy" feature in Xcode.
+- On all platforms, `available_monitors` and `primary_monitor` are now on `EventLoopWindowTarget` rather than `EventLoop` to list monitors event in the event loop.
+- On Unix, X11 and Wayland are now optional features (enabled by default)
+- On X11, fix deadlock when calling `set_fullscreen_inner`.
+- On Web, prevent the webpage from scrolling when the user is focused on a winit canvas
+- On Web, calling `window.set_cursor_icon` no longer breaks HiDPI scaling
+- On Windows, drag and drop is now optional (enabled by default) and can be disabled with `WindowBuilderExtWindows::with_drag_and_drop(false)`.
+- On Wayland, fix deadlock when calling to `set_inner_size` from a callback.
+- On macOS, add `hide__other_applications` to `EventLoopWindowTarget` via existing `EventLoopWindowTargetExtMacOS` trait. `hide_other_applications` will hide other applications by calling `-[NSApplication hideOtherApplications: nil]`.
+- On android added support for `run_return`.
+- On MacOS, Fixed fullscreen and dialog support for `run_return`.
+- On Windows, fix bug where we'd try to emit `MainEventsCleared` events during nested win32 event loops.
+- On Web, use mouse events if pointer events aren't supported. This affects Safari.
+- On Windows, `set_ime_position` is now a no-op instead of a runtime crash.
+- On Android, `set_fullscreen` is now a no-op instead of a runtime crash.
+- On iOS and Android, `set_inner_size` is now a no-op instead of a runtime crash.
+- On Android, fix `ControlFlow::Poll` not polling the Android event queue.
+- On macOS, add `NSWindow.hasShadow` support.
+- On Web, fix vertical mouse wheel scrolling being inverted.
+- On Web, implement mouse capturing for click-dragging out of the canvas.
+- On Web, fix `ControlFlow::Exit` not properly handled.
+- On Web (web-sys only), send `WindowEvent::ScaleFactorChanged` event when `window.devicePixelRatio` is changed.
+- **Breaking:** On Web, `set_cursor_position` and `set_cursor_grab` will now always return an error.
+- **Breaking:** `PixelDelta` scroll events now return a `PhysicalPosition`.
+- On NetBSD, fixed crash due to incorrect detection of the main thread.
+- **Breaking:** On X11, `-` key is mapped to the `Minus` virtual key code, instead of `Subtract`.
+- On macOS, fix inverted horizontal scroll.
+- **Breaking:** `current_monitor` now returns `Option<MonitorHandle>`.
+- **Breaking:** `primary_monitor` now returns `Option<MonitorHandle>`.
+- On macOS, updated core-* dependencies and cocoa.
+- Bump `parking_lot` to 0.11
+- On Android, bump `ndk`, `ndk-sys` and `ndk-glue` to 0.2. Checkout the new ndk-glue main proc attribute.
+- On iOS, fixed starting the app in landscape where the view still had portrait dimensions.
+- Deprecate the stdweb backend, to be removed in a future release
+- **Breaking:** Prefixed virtual key codes `Add`, `Multiply`, `Divide`, `Decimal`, and `Subtract` with `Numpad`.
+- Added `Asterisk` and `Plus` virtual key codes.
+- On Web (web-sys only), the `Event::LoopDestroyed` event is correctly emitted when leaving the page.
+- On Web, the `WindowEvent::Destroyed` event now gets emitted when a `Window` is dropped.
+- On Web (web-sys only), the event listeners are now removed when a `Window` is dropped or when the event loop is destroyed.
+- On Web, the event handler closure passed to `EventLoop::run` now gets dropped after the event loop is destroyed.
+- **Breaking:** On Web, the canvas element associated to a `Window` is no longer removed from the DOM when the `Window` is dropped.
+- On Web, `WindowEvent::Resized` is now emitted when `Window::set_inner_size` is called.
+- **Breaking:** `Fullscreen` enum now uses `Borderless(Option<MonitorHandle>)` instead of `Borderless(MonitorHandle)` to allow picking the current monitor.
+- On MacOS, fix `WindowEvent::Moved` ignoring the scale factor.
+- On Wayland, add missing virtual keycodes.
+- On Wayland, implement proper `set_cursor_grab`.
+- On Wayland, the cursor will use similar icons if the requested one isn't available.
+- On Wayland, right clicking on client side decorations will request application menu.
+- On Wayland, fix tracking of window size after state changes.
+- On Wayland, fix client side decorations not being hidden properly in fullscreen.
+- On Wayland, fix incorrect size event when entering fullscreen with client side decorations.
+- On Wayland, fix `resizable` attribute not being applied properly on startup.
+- On Wayland, fix disabled repeat rate not being handled.
+- On Wayland, fix decoration buttons not working after tty switch.
+- On Wayland, fix scaling not being applied on output re-enable.
+- On Wayland, fix crash when `XCURSOR_SIZE` is `0`.
+- On Wayland, fix pointer getting created in some cases without pointer capability.
+- On Wayland, on kwin, fix space between window and decorations on startup.
+- **Breaking:** On Wayland, `Theme` trait was reworked.
+- On Wayland, disable maximize button for non-resizable window.
+- On Wayland, added support for `set_ime_position`.
+- On Wayland, fix crash on startup since GNOME 3.37.90.
+- On X11, fix incorrect modifiers state on startup.
+
+# 0.22.2 (2020-05-16)
+
+- Added Clone implementation for 'static events.
+- On Windows, fix window intermittently hanging when `ControlFlow` was set to `Poll`.
+- On Windows, fix `WindowBuilder::with_maximized` being ignored.
+- On Android, minimal platform support.
+- On iOS, touch positions are now properly converted to physical pixels.
+- On macOS, updated core-* dependencies and cocoa
+
+# 0.22.1 (2020-04-16)
+
+- On X11, fix `ResumeTimeReached` being fired too early.
+- On Web, replaced zero timeout for `ControlFlow::Poll` with `requestAnimationFrame`
+- On Web, fix a possible panic during event handling
+- On macOS, fix `EventLoopProxy` leaking memory for every instance.
+
+# 0.22.0 (2020-03-09)
+
+- On Windows, fix minor timing issue in wait_until_time_or_msg
+- On Windows, rework handling of request_redraw() to address panics.
+- On macOS, fix `set_simple_screen` to remember frame excluding title bar.
+- On Wayland, fix coordinates in touch events when scale factor isn't 1.
+- On Wayland, fix color from `close_button_icon_color` not applying.
+- Ignore locale if unsupported by X11 backend
+- On Wayland, Add HiDPI cursor support
+- On Web, add the ability to query "Light" or "Dark" system theme send `ThemeChanged` on change.
+- Fix `Event::to_static` returning `None` for user events.
+- On Wayland, Hide CSD for fullscreen windows.
+- On Windows, ignore spurious mouse move messages.
+- **Breaking:** Move `ModifiersChanged` variant from `DeviceEvent` to `WindowEvent`.
+- On Windows, add `IconExtWindows` trait which exposes creating an `Icon` from an external file or embedded resource
+- Add `BadIcon::OsError` variant for when OS icon functionality fails
+- On Windows, fix crash at startup on systems that do not properly support Windows' Dark Mode
+- Revert On macOS, fix not sending ReceivedCharacter event for specific keys combinations.
+- on macOS, fix incorrect ReceivedCharacter events for some key combinations.
+- **Breaking:** Use `i32` instead of `u32` for position type in `WindowEvent::Moved`.
+- On macOS, a mouse motion event is now generated before every mouse click.
+
+# 0.21.0 (2020-02-04)
+
+- On Windows, fixed "error: linking with `link.exe` failed: exit code: 1120" error on older versions of windows.
+- On macOS, fix set_minimized(true) works only with decorations.
+- On macOS, add `hide_application` to `EventLoopWindowTarget` via a new `EventLoopWindowTargetExtMacOS` trait. `hide_application` will hide the entire application by calling `-[NSApplication hide: nil]`.
+- On macOS, fix not sending ReceivedCharacter event for specific keys combinations.
+- On macOS, fix `CursorMoved` event reporting the cursor position using logical coordinates.
+- On macOS, fix issue where unbundled applications would sometimes open without being focused.
+- On macOS, fix `run_return` does not return unless it receives a message.
+- On Windows, fix bug where `RedrawRequested` would only get emitted every other iteration of the event loop.
+- On X11, fix deadlock on window state when handling certain window events.
+- `WindowBuilder` now implements `Default`.
+- **Breaking:** `WindowEvent::CursorMoved` changed to `f64` units, preserving high-precision data supplied by most backends
+- On Wayland, fix coordinates in mouse events when scale factor isn't 1
+- On Web, add the ability to provide a custom canvas
+- **Breaking:** On Wayland, the `WaylandTheme` struct has been replaced with a `Theme` trait, allowing for extra configuration
+
+# 0.20.0 (2020-01-05)
+
+- On X11, fix `ModifiersChanged` emitting incorrect modifier change events
+- **Breaking**: Overhaul how Winit handles DPI:
+  - Window functions and events now return `PhysicalSize` instead of `LogicalSize`.
+  - Functions that take `Size` or `Position` types can now take either `Logical` or `Physical` types.
+  - `hidpi_factor` has been renamed to `scale_factor`.
+  - `HiDpiFactorChanged` has been renamed to `ScaleFactorChanged`, and lets you control how the OS
+    resizes the window in response to the change.
+  - On X11, deprecate `WINIT_HIDPI_FACTOR` environment variable in favor of `WINIT_X11_SCALE_FACTOR`.
+  - `Size` and `Position` types are now generic over their exact pixel type.
+
+# 0.20.0 Alpha 6 (2020-01-03)
+
+- On macOS, fix `set_cursor_visible` hides cursor outside of window.
+- On macOS, fix `CursorEntered` and `CursorLeft` events fired at old window size.
+- On macOS, fix error when `set_fullscreen` is called during fullscreen transition.
+- On all platforms except mobile and WASM, implement `Window::set_minimized`.
+- On X11, fix `CursorEntered` event being generated for non-winit windows.
+- On macOS, fix crash when starting maximized without decorations.
+- On macOS, fix application not terminating on `run_return`.
+- On Wayland, fix cursor icon updates on window borders when using CSD.
+- On Wayland, under mutter(GNOME Wayland), fix CSD being behind the status bar, when starting window in maximized mode.
+- On Windows, theme the title bar according to whether the system theme is "Light" or "Dark".
+- Added `WindowEvent::ThemeChanged` variant to handle changes to the system theme. Currently only implemented on Windows.
+- **Breaking**: Changes to the `RedrawRequested` event (#1041):
+  - `RedrawRequested` has been moved from `WindowEvent` to `Event`.
+  - `EventsCleared` has been renamed to `MainEventsCleared`.
+  - `RedrawRequested` is now issued only after `MainEventsCleared`.
+  - `RedrawEventsCleared` is issued after each set of `RedrawRequested` events.
+- Implement synthetic window focus key events on Windows.
+- **Breaking**: Change `ModifiersState` to a `bitflags` struct.
+- On Windows, implement `VirtualKeyCode` translation for `LWin` and `RWin`.
+- On Windows, fix closing the last opened window causing `DeviceEvent`s to stop getting emitted.
+- On Windows, fix `Window::set_visible` not setting internal flags correctly. This resulted in some weird behavior.
+- Add `DeviceEvent::ModifiersChanged`.
+  - Deprecate `modifiers` fields in other events in favor of `ModifiersChanged`.
+- On X11, `WINIT_HIDPI_FACTOR` now dominates `Xft.dpi` when picking DPI factor for output.
+- On X11, add special value `randr` for `WINIT_HIDPI_FACTOR` to make winit use self computed DPI factor instead of the one from `Xft.dpi`.
+
+# 0.20.0 Alpha 5 (2019-12-09)
+
+- On macOS, fix application termination on `ControlFlow::Exit`
+- On Windows, fix missing `ReceivedCharacter` events when Alt is held.
+- On macOS, stop emitting private corporate characters in `ReceivedCharacter` events.
+- On X11, fix misreporting DPI factor at startup.
+- On X11, fix events not being reported when using `run_return`.
+- On X11, fix key modifiers being incorrectly reported.
+- On X11, fix window creation hanging when another window is fullscreen.
+- On Windows, fix focusing unfocused windows when switching from fullscreen to windowed.
+- On X11, fix reporting incorrect DPI factor when waking from suspend.
+- Change `EventLoopClosed` to contain the original event.
+- **Breaking**: Add `is_synthetic` field to `WindowEvent` variant `KeyboardInput`,
+  indicating that the event is generated by winit.
+- On X11, generate synthetic key events for keys held when a window gains or loses focus.
+- On X11, issue a `CursorMoved` event when a `Touch` event occurs,
+  as X11 implicitly moves the cursor for such events.
+
 # 0.20.0 Alpha 4 (2019-10-18)
 
 - Add web support via the 'stdweb' or 'web-sys' features
@@ -26,6 +501,7 @@
 - On X11, return dummy monitor data to avoid panicking when no monitors exist.
 - On X11, prevent stealing input focus when creating a new window.
   Only steal input focus when entering fullscreen mode.
+- On Wayland, fixed DeviceEvents for relative mouse movement is not always produced
 - On Wayland, add support for set_cursor_visible and set_cursor_grab.
 - On Wayland, fixed DeviceEvents for relative mouse movement is not always produced.
 - Removed `derivative` crate dependency.
@@ -41,6 +517,8 @@
   - This is because some platforms cannot run the event loop outside the main thread. Preventing this
     reduces the potential for cross-platform compatibility gotchyas.
 - On Windows and Linux X11/Wayland, add platform-specific functions for creating an `EventLoop` outside the main thread.
+- On Wayland, drop resize events identical to the current window size.
+- On Windows, fix window rectangle not getting set correctly on high-DPI systems.
 
 # 0.20.0 Alpha 3 (2019-08-14)
 
@@ -54,7 +532,7 @@
 - `Window::set_fullscreen` now takes `Option<Fullscreen>` where `Fullscreen`
   consists of `Fullscreen::Exclusive(VideoMode)` and
   `Fullscreen::Borderless(MonitorHandle)` variants.
-    - Adds support for exclusive fullscreen mode.
+  - Adds support for exclusive fullscreen mode.
 - On iOS, add support for hiding the home indicator.
 - On iOS, add support for deferring system gestures.
 - On iOS, fix a crash that occurred while acquiring a monitor's name.
@@ -253,7 +731,7 @@ and `WindowEvent::HoveredFile`.
 # Version 0.16.1 (2018-07-02)
 
 - Added logging through `log`. Logging will become more extensive over time.
-- On X11 and Windows, the window's DPI factor is guessed before creating the window. This *greatly* cuts back on unsightly auto-resizing that would occur immediately after window creation.
+- On X11 and Windows, the window's DPI factor is guessed before creating the window. This _greatly_ cuts back on unsightly auto-resizing that would occur immediately after window creation.
 - Fixed X11 backend compilation for environments where `c_char` is unsigned.
 
 # Version 0.16.0 (2018-06-25)
@@ -403,7 +881,7 @@ and `WindowEvent::HoveredFile`.
 
 # Version 0.10.1 (2018-02-05)
 
-*Yanked*
+_Yanked_
 
 # Version 0.10.0 (2017-12-27)
 

CONTRIBUTING.md

@@ -20,12 +20,16 @@ your description of the issue as detailed as possible:
 
 When making a code contribution to winit, before opening your pull request, please make sure that:
 
+- your patch builds with Winit's minimal supported rust version - Rust 1.60.
 - 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 changelog file if the introduced change is relevant to winit users
+- your PR adds an entry to the changelog file if the introduced change is relevant to winit users.
+
+  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.
@@ -34,9 +38,35 @@ Once your PR is open, you can ask for review by a maintainer of your platform. W
 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).
 
+Once your PR is deemed ready, the merging maintainer will take care of resolving conflicts in
+`CHANGELOG.md` (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.
+
 ## Maintainers & Testers
 
-The current [list of testers and contributors](https://github.com/rust-windowing/winit/wiki/Testers-and-Contributors)
-can be found on the Wiki.
+The current maintainers are listed in the [CODEOWNERS](.github/CODEOWNERS) file.
 
-If you are interested in contributing or testing on a platform, please add yourself to that table!
+If you are interested in being pinged when testing is needed for a certain platform, please add yourself to the [Testers and Contributors](https://github.com/rust-windowing/winit/wiki/Testers-and-Contributors) table!
+
+## 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.
+
+To achieve these goals, a new branch is created for every new release. Releases
+and later patch releases are committed and tagged in this branch.
+
+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. In the branch, the version is bumped to `v0.2.0`
+  4. The new commit in the branch is tagged `v0.2.0`
+  5. The version is pushed to crates.io
+  6. A GitHub release is created for the `v0.2.0` tag
+  7. On master, the version is bumped to `0.2.0` and the CHANGELOG is updated
+  
+When doing a patch release the process is similar:
+  1. Initially the version of the latest release is `0.2.0`
+  2. Checkout the `v0.2.x` branch
+  3. Cherry-pick the required non-breaking changes into the `v0.2.x`
+  4. Follow steps 3-7 of the regular release example

Cargo.toml

@@ -1,106 +1,146 @@
 [package]
 name = "winit"
-version = "0.20.0-alpha4"
+version = "0.28.3"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
-edition = "2018"
+edition = "2021"
 keywords = ["windowing"]
 license = "Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/rust-windowing/winit"
 documentation = "https://docs.rs/winit"
 categories = ["gui"]
+rust-version = "1.60.0"
 
 [package.metadata.docs.rs]
 features = ["serde"]
+default-target = "x86_64-unknown-linux-gnu"
+# These are all tested in CI
+targets = [
+    # Windows
+    "i686-pc-windows-msvc",
+    "x86_64-pc-windows-msvc",
+    # macOS
+    "x86_64-apple-darwin",
+    # Unix (X11 & Wayland)
+    "i686-unknown-linux-gnu",
+    "x86_64-unknown-linux-gnu",
+    # iOS
+    "x86_64-apple-ios",
+    # Android
+    "aarch64-linux-android",
+    # WebAssembly
+    "wasm32-unknown-unknown",
+]
+rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
-web-sys = ["web_sys", "wasm-bindgen", "instant/wasm-bindgen"]
-stdweb = ["std_web", "instant/stdweb"]
+default = ["x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
+x11 = ["x11-dl", "mio", "percent-encoding"]
+wayland = ["wayland-client", "wayland-protocols", "sctk", "wayland-commons"]
+wayland-dlopen = ["sctk/dlopen", "wayland-client/dlopen"]
+wayland-csd-adwaita = ["sctk-adwaita", "sctk-adwaita/ab_glyph"]
+wayland-csd-adwaita-crossfont = ["sctk-adwaita", "sctk-adwaita/crossfont"]
+wayland-csd-adwaita-notitle = ["sctk-adwaita"]
+android-native-activity = [ "android-activity/native-activity" ]
+android-game-activity = [ "android-activity/game-activity" ]
+
+[build-dependencies]
+cfg_aliases = "0.1.1"
 
 [dependencies]
-instant = "0.1"
-lazy_static = "1"
-libc = "0.2.64"
+bitflags = "1"
+instant = { version = "0.1", features = ["wasm-bindgen"] }
 log = "0.4"
+mint = { version = "0.5.6", optional = true }
+once_cell = "1.12"
+raw_window_handle = { package = "raw-window-handle", version = "0.5" }
 serde = { version = "1", optional = true, features = ["serde_derive"] }
-raw-window-handle = "0.3"
 
 [dev-dependencies]
-image = "0.21"
-env_logger = "0.5"
+image = { version = "0.24.0", default-features = false, features = ["png"] }
+simple_logger = { version = "2.1.0", default_features = false }
 
-[target.'cfg(target_os = "android")'.dependencies.android_glue]
-version = "0.2"
+[target.'cfg(target_os = "android")'.dependencies]
+# Coordinate the next winit release with android-ndk-rs: https://github.com/rust-windowing/winit/issues/1995
+android-activity = "0.4.0"
+ndk = "0.7.0"
 
-[target.'cfg(target_os = "ios")'.dependencies]
-objc = "0.2.3"
+[target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
+core-foundation = "0.9.3"
+objc2 = ">=0.3.0-beta.3, <0.3.0-beta.4" # Allow `0.3.0-beta.3.patch-leaks`
 
 [target.'cfg(target_os = "macos")'.dependencies]
-cocoa = "0.19.1"
-core-foundation = "0.6"
-core-graphics = "0.17.3"
-dispatch = "0.1.4"
-objc = "0.2.3"
+core-graphics = "0.22.3"
+dispatch = "0.2.0"
 
-[target.'cfg(target_os = "macos")'.dependencies.core-video-sys]
-version = "0.1.3"
-default_features = false
-features = ["display_link"]
-
-[target.'cfg(any(target_os = "ios", target_os = "windows"))'.dependencies]
-bitflags = "1"
-
-[target.'cfg(target_os = "windows")'.dependencies.winapi]
-version = "0.3.6"
+[target.'cfg(target_os = "windows")'.dependencies.windows-sys]
+version = "0.45"
 features = [
-    "combaseapi",
-    "commctrl",
-    "dwmapi",
-    "errhandlingapi",
-    "hidusage",
-    "libloaderapi",
-    "objbase",
-    "ole2",
-    "processthreadsapi",
-    "shellapi",
-    "shellscalingapi",
-    "shobjidl_core",
-    "unknwnbase",
-    "winbase",
-    "windowsx",
-    "winerror",
-    "wingdi",
-    "winnt",
-    "winuser",
+    "Win32_Devices_HumanInterfaceDevice",
+    "Win32_Foundation",
+    "Win32_Globalization",
+    "Win32_Graphics_Dwm",
+    "Win32_Graphics_Gdi",
+    "Win32_Media",
+    "Win32_System_Com_StructuredStorage",
+    "Win32_System_Com",
+    "Win32_System_LibraryLoader",
+    "Win32_System_Ole",
+    "Win32_System_SystemInformation",
+    "Win32_System_SystemServices",
+    "Win32_System_Threading",
+    "Win32_System_WindowsProgramming",
+    "Win32_UI_Accessibility",
+    "Win32_UI_Controls",
+    "Win32_UI_HiDpi",
+    "Win32_UI_Input_Ime",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Input_Pointer",
+    "Win32_UI_Input_Touch",
+    "Win32_UI_Shell",
+    "Win32_UI_TextServices",
+    "Win32_UI_WindowsAndMessaging",
 ]
 
-[target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.dependencies]
-wayland-client = { version = "0.23.0", features = [ "dlopen", "egl", "cursor", "eventloop"] }
-calloop = "0.4.2"
-smithay-client-toolkit = "0.6"
-x11-dl = "2.18.3"
-percent-encoding = "2.0"
+[target.'cfg(all(unix, not(any(target_os = "redox", target_arch = "wasm32", target_os = "android", target_os = "ios", target_os = "macos"))))'.dependencies]
+libc = "0.2.64"
+mio = { version = "0.8", features = ["os-ext"], optional = true }
+percent-encoding = { version = "2.0", optional = true }
+sctk = { package = "smithay-client-toolkit", version = "0.16.0", default_features = false, features = ["calloop"],  optional = true }
+sctk-adwaita = { version = "0.5.1", default_features = false, optional = true }
+wayland-client = { version = "0.29.5", default_features = false,  features = ["use_system_lib"], optional = true }
+wayland-protocols = { version = "0.29.5", features = [ "staging_protocols"], optional = true }
+wayland-commons = { version = "0.29.5", optional = true }
+x11-dl = { version = "2.18.5", optional = true }
 
-[target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", target_os = "windows"))'.dependencies.parking_lot]
-version = "0.9"
+[target.'cfg(target_os = "redox")'.dependencies]
+orbclient = { version = "0.3.42", default-features = false }
+redox_syscall = "0.3"
+
+[target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.build-dependencies]
+wayland-scanner = "0.29.5"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies.web_sys]
 package = "web-sys"
 version = "0.3.22"
-optional = true
 features = [
     'console',
+    "AddEventListenerOptions",
+    'CssStyleDeclaration',
     'BeforeUnloadEvent',
     'Document',
     'DomRect',
     'Element',
     'Event',
+    "EventListenerOptions",
     'EventTarget',
     'FocusEvent',
     'HtmlCanvasElement',
     'HtmlElement',
     'KeyboardEvent',
+    'MediaQueryList',
+    'MediaQueryListEvent',
     'MouseEvent',
     'Node',
     'PointerEvent',
@@ -110,10 +150,12 @@ features = [
 
 [target.'cfg(target_arch = "wasm32")'.dependencies.wasm-bindgen]
 version = "0.2.45"
-optional = true
 
-[target.'cfg(target_arch = "wasm32")'.dependencies.std_web]
-package = "stdweb"
-version = "=0.4.20"
-optional = true
-features = ["experimental_features_which_may_break_on_minor_version_bumps"]
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+console_log = "0.2"
+web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }
+
+[workspace]
+members = [
+    "run-wasm",
+]

FEATURES.md

@@ -1,13 +1,14 @@
 # Winit Scope
 
 Winit aims to expose an interface that abstracts over window creation and input handling, and can
-be used to create both games and applications. It supports the main graphical platforms:
+be used to create both games and applications. It supports the following main graphical platforms:
 - Desktop
-  - Windows
-  - macOS
+  - Windows 7+ (10+ is tested regularly)
+  - macOS 10.7+ (10.14+ is tested regularly)
   - Unix
     - via X11
     - via Wayland
+  - Redox OS, via Orbital
 - Mobile
   - iOS
   - Android
@@ -80,6 +81,7 @@ If your PR makes notable changes to Winit's features, please update this section
 - **Window maximization**: The windows created by winit can be maximized upon creation.
 - **Window maximization toggle**: The windows created by winit can be maximized and unmaximized after
   creation.
+- **Window minimization**: The windows created by winit can be minimized after creation.
 - **Fullscreen**: The windows created by winit can be put into fullscreen mode.
 - **Fullscreen toggle**: The windows created by winit can be switched to and from fullscreen after
   creation.
@@ -99,8 +101,10 @@ If your PR makes notable changes to Winit's features, please update this section
 ### Input Handling
 - **Mouse events**: Generating mouse events associated with pointer motion, click, and scrolling events.
 - **Mouse set location**: Forcibly changing the location of the pointer.
-- **Cursor grab**: Locking the cursor so it cannot exit the client area of a window.
+- **Cursor locking**: Locking the cursor inside the window so it cannot move.
+- **Cursor confining**: Confining the cursor to the window bounds so it cannot leave them.
 - **Cursor icon**: Changing the cursor icon, or hiding the cursor.
+- **Cursor hittest**: Handle or ignore mouse events for a window.
 - **Touch events**: Single-touch events.
 - **Touch pressure**: Touch events contain information about the amount of force being applied.
 - **Multitouch**: Multi-touch events, including cancellation of a gesture.
@@ -108,14 +112,16 @@ If your PR makes notable changes to Winit's features, please update this section
   translating keypresses into UTF-8 characters, handling dead keys and IMEs.
 - **Drag & Drop**: Dragging content into winit, detecting when content enters, drops, or if the drop is cancelled.
 - **Raw Device Events**: Capturing input from input devices without any OS filtering.
-- **Gamepad/Joystick events**: Capturing input from gampads and joysticks.
-- **Device movement events:**: Capturing input from the device gyroscope and accelerometer.
+- **Gamepad/Joystick events**: Capturing input from gamepads and joysticks.
+- **Device movement events**: Capturing input from the device gyroscope and accelerometer.
 
 ## Platform
 ### Windows
 * Setting the taskbar icon
 * Setting the parent window
+* Setting a menu bar
 * `WS_EX_NOREDIRECTIONBITMAP` support
+* Theme the title bar according to Windows 10 Dark Mode setting or set a preferred theme
 
 ### macOS
 * Window activation policy
@@ -124,6 +130,8 @@ If your PR makes notable changes to Winit's features, please update this section
 * Hidden titlebar
 * Hidden titlebar buttons
 * Full-size content view
+* Accepts first mouse
+* Set a preferred theme and get current theme.
 
 ### Unix
 * Window urgency
@@ -131,6 +139,7 @@ If your PR makes notable changes to Winit's features, please update this section
 * X11 Override Redirect Flag
 * GTK Theme Variant
 * Base window size
+* Setting the X11 parent window
 
 ### iOS
 * `winit` has a minimum OS requirement of iOS 8
@@ -143,10 +152,12 @@ If your PR makes notable changes to Winit's features, please update this section
 * Home indicator visibility
 * Status bar visibility
 * Deferrring system gestures
-* Support for custom `UIView` derived class
 * Getting the device idiom
 * Getting the preferred video mode
 
+### Web
+* Get if systems preferred color scheme is "dark"
+
 ## Usability
 * `serde`: Enables serialization/deserialization of certain types with Serde. (Maintainer: @Osspial)
 
@@ -161,58 +172,63 @@ Legend:
 - ❓: Unknown status
 
 ### Windowing
-|Feature                          |Windows|MacOS   |Linux x11   |Linux Wayland  |Android|iOS    |WASM      |
-|-------------------------------- | ----- | ----   | -------    | -----------   | ----- | ----- | -------- |
-|Window initialization            |✔️     |✔️     |▢[#5]      |✔️             |▢[#33]|▢[#33] |✔️        |
-|Providing pointer to init OpenGL |✔️     |✔️     |✔️         |✔️             |✔️     |✔️    |**N/A**|
-|Providing pointer to init Vulkan |✔️     |✔️     |✔️         |✔️             |✔️     |❓     |**N/A**|
-|Window decorations               |✔️     |✔️     |✔️         |▢[#306]        |**N/A**|**N/A**|**N/A**|
-|Window decorations toggle        |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|
-|Window resizing                  |✔️     |▢[#219]|✔️         |▢[#306]        |**N/A**|**N/A**|✔️        |
-|Window resize increments         |❌     |❌     |❌         |❌             |❌    |❌     |**N/A**|
-|Window transparency              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|N/A        |
-|Window maximization              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|
-|Window maximization toggle       |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|
-|Fullscreen                       |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |
-|Fullscreen toggle                |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |
-|Exclusive fullscreen             |✔️     |✔️     |✔️         |**N/A**         |❌    |✔️     |**N/A**|
-|HiDPI support                    |✔️     |✔️     |✔️         |✔️             |▢[#721]|✔️    |**N/A**|
-|Popup windows                    |❌     |❌     |❌         |❌             |❌    |❌     |**N/A**|
+|Feature                          |Windows|MacOS   |Linux x11   |Linux Wayland  |Android|iOS    |WASM      |Redox OS|
+|-------------------------------- | ----- | ----   | -------    | -----------   | ----- | ----- | -------- | ------ |
+|Window initialization            |✔️     |✔️     |▢[#5]      |✔️             |▢[#33]|▢[#33] |✔️        |✔️      |
+|Providing pointer to init OpenGL |✔️     |✔️     |✔️         |✔️             |✔️     |✔️    |**N/A**|✔️      |
+|Providing pointer to init Vulkan |✔️     |✔️     |✔️         |✔️             |✔️     |❓     |**N/A**|**N/A** |
+|Window decorations               |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|✔️      |
+|Window decorations toggle        |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Window resizing                  |✔️     |✔️     |✔️         |✔️        |**N/A**|**N/A**|✔️        |✔️      |
+|Window resize increments         |❌     |✔️     |✔️         |❌             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Window transparency              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|N/A        |✔️      |
+|Window maximization              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Window maximization toggle       |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Window minimization              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|**N/A** |
+|Fullscreen                       |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |**N/A** |
+|Fullscreen toggle                |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |**N/A** |
+|Exclusive fullscreen             |✔️     |✔️     |✔️         |**N/A**         |❌    |✔️     |**N/A**|**N/A** |
+|HiDPI support                    |✔️     |✔️     |✔️         |✔️             |✔️     |✔️    |✔️    |❌      |
+|Popup windows                    |❌     |❌     |❌         |❌             |❌    |❌     |**N/A**|**N/A** |
 
 ### System information
-|Feature          |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS      |WASM      |
-|---------------- | ----- | ---- | ------- | ----------- | ----- | ------- | -------- |
-|Monitor list     |✔️    |✔️    |✔️       |✔️          |**N/A**|✔️       |**N/A**|
-|Video mode query |✔️    |✔️    |✔️       |✔️          |❌     |✔️      |**N/A**|
+|Feature          |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS      |WASM      |Redox OS|
+|---------------- | ----- | ---- | ------- | ----------- | ----- | ------- | -------- | ------ |
+|Monitor list     |✔️    |✔️    |✔️       |✔️          |✔️     |✔️      |**N/A**|❌      |
+|Video mode query |✔️    |✔️    |✔️       |✔️          |✔️     |✔️      |**N/A**|❌      |
 
 ### Input handling
-|Feature                 |Windows   |MacOS   |Linux x11|Linux Wayland|Android|iOS    |WASM      |
-|----------------------- | -----    | ----   | ------- | ----------- | ----- | ----- | -------- |
-|Mouse events            |✔️       |▢[#63]  |✔️       |✔️          |**N/A**|**N/A**|✔️        |
-|Mouse set location      |✔️       |✔️      |✔️       |❓           |**N/A**|**N/A**|**N/A**|
-|Cursor grab             |✔️       |▢[#165] |▢[#242]  |✔️         |**N/A**|**N/A**|❓        |
-|Cursor icon             |✔️       |✔️      |✔️       |✔️           |**N/A**|**N/A**|✔️        |
-|Touch events            |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |✔️        |
-|Touch pressure          |✔️       |❌      |❌       |❌          |❌    |✔️     |✔️        |
-|Multitouch              |✔️       |❌      |✔️       |✔️          |❓     |✔️     |✔️        |
-|Keyboard events         |✔️       |✔️      |✔️       |✔️          |❓     |❌     |✔️        |
-|Drag & Drop             |▢[#720]  |▢[#720] |▢[#720]  |❌[#306]    |**N/A**|**N/A**|❓        |
-|Raw Device Events       |▢[#750]  |▢[#750] |▢[#750]  |❌          |❌    |❌     |❓        |
-|Gamepad/Joystick events |❌[#804] |❌      |❌       |❌          |❌    |❌     |❓        |
-|Device movement events  |❓        |❓       |❓       |❓           |❌    |❌     |❓        |
+|Feature                 |Windows   |MacOS   |Linux x11|Linux Wayland|Android|iOS    |WASM      |Redox OS|
+|----------------------- | -----    | ----   | ------- | ----------- | ----- | ----- | -------- | ------ |
+|Mouse events            |✔️       |▢[#63]  |✔️       |✔️          |**N/A**|**N/A**|✔️        |✔️      |
+|Mouse set location      |✔️       |✔️      |✔️       |✔️(when locked)  |**N/A**|**N/A**|**N/A**|**N/A** |
+|Cursor locking          |❌       |✔️      |❌       |✔️          |**N/A**|**N/A**|✔️        |❌      |
+|Cursor confining        |✔️       |❌      |✔️       |✔️          |**N/A**|**N/A**|❌       |❌      |
+|Cursor icon             |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|✔️        |**N/A** |
+|Cursor hittest          |✔️       |✔️      |❌       |✔️          |**N/A**|**N/A**|❌        |❌      |
+|Touch events            |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |✔️        |**N/A** |
+|Touch pressure          |✔️       |❌      |❌       |❌          |❌    |✔️     |✔️        |**N/A** |
+|Multitouch              |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |❌        |**N/A** |
+|Keyboard events         |✔️       |✔️      |✔️       |✔️          |✔️    |❌     |✔️        |✔️      |
+|Drag & Drop             |▢[#720]  |▢[#720] |▢[#720]  |▢[#720]   |**N/A**|**N/A**|❓        |**N/A** |
+|Raw Device Events       |▢[#750]  |▢[#750] |▢[#750]  |❌          |❌    |❌     |❓        |**N/A** |
+|Gamepad/Joystick events |❌[#804] |❌      |❌       |❌          |❌    |❌     |❓        |**N/A** |
+|Device movement events  |❓        |❓       |❓       |❓           |❌    |❌     |❓        |**N/A** |
+|Drag window with cursor |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|**N/A**   |**N/A** |
+|Resize with cursor      |❌         |❌       |✔️       |❌       |**N/A**|**N/A**|**N/A**   |**N/A** |
 
 ### Pending API Reworks
 Changes in the API that have been agreed upon but aren't implemented across all platforms.
 
-|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |WASM      |
-|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- |
-|New API for HiDPI ([#315] [#319])   |✔️    |✔️    |✔️       |✔️          |▢[#721]|✔️    |❓        |
-|Event Loop 2.0 ([#459])             |✔️    |✔️    |❌       |✔️          |❌     |✔️    |❓        |
-|Keyboard Input ([#812])             |❌    |❌    |❌       |❌          |❌     |❌    |❓        |
+|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |WASM      |Redox OS|
+|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- | ------ |
+|New API for HiDPI ([#315] [#319])   |✔️    |✔️    |✔️       |✔️          |✔️     |✔️    |❓        |❓      |
+|Event Loop 2.0 ([#459])             |✔️    |✔️    |✔️       |✔️          |✔️     |✔️    |❓        |❓      |
+|Keyboard Input ([#812])             |❌    |❌    |❌       |❌          |❌     |❌    |❓        |❓      |
 
 ### Completed API Reworks
-|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |WASM      |
-|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- |
+|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |WASM      |Redox OS|
+|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- | ------ |
 
 [#165]: https://github.com/rust-windowing/winit/issues/165
 [#219]: https://github.com/rust-windowing/winit/issues/219

HALL_OF_CHAMPIONS.md

@@ -1,14 +1,26 @@
 # Hall of Champions
 
-The Winit maintainers would like to recognize the following former Winit
-contributors, without whom Winit would not exist in its current form. We thank
+The winit maintainers would like to recognize the following former winit
+contributors, without whom winit would not exist in its current form. We thank
 them deeply for their time and efforts, and wish them best of luck in their
 future endeavors:
 
-* [@tomaka]: For creating the Winit project and guiding it through its early
+* [@tomaka]: For creating the winit project and guiding it through its early
   years of existence.
+* [@vberger]: For diligently creating the Wayland backend, and being its
+  extremely helpful and benevolent maintainer for years.
 * [@francesca64]: For taking over the responsibility of maintaining almost every
-  Winit backend, and standardizing HiDPI support across all of them
+  winit backend, and standardizing HiDPI support across all of them.
+* [@Osspial]: For heroically landing EventLoop 2.0, and valiantly ushering in a
+  vastly more sustainable era of winit.
+* [@goddessfreya]: For selflessly taking over maintainership of glutin, and her
+  stellar dedication to improving both winit and glutin.
+* [@ArturKovacs]: For consistently maintaining the macOS backend, and his
+  immense involvement in designing and implementing the new keyboard API.
 
 [@tomaka]: https://github.com/tomaka
+[@vberger]: https://github.com/vberger
 [@francesca64]: https://github.com/francesca64
+[@Osspial]: https://github.com/Osspial
+[@goddessfreya]: https://github.com/goddessfreya
+[@ArturKovacs]: https://github.com/ArturKovacs

README.md

@@ -2,12 +2,11 @@
 
 [![Crates.io](https://img.shields.io/crates/v/winit.svg)](https://crates.io/crates/winit)
 [![Docs.rs](https://docs.rs/winit/badge.svg)](https://docs.rs/winit)
-[![Build Status](https://travis-ci.org/rust-windowing/winit.svg?branch=master)](https://travis-ci.org/rust-windowing/winit)
-[![Build status](https://ci.appveyor.com/api/projects/status/hr89but4x1n3dphq/branch/master?svg=true)](https://ci.appveyor.com/project/Osspial/winit/branch/master)
+[![CI Status](https://github.com/rust-windowing/winit/workflows/CI/badge.svg)](https://github.com/rust-windowing/winit/actions)
 
 ```toml
 [dependencies]
-winit = "0.20.0-alpha4"
+winit = "0.28.3"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -20,9 +19,8 @@ For features _outside_ the scope of winit, see [Missing features provided by oth
 
 Join us in any of these:
 
-[![Freenode](https://img.shields.io/badge/freenode.net-%23glutin-red.svg)](http://webchat.freenode.net?channels=%23glutin&uio=MTY9dHJ1ZSYyPXRydWUmND10cnVlJjExPTE4NSYxMj10cnVlJjE1PXRydWU7a)
-[![Matrix](https://img.shields.io/badge/Matrix-%23Glutin%3Amatrix.org-blueviolet.svg)](https://matrix.to/#/#Glutin:matrix.org)
-[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/tomaka/glutin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Matrix](https://img.shields.io/badge/Matrix-%23rust--windowing%3Amatrix.org-blueviolet.svg)](https://matrix.to/#/#rust-windowing:matrix.org)
+[![Libera.Chat](https://img.shields.io/badge/libera.chat-%23winit-red.svg)](https://web.libera.chat/#winit)
 
 ## Usage
 
@@ -46,12 +44,14 @@ fn main() {
     let window = WindowBuilder::new().build(&event_loop).unwrap();
 
     event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
         match event {
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 window_id,
             } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-            _ => *control_flow = ControlFlow::Wait,
+            _ => (),
         }
     });
 }
@@ -63,15 +63,154 @@ Winit is only officially supported on the latest stable version of the Rust comp
 
 Winit provides the following features, which can be enabled in your `Cargo.toml` file:
 * `serde`: Enables serialization/deserialization of certain types with [Serde](https://crates.io/crates/serde).
+* `x11` (enabled by default): On Unix platform, compiles with the X11 backend
+* `wayland` (enabled by default): On Unix platform, compiles with the Wayland backend
+* `mint`: Enables mint (math interoperability standard types) conversions.
 
 ### Platform-specific usage
 
+#### Wayland
+
+Note that windows don't appear on Wayland until you draw/present to them.
+
+`winit` doesn't do drawing, try the examples in [`glutin`] instead.
+
+[`glutin`]: https://github.com/rust-windowing/glutin
+
 #### WebAssembly
 
-Building a binary will yield a `.js` file. In order to use it in an HTML file, you need to:
+To run the web example: `cargo run-wasm --example web`
 
-- Put a `<canvas id="my_id"></canvas>` element somewhere. A canvas corresponds to a winit "window".
-- Write a Javascript code that creates a global variable named `Module`. Set `Module.canvas` to
-  the element of the `<canvas>` element (in the example you would retrieve it via `document.getElementById("my_id")`).
-  More information [here](https://kripken.github.io/emscripten-site/docs/api_reference/module.html).
-- Make sure that you insert the `.js` file generated by Rust after the `Module` variable is created.
+Winit supports compiling to the `wasm32-unknown-unknown` target with `web-sys`.
+
+On the web platform, a Winit window is backed by a `<canvas>` element. You can
+either [provide Winit with a `<canvas>` element][web with_canvas], or [let Winit
+create a `<canvas>` element which you can then retrieve][web canvas getter] and
+insert it into the DOM yourself.
+
+For example code using Winit with WebAssembly, check out the [web example]. For
+information on using Rust on WebAssembly, check out the [Rust and WebAssembly
+book].
+
+[web with_canvas]: https://docs.rs/winit/latest/wasm32-unknown-unknown/winit/platform/web/trait.WindowBuilderExtWebSys.html#tymethod.with_canvas
+[web canvas getter]: https://docs.rs/winit/latest/wasm32-unknown-unknown/winit/platform/web/trait.WindowExtWebSys.html#tymethod.canvas
+[web example]: ./examples/web.rs
+[Rust and WebAssembly book]: https://rustwasm.github.io/book/
+
+#### Android
+
+The Android backend builds on (and exposes types from) the [`ndk`](https://docs.rs/ndk/0.7.0/ndk/) crate.
+
+Native Android applications need some form of "glue" crate that is responsible
+for defining the main entry point for your Rust application as well as tracking
+various life-cycle events and synchronizing with the main JVM thread.
+
+Winit uses the [android-activity](https://github.com/rib/android-activity) as a
+glue crate (prior to `0.28` it used
+[ndk-glue](https://github.com/rust-windowing/android-ndk-rs/tree/master/ndk-glue)).
+
+The version of the glue crate that your application depends on _must_ match the
+version that Winit depends on because the glue crate is responsible for your
+application's main entrypoint. If Cargo resolves multiple versions they will
+clash.
+
+`winit` glue compatibility table:
+
+| winit |       ndk-glue               |
+| :---: | :--------------------------: |
+| 0.28  | `android-activity = "0.4"`   |
+| 0.27  | `ndk-glue = "0.7"`           |
+| 0.26  | `ndk-glue = "0.5"`           |
+| 0.25  | `ndk-glue = "0.3"`           |
+| 0.24  | `ndk-glue = "0.2"`           |
+
+The recommended way to avoid a conflict with the glue version is to avoid explicitly
+depending on the `android-activity` crate, and instead consume the API that
+is re-exported by Winit under `winit::platform::android::activity::*`
+
+Running on an Android device needs a dynamic system library, add this to Cargo.toml:
+
+```toml
+[lib]
+name = "main"
+crate-type = ["cdylib"]
+```
+
+All Android applications are based on an `Activity` subclass and the
+`android-activity` crate is designed to support different choices for this base
+class. Your application _must_ specify the base class it needs via a feature flag:
+
+| Base Class       | Feature Flag      |  Notes  |
+| :--------------: | :---------------: | :-----: |
+| `NativeActivity` | `android-native-activity` | Built-in to Android - it is possible to use without compiling any Java or Kotlin code. Java or Kotlin code may be needed to subclass `NativeActivity` to access some platform features. It does not derive from the [`AndroidAppCompat`] base class.|
+| [`GameActivity`] | `android-game-activity`   | Derives from [`AndroidAppCompat`] which is a defacto standard `Activity` base class that helps support a wider range of Android versions. Requires a build system that can compile Java or Kotlin and fetch Android dependencies from a [Maven repository][agdk_jetpack] (or link with an embedded [release][agdk_releases] of [`GameActivity`]) |
+
+[`GameActivity`]: https://developer.android.com/games/agdk/game-activity
+[`GameTextInput`]: https://developer.android.com/games/agdk/add-support-for-text-input
+[`AndroidAppCompat`]: https://developer.android.com/reference/androidx/appcompat/app/AppCompatActivity
+[agdk_jetpack]: https://developer.android.com/jetpack/androidx/releases/games
+[agdk_releases]: https://developer.android.com/games/agdk/download#agdk-libraries
+[Gradle]: https://developer.android.com/studio/build
+
+For example, add this to Cargo.toml:
+```toml
+winit = { version = "0.28", features = [ "android-native-activity" ] }
+
+[target.'cfg(target_os = "android")'.dependencies]
+android_logger = "0.11.0"
+```
+
+And, for example, define an entry point for your library like this:
+```rust
+#[cfg(target_os = "android")]
+use winit::platform::android::activity::AndroidApp;
+
+#[cfg(target_os = "android")]
+#[no_mangle]
+fn android_main(app: AndroidApp) {
+    use winit::platform::android::EventLoopBuilderExtAndroid;
+
+    android_logger::init_once(android_logger::Config::default().with_min_level(log::Level::Trace));
+
+    let event_loop = EventLoopBuilder::with_user_event()
+        .with_android_app(app)
+        .build();
+    _main(event_loop);
+}
+```
+
+For more details, refer to these `android-activity` [example applications](https://github.com/rib/android-activity/tree/main/examples).
+
+##### Converting from `ndk-glue` to `android-activity`
+
+If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building with `cargo apk` then the minimal changes would be:
+1. Remove `ndk-glue` from your `Cargo.toml`
+2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.28", 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).
+
+#### MacOS
+
+A lot of functionality expects the application to be ready before you start
+doing anything; this includes creating windows, fetching monitors, drawing,
+and so on, see issues [#2238], [#2051] and [#2087].
+
+If you encounter problems, you should try doing your initialization inside
+`Event::NewEvents(StartCause::Init)`.
+
+#### iOS
+
+Similar to macOS, iOS's main `UIApplicationMain` does some init work that's required
+by all UI related code, see issue [#1705]. You should consider creating your windows
+inside `Event::NewEvents(StartCause::Init)`.
+
+
+[#2238]: https://github.com/rust-windowing/winit/issues/2238
+[#2051]: https://github.com/rust-windowing/winit/issues/2051
+[#2087]: https://github.com/rust-windowing/winit/issues/2087
+[#1705]: https://github.com/rust-windowing/winit/issues/1705
+
+#### Redox OS
+
+Redox OS has some functionality not present yet, that will be implemented when
+its orbital display server provides it.

appveyor.yml

@@ -1,34 +0,0 @@
-environment:
-  matrix:
-  - TARGET: x86_64-pc-windows-msvc
-    CHANNEL: stable
-  - TARGET: i686-pc-windows-msvc
-    CHANNEL: stable
-  - TARGET: x86_64-pc-windows-gnu
-    CHANNEL: stable
-  - TARGET: i686-pc-windows-gnu
-    CHANNEL: stable
-  - TARGET: x86_64-pc-windows-msvc
-    CHANNEL: nightly
-  - TARGET: i686-pc-windows-msvc
-    CHANNEL: nightly
-  - TARGET: x86_64-pc-windows-gnu
-    CHANNEL: nightly
-  - TARGET: i686-pc-windows-gnu
-    CHANNEL: nightly
-matrix:
-  allow_failures:
-    - CHANNEL: nightly
-install:
-  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  - rustup-init -yv --default-toolchain %CHANNEL% --default-host %TARGET%
-  - SET PATH=%PATH%;%USERPROFILE%\.cargo\bin
-  - SET PATH=%PATH%;C:\MinGW\bin
-  - rustc -V
-  - cargo -V
-
-build: false
-
-test_script:
-  - cargo test --verbose
-  - cargo test --features serde --verbose

build.rs

@@ -0,0 +1,64 @@
+use cfg_aliases::cfg_aliases;
+
+#[cfg(all(
+    any(
+        target_os = "linux",
+        target_os = "dragonfly",
+        target_os = "freebsd",
+        target_os = "openbsd",
+        target_os = "netbsd",
+    ),
+    feature = "wayland",
+))]
+mod wayland {
+    use std::env;
+    use std::path::PathBuf;
+    use wayland_scanner::Side;
+
+    pub fn main() {
+        let mut path = PathBuf::from(env::var("OUT_DIR").unwrap());
+        path.push("fractional_scale_v1.rs");
+        wayland_scanner::generate_code(
+            "wayland_protocols/fractional-scale-v1.xml",
+            &path,
+            Side::Client,
+        );
+    }
+}
+
+fn main() {
+    // The script doesn't depend on our code
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed=wayland_protocols");
+
+    // Setup cfg aliases
+    cfg_aliases! {
+        // Systems.
+        android_platform: { target_os = "android" },
+        wasm_platform: { target_arch = "wasm32" },
+        macos_platform: { target_os = "macos" },
+        ios_platform: { target_os = "ios" },
+        windows_platform: { target_os = "windows" },
+        apple: { any(target_os = "ios", target_os = "macos") },
+        free_unix: { all(unix, not(apple), not(android_platform)) },
+        redox: { target_os = "redox" },
+
+        // Native displays.
+        x11_platform: { all(feature = "x11", free_unix, not(wasm), not(redox)) },
+        wayland_platform: { all(feature = "wayland", free_unix, not(wasm), not(redox)) },
+        orbital_platform: { redox },
+    }
+
+    // XXX aliases are not available for the build script itself.
+    #[cfg(all(
+        any(
+            target_os = "linux",
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "openbsd",
+            target_os = "netbsd",
+        ),
+        feature = "wayland",
+    ))]
+    wayland::main();
+}

examples/child_window.rs

@@ -0,0 +1,80 @@
+#[cfg(any(x11_platform, macos_platform, windows_platform))]
+fn main() {
+    use std::collections::HashMap;
+
+    use raw_window_handle::HasRawWindowHandle;
+    use winit::{
+        dpi::{LogicalPosition, LogicalSize, Position},
+        event::{ElementState, Event, KeyboardInput, WindowEvent},
+        event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+        window::{Window, WindowBuilder, WindowId},
+    };
+
+    fn spawn_child_window(
+        parent: &Window,
+        event_loop: &EventLoopWindowTarget<()>,
+        windows: &mut HashMap<WindowId, Window>,
+    ) {
+        let parent = parent.raw_window_handle();
+        let mut builder = WindowBuilder::new()
+            .with_title("child window")
+            .with_inner_size(LogicalSize::new(200.0f32, 200.0f32))
+            .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
+            .with_visible(true);
+        // `with_parent_window` is unsafe. Parent window must be a valid window.
+        builder = unsafe { builder.with_parent_window(Some(parent)) };
+        let child_window = builder.build(event_loop).unwrap();
+
+        let id = child_window.id();
+        windows.insert(id, child_window);
+        println!("child window created with id: {id:?}");
+    }
+
+    let mut windows = HashMap::new();
+
+    let event_loop: EventLoop<()> = EventLoop::new();
+    let parent_window = WindowBuilder::new()
+        .with_title("parent window")
+        .with_position(Position::Logical(LogicalPosition::new(0.0, 0.0)))
+        .with_inner_size(LogicalSize::new(640.0f32, 480.0f32))
+        .build(&event_loop)
+        .unwrap();
+
+    println!("parent window: {parent_window:?})");
+
+    event_loop.run(move |event: Event<'_, ()>, event_loop, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        if let Event::WindowEvent { event, window_id } = event {
+            match event {
+                WindowEvent::CloseRequested => {
+                    windows.clear();
+                    *control_flow = ControlFlow::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 arround (200, 200) in parent window.
+                    println!("cursor entered in the window {window_id:?}");
+                }
+                WindowEvent::KeyboardInput {
+                    input:
+                        KeyboardInput {
+                            state: ElementState::Pressed,
+                            ..
+                        },
+                    ..
+                } => {
+                    spawn_child_window(&parent_window, event_loop, &mut windows);
+                }
+                _ => (),
+            }
+        }
+    })
+}
+
+#[cfg(not(any(x11_platform, macos_platform, windows_platform)))]
+fn main() {
+    panic!("This example is supported only on x11, macOS, and Windows.");
+}

examples/control_flow.rs

@@ -0,0 +1,114 @@
+#![allow(clippy::single_match)]
+
+use std::{thread, time};
+
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{Event, KeyboardInput, WindowEvent},
+    event_loop::EventLoop,
+    window::WindowBuilder,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Mode {
+    Wait,
+    WaitUntil,
+    Poll,
+}
+
+const WAIT_TIME: time::Duration = time::Duration::from_millis(100);
+const POLL_SLEEP_TIME: time::Duration = time::Duration::from_millis(100);
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+
+    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.");
+
+    let event_loop = EventLoop::new();
+    let window = WindowBuilder::new()
+        .with_title("Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.")
+        .build(&event_loop)
+        .unwrap();
+
+    let mut mode = Mode::Wait;
+    let mut request_redraw = false;
+    let mut wait_cancelled = false;
+    let mut close_requested = false;
+
+    event_loop.run(move |event, _, control_flow| {
+        use winit::event::{ElementState, StartCause, VirtualKeyCode};
+        println!("{event:?}");
+        match event {
+            Event::NewEvents(start_cause) => {
+                wait_cancelled = match start_cause {
+                    StartCause::WaitCancelled { .. } => mode == Mode::WaitUntil,
+                    _ => false,
+                }
+            }
+            Event::WindowEvent { event, .. } => match event {
+                WindowEvent::CloseRequested => {
+                    close_requested = true;
+                }
+                WindowEvent::KeyboardInput {
+                    input:
+                        KeyboardInput {
+                            virtual_keycode: Some(virtual_code),
+                            state: ElementState::Pressed,
+                            ..
+                        },
+                    ..
+                } => match virtual_code {
+                    VirtualKeyCode::Key1 => {
+                        mode = Mode::Wait;
+                        println!("\nmode: {mode:?}\n");
+                    }
+                    VirtualKeyCode::Key2 => {
+                        mode = Mode::WaitUntil;
+                        println!("\nmode: {mode:?}\n");
+                    }
+                    VirtualKeyCode::Key3 => {
+                        mode = Mode::Poll;
+                        println!("\nmode: {mode:?}\n");
+                    }
+                    VirtualKeyCode::R => {
+                        request_redraw = !request_redraw;
+                        println!("\nrequest_redraw: {request_redraw}\n");
+                    }
+                    VirtualKeyCode::Escape => {
+                        close_requested = true;
+                    }
+                    _ => (),
+                },
+                _ => (),
+            },
+            Event::MainEventsCleared => {
+                if request_redraw && !wait_cancelled && !close_requested {
+                    window.request_redraw();
+                }
+                if close_requested {
+                    control_flow.set_exit();
+                }
+            }
+            Event::RedrawRequested(_window_id) => {}
+            Event::RedrawEventsCleared => {
+                match mode {
+                    Mode::Wait => control_flow.set_wait(),
+                    Mode::WaitUntil => {
+                        if !wait_cancelled {
+                            control_flow.set_wait_until(instant::Instant::now() + WAIT_TIME);
+                        }
+                    }
+                    Mode::Poll => {
+                        thread::sleep(POLL_SLEEP_TIME);
+                        control_flow.set_poll();
+                    }
+                };
+            }
+            _ => (),
+        }
+    });
+}

examples/cursor.rs

@@ -1,10 +1,14 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::{CursorIcon, WindowBuilder},
 };
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new().build(&event_loop).unwrap();
@@ -12,35 +16,38 @@ fn main() {
 
     let mut cursor_idx = 0;
 
-    event_loop.run(move |event, _, control_flow| match event {
-        Event::WindowEvent {
-            event:
-                WindowEvent::KeyboardInput {
-                    input:
-                        KeyboardInput {
-                            state: ElementState::Pressed,
-                            ..
-                        },
-                    ..
-                },
-            ..
-        } => {
-            println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]);
-            window.set_cursor_icon(CURSORS[cursor_idx]);
-            if cursor_idx < CURSORS.len() - 1 {
-                cursor_idx += 1;
-            } else {
-                cursor_idx = 0;
+    event_loop.run(move |event, _, control_flow| {
+        control_flow.set_wait();
+
+        match event {
+            Event::WindowEvent {
+                event:
+                    WindowEvent::KeyboardInput {
+                        input:
+                            KeyboardInput {
+                                state: ElementState::Pressed,
+                                ..
+                            },
+                        ..
+                    },
+                ..
+            } => {
+                println!("Setting cursor to \"{:?}\"", CURSORS[cursor_idx]);
+                window.set_cursor_icon(CURSORS[cursor_idx]);
+                if cursor_idx < CURSORS.len() - 1 {
+                    cursor_idx += 1;
+                } else {
+                    cursor_idx = 0;
+                }
             }
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => {
+                control_flow.set_exit();
+            }
+            _ => (),
         }
-        Event::WindowEvent {
-            event: WindowEvent::CloseRequested,
-            ..
-        } => {
-            *control_flow = ControlFlow::Exit;
-            return;
-        }
-        _ => (),
     });
 }
 

examples/cursor_grab.rs

@@ -1,10 +1,14 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
 use winit::{
-    event::{DeviceEvent, ElementState, Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
+    event::{DeviceEvent, ElementState, Event, KeyboardInput, ModifiersState, WindowEvent},
+    event_loop::EventLoop,
+    window::{CursorGrabMode, WindowBuilder},
 };
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
@@ -12,36 +16,51 @@ fn main() {
         .build(&event_loop)
         .unwrap();
 
+    let mut modifiers = ModifiersState::default();
+
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
+
         match event {
             Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
                     input:
                         KeyboardInput {
                             state: ElementState::Released,
                             virtual_keycode: Some(key),
-                            modifiers,
                             ..
                         },
                     ..
                 } => {
                     use winit::event::VirtualKeyCode::*;
-                    match key {
-                        Escape => *control_flow = ControlFlow::Exit,
-                        G => window.set_cursor_grab(!modifiers.shift).unwrap(),
-                        H => window.set_cursor_visible(modifiers.shift),
-                        _ => (),
+                    let result = match key {
+                        Escape => {
+                            control_flow.set_exit();
+                            Ok(())
+                        }
+                        G => window.set_cursor_grab(CursorGrabMode::Confined),
+                        L => window.set_cursor_grab(CursorGrabMode::Locked),
+                        A => window.set_cursor_grab(CursorGrabMode::None),
+                        H => {
+                            window.set_cursor_visible(modifiers.shift());
+                            Ok(())
+                        }
+                        _ => Ok(()),
+                    };
+
+                    if let Err(err) = result {
+                        println!("error: {err}");
                     }
                 }
+                WindowEvent::ModifiersChanged(m) => modifiers = m,
                 _ => (),
             },
             Event::DeviceEvent { event, .. } => match event {
-                DeviceEvent::MouseMotion { delta } => println!("mouse moved: {:?}", delta),
+                DeviceEvent::MouseMotion { delta } => println!("mouse moved: {delta:?}"),
                 DeviceEvent::Button { button, state } => match state {
-                    ElementState::Pressed => println!("mouse button {} pressed", button),
-                    ElementState::Released => println!("mouse button {} released", button),
+                    ElementState::Pressed => println!("mouse button {button} pressed"),
+                    ElementState::Released => println!("mouse button {button} released"),
                 },
                 _ => (),
             },

examples/custom_events.rs

@@ -1,8 +1,11 @@
-#[cfg(not(target_arch = "wasm32"))]
+#![allow(clippy::single_match)]
+
+#[cfg(not(wasm_platform))]
 fn main() {
+    use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
+        event_loop::EventLoopBuilder,
         window::WindowBuilder,
     };
 
@@ -11,7 +14,8 @@ fn main() {
         Timer,
     }
 
-    let event_loop = EventLoop::<CustomEvent>::with_user_event();
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoopBuilder::<CustomEvent>::with_user_event().build();
 
     let _window = WindowBuilder::new()
         .with_title("A fantastic window!")
@@ -31,17 +35,21 @@ fn main() {
         }
     });
 
-    event_loop.run(move |event, _, control_flow| match event {
-        Event::UserEvent(event) => println!("user event: {:?}", event),
-        Event::WindowEvent {
-            event: WindowEvent::CloseRequested,
-            ..
-        } => *control_flow = ControlFlow::Exit,
-        _ => *control_flow = ControlFlow::Wait,
+    event_loop.run(move |event, _, control_flow| {
+        control_flow.set_wait();
+
+        match event {
+            Event::UserEvent(event) => println!("user event: {event:?}"),
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => control_flow.set_exit(),
+            _ => (),
+        }
     });
 }
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(wasm_platform)]
 fn main() {
     panic!("This example is not supported on web.");
 }

examples/drag_window.rs

@@ -0,0 +1,75 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{
+        ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
+    },
+    event_loop::EventLoop,
+    window::{Window, WindowBuilder, WindowId},
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window_1 = WindowBuilder::new().build(&event_loop).unwrap();
+    let window_2 = WindowBuilder::new().build(&event_loop).unwrap();
+
+    let mut switched = false;
+    let mut entered_id = window_2.id();
+
+    event_loop.run(move |event, _, control_flow| match event {
+        Event::NewEvents(StartCause::Init) => {
+            eprintln!("Switch which window is to be dragged by pressing \"x\".")
+        }
+        Event::WindowEvent { event, window_id } => match event {
+            WindowEvent::CloseRequested => control_flow.set_exit(),
+            WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Left,
+                ..
+            } => {
+                let window = if (window_id == window_1.id() && switched)
+                    || (window_id == window_2.id() && !switched)
+                {
+                    &window_2
+                } else {
+                    &window_1
+                };
+
+                window.drag_window().unwrap()
+            }
+            WindowEvent::CursorEntered { .. } => {
+                entered_id = window_id;
+                name_windows(entered_id, switched, &window_1, &window_2)
+            }
+            WindowEvent::KeyboardInput {
+                input:
+                    KeyboardInput {
+                        state: ElementState::Released,
+                        virtual_keycode: Some(VirtualKeyCode::X),
+                        ..
+                    },
+                ..
+            } => {
+                switched = !switched;
+                name_windows(entered_id, switched, &window_1, &window_2);
+                println!("Switched!")
+            }
+            _ => (),
+        },
+        _ => (),
+    });
+}
+
+fn name_windows(window_id: WindowId, switched: bool, window_1: &Window, window_2: &Window) {
+    let (drag_target, other) =
+        if (window_id == window_1.id() && switched) || (window_id == window_2.id() && !switched) {
+            (&window_2, &window_1)
+        } else {
+            (&window_1, &window_2)
+        };
+    drag_target.set_title("drag target");
+    other.set_title("winit window");
+}

examples/fullscreen.rs

@@ -1,68 +1,117 @@
-use std::io::{stdin, stdout, Write};
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
 use winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent};
-use winit::event_loop::{ControlFlow, EventLoop};
-use winit::monitor::{MonitorHandle, VideoMode};
+use winit::event_loop::EventLoop;
 use winit::window::{Fullscreen, WindowBuilder};
 
+#[cfg(target_os = "macos")]
+use winit::platform::macos::WindowExtMacOS;
+
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
-    print!("Please choose the fullscreen mode: (1) exclusive, (2) borderless: ");
-    stdout().flush().unwrap();
-
-    let mut num = String::new();
-    stdin().read_line(&mut num).unwrap();
-    let num = num.trim().parse().ok().expect("Please enter a number");
-
-    let fullscreen = Some(match num {
-        1 => Fullscreen::Exclusive(prompt_for_video_mode(&prompt_for_monitor(&event_loop))),
-        2 => Fullscreen::Borderless(prompt_for_monitor(&event_loop)),
-        _ => panic!("Please enter a valid number"),
-    });
-
-    let mut is_maximized = false;
     let mut decorations = true;
+    let mut minimized = false;
 
     let window = WindowBuilder::new()
         .with_title("Hello world!")
-        .with_fullscreen(fullscreen.clone())
         .build(&event_loop)
         .unwrap();
 
-    event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+    let mut monitor_index = 0;
+    let mut monitor = event_loop
+        .available_monitors()
+        .next()
+        .expect("no monitor found!");
+    println!("Monitor: {:?}", monitor.name());
+
+    let mut mode_index = 0;
+    let mut mode = monitor.video_modes().next().expect("no mode found");
+    println!("Mode: {mode}");
+
+    println!("Keys:");
+    println!("- Esc\tExit");
+    println!("- F\tToggle exclusive fullscreen mode");
+    println!("- B\tToggle borderless mode");
+    #[cfg(target_os = "macos")]
+    println!("- C\tToggle simple fullscreen mode");
+    println!("- S\tNext screen");
+    println!("- M\tNext mode for this screen");
+    println!("- D\tToggle window decorations");
+    println!("- X\tMaximize window");
+    println!("- Z\tMinimize window");
+
+    event_loop.run(move |event, elwt, control_flow| {
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
                     input:
                         KeyboardInput {
                             virtual_keycode: Some(virtual_code),
-                            state,
+                            state: ElementState::Pressed,
                             ..
                         },
                     ..
-                } => match (virtual_code, state) {
-                    (VirtualKeyCode::Escape, _) => *control_flow = ControlFlow::Exit,
-                    (VirtualKeyCode::F, ElementState::Pressed) => {
-                        if window.fullscreen().is_some() {
-                            window.set_fullscreen(None);
+                } => match virtual_code {
+                    VirtualKeyCode::Escape => control_flow.set_exit(),
+                    VirtualKeyCode::F | VirtualKeyCode::B if window.fullscreen().is_some() => {
+                        window.set_fullscreen(None);
+                    }
+                    VirtualKeyCode::F => {
+                        let fullscreen = Some(Fullscreen::Exclusive(mode.clone()));
+                        println!("Setting mode: {fullscreen:?}");
+                        window.set_fullscreen(fullscreen);
+                    }
+                    VirtualKeyCode::B => {
+                        let fullscreen = Some(Fullscreen::Borderless(Some(monitor.clone())));
+                        println!("Setting mode: {fullscreen:?}");
+                        window.set_fullscreen(fullscreen);
+                    }
+                    #[cfg(target_os = "macos")]
+                    VirtualKeyCode::C => {
+                        window.set_simple_fullscreen(!window.simple_fullscreen());
+                    }
+                    VirtualKeyCode::S => {
+                        monitor_index += 1;
+                        if let Some(mon) = elwt.available_monitors().nth(monitor_index) {
+                            monitor = mon;
                         } else {
-                            window.set_fullscreen(fullscreen.clone());
+                            monitor_index = 0;
+                            monitor = elwt.available_monitors().next().expect("no monitor found!");
                         }
+                        println!("Monitor: {:?}", monitor.name());
+
+                        mode_index = 0;
+                        mode = monitor.video_modes().next().expect("no mode found");
+                        println!("Mode: {mode}");
                     }
-                    (VirtualKeyCode::S, ElementState::Pressed) => {
-                        println!("window.fullscreen {:?}", window.fullscreen());
+                    VirtualKeyCode::M => {
+                        mode_index += 1;
+                        if let Some(m) = monitor.video_modes().nth(mode_index) {
+                            mode = m;
+                        } else {
+                            mode_index = 0;
+                            mode = monitor.video_modes().next().expect("no mode found");
+                        }
+                        println!("Mode: {mode}");
                     }
-                    (VirtualKeyCode::M, ElementState::Pressed) => {
-                        is_maximized = !is_maximized;
-                        window.set_maximized(is_maximized);
-                    }
-                    (VirtualKeyCode::D, ElementState::Pressed) => {
+                    VirtualKeyCode::D => {
                         decorations = !decorations;
                         window.set_decorations(decorations);
                     }
+                    VirtualKeyCode::X => {
+                        let is_maximized = window.is_maximized();
+                        window.set_maximized(!is_maximized);
+                    }
+                    VirtualKeyCode::Z => {
+                        minimized = !minimized;
+                        window.set_minimized(minimized);
+                    }
                     _ => (),
                 },
                 _ => (),
@@ -71,46 +120,3 @@ fn main() {
         }
     });
 }
-
-// Enumerate monitors and prompt user to choose one
-fn prompt_for_monitor(event_loop: &EventLoop<()>) -> MonitorHandle {
-    for (num, monitor) in event_loop.available_monitors().enumerate() {
-        println!("Monitor #{}: {:?}", num, monitor.name());
-    }
-
-    print!("Please write the number of the monitor to use: ");
-    stdout().flush().unwrap();
-
-    let mut num = String::new();
-    stdin().read_line(&mut num).unwrap();
-    let num = num.trim().parse().ok().expect("Please enter a number");
-    let monitor = event_loop
-        .available_monitors()
-        .nth(num)
-        .expect("Please enter a valid ID");
-
-    println!("Using {:?}", monitor.name());
-
-    monitor
-}
-
-fn prompt_for_video_mode(monitor: &MonitorHandle) -> VideoMode {
-    for (i, video_mode) in monitor.video_modes().enumerate() {
-        println!("Video mode #{}: {}", i, video_mode);
-    }
-
-    print!("Please write the number of the video mode to use: ");
-    stdout().flush().unwrap();
-
-    let mut num = String::new();
-    stdin().read_line(&mut num).unwrap();
-    let num = num.trim().parse().ok().expect("Please enter a number");
-    let video_mode = monitor
-        .video_modes()
-        .nth(num)
-        .expect("Please enter a valid ID");
-
-    println!("Using {}", video_mode);
-
-    video_mode
-}

examples/handling_close.rs

@@ -1,10 +1,14 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
     let _window = WindowBuilder::new()
@@ -19,7 +23,7 @@ fn main() {
             ElementState::Released,
             VirtualKeyCode::{N, Y},
         };
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
 
         match event {
             Event::WindowEvent { event, .. } => {
@@ -61,7 +65,7 @@ fn main() {
                                     // event loop (i.e. if it's a multi-window application), you need to
                                     // drop the window. That closes it, and results in `Destroyed` being
                                     // sent.
-                                    *control_flow = ControlFlow::Exit;
+                                    control_flow.set_exit();
                                 }
                             }
                             N => {

examples/ime.rs

@@ -0,0 +1,112 @@
+#![allow(clippy::single_match)]
+
+use log::LevelFilter;
+use simple_logger::SimpleLogger;
+use winit::{
+    dpi::PhysicalPosition,
+    event::{ElementState, Event, Ime, VirtualKeyCode, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::{ImePurpose, WindowBuilder},
+};
+
+fn main() {
+    SimpleLogger::new()
+        .with_level(LevelFilter::Trace)
+        .init()
+        .unwrap();
+
+    println!("IME position will system default");
+    println!("Click to set IME position to cursor's");
+    println!("Press F2 to toggle IME. See the documentation of `set_ime_allowed` for more info");
+    println!("Press F3 to cycle through IME purposes.");
+
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_inner_size(winit::dpi::LogicalSize::new(256f64, 128f64))
+        .build(&event_loop)
+        .unwrap();
+
+    let mut ime_purpose = ImePurpose::Normal;
+    let mut ime_allowed = true;
+    window.set_ime_allowed(ime_allowed);
+
+    let mut may_show_ime = false;
+    let mut cursor_position = PhysicalPosition::new(0.0, 0.0);
+    let mut ime_pos = PhysicalPosition::new(0.0, 0.0);
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => *control_flow = ControlFlow::Exit,
+            Event::WindowEvent {
+                event: WindowEvent::CursorMoved { position, .. },
+                ..
+            } => {
+                cursor_position = position;
+            }
+            Event::WindowEvent {
+                event:
+                    WindowEvent::MouseInput {
+                        state: ElementState::Released,
+                        ..
+                    },
+                ..
+            } => {
+                println!(
+                    "Setting ime position to {}, {}",
+                    cursor_position.x, cursor_position.y
+                );
+                ime_pos = cursor_position;
+                if may_show_ime {
+                    window.set_ime_position(ime_pos);
+                }
+            }
+            Event::WindowEvent {
+                event: WindowEvent::Ime(event),
+                ..
+            } => {
+                println!("{event:?}");
+                may_show_ime = event != Ime::Disabled;
+                if may_show_ime {
+                    window.set_ime_position(ime_pos);
+                }
+            }
+            Event::WindowEvent {
+                event: WindowEvent::ReceivedCharacter(ch),
+                ..
+            } => {
+                println!("ch: {ch:?}");
+            }
+            Event::WindowEvent {
+                event: WindowEvent::KeyboardInput { input, .. },
+                ..
+            } => {
+                println!("key: {input:?}");
+
+                if input.state == ElementState::Pressed
+                    && input.virtual_keycode == Some(VirtualKeyCode::F2)
+                {
+                    ime_allowed = !ime_allowed;
+                    window.set_ime_allowed(ime_allowed);
+                    println!("\nIME allowed: {ime_allowed}\n");
+                }
+                if input.state == ElementState::Pressed
+                    && input.virtual_keycode == Some(VirtualKeyCode::F3)
+                {
+                    ime_purpose = match ime_purpose {
+                        ImePurpose::Normal => ImePurpose::Password,
+                        ImePurpose::Password => ImePurpose::Terminal,
+                        _ => ImePurpose::Normal,
+                    };
+                    window.set_ime_purpose(ime_purpose);
+                    println!("\nIME purpose: {ime_purpose:?}\n");
+                }
+            }
+            _ => (),
+        }
+    });
+}

examples/min_max_size.rs

@@ -1,27 +0,0 @@
-use winit::{
-    dpi::LogicalSize,
-    event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
-    window::WindowBuilder,
-};
-
-fn main() {
-    let event_loop = EventLoop::new();
-
-    let window = WindowBuilder::new().build(&event_loop).unwrap();
-
-    window.set_min_inner_size(Some(LogicalSize::new(400.0, 200.0)));
-    window.set_max_inner_size(Some(LogicalSize::new(800.0, 400.0)));
-
-    event_loop.run(move |event, _, control_flow| {
-        println!("{:?}", event);
-
-        match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => *control_flow = ControlFlow::Exit,
-            _ => *control_flow = ControlFlow::Wait,
-        }
-    });
-}

examples/monitor_list.rs

@@ -1,9 +1,58 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
+use winit::dpi::{PhysicalPosition, PhysicalSize};
+use winit::monitor::MonitorHandle;
 use winit::{event_loop::EventLoop, window::WindowBuilder};
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
     let window = WindowBuilder::new().build(&event_loop).unwrap();
 
-    dbg!(window.available_monitors().collect::<Vec<_>>());
-    dbg!(window.primary_monitor());
+    if let Some(mon) = window.primary_monitor() {
+        print_info("Primary output", mon);
+    }
+
+    for mon in window.available_monitors() {
+        if Some(&mon) == window.primary_monitor().as_ref() {
+            continue;
+        }
+
+        println!();
+        print_info("Output", mon);
+    }
+}
+
+fn print_info(intro: &str, monitor: MonitorHandle) {
+    if let Some(name) = monitor.name() {
+        println!("{intro}: {name}");
+    } else {
+        println!("{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!();
+    }
+
+    let PhysicalPosition { x, y } = monitor.position();
+    println!("  Position: {x},{y}");
+
+    println!("  Scale factor: {}", monitor.scale_factor());
+
+    println!("  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
+        );
+    }
 }

examples/mouse_wheel.rs

@@ -0,0 +1,62 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{Event, WindowEvent},
+    event_loop::EventLoop,
+    window::WindowBuilder,
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("Mouse Wheel events")
+        .build(&event_loop)
+        .unwrap();
+
+    println!(
+        r"
+When using so called 'natural scrolling' (scrolling that acts like on a touch screen), this is what to expect:
+
+Moving your finger downwards on a scroll wheel should make the window move down, and you should see a positive Y scroll value.
+
+When moving fingers on a trackpad down and to the right, you should see positive X and Y deltas, and the window should move down and to the right.
+
+With reverse scrolling, you should see the inverse behavior.
+
+In both cases the example window should move like the content of a scroll area in any other application.
+
+In other words, the deltas indicate the direction in which to move the content (in this case the window)."
+    );
+
+    event_loop.run(move |event, _, control_flow| {
+        control_flow.set_wait();
+
+        match event {
+            Event::WindowEvent { event, .. } => match event {
+                WindowEvent::CloseRequested => control_flow.set_exit(),
+                WindowEvent::MouseWheel { delta, .. } => match delta {
+                    winit::event::MouseScrollDelta::LineDelta(x, y) => {
+                        println!("mouse wheel Line Delta: ({x},{y})");
+                        let pixels_per_line = 120.0;
+                        let mut pos = window.outer_position().unwrap();
+                        pos.x += (x * pixels_per_line) as i32;
+                        pos.y += (y * pixels_per_line) as i32;
+                        window.set_outer_position(pos)
+                    }
+                    winit::event::MouseScrollDelta::PixelDelta(p) => {
+                        println!("mouse wheel Pixel Delta: ({},{})", p.x, p.y);
+                        let mut pos = window.outer_position().unwrap();
+                        pos.x += p.x as i32;
+                        pos.y += p.y as i32;
+                        window.set_outer_position(pos)
+                    }
+                },
+                _ => (),
+            },
+            _ => (),
+        }
+    });
+}

examples/multithreaded.rs

@@ -1,28 +1,30 @@
-#[cfg(not(target_arch = "wasm32"))]
-fn main() {
-    extern crate env_logger;
+#![allow(clippy::single_match)]
 
+#[cfg(not(wasm_platform))]
+fn main() {
     use std::{collections::HashMap, sync::mpsc, thread, time::Duration};
 
+    use simple_logger::SimpleLogger;
     use winit::{
+        dpi::{PhysicalPosition, PhysicalSize, Position, Size},
         event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
-        window::{CursorIcon, Fullscreen, WindowBuilder},
+        event_loop::EventLoop,
+        window::{CursorGrabMode, CursorIcon, Fullscreen, WindowBuilder, WindowLevel},
     };
 
     const WINDOW_COUNT: usize = 3;
-    const WINDOW_SIZE: (u32, u32) = (600, 400);
+    const WINDOW_SIZE: PhysicalSize<u32> = PhysicalSize::new(600, 400);
 
-    env_logger::init();
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
     let mut window_senders = HashMap::with_capacity(WINDOW_COUNT);
     for _ in 0..WINDOW_COUNT {
         let window = WindowBuilder::new()
-            .with_inner_size(WINDOW_SIZE.into())
+            .with_inner_size(WINDOW_SIZE)
             .build(&event_loop)
             .unwrap();
 
-        let mut video_modes: Vec<_> = window.current_monitor().video_modes().collect();
+        let mut video_modes: Vec<_> = window.current_monitor().unwrap().video_modes().collect();
         let mut video_mode_id = 0usize;
 
         let (tx, rx) = mpsc::channel();
@@ -34,10 +36,10 @@ fn main() {
                         // We need to update our chosen video mode if the window
                         // was moved to an another monitor, so that the window
                         // appears on this monitor instead when we go fullscreen
-                        let previous_video_mode = video_modes.iter().cloned().nth(video_mode_id);
-                        video_modes = window.current_monitor().video_modes().collect();
+                        let previous_video_mode = video_modes.get(video_mode_id).cloned();
+                        video_modes = window.current_monitor().unwrap().video_modes().collect();
                         video_mode_id = video_mode_id.min(video_modes.len());
-                        let video_mode = video_modes.iter().nth(video_mode_id);
+                        let video_mode = video_modes.get(video_mode_id);
 
                         // Different monitors may support different video modes,
                         // and the index we chose previously may now point to a
@@ -45,10 +47,11 @@ fn main() {
                         if video_mode != previous_video_mode.as_ref() {
                             println!(
                                 "Window moved to another monitor, picked video mode: {}",
-                                video_modes.iter().nth(video_mode_id).unwrap()
+                                video_modes.get(video_mode_id).unwrap()
                             );
                         }
                     }
+                    #[allow(deprecated)]
                     WindowEvent::KeyboardInput {
                         input:
                             KeyboardInput {
@@ -59,11 +62,13 @@ fn main() {
                             },
                         ..
                     } => {
-                        window.set_title(&format!("{:?}", key));
-                        let state = !modifiers.shift;
+                        window.set_title(&format!("{key:?}"));
+                        let state = !modifiers.shift();
                         use VirtualKeyCode::*;
                         match key {
-                            A => window.set_always_on_top(state),
+                            Key1 => window.set_window_level(WindowLevel::AlwaysOnTop),
+                            Key2 => window.set_window_level(WindowLevel::AlwaysOnBottom),
+                            Key3 => window.set_window_level(WindowLevel::Normal),
                             C => window.set_cursor_icon(match state {
                                 true => CursorIcon::Progress,
                                 false => CursorIcon::Default,
@@ -76,21 +81,30 @@ fn main() {
                                     Right => (video_modes.len() - 1).min(video_mode_id + 1),
                                     _ => unreachable!(),
                                 };
-                                println!(
-                                    "Picking video mode: {}",
-                                    video_modes.iter().nth(video_mode_id).unwrap()
-                                );
+                                println!("Picking video mode: {}", video_modes[video_mode_id]);
                             }
-                            F => window.set_fullscreen(match (state, modifiers.alt) {
-                                (true, false) => {
-                                    Some(Fullscreen::Borderless(window.current_monitor()))
+                            F => window.set_fullscreen(match (state, modifiers.alt()) {
+                                (true, false) => Some(Fullscreen::Borderless(None)),
+                                (true, true) => {
+                                    Some(Fullscreen::Exclusive(video_modes[video_mode_id].clone()))
                                 }
-                                (true, true) => Some(Fullscreen::Exclusive(
-                                    video_modes.iter().nth(video_mode_id).unwrap().clone(),
-                                )),
                                 (false, _) => None,
                             }),
-                            G => window.set_cursor_grab(state).unwrap(),
+                            L if state => {
+                                if let Err(err) = window.set_cursor_grab(CursorGrabMode::Locked) {
+                                    println!("error: {err}");
+                                }
+                            }
+                            G if state => {
+                                if let Err(err) = window.set_cursor_grab(CursorGrabMode::Confined) {
+                                    println!("error: {err}");
+                                }
+                            }
+                            G | L if !state => {
+                                if let Err(err) = window.set_cursor_grab(CursorGrabMode::None) {
+                                    println!("error: {err}");
+                                }
+                            }
                             H => window.set_cursor_visible(!state),
                             I => {
                                 println!("Info:");
@@ -101,31 +115,38 @@ fn main() {
                                 println!("-> fullscreen     : {:?}", window.fullscreen());
                             }
                             L => window.set_min_inner_size(match state {
-                                true => Some(WINDOW_SIZE.into()),
+                                true => Some(WINDOW_SIZE),
                                 false => None,
                             }),
                             M => window.set_maximized(state),
                             P => window.set_outer_position({
                                 let mut position = window.outer_position().unwrap();
-                                let sign = if state { 1.0 } else { -1.0 };
-                                position.x += 10.0 * sign;
-                                position.y += 10.0 * sign;
+                                let sign = if state { 1 } else { -1 };
+                                position.x += 10 * sign;
+                                position.y += 10 * sign;
                                 position
                             }),
                             Q => window.request_redraw(),
                             R => window.set_resizable(state),
-                            S => window.set_inner_size(
-                                match state {
-                                    true => (WINDOW_SIZE.0 + 100, WINDOW_SIZE.1 + 100),
-                                    false => WINDOW_SIZE,
+                            S => window.set_inner_size(match state {
+                                true => PhysicalSize::new(
+                                    WINDOW_SIZE.width + 100,
+                                    WINDOW_SIZE.height + 100,
+                                ),
+                                false => WINDOW_SIZE,
+                            }),
+                            W => {
+                                if let Size::Physical(size) = WINDOW_SIZE.into() {
+                                    window
+                                        .set_cursor_position(Position::Physical(
+                                            PhysicalPosition::new(
+                                                size.width as i32 / 2,
+                                                size.height as i32 / 2,
+                                            ),
+                                        ))
+                                        .unwrap()
                                 }
-                                .into(),
-                            ),
-                            W => window
-                                .set_cursor_position(
-                                    (WINDOW_SIZE.0 as i32 / 2, WINDOW_SIZE.1 as i32 / 2).into(),
-                                )
-                                .unwrap(),
+                            }
                             Z => {
                                 window.set_visible(false);
                                 thread::sleep(Duration::from_secs(1));
@@ -140,9 +161,9 @@ fn main() {
         });
     }
     event_loop.run(move |event, _event_loop, control_flow| {
-        *control_flow = match !window_senders.is_empty() {
-            true => ControlFlow::Wait,
-            false => ControlFlow::Exit,
+        match !window_senders.is_empty() {
+            true => control_flow.set_wait(),
+            false => control_flow.set_exit(),
         };
         match event {
             Event::WindowEvent { event, window_id } => match event {
@@ -161,16 +182,18 @@ fn main() {
                 }
                 _ => {
                     if let Some(tx) = window_senders.get(&window_id) {
-                        tx.send(event).unwrap();
+                        if let Some(event) = event.to_static() {
+                            tx.send(event).unwrap();
+                        }
                     }
                 }
             },
-            _ => (),
+            _ => {}
         }
     })
 }
 
-#[cfg(target_arch = "wasm32")]
+#[cfg(wasm_platform)]
 fn main() {
     panic!("Example not supported on Wasm");
 }

examples/multiwindow.rs

@@ -1,43 +1,55 @@
+#![allow(clippy::single_match)]
+
 use std::collections::HashMap;
+
+use simple_logger::SimpleLogger;
 use winit::{
-    event::{ElementState, Event, KeyboardInput, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::EventLoop,
     window::Window,
 };
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
     let mut windows = HashMap::new();
     for _ in 0..3 {
         let window = Window::new(&event_loop).unwrap();
+        println!("Opened a new window: {:?}", window.id());
         windows.insert(window.id(), window);
     }
 
+    println!("Press N to open a new window.");
+
     event_loop.run(move |event, event_loop, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
+
         match event {
             Event::WindowEvent { event, window_id } => {
                 match event {
                     WindowEvent::CloseRequested => {
-                        println!("Window {:?} has received the signal to close", window_id);
+                        println!("Window {window_id:?} has received the signal to close");
 
                         // This drops the window, causing it to close.
                         windows.remove(&window_id);
 
                         if windows.is_empty() {
-                            *control_flow = ControlFlow::Exit;
+                            control_flow.set_exit();
                         }
                     }
                     WindowEvent::KeyboardInput {
                         input:
                             KeyboardInput {
                                 state: ElementState::Pressed,
+                                virtual_keycode: Some(VirtualKeyCode::N),
                                 ..
                             },
+                        is_synthetic: false,
                         ..
                     } => {
-                        let window = Window::new(&event_loop).unwrap();
+                        let window = Window::new(event_loop).unwrap();
+                        println!("Opened a new window: {:?}", window.id());
                         windows.insert(window.id(), window);
                     }
                     _ => (),

examples/request_redraw.rs

@@ -1,13 +1,14 @@
-use instant::Instant;
-use std::time::Duration;
+#![allow(clippy::single_match)]
 
+use simple_logger::SimpleLogger;
 use winit::{
-    event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event::{ElementState, Event, WindowEvent},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
@@ -15,21 +16,26 @@ fn main() {
         .build(&event_loop)
         .unwrap();
 
-    event_loop.run(move |event, _, control_flow| match event {
-        Event::WindowEvent {
-            event: WindowEvent::CloseRequested,
-            ..
-        } => *control_flow = ControlFlow::Exit,
-        Event::EventsCleared => {
-            window.request_redraw();
-            *control_flow = ControlFlow::WaitUntil(Instant::now() + Duration::new(1, 0))
+    event_loop.run(move |event, _, control_flow| {
+        println!("{event:?}");
+
+        control_flow.set_wait();
+
+        match event {
+            Event::WindowEvent { event, .. } => match event {
+                WindowEvent::CloseRequested => control_flow.set_exit(),
+                WindowEvent::MouseInput {
+                    state: ElementState::Released,
+                    ..
+                } => {
+                    window.request_redraw();
+                }
+                _ => (),
+            },
+            Event::RedrawRequested(_) => {
+                println!("\nredrawing!\n");
+            }
+            _ => (),
         }
-        Event::WindowEvent {
-            event: WindowEvent::RedrawRequested,
-            ..
-        } => {
-            println!("{:?}", event);
-        }
-        _ => (),
     });
 }

examples/request_redraw_threaded.rs

@@ -0,0 +1,48 @@
+#![allow(clippy::single_match)]
+
+#[cfg(not(wasm_platform))]
+fn main() {
+    use std::{thread, time};
+
+    use simple_logger::SimpleLogger;
+    use winit::{
+        event::{Event, WindowEvent},
+        event_loop::EventLoop,
+        window::WindowBuilder,
+    };
+
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .build(&event_loop)
+        .unwrap();
+
+    thread::spawn(move || loop {
+        thread::sleep(time::Duration::from_secs(1));
+        window.request_redraw();
+    });
+
+    event_loop.run(move |event, _, control_flow| {
+        println!("{event:?}");
+
+        control_flow.set_wait();
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => control_flow.set_exit(),
+            Event::RedrawRequested(_) => {
+                println!("\nredrawing!\n");
+            }
+            _ => (),
+        }
+    });
+}
+
+#[cfg(wasm_platform)]
+fn main() {
+    unimplemented!() // `Window` can't be sent between threads
+}

examples/resizable.rs

@@ -1,26 +1,34 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
 use winit::{
+    dpi::LogicalSize,
     event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
     let mut resizable = false;
 
     let window = WindowBuilder::new()
         .with_title("Hit space to toggle resizability.")
-        .with_inner_size((400, 200).into())
+        .with_inner_size(LogicalSize::new(600.0, 300.0))
+        .with_min_inner_size(LogicalSize::new(400.0, 200.0))
+        .with_max_inner_size(LogicalSize::new(800.0, 400.0))
         .with_resizable(resizable)
         .build(&event_loop)
         .unwrap();
 
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
+
         match event {
             Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
                     input:
                         KeyboardInput {
@@ -31,7 +39,7 @@ fn main() {
                     ..
                 } => {
                     resizable = !resizable;
-                    println!("Resizable: {}", resizable);
+                    println!("Resizable: {resizable}");
                     window.set_resizable(resizable);
                 }
                 _ => (),

examples/theme.rs

@@ -0,0 +1,71 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::{Theme, WindowBuilder},
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .with_theme(Some(Theme::Dark))
+        .build(&event_loop)
+        .unwrap();
+
+    println!("Initial theme: {:?}", window.theme());
+    println!("debugging keys:");
+    println!("  (A) Automatic theme");
+    println!("  (L) Light theme");
+    println!("  (D) Dark theme");
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => *control_flow = ControlFlow::Exit,
+            Event::WindowEvent {
+                event: WindowEvent::ThemeChanged(theme),
+                window_id,
+                ..
+            } if window_id == window.id() => {
+                println!("Theme is changed: {theme:?}")
+            }
+            Event::WindowEvent {
+                event:
+                    WindowEvent::KeyboardInput {
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(key),
+                                state: ElementState::Pressed,
+                                ..
+                            },
+                        ..
+                    },
+                ..
+            } => match key {
+                VirtualKeyCode::A => {
+                    println!("Theme was: {:?}", window.theme());
+                    window.set_theme(None);
+                }
+                VirtualKeyCode::L => {
+                    println!("Theme was: {:?}", window.theme());
+                    window.set_theme(Some(Theme::Light));
+                }
+                VirtualKeyCode::D => {
+                    println!("Theme was: {:?}", window.theme());
+                    window.set_theme(Some(Theme::Dark));
+                }
+                _ => (),
+            },
+            _ => (),
+        }
+    });
+}

examples/timer.rs

@@ -1,12 +1,17 @@
+#![allow(clippy::single_match)]
+
 use instant::Instant;
 use std::time::Duration;
+
+use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, StartCause, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
     let _window = WindowBuilder::new()
@@ -17,20 +22,20 @@ fn main() {
     let timer_length = Duration::new(1, 0);
 
     event_loop.run(move |event, _, control_flow| {
-        println!("{:?}", event);
+        println!("{event:?}");
 
         match event {
             Event::NewEvents(StartCause::Init) => {
-                *control_flow = ControlFlow::WaitUntil(Instant::now() + timer_length)
+                control_flow.set_wait_until(Instant::now() + timer_length);
             }
             Event::NewEvents(StartCause::ResumeTimeReached { .. }) => {
-                *control_flow = ControlFlow::WaitUntil(Instant::now() + timer_length);
+                control_flow.set_wait_until(Instant::now() + timer_length);
                 println!("\nTimer\n");
             }
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 ..
-            } => *control_flow = ControlFlow::Exit,
+            } => control_flow.set_exit(),
             _ => (),
         }
     });

examples/touchpad_gestures.rs

@@ -0,0 +1,46 @@
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::WindowBuilder,
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let _window = WindowBuilder::new()
+        .with_title("Touchpad gestures")
+        .build(&event_loop)
+        .unwrap();
+
+    println!("Only supported on macOS at the moment.");
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        if let Event::WindowEvent { event, .. } = event {
+            match event {
+                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                WindowEvent::TouchpadMagnify { delta, .. } => {
+                    if delta > 0.0 {
+                        println!("Zoomed in {delta}");
+                    } else {
+                        println!("Zoomed out {delta}");
+                    }
+                }
+                WindowEvent::SmartMagnify { .. } => {
+                    println!("Smart zoom");
+                }
+                WindowEvent::TouchpadRotate { delta, .. } => {
+                    if delta > 0.0 {
+                        println!("Rotated counterclockwise {delta}");
+                    } else {
+                        println!("Rotated clockwise {delta}");
+                    }
+                }
+                _ => (),
+            }
+        }
+    });
+}

examples/transparent.rs

@@ -1,10 +1,14 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
@@ -16,14 +20,15 @@ fn main() {
     window.set_title("A fantastic window!");
 
     event_loop.run(move |event, _, control_flow| {
-        println!("{:?}", event);
+        control_flow.set_wait();
+        println!("{event:?}");
 
         match event {
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 ..
-            } => *control_flow = ControlFlow::Exit,
-            _ => *control_flow = ControlFlow::Wait,
+            } => control_flow.set_exit(),
+            _ => (),
         }
     });
 }

examples/video_modes.rs

@@ -1,12 +1,22 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
 use winit::event_loop::EventLoop;
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
-    let monitor = event_loop.primary_monitor();
+    let monitor = match event_loop.primary_monitor() {
+        Some(monitor) => monitor,
+        None => {
+            println!("No primary monitor detected.");
+            return;
+        }
+    };
 
     println!("Listing available video modes:");
 
     for mode in monitor.video_modes() {
-        println!("{}", mode);
+        println!("{mode}");
     }
 }

examples/web.rs

@@ -0,0 +1,90 @@
+#![allow(clippy::single_match)]
+
+use winit::{
+    event::{Event, WindowEvent},
+    event_loop::EventLoop,
+    window::WindowBuilder,
+};
+
+pub fn main() {
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .build(&event_loop)
+        .unwrap();
+
+    #[cfg(wasm_platform)]
+    let log_list = wasm::insert_canvas_and_create_log_list(&window);
+
+    event_loop.run(move |event, _, control_flow| {
+        control_flow.set_wait();
+
+        #[cfg(wasm_platform)]
+        wasm::log_event(&log_list, &event);
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                window_id,
+            } if window_id == window.id() => control_flow.set_exit(),
+            Event::MainEventsCleared => {
+                window.request_redraw();
+            }
+            _ => (),
+        }
+    });
+}
+
+#[cfg(wasm_platform)]
+mod wasm {
+    use wasm_bindgen::prelude::*;
+    use winit::{event::Event, window::Window};
+
+    #[wasm_bindgen(start)]
+    pub fn run() {
+        console_log::init_with_level(log::Level::Debug).expect("error initializing logger");
+
+        #[allow(clippy::main_recursion)]
+        super::main();
+    }
+
+    pub fn insert_canvas_and_create_log_list(window: &Window) -> web_sys::Element {
+        use winit::platform::web::WindowExtWebSys;
+
+        let canvas = window.canvas();
+
+        let window = web_sys::window().unwrap();
+        let document = window.document().unwrap();
+        let body = document.body().unwrap();
+
+        // Set a background color for the canvas to make it easier to tell where the canvas is for debugging purposes.
+        canvas.style().set_css_text("background-color: crimson;");
+        body.append_child(&canvas).unwrap();
+
+        let log_header = document.create_element("h2").unwrap();
+        log_header.set_text_content(Some("Event Log"));
+        body.append_child(&log_header).unwrap();
+
+        let log_list = document.create_element("ul").unwrap();
+        body.append_child(&log_list).unwrap();
+        log_list
+    }
+
+    pub fn log_event(log_list: &web_sys::Element, event: &Event<()>) {
+        log::debug!("{:?}", event);
+
+        // Getting access to browser logs requires a lot of setup on mobile devices.
+        // So we implement this basic logging system into the page to give developers an easy alternative.
+        // As a bonus its also kind of handy on desktop.
+        if let Event::WindowEvent { event, .. } = &event {
+            let window = web_sys::window().unwrap();
+            let document = window.document().unwrap();
+            let log = document.create_element("li").unwrap();
+            log.set_text_content(Some(&format!("{event:?}")));
+            log_list
+                .insert_before(&log, log_list.first_child().as_ref())
+                .unwrap();
+        }
+    }
+}

examples/web_aspect_ratio.rs

@@ -0,0 +1,103 @@
+pub fn main() {
+    println!("This example must be run with cargo run-wasm --example web_aspect_ratio")
+}
+
+#[cfg(wasm_platform)]
+mod wasm {
+    use wasm_bindgen::prelude::*;
+    use wasm_bindgen::JsCast;
+    use web_sys::HtmlCanvasElement;
+    use winit::{
+        dpi::PhysicalSize,
+        event::{Event, WindowEvent},
+        event_loop::{ControlFlow, EventLoop},
+        window::{Window, WindowBuilder},
+    };
+
+    const EXPLANATION: &str = "
+This example draws a circle in the middle of a 4/1 aspect ratio canvas which acts as a useful demonstration of winit's resize handling on web.
+Even when the browser window is resized or aspect-ratio of the canvas changed the circle should always:
+* Fill the entire width or height of the canvas (whichever is smaller) without exceeding it.
+* Be perfectly round
+* Not be blurry or pixelated (there is no antialiasing so you may still see jagged edges depending on the DPI of your monitor)
+
+Currently winit does not handle resizes on web so the circle is rendered incorrectly.
+This example demonstrates the desired future functionality which will possibly be provided by https://github.com/rust-windowing/winit/pull/2074
+";
+
+    #[wasm_bindgen(start)]
+    pub fn run() {
+        console_log::init_with_level(log::Level::Debug).expect("error initializing logger");
+        let event_loop = EventLoop::new();
+
+        let window = WindowBuilder::new()
+            .with_title("A fantastic window!")
+            // When running in a non-wasm environment this would set the window size to 100x100.
+            // However in this example it just sets a default initial size of 100x100 that is immediately overwritten due to the layout + styling of the page.
+            .with_inner_size(PhysicalSize::new(100, 100))
+            .build(&event_loop)
+            .unwrap();
+
+        let canvas = create_canvas(&window);
+
+        // Render once with the size info we currently have
+        render_circle(&canvas, window.inner_size());
+
+        event_loop.run(move |event, _, control_flow| {
+            *control_flow = ControlFlow::Wait;
+
+            match event {
+                Event::WindowEvent {
+                    event: WindowEvent::Resized(resize),
+                    window_id,
+                } if window_id == window.id() => {
+                    render_circle(&canvas, resize);
+                }
+                _ => (),
+            }
+        });
+    }
+
+    pub fn create_canvas(window: &Window) -> HtmlCanvasElement {
+        use winit::platform::web::WindowExtWebSys;
+
+        let web_window = web_sys::window().unwrap();
+        let document = web_window.document().unwrap();
+        let body = document.body().unwrap();
+
+        // Set a background color for the canvas to make it easier to tell the where the canvas is for debugging purposes.
+        let canvas = window.canvas();
+        canvas
+            .style()
+            .set_css_text("display: block; background-color: crimson; margin: auto; width: 50%; aspect-ratio: 4 / 1;");
+        body.append_child(&canvas).unwrap();
+
+        let explanation = document.create_element("pre").unwrap();
+        explanation.set_text_content(Some(EXPLANATION));
+        body.append_child(&explanation).unwrap();
+
+        canvas
+    }
+
+    pub fn render_circle(canvas: &HtmlCanvasElement, size: PhysicalSize<u32>) {
+        log::info!("rendering circle with canvas size: {:?}", size);
+        let context = canvas
+            .get_context("2d")
+            .unwrap()
+            .unwrap()
+            .dyn_into::<web_sys::CanvasRenderingContext2d>()
+            .unwrap();
+
+        context.begin_path();
+        context
+            .arc(
+                size.width as f64 / 2.0,
+                size.height as f64 / 2.0,
+                size.width.min(size.height) as f64 / 2.0,
+                0.0,
+                std::f64::consts::PI * 2.0,
+            )
+            .unwrap();
+        context.fill();
+    }
+}

examples/window.rs

@@ -1,26 +1,35 @@
+#![allow(clippy::single_match)]
+
+use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::WindowBuilder,
 };
 
 fn main() {
+    SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
 
     let window = WindowBuilder::new()
         .with_title("A fantastic window!")
+        .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
         .build(&event_loop)
         .unwrap();
 
     event_loop.run(move |event, _, control_flow| {
-        println!("{:?}", event);
+        control_flow.set_wait();
+        println!("{event:?}");
 
         match event {
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 window_id,
-            } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-            _ => *control_flow = ControlFlow::Wait,
+            } if window_id == window.id() => control_flow.set_exit(),
+            Event::MainEventsCleared => {
+                window.request_redraw();
+            }
+            _ => (),
         }
     });
 }

examples/window_buttons.rs

@@ -0,0 +1,68 @@
+#![allow(clippy::single_match)]
+
+// This example is used by developers to test various window functions.
+
+use simple_logger::SimpleLogger;
+use winit::{
+    dpi::LogicalSize,
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::{DeviceEventFilter, EventLoop},
+    window::{WindowBuilder, WindowButtons},
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .with_inner_size(LogicalSize::new(300.0, 300.0))
+        .build(&event_loop)
+        .unwrap();
+
+    eprintln!("Window Button keys:");
+    eprintln!("  (F) Toggle close button");
+    eprintln!("  (G) Toggle maximize button");
+    eprintln!("  (H) Toggle minimize button");
+
+    event_loop.set_device_event_filter(DeviceEventFilter::Never);
+
+    event_loop.run(move |event, _, control_flow| {
+        control_flow.set_wait();
+
+        match event {
+            Event::WindowEvent {
+                event:
+                    WindowEvent::KeyboardInput {
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(key),
+                                state: ElementState::Pressed,
+                                ..
+                            },
+                        ..
+                    },
+                ..
+            } => match key {
+                VirtualKeyCode::F => {
+                    let buttons = window.enabled_buttons();
+                    window.set_enabled_buttons(buttons ^ WindowButtons::CLOSE);
+                }
+                VirtualKeyCode::G => {
+                    let buttons = window.enabled_buttons();
+                    window.set_enabled_buttons(buttons ^ WindowButtons::MAXIMIZE);
+                }
+                VirtualKeyCode::H => {
+                    let buttons = window.enabled_buttons();
+                    window.set_enabled_buttons(buttons ^ WindowButtons::MINIMIZE);
+                }
+                _ => (),
+            },
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                window_id,
+            } if window_id == window.id() => control_flow.set_exit(),
+            _ => (),
+        }
+    });
+}

examples/window_debug.rs

@@ -0,0 +1,132 @@
+#![allow(clippy::single_match)]
+
+// This example is used by developers to test various window functions.
+
+use simple_logger::SimpleLogger;
+use winit::{
+    dpi::{LogicalSize, PhysicalSize},
+    event::{DeviceEvent, ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::{DeviceEventFilter, EventLoop},
+    window::{Fullscreen, WindowBuilder},
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .with_inner_size(LogicalSize::new(100.0, 100.0))
+        .build(&event_loop)
+        .unwrap();
+
+    eprintln!("debugging keys:");
+    eprintln!("  (E) Enter exclusive fullscreen");
+    eprintln!("  (F) Toggle borderless fullscreen");
+    eprintln!("  (P) Toggle borderless fullscreen on system's preffered monitor");
+    eprintln!("  (M) Toggle minimized");
+    eprintln!("  (Q) Quit event loop");
+    eprintln!("  (V) Toggle visibility");
+    eprintln!("  (X) Toggle maximized");
+
+    let mut minimized = false;
+    let mut visible = true;
+
+    event_loop.set_device_event_filter(DeviceEventFilter::Never);
+
+    event_loop.run(move |event, _, control_flow| {
+        control_flow.set_wait();
+
+        match event {
+            Event::DeviceEvent {
+                event:
+                    DeviceEvent::Key(KeyboardInput {
+                        virtual_keycode: Some(key),
+                        state: ElementState::Pressed,
+                        ..
+                    }),
+                ..
+            } => match key {
+                VirtualKeyCode::M => {
+                    if minimized {
+                        minimized = !minimized;
+                        window.set_minimized(minimized);
+                        window.focus_window();
+                    }
+                }
+                VirtualKeyCode::V => {
+                    if !visible {
+                        visible = !visible;
+                        window.set_visible(visible);
+                    }
+                }
+                _ => (),
+            },
+            Event::WindowEvent {
+                event:
+                    WindowEvent::KeyboardInput {
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(key),
+                                state: ElementState::Pressed,
+                                ..
+                            },
+                        ..
+                    },
+                ..
+            } => match key {
+                VirtualKeyCode::E => {
+                    fn area(size: PhysicalSize<u32>) -> u32 {
+                        size.width * size.height
+                    }
+
+                    let monitor = window.current_monitor().unwrap();
+                    if let Some(mode) = monitor
+                        .video_modes()
+                        .max_by(|a, b| area(a.size()).cmp(&area(b.size())))
+                    {
+                        window.set_fullscreen(Some(Fullscreen::Exclusive(mode)));
+                    } else {
+                        eprintln!("no video modes available");
+                    }
+                }
+                VirtualKeyCode::F => {
+                    if window.fullscreen().is_some() {
+                        window.set_fullscreen(None);
+                    } else {
+                        let monitor = window.current_monitor();
+                        window.set_fullscreen(Some(Fullscreen::Borderless(monitor)));
+                    }
+                }
+                VirtualKeyCode::P => {
+                    if window.fullscreen().is_some() {
+                        window.set_fullscreen(None);
+                    } else {
+                        window.set_fullscreen(Some(Fullscreen::Borderless(None)));
+                    }
+                }
+                VirtualKeyCode::M => {
+                    minimized = !minimized;
+                    window.set_minimized(minimized);
+                }
+                VirtualKeyCode::Q => {
+                    control_flow.set_exit();
+                }
+                VirtualKeyCode::V => {
+                    visible = !visible;
+                    window.set_visible(visible);
+                }
+                VirtualKeyCode::X => {
+                    let is_maximized = window.is_maximized();
+                    window.set_maximized(!is_maximized);
+                }
+                _ => (),
+            },
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                window_id,
+            } if window_id == window.id() => control_flow.set_exit(),
+            _ => (),
+        }
+    });
+}

examples/window_drag_resize.rs

@@ -0,0 +1,141 @@
+//! Demonstrates capability to create in-app draggable regions for client-side decoration support.
+
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{
+        ElementState, Event, KeyboardInput, MouseButton, StartCause, VirtualKeyCode, WindowEvent,
+    },
+    event_loop::{ControlFlow, EventLoop},
+    window::{CursorIcon, ResizeDirection, WindowBuilder},
+};
+
+const BORDER: f64 = 8.0;
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_inner_size(winit::dpi::LogicalSize::new(600.0, 400.0))
+        .with_min_inner_size(winit::dpi::LogicalSize::new(400.0, 200.0))
+        .with_decorations(false)
+        .build(&event_loop)
+        .unwrap();
+
+    let mut border = false;
+    let mut cursor_location = None;
+
+    event_loop.run(move |event, _, control_flow| match event {
+        Event::NewEvents(StartCause::Init) => {
+            eprintln!("Press 'B' to toggle borderless")
+        }
+        Event::WindowEvent { event, .. } => match event {
+            WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+            WindowEvent::CursorMoved { position, .. } => {
+                if !window.is_decorated() {
+                    let new_location =
+                        cursor_resize_direction(window.inner_size(), position, BORDER);
+
+                    if new_location != cursor_location {
+                        cursor_location = new_location;
+                        window.set_cursor_icon(cursor_direction_icon(cursor_location))
+                    }
+                }
+            }
+
+            WindowEvent::MouseInput {
+                state: ElementState::Pressed,
+                button: MouseButton::Left,
+                ..
+            } => {
+                if let Some(dir) = cursor_location {
+                    let _res = window.drag_resize_window(dir);
+                }
+            }
+            WindowEvent::KeyboardInput {
+                input:
+                    KeyboardInput {
+                        state: ElementState::Released,
+                        virtual_keycode: Some(VirtualKeyCode::B),
+                        ..
+                    },
+                ..
+            } => {
+                border = !border;
+                window.set_decorations(border);
+            }
+            _ => (),
+        },
+        _ => (),
+    });
+}
+
+fn cursor_direction_icon(resize_direction: Option<ResizeDirection>) -> CursorIcon {
+    match resize_direction {
+        Some(resize_direction) => match resize_direction {
+            ResizeDirection::East => CursorIcon::EResize,
+            ResizeDirection::North => CursorIcon::NResize,
+            ResizeDirection::NorthEast => CursorIcon::NeResize,
+            ResizeDirection::NorthWest => CursorIcon::NwResize,
+            ResizeDirection::South => CursorIcon::SResize,
+            ResizeDirection::SouthEast => CursorIcon::SeResize,
+            ResizeDirection::SouthWest => CursorIcon::SwResize,
+            ResizeDirection::West => CursorIcon::WResize,
+        },
+        None => CursorIcon::Default,
+    }
+}
+
+fn cursor_resize_direction(
+    win_size: winit::dpi::PhysicalSize<u32>,
+    position: winit::dpi::PhysicalPosition<f64>,
+    border_size: f64,
+) -> Option<ResizeDirection> {
+    enum XDirection {
+        West,
+        East,
+        Default,
+    }
+
+    enum YDirection {
+        North,
+        South,
+        Default,
+    }
+
+    let xdir = if position.x < border_size {
+        XDirection::West
+    } else if position.x > (win_size.width as f64 - border_size) {
+        XDirection::East
+    } else {
+        XDirection::Default
+    };
+
+    let ydir = if position.y < border_size {
+        YDirection::North
+    } else if position.y > (win_size.height as f64 - border_size) {
+        YDirection::South
+    } else {
+        YDirection::Default
+    };
+
+    Some(match xdir {
+        XDirection::West => match ydir {
+            YDirection::North => ResizeDirection::NorthWest,
+            YDirection::South => ResizeDirection::SouthWest,
+            YDirection::Default => ResizeDirection::West,
+        },
+
+        XDirection::East => match ydir {
+            YDirection::North => ResizeDirection::NorthEast,
+            YDirection::South => ResizeDirection::SouthEast,
+            YDirection::Default => ResizeDirection::East,
+        },
+
+        XDirection::Default => match ydir {
+            YDirection::North => ResizeDirection::North,
+            YDirection::South => ResizeDirection::South,
+            YDirection::Default => return None,
+        },
+    })
+}

examples/window_icon.rs

@@ -1,12 +1,17 @@
-extern crate image;
+#![allow(clippy::single_match)]
+
 use std::path::Path;
+
+use simple_logger::SimpleLogger;
 use winit::{
     event::Event,
-    event_loop::{ControlFlow, EventLoop},
+    event_loop::EventLoop,
     window::{Icon, WindowBuilder},
 };
 
 fn main() {
+    SimpleLogger::new().init().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
@@ -26,11 +31,12 @@ fn main() {
         .unwrap();
 
     event_loop.run(move |event, _, control_flow| {
-        *control_flow = ControlFlow::Wait;
+        control_flow.set_wait();
+
         if let Event::WindowEvent { event, .. } = event {
             use winit::event::WindowEvent::*;
             match event {
-                CloseRequested => *control_flow = ControlFlow::Exit,
+                CloseRequested => control_flow.set_exit(),
                 DroppedFile(path) => {
                     window.set_window_icon(Some(load_icon(&path)));
                 }
@@ -42,13 +48,11 @@ fn main() {
 
 fn load_icon(path: &Path) -> Icon {
     let (icon_rgba, icon_width, icon_height) = {
-        let image = image::open(path).expect("Failed to open icon path");
-        use image::{GenericImageView, Pixel};
+        let image = image::open(path)
+            .expect("Failed to open icon path")
+            .into_rgba8();
         let (width, height) = image.dimensions();
-        let mut rgba = Vec::with_capacity((width * height) as usize * 4);
-        for (_, _, pixel) in image.pixels() {
-            rgba.extend_from_slice(&pixel.to_rgba().data);
-        }
+        let rgba = image.into_raw();
         (rgba, width, height)
     };
     Icon::from_rgba(icon_rgba, icon_width, icon_height).expect("Failed to open icon")

examples/window_option_as_alt.rs

@@ -0,0 +1,67 @@
+#![allow(clippy::single_match)]
+
+#[cfg(target_os = "macos")]
+use winit::platform::macos::{OptionAsAlt, WindowExtMacOS};
+
+#[cfg(target_os = "macos")]
+use winit::{
+    event::ElementState,
+    event::{Event, MouseButton, WindowEvent},
+    event_loop::EventLoop,
+    window::WindowBuilder,
+};
+
+/// Prints the keyboard events characters received when option_is_alt is true versus false.
+/// A left mouse click will toggle option_is_alt.
+#[cfg(target_os = "macos")]
+fn main() {
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
+        .build(&event_loop)
+        .unwrap();
+
+    let mut option_as_alt = window.option_as_alt();
+
+    event_loop.run(move |event, _, control_flow| {
+        control_flow.set_wait();
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                window_id,
+            } if window_id == window.id() => control_flow.set_exit(),
+            Event::WindowEvent { event, .. } => match event {
+                WindowEvent::MouseInput {
+                    state: ElementState::Pressed,
+                    button: MouseButton::Left,
+                    ..
+                } => {
+                    option_as_alt = match option_as_alt {
+                        OptionAsAlt::None => OptionAsAlt::OnlyLeft,
+                        OptionAsAlt::OnlyLeft => OptionAsAlt::OnlyRight,
+                        OptionAsAlt::OnlyRight => OptionAsAlt::Both,
+                        OptionAsAlt::Both => OptionAsAlt::None,
+                    };
+
+                    println!("Received Mouse click, toggling option_as_alt to: {option_as_alt:?}");
+                    window.set_option_as_alt(option_as_alt);
+                }
+                WindowEvent::ReceivedCharacter(c) => println!("ReceivedCharacter: {c:?}"),
+                WindowEvent::KeyboardInput { .. } => println!("KeyboardInput: {event:?}"),
+                _ => (),
+            },
+            Event::MainEventsCleared => {
+                window.request_redraw();
+            }
+            _ => (),
+        }
+    });
+}
+
+#[cfg(not(target_os = "macos"))]
+fn main() {
+    println!("This example is only supported on MacOS");
+}

examples/window_resize_increments.rs

@@ -0,0 +1,57 @@
+use log::debug;
+use simple_logger::SimpleLogger;
+use winit::{
+    dpi::LogicalSize,
+    event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
+    event_loop::EventLoop,
+    window::WindowBuilder,
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("A fantastic window!")
+        .with_inner_size(LogicalSize::new(128.0, 128.0))
+        .with_resize_increments(LogicalSize::new(25.0, 25.0))
+        .build(&event_loop)
+        .unwrap();
+
+    let mut has_increments = true;
+
+    event_loop.run(move |event, _, control_flow| {
+        control_flow.set_wait();
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                window_id,
+            } if window_id == window.id() => control_flow.set_exit(),
+            Event::WindowEvent {
+                event:
+                    WindowEvent::KeyboardInput {
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(VirtualKeyCode::Space),
+                                state: ElementState::Released,
+                                ..
+                            },
+                        ..
+                    },
+                window_id,
+            } if window_id == window.id() => {
+                has_increments = !has_increments;
+
+                let new_increments = match window.resize_increments() {
+                    Some(_) => None,
+                    None => Some(LogicalSize::new(25.0, 25.0)),
+                };
+                debug!("Had increments: {}", new_increments.is_none());
+                window.set_resize_increments(new_increments);
+            }
+            Event::MainEventsCleared => window.request_redraw(),
+            _ => (),
+        }
+    });
+}

examples/window_run_return.rs

@@ -1,55 +1,64 @@
+#![allow(clippy::single_match)]
+
 // Limit this example to only compatible platforms.
 #[cfg(any(
-    target_os = "windows",
-    target_os = "macos",
-    target_os = "linux",
-    target_os = "dragonfly",
-    target_os = "freebsd",
-    target_os = "netbsd",
-    target_os = "openbsd"
+    windows_platform,
+    macos_platform,
+    x11_platform,
+    wayland_platform,
+    android_platform,
+    orbital_platform,
 ))]
 fn main() {
+    use std::{thread::sleep, time::Duration};
+
+    use simple_logger::SimpleLogger;
     use winit::{
         event::{Event, WindowEvent},
-        event_loop::{ControlFlow, EventLoop},
-        platform::desktop::EventLoopExtDesktop,
+        event_loop::EventLoop,
+        platform::run_return::EventLoopExtRunReturn,
         window::WindowBuilder,
     };
     let mut event_loop = EventLoop::new();
 
-    let window = WindowBuilder::new()
+    SimpleLogger::new().init().unwrap();
+    let _window = WindowBuilder::new()
         .with_title("A fantastic window!")
         .build(&event_loop)
         .unwrap();
 
-    println!("Close the window to continue.");
-    event_loop.run_return(|event, _, control_flow| match event {
-        Event::WindowEvent {
-            event: WindowEvent::CloseRequested,
-            ..
-        } => *control_flow = ControlFlow::Exit,
-        _ => *control_flow = ControlFlow::Wait,
-    });
-    drop(window);
+    let mut quit = false;
 
-    let _window_2 = WindowBuilder::new()
-        .with_title("A second, fantasticer window!")
-        .build(&event_loop)
-        .unwrap();
+    while !quit {
+        event_loop.run_return(|event, _, control_flow| {
+            control_flow.set_wait();
 
-    println!("Wa ha ha! You thought that closing the window would finish this?!");
-    event_loop.run_return(|event, _, control_flow| match event {
-        Event::WindowEvent {
-            event: WindowEvent::CloseRequested,
-            ..
-        } => *control_flow = ControlFlow::Exit,
-        _ => *control_flow = ControlFlow::Wait,
-    });
+            if let Event::WindowEvent { event, .. } = &event {
+                // Print only Window events to reduce noise
+                println!("{event:?}");
+            }
 
-    println!("Okay we're done now for real.");
+            match event {
+                Event::WindowEvent {
+                    event: WindowEvent::CloseRequested,
+                    ..
+                } => {
+                    quit = true;
+                }
+                Event::MainEventsCleared => {
+                    control_flow.set_exit();
+                }
+                _ => (),
+            }
+        });
+
+        // Sleep for 1/60 second to simulate rendering
+        println!("rendering");
+        sleep(Duration::from_millis(16));
+    }
 }
 
-#[cfg(any(target_os = "ios", target_os = "android", target_arch = "wasm32"))]
+#[cfg(any(ios_platform, wasm_platform))]
 fn main() {
     println!("This platform doesn't support run_return.");
 }

run-wasm/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "run-wasm"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+cargo-run-wasm = "0.2.0"

run-wasm/src/main.rs

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

src/dpi.rs

@@ -1,331 +1,583 @@
-//! DPI is important, so read the docs for this module if you don't want to be confused.
+//! UI scaling is important, so read the docs for this module if you don't want to be confused.
 //!
-//! Originally, `winit` dealt entirely in physical pixels (excluding unintentional inconsistencies), but now all
-//! window-related functions both produce and consume logical pixels. Monitor-related functions still use physical
-//! pixels, as do any context-related functions in `glutin`.
+//! ## Why should I care about UI scaling?
 //!
-//! If you've never heard of these terms before, then you're not alone, and this documentation will explain the
-//! concepts.
+//! Modern computer screens don't have a consistent relationship between resolution and size.
+//! 1920x1080 is a common resolution for both desktop and mobile screens, despite mobile screens
+//! normally being less than a quarter the size of their desktop counterparts. What's more, neither
+//! desktop nor mobile screens are consistent resolutions within their own size classes - common
+//! mobile screens range from below 720p to above 1440p, and desktop screens range from 720p to 5K
+//! and beyond.
 //!
-//! Modern screens have a defined physical resolution, most commonly 1920x1080. Indepedent of that is the amount of
-//! space the screen occupies, which is to say, the height and width in millimeters. The relationship between these two
-//! measurements is the *pixel density*. Mobile screens require a high pixel density, as they're held close to the
-//! eyes. Larger displays also require a higher pixel density, hence the growing presence of 1440p and 4K displays.
+//! Given that, it's a mistake to assume that 2D content will only be displayed on screens with
+//! a consistent pixel density. If you were to render a 96-pixel-square image on a 1080p screen,
+//! then render the same image on a similarly-sized 4K screen, the 4K rendition would only take up
+//! about a quarter of the physical space as it did on the 1080p screen. That issue is especially
+//! problematic with text rendering, where quarter-sized text becomes a significant legibility
+//! problem.
 //!
-//! So, this presents a problem. Let's say we want to render a square 100px button. It will occupy 100x100 of the
-//! screen's pixels, which in many cases, seems perfectly fine. However, because this size doesn't account for the
-//! screen's dimensions or pixel density, the button's size can vary quite a bit. On a 4K display, it would be unusably
-//! small.
+//! Failure to account for the scale factor can create a significantly degraded user experience.
+//! Most notably, it can make users feel like they have bad eyesight, which will potentially cause
+//! them to think about growing elderly, resulting in them having an existential crisis. Once users
+//! enter that state, they will no longer be focused on your application.
 //!
-//! That's a description of what happens when the button is 100x100 *physical* pixels. Instead, let's try using 100x100
-//! *logical* pixels. To map logical pixels to physical pixels, we simply multiply by the DPI (dots per inch) factor.
-//! On a "typical" desktop display, the DPI factor will be 1.0, so 100x100 logical pixels equates to 100x100 physical
-//! pixels. However, a 1440p display may have a DPI factor of 1.25, so the button is rendered as 125x125 physical pixels.
-//! Ideally, the button now has approximately the same perceived size across varying displays.
+//! ## How should I handle it?
 //!
-//! Failure to account for the DPI factor can create a badly degraded user experience. Most notably, it can make users
-//! feel like they have bad eyesight, which will potentially cause them to think about growing elderly, resulting in
-//! them entering an existential panic. Once users enter that state, they will no longer be focused on your application.
+//! The solution to this problem is to account for the device's *scale factor*. The scale factor is
+//! the factor UI elements should be scaled by to be consistent with the rest of the user's system -
+//! for example, a button that's normally 50 pixels across would be 100 pixels across on a device
+//! with a scale factor of `2.0`, or 75 pixels across with a scale factor of `1.5`.
 //!
-//! There are two ways to get the DPI factor:
-//! - You can track the [`HiDpiFactorChanged`](../enum.WindowEvent.html#variant.HiDpiFactorChanged) event of your
-//!   windows. This event is sent any time the DPI factor changes, either because the window moved to another monitor,
-//!   or because the user changed the configuration of their screen.
-//! - You can also retrieve the DPI factor of a monitor by calling
-//!   [`MonitorHandle::hidpi_factor`](../monitor/struct.MonitorHandle.html#method.hidpi_factor), or the
-//!   current DPI factor applied to a window by calling
-//!   [`Window::hidpi_factor`](../window/struct.Window.html#method.hidpi_factor), which is roughly equivalent
-//!   to `window.current_monitor().hidpi_factor()`.
+//! Many UI systems, such as CSS, expose DPI-dependent units like [points] or [picas]. That's
+//! usually a mistake, since there's no consistent mapping between the scale factor and the screen's
+//! actual DPI. Unless you're printing to a physical medium, you should work in scaled pixels rather
+//! than any DPI-dependent units.
 //!
-//! Depending on the platform, the window's actual DPI factor may only be known after
-//! the event loop has started and your window has been drawn once. To properly handle these cases,
-//! the most robust way is to monitor the [`HiDpiFactorChanged`](../enum.WindowEvent.html#variant.HiDpiFactorChanged)
-//! event and dynamically adapt your drawing logic to follow the DPI factor.
+//! ### Position and Size types
 //!
-//! Here's an overview of what sort of DPI factors you can expect, and where they come from:
-//! - **Windows:** On Windows 8 and 10, per-monitor scaling is readily configured by users from the display settings.
-//! While users are free to select any option they want, they're only given a selection of "nice" DPI factors, i.e.
-//! 1.0, 1.25, 1.5... on Windows 7, the DPI factor is global and changing it requires logging out.
-//! - **macOS:** The buzzword is "retina displays", which have a DPI factor of 2.0. Otherwise, the DPI factor is 1.0.
-//! Intermediate DPI factors are never used, thus 1440p displays/etc. aren't properly supported. It's possible for any
-//! display to use that 2.0 DPI factor, given the use of the command line.
-//! - **X11:** On X11, we calcuate the DPI factor based on the millimeter dimensions provided by XRandR. This can
-//! result in a wide range of possible values, including some interesting ones like 1.0833333333333333. This can be
-//! overridden using the `WINIT_HIDPI_FACTOR` environment variable, though that's not recommended.
-//! - **Wayland:** On Wayland, DPI factors are set per-screen by the server, and are always integers (most often 1 or 2).
-//! - **iOS:** DPI factors are both constant and device-specific on iOS.
-//! - **Android:** This feature isn't yet implemented on Android, so the DPI factor will always be returned as 1.0.
-//! - **Web:** DPI factors are handled by the browser and will always be 1.0 for your application.
+//! Winit's [`PhysicalPosition`] / [`PhysicalSize`] types correspond with the actual pixels on the
+//! device, and the [`LogicalPosition`] / [`LogicalSize`] types correspond to the physical pixels
+//! divided by the scale factor.
+//! All of Winit's functions return physical types, but can take either logical or physical
+//! coordinates as input, allowing you to use the most convenient coordinate system for your
+//! particular application.
 //!
-//! The window's logical size is conserved across DPI changes, resulting in the physical size changing instead. This
-//! may be surprising on X11, but is quite standard elsewhere. Physical size changes always produce a
-//! [`Resized`](../event/enum.WindowEvent.html#variant.Resized) event, even on platforms where no resize actually occurs,
-//! such as macOS and Wayland. As a result, it's not necessary to separately handle
-//! [`HiDpiFactorChanged`](../event/enum.WindowEvent.html#variant.HiDpiFactorChanged) if you're only listening for size.
+//! Winit's position and size types 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
+//! floating precision when necessary (e.g. logical sizes for fractional scale factors and touch
+//! input). If `P` is a floating-point type, please do not cast the values with `as {int}`. Doing so
+//! will truncate the fractional part of the float, rather than properly round to the nearest
+//! integer. Use the provided `cast` function or [`From`]/[`Into`] conversions, which handle the
+//! rounding properly. Note that precision loss will still occur when rounding from a float to an
+//! int, although rounding lessens the problem.
 //!
-//! Your GPU has no awareness of the concept of logical pixels, and unless you like wasting pixel density, your
-//! framebuffer's size should be in physical pixels.
+//! ### Events
 //!
-//! `winit` will send [`Resized`](../enum.WindowEvent.html#variant.Resized) events whenever a window's logical size
-//! changes, and [`HiDpiFactorChanged`](../enum.WindowEvent.html#variant.HiDpiFactorChanged) events
-//! whenever the DPI factor changes. Receiving either of these events means that the physical size of your window has
-//! changed, and you should recompute it using the latest values you received for each. If the logical size and the
-//! DPI factor change simultaneously, `winit` will send both events together; thus, it's recommended to buffer
-//! these events and process them at the end of the queue.
+//! Winit will dispatch a [`ScaleFactorChanged`] event whenever a window's scale factor has changed.
+//! This can happen if the user drags their window from a standard-resolution monitor to a high-DPI
+//! monitor, or if the user changes their DPI settings. This gives you a chance to rescale your
+//! application's UI elements and adjust how the platform changes the window's size to reflect the new
+//! scale factor. If a window hasn't received a [`ScaleFactorChanged`] event,  then its scale factor
+//! can be found by calling [`window.scale_factor()`].
 //!
-//! If you never received any [`HiDpiFactorChanged`](../enum.WindowEvent.html#variant.HiDpiFactorChanged) events,
-//! then your window's DPI factor is 1.
+//! ## How is the scale factor calculated?
+//!
+//! Scale factor is calculated differently on different platforms:
+//!
+//! - **Windows:** On Windows 8 and 10, per-monitor scaling is readily configured by users from the
+//!   display settings. While users are free to select any option they want, they're only given a
+//!   selection of "nice" scale factors, i.e. 1.0, 1.25, 1.5... on Windows 7, the scale factor is
+//!   global and changing it requires logging out. See [this article][windows_1] for technical
+//!   details.
+//! - **macOS:** Recent versions of macOS allow the user to change the scaling factor for certain
+//!   displays. When this is available, the user may pick a per-monitor scaling factor from a set
+//!   of pre-defined settings. All "retina displays" have a scaling factor above 1.0 by default but
+//!   the specific value varies across devices.
+//! - **X11:** Many man-hours have been spent trying to figure out how to handle DPI in X11. Winit
+//!   currently uses a three-pronged approach:
+//!   + Use the value in the `WINIT_X11_SCALE_FACTOR` environment variable, if present.
+//!   + If not present, use the value set in `Xft.dpi` in Xresources.
+//!   + Otherwise, calculate the scale factor based on the millimeter monitor dimensions provided by XRandR.
+//!
+//!   If `WINIT_X11_SCALE_FACTOR` is set to `randr`, it'll ignore the `Xft.dpi` field and use the
+//!   XRandR scaling method. Generally speaking, you should try to configure the standard system
+//!   variables to do what you want before resorting to `WINIT_X11_SCALE_FACTOR`.
+//! - **Wayland:** On Wayland, scale factors are set per-screen by the server, and are always
+//!   integers (most often 1 or 2).
+//! - **iOS:** Scale factors are set by Apple to the value that best suits the device, and range
+//!   from `1.0` to `3.0`. See [this article][apple_1] and [this article][apple_2] for more
+//!   information.
+//! - **Android:** Scale factors are set by the manufacturer to the value that best suits the
+//!   device, and range from `1.0` to `4.0`. See [this article][android_1] for more information.
+//! - **Web:** The scale factor is the ratio between CSS pixels and the physical device pixels.
+//!   In other words, it is the value of [`window.devicePixelRatio`][web_1]. It is affected by
+//!   both the screen scaling and the browser zoom level and can go below `1.0`.
+//!
+//!
+//! [points]: https://en.wikipedia.org/wiki/Point_(typography)
+//! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)
+//! [`ScaleFactorChanged`]: crate::event::WindowEvent::ScaleFactorChanged
+//! [`window.scale_factor()`]: crate::window::Window::scale_factor
+//! [windows_1]: https://docs.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows
+//! [apple_1]: https://developer.apple.com/library/archive/documentation/DeviceInformation/Reference/iOSDeviceCompatibility/Displays/Displays.html
+//! [apple_2]: https://developer.apple.com/design/human-interface-guidelines/macos/icons-and-images/image-size-and-resolution/
+//! [android_1]: https://developer.android.com/training/multiscreen/screendensities
+//! [web_1]: https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio
 
-/// Checks that the DPI factor is a normal positive `f64`.
+pub trait Pixel: Copy + Into<f64> {
+    fn from_f64(f: f64) -> Self;
+    fn cast<P: Pixel>(self) -> P {
+        P::from_f64(self.into())
+    }
+}
+
+impl Pixel for u8 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as u8
+    }
+}
+impl Pixel for u16 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as u16
+    }
+}
+impl Pixel for u32 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as u32
+    }
+}
+impl Pixel for i8 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as i8
+    }
+}
+impl Pixel for i16 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as i16
+    }
+}
+impl Pixel for i32 {
+    fn from_f64(f: f64) -> Self {
+        f.round() as i32
+    }
+}
+impl Pixel for f32 {
+    fn from_f64(f: f64) -> Self {
+        f as f32
+    }
+}
+impl Pixel for f64 {
+    fn from_f64(f: f64) -> Self {
+        f
+    }
+}
+
+/// Checks that the scale factor is a normal positive `f64`.
 ///
-/// All functions that take a DPI factor assert that this will return `true`. If you're sourcing DPI factors from
+/// 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_hidpi_factor(dpi_factor: f64) -> bool {
-    dpi_factor.is_sign_positive() && dpi_factor.is_normal()
+pub fn validate_scale_factor(scale_factor: f64) -> bool {
+    scale_factor.is_sign_positive() && scale_factor.is_normal()
 }
 
 /// A position represented in logical pixels.
 ///
-/// The position is stored as floats, so please be careful. Casting floats to integers truncates the fractional part,
-/// which can cause noticable issues. To help with that, an `Into<(i32, i32)>` implementation is provided which
-/// does the rounding for you.
-#[derive(Debug, Copy, Clone, PartialEq)]
+/// The position is stored as floats, so please be careful. Casting floats to integers truncates the
+/// fractional part, which can cause noticable issues. To help with that, an `Into<(i32, i32)>`
+/// implementation is provided which does the rounding for you.
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct LogicalPosition {
-    pub x: f64,
-    pub y: f64,
+pub struct LogicalPosition<P> {
+    pub x: P,
+    pub y: P,
 }
 
-impl LogicalPosition {
+impl<P> LogicalPosition<P> {
     #[inline]
-    pub fn new(x: f64, y: f64) -> Self {
+    pub const fn new(x: P, y: P) -> Self {
         LogicalPosition { x, y }
     }
+}
 
+impl<P: Pixel> LogicalPosition<P> {
     #[inline]
-    pub fn from_physical<T: Into<PhysicalPosition>>(physical: T, dpi_factor: f64) -> Self {
-        physical.into().to_logical(dpi_factor)
+    pub fn from_physical<T: Into<PhysicalPosition<X>>, X: Pixel>(
+        physical: T,
+        scale_factor: f64,
+    ) -> Self {
+        physical.into().to_logical(scale_factor)
     }
 
     #[inline]
-    pub fn to_physical(&self, dpi_factor: f64) -> PhysicalPosition {
-        assert!(validate_hidpi_factor(dpi_factor));
-        let x = self.x * dpi_factor;
-        let y = self.y * dpi_factor;
-        PhysicalPosition::new(x, y)
+    pub fn to_physical<X: Pixel>(&self, scale_factor: f64) -> PhysicalPosition<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let x = self.x.into() * scale_factor;
+        let y = self.y.into() * scale_factor;
+        PhysicalPosition::new(x, y).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> LogicalPosition<X> {
+        LogicalPosition {
+            x: self.x.cast(),
+            y: self.y.cast(),
+        }
     }
 }
 
-impl From<(f64, f64)> for LogicalPosition {
-    #[inline]
-    fn from((x, y): (f64, f64)) -> Self {
-        Self::new(x, y)
+impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalPosition<P> {
+    fn from((x, y): (X, X)) -> LogicalPosition<P> {
+        LogicalPosition::new(x.cast(), y.cast())
     }
 }
 
-impl From<(i32, i32)> for LogicalPosition {
-    #[inline]
-    fn from((x, y): (i32, i32)) -> Self {
-        Self::new(x as f64, y as f64)
+impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for (X, X) {
+    fn from(p: LogicalPosition<P>) -> (X, X) {
+        (p.x.cast(), p.y.cast())
     }
 }
 
-impl Into<(f64, f64)> for LogicalPosition {
-    #[inline]
-    fn into(self) -> (f64, f64) {
-        (self.x, self.y)
+impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalPosition<P> {
+    fn from([x, y]: [X; 2]) -> LogicalPosition<P> {
+        LogicalPosition::new(x.cast(), y.cast())
     }
 }
 
-impl Into<(i32, i32)> for LogicalPosition {
-    /// Note that this rounds instead of truncating.
-    #[inline]
-    fn into(self) -> (i32, i32) {
-        (self.x.round() as _, self.y.round() as _)
+impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for [X; 2] {
+    fn from(p: LogicalPosition<P>) -> [X; 2] {
+        [p.x.cast(), p.y.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Point2<P>> for LogicalPosition<P> {
+    fn from(p: mint::Point2<P>) -> Self {
+        Self::new(p.x, p.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<LogicalPosition<P>> for mint::Point2<P> {
+    fn from(p: LogicalPosition<P>) -> Self {
+        mint::Point2 { x: p.x, y: p.y }
     }
 }
 
 /// A position represented in physical pixels.
-///
-/// The position is stored as floats, so please be careful. Casting floats to integers truncates the fractional part,
-/// which can cause noticable issues. To help with that, an `Into<(i32, i32)>` implementation is provided which
-/// does the rounding for you.
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct PhysicalPosition {
-    pub x: f64,
-    pub y: f64,
+pub struct PhysicalPosition<P> {
+    pub x: P,
+    pub y: P,
 }
 
-impl PhysicalPosition {
+impl<P> PhysicalPosition<P> {
     #[inline]
-    pub fn new(x: f64, y: f64) -> Self {
+    pub const fn new(x: P, y: P) -> Self {
         PhysicalPosition { x, y }
     }
+}
 
+impl<P: Pixel> PhysicalPosition<P> {
     #[inline]
-    pub fn from_logical<T: Into<LogicalPosition>>(logical: T, dpi_factor: f64) -> Self {
-        logical.into().to_physical(dpi_factor)
+    pub fn from_logical<T: Into<LogicalPosition<X>>, X: Pixel>(
+        logical: T,
+        scale_factor: f64,
+    ) -> Self {
+        logical.into().to_physical(scale_factor)
     }
 
     #[inline]
-    pub fn to_logical(&self, dpi_factor: f64) -> LogicalPosition {
-        assert!(validate_hidpi_factor(dpi_factor));
-        let x = self.x / dpi_factor;
-        let y = self.y / dpi_factor;
-        LogicalPosition::new(x, y)
+    pub fn to_logical<X: Pixel>(&self, scale_factor: f64) -> LogicalPosition<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let x = self.x.into() / scale_factor;
+        let y = self.y.into() / scale_factor;
+        LogicalPosition::new(x, y).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> PhysicalPosition<X> {
+        PhysicalPosition {
+            x: self.x.cast(),
+            y: self.y.cast(),
+        }
     }
 }
 
-impl From<(f64, f64)> for PhysicalPosition {
-    #[inline]
-    fn from((x, y): (f64, f64)) -> Self {
-        Self::new(x, y)
+impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalPosition<P> {
+    fn from((x, y): (X, X)) -> PhysicalPosition<P> {
+        PhysicalPosition::new(x.cast(), y.cast())
     }
 }
 
-impl From<(i32, i32)> for PhysicalPosition {
-    #[inline]
-    fn from((x, y): (i32, i32)) -> Self {
-        Self::new(x as f64, y as f64)
+impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for (X, X) {
+    fn from(p: PhysicalPosition<P>) -> (X, X) {
+        (p.x.cast(), p.y.cast())
     }
 }
 
-impl Into<(f64, f64)> for PhysicalPosition {
-    #[inline]
-    fn into(self) -> (f64, f64) {
-        (self.x, self.y)
+impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalPosition<P> {
+    fn from([x, y]: [X; 2]) -> PhysicalPosition<P> {
+        PhysicalPosition::new(x.cast(), y.cast())
     }
 }
 
-impl Into<(i32, i32)> for PhysicalPosition {
-    /// Note that this rounds instead of truncating.
-    #[inline]
-    fn into(self) -> (i32, i32) {
-        (self.x.round() as _, self.y.round() as _)
+impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for [X; 2] {
+    fn from(p: PhysicalPosition<P>) -> [X; 2] {
+        [p.x.cast(), p.y.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Point2<P>> for PhysicalPosition<P> {
+    fn from(p: mint::Point2<P>) -> Self {
+        Self::new(p.x, p.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<PhysicalPosition<P>> for mint::Point2<P> {
+    fn from(p: PhysicalPosition<P>) -> Self {
+        mint::Point2 { x: p.x, y: p.y }
     }
 }
 
 /// A size represented in logical pixels.
-///
-/// The size is stored as floats, so please be careful. Casting floats to integers truncates the fractional part,
-/// which can cause noticable issues. To help with that, an `Into<(u32, u32)>` implementation is provided which
-/// does the rounding for you.
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct LogicalSize {
-    pub width: f64,
-    pub height: f64,
+pub struct LogicalSize<P> {
+    pub width: P,
+    pub height: P,
 }
 
-impl LogicalSize {
+impl<P> LogicalSize<P> {
     #[inline]
-    pub fn new(width: f64, height: f64) -> Self {
+    pub const fn new(width: P, height: P) -> Self {
         LogicalSize { width, height }
     }
+}
 
+impl<P: Pixel> LogicalSize<P> {
     #[inline]
-    pub fn from_physical<T: Into<PhysicalSize>>(physical: T, dpi_factor: f64) -> Self {
-        physical.into().to_logical(dpi_factor)
+    pub fn from_physical<T: Into<PhysicalSize<X>>, X: Pixel>(
+        physical: T,
+        scale_factor: f64,
+    ) -> Self {
+        physical.into().to_logical(scale_factor)
     }
 
     #[inline]
-    pub fn to_physical(&self, dpi_factor: f64) -> PhysicalSize {
-        assert!(validate_hidpi_factor(dpi_factor));
-        let width = self.width * dpi_factor;
-        let height = self.height * dpi_factor;
-        PhysicalSize::new(width, height)
+    pub fn to_physical<X: Pixel>(&self, scale_factor: f64) -> PhysicalSize<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let width = self.width.into() * scale_factor;
+        let height = self.height.into() * scale_factor;
+        PhysicalSize::new(width, height).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> LogicalSize<X> {
+        LogicalSize {
+            width: self.width.cast(),
+            height: self.height.cast(),
+        }
     }
 }
 
-impl From<(f64, f64)> for LogicalSize {
-    #[inline]
-    fn from((width, height): (f64, f64)) -> Self {
-        Self::new(width, height)
+impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalSize<P> {
+    fn from((x, y): (X, X)) -> LogicalSize<P> {
+        LogicalSize::new(x.cast(), y.cast())
     }
 }
 
-impl From<(u32, u32)> for LogicalSize {
-    #[inline]
-    fn from((width, height): (u32, u32)) -> Self {
-        Self::new(width as f64, height as f64)
+impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for (X, X) {
+    fn from(s: LogicalSize<P>) -> (X, X) {
+        (s.width.cast(), s.height.cast())
     }
 }
 
-impl Into<(f64, f64)> for LogicalSize {
-    #[inline]
-    fn into(self) -> (f64, f64) {
-        (self.width, self.height)
+impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalSize<P> {
+    fn from([x, y]: [X; 2]) -> LogicalSize<P> {
+        LogicalSize::new(x.cast(), y.cast())
     }
 }
 
-impl Into<(u32, u32)> for LogicalSize {
-    /// Note that this rounds instead of truncating.
-    #[inline]
-    fn into(self) -> (u32, u32) {
-        (self.width.round() as _, self.height.round() as _)
+impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for [X; 2] {
+    fn from(s: LogicalSize<P>) -> [X; 2] {
+        [s.width.cast(), s.height.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Vector2<P>> for LogicalSize<P> {
+    fn from(v: mint::Vector2<P>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<LogicalSize<P>> for mint::Vector2<P> {
+    fn from(s: LogicalSize<P>) -> Self {
+        mint::Vector2 {
+            x: s.width,
+            y: s.height,
+        }
     }
 }
 
 /// A size represented in physical pixels.
-///
-/// The size is stored as floats, so please be careful. Casting floats to integers truncates the fractional part,
-/// which can cause noticable issues. To help with that, an `Into<(u32, u32)>` implementation is provided which
-/// does the rounding for you.
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct PhysicalSize {
-    pub width: f64,
-    pub height: f64,
+pub struct PhysicalSize<P> {
+    pub width: P,
+    pub height: P,
 }
 
-impl PhysicalSize {
+impl<P> PhysicalSize<P> {
     #[inline]
-    pub fn new(width: f64, height: f64) -> Self {
+    pub const fn new(width: P, height: P) -> Self {
         PhysicalSize { width, height }
     }
+}
 
+impl<P: Pixel> PhysicalSize<P> {
     #[inline]
-    pub fn from_logical<T: Into<LogicalSize>>(logical: T, dpi_factor: f64) -> Self {
-        logical.into().to_physical(dpi_factor)
+    pub fn from_logical<T: Into<LogicalSize<X>>, X: Pixel>(logical: T, scale_factor: f64) -> Self {
+        logical.into().to_physical(scale_factor)
     }
 
     #[inline]
-    pub fn to_logical(&self, dpi_factor: f64) -> LogicalSize {
-        assert!(validate_hidpi_factor(dpi_factor));
-        let width = self.width / dpi_factor;
-        let height = self.height / dpi_factor;
-        LogicalSize::new(width, height)
+    pub fn to_logical<X: Pixel>(&self, scale_factor: f64) -> LogicalSize<X> {
+        assert!(validate_scale_factor(scale_factor));
+        let width = self.width.into() / scale_factor;
+        let height = self.height.into() / scale_factor;
+        LogicalSize::new(width, height).cast()
+    }
+
+    #[inline]
+    pub fn cast<X: Pixel>(&self) -> PhysicalSize<X> {
+        PhysicalSize {
+            width: self.width.cast(),
+            height: self.height.cast(),
+        }
     }
 }
 
-impl From<(f64, f64)> for PhysicalSize {
-    #[inline]
-    fn from((width, height): (f64, f64)) -> Self {
-        Self::new(width, height)
+impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalSize<P> {
+    fn from((x, y): (X, X)) -> PhysicalSize<P> {
+        PhysicalSize::new(x.cast(), y.cast())
     }
 }
 
-impl From<(u32, u32)> for PhysicalSize {
-    #[inline]
-    fn from((width, height): (u32, u32)) -> Self {
-        Self::new(width as f64, height as f64)
+impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for (X, X) {
+    fn from(s: PhysicalSize<P>) -> (X, X) {
+        (s.width.cast(), s.height.cast())
     }
 }
 
-impl Into<(f64, f64)> for PhysicalSize {
-    #[inline]
-    fn into(self) -> (f64, f64) {
-        (self.width, self.height)
+impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalSize<P> {
+    fn from([x, y]: [X; 2]) -> PhysicalSize<P> {
+        PhysicalSize::new(x.cast(), y.cast())
     }
 }
 
-impl Into<(u32, u32)> for PhysicalSize {
-    /// Note that this rounds instead of truncating.
-    #[inline]
-    fn into(self) -> (u32, u32) {
-        (self.width.round() as _, self.height.round() as _)
+impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for [X; 2] {
+    fn from(s: PhysicalSize<P>) -> [X; 2] {
+        [s.width.cast(), s.height.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Vector2<P>> for PhysicalSize<P> {
+    fn from(v: mint::Vector2<P>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<PhysicalSize<P>> for mint::Vector2<P> {
+    fn from(s: PhysicalSize<P>) -> Self {
+        mint::Vector2 {
+            x: s.width,
+            y: s.height,
+        }
+    }
+}
+
+/// A size that's either physical or logical.
+#[derive(Debug, Copy, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum Size {
+    Physical(PhysicalSize<u32>),
+    Logical(LogicalSize<f64>),
+}
+
+impl Size {
+    pub fn new<S: Into<Size>>(size: S) -> Size {
+        size.into()
+    }
+
+    pub fn to_logical<P: Pixel>(&self, scale_factor: f64) -> LogicalSize<P> {
+        match *self {
+            Size::Physical(size) => size.to_logical(scale_factor),
+            Size::Logical(size) => size.cast(),
+        }
+    }
+
+    pub fn to_physical<P: Pixel>(&self, scale_factor: f64) -> PhysicalSize<P> {
+        match *self {
+            Size::Physical(size) => size.cast(),
+            Size::Logical(size) => size.to_physical(scale_factor),
+        }
+    }
+
+    pub fn clamp<S: Into<Size>>(input: S, min: S, max: S, scale_factor: f64) -> Size {
+        let (input, min, max) = (
+            input.into().to_physical::<f64>(scale_factor),
+            min.into().to_physical::<f64>(scale_factor),
+            max.into().to_physical::<f64>(scale_factor),
+        );
+
+        let width = input.width.clamp(min.width, max.width);
+        let height = input.height.clamp(min.height, max.height);
+
+        PhysicalSize::new(width, height).into()
+    }
+}
+
+impl<P: Pixel> From<PhysicalSize<P>> for Size {
+    #[inline]
+    fn from(size: PhysicalSize<P>) -> Size {
+        Size::Physical(size.cast())
+    }
+}
+
+impl<P: Pixel> From<LogicalSize<P>> for Size {
+    #[inline]
+    fn from(size: LogicalSize<P>) -> Size {
+        Size::Logical(size.cast())
+    }
+}
+
+/// A position that's either physical or logical.
+#[derive(Debug, Copy, Clone, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum Position {
+    Physical(PhysicalPosition<i32>),
+    Logical(LogicalPosition<f64>),
+}
+
+impl Position {
+    pub fn new<S: Into<Position>>(position: S) -> Position {
+        position.into()
+    }
+
+    pub fn to_logical<P: Pixel>(&self, scale_factor: f64) -> LogicalPosition<P> {
+        match *self {
+            Position::Physical(position) => position.to_logical(scale_factor),
+            Position::Logical(position) => position.cast(),
+        }
+    }
+
+    pub fn to_physical<P: Pixel>(&self, scale_factor: f64) -> PhysicalPosition<P> {
+        match *self {
+            Position::Physical(position) => position.cast(),
+            Position::Logical(position) => position.to_physical(scale_factor),
+        }
+    }
+}
+
+impl<P: Pixel> From<PhysicalPosition<P>> for Position {
+    #[inline]
+    fn from(position: PhysicalPosition<P>) -> Position {
+        Position::Physical(position.cast())
+    }
+}
+
+impl<P: Pixel> From<LogicalPosition<P>> for Position {
+    #[inline]
+    fn from(position: LogicalPosition<P>) -> Position {
+        Position::Logical(position.cast())
     }
 }

src/event_loop.rs

@@ -1,48 +1,127 @@
-//! The `EventLoop` struct and assorted supporting types, including `ControlFlow`.
+//! The [`EventLoop`] struct and assorted supporting types, including
+//! [`ControlFlow`].
 //!
-//! If you want to send custom events to the event loop, use [`EventLoop::create_proxy()`][create_proxy]
-//! to acquire an [`EventLoopProxy`][event_loop_proxy] and call its [`send_event`][send_event] method.
+//! If you want to send custom events to the event loop, use
+//! [`EventLoop::create_proxy`] to acquire an [`EventLoopProxy`] and call its
+//! [`send_event`](`EventLoopProxy::send_event`) method.
 //!
 //! See the root-level documentation for information on how to create and use an event loop to
 //! handle events.
-//!
-//! [create_proxy]: ./struct.EventLoop.html#method.create_proxy
-//! [event_loop_proxy]: ./struct.EventLoopProxy.html
-//! [send_event]: ./struct.EventLoopProxy.html#method.send_event
-use instant::Instant;
+use std::marker::PhantomData;
 use std::ops::Deref;
 use std::{error, fmt};
 
+use instant::{Duration, Instant};
+use once_cell::sync::OnceCell;
+use raw_window_handle::{HasRawDisplayHandle, RawDisplayHandle};
+
 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.
 ///
-/// An `EventLoop` can be seen more or less as a "context". Calling `EventLoop::new()`
+/// An `EventLoop` can be seen more or less as a "context". Calling [`EventLoop::new`]
 /// initializes everything that will be required to create windows. For example on Linux creating
 /// an event loop opens a connection to the X or Wayland server.
 ///
-/// To wake up an `EventLoop` from a another thread, see the `EventLoopProxy` docs.
+/// To wake up an `EventLoop` from a another thread, see the [`EventLoopProxy`] docs.
 ///
-/// Note that the `EventLoop` 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 `EventLoop` _can_ be sent to an other thread, and the
-/// `EventLoopProxy` allows you to wake up an `EventLoop` from another thread.
+/// Note that this cannot be shared across threads (due to platform-dependant logic
+/// forbidding it), as such it is neither [`Send`] nor [`Sync`]. If you need cross-thread access, the
+/// [`Window`] created from this _can_ be sent to an other thread, and the
+/// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread.
 ///
+/// [`Window`]: crate::window::Window
 pub struct EventLoop<T: 'static> {
     pub(crate) event_loop: platform_impl::EventLoop<T>,
-    pub(crate) _marker: ::std::marker::PhantomData<*mut ()>, // Not Send nor Sync
+    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
 }
 
-/// Target that associates windows with an `EventLoop`.
+/// Target that associates windows with an [`EventLoop`].
 ///
 /// This type exists to allow you to create new windows while Winit executes
-/// your callback. `EventLoop` will coerce into this type (`impl<T> Deref for
+/// your callback. [`EventLoop`] will coerce into this type (`impl<T> Deref for
 /// EventLoop<T>`), so functions that take this as a parameter can also take
 /// `&EventLoop`.
 pub struct EventLoopWindowTarget<T: 'static> {
     pub(crate) p: platform_impl::EventLoopWindowTarget<T>,
-    pub(crate) _marker: ::std::marker::PhantomData<*mut ()>, // Not Send nor Sync
+    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
+}
+
+/// Object that allows building the event loop.
+///
+/// This is used to make specifying options that affect the whole application
+/// easier. But note that constructing multiple event loops is not supported.
+#[derive(Default)]
+pub struct EventLoopBuilder<T: 'static> {
+    pub(crate) platform_specific: platform_impl::PlatformSpecificEventLoopAttributes,
+    _p: PhantomData<T>,
+}
+
+impl EventLoopBuilder<()> {
+    /// Start building a new event loop.
+    #[inline]
+    pub fn new() -> Self {
+        Self::with_user_event()
+    }
+}
+
+impl<T> EventLoopBuilder<T> {
+    /// Start building a new event loop, with the given type as the user event
+    /// type.
+    #[inline]
+    pub fn with_user_event() -> Self {
+        Self {
+            platform_specific: Default::default(),
+            _p: PhantomData,
+        }
+    }
+
+    /// Builds a new event loop.
+    ///
+    /// ***For cross-platform compatibility, the [`EventLoop`] must be created on the main thread,
+    /// and only once per application.***
+    ///
+    /// Attempting to create the event loop on a different thread, or multiple event loops in
+    /// the same application, will panic. This restriction isn't
+    /// strictly necessary on all platforms, but is imposed to eliminate any nasty surprises when
+    /// porting to platforms that require it. `EventLoopBuilderExt::any_thread` functions are exposed
+    /// in the relevant [`platform`] module if the target platform supports creating an event loop on
+    /// any thread.
+    ///
+    /// Calling this function will result in display backend initialisation.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Linux:** Backend type can be controlled using an environment variable
+    ///   `WINIT_UNIX_BACKEND`. Legal values are `x11` and `wayland`.
+    ///   If it is not set, winit will try to connect to a Wayland connection, and if that fails,
+    ///   will fall back on X11. If this variable is set with any other value, winit will panic.
+    /// - **Android:** Must be configured with an `AndroidApp` from `android_main()` by calling
+    ///     [`.with_android_app(app)`] before calling `.build()`.
+    ///
+    /// [`platform`]: crate::platform
+    #[cfg_attr(
+        android,
+        doc = "[`.with_android_app(app)`]: crate::platform::android::EventLoopBuilderExtAndroid::with_android_app"
+    )]
+    #[cfg_attr(
+        not(android),
+        doc = "[`.with_android_app(app)`]: #only-available-on-android"
+    )]
+    #[inline]
+    pub fn build(&mut self) -> EventLoop<T> {
+        static EVENT_LOOP_CREATED: OnceCell<()> = OnceCell::new();
+        if EVENT_LOOP_CREATED.set(()).is_err() {
+            panic!("Creating EventLoop multiple times is not supported.");
+        }
+        // Certain platforms accept a mutable reference in their API.
+        #[allow(clippy::unnecessary_mut_passed)]
+        EventLoop {
+            event_loop: platform_impl::EventLoop::new(&mut self.platform_specific),
+            _marker: PhantomData,
+        }
+    }
 }
 
 impl<T> fmt::Debug for EventLoop<T> {
@@ -57,77 +136,150 @@ impl<T> fmt::Debug for EventLoopWindowTarget<T> {
     }
 }
 
-/// Set by the user callback given to the `EventLoop::run` method.
+/// Set by the user callback given to the [`EventLoop::run`] method.
 ///
-/// Indicates the desired behavior of the event loop after [`Event::EventsCleared`][events_cleared]
-/// is emitted. Defaults to `Poll`.
+/// Indicates the desired behavior of the event loop after [`Event::RedrawEventsCleared`] is emitted.
+///
+/// Defaults to [`Poll`].
 ///
 /// ## Persistency
-/// Almost every change is persistent between multiple calls to the event loop closure within a
-/// given run loop. The only exception to this is `Exit` which, once set, cannot be unset. Changes
-/// are **not** persistent between multiple calls to `run_return` - issuing a new call will reset
-/// the control flow to `Poll`.
 ///
-/// [events_cleared]: ../event/enum.Event.html#variant.EventsCleared
+/// Almost every change is persistent between multiple calls to the event loop closure within a
+/// given run loop. The only exception to this is [`ExitWithCode`] which, once set, cannot be unset.
+/// Changes are **not** persistent between multiple calls to `run_return` - issuing a new call will
+/// reset the control flow to [`Poll`].
+///
+/// [`ExitWithCode`]: Self::ExitWithCode
+/// [`Poll`]: Self::Poll
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum ControlFlow {
     /// When the current loop iteration finishes, immediately begin a new iteration regardless of
     /// whether or not new events are available to process.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web:** Events are queued and usually sent when `requestAnimationFrame` fires but sometimes
+    ///   the events in the queue may be sent before the next `requestAnimationFrame` callback, for
+    ///   example when the scaling of the page has changed. This should be treated as an implementation
+    ///   detail which should not be relied on.
     Poll,
+
     /// When the current loop iteration finishes, suspend the thread until another event arrives.
     Wait,
+
     /// When the current loop iteration finishes, suspend the thread until either another event
     /// arrives or the given time is reached.
+    ///
+    /// Useful for implementing efficient timers. Applications which want to render at the display's
+    /// native refresh rate should instead use [`Poll`] and the VSync functionality of a graphics API
+    /// to reduce odds of missed frames.
+    ///
+    /// [`Poll`]: Self::Poll
     WaitUntil(Instant),
-    /// Send a `LoopDestroyed` event and stop the event loop. This variant is *sticky* - once set,
-    /// `control_flow` cannot be changed from `Exit`, and any future attempts to do so will result
-    /// in the `control_flow` parameter being reset to `Exit`.
-    Exit,
+
+    /// Send a [`LoopDestroyed`] event and stop the event loop. This variant is *sticky* - once set,
+    /// `control_flow` cannot be changed from `ExitWithCode`, and any future attempts to do so will
+    /// result in the `control_flow` parameter being reset to `ExitWithCode`.
+    ///
+    /// The contained number will be used as exit code. The [`Exit`] constant is a shortcut for this
+    /// with exit code 0.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Android / iOS / WASM:** The supplied exit code is unused.
+    /// - **Unix:** On most Unix-like platforms, only the 8 least significant bits will be used,
+    ///   which can cause surprises with negative exit values (`-42` would end up as `214`). See
+    ///   [`std::process::exit`].
+    ///
+    /// [`LoopDestroyed`]: Event::LoopDestroyed
+    /// [`Exit`]: ControlFlow::Exit
+    ExitWithCode(i32),
+}
+
+impl ControlFlow {
+    /// Alias for [`ExitWithCode`]`(0)`.
+    ///
+    /// [`ExitWithCode`]: Self::ExitWithCode
+    #[allow(non_upper_case_globals)]
+    pub const Exit: Self = Self::ExitWithCode(0);
+
+    /// Sets this to [`Poll`].
+    ///
+    /// [`Poll`]: Self::Poll
+    pub fn set_poll(&mut self) {
+        *self = Self::Poll;
+    }
+
+    /// Sets this to [`Wait`].
+    ///
+    /// [`Wait`]: Self::Wait
+    pub fn set_wait(&mut self) {
+        *self = Self::Wait;
+    }
+
+    /// Sets this to [`WaitUntil`]`(instant)`.
+    ///
+    /// [`WaitUntil`]: Self::WaitUntil
+    pub fn set_wait_until(&mut self, instant: Instant) {
+        *self = Self::WaitUntil(instant);
+    }
+
+    /// Sets this to wait until a timeout has expired.
+    ///
+    /// In most cases, this is set to [`WaitUntil`]. However, if the timeout overflows, it is
+    /// instead set to [`Wait`].
+    ///
+    /// [`WaitUntil`]: Self::WaitUntil
+    /// [`Wait`]: Self::Wait
+    pub fn set_wait_timeout(&mut self, timeout: Duration) {
+        match Instant::now().checked_add(timeout) {
+            Some(instant) => self.set_wait_until(instant),
+            None => self.set_wait(),
+        }
+    }
+
+    /// Sets this to [`ExitWithCode`]`(code)`.
+    ///
+    /// [`ExitWithCode`]: Self::ExitWithCode
+    pub fn set_exit_with_code(&mut self, code: i32) {
+        *self = Self::ExitWithCode(code);
+    }
+
+    /// Sets this to [`Exit`].
+    ///
+    /// [`Exit`]: Self::Exit
+    pub fn set_exit(&mut self) {
+        *self = Self::Exit;
+    }
 }
 
 impl Default for ControlFlow {
     #[inline(always)]
-    fn default() -> ControlFlow {
-        ControlFlow::Poll
+    fn default() -> Self {
+        Self::Poll
     }
 }
 
 impl EventLoop<()> {
-    /// Builds a new event loop with a `()` as the user event type.
+    /// Alias for [`EventLoopBuilder::new().build()`].
     ///
-    /// ***For cross-platform compatibility, the `EventLoop` must be created on the main thread.***
-    /// Attempting to create the event loop on a different thread will panic. This restriction isn't
-    /// strictly necessary on all platforms, but is imposed to eliminate any nasty surprises when
-    /// porting to platforms that require it. `EventLoopExt::new_any_thread` functions are exposed
-    /// in the relevant `platform` module if the target platform supports creating an event loop on
-    /// any thread.
-    ///
-    /// Usage will result in display backend initialisation, this can be controlled on linux
-    /// using an environment variable `WINIT_UNIX_BACKEND`. Legal values are `x11` and `wayland`.
-    /// If it is not set, winit will try to connect to a wayland connection, and if it fails will
-    /// fallback on x11. If this variable is set with any other value, winit will panic.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS:** Can only be called on the main thread.
+    /// [`EventLoopBuilder::new().build()`]: EventLoopBuilder::build
+    #[inline]
     pub fn new() -> EventLoop<()> {
-        EventLoop::<()>::with_user_event()
+        EventLoopBuilder::new().build()
+    }
+}
+
+impl Default for EventLoop<()> {
+    fn default() -> Self {
+        Self::new()
     }
 }
 
 impl<T> EventLoop<T> {
-    /// Builds a new event loop.
-    ///
-    /// All caveats documented in [`EventLoop::new`] apply to this function.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **iOS:** Can only be called on the main thread.
+    #[deprecated = "Use `EventLoopBuilder::<T>::with_user_event().build()` instead."]
     pub fn with_user_event() -> EventLoop<T> {
-        EventLoop {
-            event_loop: platform_impl::EventLoop::new(),
-            _marker: ::std::marker::PhantomData,
-        }
+        EventLoopBuilder::<T>::with_user_event().build()
     }
 
     /// Hijacks the calling thread and initializes the winit event loop with the provided
@@ -139,37 +291,32 @@ impl<T> EventLoop<T> {
     ///
     /// Any values not passed to this function will *not* be dropped.
     ///
-    /// [`ControlFlow`]: ./enum.ControlFlow.html
+    /// ## Platform-specific
+    ///
+    /// - **X11 / Wayland:** The program terminates with exit code 1 if the display server
+    ///   disconnects.
+    ///
+    /// [`ControlFlow`]: crate::event_loop::ControlFlow
     #[inline]
     pub fn run<F>(self, event_handler: F) -> !
     where
-        F: 'static + FnMut(Event<T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<'_, T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
     {
         self.event_loop.run(event_handler)
     }
 
-    /// Creates an `EventLoopProxy` that can be used to dispatch user events to the main event loop.
+    /// Creates an [`EventLoopProxy`] that can be used to dispatch user events to the main event loop.
     pub fn create_proxy(&self) -> EventLoopProxy<T> {
         EventLoopProxy {
             event_loop_proxy: self.event_loop.create_proxy(),
         }
     }
+}
 
-    /// Returns the list of all the monitors available on the system.
-    #[inline]
-    pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
-        self.event_loop
-            .available_monitors()
-            .into_iter()
-            .map(|inner| MonitorHandle { inner })
-    }
-
-    /// Returns the primary monitor of the system.
-    #[inline]
-    pub fn primary_monitor(&self) -> MonitorHandle {
-        MonitorHandle {
-            inner: self.event_loop.primary_monitor(),
-        }
+unsafe impl<T> HasRawDisplayHandle for EventLoop<T> {
+    /// Returns a [`raw_window_handle::RawDisplayHandle`] for the event loop.
+    fn raw_display_handle(&self) -> RawDisplayHandle {
+        self.event_loop.window_target().p.raw_display_handle()
     }
 }
 
@@ -180,7 +327,55 @@ impl<T> Deref for EventLoop<T> {
     }
 }
 
-/// Used to send custom events to `EventLoop`.
+impl<T> EventLoopWindowTarget<T> {
+    /// Returns the list of all the monitors available on the system.
+    #[inline]
+    pub fn available_monitors(&self) -> impl Iterator<Item = MonitorHandle> {
+        self.p
+            .available_monitors()
+            .into_iter()
+            .map(|inner| MonitorHandle { inner })
+    }
+
+    /// Returns the primary monitor of the system.
+    ///
+    /// Returns `None` if it can't identify any monitor as a primary one.
+    ///
+    /// ## Platform-specific
+    ///
+    /// **Wayland:** Always returns `None`.
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        self.p
+            .primary_monitor()
+            .map(|inner| MonitorHandle { inner })
+    }
+
+    /// Change [`DeviceEvent`] filter mode.
+    ///
+    /// Since the [`DeviceEvent`] capture can lead to high CPU usage for unfocused windows, winit
+    /// will ignore them by default for unfocused windows on Linux/BSD. This method allows changing
+    /// this filter at runtime to explicitly capture them again.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Wayland / macOS / iOS / Android / Web / Orbital:** Unsupported.
+    ///
+    /// [`DeviceEvent`]: crate::event::DeviceEvent
+    pub fn set_device_event_filter(&self, _filter: DeviceEventFilter) {
+        #[cfg(any(x11_platform, wayland_platform, windows))]
+        self.p.set_device_event_filter(_filter);
+    }
+}
+
+unsafe impl<T> HasRawDisplayHandle for EventLoopWindowTarget<T> {
+    /// Returns a [`raw_window_handle::RawDisplayHandle`] for the event loop.
+    fn raw_display_handle(&self) -> RawDisplayHandle {
+        self.p.raw_display_handle()
+    }
+}
+
+/// Used to send custom events to [`EventLoop`].
 pub struct EventLoopProxy<T: 'static> {
     event_loop_proxy: platform_impl::EventLoopProxy<T>,
 }
@@ -194,12 +389,14 @@ impl<T: 'static> Clone for EventLoopProxy<T> {
 }
 
 impl<T: 'static> EventLoopProxy<T> {
-    /// Send an event to the `EventLoop` from which this proxy was created. This emits a
+    /// 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.
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed> {
+    /// Returns an `Err` if the associated [`EventLoop`] no longer exists.
+    ///
+    /// [`UserEvent(event)`]: Event::UserEvent
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
         self.event_loop_proxy.send_event(event)
     }
 }
@@ -210,19 +407,34 @@ impl<T: 'static> fmt::Debug for EventLoopProxy<T> {
     }
 }
 
-/// The error that is returned when an `EventLoopProxy` attempts to wake up an `EventLoop` that
+/// The error that is returned when an [`EventLoopProxy`] attempts to wake up an [`EventLoop`] that
 /// no longer exists.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
-pub struct EventLoopClosed;
+///
+/// Contains the original event given to [`EventLoopProxy::send_event`].
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct EventLoopClosed<T>(pub T);
 
-impl fmt::Display for EventLoopClosed {
+impl<T> fmt::Display for EventLoopClosed<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", error::Error::description(self))
+        f.write_str("Tried to wake up a closed `EventLoop`")
     }
 }
 
-impl error::Error for EventLoopClosed {
-    fn description(&self) -> &str {
-        "Tried to wake up a closed `EventLoop`"
+impl<T: fmt::Debug> error::Error for EventLoopClosed<T> {}
+
+/// Filter controlling the propagation of device events.
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
+pub enum DeviceEventFilter {
+    /// Always filter out device events.
+    Always,
+    /// Filter out device events while the window is not focused.
+    Unfocused,
+    /// Report all device events regardless of window focus.
+    Never,
+}
+
+impl Default for DeviceEventFilter {
+    fn default() -> Self {
+        Self::Unfocused
     }
 }

src/icon.rs

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

src/lib.rs

@@ -1,6 +1,6 @@
-//! Winit allows you to build a window on as many platforms as possible.
+//! Winit is a cross-platform window creation and event loop management library.
 //!
-//! # Building a window
+//! # Building windows
 //!
 //! Before you can build a [`Window`], you first need to build an [`EventLoop`]. This is done with the
 //! [`EventLoop::new()`] function.
@@ -15,31 +15,36 @@
 //!  - Calling [`Window::new(&event_loop)`][window_new].
 //!  - Calling [`let builder = WindowBuilder::new()`][window_builder_new] then [`builder.build(&event_loop)`][window_builder_build].
 //!
-//! The first way is the simplest way and will give you default values for everything.
-//!
-//! The second way allows you to customize the way your [`Window`] will look and behave by modifying
-//! the fields of the [`WindowBuilder`] object before you create the [`Window`].
+//! The first method is the simplest, and will give you default values for everything. The second
+//! method allows you to customize the way your [`Window`] will look and behave by modifying the
+//! fields of the [`WindowBuilder`] object before you create the [`Window`].
 //!
 //! # Event handling
 //!
 //! Once a [`Window`] has been created, it will generate different *events*. A [`Window`] object can
-//! generate a [`WindowEvent`] when certain things happen, like whenever the user moves their mouse
-//! or presses a key inside the [`Window`]. Devices can generate a [`DeviceEvent`] directly as well,
-//! which contains 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 [`UserEvent`]s, if desired.
+//! generate [`WindowEvent`]s when certain input events occur, such as a cursor moving over the
+//! window or a key getting pressed while the window is focused. Devices can generate
+//! [`DeviceEvent`]s, which contain unfiltered event data that isn't specific to a certain window.
+//! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
+//! [`DeviceEvent`]. You can also create and handle your own custom [`UserEvent`]s, if desired.
 //!
-//! Events can be retreived by using an [`EventLoop`]. A [`Window`] will send its events to the
-//! [`EventLoop`] object it was created with.
+//! You can retrieve events by calling [`EventLoop::run`][event_loop_run]. This function will
+//! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
+//! will run until the `control_flow` argument given to the closure is set to
+//! [`ControlFlow`]`::`[`ExitWithCode`] (which [`ControlFlow`]`::`[`Exit`] aliases to), at which
+//! point [`Event`]`::`[`LoopDestroyed`] is emitted and the entire program terminates.
+//!
+//! 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
+//! [`EventLoopExtRunReturn::run_return`]. See that method's documentation for more reasons about why
+//! it's discouraged, beyond compatibility reasons.
 //!
-//! You do this by calling [`event_loop.run(...)`][event_loop_run]. This function will run forever
-//! unless `control_flow` is set to [`ControlFlow`]`::`[`Exit`], at which point [`Event`]`::`[`LoopDestroyed`]
-//! is emitted and the entire program terminates.
 //!
 //! ```no_run
 //! use winit::{
 //!     event::{Event, WindowEvent},
-//!     event_loop::{ControlFlow, EventLoop},
+//!     event_loop::EventLoop,
 //!     window::WindowBuilder,
 //! };
 //!
@@ -47,87 +52,101 @@
 //! let window = WindowBuilder::new().build(&event_loop).unwrap();
 //!
 //! event_loop.run(move |event, _, control_flow| {
-//!     match event {
-//!         Event::EventsCleared => {
-//!             // Application update code.
+//!     // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
+//!     // dispatched any events. This is ideal for games and similar applications.
+//!     control_flow.set_poll();
 //!
-//!             // Queue a RedrawRequested event.
-//!             window.request_redraw();
-//!         },
-//!         Event::WindowEvent {
-//!             event: WindowEvent::RedrawRequested,
-//!             ..
-//!         } => {
-//!             // Redraw the application.
-//!             //
-//!             // It's preferrable to render in this event rather than in EventsCleared, since
-//!             // rendering in here allows the program to gracefully handle redraws requested
-//!             // by the OS.
-//!         },
+//!     // ControlFlow::Wait pauses the event loop if no events are available to process.
+//!     // This is ideal for non-game applications that only update in response to user
+//!     // input, and uses significantly less power/CPU time than ControlFlow::Poll.
+//!     control_flow.set_wait();
+//!
+//!     match event {
 //!         Event::WindowEvent {
 //!             event: WindowEvent::CloseRequested,
 //!             ..
 //!         } => {
 //!             println!("The close button was pressed; stopping");
-//!             *control_flow = ControlFlow::Exit
+//!             control_flow.set_exit();
 //!         },
-//!         // ControlFlow::Poll continuously runs the event loop, even if the OS hasn't
-//!         // dispatched any events. This is ideal for games and similar applications.
-//!         _ => *control_flow = ControlFlow::Poll,
-//!         // ControlFlow::Wait pauses the event loop if no events are available to process.
-//!         // This is ideal for non-game applications that only update in response to user
-//!         // input, and uses significantly less power/CPU time than ControlFlow::Poll.
-//!         // _ => *control_flow = ControlFlow::Wait,
+//!         Event::MainEventsCleared => {
+//!             // Application update code.
+//!
+//!             // Queue a RedrawRequested event.
+//!             //
+//!             // You only need to call this if you've determined that you need to redraw, in
+//!             // applications which do not always need to. Applications that redraw continuously
+//!             // can just render here instead.
+//!             window.request_redraw();
+//!         },
+//!         Event::RedrawRequested(_) => {
+//!             // Redraw the application.
+//!             //
+//!             // It's preferable for applications that do not render continuously to render in
+//!             // this event rather than in MainEventsCleared, since rendering in here allows
+//!             // the program to gracefully handle redraws requested by the OS.
+//!         },
+//!         _ => ()
 //!     }
 //! });
 //! ```
 //!
-//! If you use multiple [`Window`]s, [`Event`]`::`[`WindowEvent`] has a member named `window_id`. You can
-//! compare it with the value returned by the [`id()`][window_id_fn] method of [`Window`] in order to know which
-//! [`Window`] has received the event.
+//! [`Event`]`::`[`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
+//! compared to the value returned by [`Window::id()`][window_id_fn] to determine which [`Window`]
+//! dispatched the event.
 //!
 //! # Drawing on the window
 //!
-//! Winit doesn't provide any function that allows drawing on a [`Window`]. However it allows you to
-//! retrieve the raw handle of the window (see the [`platform`] module), which in turn allows you
-//! to create an OpenGL/Vulkan/DirectX/Metal/etc. context that will draw on the [`Window`].
+//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However it allows you to
+//! retrieve the raw handle of the window and display (see the [`platform`] module and/or the
+//! [`raw_window_handle`] and [`raw_display_handle`] methods), which in turn allows
+//!  you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
 //!
-//! [`EventLoop`]: ./event_loop/struct.EventLoop.html
-//! [`EventLoop::new()`]: ./event_loop/struct.EventLoop.html#method.new
-//! [event_loop_run]: ./event_loop/struct.EventLoop.html#method.run
-//! [`ControlFlow`]: ./event_loop/enum.ControlFlow.html
-//! [`Exit`]: ./event_loop/enum.ControlFlow.html#variant.Exit
-//! [`Window`]: ./window/struct.Window.html
-//! [`WindowBuilder`]: ./window/struct.WindowBuilder.html
-//! [window_new]: ./window/struct.Window.html#method.new
-//! [window_builder_new]: ./window/struct.WindowBuilder.html#method.new
-//! [window_builder_build]: ./window/struct.WindowBuilder.html#method.build
-//! [window_id_fn]: ./window/struct.Window.html#method.id
-//! [`Event`]: ./event/enum.Event.html
-//! [`WindowEvent`]: ./event/enum.WindowEvent.html
-//! [`DeviceEvent`]: ./event/enum.DeviceEvent.html
-//! [`UserEvent`]: ./event/enum.Event.html#variant.UserEvent
-//! [`LoopDestroyed`]: ./event/enum.Event.html#variant.LoopDestroyed
-//! [`platform`]: ./platform/index.html
+//! 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::WindowBuilder::with_visible) and explicitly make the
+//! window visible only once you're ready to render into it.
+//!
+//! [`EventLoop`]: event_loop::EventLoop
+//! [`EventLoopExtRunReturn::run_return`]: ./platform/run_return/trait.EventLoopExtRunReturn.html#tymethod.run_return
+//! [`EventLoop::new()`]: event_loop::EventLoop::new
+//! [event_loop_run]: event_loop::EventLoop::run
+//! [`ControlFlow`]: event_loop::ControlFlow
+//! [`Exit`]: event_loop::ControlFlow::Exit
+//! [`ExitWithCode`]: event_loop::ControlFlow::ExitWithCode
+//! [`Window`]: window::Window
+//! [`WindowId`]: window::WindowId
+//! [`WindowBuilder`]: window::WindowBuilder
+//! [window_new]: window::Window::new
+//! [window_builder_new]: window::WindowBuilder::new
+//! [window_builder_build]: window::WindowBuilder::build
+//! [window_id_fn]: window::Window::id
+//! [`Event`]: event::Event
+//! [`WindowEvent`]: event::WindowEvent
+//! [`DeviceEvent`]: event::DeviceEvent
+//! [`UserEvent`]: event::Event::UserEvent
+//! [`LoopDestroyed`]: event::Event::LoopDestroyed
+//! [`platform`]: platform
+//! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
+//! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
 
 #![deny(rust_2018_idioms)]
+#![deny(rustdoc::broken_intra_doc_links)]
+#![deny(clippy::all)]
+#![cfg_attr(feature = "cargo-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))]
+#![allow(clippy::missing_safety_doc)]
 
 #[allow(unused_imports)]
 #[macro_use]
-extern crate lazy_static;
-#[macro_use]
 extern crate log;
 #[cfg(feature = "serde")]
 #[macro_use]
 extern crate serde;
 #[macro_use]
-#[cfg(any(target_os = "ios", target_os = "windows"))]
 extern crate bitflags;
-#[cfg(any(target_os = "macos", target_os = "ios"))]
-#[macro_use]
-extern crate objc;
-#[cfg(feature = "std_web")]
-extern crate std_web as stdweb;
 
 pub mod dpi;
 #[macro_use]

src/monitor.rs

@@ -1,14 +1,10 @@
 //! Types useful for interacting with a user's monitors.
 //!
-//! If you want to get basic information about a monitor, you can use the [`MonitorHandle`][monitor_id]
-//! type. This is retreived from one of the following methods, which return an iterator of
-//! [`MonitorHandle`][monitor_id]:
-//! - [`EventLoop::available_monitors`][loop_get]
-//! - [`Window::available_monitors`][window_get].
-//!
-//! [monitor_id]: ./struct.MonitorHandle.html
-//! [loop_get]: ../event_loop/struct.EventLoop.html#method.available_monitors
-//! [window_get]: ../window/struct.Window.html#method.available_monitors
+//! If you want to get basic information about a monitor, you can use the
+//! [`MonitorHandle`] type. This is retrieved from one of the following
+//! methods, which return an iterator of [`MonitorHandle`]:
+//! - [`EventLoopWindowTarget::available_monitors`](crate::event_loop::EventLoopWindowTarget::available_monitors).
+//! - [`Window::available_monitors`](crate::window::Window::available_monitors).
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize},
     platform_impl,
@@ -16,10 +12,7 @@ use crate::{
 
 /// Describes a fullscreen video mode of a monitor.
 ///
-/// Can be acquired with:
-/// - [`MonitorHandle::video_modes`][monitor_get].
-///
-/// [monitor_get]: ../monitor/struct.MonitorHandle.html#method.video_modes
+/// Can be acquired with [`MonitorHandle::video_modes`].
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct VideoMode {
     pub(crate) video_mode: platform_impl::VideoMode,
@@ -46,8 +39,8 @@ impl Ord for VideoMode {
         self.monitor().cmp(&other.monitor()).then(
             size.cmp(&other_size)
                 .then(
-                    self.refresh_rate()
-                        .cmp(&other.refresh_rate())
+                    self.refresh_rate_millihertz()
+                        .cmp(&other.refresh_rate_millihertz())
                         .then(self.bit_depth().cmp(&other.bit_depth())),
                 )
                 .reverse(),
@@ -58,7 +51,7 @@ impl Ord for VideoMode {
 impl VideoMode {
     /// Returns the resolution of this video mode.
     #[inline]
-    pub fn size(&self) -> PhysicalSize {
+    pub fn size(&self) -> PhysicalSize<u32> {
         self.video_mode.size()
     }
 
@@ -68,26 +61,26 @@ impl VideoMode {
     ///
     /// ## Platform-specific
     ///
-    /// - **Wayland:** Always returns 32.
+    /// - **Wayland / Orbital:** Always returns 32.
     /// - **iOS:** Always returns 32.
     #[inline]
     pub fn bit_depth(&self) -> u16 {
         self.video_mode.bit_depth()
     }
 
-    /// Returns the refresh rate of this video mode. **Note**: the returned
-    /// refresh rate is an integer approximation, and you shouldn't rely on this
-    /// value to be exact.
+    /// Returns the refresh rate of this video mode in mHz.
     #[inline]
-    pub fn refresh_rate(&self) -> u16 {
-        self.video_mode.refresh_rate()
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.video_mode.refresh_rate_millihertz()
     }
 
     /// Returns the monitor that this video mode is valid for. Each monitor has
     /// a separate set of valid video modes.
     #[inline]
     pub fn monitor(&self) -> MonitorHandle {
-        self.video_mode.monitor()
+        MonitorHandle {
+            inner: self.video_mode.monitor(),
+        }
     }
 }
 
@@ -95,10 +88,10 @@ impl std::fmt::Display for VideoMode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "{}x{} @ {} Hz ({} bpp)",
+            "{}x{} @ {} mHz ({} bpp)",
             self.size().width,
             self.size().height,
-            self.refresh_rate(),
+            self.refresh_rate_millihertz(),
             self.bit_depth()
         )
     }
@@ -108,7 +101,7 @@ impl std::fmt::Display for VideoMode {
 ///
 /// Allows you to retrieve information about a given monitor and can be used in [`Window`] creation.
 ///
-/// [`Window`]: ../window/struct.Window.html
+/// [`Window`]: crate::window::Window
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct MonitorHandle {
     pub(crate) inner: platform_impl::MonitorHandle,
@@ -133,7 +126,7 @@ impl MonitorHandle {
     ///
     /// - **Web:** Always returns (0,0)
     #[inline]
-    pub fn size(&self) -> PhysicalSize {
+    pub fn size(&self) -> PhysicalSize<u32> {
         self.inner.size()
     }
 
@@ -144,22 +137,34 @@ impl MonitorHandle {
     ///
     /// - **Web:** Always returns (0,0)
     #[inline]
-    pub fn position(&self) -> PhysicalPosition {
+    pub fn position(&self) -> PhysicalPosition<i32> {
         self.inner.position()
     }
 
-    /// Returns the DPI factor that can be used to map logical pixels to physical pixels, and vice versa.
+    /// The monitor refresh rate used by the system.
     ///
-    /// See the [`dpi`](../dpi/index.html) module for more information.
+    /// Return `Some` if succeed, or `None` if failed, which usually happens when the monitor
+    /// the window is on is removed.
+    ///
+    /// When using exclusive fullscreen, the refresh rate of the [`VideoMode`] that was used to
+    /// enter fullscreen should be used instead.
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        self.inner.refresh_rate_millihertz()
+    }
+
+    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.
+    ///
+    /// See the [`dpi`](crate::dpi) module for more information.
     ///
     /// ## Platform-specific
     ///
-    /// - **X11:** Can be overridden using the `WINIT_HIDPI_FACTOR` environment variable.
+    /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
     /// - **Android:** Always returns 1.0.
     /// - **Web:** Always returns 1.0
     #[inline]
-    pub fn hidpi_factor(&self) -> f64 {
-        self.inner.hidpi_factor()
+    pub fn scale_factor(&self) -> f64 {
+        self.inner.scale_factor()
     }
 
     /// Returns all fullscreen video modes supported by this monitor.
@@ -169,6 +174,8 @@ impl MonitorHandle {
     /// - **Web:** Always returns an empty iterator
     #[inline]
     pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        self.inner.video_modes()
+        self.inner
+            .video_modes()
+            .map(|video_mode| VideoMode { video_mode })
     }
 }

src/platform/android.rs

@@ -1,33 +1,78 @@
-#![cfg(any(target_os = "android"))]
+use crate::{
+    event_loop::{EventLoop, EventLoopBuilder, EventLoopWindowTarget},
+    window::{Window, WindowBuilder},
+};
 
-use crate::{EventLoop, Window, WindowBuilder};
-use std::os::raw::c_void;
+use android_activity::{AndroidApp, ConfigurationRef, Rect};
 
-/// Additional methods on `EventLoop` that are specific to Android.
-pub trait EventLoopExtAndroid {
-    /// Makes it possible for glutin to register a callback when a suspend event happens on Android
-    fn set_suspend_callback(&self, cb: Option<Box<dyn Fn(bool) -> ()>>);
-}
+/// Additional methods on [`EventLoop`] that are specific to Android.
+pub trait EventLoopExtAndroid {}
 
-impl EventLoopExtAndroid for EventLoop {
-    fn set_suspend_callback(&self, cb: Option<Box<dyn Fn(bool) -> ()>>) {
-        self.event_loop.set_suspend_callback(cb);
-    }
-}
+impl<T> EventLoopExtAndroid for EventLoop<T> {}
 
-/// Additional methods on `Window` that are specific to Android.
+/// Additional methods on [`EventLoopWindowTarget`] that are specific to Android.
+pub trait EventLoopWindowTargetExtAndroid {}
+
+/// Additional methods on [`Window`] that are specific to Android.
 pub trait WindowExtAndroid {
-    fn native_window(&self) -> *const c_void;
+    fn content_rect(&self) -> Rect;
+
+    fn config(&self) -> ConfigurationRef;
 }
 
 impl WindowExtAndroid for Window {
-    #[inline]
-    fn native_window(&self) -> *const c_void {
-        self.window.native_window()
+    fn content_rect(&self) -> Rect {
+        self.window.content_rect()
+    }
+
+    fn config(&self) -> ConfigurationRef {
+        self.window.config()
     }
 }
 
-/// Additional methods on `WindowBuilder` that are specific to Android.
+impl<T> EventLoopWindowTargetExtAndroid for EventLoopWindowTarget<T> {}
+
+/// Additional methods on [`WindowBuilder`] that are specific to Android.
 pub trait WindowBuilderExtAndroid {}
 
 impl WindowBuilderExtAndroid for WindowBuilder {}
+
+pub trait EventLoopBuilderExtAndroid {
+    /// Associates the `AndroidApp` that was passed to `android_main()` with the event loop
+    ///
+    /// This must be called on Android since the `AndroidApp` is not global state.
+    fn with_android_app(&mut self, app: AndroidApp) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
+    fn with_android_app(&mut self, app: AndroidApp) -> &mut Self {
+        self.platform_specific.android_app = Some(app);
+        self
+    }
+}
+
+/// Re-export of the `android_activity` API
+///
+/// Winit re-exports the `android_activity` API for convenience so that most
+/// applications can rely on the Winit crate to resolve the required version of
+/// `android_activity` and avoid any chance of a conflict between Winit and the
+/// application crate.
+///
+/// Unlike most libraries there can only be a single implementation
+/// of the `android_activity` glue crate linked with an application because
+/// it is responsible for the application's `android_main()` entry point.
+///
+/// Since Winit depends on a specific version of `android_activity` the simplest
+/// way to avoid creating a conflict is for applications to avoid explicitly
+/// depending on the `android_activity` crate, and instead consume the API that
+/// is re-exported by Winit.
+///
+/// For compatibility applications should then import the `AndroidApp` type for
+/// their `android_main(app: AndroidApp)` function like:
+/// ```rust
+/// #[cfg(target_os="android")]
+/// use winit::platform::android::activity::AndroidApp;
+/// ```
+pub mod activity {
+    pub use android_activity::*;
+}

src/platform/desktop.rs

@@ -1,45 +0,0 @@
-#![cfg(any(
-    target_os = "windows",
-    target_os = "macos",
-    target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"
-))]
-
-use crate::{
-    event::Event,
-    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
-};
-
-/// Additional methods on `EventLoop` that are specific to desktop platforms.
-pub trait EventLoopExtDesktop {
-    /// A type provided by the user that can be passed through `Event::UserEvent`.
-    type UserEvent;
-
-    /// Initializes the `winit` event loop.
-    ///
-    /// Unlike `run`, this function accepts non-`'static` (i.e. non-`move`) closures and returns
-    /// control flow to the caller when `control_flow` is set to `ControlFlow::Exit`.
-    ///
-    /// # Caveats
-    /// Despite its apperance at first glance, this is *not* a perfect replacement for
-    /// `poll_events`. For example, this function will not return on Windows or macOS while a
-    /// window is getting resized, resulting in all application logic outside of the
-    /// `event_handler` closure not running until the resize operation ends. Other OS operations
-    /// may also result in such freezes. This behavior is caused by fundamental limitations in the
-    /// underyling OS APIs, which cannot be hidden by Winit without severe stability reprecussions.
-    ///
-    /// You are strongly encouraged to use `run`, unless the use of this is absolutely necessary.
-    fn run_return<F>(&mut self, event_handler: F)
-    where
-        F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>, &mut ControlFlow);
-}
-
-impl<T> EventLoopExtDesktop for EventLoop<T> {
-    type UserEvent = T;
-
-    fn run_return<F>(&mut self, event_handler: F)
-    where
-        F: FnMut(Event<T>, &EventLoopWindowTarget<T>, &mut ControlFlow),
-    {
-        self.event_loop.run_return(event_handler)
-    }
-}

src/platform/ios.rs

@@ -1,7 +1,7 @@
-#![cfg(target_os = "ios")]
-
 use std::os::raw::c_void;
 
+use objc2::rc::Id;
+
 use crate::{
     event_loop::EventLoop,
     monitor::{MonitorHandle, VideoMode},
@@ -43,14 +43,14 @@ pub trait WindowExtIOS {
     /// [`UIView`]: https://developer.apple.com/documentation/uikit/uiview?language=objc
     fn ui_view(&self) -> *mut c_void;
 
-    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `hidpi_factor`.
+    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
     ///
     /// The default value is device dependent, and it's recommended GLES or Metal applications set
-    /// this to [`MonitorHandle::hidpi_factor()`].
+    /// this to [`MonitorHandle::scale_factor()`].
     ///
     /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
     /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
-    fn set_hidpi_factor(&self, hidpi_factor: f64);
+    fn set_scale_factor(&self, scale_factor: f64);
 
     /// Sets the valid orientations for the [`Window`].
     ///
@@ -99,22 +99,22 @@ pub trait WindowExtIOS {
 impl WindowExtIOS for Window {
     #[inline]
     fn ui_window(&self) -> *mut c_void {
-        self.window.ui_window() as _
+        self.window.ui_window()
     }
 
     #[inline]
     fn ui_view_controller(&self) -> *mut c_void {
-        self.window.ui_view_controller() as _
+        self.window.ui_view_controller()
     }
 
     #[inline]
     fn ui_view(&self) -> *mut c_void {
-        self.window.ui_view() as _
+        self.window.ui_view()
     }
 
     #[inline]
-    fn set_hidpi_factor(&self, hidpi_factor: f64) {
-        self.window.set_hidpi_factor(hidpi_factor)
+    fn set_scale_factor(&self, scale_factor: f64) {
+        self.window.set_scale_factor(scale_factor)
     }
 
     #[inline]
@@ -141,21 +141,14 @@ impl WindowExtIOS for Window {
 
 /// Additional methods on [`WindowBuilder`] that are specific to iOS.
 pub trait WindowBuilderExtIOS {
-    /// Sets the root view class used by the [`Window`], otherwise a barebones [`UIView`] is provided.
-    ///
-    /// An instance of the class will be initialized by calling [`-[UIView initWithFrame:]`](https://developer.apple.com/documentation/uikit/uiview/1622488-initwithframe?language=objc).
-    ///
-    /// [`UIView`]: https://developer.apple.com/documentation/uikit/uiview?language=objc
-    fn with_root_view_class(self, root_view_class: *const c_void) -> WindowBuilder;
-
-    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `hidpi_factor`.
+    /// Sets the [`contentScaleFactor`] of the underlying [`UIWindow`] to `scale_factor`.
     ///
     /// The default value is device dependent, and it's recommended GLES or Metal applications set
-    /// this to [`MonitorHandle::hidpi_factor()`].
+    /// this to [`MonitorHandle::scale_factor()`].
     ///
     /// [`UIWindow`]: https://developer.apple.com/documentation/uikit/uiwindow?language=objc
     /// [`contentScaleFactor`]: https://developer.apple.com/documentation/uikit/uiview/1622657-contentscalefactor?language=objc
-    fn with_hidpi_factor(self, hidpi_factor: f64) -> WindowBuilder;
+    fn with_scale_factor(self, scale_factor: f64) -> WindowBuilder;
 
     /// Sets the valid orientations for the [`Window`].
     ///
@@ -198,14 +191,8 @@ pub trait WindowBuilderExtIOS {
 
 impl WindowBuilderExtIOS for WindowBuilder {
     #[inline]
-    fn with_root_view_class(mut self, root_view_class: *const c_void) -> WindowBuilder {
-        self.platform_specific.root_view_class = unsafe { &*(root_view_class as *const _) };
-        self
-    }
-
-    #[inline]
-    fn with_hidpi_factor(mut self, hidpi_factor: f64) -> WindowBuilder {
-        self.platform_specific.hidpi_factor = Some(hidpi_factor);
+    fn with_scale_factor(mut self, scale_factor: f64) -> WindowBuilder {
+        self.platform_specific.scale_factor = Some(scale_factor);
         self
     }
 
@@ -254,12 +241,14 @@ pub trait MonitorHandleExtIOS {
 impl MonitorHandleExtIOS for MonitorHandle {
     #[inline]
     fn ui_screen(&self) -> *mut c_void {
-        self.inner.ui_screen() as _
+        Id::as_ptr(self.inner.ui_screen()) as *mut c_void
     }
 
     #[inline]
     fn preferred_video_mode(&self) -> VideoMode {
-        self.inner.preferred_video_mode()
+        VideoMode {
+            video_mode: self.inner.preferred_video_mode(),
+        }
     }
 }
 

src/platform/macos.rs

@@ -1,49 +1,25 @@
-#![cfg(target_os = "macos")]
-
 use std::os::raw::c_void;
 
+use objc2::rc::Id;
+
 use crate::{
-    dpi::LogicalSize,
+    event_loop::{EventLoopBuilder, EventLoopWindowTarget},
     monitor::MonitorHandle,
     window::{Window, WindowBuilder},
 };
 
-/// Corresponds to `NSRequestUserAttentionType`.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum RequestUserAttentionType {
-    /// Corresponds to `NSCriticalRequest`.
-    ///
-    /// Dock icon will bounce until the application is focused.
-    Critical,
-
-    /// Corresponds to `NSInformationalRequest`.
-    ///
-    /// Dock icon will bounce once.
-    Informational,
-}
-
-impl Default for RequestUserAttentionType {
-    fn default() -> Self {
-        RequestUserAttentionType::Critical
-    }
-}
-
-/// Additional methods on `Window` that are specific to MacOS.
+/// Additional methods on [`Window`] that are specific to MacOS.
 pub trait WindowExtMacOS {
     /// Returns a pointer to the cocoa `NSWindow` that is used by this window.
     ///
-    /// The pointer will become invalid when the `Window` is destroyed.
+    /// The pointer will become invalid when the [`Window`] is destroyed.
     fn ns_window(&self) -> *mut c_void;
 
     /// Returns a pointer to the cocoa `NSView` that is used by this window.
     ///
-    /// The pointer will become invalid when the `Window` is destroyed.
+    /// The pointer will become invalid when the [`Window`] is destroyed.
     fn ns_view(&self) -> *mut c_void;
 
-    /// Request user attention, causing the application's dock icon to bounce.
-    /// Note that this has no effect if the application is already focused.
-    fn request_user_attention(&self, request_type: RequestUserAttentionType);
-
     /// Returns whether or not the window is in simple fullscreen mode.
     fn simple_fullscreen(&self) -> bool;
 
@@ -55,6 +31,42 @@ pub trait WindowExtMacOS {
     /// And allows the user to have a fullscreen window without using another
     /// space or taking control over the entire monitor.
     fn set_simple_fullscreen(&self, fullscreen: bool) -> bool;
+
+    /// Returns whether or not the window has shadow.
+    fn has_shadow(&self) -> bool;
+
+    /// Sets whether or not the window has shadow.
+    fn set_has_shadow(&self, has_shadow: bool);
+
+    /// Get the window's edit state.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// WindowEvent::CloseRequested => {
+    ///     if window.is_document_edited() {
+    ///         // Show the user a save pop-up or similar
+    ///     } else {
+    ///         // Close the window
+    ///         drop(window);
+    ///     }
+    /// }
+    /// ```
+    fn is_document_edited(&self) -> bool;
+
+    /// Put the window in a state which indicates a file save is required.
+    fn set_document_edited(&self, edited: bool);
+
+    /// Set option as alt behavior as described in [`OptionAsAlt`].
+    ///
+    /// This will ignore diacritical marks and accent characters from
+    /// being processed as received characters. Instead, the input
+    /// device's raw character will be placed in event queues with the
+    /// Alt modifier set.
+    fn set_option_as_alt(&self, option_as_alt: OptionAsAlt);
+
+    /// Getter for the [`WindowExtMacOS::set_option_as_alt`].
+    fn option_as_alt(&self) -> OptionAsAlt;
 }
 
 impl WindowExtMacOS for Window {
@@ -68,11 +80,6 @@ impl WindowExtMacOS for Window {
         self.window.ns_view()
     }
 
-    #[inline]
-    fn request_user_attention(&self, request_type: RequestUserAttentionType) {
-        self.window.request_user_attention(request_type)
-    }
-
     #[inline]
     fn simple_fullscreen(&self) -> bool {
         self.window.simple_fullscreen()
@@ -82,10 +89,40 @@ impl WindowExtMacOS for Window {
     fn set_simple_fullscreen(&self, fullscreen: bool) -> bool {
         self.window.set_simple_fullscreen(fullscreen)
     }
+
+    #[inline]
+    fn has_shadow(&self) -> bool {
+        self.window.has_shadow()
+    }
+
+    #[inline]
+    fn set_has_shadow(&self, has_shadow: bool) {
+        self.window.set_has_shadow(has_shadow)
+    }
+
+    #[inline]
+    fn is_document_edited(&self) -> bool {
+        self.window.is_document_edited()
+    }
+
+    #[inline]
+    fn set_document_edited(&self, edited: bool) {
+        self.window.set_document_edited(edited)
+    }
+
+    #[inline]
+    fn set_option_as_alt(&self, option_as_alt: OptionAsAlt) {
+        self.window.set_option_as_alt(option_as_alt)
+    }
+
+    #[inline]
+    fn option_as_alt(&self) -> OptionAsAlt {
+        self.window.option_as_alt()
+    }
 }
 
 /// Corresponds to `NSApplicationActivationPolicy`.
-#[derive(Debug, Clone, Copy, PartialEq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum ActivationPolicy {
     /// Corresponds to `NSApplicationActivationPolicyRegular`.
     Regular,
@@ -101,19 +138,15 @@ impl Default for ActivationPolicy {
     }
 }
 
-/// Additional methods on `WindowBuilder` that are specific to MacOS.
+/// Additional methods on [`WindowBuilder`] that are specific to MacOS.
 ///
-/// **Note:** Properties dealing with the titlebar will be overwritten by the `with_decorations` method
-/// on the base `WindowBuilder`:
-///
-///  - `with_titlebar_transparent`
-///  - `with_title_hidden`
-///  - `with_titlebar_hidden`
-///  - `with_titlebar_buttons_hidden`
-///  - `with_fullsize_content_view`
+/// **Note:** Properties dealing with the titlebar will be overwritten by the [`WindowBuilder::with_decorations`] method:
+/// - `with_titlebar_transparent`
+/// - `with_title_hidden`
+/// - `with_titlebar_hidden`
+/// - `with_titlebar_buttons_hidden`
+/// - `with_fullsize_content_view`
 pub trait WindowBuilderExtMacOS {
-    /// Sets the activation policy for the window being built.
-    fn with_activation_policy(self, activation_policy: ActivationPolicy) -> WindowBuilder;
     /// Enables click-and-drag behavior for the entire window, not just the titlebar.
     fn with_movable_by_window_background(self, movable_by_window_background: bool)
         -> WindowBuilder;
@@ -127,18 +160,18 @@ pub trait WindowBuilderExtMacOS {
     fn with_titlebar_buttons_hidden(self, titlebar_buttons_hidden: bool) -> WindowBuilder;
     /// Makes the window content appear behind the titlebar.
     fn with_fullsize_content_view(self, fullsize_content_view: bool) -> WindowBuilder;
-    /// Build window with `resizeIncrements` property. Values must not be 0.
-    fn with_resize_increments(self, increments: LogicalSize) -> WindowBuilder;
     fn with_disallow_hidpi(self, disallow_hidpi: bool) -> WindowBuilder;
+    fn with_has_shadow(self, has_shadow: bool) -> WindowBuilder;
+    /// Window accepts click-through mouse events.
+    fn with_accepts_first_mouse(self, accepts_first_mouse: bool) -> WindowBuilder;
+
+    /// Set whether the `OptionAsAlt` key is interpreted as the `Alt` modifier.
+    ///
+    /// See [`WindowExtMacOS::set_option_as_alt`] for details on what this means if set.
+    fn with_option_as_alt(self, option_as_alt: OptionAsAlt) -> WindowBuilder;
 }
 
 impl WindowBuilderExtMacOS for WindowBuilder {
-    #[inline]
-    fn with_activation_policy(mut self, activation_policy: ActivationPolicy) -> WindowBuilder {
-        self.platform_specific.activation_policy = activation_policy;
-        self
-    }
-
     #[inline]
     fn with_movable_by_window_background(
         mut self,
@@ -178,20 +211,104 @@ impl WindowBuilderExtMacOS for WindowBuilder {
         self
     }
 
-    #[inline]
-    fn with_resize_increments(mut self, increments: LogicalSize) -> WindowBuilder {
-        self.platform_specific.resize_increments = Some(increments.into());
-        self
-    }
-
     #[inline]
     fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> WindowBuilder {
         self.platform_specific.disallow_hidpi = disallow_hidpi;
         self
     }
+
+    #[inline]
+    fn with_has_shadow(mut self, has_shadow: bool) -> WindowBuilder {
+        self.platform_specific.has_shadow = has_shadow;
+        self
+    }
+
+    #[inline]
+    fn with_accepts_first_mouse(mut self, accepts_first_mouse: bool) -> WindowBuilder {
+        self.platform_specific.accepts_first_mouse = accepts_first_mouse;
+        self
+    }
+
+    #[inline]
+    fn with_option_as_alt(mut self, option_as_alt: OptionAsAlt) -> WindowBuilder {
+        self.platform_specific.option_as_alt = option_as_alt;
+        self
+    }
 }
 
-/// Additional methods on `MonitorHandle` that are specific to MacOS.
+pub trait EventLoopBuilderExtMacOS {
+    /// Sets the activation policy for the application.
+    ///
+    /// It is set to [`ActivationPolicy::Regular`] by default.
+    ///
+    /// # Example
+    ///
+    /// Set the activation policy to "accessory".
+    ///
+    /// ```
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "macos")]
+    /// use winit::platform::macos::{EventLoopBuilderExtMacOS, ActivationPolicy};
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "macos")]
+    /// builder.with_activation_policy(ActivationPolicy::Accessory);
+    /// # if false { // We can't test this part
+    /// let event_loop = builder.build();
+    /// # }
+    /// ```
+    fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self;
+
+    /// Used to control whether a default menubar menu is created.
+    ///
+    /// Menu creation is enabled by default.
+    ///
+    /// # Example
+    ///
+    /// Disable creating a default menubar.
+    ///
+    /// ```
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "macos")]
+    /// use winit::platform::macos::EventLoopBuilderExtMacOS;
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "macos")]
+    /// builder.with_default_menu(false);
+    /// # if false { // We can't test this part
+    /// let event_loop = builder.build();
+    /// # }
+    /// ```
+    fn with_default_menu(&mut self, enable: bool) -> &mut Self;
+
+    /// Used to prevent the application from automatically activating when launched if
+    /// another application is already active.
+    ///
+    /// The default behavior is to ignore other applications and activate when launched.
+    fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtMacOS for EventLoopBuilder<T> {
+    #[inline]
+    fn with_activation_policy(&mut self, activation_policy: ActivationPolicy) -> &mut Self {
+        self.platform_specific.activation_policy = activation_policy;
+        self
+    }
+
+    #[inline]
+    fn with_default_menu(&mut self, enable: bool) -> &mut Self {
+        self.platform_specific.default_menu = enable;
+        self
+    }
+
+    #[inline]
+    fn with_activate_ignoring_other_apps(&mut self, ignore: bool) -> &mut Self {
+        self.platform_specific.activate_ignoring_other_apps = ignore;
+        self
+    }
+}
+
+/// Additional methods on [`MonitorHandle`] that are specific to MacOS.
 pub trait MonitorHandleExtMacOS {
     /// Returns the identifier of the monitor for Cocoa.
     fn native_id(&self) -> u32;
@@ -206,6 +323,49 @@ impl MonitorHandleExtMacOS for MonitorHandle {
     }
 
     fn ns_screen(&self) -> Option<*mut c_void> {
-        self.inner.ns_screen().map(|s| s as *mut c_void)
+        self.inner.ns_screen().map(|s| Id::as_ptr(&s) as _)
+    }
+}
+
+/// Additional methods on [`EventLoopWindowTarget`] that are specific to macOS.
+pub trait EventLoopWindowTargetExtMacOS {
+    /// Hide the entire application. In most applications this is typically triggered with Command-H.
+    fn hide_application(&self);
+    /// Hide the other applications. In most applications this is typically triggered with Command+Option-H.
+    fn hide_other_applications(&self);
+}
+
+impl<T> EventLoopWindowTargetExtMacOS for EventLoopWindowTarget<T> {
+    fn hide_application(&self) {
+        self.p.hide_application()
+    }
+
+    fn hide_other_applications(&self) {
+        self.p.hide_other_applications()
+    }
+}
+
+/// Option as alt behavior.
+///
+/// The default is `None`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum OptionAsAlt {
+    /// The left `Option` key is treated as `Alt`.
+    OnlyLeft,
+
+    /// The right `Option` key is treated as `Alt`.
+    OnlyRight,
+
+    /// Both `Option` keys are treated as `Alt`.
+    Both,
+
+    /// No special handling is applied for `Option` key.
+    None,
+}
+
+impl Default for OptionAsAlt {
+    fn default() -> Self {
+        OptionAsAlt::None
     }
 }

src/platform/mod.rs

@@ -11,15 +11,33 @@
 //!
 //! And the following platform-specific module:
 //!
-//! - `desktop` (available on `windows`, `unix`, and `macos`)
+//! - `run_return` (available on `windows`, `unix`, `macos`, and `android`)
 //!
 //! However only the module corresponding to the platform you're compiling to will be available.
 
+#[cfg(android_platform)]
 pub mod android;
+#[cfg(ios_platform)]
 pub mod ios;
+#[cfg(macos_platform)]
 pub mod macos;
-pub mod unix;
-pub mod windows;
-
-pub mod desktop;
+#[cfg(orbital_platform)]
+pub mod orbital;
+#[cfg(wayland_platform)]
+pub mod wayland;
+#[cfg(wasm_platform)]
 pub mod web;
+#[cfg(windows_platform)]
+pub mod windows;
+#[cfg(x11_platform)]
+pub mod x11;
+
+#[cfg(any(
+    windows_platform,
+    macos_platform,
+    android_platform,
+    x11_platform,
+    wayland_platform,
+    orbital_platform
+))]
+pub mod run_return;

src/platform/orbital.rs

@@ -0,0 +1 @@
+// There are no Orbital specific traits yet.

src/platform/run_return.rs

@@ -0,0 +1,53 @@
+use crate::{
+    event::Event,
+    event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+};
+
+/// Additional methods on [`EventLoop`] to return control flow to the caller.
+pub trait EventLoopExtRunReturn {
+    /// A type provided by the user that can be passed through [`Event::UserEvent`].
+    type UserEvent;
+
+    /// Initializes the `winit` event loop.
+    ///
+    /// Unlike [`EventLoop::run`], this function accepts non-`'static` (i.e. non-`move`) closures
+    /// and returns control flow to the caller when `control_flow` is set to [`ControlFlow::Exit`].
+    ///
+    /// # Caveats
+    ///
+    /// Despite its appearance at first glance, this is *not* a perfect replacement for
+    /// `poll_events`. For example, this function will not return on Windows or macOS while a
+    /// window is getting resized, resulting in all application logic outside of the
+    /// `event_handler` closure not running until the resize operation ends. Other OS operations
+    /// may also result in such freezes. This behavior is caused by fundamental limitations in the
+    /// underlying OS APIs, which cannot be hidden by `winit` without severe stability repercussions.
+    ///
+    /// You are strongly encouraged to use `run`, unless the use of this is absolutely necessary.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11 / Wayland:** This function returns `1` upon disconnection from
+    ///   the display server.
+    fn run_return<F>(&mut self, event_handler: F) -> i32
+    where
+        F: FnMut(
+            Event<'_, Self::UserEvent>,
+            &EventLoopWindowTarget<Self::UserEvent>,
+            &mut ControlFlow,
+        );
+}
+
+impl<T> EventLoopExtRunReturn for EventLoop<T> {
+    type UserEvent = T;
+
+    fn run_return<F>(&mut self, event_handler: F) -> i32
+    where
+        F: FnMut(
+            Event<'_, Self::UserEvent>,
+            &EventLoopWindowTarget<Self::UserEvent>,
+            &mut ControlFlow,
+        ),
+    {
+        self.event_loop.run_return(event_handler)
+    }
+}

src/platform/unix.rs

@@ -1,463 +0,0 @@
-#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "netbsd", target_os = "openbsd"))]
-
-use std::{os::raw, ptr, sync::Arc};
-
-use smithay_client_toolkit::window::{ButtonState, Theme};
-
-use crate::{
-    dpi::LogicalSize,
-    event_loop::{EventLoop, EventLoopWindowTarget},
-    monitor::MonitorHandle,
-    window::{Window, WindowBuilder},
-};
-
-use crate::platform_impl::{
-    x11::{ffi::XVisualInfo, XConnection},
-    EventLoop as LinuxEventLoop, EventLoopWindowTarget as LinuxEventLoopWindowTarget,
-    Window as LinuxWindow,
-};
-
-// TODO: stupid hack so that glutin can do its work
-#[doc(hidden)]
-pub use crate::platform_impl::x11;
-
-pub use crate::platform_impl::{x11::util::WindowType as XWindowType, XNotSupported};
-
-/// Theme for wayland client side decorations
-///
-/// Colors must be in ARGB8888 format
-pub struct WaylandTheme {
-    /// Primary color when the window is focused
-    pub primary_active: [u8; 4],
-    /// Primary color when the window is unfocused
-    pub primary_inactive: [u8; 4],
-    /// Secondary color when the window is focused
-    pub secondary_active: [u8; 4],
-    /// Secondary color when the window is unfocused
-    pub secondary_inactive: [u8; 4],
-    /// Close button color when hovered over
-    pub close_button_hovered: [u8; 4],
-    /// Close button color
-    pub close_button: [u8; 4],
-    /// Close button color when hovered over
-    pub maximize_button_hovered: [u8; 4],
-    /// Maximize button color
-    pub maximize_button: [u8; 4],
-    /// Minimize button color when hovered over
-    pub minimize_button_hovered: [u8; 4],
-    /// Minimize button color
-    pub minimize_button: [u8; 4],
-}
-
-struct WaylandThemeObject(WaylandTheme);
-
-impl Theme for WaylandThemeObject {
-    fn get_primary_color(&self, active: bool) -> [u8; 4] {
-        if active {
-            self.0.primary_active
-        } else {
-            self.0.primary_inactive
-        }
-    }
-
-    // Used for division line
-    fn get_secondary_color(&self, active: bool) -> [u8; 4] {
-        if active {
-            self.0.secondary_active
-        } else {
-            self.0.secondary_inactive
-        }
-    }
-
-    fn get_close_button_color(&self, state: ButtonState) -> [u8; 4] {
-        match state {
-            ButtonState::Hovered => self.0.close_button_hovered,
-            _ => self.0.close_button,
-        }
-    }
-
-    fn get_maximize_button_color(&self, state: ButtonState) -> [u8; 4] {
-        match state {
-            ButtonState::Hovered => self.0.maximize_button_hovered,
-            _ => self.0.maximize_button,
-        }
-    }
-
-    fn get_minimize_button_color(&self, state: ButtonState) -> [u8; 4] {
-        match state {
-            ButtonState::Hovered => self.0.minimize_button_hovered,
-            _ => self.0.minimize_button,
-        }
-    }
-}
-
-/// Additional methods on `EventLoopWindowTarget` that are specific to Unix.
-pub trait EventLoopWindowTargetExtUnix {
-    /// True if the `EventLoopWindowTarget` uses Wayland.
-    fn is_wayland(&self) -> bool;
-    ///
-    /// True if the `EventLoopWindowTarget` uses X11.
-    fn is_x11(&self) -> bool;
-
-    #[doc(hidden)]
-    fn xlib_xconnection(&self) -> Option<Arc<XConnection>>;
-
-    /// Returns a pointer to the `wl_display` object of wayland that is used by this
-    /// `EventLoopWindowTarget`.
-    ///
-    /// Returns `None` if the `EventLoop` doesn't use wayland (if it uses xlib for example).
-    ///
-    /// The pointer will become invalid when the winit `EventLoop` is destroyed.
-    fn wayland_display(&self) -> Option<*mut raw::c_void>;
-}
-
-impl<T> EventLoopWindowTargetExtUnix for EventLoopWindowTarget<T> {
-    #[inline]
-    fn is_wayland(&self) -> bool {
-        self.p.is_wayland()
-    }
-
-    #[inline]
-    fn is_x11(&self) -> bool {
-        !self.p.is_wayland()
-    }
-
-    #[inline]
-    #[doc(hidden)]
-    fn xlib_xconnection(&self) -> Option<Arc<XConnection>> {
-        match self.p {
-            LinuxEventLoopWindowTarget::X(ref e) => Some(e.x_connection().clone()),
-            _ => None,
-        }
-    }
-
-    #[inline]
-    fn wayland_display(&self) -> Option<*mut raw::c_void> {
-        match self.p {
-            LinuxEventLoopWindowTarget::Wayland(ref p) => {
-                Some(p.display().get_display_ptr() as *mut _)
-            }
-            _ => None,
-        }
-    }
-}
-
-/// Additional methods on `EventLoop` that are specific to Unix.
-pub trait EventLoopExtUnix {
-    /// Builds a new `EventLoop` that is forced to use X11.
-    ///
-    /// # Panics
-    ///
-    /// If called outside the main thread. To initialize an X11 event loop outside
-    /// the main thread, use [`new_x11_any_thread`](#tymethod.new_x11_any_thread).
-    fn new_x11() -> Result<Self, XNotSupported>
-    where
-        Self: Sized;
-
-    /// Builds a new `EventLoop` that is forced to use Wayland.
-    ///
-    /// # Panics
-    ///
-    /// If called outside the main thread. To initialize a Wayland event loop outside
-    /// the main thread, use [`new_wayland_any_thread`](#tymethod.new_wayland_any_thread).
-    fn new_wayland() -> Self
-    where
-        Self: Sized;
-
-    /// Builds a new `EventLoop` on any thread.
-    ///
-    /// This method bypasses the cross-platform compatibility requirement
-    /// that `EventLoop` be created on the main thread.
-    fn new_any_thread() -> Self
-    where
-        Self: Sized;
-
-    /// Builds a new X11 `EventLoop` on any thread.
-    ///
-    /// This method bypasses the cross-platform compatibility requirement
-    /// that `EventLoop` be created on the main thread.
-    fn new_x11_any_thread() -> Result<Self, XNotSupported>
-    where
-        Self: Sized;
-
-    /// Builds a new Wayland `EventLoop` on any thread.
-    ///
-    /// This method bypasses the cross-platform compatibility requirement
-    /// that `EventLoop` be created on the main thread.
-    fn new_wayland_any_thread() -> Self
-    where
-        Self: Sized;
-}
-
-fn wrap_ev<T>(event_loop: LinuxEventLoop<T>) -> EventLoop<T> {
-    EventLoop {
-        event_loop,
-        _marker: std::marker::PhantomData,
-    }
-}
-
-impl<T> EventLoopExtUnix for EventLoop<T> {
-    #[inline]
-    fn new_any_thread() -> Self {
-        wrap_ev(LinuxEventLoop::new_any_thread())
-    }
-
-    #[inline]
-    fn new_x11_any_thread() -> Result<Self, XNotSupported> {
-        LinuxEventLoop::new_x11_any_thread().map(wrap_ev)
-    }
-
-    #[inline]
-    fn new_wayland_any_thread() -> Self {
-        wrap_ev(
-            LinuxEventLoop::new_wayland_any_thread()
-                // TODO: propagate
-                .expect("failed to open Wayland connection"),
-        )
-    }
-
-    #[inline]
-    fn new_x11() -> Result<Self, XNotSupported> {
-        LinuxEventLoop::new_x11().map(wrap_ev)
-    }
-
-    #[inline]
-    fn new_wayland() -> Self {
-        wrap_ev(
-            LinuxEventLoop::new_wayland()
-                // TODO: propagate
-                .expect("failed to open Wayland connection"),
-        )
-    }
-}
-
-/// Additional methods on `Window` that are specific to Unix.
-pub trait WindowExtUnix {
-    /// Returns the ID of the `Window` xlib object that is used by this window.
-    ///
-    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
-    fn xlib_window(&self) -> Option<raw::c_ulong>;
-
-    /// Returns a pointer to the `Display` object of xlib that is used by this window.
-    ///
-    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
-    ///
-    /// The pointer will become invalid when the glutin `Window` is destroyed.
-    fn xlib_display(&self) -> Option<*mut raw::c_void>;
-
-    fn xlib_screen_id(&self) -> Option<raw::c_int>;
-
-    #[doc(hidden)]
-    fn xlib_xconnection(&self) -> Option<Arc<XConnection>>;
-
-    /// Set window urgency hint (`XUrgencyHint`). Only relevant on X.
-    fn set_urgent(&self, is_urgent: bool);
-
-    /// This function returns the underlying `xcb_connection_t` of an xlib `Display`.
-    ///
-    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
-    ///
-    /// The pointer will become invalid when the glutin `Window` is destroyed.
-    fn xcb_connection(&self) -> Option<*mut raw::c_void>;
-
-    /// Returns a pointer to the `wl_surface` object of wayland that is used by this window.
-    ///
-    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
-    ///
-    /// The pointer will become invalid when the glutin `Window` is destroyed.
-    fn wayland_surface(&self) -> Option<*mut raw::c_void>;
-
-    /// Returns a pointer to the `wl_display` object of wayland that is used by this window.
-    ///
-    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
-    ///
-    /// The pointer will become invalid when the glutin `Window` is destroyed.
-    fn wayland_display(&self) -> Option<*mut raw::c_void>;
-
-    /// Sets the color theme of the client side window decorations on wayland
-    fn set_wayland_theme(&self, theme: WaylandTheme);
-
-    /// Check if the window is ready for drawing
-    ///
-    /// It is a remnant of a previous implementation detail for the
-    /// wayland backend, and is no longer relevant.
-    ///
-    /// Always return true.
-    #[deprecated]
-    fn is_ready(&self) -> bool;
-}
-
-impl WindowExtUnix for Window {
-    #[inline]
-    fn xlib_window(&self) -> Option<raw::c_ulong> {
-        match self.window {
-            LinuxWindow::X(ref w) => Some(w.xlib_window()),
-            _ => None,
-        }
-    }
-
-    #[inline]
-    fn xlib_display(&self) -> Option<*mut raw::c_void> {
-        match self.window {
-            LinuxWindow::X(ref w) => Some(w.xlib_display()),
-            _ => None,
-        }
-    }
-
-    #[inline]
-    fn xlib_screen_id(&self) -> Option<raw::c_int> {
-        match self.window {
-            LinuxWindow::X(ref w) => Some(w.xlib_screen_id()),
-            _ => None,
-        }
-    }
-
-    #[inline]
-    #[doc(hidden)]
-    fn xlib_xconnection(&self) -> Option<Arc<XConnection>> {
-        match self.window {
-            LinuxWindow::X(ref w) => Some(w.xlib_xconnection()),
-            _ => None,
-        }
-    }
-
-    #[inline]
-    fn set_urgent(&self, is_urgent: bool) {
-        if let LinuxWindow::X(ref w) = self.window {
-            w.set_urgent(is_urgent);
-        }
-    }
-
-    #[inline]
-    fn xcb_connection(&self) -> Option<*mut raw::c_void> {
-        match self.window {
-            LinuxWindow::X(ref w) => Some(w.xcb_connection()),
-            _ => None,
-        }
-    }
-
-    #[inline]
-    fn wayland_surface(&self) -> Option<*mut raw::c_void> {
-        match self.window {
-            LinuxWindow::Wayland(ref w) => Some(w.surface().as_ref().c_ptr() as *mut _),
-            _ => None,
-        }
-    }
-
-    #[inline]
-    fn wayland_display(&self) -> Option<*mut raw::c_void> {
-        match self.window {
-            LinuxWindow::Wayland(ref w) => Some(w.display().as_ref().c_ptr() as *mut _),
-            _ => None,
-        }
-    }
-
-    #[inline]
-    fn set_wayland_theme(&self, theme: WaylandTheme) {
-        match self.window {
-            LinuxWindow::Wayland(ref w) => w.set_theme(WaylandThemeObject(theme)),
-            _ => {}
-        }
-    }
-
-    #[inline]
-    fn is_ready(&self) -> bool {
-        true
-    }
-}
-
-/// Additional methods on `WindowBuilder` that are specific to Unix.
-pub trait WindowBuilderExtUnix {
-    fn with_x11_visual<T>(self, visual_infos: *const T) -> Self;
-    fn with_x11_screen(self, screen_id: i32) -> Self;
-
-    /// Build window with `WM_CLASS` hint; defaults to the name of the binary. Only relevant on X11.
-    fn with_class(self, class: String, instance: String) -> Self;
-    /// Build window with override-redirect flag; defaults to false. Only relevant on X11.
-    fn with_override_redirect(self, override_redirect: bool) -> Self;
-    /// Build window with `_NET_WM_WINDOW_TYPE` hints; defaults to `Normal`. Only relevant on X11.
-    fn with_x11_window_type(self, x11_window_type: Vec<XWindowType>) -> Self;
-    /// Build window with `_GTK_THEME_VARIANT` hint set to the specified value. Currently only relevant on X11.
-    fn with_gtk_theme_variant(self, variant: String) -> Self;
-    /// Build window with resize increment hint. Only implemented on X11.
-    fn with_resize_increments(self, increments: LogicalSize) -> Self;
-    /// Build window with base size hint. Only implemented on X11.
-    fn with_base_size(self, base_size: LogicalSize) -> Self;
-
-    /// Build window with a given application ID. It should match the `.desktop` file distributed with
-    /// your program. Only relevant on Wayland.
-    ///
-    /// For details about application ID conventions, see the
-    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
-    fn with_app_id(self, app_id: String) -> Self;
-}
-
-impl WindowBuilderExtUnix for WindowBuilder {
-    #[inline]
-    fn with_x11_visual<T>(mut self, visual_infos: *const T) -> Self {
-        self.platform_specific.visual_infos =
-            Some(unsafe { ptr::read(visual_infos as *const XVisualInfo) });
-        self
-    }
-
-    #[inline]
-    fn with_x11_screen(mut self, screen_id: i32) -> Self {
-        self.platform_specific.screen_id = Some(screen_id);
-        self
-    }
-
-    #[inline]
-    fn with_class(mut self, instance: String, class: String) -> Self {
-        self.platform_specific.class = Some((instance, class));
-        self
-    }
-
-    #[inline]
-    fn with_override_redirect(mut self, override_redirect: bool) -> Self {
-        self.platform_specific.override_redirect = override_redirect;
-        self
-    }
-
-    #[inline]
-    fn with_x11_window_type(mut self, x11_window_types: Vec<XWindowType>) -> Self {
-        self.platform_specific.x11_window_types = x11_window_types;
-        self
-    }
-
-    #[inline]
-    fn with_gtk_theme_variant(mut self, variant: String) -> Self {
-        self.platform_specific.gtk_theme_variant = Some(variant);
-        self
-    }
-
-    #[inline]
-    fn with_resize_increments(mut self, increments: LogicalSize) -> Self {
-        self.platform_specific.resize_increments = Some(increments.into());
-        self
-    }
-
-    #[inline]
-    fn with_base_size(mut self, base_size: LogicalSize) -> Self {
-        self.platform_specific.base_size = Some(base_size.into());
-        self
-    }
-
-    #[inline]
-    fn with_app_id(mut self, app_id: String) -> Self {
-        self.platform_specific.app_id = Some(app_id);
-        self
-    }
-}
-
-/// Additional methods on `MonitorHandle` that are specific to Linux.
-pub trait MonitorHandleExtUnix {
-    /// Returns the inner identifier of the monitor.
-    fn native_id(&self) -> u32;
-}
-
-impl MonitorHandleExtUnix for MonitorHandle {
-    #[inline]
-    fn native_id(&self) -> u32 {
-        self.inner.native_identifier()
-    }
-}

src/platform/wayland.rs

@@ -0,0 +1,144 @@
+use std::os::raw;
+
+use crate::{
+    event_loop::{EventLoopBuilder, EventLoopWindowTarget},
+    monitor::MonitorHandle,
+    window::{Window, WindowBuilder},
+};
+
+use crate::platform_impl::{
+    ApplicationName, Backend, EventLoopWindowTarget as LinuxEventLoopWindowTarget,
+    Window as LinuxWindow,
+};
+
+pub use crate::window::Theme;
+
+/// Additional methods on [`EventLoopWindowTarget`] that are specific to Wayland.
+pub trait EventLoopWindowTargetExtWayland {
+    /// True if the [`EventLoopWindowTarget`] uses Wayland.
+    fn is_wayland(&self) -> bool;
+
+    /// Returns a pointer to the `wl_display` object of wayland that is used by this
+    /// [`EventLoopWindowTarget`].
+    ///
+    /// Returns `None` if the [`EventLoop`] doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the winit [`EventLoop`] is destroyed.
+    ///
+    /// [`EventLoop`]: crate::event_loop::EventLoop
+    fn wayland_display(&self) -> Option<*mut raw::c_void>;
+}
+
+impl<T> EventLoopWindowTargetExtWayland for EventLoopWindowTarget<T> {
+    #[inline]
+    fn is_wayland(&self) -> bool {
+        self.p.is_wayland()
+    }
+
+    #[inline]
+    fn wayland_display(&self) -> Option<*mut raw::c_void> {
+        match self.p {
+            LinuxEventLoopWindowTarget::Wayland(ref p) => {
+                Some(p.display().get_display_ptr() as *mut _)
+            }
+            #[cfg(x11_platform)]
+            _ => None,
+        }
+    }
+}
+
+/// Additional methods on [`EventLoopBuilder`] that are specific to Wayland.
+pub trait EventLoopBuilderExtWayland {
+    /// Force using Wayland.
+    fn with_wayland(&mut self) -> &mut Self;
+
+    /// Whether to allow the event loop to be created off of the main thread.
+    ///
+    /// By default, the window is only allowed to be created on the main
+    /// thread, to make platform compatibility easier.
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtWayland for EventLoopBuilder<T> {
+    #[inline]
+    fn with_wayland(&mut self) -> &mut Self {
+        self.platform_specific.forced_backend = Some(Backend::Wayland);
+        self
+    }
+
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+}
+
+/// Additional methods on [`Window`] that are specific to Wayland.
+pub trait WindowExtWayland {
+    /// Returns a pointer to the `wl_surface` object of wayland that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn wayland_surface(&self) -> Option<*mut raw::c_void>;
+
+    /// Returns a pointer to the `wl_display` object of wayland that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use wayland (if it uses xlib for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn wayland_display(&self) -> Option<*mut raw::c_void>;
+}
+
+impl WindowExtWayland for Window {
+    #[inline]
+    fn wayland_surface(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => Some(w.surface().as_ref().c_ptr() as *mut _),
+            #[cfg(x11_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn wayland_display(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::Wayland(ref w) => Some(w.display().get_display_ptr() as *mut _),
+            #[cfg(x11_platform)]
+            _ => None,
+        }
+    }
+}
+
+/// Additional methods on [`WindowBuilder`] that are specific to Wayland.
+pub trait WindowBuilderExtWayland {
+    /// Build window with the given name.
+    ///
+    /// The `general` name sets an application ID, which should match the `.desktop`
+    /// file destributed with your program. The `instance` is a `no-op`.
+    ///
+    /// For details about application ID conventions, see the
+    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
+    fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;
+}
+
+impl WindowBuilderExtWayland for WindowBuilder {
+    #[inline]
+    fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
+        self.platform_specific.name = Some(ApplicationName::new(general.into(), instance.into()));
+        self
+    }
+}
+
+/// Additional methods on `MonitorHandle` that are specific to Wayland.
+pub trait MonitorHandleExtWayland {
+    /// Returns the inner identifier of the monitor.
+    fn native_id(&self) -> u32;
+}
+
+impl MonitorHandleExtWayland for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+}

src/platform/web.rs

@@ -1,22 +1,89 @@
-#![cfg(target_arch = "wasm32")]
-
 //! The web target does not automatically insert the canvas element object into the web page, to
-//! allow end users to determine how the page should be laid out. Use the `WindowExtStdweb` or
-//! `WindowExtWebSys` traits (depending on your web backend) to retrieve the canvas from the
-//! Window.
+//! allow end users to determine how the page should be laid out. Use the [`WindowExtWebSys`] trait
+//! to retrieve the canvas from the Window. Alternatively, use the [`WindowBuilderExtWebSys`] trait
+//! to provide your own canvas.
 
-#[cfg(feature = "stdweb")]
-use stdweb::web::html_element::CanvasElement;
+use crate::event::Event;
+use crate::event_loop::ControlFlow;
+use crate::event_loop::EventLoop;
+use crate::event_loop::EventLoopWindowTarget;
+use crate::window::WindowBuilder;
 
-#[cfg(feature = "stdweb")]
-pub trait WindowExtStdweb {
-    fn canvas(&self) -> CanvasElement;
-}
-
-#[cfg(feature = "web-sys")]
 use web_sys::HtmlCanvasElement;
 
-#[cfg(feature = "web-sys")]
 pub trait WindowExtWebSys {
     fn canvas(&self) -> HtmlCanvasElement;
+
+    /// Whether the browser reports the preferred color scheme to be "dark".
+    fn is_dark_mode(&self) -> bool;
+}
+
+pub trait WindowBuilderExtWebSys {
+    fn with_canvas(self, canvas: Option<HtmlCanvasElement>) -> Self;
+
+    /// Whether `event.preventDefault` should be automatically called to prevent event propagation
+    /// when appropriate.
+    ///
+    /// For example, mouse wheel events are only handled by the canvas by default. This avoids
+    /// the default behavior of scrolling the page.
+    fn with_prevent_default(self, prevent_default: bool) -> Self;
+
+    /// Whether the canvas should be focusable using the tab key. This is necessary to capture
+    /// canvas keyboard events.
+    fn with_focusable(self, focusable: bool) -> Self;
+}
+
+impl WindowBuilderExtWebSys for WindowBuilder {
+    fn with_canvas(mut self, canvas: Option<HtmlCanvasElement>) -> Self {
+        self.platform_specific.canvas = canvas;
+
+        self
+    }
+
+    fn with_prevent_default(mut self, prevent_default: bool) -> Self {
+        self.platform_specific.prevent_default = prevent_default;
+
+        self
+    }
+
+    fn with_focusable(mut self, focusable: bool) -> Self {
+        self.platform_specific.focusable = focusable;
+
+        self
+    }
+}
+
+/// 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;
+
+    /// Initializes the winit event loop.
+    ///
+    /// Unlike `run`, this returns immediately, and doesn't throw an exception in order to
+    /// satisfy its `!` return type.
+    fn spawn<F>(self, event_handler: F)
+    where
+        F: 'static
+            + FnMut(
+                Event<'_, Self::UserEvent>,
+                &EventLoopWindowTarget<Self::UserEvent>,
+                &mut ControlFlow,
+            );
+}
+
+impl<T> EventLoopExtWebSys for EventLoop<T> {
+    type UserEvent = T;
+
+    fn spawn<F>(self, event_handler: F)
+    where
+        F: 'static
+            + FnMut(
+                Event<'_, Self::UserEvent>,
+                &EventLoopWindowTarget<Self::UserEvent>,
+                &mut ControlFlow,
+            ),
+    {
+        self.event_loop.spawn(event_handler)
+    }
 }

src/platform/windows.rs

@@ -1,117 +1,243 @@
-#![cfg(target_os = "windows")]
-
-use std::os::raw::c_void;
-
-use libc;
-use winapi::shared::windef::HWND;
+use std::{ffi::c_void, path::Path};
 
 use crate::{
+    dpi::PhysicalSize,
     event::DeviceId,
-    event_loop::EventLoop,
+    event_loop::EventLoopBuilder,
     monitor::MonitorHandle,
-    platform_impl::EventLoop as WindowsEventLoop,
-    window::{Icon, Window, WindowBuilder},
+    platform_impl::WinIcon,
+    window::{BadIcon, Icon, Window, WindowBuilder},
 };
 
+/// Window Handle type used by Win32 API
+pub type HWND = isize;
+/// Menu Handle type used by Win32 API
+pub type HMENU = isize;
+/// Monitor Handle type used by Win32 API
+pub type HMONITOR = isize;
+/// Instance Handle type used by Win32 API
+pub type HINSTANCE = isize;
+
 /// Additional methods on `EventLoop` that are specific to Windows.
-pub trait EventLoopExtWindows {
-    /// Creates an event loop off of the main thread.
+pub trait EventLoopBuilderExtWindows {
+    /// Whether to allow the event loop to be created off of the main thread.
+    ///
+    /// By default, the window is only allowed to be created on the main
+    /// thread, to make platform compatibility easier.
     ///
     /// # `Window` caveats
     ///
     /// Note that any `Window` created on the new thread will be destroyed when the thread
     /// terminates. Attempting to use a `Window` after its parent thread terminates has
     /// unspecified, although explicitly not undefined, behavior.
-    fn new_any_thread() -> Self
-    where
-        Self: Sized;
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
 
-    /// By default, winit on Windows will attempt to enable process-wide DPI awareness. If that's
-    /// undesirable, you can create an `EventLoop` using this function instead.
-    fn new_dpi_unaware() -> Self
-    where
-        Self: Sized;
-
-    /// Creates a DPI-unaware event loop off of the main thread.
+    /// Whether to enable process-wide DPI awareness.
     ///
-    /// The `Window` caveats in [`new_any_thread`](EventLoopExtWindows::new_any_thread) also apply here.
-    fn new_dpi_unaware_any_thread() -> Self
+    /// By default, `winit` will attempt to enable process-wide DPI awareness. If
+    /// that's undesirable, you can disable it with this function.
+    ///
+    /// # Example
+    ///
+    /// Disable process-wide DPI awareness.
+    ///
+    /// ```
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "windows")]
+    /// use winit::platform::windows::EventLoopBuilderExtWindows;
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "windows")]
+    /// builder.with_dpi_aware(false);
+    /// # if false { // We can't test this part
+    /// let event_loop = builder.build();
+    /// # }
+    /// ```
+    fn with_dpi_aware(&mut self, dpi_aware: bool) -> &mut Self;
+
+    /// A callback to be executed before dispatching a win32 message to the window procedure.
+    /// Return true to disable winit's internal message dispatching.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use windows_sys::Win32::UI::WindowsAndMessaging::{ACCEL, CreateAcceleratorTableW, TranslateAcceleratorW, DispatchMessageW, TranslateMessage, MSG};
+    /// use winit::event_loop::EventLoopBuilder;
+    /// #[cfg(target_os = "windows")]
+    /// use winit::platform::windows::EventLoopBuilderExtWindows;
+    ///
+    /// let mut builder = EventLoopBuilder::new();
+    /// #[cfg(target_os = "windows")]
+    /// builder.with_msg_hook(|msg|{
+    ///     let msg = msg as *const MSG;
+    /// #   let accels: Vec<ACCEL> = Vec::new();
+    ///     let translated = unsafe {
+    ///         TranslateAcceleratorW(
+    ///             (*msg).hwnd,
+    ///             CreateAcceleratorTableW(accels.as_ptr() as _, 1),
+    ///             msg,
+    ///         ) == 1
+    ///     };
+    ///     translated
+    /// });
+    /// ```
+    fn with_msg_hook<F>(&mut self, callback: F) -> &mut Self
     where
-        Self: Sized;
+        F: FnMut(*const c_void) -> bool + 'static;
 }
 
-impl<T> EventLoopExtWindows for EventLoop<T> {
+impl<T> EventLoopBuilderExtWindows for EventLoopBuilder<T> {
     #[inline]
-    fn new_any_thread() -> Self {
-        EventLoop {
-            event_loop: WindowsEventLoop::new_any_thread(),
-            _marker: ::std::marker::PhantomData,
-        }
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
     }
 
     #[inline]
-    fn new_dpi_unaware() -> Self {
-        EventLoop {
-            event_loop: WindowsEventLoop::new_dpi_unaware(),
-            _marker: ::std::marker::PhantomData,
-        }
+    fn with_dpi_aware(&mut self, dpi_aware: bool) -> &mut Self {
+        self.platform_specific.dpi_aware = dpi_aware;
+        self
     }
 
     #[inline]
-    fn new_dpi_unaware_any_thread() -> Self {
-        EventLoop {
-            event_loop: WindowsEventLoop::new_dpi_unaware_any_thread(),
-            _marker: ::std::marker::PhantomData,
-        }
+    fn with_msg_hook<F>(&mut self, callback: F) -> &mut Self
+    where
+        F: FnMut(*const c_void) -> bool + 'static,
+    {
+        self.platform_specific.msg_hook = Some(Box::new(callback));
+        self
     }
 }
 
 /// Additional methods on `Window` that are specific to Windows.
 pub trait WindowExtWindows {
     /// Returns the HINSTANCE of the window
-    fn hinstance(&self) -> *mut libc::c_void;
+    fn hinstance(&self) -> HINSTANCE;
     /// Returns the native handle that is used by this window.
     ///
     /// The pointer will become invalid when the native window was destroyed.
-    fn hwnd(&self) -> *mut libc::c_void;
+    fn hwnd(&self) -> HWND;
+
+    /// Enables or disables mouse and keyboard input to the specified window.
+    ///
+    /// A window must be enabled before it can be activated.
+    /// If an application has create a modal dialog box by disabling its owner window
+    /// (as described in [`WindowBuilderExtWindows::with_owner_window`]), the application must enable
+    /// the owner window before destroying the dialog box.
+    /// Otherwise, another window will receive the keyboard focus and be activated.
+    ///
+    /// If a child window is disabled, it is ignored when the system tries to determine which
+    /// window should receive mouse messages.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-enablewindow#remarks>
+    /// and <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#disabled-windows>
+    fn set_enable(&self, enabled: bool);
 
     /// This sets `ICON_BIG`. A good ceiling here is 256x256.
     fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>);
+
+    /// Whether to show or hide the window icon in the taskbar.
+    fn set_skip_taskbar(&self, skip: bool);
+
+    /// Shows or hides the background drop shadow for undecorated windows.
+    ///
+    /// Enabling the shadow causes a thin 1px line to appear on the top of the window.
+    fn set_undecorated_shadow(&self, shadow: bool);
 }
 
 impl WindowExtWindows for Window {
     #[inline]
-    fn hinstance(&self) -> *mut libc::c_void {
-        self.window.hinstance() as *mut _
+    fn hinstance(&self) -> HINSTANCE {
+        self.window.hinstance()
     }
 
     #[inline]
-    fn hwnd(&self) -> *mut libc::c_void {
-        self.window.hwnd() as *mut _
+    fn hwnd(&self) -> HWND {
+        self.window.hwnd()
+    }
+
+    #[inline]
+    fn set_enable(&self, enabled: bool) {
+        self.window.set_enable(enabled)
     }
 
     #[inline]
     fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
         self.window.set_taskbar_icon(taskbar_icon)
     }
+
+    #[inline]
+    fn set_skip_taskbar(&self, skip: bool) {
+        self.window.set_skip_taskbar(skip)
+    }
+
+    #[inline]
+    fn set_undecorated_shadow(&self, shadow: bool) {
+        self.window.set_undecorated_shadow(shadow)
+    }
 }
 
 /// Additional methods on `WindowBuilder` that are specific to Windows.
 pub trait WindowBuilderExtWindows {
-    /// Sets a parent to the window to be created.
-    fn with_parent_window(self, parent: HWND) -> WindowBuilder;
+    /// Set an owner to the window to be created. Can be used to create a dialog box, for example.
+    /// This only works when [`WindowBuilder::with_parent_window`] isn't called or set to `None`.
+    /// Can be used in combination with [`WindowExtWindows::set_enable(false)`](WindowExtWindows::set_enable)
+    /// on the owner window to create a modal dialog box.
+    ///
+    /// From MSDN:
+    /// - An owned window is always above its owner in the z-order.
+    /// - The system automatically destroys an owned window when its owner is destroyed.
+    /// - An owned window is hidden when its owner is minimized.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#owned-windows>
+    fn with_owner_window(self, parent: HWND) -> WindowBuilder;
+
+    /// Sets a menu on the window to be created.
+    ///
+    /// Parent and menu are mutually exclusive; a child window cannot have a menu!
+    ///
+    /// The menu must have been manually created beforehand with [`CreateMenu`] or similar.
+    ///
+    /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how the menus look.
+    /// If you use this, it is recommended that you combine it with `with_theme(Some(Theme::Light))` to avoid a jarring effect.
+    ///
+    /// [`CreateMenu`]: windows_sys::Win32::UI::WindowsAndMessaging::CreateMenu
+    fn with_menu(self, menu: HMENU) -> WindowBuilder;
 
     /// This sets `ICON_BIG`. A good ceiling here is 256x256.
     fn with_taskbar_icon(self, taskbar_icon: Option<Icon>) -> WindowBuilder;
 
     /// This sets `WS_EX_NOREDIRECTIONBITMAP`.
     fn with_no_redirection_bitmap(self, flag: bool) -> WindowBuilder;
+
+    /// 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) -> WindowBuilder;
+
+    /// Whether show or hide the window icon in the taskbar.
+    fn with_skip_taskbar(self, skip: bool) -> WindowBuilder;
+
+    /// Shows or hides the background drop shadow for undecorated windows.
+    ///
+    /// The shadow is hidden by default.
+    /// Enabling the shadow causes a thin 1px line to appear on the top of the window.
+    fn with_undecorated_shadow(self, shadow: bool) -> WindowBuilder;
 }
 
 impl WindowBuilderExtWindows for WindowBuilder {
     #[inline]
-    fn with_parent_window(mut self, parent: HWND) -> WindowBuilder {
-        self.platform_specific.parent = Some(parent);
+    fn with_owner_window(mut self, parent: HWND) -> WindowBuilder {
+        self.platform_specific.owner = Some(parent);
+        self
+    }
+
+    #[inline]
+    fn with_menu(mut self, menu: HMENU) -> WindowBuilder {
+        self.platform_specific.menu = Some(menu);
         self
     }
 
@@ -126,6 +252,24 @@ impl WindowBuilderExtWindows for WindowBuilder {
         self.platform_specific.no_redirection_bitmap = flag;
         self
     }
+
+    #[inline]
+    fn with_drag_and_drop(mut self, flag: bool) -> WindowBuilder {
+        self.platform_specific.drag_and_drop = flag;
+        self
+    }
+
+    #[inline]
+    fn with_skip_taskbar(mut self, skip: bool) -> WindowBuilder {
+        self.platform_specific.skip_taskbar = skip;
+        self
+    }
+
+    #[inline]
+    fn with_undecorated_shadow(mut self, shadow: bool) -> WindowBuilder {
+        self.platform_specific.decoration_shadow = shadow;
+        self
+    }
 }
 
 /// Additional methods on `MonitorHandle` that are specific to Windows.
@@ -134,7 +278,7 @@ pub trait MonitorHandleExtWindows {
     fn native_id(&self) -> String;
 
     /// Returns the handle of the monitor - `HMONITOR`.
-    fn hmonitor(&self) -> *mut c_void;
+    fn hmonitor(&self) -> HMONITOR;
 }
 
 impl MonitorHandleExtWindows for MonitorHandle {
@@ -144,8 +288,8 @@ impl MonitorHandleExtWindows for MonitorHandle {
     }
 
     #[inline]
-    fn hmonitor(&self) -> *mut c_void {
-        self.inner.hmonitor() as *mut _
+    fn hmonitor(&self) -> HMONITOR {
+        self.inner.hmonitor()
     }
 }
 
@@ -163,3 +307,40 @@ impl DeviceIdExtWindows for DeviceId {
         self.0.persistent_identifier()
     }
 }
+
+/// Additional methods on `Icon` that are specific to Windows.
+pub trait IconExtWindows: Sized {
+    /// Create an icon from a file path.
+    ///
+    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
+    /// icon size from the file.
+    ///
+    /// In cases where the specified size does not exist in the file, Windows may perform scaling
+    /// to get an icon of the desired size.
+    fn from_path<P: AsRef<Path>>(path: P, size: Option<PhysicalSize<u32>>)
+        -> Result<Self, BadIcon>;
+
+    /// Create an icon from a resource embedded in this executable or library.
+    ///
+    /// Specify `size` to load a specific icon size from the file, or `None` to load the default
+    /// icon size from the file.
+    ///
+    /// In cases where the specified size does not exist in the file, Windows may perform scaling
+    /// to get an icon of the desired size.
+    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon>;
+}
+
+impl IconExtWindows for Icon {
+    fn from_path<P: AsRef<Path>>(
+        path: P,
+        size: Option<PhysicalSize<u32>>,
+    ) -> Result<Self, BadIcon> {
+        let win_icon = WinIcon::from_path(path, size)?;
+        Ok(Icon { inner: win_icon })
+    }
+
+    fn from_resource(ordinal: u16, size: Option<PhysicalSize<u32>>) -> Result<Self, BadIcon> {
+        let win_icon = WinIcon::from_resource(ordinal, size)?;
+        Ok(Icon { inner: win_icon })
+    }
+}

src/platform/x11.rs

@@ -0,0 +1,233 @@
+use std::os::raw;
+use std::ptr;
+
+use crate::{
+    event_loop::{EventLoopBuilder, EventLoopWindowTarget},
+    monitor::MonitorHandle,
+    window::{Window, WindowBuilder},
+};
+
+use crate::dpi::Size;
+use crate::platform_impl::{
+    x11::ffi::XVisualInfo, ApplicationName, Backend, Window as LinuxWindow, XLIB_ERROR_HOOKS,
+};
+
+pub use crate::platform_impl::{x11::util::WindowType as XWindowType, XNotSupported};
+
+/// The first argument in the provided hook will be the pointer to `XDisplay`
+/// and the second one the pointer to [`XErrorEvent`]. The returned `bool` is an
+/// indicator whether the error was handled by the callback.
+///
+/// [`XErrorEvent`]: https://linux.die.net/man/3/xerrorevent
+pub type XlibErrorHook =
+    Box<dyn Fn(*mut std::ffi::c_void, *mut std::ffi::c_void) -> bool + Send + Sync>;
+
+/// Hook to winit's xlib error handling callback.
+///
+/// This method is provided as a safe way to handle the errors comming from X11
+/// when using xlib in external crates, like glutin for GLX access. Trying to
+/// handle errors by speculating with `XSetErrorHandler` is [`unsafe`].
+///
+/// **Be aware that your hook is always invoked and returning `true` from it will
+/// prevent `winit` from getting the error itself. It's wise to always return
+/// `false` if you're not initiated the `Sync`.**
+///
+/// [`unsafe`]: https://www.remlab.net/op/xlib.shtml
+#[inline]
+pub fn register_xlib_error_hook(hook: XlibErrorHook) {
+    // Append new hook.
+    unsafe {
+        XLIB_ERROR_HOOKS.lock().unwrap().push(hook);
+    }
+}
+
+/// Additional methods on [`EventLoopWindowTarget`] that are specific to X11.
+pub trait EventLoopWindowTargetExtX11 {
+    /// True if the [`EventLoopWindowTarget`] uses X11.
+    fn is_x11(&self) -> bool;
+}
+
+impl<T> EventLoopWindowTargetExtX11 for EventLoopWindowTarget<T> {
+    #[inline]
+    fn is_x11(&self) -> bool {
+        !self.p.is_wayland()
+    }
+}
+
+/// Additional methods on [`EventLoopBuilder`] that are specific to X11.
+pub trait EventLoopBuilderExtX11 {
+    /// Force using X11.
+    fn with_x11(&mut self) -> &mut Self;
+
+    /// Whether to allow the event loop to be created off of the main thread.
+    ///
+    /// By default, the window is only allowed to be created on the main
+    /// thread, to make platform compatibility easier.
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self;
+}
+
+impl<T> EventLoopBuilderExtX11 for EventLoopBuilder<T> {
+    #[inline]
+    fn with_x11(&mut self) -> &mut Self {
+        self.platform_specific.forced_backend = Some(Backend::X);
+        self
+    }
+
+    #[inline]
+    fn with_any_thread(&mut self, any_thread: bool) -> &mut Self {
+        self.platform_specific.any_thread = any_thread;
+        self
+    }
+}
+
+/// Additional methods on [`Window`] that are specific to X11.
+pub trait WindowExtX11 {
+    /// Returns the ID of the [`Window`] xlib object that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+    fn xlib_window(&self) -> Option<raw::c_ulong>;
+
+    /// Returns a pointer to the `Display` object of xlib that is used by this window.
+    ///
+    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn xlib_display(&self) -> Option<*mut raw::c_void>;
+
+    fn xlib_screen_id(&self) -> Option<raw::c_int>;
+
+    /// This function returns the underlying `xcb_connection_t` of an xlib `Display`.
+    ///
+    /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
+    ///
+    /// The pointer will become invalid when the [`Window`] is destroyed.
+    fn xcb_connection(&self) -> Option<*mut raw::c_void>;
+}
+
+impl WindowExtX11 for Window {
+    #[inline]
+    fn xlib_window(&self) -> Option<raw::c_ulong> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_window()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn xlib_display(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_display()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn xlib_screen_id(&self) -> Option<raw::c_int> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_screen_id()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    fn xcb_connection(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xcb_connection()),
+            #[cfg(wayland_platform)]
+            _ => None,
+        }
+    }
+}
+
+/// Additional methods on [`WindowBuilder`] that are specific to X11.
+pub trait WindowBuilderExtX11 {
+    fn with_x11_visual<T>(self, visual_infos: *const T) -> Self;
+
+    fn with_x11_screen(self, screen_id: i32) -> Self;
+
+    /// Build window with the given `general` and `instance` names.
+    ///
+    /// The `general` sets general class of `WM_CLASS(STRING)`, while `instance` set the
+    /// instance part of it. The resulted property looks like `WM_CLASS(STRING) = "general", "instance"`.
+    ///
+    /// For details about application ID conventions, see the
+    /// [Desktop Entry Spec](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#desktop-file-id)
+    fn with_name(self, general: impl Into<String>, instance: impl Into<String>) -> Self;
+
+    /// Build window with override-redirect flag; defaults to false. Only relevant on X11.
+    fn with_override_redirect(self, override_redirect: bool) -> Self;
+
+    /// Build window with `_NET_WM_WINDOW_TYPE` hints; defaults to `Normal`. Only relevant on X11.
+    fn with_x11_window_type(self, x11_window_type: Vec<XWindowType>) -> Self;
+
+    /// Build window with base size hint. Only implemented on X11.
+    ///
+    /// ```
+    /// # use winit::dpi::{LogicalSize, PhysicalSize};
+    /// # use winit::window::WindowBuilder;
+    /// # use winit::platform::x11::WindowBuilderExtX11;
+    /// // Specify the size in logical dimensions like this:
+    /// WindowBuilder::new().with_base_size(LogicalSize::new(400.0, 200.0));
+    ///
+    /// // Or specify the size in physical dimensions like this:
+    /// WindowBuilder::new().with_base_size(PhysicalSize::new(400, 200));
+    /// ```
+    fn with_base_size<S: Into<Size>>(self, base_size: S) -> Self;
+}
+
+impl WindowBuilderExtX11 for WindowBuilder {
+    #[inline]
+    fn with_x11_visual<T>(mut self, visual_infos: *const T) -> Self {
+        {
+            self.platform_specific.visual_infos =
+                Some(unsafe { ptr::read(visual_infos as *const XVisualInfo) });
+        }
+        self
+    }
+
+    #[inline]
+    fn with_x11_screen(mut self, screen_id: i32) -> Self {
+        self.platform_specific.screen_id = Some(screen_id);
+        self
+    }
+
+    #[inline]
+    fn with_name(mut self, general: impl Into<String>, instance: impl Into<String>) -> Self {
+        self.platform_specific.name = Some(ApplicationName::new(general.into(), instance.into()));
+        self
+    }
+
+    #[inline]
+    fn with_override_redirect(mut self, override_redirect: bool) -> Self {
+        self.platform_specific.override_redirect = override_redirect;
+        self
+    }
+
+    #[inline]
+    fn with_x11_window_type(mut self, x11_window_types: Vec<XWindowType>) -> Self {
+        self.platform_specific.x11_window_types = x11_window_types;
+        self
+    }
+
+    #[inline]
+    fn with_base_size<S: Into<Size>>(mut self, base_size: S) -> Self {
+        self.platform_specific.base_size = Some(base_size.into());
+        self
+    }
+}
+
+/// Additional methods on `MonitorHandle` that are specific to X11.
+pub trait MonitorHandleExtX11 {
+    /// Returns the inner identifier of the monitor.
+    fn native_id(&self) -> u32;
+}
+
+impl MonitorHandleExtX11 for MonitorHandle {
+    #[inline]
+    fn native_id(&self) -> u32 {
+        self.inner.native_identifier()
+    }
+}

src/platform_impl/android/ffi.rs

@@ -1,122 +0,0 @@
-#![allow(dead_code)]
-#![allow(non_snake_case)]
-#![allow(non_camel_case_types)]
-#![allow(non_upper_case_globals)]
-
-use libc;
-use std::os::raw;
-
-#[link(name = "android")]
-#[link(name = "EGL")]
-#[link(name = "GLESv2")]
-extern "C" {}
-
-/**
- ** asset_manager.h
- **/
-pub type AAssetManager = raw::c_void;
-
-/**
- ** native_window.h
- **/
-pub type ANativeWindow = raw::c_void;
-
-extern "C" {
-    pub fn ANativeWindow_getHeight(window: *const ANativeWindow) -> libc::int32_t;
-    pub fn ANativeWindow_getWidth(window: *const ANativeWindow) -> libc::int32_t;
-}
-
-/**
- ** native_activity.h
- **/
-pub type JavaVM = ();
-pub type JNIEnv = ();
-pub type jobject = *const libc::c_void;
-
-pub type AInputQueue = (); // FIXME: wrong
-pub type ARect = (); // FIXME: wrong
-
-#[repr(C)]
-pub struct ANativeActivity {
-    pub callbacks: *mut ANativeActivityCallbacks,
-    pub vm: *mut JavaVM,
-    pub env: *mut JNIEnv,
-    pub clazz: jobject,
-    pub internalDataPath: *const libc::c_char,
-    pub externalDataPath: *const libc::c_char,
-    pub sdkVersion: libc::int32_t,
-    pub instance: *mut libc::c_void,
-    pub assetManager: *mut AAssetManager,
-    pub obbPath: *const libc::c_char,
-}
-
-#[repr(C)]
-pub struct ANativeActivityCallbacks {
-    pub onStart: extern "C" fn(*mut ANativeActivity),
-    pub onResume: extern "C" fn(*mut ANativeActivity),
-    pub onSaveInstanceState: extern "C" fn(*mut ANativeActivity, *mut libc::size_t),
-    pub onPause: extern "C" fn(*mut ANativeActivity),
-    pub onStop: extern "C" fn(*mut ANativeActivity),
-    pub onDestroy: extern "C" fn(*mut ANativeActivity),
-    pub onWindowFocusChanged: extern "C" fn(*mut ANativeActivity, libc::c_int),
-    pub onNativeWindowCreated: extern "C" fn(*mut ANativeActivity, *const ANativeWindow),
-    pub onNativeWindowResized: extern "C" fn(*mut ANativeActivity, *const ANativeWindow),
-    pub onNativeWindowRedrawNeeded: extern "C" fn(*mut ANativeActivity, *const ANativeWindow),
-    pub onNativeWindowDestroyed: extern "C" fn(*mut ANativeActivity, *const ANativeWindow),
-    pub onInputQueueCreated: extern "C" fn(*mut ANativeActivity, *mut AInputQueue),
-    pub onInputQueueDestroyed: extern "C" fn(*mut ANativeActivity, *mut AInputQueue),
-    pub onContentRectChanged: extern "C" fn(*mut ANativeActivity, *const ARect),
-    pub onConfigurationChanged: extern "C" fn(*mut ANativeActivity),
-    pub onLowMemory: extern "C" fn(*mut ANativeActivity),
-}
-
-/**
- ** looper.h
- **/
-pub type ALooper = ();
-
-#[link(name = "android")]
-extern "C" {
-    pub fn ALooper_forThread() -> *const ALooper;
-    pub fn ALooper_acquire(looper: *const ALooper);
-    pub fn ALooper_release(looper: *const ALooper);
-    pub fn ALooper_prepare(opts: libc::c_int) -> *const ALooper;
-    pub fn ALooper_pollOnce(
-        timeoutMillis: libc::c_int,
-        outFd: *mut libc::c_int,
-        outEvents: *mut libc::c_int,
-        outData: *mut *mut libc::c_void,
-    ) -> libc::c_int;
-    pub fn ALooper_pollAll(
-        timeoutMillis: libc::c_int,
-        outFd: *mut libc::c_int,
-        outEvents: *mut libc::c_int,
-        outData: *mut *mut libc::c_void,
-    ) -> libc::c_int;
-    pub fn ALooper_wake(looper: *const ALooper);
-    pub fn ALooper_addFd(
-        looper: *const ALooper,
-        fd: libc::c_int,
-        ident: libc::c_int,
-        events: libc::c_int,
-        callback: ALooper_callbackFunc,
-        data: *mut libc::c_void,
-    ) -> libc::c_int;
-    pub fn ALooper_removeFd(looper: *const ALooper, fd: libc::c_int) -> libc::c_int;
-}
-
-pub const ALOOPER_PREPARE_ALLOW_NON_CALLBACKS: libc::c_int = 1 << 0;
-
-pub const ALOOPER_POLL_WAKE: libc::c_int = -1;
-pub const ALOOPER_POLL_CALLBACK: libc::c_int = -2;
-pub const ALOOPER_POLL_TIMEOUT: libc::c_int = -3;
-pub const ALOOPER_POLL_ERROR: libc::c_int = -4;
-
-pub const ALOOPER_EVENT_INPUT: libc::c_int = 1 << 0;
-pub const ALOOPER_EVENT_OUTPUT: libc::c_int = 1 << 1;
-pub const ALOOPER_EVENT_ERROR: libc::c_int = 1 << 2;
-pub const ALOOPER_EVENT_HANGUP: libc::c_int = 1 << 3;
-pub const ALOOPER_EVENT_INVALID: libc::c_int = 1 << 4;
-
-pub type ALooper_callbackFunc =
-    extern "C" fn(libc::c_int, libc::c_int, *mut libc::c_void) -> libc::c_int;

src/platform_impl/ios/app_state.rs

@@ -9,19 +9,27 @@ use std::{
     time::Instant,
 };
 
-use objc::runtime::{BOOL, YES};
+use core_foundation::base::CFRelease;
+use core_foundation::date::CFAbsoluteTimeGetCurrent;
+use core_foundation::runloop::{
+    kCFRunLoopCommonModes, CFRunLoopAddTimer, CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate,
+    CFRunLoopTimerInvalidate, CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate,
+};
+use objc2::foundation::{CGRect, CGSize, NSInteger, NSProcessInfo};
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Object;
+use objc2::{msg_send, sel};
+use once_cell::sync::Lazy;
 
+use super::uikit::UIView;
+use super::view::WinitUIWindow;
 use crate::{
+    dpi::LogicalSize,
     event::{Event, StartCause, WindowEvent},
     event_loop::ControlFlow,
     platform_impl::platform::{
-        event_loop::{EventHandler, Never},
-        ffi::{
-            id, kCFRunLoopCommonModes, CFAbsoluteTimeGetCurrent, CFRelease, CFRunLoopAddTimer,
-            CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate, CFRunLoopTimerInvalidate,
-            CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate, NSInteger, NSOperatingSystemVersion,
-            NSUInteger,
-        },
+        event_loop::{EventHandler, EventProxy, EventWrapper, Never},
+        ffi::NSOperatingSystemVersion,
     },
     window::WindowId as RootWindowId,
 };
@@ -45,21 +53,13 @@ enum UserCallbackTransitionResult<'a> {
         processing_redraws: bool,
     },
     ReentrancyPrevented {
-        queued_events: &'a mut Vec<Event<Never>>,
+        queued_events: &'a mut Vec<EventWrapper>,
     },
 }
 
-impl Event<Never> {
+impl Event<'static, Never> {
     fn is_redraw(&self) -> bool {
-        if let Event::WindowEvent {
-            window_id: _,
-            event: WindowEvent::RedrawRequested,
-        } = self
-        {
-            true
-        } else {
-            false
-        }
+        matches!(self, Event::RedrawRequested(_))
     }
 }
 
@@ -68,25 +68,25 @@ impl Event<Never> {
 #[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"]
 enum AppStateImpl {
     NotLaunched {
-        queued_windows: Vec<id>,
-        queued_events: Vec<Event<Never>>,
-        queued_gpu_redraws: HashSet<id>,
+        queued_windows: Vec<Id<WinitUIWindow, Shared>>,
+        queued_events: Vec<EventWrapper>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
     },
     Launching {
-        queued_windows: Vec<id>,
-        queued_events: Vec<Event<Never>>,
+        queued_windows: Vec<Id<WinitUIWindow, Shared>>,
+        queued_events: Vec<EventWrapper>,
         queued_event_handler: Box<dyn EventHandler>,
-        queued_gpu_redraws: HashSet<id>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
     },
     ProcessingEvents {
         event_handler: Box<dyn EventHandler>,
-        queued_gpu_redraws: HashSet<id>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
         active_control_flow: ControlFlow,
     },
     // special state to deal with reentrancy and prevent mutable aliasing.
     InUserCallback {
-        queued_events: Vec<Event<Never>>,
-        queued_gpu_redraws: HashSet<id>,
+        queued_events: Vec<EventWrapper>,
+        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
     },
     ProcessingRedraws {
         event_handler: Box<dyn EventHandler>,
@@ -109,28 +109,6 @@ struct AppState {
     waker: EventLoopWaker,
 }
 
-impl Drop for AppState {
-    fn drop(&mut self) {
-        match self.state_mut() {
-            &mut AppStateImpl::NotLaunched {
-                ref mut queued_windows,
-                ..
-            }
-            | &mut AppStateImpl::Launching {
-                ref mut queued_windows,
-                ..
-            } => {
-                for &mut window in queued_windows {
-                    unsafe {
-                        let () = msg_send![window, release];
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-}
-
 impl AppState {
     // requires main thread
     unsafe fn get_mut() -> RefMut<'static, AppState> {
@@ -203,10 +181,10 @@ impl AppState {
     }
 
     fn has_launched(&self) -> bool {
-        match self.state() {
-            &AppStateImpl::NotLaunched { .. } | &AppStateImpl::Launching { .. } => false,
-            _ => true,
-        }
+        !matches!(
+            self.state(),
+            AppStateImpl::NotLaunched { .. } | AppStateImpl::Launching { .. }
+        )
     }
 
     fn will_launch_transition(&mut self, queued_event_handler: Box<dyn EventHandler>) {
@@ -226,7 +204,9 @@ impl AppState {
         });
     }
 
-    fn did_finish_launching_transition(&mut self) -> (Vec<id>, Vec<Event<Never>>) {
+    fn did_finish_launching_transition(
+        &mut self,
+    ) -> (Vec<Id<WinitUIWindow, Shared>>, Vec<EventWrapper>) {
         let (windows, events, event_handler, queued_gpu_redraws) = match self.take_state() {
             AppStateImpl::Launching {
                 queued_windows,
@@ -249,7 +229,7 @@ impl AppState {
         (windows, events)
     }
 
-    fn wakeup_transition(&mut self) -> Option<Event<Never>> {
+    fn wakeup_transition(&mut self) -> Option<EventWrapper> {
         // before `AppState::did_finish_launching` is called, pretend there is no running
         // event loop.
         if !self.has_launched() {
@@ -262,7 +242,10 @@ impl AppState {
                 AppStateImpl::PollFinished {
                     waiting_event_handler,
                 },
-            ) => (waiting_event_handler, Event::NewEvents(StartCause::Poll)),
+            ) => (
+                waiting_event_handler,
+                EventWrapper::StaticEvent(Event::NewEvents(StartCause::Poll)),
+            ),
             (
                 ControlFlow::Wait,
                 AppStateImpl::Waiting {
@@ -271,10 +254,10 @@ impl AppState {
                 },
             ) => (
                 waiting_event_handler,
-                Event::NewEvents(StartCause::WaitCancelled {
+                EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled {
                     start,
                     requested_resume: None,
-                }),
+                })),
             ),
             (
                 ControlFlow::WaitUntil(requested_resume),
@@ -284,19 +267,19 @@ impl AppState {
                 },
             ) => {
                 let event = if Instant::now() >= requested_resume {
-                    Event::NewEvents(StartCause::ResumeTimeReached {
+                    EventWrapper::StaticEvent(Event::NewEvents(StartCause::ResumeTimeReached {
                         start,
                         requested_resume,
-                    })
+                    }))
                 } else {
-                    Event::NewEvents(StartCause::WaitCancelled {
+                    EventWrapper::StaticEvent(Event::NewEvents(StartCause::WaitCancelled {
                         start,
                         requested_resume: Some(requested_resume),
-                    })
+                    }))
                 };
                 (waiting_event_handler, event)
             }
-            (ControlFlow::Exit, _) => bug!("unexpected `ControlFlow` `Exit`"),
+            (ControlFlow::ExitWithCode(_), _) => bug!("unexpected `ControlFlow` `Exit`"),
             s => bug!("`EventHandler` unexpectedly woke up {:?}", s),
         };
 
@@ -380,7 +363,7 @@ impl AppState {
         }
     }
 
-    fn main_events_cleared_transition(&mut self) -> HashSet<id> {
+    fn main_events_cleared_transition(&mut self) -> HashSet<Id<WinitUIWindow, Shared>> {
         let (event_handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
             AppStateImpl::ProcessingEvents {
                 event_handler,
@@ -451,7 +434,7 @@ impl AppState {
                 });
                 self.waker.start()
             }
-            (_, ControlFlow::Exit) => {
+            (_, ControlFlow::ExitWithCode(_)) => {
                 // https://developer.apple.com/library/archive/qa/qa1561/_index.html
                 // it is not possible to quit an iOS app gracefully and programatically
                 warn!("`ControlFlow::Exit` ignored on iOS");
@@ -473,20 +456,13 @@ impl AppState {
 
 // requires main thread and window is a UIWindow
 // retains window
-pub unsafe fn set_key_window(window: id) {
-    bug_assert!(
-        {
-            let is_window: BOOL = msg_send![window, isKindOfClass: class!(UIWindow)];
-            is_window == YES
-        },
-        "set_key_window called with an incorrect type"
-    );
+pub(crate) unsafe fn set_key_window(window: &Id<WinitUIWindow, Shared>) {
     let mut this = AppState::get_mut();
     match this.state_mut() {
         &mut AppStateImpl::NotLaunched {
             ref mut queued_windows,
             ..
-        } => return queued_windows.push(msg_send![window, retain]),
+        } => return queued_windows.push(window.clone()),
         &mut AppStateImpl::ProcessingEvents { .. }
         | &mut AppStateImpl::InUserCallback { .. }
         | &mut AppStateImpl::ProcessingRedraws { .. } => {}
@@ -498,19 +474,12 @@ pub unsafe fn set_key_window(window: id) {
         }
     }
     drop(this);
-    msg_send![window, makeKeyAndVisible]
+    window.makeKeyAndVisible();
 }
 
 // requires main thread and window is a UIWindow
 // retains window
-pub unsafe fn queue_gl_or_metal_redraw(window: id) {
-    bug_assert!(
-        {
-            let is_window: BOOL = msg_send![window, isKindOfClass: class!(UIWindow)];
-            is_window == YES
-        },
-        "set_key_window called with an incorrect type"
-    );
+pub(crate) unsafe fn queue_gl_or_metal_redraw(window: Id<WinitUIWindow, Shared>) {
     let mut this = AppState::get_mut();
     match this.state_mut() {
         &mut AppStateImpl::NotLaunched {
@@ -528,7 +497,9 @@ pub unsafe fn queue_gl_or_metal_redraw(window: id) {
         | &mut AppStateImpl::InUserCallback {
             ref mut queued_gpu_redraws,
             ..
-        } => drop(queued_gpu_redraws.insert(window)),
+        } => {
+            let _ = queued_gpu_redraws.insert(window);
+        }
         s @ &mut AppStateImpl::ProcessingRedraws { .. }
         | s @ &mut AppStateImpl::Waiting { .. }
         | s @ &mut AppStateImpl::PollFinished { .. } => bug!("unexpected state {:?}", s),
@@ -536,7 +507,6 @@ pub unsafe fn queue_gl_or_metal_redraw(window: id) {
             panic!("Attempt to create a `Window` after the app has terminated")
         }
     }
-    drop(this);
 }
 
 // requires main thread
@@ -548,7 +518,7 @@ pub unsafe fn will_launch(queued_event_handler: Box<dyn EventHandler>) {
 pub unsafe fn did_finish_launching() {
     let mut this = AppState::get_mut();
     let windows = match this.state_mut() {
-        AppStateImpl::Launching { queued_windows, .. } => mem::replace(queued_windows, Vec::new()),
+        AppStateImpl::Launching { queued_windows, .. } => mem::take(queued_windows),
         s => bug!("unexpected state {:?}", s),
     };
 
@@ -563,46 +533,39 @@ pub unsafe fn did_finish_launching() {
     drop(this);
 
     for window in windows {
-        let count: NSUInteger = msg_send![window, retainCount];
-        // make sure the window is still referenced
-        if count > 1 {
-            // Do a little screen dance here to account for windows being created before
-            // `UIApplicationMain` is called. This fixes visual issues such as being
-            // offcenter and sized incorrectly. Additionally, to fix orientation issues, we
-            // gotta reset the `rootViewController`.
-            //
-            // relevant iOS log:
-            // ```
-            // [ApplicationLifecycle] Windows were created before application initialzation
-            // completed. This may result in incorrect visual appearance.
-            // ```
-            let screen: id = msg_send![window, screen];
-            let _: id = msg_send![screen, retain];
-            let () = msg_send![window, setScreen:0 as id];
-            let () = msg_send![window, setScreen: screen];
-            let () = msg_send![screen, release];
-            let controller: id = msg_send![window, rootViewController];
-            let () = msg_send![window, setRootViewController:ptr::null::<()>()];
-            let () = msg_send![window, setRootViewController: controller];
-            let () = msg_send![window, makeKeyAndVisible];
-        }
-        let () = msg_send![window, release];
+        // Do a little screen dance here to account for windows being created before
+        // `UIApplicationMain` is called. This fixes visual issues such as being
+        // offcenter and sized incorrectly. Additionally, to fix orientation issues, we
+        // gotta reset the `rootViewController`.
+        //
+        // relevant iOS log:
+        // ```
+        // [ApplicationLifecycle] Windows were created before application initialzation
+        // completed. This may result in incorrect visual appearance.
+        // ```
+        let screen = window.screen();
+        let _: () = msg_send![&window, setScreen: ptr::null::<Object>()];
+        window.setScreen(&screen);
+
+        let controller = window.rootViewController();
+        window.setRootViewController(None);
+        window.setRootViewController(controller.as_deref());
+
+        window.makeKeyAndVisible();
     }
 
     let (windows, events) = AppState::get_mut().did_finish_launching_transition();
 
-    let events = std::iter::once(Event::NewEvents(StartCause::Init)).chain(events);
+    let events = std::iter::once(EventWrapper::StaticEvent(Event::NewEvents(
+        StartCause::Init,
+    )))
+    .chain(events);
     handle_nonuser_events(events);
 
     // the above window dance hack, could possibly trigger new windows to be created.
     // we can just set those windows up normally, as they were created after didFinishLaunching
     for window in windows {
-        let count: NSUInteger = msg_send![window, retainCount];
-        // make sure the window is still referenced
-        if count > 1 {
-            let () = msg_send![window, makeKeyAndVisible];
-        }
-        let () = msg_send![window, release];
+        window.makeKeyAndVisible();
     }
 }
 
@@ -620,12 +583,12 @@ pub unsafe fn handle_wakeup_transition() {
 }
 
 // requires main thread
-pub unsafe fn handle_nonuser_event(event: Event<Never>) {
+pub(crate) unsafe fn handle_nonuser_event(event: EventWrapper) {
     handle_nonuser_events(std::iter::once(event))
 }
 
 // requires main thread
-pub unsafe fn handle_nonuser_events<I: IntoIterator<Item = Event<Never>>>(events: I) {
+pub(crate) unsafe fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(events: I) {
     let mut this = AppState::get_mut();
     let (mut event_handler, active_control_flow, processing_redraws) =
         match this.try_user_callback_transition() {
@@ -642,16 +605,23 @@ pub unsafe fn handle_nonuser_events<I: IntoIterator<Item = Event<Never>>>(events
     let mut control_flow = this.control_flow;
     drop(this);
 
-    for event in events {
-        if !processing_redraws && event.is_redraw() {
-            log::info!("processing `RedrawRequested` during the main event loop");
-        } else if processing_redraws && !event.is_redraw() {
-            log::warn!(
-                "processing non `RedrawRequested` event after the main event loop: {:#?}",
-                event
-            );
+    for wrapper in events {
+        match wrapper {
+            EventWrapper::StaticEvent(event) => {
+                if !processing_redraws && event.is_redraw() {
+                    log::info!("processing `RedrawRequested` during the main event loop");
+                } else if processing_redraws && !event.is_redraw() {
+                    log::warn!(
+                        "processing non `RedrawRequested` event after the main event loop: {:#?}",
+                        event
+                    );
+                }
+                event_handler.handle_nonuser_event(event, &mut control_flow)
+            }
+            EventWrapper::EventProxy(proxy) => {
+                handle_event_proxy(&mut event_handler, control_flow, proxy)
+            }
         }
-        event_handler.handle_nonuser_event(event, &mut control_flow)
     }
 
     loop {
@@ -660,7 +630,7 @@ pub unsafe fn handle_nonuser_events<I: IntoIterator<Item = Event<Never>>>(events
             &mut AppStateImpl::InUserCallback {
                 ref mut queued_events,
                 queued_gpu_redraws: _,
-            } => mem::replace(queued_events, Vec::new()),
+            } => mem::take(queued_events),
             s => bug!("unexpected state {:?}", s),
         };
         if queued_events.is_empty() {
@@ -692,16 +662,23 @@ pub unsafe fn handle_nonuser_events<I: IntoIterator<Item = Event<Never>>>(events
         }
         drop(this);
 
-        for event in queued_events {
-            if !processing_redraws && event.is_redraw() {
-                log::info!("processing `RedrawRequested` during the main event loop");
-            } else if processing_redraws && !event.is_redraw() {
-                log::warn!(
-                    "processing non-`RedrawRequested` event after the main event loop: {:#?}",
-                    event
-                );
+        for wrapper in queued_events {
+            match wrapper {
+                EventWrapper::StaticEvent(event) => {
+                    if !processing_redraws && event.is_redraw() {
+                        log::info!("processing `RedrawRequested` during the main event loop");
+                    } else if processing_redraws && !event.is_redraw() {
+                        log::warn!(
+                            "processing non-`RedrawRequested` event after the main event loop: {:#?}",
+                            event
+                        );
+                    }
+                    event_handler.handle_nonuser_event(event, &mut control_flow)
+                }
+                EventWrapper::EventProxy(proxy) => {
+                    handle_event_proxy(&mut event_handler, control_flow, proxy)
+                }
             }
-            event_handler.handle_nonuser_event(event, &mut control_flow)
         }
     }
 }
@@ -734,7 +711,7 @@ unsafe fn handle_user_events() {
             &mut AppStateImpl::InUserCallback {
                 ref mut queued_events,
                 queued_gpu_redraws: _,
-            } => mem::replace(queued_events, Vec::new()),
+            } => mem::take(queued_events),
             s => bug!("unexpected state {:?}", s),
         };
         if queued_events.is_empty() {
@@ -755,8 +732,15 @@ unsafe fn handle_user_events() {
         }
         drop(this);
 
-        for event in queued_events {
-            event_handler.handle_nonuser_event(event, &mut control_flow)
+        for wrapper in queued_events {
+            match wrapper {
+                EventWrapper::StaticEvent(event) => {
+                    event_handler.handle_nonuser_event(event, &mut control_flow)
+                }
+                EventWrapper::EventProxy(proxy) => {
+                    handle_event_proxy(&mut event_handler, control_flow, proxy)
+                }
+            }
         }
         event_handler.handle_user_events(&mut control_flow);
     }
@@ -769,23 +753,23 @@ pub unsafe fn handle_main_events_cleared() {
         return;
     }
     match this.state_mut() {
-        &mut AppStateImpl::ProcessingEvents { .. } => {}
+        AppStateImpl::ProcessingEvents { .. } => {}
         _ => bug!("`ProcessingRedraws` happened unexpectedly"),
     };
     drop(this);
 
     // User events are always sent out at the end of the "MainEventLoop"
     handle_user_events();
-    handle_nonuser_event(Event::EventsCleared);
+    handle_nonuser_event(EventWrapper::StaticEvent(Event::MainEventsCleared));
 
     let mut this = AppState::get_mut();
-    let redraw_events = this
+    let mut redraw_events: Vec<EventWrapper> = this
         .main_events_cleared_transition()
         .into_iter()
-        .map(|window| Event::WindowEvent {
-            window_id: RootWindowId(window.into()),
-            event: WindowEvent::RedrawRequested,
-        });
+        .map(|window| EventWrapper::StaticEvent(Event::RedrawRequested(RootWindowId(window.id()))))
+        .collect();
+
+    redraw_events.push(EventWrapper::StaticEvent(Event::RedrawEventsCleared));
     drop(this);
 
     handle_nonuser_events(redraw_events);
@@ -806,6 +790,61 @@ pub unsafe fn terminated() {
     event_handler.handle_nonuser_event(Event::LoopDestroyed, &mut control_flow)
 }
 
+fn handle_event_proxy(
+    event_handler: &mut Box<dyn EventHandler>,
+    control_flow: ControlFlow,
+    proxy: EventProxy,
+) {
+    match proxy {
+        EventProxy::DpiChangedProxy {
+            suggested_size,
+            scale_factor,
+            window,
+        } => handle_hidpi_proxy(
+            event_handler,
+            control_flow,
+            suggested_size,
+            scale_factor,
+            window,
+        ),
+    }
+}
+
+fn handle_hidpi_proxy(
+    event_handler: &mut Box<dyn EventHandler>,
+    mut control_flow: ControlFlow,
+    suggested_size: LogicalSize<f64>,
+    scale_factor: f64,
+    window: Id<WinitUIWindow, Shared>,
+) {
+    let mut size = suggested_size.to_physical(scale_factor);
+    let new_inner_size = &mut size;
+    let event = Event::WindowEvent {
+        window_id: RootWindowId(window.id()),
+        event: WindowEvent::ScaleFactorChanged {
+            scale_factor,
+            new_inner_size,
+        },
+    };
+    event_handler.handle_nonuser_event(event, &mut control_flow);
+    let (view, screen_frame) = get_view_and_screen_frame(&window);
+    let physical_size = *new_inner_size;
+    let logical_size = physical_size.to_logical(scale_factor);
+    let size = CGSize::new(logical_size.width, logical_size.height);
+    let new_frame: CGRect = CGRect::new(screen_frame.origin, size);
+    view.setFrame(new_frame);
+}
+
+fn get_view_and_screen_frame(window: &WinitUIWindow) -> (Id<UIView, Shared>, CGRect) {
+    let view_controller = window.rootViewController().unwrap();
+    let view = view_controller.view().unwrap();
+    let bounds = window.bounds();
+    let screen = window.screen();
+    let screen_space = screen.coordinateSpace();
+    let screen_frame = window.convertRect_toCoordinateSpace(bounds, &screen_space);
+    (view, screen_frame)
+}
+
 struct EventLoopWaker {
     timer: CFRunLoopTimerRef,
 }
@@ -904,20 +943,20 @@ macro_rules! os_capabilities {
 }
 
 os_capabilities! {
-    /// https://developer.apple.com/documentation/uikit/uiview/2891103-safeareainsets?language=objc
+    /// <https://developer.apple.com/documentation/uikit/uiview/2891103-safeareainsets?language=objc>
     #[allow(unused)] // error message unused
     safe_area_err_msg: "-[UIView safeAreaInsets]",
     safe_area: 11-0,
-    /// https://developer.apple.com/documentation/uikit/uiviewcontroller/2887509-setneedsupdateofhomeindicatoraut?language=objc
+    /// <https://developer.apple.com/documentation/uikit/uiviewcontroller/2887509-setneedsupdateofhomeindicatoraut?language=objc>
     home_indicator_hidden_err_msg: "-[UIViewController setNeedsUpdateOfHomeIndicatorAutoHidden]",
     home_indicator_hidden: 11-0,
-    /// https://developer.apple.com/documentation/uikit/uiviewcontroller/2887507-setneedsupdateofscreenedgesdefer?language=objc
+    /// <https://developer.apple.com/documentation/uikit/uiviewcontroller/2887507-setneedsupdateofscreenedgesdefer?language=objc>
     defer_system_gestures_err_msg: "-[UIViewController setNeedsUpdateOfScreenEdgesDeferringSystem]",
     defer_system_gestures: 11-0,
-    /// https://developer.apple.com/documentation/uikit/uiscreen/2806814-maximumframespersecond?language=objc
+    /// <https://developer.apple.com/documentation/uikit/uiscreen/2806814-maximumframespersecond?language=objc>
     maximum_frames_per_second_err_msg: "-[UIScreen maximumFramesPerSecond]",
     maximum_frames_per_second: 10-3,
-    /// https://developer.apple.com/documentation/uikit/uitouch/1618110-force?language=objc
+    /// <https://developer.apple.com/documentation/uikit/uitouch/1618110-force?language=objc>
     #[allow(unused)] // error message unused
     force_touch_err_msg: "-[UITouch force]",
     force_touch: 9-0,
@@ -930,29 +969,24 @@ impl NSOperatingSystemVersion {
 }
 
 pub fn os_capabilities() -> OSCapabilities {
-    lazy_static! {
-        static ref OS_CAPABILITIES: OSCapabilities = {
-            let version: NSOperatingSystemVersion = unsafe {
-                let process_info: id = msg_send![class!(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 == YES,
-                    "`winit` requires iOS version 8 or greater"
-                );
-                msg_send![process_info, operatingSystemVersion]
-            };
-            version.into()
+    static OS_CAPABILITIES: Lazy<OSCapabilities> = Lazy::new(|| {
+        let version: NSOperatingSystemVersion = unsafe {
+            let process_info = NSProcessInfo::process_info();
+            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");
+            msg_send![&process_info, operatingSystemVersion]
         };
-    }
+        version.into()
+    });
     OS_CAPABILITIES.clone()
 }

src/platform_impl/ios/event_loop.rs

@@ -3,11 +3,27 @@ use std::{
     ffi::c_void,
     fmt::{self, Debug},
     marker::PhantomData,
-    mem, ptr,
+    ptr,
     sync::mpsc::{self, Receiver, Sender},
 };
 
+use core_foundation::base::{CFIndex, CFRelease};
+use core_foundation::runloop::{
+    kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes, kCFRunLoopDefaultMode,
+    kCFRunLoopExit, CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
+    CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext, CFRunLoopSourceCreate,
+    CFRunLoopSourceInvalidate, CFRunLoopSourceRef, CFRunLoopSourceSignal, CFRunLoopWakeUp,
+};
+use objc2::foundation::{MainThreadMarker, NSString};
+use objc2::rc::{Id, Shared};
+use objc2::ClassType;
+use raw_window_handle::{RawDisplayHandle, UiKitDisplayHandle};
+
+use super::uikit::{UIApplication, UIApplicationMain, UIDevice, UIScreen};
+use super::view::WinitUIWindow;
+use super::{app_state, monitor, view, MonitorHandle};
 use crate::{
+    dpi::LogicalSize,
     event::Event,
     event_loop::{
         ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootEventLoopWindowTarget,
@@ -15,40 +31,61 @@ use crate::{
     platform::ios::Idiom,
 };
 
-use crate::platform_impl::platform::{
-    app_state,
-    ffi::{
-        id, kCFRunLoopAfterWaiting, kCFRunLoopBeforeWaiting, kCFRunLoopCommonModes,
-        kCFRunLoopDefaultMode, kCFRunLoopEntry, kCFRunLoopExit, nil, CFIndex, CFRelease,
-        CFRunLoopActivity, CFRunLoopAddObserver, CFRunLoopAddSource, CFRunLoopGetMain,
-        CFRunLoopObserverCreate, CFRunLoopObserverRef, CFRunLoopSourceContext,
-        CFRunLoopSourceCreate, CFRunLoopSourceInvalidate, CFRunLoopSourceRef,
-        CFRunLoopSourceSignal, CFRunLoopWakeUp, NSString, UIApplicationMain, UIUserInterfaceIdiom,
+#[derive(Debug)]
+pub(crate) enum EventWrapper {
+    StaticEvent(Event<'static, Never>),
+    EventProxy(EventProxy),
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) enum EventProxy {
+    DpiChangedProxy {
+        window: Id<WinitUIWindow, Shared>,
+        suggested_size: LogicalSize<f64>,
+        scale_factor: f64,
     },
-    monitor, view, MonitorHandle,
-};
+}
 
 pub struct EventLoopWindowTarget<T: 'static> {
     receiver: Receiver<T>,
     sender_to_clone: Sender<T>,
 }
 
+impl<T: 'static> EventLoopWindowTarget<T> {
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        monitor::uiscreens(MainThreadMarker::new().unwrap())
+    }
+
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        Some(MonitorHandle::new(UIScreen::main(
+            MainThreadMarker::new().unwrap(),
+        )))
+    }
+
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        RawDisplayHandle::UiKit(UiKitDisplayHandle::empty())
+    }
+}
+
 pub struct EventLoop<T: 'static> {
     window_target: RootEventLoopWindowTarget<T>,
 }
 
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub(crate) struct PlatformSpecificEventLoopAttributes {}
+
 impl<T: 'static> EventLoop<T> {
-    pub fn new() -> EventLoop<T> {
+    pub(crate) fn new(_: &PlatformSpecificEventLoopAttributes) -> EventLoop<T> {
+        assert_main_thread!("`EventLoop` can only be created on the main thread on iOS");
+
         static mut SINGLETON_INIT: bool = false;
         unsafe {
-            assert_main_thread!("`EventLoop` can only be created on the main thread on iOS");
             assert!(
                 !SINGLETON_INIT,
                 "Only one `EventLoop` is supported on iOS. \
                  `EventLoopProxy` might be helpful"
             );
             SINGLETON_INIT = true;
-            view::create_delegate_class();
         }
 
         let (sender_to_clone, receiver) = mpsc::channel();
@@ -69,27 +106,29 @@ impl<T: 'static> EventLoop<T> {
 
     pub fn run<F>(self, event_handler: F) -> !
     where
-        F: 'static + FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+        F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     {
         unsafe {
-            let application: *mut c_void = msg_send![class!(UIApplication), sharedApplication];
-            assert_eq!(
-                application,
-                ptr::null_mut(),
+            let application = UIApplication::shared(MainThreadMarker::new().unwrap());
+            assert!(
+                application.is_none(),
                 "\
-                 `EventLoop` cannot be `run` after a call to `UIApplicationMain` on iOS\n\
-                 Note: `EventLoop::run` calls `UIApplicationMain` on iOS"
+                `EventLoop` cannot be `run` after a call to `UIApplicationMain` on iOS\n\
+                 Note: `EventLoop::run` calls `UIApplicationMain` on iOS",
             );
             app_state::will_launch(Box::new(EventLoopHandler {
                 f: event_handler,
                 event_loop: self.window_target,
             }));
 
+            // Ensure application delegate is initialized
+            view::WinitApplicationDelegate::class();
+
             UIApplicationMain(
                 0,
                 ptr::null(),
-                nil,
-                NSString::alloc(nil).init_str("AppDelegate"),
+                None,
+                Some(&NSString::from_str("WinitApplicationDelegate")),
             );
             unreachable!()
         }
@@ -99,16 +138,6 @@ impl<T: 'static> EventLoop<T> {
         EventLoopProxy::new(self.window_target.p.sender_to_clone.clone())
     }
 
-    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        // guaranteed to be on main thread
-        unsafe { monitor::uiscreens() }
-    }
-
-    pub fn primary_monitor(&self) -> MonitorHandle {
-        // guaranteed to be on main thread
-        unsafe { monitor::main_uiscreen() }
-    }
-
     pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
         &self.window_target
     }
@@ -117,8 +146,9 @@ impl<T: 'static> EventLoop<T> {
 // EventLoopExtIOS
 impl<T: 'static> EventLoop<T> {
     pub fn idiom(&self) -> Idiom {
-        // guaranteed to be on main thread
-        unsafe { self::get_idiom() }
+        UIDevice::current(MainThreadMarker::new().unwrap())
+            .userInterfaceIdiom()
+            .into()
     }
 }
 
@@ -148,14 +178,23 @@ impl<T> EventLoopProxy<T> {
     fn new(sender: Sender<T>) -> EventLoopProxy<T> {
         unsafe {
             // just wake up the eventloop
-            extern "C" fn event_loop_proxy_handler(_: *mut c_void) {}
+            extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
 
             // adding a Source to the main CFRunLoop lets us wake it up and
             // process user events through the normal OS EventLoop mechanisms.
             let rl = CFRunLoopGetMain();
-            // we want all the members of context to be zero/null, except one
-            let mut context: CFRunLoopSourceContext = mem::zeroed();
-            context.perform = Some(event_loop_proxy_handler);
+            let mut context = CFRunLoopSourceContext {
+                version: 0,
+                info: ptr::null_mut(),
+                retain: None,
+                release: None,
+                copyDescription: None,
+                equal: None,
+                hash: None,
+                schedule: None,
+                cancel: None,
+                perform: event_loop_proxy_handler,
+            };
             let source =
                 CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
             CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
@@ -165,8 +204,10 @@ impl<T> EventLoopProxy<T> {
         }
     }
 
-    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed> {
-        self.sender.send(event).map_err(|_| EventLoopClosed)?;
+    pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
+        self.sender
+            .send(event)
+            .map_err(|::std::sync::mpsc::SendError(x)| EventLoopClosed(x))?;
         unsafe {
             // let the main thread know there's a new event
             CFRunLoopSourceSignal(self.source);
@@ -189,7 +230,6 @@ fn setup_control_flow_observers() {
                 #[allow(non_upper_case_globals)]
                 match activity {
                     kCFRunLoopAfterWaiting => app_state::handle_wakeup_transition(),
-                    kCFRunLoopEntry => unimplemented!(), // not expected to ever happen
                     _ => unreachable!(),
                 }
             }
@@ -197,10 +237,10 @@ fn setup_control_flow_observers() {
 
         // Core Animation registers its `CFRunLoopObserver` that performs drawing operations in
         // `CA::Transaction::ensure_implicit` with a priority of `0x1e8480`. We set the main_end
-        // priority to be 0, in order to send EventsCleared before RedrawRequested. This value was
+        // priority to be 0, in order to send MainEventsCleared before RedrawRequested. This value was
         // chosen conservatively to guard against apple using different priorities for their redraw
         // observers in different OS's or on different devices. If it so happens that it's too
-        // conservative, the main symptom would be non-redraw events coming in after `EventsCleared`.
+        // conservative, the main symptom would be non-redraw events coming in after `MainEventsCleared`.
         //
         // The value of `0x1e8480` was determined by inspecting stack traces and the associated
         // registers for every `CFRunLoopAddObserver` call on an iPad Air 2 running iOS 11.4.
@@ -241,7 +281,7 @@ fn setup_control_flow_observers() {
 
         let begin_observer = CFRunLoopObserverCreate(
             ptr::null_mut(),
-            kCFRunLoopEntry | kCFRunLoopAfterWaiting,
+            kCFRunLoopAfterWaiting,
             1, // repeat = true
             CFIndex::min_value(),
             control_flow_begin_handler,
@@ -275,7 +315,7 @@ fn setup_control_flow_observers() {
 pub enum Never {}
 
 pub trait EventHandler: Debug {
-    fn handle_nonuser_event(&mut self, event: Event<Never>, control_flow: &mut ControlFlow);
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow);
     fn handle_user_events(&mut self, control_flow: &mut ControlFlow);
 }
 
@@ -294,10 +334,10 @@ impl<F, T: 'static> Debug for EventLoopHandler<F, T> {
 
 impl<F, T> EventHandler for EventLoopHandler<F, T>
 where
-    F: 'static + FnMut(Event<T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+    F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     T: 'static,
 {
-    fn handle_nonuser_event(&mut self, event: Event<Never>, control_flow: &mut ControlFlow) {
+    fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
         (self.f)(
             event.map_nonuser_event().unwrap(),
             &self.event_loop,
@@ -311,10 +351,3 @@ where
         }
     }
 }
-
-// must be called on main thread
-pub unsafe fn get_idiom() -> Idiom {
-    let device: id = msg_send![class!(UIDevice), currentDevice];
-    let raw_idiom: UIUserInterfaceIdiom = msg_send![device, userInterfaceIdiom];
-    raw_idiom.into()
-}

src/platform_impl/ios/ffi.rs

@@ -1,21 +1,11 @@
 #![allow(non_camel_case_types, non_snake_case, non_upper_case_globals)]
 
-use std::{convert::TryInto, ffi::CString, ops::BitOr, os::raw::*};
+use std::convert::TryInto;
 
-use objc::{runtime::Object, Encode, Encoding};
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{NSInteger, NSUInteger};
 
-use crate::platform::ios::{Idiom, ScreenEdge, ValidOrientations};
-
-pub type id = *mut Object;
-pub const nil: id = 0 as id;
-
-#[cfg(target_pointer_width = "32")]
-pub type CGFloat = f32;
-#[cfg(target_pointer_width = "64")]
-pub type CGFloat = f64;
-
-pub type NSInteger = isize;
-pub type NSUInteger = usize;
+use crate::platform::ios::{Idiom, ScreenEdge};
 
 #[repr(C)]
 #[derive(Clone, Debug)]
@@ -25,76 +15,15 @@ pub struct NSOperatingSystemVersion {
     pub patch: NSInteger,
 }
 
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct CGPoint {
-    pub x: CGFloat,
-    pub y: CGFloat,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct CGSize {
-    pub width: CGFloat,
-    pub height: CGFloat,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct CGRect {
-    pub origin: CGPoint,
-    pub size: CGSize,
-}
-
-unsafe impl Encode for CGRect {
-    fn encode() -> Encoding {
-        unsafe {
-            if cfg!(target_pointer_width = "32") {
-                Encoding::from_str("{CGRect={CGPoint=ff}{CGSize=ff}}")
-            } else if cfg!(target_pointer_width = "64") {
-                Encoding::from_str("{CGRect={CGPoint=dd}{CGSize=dd}}")
-            } else {
-                unimplemented!()
-            }
-        }
-    }
-}
-#[derive(Debug)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UITouchPhase {
-    Began = 0,
-    Moved,
-    Stationary,
-    Ended,
-    Cancelled,
-}
-
-#[derive(Debug, PartialEq)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UIForceTouchCapability {
-    Unknown = 0,
-    Unavailable,
-    Available,
-}
-
-#[derive(Debug, PartialEq)]
-#[allow(dead_code)]
-#[repr(isize)]
-pub enum UITouchType {
-    Direct = 0,
-    Indirect,
-    Pencil,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone)]
-pub struct UIEdgeInsets {
-    pub top: CGFloat,
-    pub left: CGFloat,
-    pub bottom: CGFloat,
-    pub right: CGFloat,
+unsafe impl Encode for NSOperatingSystemVersion {
+    const ENCODING: Encoding = Encoding::Struct(
+        "NSOperatingSystemVersion",
+        &[
+            NSInteger::ENCODING,
+            NSInteger::ENCODING,
+            NSInteger::ENCODING,
+        ],
+    );
 }
 
 #[repr(transparent)]
@@ -102,9 +31,7 @@ pub struct UIEdgeInsets {
 pub struct UIUserInterfaceIdiom(NSInteger);
 
 unsafe impl Encode for UIUserInterfaceIdiom {
-    fn encode() -> Encoding {
-        NSInteger::encode()
-    }
+    const ENCODING: Encoding = NSInteger::ENCODING;
 }
 
 impl UIUserInterfaceIdiom {
@@ -126,10 +53,9 @@ impl From<Idiom> for UIUserInterfaceIdiom {
         }
     }
 }
-
-impl Into<Idiom> for UIUserInterfaceIdiom {
-    fn into(self) -> Idiom {
-        match self {
+impl From<UIUserInterfaceIdiom> for Idiom {
+    fn from(ui_idiom: UIUserInterfaceIdiom) -> Idiom {
+        match ui_idiom {
             UIUserInterfaceIdiom::Unspecified => Idiom::Unspecified,
             UIUserInterfaceIdiom::Phone => Idiom::Phone,
             UIUserInterfaceIdiom::Pad => Idiom::Pad,
@@ -140,65 +66,12 @@ impl Into<Idiom> for UIUserInterfaceIdiom {
     }
 }
 
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug)]
-pub struct UIInterfaceOrientationMask(NSUInteger);
-
-unsafe impl Encode for UIInterfaceOrientationMask {
-    fn encode() -> Encoding {
-        NSUInteger::encode()
-    }
-}
-
-impl UIInterfaceOrientationMask {
-    pub const Portrait: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 1);
-    pub const PortraitUpsideDown: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 2);
-    pub const LandscapeLeft: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 4);
-    pub const LandscapeRight: UIInterfaceOrientationMask = UIInterfaceOrientationMask(1 << 3);
-    pub const Landscape: UIInterfaceOrientationMask =
-        UIInterfaceOrientationMask(Self::LandscapeLeft.0 | Self::LandscapeRight.0);
-    pub const AllButUpsideDown: UIInterfaceOrientationMask =
-        UIInterfaceOrientationMask(Self::Landscape.0 | Self::Portrait.0);
-    pub const All: UIInterfaceOrientationMask =
-        UIInterfaceOrientationMask(Self::AllButUpsideDown.0 | Self::PortraitUpsideDown.0);
-}
-
-impl BitOr for UIInterfaceOrientationMask {
-    type Output = Self;
-
-    fn bitor(self, rhs: Self) -> Self {
-        UIInterfaceOrientationMask(self.0 | rhs.0)
-    }
-}
-
-impl UIInterfaceOrientationMask {
-    pub fn from_valid_orientations_idiom(
-        valid_orientations: ValidOrientations,
-        idiom: Idiom,
-    ) -> UIInterfaceOrientationMask {
-        match (valid_orientations, idiom) {
-            (ValidOrientations::LandscapeAndPortrait, Idiom::Phone) => {
-                UIInterfaceOrientationMask::AllButUpsideDown
-            }
-            (ValidOrientations::LandscapeAndPortrait, _) => UIInterfaceOrientationMask::All,
-            (ValidOrientations::Landscape, _) => UIInterfaceOrientationMask::Landscape,
-            (ValidOrientations::Portrait, Idiom::Phone) => UIInterfaceOrientationMask::Portrait,
-            (ValidOrientations::Portrait, _) => {
-                UIInterfaceOrientationMask::Portrait
-                    | UIInterfaceOrientationMask::PortraitUpsideDown
-            }
-        }
-    }
-}
-
 #[repr(transparent)]
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct UIRectEdge(NSUInteger);
 
 unsafe impl Encode for UIRectEdge {
-    fn encode() -> Encoding {
-        NSUInteger::encode()
-    }
+    const ENCODING: Encoding = NSUInteger::ENCODING;
 }
 
 impl From<ScreenEdge> for UIRectEdge {
@@ -212,161 +85,9 @@ impl From<ScreenEdge> for UIRectEdge {
     }
 }
 
-impl Into<ScreenEdge> for UIRectEdge {
-    fn into(self) -> ScreenEdge {
-        let bits: u8 = self.0.try_into().expect("invalid `UIRectEdge`");
+impl From<UIRectEdge> for ScreenEdge {
+    fn from(ui_rect_edge: UIRectEdge) -> ScreenEdge {
+        let bits: u8 = ui_rect_edge.0.try_into().expect("invalid `UIRectEdge`");
         ScreenEdge::from_bits(bits).expect("invalid `ScreenEdge`")
     }
 }
-
-#[repr(transparent)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct UIScreenOverscanCompensation(NSInteger);
-
-unsafe impl Encode for UIScreenOverscanCompensation {
-    fn encode() -> Encoding {
-        NSInteger::encode()
-    }
-}
-
-#[allow(dead_code)]
-impl UIScreenOverscanCompensation {
-    pub const Scale: UIScreenOverscanCompensation = UIScreenOverscanCompensation(0);
-    pub const InsetBounds: UIScreenOverscanCompensation = UIScreenOverscanCompensation(1);
-    pub const None: UIScreenOverscanCompensation = UIScreenOverscanCompensation(2);
-}
-
-#[link(name = "UIKit", kind = "framework")]
-#[link(name = "CoreFoundation", kind = "framework")]
-extern "C" {
-    pub static kCFRunLoopDefaultMode: CFRunLoopMode;
-    pub static kCFRunLoopCommonModes: CFRunLoopMode;
-
-    pub fn UIApplicationMain(
-        argc: c_int,
-        argv: *const c_char,
-        principalClassName: id,
-        delegateClassName: id,
-    ) -> c_int;
-
-    pub fn CFRunLoopGetMain() -> CFRunLoopRef;
-    pub fn CFRunLoopWakeUp(rl: CFRunLoopRef);
-
-    pub fn CFRunLoopObserverCreate(
-        allocator: CFAllocatorRef,
-        activities: CFOptionFlags,
-        repeats: Boolean,
-        order: CFIndex,
-        callout: CFRunLoopObserverCallBack,
-        context: *mut CFRunLoopObserverContext,
-    ) -> CFRunLoopObserverRef;
-    pub fn CFRunLoopAddObserver(
-        rl: CFRunLoopRef,
-        observer: CFRunLoopObserverRef,
-        mode: CFRunLoopMode,
-    );
-
-    pub fn CFRunLoopTimerCreate(
-        allocator: CFAllocatorRef,
-        fireDate: CFAbsoluteTime,
-        interval: CFTimeInterval,
-        flags: CFOptionFlags,
-        order: CFIndex,
-        callout: CFRunLoopTimerCallBack,
-        context: *mut CFRunLoopTimerContext,
-    ) -> CFRunLoopTimerRef;
-    pub fn CFRunLoopAddTimer(rl: CFRunLoopRef, timer: CFRunLoopTimerRef, mode: CFRunLoopMode);
-    pub fn CFRunLoopTimerSetNextFireDate(timer: CFRunLoopTimerRef, fireDate: CFAbsoluteTime);
-    pub fn CFRunLoopTimerInvalidate(time: CFRunLoopTimerRef);
-
-    pub fn CFRunLoopSourceCreate(
-        allocator: CFAllocatorRef,
-        order: CFIndex,
-        context: *mut CFRunLoopSourceContext,
-    ) -> CFRunLoopSourceRef;
-    pub fn CFRunLoopAddSource(rl: CFRunLoopRef, source: CFRunLoopSourceRef, mode: CFRunLoopMode);
-    pub fn CFRunLoopSourceInvalidate(source: CFRunLoopSourceRef);
-    pub fn CFRunLoopSourceSignal(source: CFRunLoopSourceRef);
-
-    pub fn CFAbsoluteTimeGetCurrent() -> CFAbsoluteTime;
-    pub fn CFRelease(cftype: *const c_void);
-}
-
-pub type Boolean = u8;
-pub enum CFAllocator {}
-pub type CFAllocatorRef = *mut CFAllocator;
-pub enum CFRunLoop {}
-pub type CFRunLoopRef = *mut CFRunLoop;
-pub type CFRunLoopMode = CFStringRef;
-pub enum CFRunLoopObserver {}
-pub type CFRunLoopObserverRef = *mut CFRunLoopObserver;
-pub enum CFRunLoopTimer {}
-pub type CFRunLoopTimerRef = *mut CFRunLoopTimer;
-pub enum CFRunLoopSource {}
-pub type CFRunLoopSourceRef = *mut CFRunLoopSource;
-pub enum CFString {}
-pub type CFStringRef = *const CFString;
-
-pub type CFHashCode = c_ulong;
-pub type CFIndex = c_long;
-pub type CFOptionFlags = c_ulong;
-pub type CFRunLoopActivity = CFOptionFlags;
-
-pub type CFAbsoluteTime = CFTimeInterval;
-pub type CFTimeInterval = f64;
-
-pub const kCFRunLoopEntry: CFRunLoopActivity = 0;
-pub const kCFRunLoopBeforeWaiting: CFRunLoopActivity = 1 << 5;
-pub const kCFRunLoopAfterWaiting: CFRunLoopActivity = 1 << 6;
-pub const kCFRunLoopExit: CFRunLoopActivity = 1 << 7;
-
-pub type CFRunLoopObserverCallBack =
-    extern "C" fn(observer: CFRunLoopObserverRef, activity: CFRunLoopActivity, info: *mut c_void);
-pub type CFRunLoopTimerCallBack = extern "C" fn(timer: CFRunLoopTimerRef, info: *mut c_void);
-
-pub enum CFRunLoopObserverContext {}
-pub enum CFRunLoopTimerContext {}
-
-#[repr(C)]
-pub struct CFRunLoopSourceContext {
-    pub version: CFIndex,
-    pub info: *mut c_void,
-    pub retain: Option<extern "C" fn(*const c_void) -> *const c_void>,
-    pub release: Option<extern "C" fn(*const c_void)>,
-    pub copyDescription: Option<extern "C" fn(*const c_void) -> CFStringRef>,
-    pub equal: Option<extern "C" fn(*const c_void, *const c_void) -> Boolean>,
-    pub hash: Option<extern "C" fn(*const c_void) -> CFHashCode>,
-    pub schedule: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
-    pub cancel: Option<extern "C" fn(*mut c_void, CFRunLoopRef, CFRunLoopMode)>,
-    pub perform: Option<extern "C" fn(*mut c_void)>,
-}
-
-pub trait NSString: Sized {
-    unsafe fn alloc(_: Self) -> id {
-        msg_send![class!(NSString), alloc]
-    }
-
-    unsafe fn initWithUTF8String_(self, c_string: *const c_char) -> id;
-    unsafe fn stringByAppendingString_(self, other: id) -> id;
-    unsafe fn init_str(self, string: &str) -> Self;
-    unsafe fn UTF8String(self) -> *const c_char;
-}
-
-impl NSString for id {
-    unsafe fn initWithUTF8String_(self, c_string: *const c_char) -> id {
-        msg_send![self, initWithUTF8String: c_string as id]
-    }
-
-    unsafe fn stringByAppendingString_(self, other: id) -> id {
-        msg_send![self, stringByAppendingString: other]
-    }
-
-    unsafe fn init_str(self, string: &str) -> id {
-        let cstring = CString::new(string).unwrap();
-        self.initWithUTF8String_(cstring.as_ptr())
-    }
-
-    unsafe fn UTF8String(self) -> *const c_char {
-        msg_send![self, UTF8String]
-    }
-}

src/platform_impl/ios/mod.rs

@@ -55,14 +55,15 @@
 //!
 //! Also note that app may not receive the LoopDestroyed event if suspended; it might be SIGKILL'ed.
 
-#![cfg(target_os = "ios")]
+#![cfg(ios_platform)]
+#![allow(clippy::let_unit_value)]
 
 // TODO: (mtak-) UIKit requires main thread for virtually all function/method calls. This could be
 // worked around in the future by using GCD (grand central dispatch) and/or caching of values like
 // window size/position.
 macro_rules! assert_main_thread {
     ($($t:tt)*) => {
-        if !msg_send![class!(NSThread), isMainThread] {
+        if !::objc2::foundation::is_main_thread() {
             panic!($($t)*);
         }
     };
@@ -72,26 +73,33 @@ mod app_state;
 mod event_loop;
 mod ffi;
 mod monitor;
+mod uikit;
 mod view;
 mod window;
 
 use std::fmt;
 
-pub use self::{
-    event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget},
+pub(crate) use self::{
+    event_loop::{
+        EventLoop, EventLoopProxy, EventLoopWindowTarget, PlatformSpecificEventLoopAttributes,
+    },
     monitor::{MonitorHandle, VideoMode},
     window::{PlatformSpecificWindowBuilderAttributes, Window, WindowId},
 };
 
+use self::uikit::UIScreen;
+pub(crate) use crate::icon::NoIcon as PlatformIcon;
+pub(self) use crate::platform_impl::Fullscreen;
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId {
-    uiscreen: ffi::id,
+    uiscreen: *const UIScreen,
 }
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         DeviceId {
-            uiscreen: std::ptr::null_mut(),
+            uiscreen: std::ptr::null(),
         }
     }
 }
@@ -103,9 +111,7 @@ unsafe impl Sync for DeviceId {}
 pub enum OsError {}
 
 impl fmt::Display for OsError {
-    fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            _ => unreachable!(),
-        }
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "os error")
     }
 }

src/platform_impl/ios/monitor.rs

@@ -1,54 +1,206 @@
+#![allow(clippy::unnecessary_cast)]
+
 use std::{
     collections::{BTreeSet, VecDeque},
     fmt,
     ops::{Deref, DerefMut},
 };
 
+use objc2::foundation::{MainThreadMarker, NSInteger};
+use objc2::rc::{Id, Shared};
+
+use super::uikit::{UIScreen, UIScreenMode};
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize},
-    monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
-    platform_impl::platform::{
-        app_state,
-        ffi::{id, nil, CGFloat, CGRect, CGSize, NSInteger, NSUInteger},
-    },
+    monitor::VideoMode as RootVideoMode,
+    platform_impl::platform::app_state,
 };
 
-#[derive(Debug, PartialEq, Eq, Hash)]
+// TODO(madsmtm): Remove or refactor this
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub(crate) struct ScreenModeSendSync(pub(crate) Id<UIScreenMode, Shared>);
+
+unsafe impl Send for ScreenModeSendSync {}
+unsafe impl Sync for ScreenModeSendSync {}
+
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub struct VideoMode {
     pub(crate) size: (u32, u32),
     pub(crate) bit_depth: u16,
-    pub(crate) refresh_rate: u16,
-    pub(crate) screen_mode: id,
+    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) screen_mode: ScreenModeSendSync,
     pub(crate) monitor: MonitorHandle,
 }
 
-impl Clone for VideoMode {
-    fn clone(&self) -> VideoMode {
-        VideoMode {
-            size: self.size,
-            bit_depth: self.bit_depth,
-            refresh_rate: self.refresh_rate,
-            screen_mode: unsafe { msg_send![self.screen_mode, retain] },
-            monitor: self.monitor.clone(),
-        }
-    }
-}
-
-impl Drop for VideoMode {
-    fn drop(&mut self) {
-        unsafe {
-            assert_main_thread!("`VideoMode` can only be dropped on the main thread on iOS");
-            let () = msg_send![self.screen_mode, release];
-        }
-    }
-}
-
 impl VideoMode {
-    unsafe fn retained_new(uiscreen: id, screen_mode: id) -> VideoMode {
+    fn new(uiscreen: Id<UIScreen, Shared>, screen_mode: Id<UIScreenMode, Shared>) -> VideoMode {
         assert_main_thread!("`VideoMode` can only be created on the main thread on iOS");
+        let refresh_rate_millihertz = refresh_rate_millihertz(&uiscreen);
+        let size = screen_mode.size();
+        VideoMode {
+            size: (size.width as u32, size.height as u32),
+            bit_depth: 32,
+            refresh_rate_millihertz,
+            screen_mode: ScreenModeSendSync(screen_mode),
+            monitor: MonitorHandle::new(uiscreen),
+        }
+    }
+
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.size.into()
+    }
+
+    pub fn bit_depth(&self) -> u16 {
+        self.bit_depth
+    }
+
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.refresh_rate_millihertz
+    }
+
+    pub fn monitor(&self) -> MonitorHandle {
+        self.monitor.clone()
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Inner {
+    uiscreen: Id<UIScreen, Shared>,
+}
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct MonitorHandle {
+    inner: Inner,
+}
+
+impl PartialOrd for MonitorHandle {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MonitorHandle {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        // TODO: Make a better ordering
+        (self as *const Self).cmp(&(other as *const Self))
+    }
+}
+
+impl Deref for MonitorHandle {
+    type Target = Inner;
+
+    fn deref(&self) -> &Inner {
+        assert_main_thread!("`MonitorHandle` methods can only be run on the main thread on iOS");
+        &self.inner
+    }
+}
+
+impl DerefMut for MonitorHandle {
+    fn deref_mut(&mut self) -> &mut Inner {
+        assert_main_thread!("`MonitorHandle` methods can only be run on the main thread on iOS");
+        &mut self.inner
+    }
+}
+
+unsafe impl Send for MonitorHandle {}
+unsafe impl Sync for MonitorHandle {}
+
+impl Drop for MonitorHandle {
+    fn drop(&mut self) {
+        assert_main_thread!("`MonitorHandle` can only be dropped on the main thread on iOS");
+    }
+}
+
+impl fmt::Debug for MonitorHandle {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // TODO: Do this using the proper fmt API
+        #[derive(Debug)]
+        #[allow(dead_code)]
+        struct MonitorHandle {
+            name: Option<String>,
+            size: PhysicalSize<u32>,
+            position: PhysicalPosition<i32>,
+            scale_factor: f64,
+        }
+
+        let monitor_id_proxy = MonitorHandle {
+            name: self.name(),
+            size: self.size(),
+            position: self.position(),
+            scale_factor: self.scale_factor(),
+        };
+
+        monitor_id_proxy.fmt(f)
+    }
+}
+
+impl MonitorHandle {
+    pub(crate) fn new(uiscreen: Id<UIScreen, Shared>) -> Self {
+        assert_main_thread!("`MonitorHandle` can only be created on the main thread on iOS");
+        Self {
+            inner: Inner { uiscreen },
+        }
+    }
+}
+
+impl Inner {
+    pub fn name(&self) -> Option<String> {
+        let main = UIScreen::main(MainThreadMarker::new().unwrap());
+        if self.uiscreen == main {
+            Some("Primary".to_string())
+        } else if self.uiscreen == main.mirroredScreen() {
+            Some("Mirrored".to_string())
+        } else {
+            UIScreen::screens(MainThreadMarker::new().unwrap())
+                .iter()
+                .position(|rhs| rhs == &*self.uiscreen)
+                .map(|idx| idx.to_string())
+        }
+    }
+
+    pub fn size(&self) -> PhysicalSize<u32> {
+        let bounds = self.uiscreen.nativeBounds();
+        PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
+    }
+
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        let bounds = self.uiscreen.nativeBounds();
+        (bounds.origin.x as f64, bounds.origin.y as f64).into()
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        self.uiscreen.nativeScale() as f64
+    }
+
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        Some(refresh_rate_millihertz(&self.uiscreen))
+    }
+
+    pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
+        // Use Ord impl of RootVideoMode
+        let modes: BTreeSet<_> = self
+            .uiscreen
+            .availableModes()
+            .into_iter()
+            .map(|mode| {
+                let mode: *const UIScreenMode = mode;
+                let mode = unsafe { Id::retain(mode as *mut UIScreenMode).unwrap() };
+
+                RootVideoMode {
+                    video_mode: VideoMode::new(self.uiscreen.clone(), mode),
+                }
+            })
+            .collect();
+
+        modes.into_iter().map(|mode| mode.video_mode)
+    }
+}
+
+fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
+    let refresh_rate_millihertz: NSInteger = {
         let os_capabilities = app_state::os_capabilities();
-        let refresh_rate: NSInteger = if os_capabilities.maximum_frames_per_second {
-            msg_send![uiscreen, maximumFramesPerSecond]
+        if os_capabilities.maximum_frames_per_second {
+            uiscreen.maximumFramesPerSecond()
         } else {
             // https://developer.apple.com/library/archive/technotes/tn2460/_index.html
             // https://en.wikipedia.org/wiki/IPad_Pro#Model_comparison
@@ -62,223 +214,33 @@ impl VideoMode {
             // `-[CADisplayLink duration]`.
             os_capabilities.maximum_frames_per_second_err_msg("defaulting to 60 fps");
             60
-        };
-        let size: CGSize = msg_send![screen_mode, size];
-        VideoMode {
-            size: (size.width as u32, size.height as u32),
-            bit_depth: 32,
-            refresh_rate: refresh_rate as u16,
-            screen_mode: msg_send![screen_mode, retain],
-            monitor: MonitorHandle::retained_new(uiscreen),
         }
-    }
+    };
 
-    pub fn size(&self) -> PhysicalSize {
-        self.size.into()
-    }
-
-    pub fn bit_depth(&self) -> u16 {
-        self.bit_depth
-    }
-
-    pub fn refresh_rate(&self) -> u16 {
-        self.refresh_rate
-    }
-
-    pub fn monitor(&self) -> RootMonitorHandle {
-        RootMonitorHandle {
-            inner: self.monitor.clone(),
-        }
-    }
-}
-
-#[derive(PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct Inner {
-    uiscreen: id,
-}
-
-impl Drop for Inner {
-    fn drop(&mut self) {
-        unsafe {
-            let () = msg_send![self.uiscreen, release];
-        }
-    }
-}
-
-#[derive(PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub struct MonitorHandle {
-    inner: Inner,
-}
-
-impl Deref for MonitorHandle {
-    type Target = Inner;
-
-    fn deref(&self) -> &Inner {
-        unsafe {
-            assert_main_thread!(
-                "`MonitorHandle` methods can only be run on the main thread on iOS"
-            );
-        }
-        &self.inner
-    }
-}
-
-impl DerefMut for MonitorHandle {
-    fn deref_mut(&mut self) -> &mut Inner {
-        unsafe {
-            assert_main_thread!(
-                "`MonitorHandle` methods can only be run on the main thread on iOS"
-            );
-        }
-        &mut self.inner
-    }
-}
-
-unsafe impl Send for MonitorHandle {}
-unsafe impl Sync for MonitorHandle {}
-
-impl Clone for MonitorHandle {
-    fn clone(&self) -> MonitorHandle {
-        MonitorHandle::retained_new(self.uiscreen)
-    }
-}
-
-impl Drop for MonitorHandle {
-    fn drop(&mut self) {
-        unsafe {
-            assert_main_thread!("`MonitorHandle` can only be dropped on the main thread on iOS");
-        }
-    }
-}
-
-impl fmt::Debug for MonitorHandle {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        #[derive(Debug)]
-        struct MonitorHandle {
-            name: Option<String>,
-            size: PhysicalSize,
-            position: PhysicalPosition,
-            hidpi_factor: f64,
-        }
-
-        let monitor_id_proxy = MonitorHandle {
-            name: self.name(),
-            size: self.size(),
-            position: self.position(),
-            hidpi_factor: self.hidpi_factor(),
-        };
-
-        monitor_id_proxy.fmt(f)
-    }
-}
-
-impl MonitorHandle {
-    pub fn retained_new(uiscreen: id) -> MonitorHandle {
-        unsafe {
-            assert_main_thread!("`MonitorHandle` can only be cloned on the main thread on iOS");
-            let () = msg_send![uiscreen, retain];
-        }
-        MonitorHandle {
-            inner: Inner { uiscreen },
-        }
-    }
-}
-
-impl Inner {
-    pub fn name(&self) -> Option<String> {
-        unsafe {
-            let main = main_uiscreen();
-            if self.uiscreen == main.uiscreen {
-                Some("Primary".to_string())
-            } else if self.uiscreen == mirrored_uiscreen(&main).uiscreen {
-                Some("Mirrored".to_string())
-            } else {
-                uiscreens()
-                    .iter()
-                    .position(|rhs| rhs.uiscreen == self.uiscreen)
-                    .map(|idx| idx.to_string())
-            }
-        }
-    }
-
-    pub fn size(&self) -> PhysicalSize {
-        unsafe {
-            let bounds: CGRect = msg_send![self.ui_screen(), nativeBounds];
-            (bounds.size.width as f64, bounds.size.height as f64).into()
-        }
-    }
-
-    pub fn position(&self) -> PhysicalPosition {
-        unsafe {
-            let bounds: CGRect = msg_send![self.ui_screen(), nativeBounds];
-            (bounds.origin.x as f64, bounds.origin.y as f64).into()
-        }
-    }
-
-    pub fn hidpi_factor(&self) -> f64 {
-        unsafe {
-            let scale: CGFloat = msg_send![self.ui_screen(), nativeScale];
-            scale as f64
-        }
-    }
-
-    pub fn video_modes(&self) -> impl Iterator<Item = RootVideoMode> {
-        let mut modes = BTreeSet::new();
-        unsafe {
-            let available_modes: id = msg_send![self.uiscreen, availableModes];
-            let available_mode_count: NSUInteger = msg_send![available_modes, count];
-
-            for i in 0..available_mode_count {
-                let mode: id = msg_send![available_modes, objectAtIndex: i];
-                modes.insert(RootVideoMode {
-                    video_mode: VideoMode::retained_new(self.uiscreen, mode),
-                });
-            }
-        }
-
-        modes.into_iter()
-    }
+    refresh_rate_millihertz as u32 * 1000
 }
 
 // MonitorHandleExtIOS
 impl Inner {
-    pub fn ui_screen(&self) -> id {
-        self.uiscreen
+    pub(crate) fn ui_screen(&self) -> &Id<UIScreen, Shared> {
+        &self.uiscreen
     }
 
-    pub fn preferred_video_mode(&self) -> RootVideoMode {
-        unsafe {
-            let mode: id = msg_send![self.uiscreen, preferredMode];
-            RootVideoMode {
-                video_mode: VideoMode::retained_new(self.uiscreen, mode),
-            }
-        }
+    pub fn preferred_video_mode(&self) -> VideoMode {
+        VideoMode::new(
+            self.uiscreen.clone(),
+            self.uiscreen.preferredMode().unwrap(),
+        )
     }
 }
 
-// requires being run on main thread
-pub unsafe fn main_uiscreen() -> MonitorHandle {
-    let uiscreen: id = msg_send![class!(UIScreen), mainScreen];
-    MonitorHandle::retained_new(uiscreen)
-}
-
-// requires being run on main thread
-unsafe fn mirrored_uiscreen(monitor: &MonitorHandle) -> MonitorHandle {
-    let uiscreen: id = msg_send![monitor.uiscreen, mirroredScreen];
-    MonitorHandle::retained_new(uiscreen)
-}
-
-// requires being run on main thread
-pub unsafe fn uiscreens() -> VecDeque<MonitorHandle> {
-    let screens: id = msg_send![class!(UIScreen), screens];
-    let count: NSUInteger = msg_send![screens, count];
-    let mut result = VecDeque::with_capacity(count as _);
-    let screens_enum: id = msg_send![screens, objectEnumerator];
-    loop {
-        let screen: id = msg_send![screens_enum, nextObject];
-        if screen == nil {
-            break result;
-        }
-        result.push_back(MonitorHandle::retained_new(screen));
-    }
+pub fn uiscreens(mtm: MainThreadMarker) -> VecDeque<MonitorHandle> {
+    UIScreen::screens(mtm)
+        .into_iter()
+        .map(|screen| {
+            let screen: *const UIScreen = screen;
+            let screen = unsafe { Id::retain(screen as *mut UIScreen).unwrap() };
+            MonitorHandle::new(screen)
+        })
+        .collect()
 }

src/platform_impl/ios/uikit/application.rs

@@ -0,0 +1,30 @@
+use objc2::foundation::{CGRect, MainThreadMarker, NSArray, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, 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;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIApplication {
+        pub fn shared(_mtm: MainThreadMarker) -> Option<Id<Self, Shared>> {
+            unsafe { msg_send_id![Self::class(), sharedApplication] }
+        }
+
+        pub fn windows(&self) -> Id<NSArray<UIWindow, Shared>, Shared> {
+            unsafe { msg_send_id![self, windows] }
+        }
+
+        #[sel(statusBarFrame)]
+        pub fn statusBarFrame(&self) -> CGRect;
+    }
+);

src/platform_impl/ios/uikit/coordinate_space.rs

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

src/platform_impl/ios/uikit/device.rs

@@ -0,0 +1,25 @@
+use objc2::foundation::{MainThreadMarker, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::super::ffi::UIUserInterfaceIdiom;
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIDevice;
+
+    unsafe impl ClassType for UIDevice {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIDevice {
+        pub fn current(_mtm: MainThreadMarker) -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), currentDevice] }
+        }
+
+        #[sel(userInterfaceIdiom)]
+        pub fn userInterfaceIdiom(&self) -> UIUserInterfaceIdiom;
+    }
+);

src/platform_impl/ios/uikit/event.rs

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

src/platform_impl/ios/uikit/mod.rs

@@ -0,0 +1,44 @@
+#![deny(unsafe_op_in_unsafe_fn)]
+#![allow(non_snake_case)]
+#![allow(non_upper_case_globals)]
+
+use std::os::raw::{c_char, c_int};
+
+use objc2::foundation::NSString;
+
+mod application;
+mod coordinate_space;
+mod device;
+mod event;
+mod responder;
+mod screen;
+mod screen_mode;
+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;
+pub(crate) use self::event::UIEvent;
+pub(crate) use self::responder::UIResponder;
+pub(crate) use self::screen::{UIScreen, UIScreenOverscanCompensation};
+pub(crate) use self::screen_mode::UIScreenMode;
+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

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

src/platform_impl/ios/uikit/screen.rs

@@ -0,0 +1,79 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{CGFloat, CGRect, MainThreadMarker, NSArray, NSInteger, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::{UICoordinateSpace, UIScreenMode};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIScreen;
+
+    unsafe impl ClassType for UIScreen {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIScreen {
+        pub fn main(_mtm: MainThreadMarker) -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), mainScreen] }
+        }
+
+        pub fn screens(_mtm: MainThreadMarker) -> Id<NSArray<Self, Shared>, Shared> {
+            unsafe { msg_send_id![Self::class(), screens] }
+        }
+
+        #[sel(bounds)]
+        pub fn bounds(&self) -> CGRect;
+
+        #[sel(scale)]
+        pub fn scale(&self) -> CGFloat;
+
+        #[sel(nativeBounds)]
+        pub fn nativeBounds(&self) -> CGRect;
+
+        #[sel(nativeScale)]
+        pub fn nativeScale(&self) -> CGFloat;
+
+        #[sel(maximumFramesPerSecond)]
+        pub fn maximumFramesPerSecond(&self) -> NSInteger;
+
+        pub fn mirroredScreen(&self) -> Id<Self, Shared> {
+            unsafe { msg_send_id![Self::class(), mirroredScreen] }
+        }
+
+        pub fn preferredMode(&self) -> Option<Id<UIScreenMode, Shared>> {
+            unsafe { msg_send_id![self, preferredMode] }
+        }
+
+        #[sel(setCurrentMode:)]
+        pub fn setCurrentMode(&self, mode: Option<&UIScreenMode>);
+
+        pub fn availableModes(&self) -> Id<NSArray<UIScreenMode, Shared>, Shared> {
+            unsafe { msg_send_id![self, availableModes] }
+        }
+
+        #[sel(setOverscanCompensation:)]
+        pub fn setOverscanCompensation(&self, overscanCompensation: UIScreenOverscanCompensation);
+
+        pub fn coordinateSpace(&self) -> Id<UICoordinateSpace, Shared> {
+            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

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

src/platform_impl/ios/uikit/touch.rs

@@ -0,0 +1,64 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{CGFloat, CGPoint, NSInteger, NSObject};
+use objc2::{extern_class, extern_methods, ClassType};
+
+use super::UIView;
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UITouch;
+
+    unsafe impl ClassType for UITouch {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl UITouch {
+        #[sel(locationInView:)]
+        pub fn locationInView(&self, view: Option<&UIView>) -> CGPoint;
+
+        #[sel(type)]
+        pub fn type_(&self) -> UITouchType;
+
+        #[sel(force)]
+        pub fn force(&self) -> CGFloat;
+
+        #[sel(maximumPossibleForce)]
+        pub fn maximumPossibleForce(&self) -> CGFloat;
+
+        #[sel(altitudeAngle)]
+        pub fn altitudeAngle(&self) -> CGFloat;
+
+        #[sel(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

@@ -0,0 +1,32 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{NSInteger, NSObject};
+use objc2::{extern_class, extern_methods, ClassType};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UITraitCollection;
+
+    unsafe impl ClassType for UITraitCollection {
+        type Super = NSObject;
+    }
+);
+
+extern_methods!(
+    unsafe impl UITraitCollection {
+        #[sel(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

@@ -0,0 +1,89 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{CGFloat, CGRect, NSObject};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, ClassType};
+
+use super::{UICoordinateSpace, UIResponder, UIViewController};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct UIView;
+
+    unsafe impl ClassType for UIView {
+        #[inherits(NSObject)]
+        type Super = UIResponder;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIView {
+        #[sel(bounds)]
+        pub fn bounds(&self) -> CGRect;
+
+        #[sel(setBounds:)]
+        pub fn setBounds(&self, value: CGRect);
+
+        #[sel(frame)]
+        pub fn frame(&self) -> CGRect;
+
+        #[sel(setFrame:)]
+        pub fn setFrame(&self, value: CGRect);
+
+        #[sel(contentScaleFactor)]
+        pub fn contentScaleFactor(&self) -> CGFloat;
+
+        #[sel(setContentScaleFactor:)]
+        pub fn setContentScaleFactor(&self, val: CGFloat);
+
+        #[sel(setMultipleTouchEnabled:)]
+        pub fn setMultipleTouchEnabled(&self, val: bool);
+
+        pub fn rootViewController(&self) -> Option<Id<UIViewController, Shared>> {
+            unsafe { msg_send_id![self, rootViewController] }
+        }
+
+        #[sel(setRootViewController:)]
+        pub fn setRootViewController(&self, rootViewController: Option<&UIViewController>);
+
+        #[sel(convertRect:toCoordinateSpace:)]
+        pub fn convertRect_toCoordinateSpace(
+            &self,
+            rect: CGRect,
+            coordinateSpace: &UICoordinateSpace,
+        ) -> CGRect;
+
+        #[sel(convertRect:fromCoordinateSpace:)]
+        pub fn convertRect_fromCoordinateSpace(
+            &self,
+            rect: CGRect,
+            coordinateSpace: &UICoordinateSpace,
+        ) -> CGRect;
+
+        #[sel(safeAreaInsets)]
+        pub fn safeAreaInsets(&self) -> UIEdgeInsets;
+
+        #[sel(setNeedsDisplay)]
+        pub fn setNeedsDisplay(&self);
+    }
+);
+
+#[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

@@ -0,0 +1,55 @@
+use objc2::encode::{Encode, Encoding};
+use objc2::foundation::{NSObject, NSUInteger};
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, 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;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIViewController {
+        #[sel(attemptRotationToDeviceOrientation)]
+        pub fn attemptRotationToDeviceOrientation();
+
+        #[sel(setNeedsStatusBarAppearanceUpdate)]
+        pub fn setNeedsStatusBarAppearanceUpdate(&self);
+
+        #[sel(setNeedsUpdateOfHomeIndicatorAutoHidden)]
+        pub fn setNeedsUpdateOfHomeIndicatorAutoHidden(&self);
+
+        #[sel(setNeedsUpdateOfScreenEdgesDeferringSystemGestures)]
+        pub fn setNeedsUpdateOfScreenEdgesDeferringSystemGestures(&self);
+
+        pub fn view(&self) -> Option<Id<UIView, Shared>> {
+            unsafe { msg_send_id![self, view] }
+        }
+
+        #[sel(setView:)]
+        pub fn setView(&self, view: Option<&UIView>);
+    }
+);
+
+bitflags! {
+    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

@@ -0,0 +1,35 @@
+use objc2::foundation::NSObject;
+use objc2::rc::{Id, Shared};
+use objc2::{extern_class, extern_methods, msg_send_id, 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;
+    }
+);
+
+extern_methods!(
+    unsafe impl UIWindow {
+        pub fn screen(&self) -> Id<UIScreen, Shared> {
+            unsafe { msg_send_id![self, screen] }
+        }
+
+        #[sel(setScreen:)]
+        pub fn setScreen(&self, screen: &UIScreen);
+
+        #[sel(setHidden:)]
+        pub fn setHidden(&self, flag: bool);
+
+        #[sel(makeKeyAndVisible)]
+        pub fn makeKeyAndVisible(&self);
+
+        #[sel(isKeyWindow)]
+        pub fn isKeyWindow(&self) -> bool;
+    }
+);

src/platform_impl/ios/window.rs

@@ -1,60 +1,60 @@
-use raw_window_handle::{ios::IOSHandle, RawWindowHandle};
+#![allow(clippy::unnecessary_cast)]
+
 use std::{
     collections::VecDeque,
+    ffi::c_void,
     ops::{Deref, DerefMut},
 };
 
-use objc::runtime::{Class, Object, BOOL, NO, YES};
+use objc2::foundation::{CGFloat, CGPoint, CGRect, CGSize, MainThreadMarker};
+use objc2::rc::{Id, Shared};
+use objc2::runtime::Object;
+use objc2::{class, msg_send};
+use raw_window_handle::{RawDisplayHandle, RawWindowHandle, UiKitDisplayHandle, UiKitWindowHandle};
 
+use super::uikit::{UIApplication, UIScreen, UIScreenOverscanCompensation};
+use super::view::{WinitUIWindow, WinitView, WinitViewController};
 use crate::{
-    dpi::{self, LogicalPosition, LogicalSize},
+    dpi::{self, LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size},
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
     event::{Event, WindowEvent},
     icon::Icon,
-    monitor::MonitorHandle as RootMonitorHandle,
-    platform::ios::{MonitorHandleExtIOS, ScreenEdge, ValidOrientations},
+    platform::ios::{ScreenEdge, ValidOrientations},
     platform_impl::platform::{
-        app_state, event_loop,
-        ffi::{
-            id, CGFloat, CGPoint, CGRect, CGSize, UIEdgeInsets, UIInterfaceOrientationMask,
-            UIRectEdge, UIScreenOverscanCompensation,
-        },
-        monitor, view, EventLoopWindowTarget, MonitorHandle,
+        app_state,
+        event_loop::{EventProxy, EventWrapper},
+        ffi::UIRectEdge,
+        monitor, EventLoopWindowTarget, Fullscreen, MonitorHandle,
+    },
+    window::{
+        CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
+        WindowAttributes, WindowButtons, WindowId as RootWindowId, WindowLevel,
     },
-    window::{CursorIcon, Fullscreen, WindowAttributes, WindowId as RootWindowId},
 };
 
 pub struct Inner {
-    pub window: id,
-    pub view_controller: id,
-    pub view: id,
+    pub(crate) window: Id<WinitUIWindow, Shared>,
+    pub(crate) view_controller: Id<WinitViewController, Shared>,
+    pub(crate) view: Id<WinitView, Shared>,
     gl_or_metal_backed: bool,
 }
 
-impl Drop for Inner {
-    fn drop(&mut self) {
-        unsafe {
-            let () = msg_send![self.view, release];
-            let () = msg_send![self.view_controller, release];
-            let () = msg_send![self.window, release];
-        }
-    }
-}
-
 impl Inner {
     pub fn set_title(&self, _title: &str) {
         debug!("`Window::set_title` is ignored on iOS")
     }
 
+    pub fn set_transparent(&self, _transparent: bool) {
+        debug!("`Window::set_transparent` is ignored on iOS")
+    }
+
     pub fn set_visible(&self, visible: bool) {
-        match visible {
-            true => unsafe {
-                let () = msg_send![self.window, setHidden: NO];
-            },
-            false => unsafe {
-                let () = msg_send![self.window, setHidden: YES];
-            },
-        }
+        self.window.setHidden(!visible)
+    }
+
+    pub fn is_visible(&self) -> Option<bool> {
+        warn!("`Window::is_visible` is ignored on iOS");
+        None
     }
 
     pub fn request_redraw(&self) {
@@ -68,35 +68,41 @@ impl Inner {
                 // testing.
                 //
                 // https://developer.apple.com/documentation/uikit/uiview/1622437-setneedsdisplay?language=objc
-                app_state::queue_gl_or_metal_redraw(self.window);
+                app_state::queue_gl_or_metal_redraw(self.window.clone());
             } else {
-                let () = msg_send![self.view, setNeedsDisplay];
+                self.view.setNeedsDisplay();
             }
         }
     }
 
-    pub fn inner_position(&self) -> Result<LogicalPosition, NotSupportedError> {
+    pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         unsafe {
             let safe_area = self.safe_area_screen_space();
-            Ok(LogicalPosition {
-                x: safe_area.origin.x as _,
-                y: safe_area.origin.y as _,
-            })
+            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<LogicalPosition, NotSupportedError> {
+    pub fn outer_position(&self) -> Result<PhysicalPosition<i32>, NotSupportedError> {
         unsafe {
             let screen_frame = self.screen_frame();
-            Ok(LogicalPosition {
-                x: screen_frame.origin.x as _,
-                y: screen_frame.origin.y as _,
-            })
+            let position = LogicalPosition {
+                x: screen_frame.origin.x as f64,
+                y: screen_frame.origin.y as f64,
+            };
+            let scale_factor = self.scale_factor();
+            Ok(position.to_physical(scale_factor))
         }
     }
 
-    pub fn set_outer_position(&self, position: LogicalPosition) {
+    pub fn set_outer_position(&self, physical_position: Position) {
         unsafe {
+            let scale_factor = self.scale_factor();
+            let position = physical_position.to_logical::<f64>(scale_factor);
             let screen_frame = self.screen_frame();
             let new_screen_frame = CGRect {
                 origin: CGPoint {
@@ -105,63 +111,89 @@ impl Inner {
                 },
                 size: screen_frame.size,
             };
-            let bounds = self.from_screen_space(new_screen_frame);
-            let () = msg_send![self.window, setBounds: bounds];
+            let bounds = self.rect_from_screen_space(new_screen_frame);
+            self.window.setBounds(bounds);
         }
     }
 
-    pub fn inner_size(&self) -> LogicalSize {
+    pub fn inner_size(&self) -> PhysicalSize<u32> {
         unsafe {
+            let scale_factor = self.scale_factor();
             let safe_area = self.safe_area_screen_space();
-            LogicalSize {
-                width: safe_area.size.width as _,
-                height: safe_area.size.height as _,
-            }
+            let size = LogicalSize {
+                width: safe_area.size.width as f64,
+                height: safe_area.size.height as f64,
+            };
+            size.to_physical(scale_factor)
         }
     }
 
-    pub fn outer_size(&self) -> LogicalSize {
+    pub fn outer_size(&self) -> PhysicalSize<u32> {
         unsafe {
+            let scale_factor = self.scale_factor();
             let screen_frame = self.screen_frame();
-            LogicalSize {
-                width: screen_frame.size.width as _,
-                height: screen_frame.size.height as _,
-            }
+            let size = LogicalSize {
+                width: screen_frame.size.width as f64,
+                height: screen_frame.size.height as f64,
+            };
+            size.to_physical(scale_factor)
         }
     }
 
-    pub fn set_inner_size(&self, _size: LogicalSize) {
-        unimplemented!("not clear what `Window::set_inner_size` means on iOS");
+    pub fn set_inner_size(&self, _size: Size) {
+        warn!("not clear what `Window::set_inner_size` means on iOS");
     }
 
-    pub fn set_min_inner_size(&self, _dimensions: Option<LogicalSize>) {
+    pub fn set_min_inner_size(&self, _dimensions: Option<Size>) {
         warn!("`Window::set_min_inner_size` is ignored on iOS")
     }
 
-    pub fn set_max_inner_size(&self, _dimensions: Option<LogicalSize>) {
+    pub fn set_max_inner_size(&self, _dimensions: Option<Size>) {
         warn!("`Window::set_max_inner_size` is ignored on iOS")
     }
 
+    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
+        None
+    }
+
+    #[inline]
+    pub fn set_resize_increments(&self, _increments: Option<Size>) {
+        warn!("`Window::set_resize_increments` is ignored on iOS")
+    }
+
     pub fn set_resizable(&self, _resizable: bool) {
         warn!("`Window::set_resizable` is ignored on iOS")
     }
 
-    pub fn hidpi_factor(&self) -> f64 {
-        unsafe {
-            let hidpi: CGFloat = msg_send![self.view, contentScaleFactor];
-            hidpi as _
-        }
+    pub fn is_resizable(&self) -> bool {
+        warn!("`Window::is_resizable` is ignored on iOS");
+        false
+    }
+
+    #[inline]
+    pub fn set_enabled_buttons(&self, _buttons: WindowButtons) {
+        warn!("`Window::set_enabled_buttons` is ignored on iOS");
+    }
+
+    #[inline]
+    pub fn enabled_buttons(&self) -> WindowButtons {
+        warn!("`Window::enabled_buttons` is ignored on iOS");
+        WindowButtons::all()
+    }
+
+    pub fn scale_factor(&self) -> f64 {
+        self.view.contentScaleFactor() as _
     }
 
     pub fn set_cursor_icon(&self, _cursor: CursorIcon) {
         debug!("`Window::set_cursor_icon` ignored on iOS")
     }
 
-    pub fn set_cursor_position(&self, _position: LogicalPosition) -> Result<(), ExternalError> {
+    pub fn set_cursor_position(&self, _position: Position) -> Result<(), ExternalError> {
         Err(ExternalError::NotSupported(NotSupportedError::new()))
     }
 
-    pub fn set_cursor_grab(&self, _grab: bool) -> Result<(), ExternalError> {
+    pub fn set_cursor_grab(&self, _: CursorGrabMode) -> Result<(), ExternalError> {
         Err(ExternalError::NotSupported(NotSupportedError::new()))
     }
 
@@ -169,50 +201,72 @@ impl Inner {
         debug!("`Window::set_cursor_visible` is ignored on iOS")
     }
 
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn set_cursor_hittest(&self, _hittest: bool) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
+    pub fn set_minimized(&self, _minimized: bool) {
+        warn!("`Window::set_minimized` is ignored on iOS")
+    }
+
+    pub fn is_minimized(&self) -> Option<bool> {
+        warn!("`Window::is_minimized` is ignored on iOS");
+        None
+    }
+
     pub fn set_maximized(&self, _maximized: bool) {
         warn!("`Window::set_maximized` is ignored on iOS")
     }
 
-    pub fn set_fullscreen(&self, monitor: Option<Fullscreen>) {
-        unsafe {
-            let uiscreen = match monitor {
-                Some(Fullscreen::Exclusive(video_mode)) => {
-                    let uiscreen = video_mode.video_mode.monitor.ui_screen() as id;
-                    let () = msg_send![uiscreen, setCurrentMode: video_mode.video_mode.screen_mode];
-                    uiscreen
-                }
-                Some(Fullscreen::Borderless(monitor)) => monitor.ui_screen() as id,
-                None => {
-                    warn!("`Window::set_fullscreen(None)` ignored on iOS");
-                    return;
-                }
-            };
-
-            // this is pretty slow on iOS, so avoid doing it if we can
-            let current: id = msg_send![self.window, screen];
-            if uiscreen != current {
-                let () = msg_send![self.window, setScreen: uiscreen];
-            }
-
-            let bounds: CGRect = msg_send![uiscreen, bounds];
-            let () = msg_send![self.window, setFrame: bounds];
-
-            // For external displays, we must disable overscan compensation or
-            // the displayed image will have giant black bars surrounding it on
-            // each side
-            let () = msg_send![
-                uiscreen,
-                setOverscanCompensation: UIScreenOverscanCompensation::None
-            ];
-        }
+    pub fn is_maximized(&self) -> bool {
+        warn!("`Window::is_maximized` is ignored on iOS");
+        false
     }
 
-    pub fn fullscreen(&self) -> Option<Fullscreen> {
+    pub(crate) fn set_fullscreen(&self, monitor: Option<Fullscreen>) {
+        let uiscreen = match &monitor {
+            Some(Fullscreen::Exclusive(video_mode)) => {
+                let uiscreen = video_mode.monitor.ui_screen();
+                uiscreen.setCurrentMode(Some(&video_mode.screen_mode.0));
+                uiscreen.clone()
+            }
+            Some(Fullscreen::Borderless(Some(monitor))) => monitor.ui_screen().clone(),
+            Some(Fullscreen::Borderless(None)) => self.current_monitor_inner().ui_screen().clone(),
+            None => {
+                warn!("`Window::set_fullscreen(None)` ignored on iOS");
+                return;
+            }
+        };
+
+        // this is pretty slow on iOS, so avoid doing it if we can
+        let current = self.window.screen();
+        if uiscreen != current {
+            self.window.setScreen(&uiscreen);
+        }
+
+        let bounds = uiscreen.bounds();
+        self.window.setFrame(bounds);
+
+        // For external displays, we must disable overscan compensation or
+        // the displayed image will have giant black bars surrounding it on
+        // each side
+        uiscreen.setOverscanCompensation(UIScreenOverscanCompensation::None);
+    }
+
+    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
         unsafe {
-            let monitor = self.current_monitor();
-            let uiscreen = monitor.inner.ui_screen();
+            let monitor = self.current_monitor_inner();
+            let uiscreen = monitor.ui_screen();
             let screen_space_bounds = self.screen_frame();
-            let screen_bounds: CGRect = msg_send![uiscreen, bounds];
+            let screen_bounds = uiscreen.bounds();
 
             // TODO: track fullscreen instead of relying on brittle float comparisons
             if screen_space_bounds.origin.x == screen_bounds.origin.x
@@ -220,58 +274,99 @@ impl Inner {
                 && screen_space_bounds.size.width == screen_bounds.size.width
                 && screen_space_bounds.size.height == screen_bounds.size.height
             {
-                Some(Fullscreen::Borderless(monitor))
+                Some(Fullscreen::Borderless(Some(monitor)))
             } else {
                 None
             }
         }
     }
 
-    pub fn set_decorations(&self, _decorations: bool) {
-        warn!("`Window::set_decorations` is ignored on iOS")
+    pub fn set_decorations(&self, _decorations: bool) {}
+
+    pub fn is_decorated(&self) -> bool {
+        true
     }
 
-    pub fn set_always_on_top(&self, _always_on_top: bool) {
-        warn!("`Window::set_always_on_top` is ignored on iOS")
+    pub fn set_window_level(&self, _level: WindowLevel) {
+        warn!("`Window::set_window_level` is ignored on iOS")
     }
 
     pub fn set_window_icon(&self, _icon: Option<Icon>) {
         warn!("`Window::set_window_icon` is ignored on iOS")
     }
 
-    pub fn set_ime_position(&self, _position: LogicalPosition) {
+    pub fn set_ime_position(&self, _position: Position) {
         warn!("`Window::set_ime_position` is ignored on iOS")
     }
 
-    pub fn current_monitor(&self) -> RootMonitorHandle {
-        unsafe {
-            let uiscreen: id = msg_send![self.window, screen];
-            RootMonitorHandle {
-                inner: MonitorHandle::retained_new(uiscreen),
-            }
-        }
+    pub fn set_ime_allowed(&self, _allowed: bool) {
+        warn!("`Window::set_ime_allowed` is ignored on iOS")
+    }
+
+    pub fn set_ime_purpose(&self, _purpose: ImePurpose) {
+        warn!("`Window::set_ime_allowed` is ignored on iOS")
+    }
+
+    pub fn focus_window(&self) {
+        warn!("`Window::set_focus` is ignored on iOS")
+    }
+
+    pub fn request_user_attention(&self, _request_type: Option<UserAttentionType>) {
+        warn!("`Window::request_user_attention` is ignored on iOS")
+    }
+
+    // Allow directly accessing the current monitor internally without unwrapping.
+    fn current_monitor_inner(&self) -> MonitorHandle {
+        MonitorHandle::new(self.window.screen())
+    }
+
+    pub fn current_monitor(&self) -> Option<MonitorHandle> {
+        Some(self.current_monitor_inner())
     }
 
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        unsafe { monitor::uiscreens() }
+        monitor::uiscreens(MainThreadMarker::new().unwrap())
     }
 
-    pub fn primary_monitor(&self) -> MonitorHandle {
-        unsafe { monitor::main_uiscreen() }
+    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+        Some(MonitorHandle::new(UIScreen::main(
+            MainThreadMarker::new().unwrap(),
+        )))
     }
 
     pub fn id(&self) -> WindowId {
-        self.window.into()
+        self.window.id()
     }
 
     pub fn raw_window_handle(&self) -> RawWindowHandle {
-        let handle = IOSHandle {
-            ui_window: self.window as _,
-            ui_view: self.view as _,
-            ui_view_controller: self.view_controller as _,
-            ..IOSHandle::empty()
-        };
-        RawWindowHandle::IOS(handle)
+        let mut window_handle = 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 _;
+        RawWindowHandle::UiKit(window_handle)
+    }
+
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        RawDisplayHandle::UiKit(UiKitDisplayHandle::empty())
+    }
+
+    pub fn theme(&self) -> Option<Theme> {
+        warn!("`Window::theme` is ignored on iOS");
+        None
+    }
+
+    pub fn has_focus(&self) -> bool {
+        self.window.isKeyWindow()
+    }
+
+    #[inline]
+    pub fn set_theme(&self, _theme: Option<Theme>) {
+        warn!("`Window::set_theme` is ignored on iOS");
+    }
+
+    pub fn title(&self) -> String {
+        warn!("`Window::title` is ignored on iOS");
+        String::new()
     }
 }
 
@@ -281,9 +376,7 @@ pub struct Window {
 
 impl Drop for Window {
     fn drop(&mut self) {
-        unsafe {
-            assert_main_thread!("`Window::drop` can only be run on the main thread on iOS");
-        }
+        assert_main_thread!("`Window::drop` can only be run on the main thread on iOS");
     }
 }
 
@@ -294,222 +387,192 @@ impl Deref for Window {
     type Target = Inner;
 
     fn deref(&self) -> &Inner {
-        unsafe {
-            assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
-        }
+        assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
         &self.inner
     }
 }
 
 impl DerefMut for Window {
     fn deref_mut(&mut self) -> &mut Inner {
-        unsafe {
-            assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
-        }
+        assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
         &mut self.inner
     }
 }
 
 impl Window {
-    pub fn new<T>(
+    pub(crate) fn new<T>(
         _event_loop: &EventLoopWindowTarget<T>,
         window_attributes: WindowAttributes,
         platform_attributes: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Window, RootOsError> {
-        if let Some(_) = window_attributes.min_inner_size {
+        let mtm = MainThreadMarker::new().unwrap();
+
+        if window_attributes.min_inner_size.is_some() {
             warn!("`WindowAttributes::min_inner_size` is ignored on iOS");
         }
-        if let Some(_) = window_attributes.max_inner_size {
+        if window_attributes.max_inner_size.is_some() {
             warn!("`WindowAttributes::max_inner_size` is ignored on iOS");
         }
-        if window_attributes.always_on_top {
-            warn!("`WindowAttributes::always_on_top` is unsupported on iOS");
-        }
+
         // TODO: transparency, visible
 
-        unsafe {
-            let screen = match window_attributes.fullscreen {
-                Some(Fullscreen::Exclusive(ref video_mode)) => {
-                    video_mode.video_mode.monitor.ui_screen() as id
-                }
-                Some(Fullscreen::Borderless(ref monitor)) => monitor.ui_screen() as id,
-                None => monitor::main_uiscreen().ui_screen(),
-            };
+        let main_screen = UIScreen::main(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(),
+            Some(Fullscreen::Borderless(Some(ref monitor))) => monitor.ui_screen(),
+            Some(Fullscreen::Borderless(None)) | None => &main_screen,
+        };
 
-            let screen_bounds: CGRect = msg_send![screen, bounds];
+        let screen_bounds = screen.bounds();
 
-            let frame = match window_attributes.inner_size {
-                Some(dim) => CGRect {
+        let frame = match window_attributes.inner_size {
+            Some(dim) => {
+                let scale_factor = screen.scale();
+                let size = dim.to_logical::<f64>(scale_factor as f64);
+                CGRect {
                     origin: screen_bounds.origin,
                     size: CGSize {
-                        width: dim.width as _,
-                        height: dim.height as _,
+                        width: size.width as _,
+                        height: size.height as _,
                     },
-                },
-                None => screen_bounds,
+                }
+            }
+            None => screen_bounds,
+        };
+
+        let view = WinitView::new(mtm, &window_attributes, &platform_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 view_controller =
+            WinitViewController::new(mtm, &window_attributes, &platform_attributes, &view);
+        let window = WinitUIWindow::new(
+            mtm,
+            &window_attributes,
+            &platform_attributes,
+            frame,
+            &view_controller,
+        );
+
+        unsafe { app_state::set_key_window(&window) };
+
+        // Like the Windows and macOS backends, we send a `ScaleFactorChanged` and `Resized`
+        // event on window creation if the DPI factor != 1.0
+        let scale_factor = view.contentScaleFactor();
+        let scale_factor = scale_factor as f64;
+        if scale_factor != 1.0 {
+            let bounds = view.bounds();
+            let screen = window.screen();
+            let screen_space = screen.coordinateSpace();
+            let screen_frame = view.convertRect_toCoordinateSpace(bounds, &screen_space);
+            let size = crate::dpi::LogicalSize {
+                width: screen_frame.size.width as _,
+                height: screen_frame.size.height as _,
             };
-
-            let view = view::create_view(&window_attributes, &platform_attributes, frame.clone());
-
-            let gl_or_metal_backed = {
-                let view_class: id = msg_send![view, class];
-                let layer_class: id = msg_send![view_class, layerClass];
-                let is_metal: BOOL =
-                    msg_send![layer_class, isSubclassOfClass: class!(CAMetalLayer)];
-                let is_gl: BOOL = msg_send![layer_class, isSubclassOfClass: class!(CAEAGLLayer)];
-                is_metal == YES || is_gl == YES
-            };
-
-            let view_controller =
-                view::create_view_controller(&window_attributes, &platform_attributes, view);
-            let window = view::create_window(
-                &window_attributes,
-                &platform_attributes,
-                frame,
-                view_controller,
-            );
-
-            let result = Window {
-                inner: Inner {
-                    window,
-                    view_controller,
-                    view,
-                    gl_or_metal_backed,
-                },
-            };
-            app_state::set_key_window(window);
-
-            // Like the Windows and macOS backends, we send a `HiDpiFactorChanged` and `Resized`
-            // event on window creation if the DPI factor != 1.0
-            let hidpi_factor: CGFloat = msg_send![view, contentScaleFactor];
-            if hidpi_factor != 1.0 {
-                let bounds: CGRect = msg_send![view, bounds];
-                let screen: id = msg_send![window, screen];
-                let screen_space: id = msg_send![screen, coordinateSpace];
-                let screen_frame: CGRect =
-                    msg_send![view, convertRect:bounds toCoordinateSpace:screen_space];
-                let size = crate::dpi::LogicalSize {
-                    width: screen_frame.size.width as _,
-                    height: screen_frame.size.height as _,
-                };
+            let window_id = RootWindowId(window.id());
+            unsafe {
                 app_state::handle_nonuser_events(
-                    std::iter::once(Event::WindowEvent {
-                        window_id: RootWindowId(window.into()),
-                        event: WindowEvent::HiDpiFactorChanged(hidpi_factor as _),
-                    })
-                    .chain(std::iter::once(Event::WindowEvent {
-                        window_id: RootWindowId(window.into()),
-                        event: WindowEvent::Resized(size),
-                    })),
+                    std::iter::once(EventWrapper::EventProxy(EventProxy::DpiChangedProxy {
+                        window: window.clone(),
+                        scale_factor,
+                        suggested_size: size,
+                    }))
+                    .chain(std::iter::once(EventWrapper::StaticEvent(
+                        Event::WindowEvent {
+                            window_id,
+                            event: WindowEvent::Resized(size.to_physical(scale_factor)),
+                        },
+                    ))),
                 );
             }
-
-            Ok(result)
         }
+
+        Ok(Window {
+            inner: Inner {
+                window,
+                view_controller,
+                view,
+                gl_or_metal_backed,
+            },
+        })
     }
 }
 
 // WindowExtIOS
 impl Inner {
-    pub fn ui_window(&self) -> id {
-        self.window
+    pub fn ui_window(&self) -> *mut c_void {
+        Id::as_ptr(&self.window) as *mut c_void
     }
-    pub fn ui_view_controller(&self) -> id {
-        self.view_controller
+    pub fn ui_view_controller(&self) -> *mut c_void {
+        Id::as_ptr(&self.view_controller) as *mut c_void
     }
-    pub fn ui_view(&self) -> id {
-        self.view
+    pub fn ui_view(&self) -> *mut c_void {
+        Id::as_ptr(&self.view) as *mut c_void
     }
 
-    pub fn set_hidpi_factor(&self, hidpi_factor: f64) {
-        unsafe {
-            assert!(
-                dpi::validate_hidpi_factor(hidpi_factor),
-                "`WindowExtIOS::set_hidpi_factor` received an invalid hidpi factor"
-            );
-            let hidpi_factor = hidpi_factor as CGFloat;
-            let () = msg_send![self.view, setContentScaleFactor: hidpi_factor];
-        }
+    pub fn set_scale_factor(&self, scale_factor: f64) {
+        assert!(
+            dpi::validate_scale_factor(scale_factor),
+            "`WindowExtIOS::set_scale_factor` received an invalid hidpi factor"
+        );
+        let scale_factor = scale_factor as CGFloat;
+        self.view.setContentScaleFactor(scale_factor);
     }
 
     pub fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
-        unsafe {
-            let idiom = event_loop::get_idiom();
-            let supported_orientations = UIInterfaceOrientationMask::from_valid_orientations_idiom(
-                valid_orientations,
-                idiom,
-            );
-            msg_send![
-                self.view_controller,
-                setSupportedInterfaceOrientations: supported_orientations
-            ]
-        }
+        self.view_controller.set_supported_interface_orientations(
+            MainThreadMarker::new().unwrap(),
+            valid_orientations,
+        );
     }
 
     pub fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
-        unsafe {
-            let prefers_home_indicator_hidden = if hidden { YES } else { NO };
-            let () = msg_send![
-                self.view_controller,
-                setPrefersHomeIndicatorAutoHidden: prefers_home_indicator_hidden
-            ];
-        }
+        self.view_controller
+            .setPrefersHomeIndicatorAutoHidden(hidden);
     }
 
     pub fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
         let edges: UIRectEdge = edges.into();
-        unsafe {
-            let () = msg_send![
-                self.view_controller,
-                setPreferredScreenEdgesDeferringSystemGestures: edges
-            ];
-        }
+        self.view_controller
+            .setPreferredScreenEdgesDeferringSystemGestures(edges);
     }
 
     pub fn set_prefers_status_bar_hidden(&self, hidden: bool) {
-        unsafe {
-            let status_bar_hidden = if hidden { YES } else { NO };
-            let () = msg_send![
-                self.view_controller,
-                setPrefersStatusBarHidden: status_bar_hidden
-            ];
-        }
+        self.view_controller.setPrefersStatusBarHidden(hidden);
     }
 }
 
 impl Inner {
     // requires main thread
     unsafe fn screen_frame(&self) -> CGRect {
-        self.to_screen_space(msg_send![self.window, bounds])
+        self.rect_to_screen_space(self.window.bounds())
     }
 
     // requires main thread
-    unsafe fn to_screen_space(&self, rect: CGRect) -> CGRect {
-        let screen: id = msg_send![self.window, screen];
-        if !screen.is_null() {
-            let screen_space: id = msg_send![screen, coordinateSpace];
-            msg_send![self.window, convertRect:rect toCoordinateSpace:screen_space]
-        } else {
-            rect
-        }
+    unsafe fn rect_to_screen_space(&self, rect: CGRect) -> CGRect {
+        let screen_space = self.window.screen().coordinateSpace();
+        self.window
+            .convertRect_toCoordinateSpace(rect, &screen_space)
     }
 
     // requires main thread
-    unsafe fn from_screen_space(&self, rect: CGRect) -> CGRect {
-        let screen: id = msg_send![self.window, screen];
-        if !screen.is_null() {
-            let screen_space: id = msg_send![screen, coordinateSpace];
-            msg_send![self.window, convertRect:rect fromCoordinateSpace:screen_space]
-        } else {
-            rect
-        }
+    unsafe fn rect_from_screen_space(&self, rect: CGRect) -> CGRect {
+        let screen_space = self.window.screen().coordinateSpace();
+        self.window
+            .convertRect_fromCoordinateSpace(rect, &screen_space)
     }
 
     // requires main thread
     unsafe fn safe_area_screen_space(&self) -> CGRect {
-        let bounds: CGRect = msg_send![self.window, bounds];
+        let bounds = self.window.bounds();
         if app_state::os_capabilities().safe_area {
-            let safe_area: UIEdgeInsets = msg_send![self.window, safeAreaInsets];
+            let safe_area = self.window.safeAreaInsets();
             let safe_bounds = CGRect {
                 origin: CGPoint {
                     x: bounds.origin.x + safe_area.left,
@@ -520,16 +583,14 @@ impl Inner {
                     height: bounds.size.height - safe_area.top - safe_area.bottom,
                 },
             };
-            self.to_screen_space(safe_bounds)
+            self.rect_to_screen_space(safe_bounds)
         } else {
-            let screen_frame = self.to_screen_space(bounds);
-            let status_bar_frame: CGRect = {
-                let app: id = msg_send![class!(UIApplication), sharedApplication];
-                assert!(
-                    !app.is_null(),
-                    "`Window::get_inner_position` cannot be called before `EventLoop::run` on iOS"
+            let screen_frame = self.rect_to_screen_space(bounds);
+            let status_bar_frame = {
+                let app = UIApplication::shared(MainThreadMarker::new().unwrap_unchecked()).expect(
+                    "`Window::get_inner_position` cannot be called before `EventLoop::run` on iOS",
                 );
-                msg_send![app, statusBarFrame]
+                app.statusBarFrame()
             };
             let (y, height) = if screen_frame.origin.y > status_bar_frame.size.height {
                 (screen_frame.origin.y, screen_frame.size.height)
@@ -555,17 +616,31 @@ impl Inner {
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WindowId {
-    window: id,
+    window: *mut WinitUIWindow,
 }
 
 impl WindowId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         WindowId {
             window: std::ptr::null_mut(),
         }
     }
 }
 
+impl From<WindowId> for u64 {
+    fn from(window_id: WindowId) -> Self {
+        window_id.window as u64
+    }
+}
+
+impl From<u64> for WindowId {
+    fn from(raw_id: u64) -> Self {
+        Self {
+            window: raw_id as _,
+        }
+    }
+}
+
 unsafe impl Send for WindowId {}
 unsafe impl Sync for WindowId {}
 
@@ -577,39 +652,11 @@ impl From<&Object> for WindowId {
     }
 }
 
-impl From<&mut Object> for WindowId {
-    fn from(window: &mut Object) -> WindowId {
-        WindowId {
-            window: window as _,
-        }
-    }
-}
-
-impl From<id> for WindowId {
-    fn from(window: id) -> WindowId {
-        WindowId { window }
-    }
-}
-
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct PlatformSpecificWindowBuilderAttributes {
-    pub root_view_class: &'static Class,
-    pub hidpi_factor: Option<f64>,
+    pub scale_factor: Option<f64>,
     pub valid_orientations: ValidOrientations,
     pub prefers_home_indicator_hidden: bool,
     pub prefers_status_bar_hidden: bool,
     pub preferred_screen_edges_deferring_system_gestures: ScreenEdge,
 }
-
-impl Default for PlatformSpecificWindowBuilderAttributes {
-    fn default() -> PlatformSpecificWindowBuilderAttributes {
-        PlatformSpecificWindowBuilderAttributes {
-            root_view_class: class!(UIView),
-            hidpi_factor: None,
-            valid_orientations: Default::default(),
-            prefers_home_indicator_hidden: false,
-            prefers_status_bar_hidden: false,
-            preferred_screen_edges_deferring_system_gestures: Default::default(),
-        }
-    }
-}

src/platform_impl/linux/wayland/env.rs

@@ -0,0 +1,183 @@
+//! SCTK environment setup.
+
+use sctk::reexports::client::protocol::wl_compositor::WlCompositor;
+use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::protocols::unstable::xdg_shell::v6::client::zxdg_shell_v6::ZxdgShellV6;
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
+use sctk::reexports::protocols::unstable::xdg_decoration::v1::client::zxdg_decoration_manager_v1::ZxdgDecorationManagerV1;
+use sctk::reexports::client::protocol::wl_shell::WlShell;
+use sctk::reexports::client::protocol::wl_subcompositor::WlSubcompositor;
+use sctk::reexports::client::{Attached, DispatchData};
+use sctk::reexports::client::protocol::wl_shm::WlShm;
+use sctk::reexports::protocols::xdg_shell::client::xdg_wm_base::XdgWmBase;
+use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1;
+use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1;
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
+use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_v1::XdgActivationV1;
+use sctk::reexports::protocols::viewporter::client::wp_viewporter::WpViewporter;
+
+use sctk::environment::{Environment, SimpleGlobal};
+use sctk::output::{OutputHandler, OutputHandling, OutputInfo, OutputStatusListener};
+use sctk::seat::{SeatData, SeatHandler, SeatHandling, SeatListener};
+use sctk::shell::{Shell, ShellHandler, ShellHandling};
+use sctk::shm::ShmHandler;
+
+use crate::platform_impl::wayland::protocols::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1;
+
+/// Set of extra features that are supported by the compositor.
+#[derive(Debug, Clone, Copy)]
+pub struct WindowingFeatures {
+    pointer_constraints: bool,
+    xdg_activation: bool,
+}
+
+impl WindowingFeatures {
+    /// Create `WindowingFeatures` based on the presented interfaces.
+    pub fn new(env: &Environment<WinitEnv>) -> Self {
+        let pointer_constraints = env.get_global::<ZwpPointerConstraintsV1>().is_some();
+        let xdg_activation = env.get_global::<XdgActivationV1>().is_some();
+        Self {
+            pointer_constraints,
+            xdg_activation,
+        }
+    }
+
+    pub fn pointer_constraints(&self) -> bool {
+        self.pointer_constraints
+    }
+
+    pub fn xdg_activation(&self) -> bool {
+        self.xdg_activation
+    }
+}
+
+sctk::environment!(WinitEnv,
+    singles = [
+        WlShm => shm,
+        WlCompositor => compositor,
+        WlSubcompositor => subcompositor,
+        WlShell => shell,
+        XdgWmBase => shell,
+        ZxdgShellV6 => shell,
+        ZxdgDecorationManagerV1 => decoration_manager,
+        ZwpRelativePointerManagerV1 => relative_pointer_manager,
+        ZwpPointerConstraintsV1 => pointer_constraints,
+        ZwpTextInputManagerV3 => text_input_manager,
+        XdgActivationV1 => xdg_activation,
+        WpFractionalScaleManagerV1 => fractional_scale_manager,
+        WpViewporter => viewporter,
+    ],
+    multis = [
+        WlSeat => seats,
+        WlOutput => outputs,
+    ]
+);
+
+/// The environment that we utilize.
+pub struct WinitEnv {
+    seats: SeatHandler,
+
+    outputs: OutputHandler,
+
+    shm: ShmHandler,
+
+    compositor: SimpleGlobal<WlCompositor>,
+
+    subcompositor: SimpleGlobal<WlSubcompositor>,
+
+    shell: ShellHandler,
+
+    relative_pointer_manager: SimpleGlobal<ZwpRelativePointerManagerV1>,
+
+    pointer_constraints: SimpleGlobal<ZwpPointerConstraintsV1>,
+
+    text_input_manager: SimpleGlobal<ZwpTextInputManagerV3>,
+
+    decoration_manager: SimpleGlobal<ZxdgDecorationManagerV1>,
+
+    xdg_activation: SimpleGlobal<XdgActivationV1>,
+
+    fractional_scale_manager: SimpleGlobal<WpFractionalScaleManagerV1>,
+
+    viewporter: SimpleGlobal<WpViewporter>,
+}
+
+impl WinitEnv {
+    pub fn new() -> Self {
+        // Output tracking for available_monitors, etc.
+        let outputs = OutputHandler::new();
+
+        // Keyboard/Pointer/Touch input.
+        let seats = SeatHandler::new();
+
+        // Essential globals.
+        let shm = ShmHandler::new();
+        let compositor = SimpleGlobal::new();
+        let subcompositor = SimpleGlobal::new();
+
+        // Gracefully handle shell picking, since SCTK automatically supports multiple
+        // backends.
+        let shell = ShellHandler::new();
+
+        // Server side decorations.
+        let decoration_manager = SimpleGlobal::new();
+
+        // Device events for pointer.
+        let relative_pointer_manager = SimpleGlobal::new();
+
+        // Pointer grab functionality.
+        let pointer_constraints = SimpleGlobal::new();
+
+        // IME handling.
+        let text_input_manager = SimpleGlobal::new();
+
+        // Surface activation.
+        let xdg_activation = SimpleGlobal::new();
+
+        // Fractional surface scaling.
+        let fractional_scale_manager = SimpleGlobal::new();
+
+        // Surface resizing (used for fractional scaling).
+        let viewporter = SimpleGlobal::new();
+
+        Self {
+            seats,
+            outputs,
+            shm,
+            compositor,
+            subcompositor,
+            shell,
+            decoration_manager,
+            relative_pointer_manager,
+            pointer_constraints,
+            text_input_manager,
+            xdg_activation,
+            fractional_scale_manager,
+            viewporter,
+        }
+    }
+}
+
+impl ShellHandling for WinitEnv {
+    fn get_shell(&self) -> Option<Shell> {
+        self.shell.get_shell()
+    }
+}
+
+impl SeatHandling for WinitEnv {
+    fn listen<F: FnMut(Attached<WlSeat>, &SeatData, DispatchData<'_>) + 'static>(
+        &mut self,
+        f: F,
+    ) -> SeatListener {
+        self.seats.listen(f)
+    }
+}
+
+impl OutputHandling for WinitEnv {
+    fn listen<F: FnMut(WlOutput, &OutputInfo, DispatchData<'_>) + 'static>(
+        &mut self,
+        f: F,
+    ) -> OutputStatusListener {
+        self.outputs.listen(f)
+    }
+}

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

@@ -0,0 +1,609 @@
+use std::cell::RefCell;
+use std::collections::HashMap;
+use std::error::Error;
+use std::io::Result as IOResult;
+use std::mem;
+use std::process;
+use std::rc::Rc;
+use std::time::{Duration, Instant};
+
+use raw_window_handle::{RawDisplayHandle, WaylandDisplayHandle};
+
+use sctk::reexports::client::protocol::wl_compositor::WlCompositor;
+use sctk::reexports::client::protocol::wl_shm::WlShm;
+use sctk::reexports::client::Display;
+
+use sctk::reexports::calloop;
+
+use sctk::environment::Environment;
+use sctk::seat::pointer::{ThemeManager, ThemeSpec};
+use sctk::WaylandSource;
+
+use crate::dpi::{LogicalSize, PhysicalSize};
+use crate::event::{Event, StartCause, WindowEvent};
+use crate::event_loop::{ControlFlow, EventLoopWindowTarget as RootEventLoopWindowTarget};
+use crate::platform_impl::platform::sticky_exit_callback;
+use crate::platform_impl::EventLoopWindowTarget as PlatformEventLoopWindowTarget;
+
+use super::env::{WindowingFeatures, WinitEnv};
+use super::output::OutputManager;
+use super::seat::SeatManager;
+use super::window::shim::{self, WindowCompositorUpdate, WindowUserRequest};
+use super::{DeviceId, WindowId};
+
+mod proxy;
+mod sink;
+mod state;
+
+pub use proxy::EventLoopProxy;
+pub use sink::EventSink;
+pub use state::WinitState;
+
+type WinitDispatcher = calloop::Dispatcher<'static, WaylandSource, WinitState>;
+
+pub struct EventLoopWindowTarget<T> {
+    /// Wayland display.
+    pub display: Display,
+
+    /// Environment to handle object creation, etc.
+    pub env: Environment<WinitEnv>,
+
+    /// Event loop handle.
+    pub event_loop_handle: calloop::LoopHandle<'static, WinitState>,
+
+    /// Output manager.
+    pub output_manager: OutputManager,
+
+    /// State that we share across callbacks.
+    pub state: RefCell<WinitState>,
+
+    /// Dispatcher of Wayland events.
+    pub wayland_dispatcher: WinitDispatcher,
+
+    /// A proxy to wake up event loop.
+    pub event_loop_awakener: calloop::ping::Ping,
+
+    /// The available windowing features.
+    pub windowing_features: WindowingFeatures,
+
+    /// Theme manager to manage cursors.
+    ///
+    /// It's being shared between all windows to avoid loading
+    /// multiple similar themes.
+    pub theme_manager: ThemeManager,
+
+    _marker: std::marker::PhantomData<T>,
+}
+
+impl<T> EventLoopWindowTarget<T> {
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        let mut display_handle = WaylandDisplayHandle::empty();
+        display_handle.display = self.display.get_display_ptr() as *mut _;
+        RawDisplayHandle::Wayland(display_handle)
+    }
+}
+
+pub struct EventLoop<T: 'static> {
+    /// Dispatcher of Wayland events.
+    pub wayland_dispatcher: WinitDispatcher,
+
+    /// Event loop.
+    event_loop: calloop::EventLoop<'static, WinitState>,
+
+    /// Wayland display.
+    display: Display,
+
+    /// Pending user events.
+    pending_user_events: Rc<RefCell<Vec<T>>>,
+
+    /// Sender of user events.
+    user_events_sender: calloop::channel::Sender<T>,
+
+    /// Window target.
+    window_target: RootEventLoopWindowTarget<T>,
+
+    /// Output manager.
+    _seat_manager: SeatManager,
+}
+
+impl<T: 'static> EventLoop<T> {
+    pub fn new() -> Result<EventLoop<T>, Box<dyn Error>> {
+        // Connect to wayland server and setup event queue.
+        let display = Display::connect_to_env()?;
+        let mut event_queue = display.create_event_queue();
+        let display_proxy = display.attach(event_queue.token());
+
+        // Setup environment.
+        let env = Environment::new(&display_proxy, &mut event_queue, WinitEnv::new())?;
+
+        // Create event loop.
+        let event_loop = calloop::EventLoop::<'static, WinitState>::try_new()?;
+        // Build windowing features.
+        let windowing_features = WindowingFeatures::new(&env);
+
+        // Create a theme manager.
+        let compositor = env.require_global::<WlCompositor>();
+        let shm = env.require_global::<WlShm>();
+        let theme_manager = ThemeManager::init(ThemeSpec::System, compositor, shm);
+
+        // Setup theme seat and output managers.
+        let seat_manager = SeatManager::new(&env, event_loop.handle(), theme_manager.clone());
+        let output_manager = OutputManager::new(&env);
+
+        // A source of events that we plug into our event loop.
+        let wayland_source = WaylandSource::new(event_queue);
+        let wayland_dispatcher =
+            calloop::Dispatcher::new(wayland_source, |_, queue, winit_state| {
+                queue.dispatch_pending(winit_state, |event, object, _| {
+                    panic!(
+                        "[calloop] Encountered an orphan event: {}@{} : {}",
+                        event.interface,
+                        object.as_ref().id(),
+                        event.name
+                    );
+                })
+            });
+
+        let _wayland_source_dispatcher = event_loop
+            .handle()
+            .register_dispatcher(wayland_dispatcher.clone())?;
+
+        // A source of user events.
+        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();
+
+        // User events channel.
+        event_loop
+            .handle()
+            .insert_source(user_events_channel, move |event, _, _| {
+                if let calloop::channel::Event::Msg(msg) = event {
+                    pending_user_events_clone.borrow_mut().push(msg);
+                }
+            })?;
+
+        // An event's loop awakener to wake up for window events from winit's windows.
+        let (event_loop_awakener, event_loop_awakener_source) = calloop::ping::make_ping()?;
+
+        // Handler of window requests.
+        event_loop
+            .handle()
+            .insert_source(event_loop_awakener_source, move |_, _, state| {
+                // Drain events here as well to account for application doing batch event processing
+                // on RedrawEventsCleared.
+                shim::handle_window_requests(state);
+            })?;
+
+        let event_loop_handle = event_loop.handle();
+        let window_map = HashMap::new();
+        let event_sink = EventSink::new();
+        let window_user_requests = HashMap::new();
+        let window_compositor_updates = HashMap::new();
+
+        // Create event loop window target.
+        let event_loop_window_target = EventLoopWindowTarget {
+            display: display.clone(),
+            env,
+            state: RefCell::new(WinitState {
+                window_map,
+                event_sink,
+                window_user_requests,
+                window_compositor_updates,
+            }),
+            event_loop_handle,
+            output_manager,
+            event_loop_awakener,
+            wayland_dispatcher: wayland_dispatcher.clone(),
+            windowing_features,
+            theme_manager,
+            _marker: std::marker::PhantomData,
+        };
+
+        // Create event loop itself.
+        let event_loop = Self {
+            event_loop,
+            display,
+            pending_user_events,
+            wayland_dispatcher,
+            _seat_manager: seat_manager,
+            user_events_sender,
+            window_target: RootEventLoopWindowTarget {
+                p: PlatformEventLoopWindowTarget::Wayland(event_loop_window_target),
+                _marker: std::marker::PhantomData,
+            },
+        };
+
+        Ok(event_loop)
+    }
+
+    pub fn run<F>(mut self, callback: F) -> !
+    where
+        F: FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow) + 'static,
+    {
+        let exit_code = self.run_return(callback);
+        process::exit(exit_code);
+    }
+
+    pub fn run_return<F>(&mut self, mut callback: F) -> i32
+    where
+        F: FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
+    {
+        let mut control_flow = ControlFlow::Poll;
+        let pending_user_events = self.pending_user_events.clone();
+
+        callback(
+            Event::NewEvents(StartCause::Init),
+            &self.window_target,
+            &mut control_flow,
+        );
+
+        // NB: For consistency all platforms must emit a 'resumed' event even though Wayland
+        // applications don't themselves have a formal suspend/resume lifecycle.
+        callback(Event::Resumed, &self.window_target, &mut control_flow);
+
+        let mut window_compositor_updates: Vec<(WindowId, WindowCompositorUpdate)> = Vec::new();
+        let mut window_user_requests: Vec<(WindowId, WindowUserRequest)> = Vec::new();
+        let mut event_sink_back_buffer = Vec::new();
+
+        // NOTE We break on errors from dispatches, since if we've got protocol error
+        // libwayland-client/wayland-rs will inform us anyway, but crashing downstream is not
+        // really an option. Instead we inform that the event loop got destroyed. We may
+        // communicate an error that something was terminated, but winit doesn't provide us
+        // with an API to do that via some event.
+        // Still, we set the exit code to the error's OS error code, or to 1 if not possible.
+        let exit_code = loop {
+            // Send pending events to the server.
+            let _ = self.display.flush();
+
+            // During the run of the user callback, some other code monitoring and reading the
+            // Wayland socket may have been run (mesa for example does this with vsync), if that
+            // is the case, some events may have been enqueued in our event queue.
+            //
+            // If some messages are there, the event loop needs to behave as if it was instantly
+            // woken up by messages arriving from the Wayland socket, to avoid delaying the
+            // dispatch of these events until we're woken up again.
+            let instant_wakeup = {
+                let mut wayland_source = self.wayland_dispatcher.as_source_mut();
+                let queue = wayland_source.queue();
+                let state = match &mut self.window_target.p {
+                    PlatformEventLoopWindowTarget::Wayland(window_target) => {
+                        window_target.state.get_mut()
+                    }
+                    #[cfg(x11_platform)]
+                    _ => unreachable!(),
+                };
+
+                match queue.dispatch_pending(state, |_, _, _| unimplemented!()) {
+                    Ok(dispatched) => dispatched > 0,
+                    Err(error) => break error.raw_os_error().unwrap_or(1),
+                }
+            };
+
+            match control_flow {
+                ControlFlow::ExitWithCode(code) => break code,
+                ControlFlow::Poll => {
+                    // Non-blocking dispatch.
+                    let timeout = Duration::from_millis(0);
+                    if let Err(error) = self.loop_dispatch(Some(timeout)) {
+                        break error.raw_os_error().unwrap_or(1);
+                    }
+
+                    callback(
+                        Event::NewEvents(StartCause::Poll),
+                        &self.window_target,
+                        &mut control_flow,
+                    );
+                }
+                ControlFlow::Wait => {
+                    let timeout = if instant_wakeup {
+                        Some(Duration::from_millis(0))
+                    } else {
+                        None
+                    };
+
+                    if let Err(error) = self.loop_dispatch(timeout) {
+                        break error.raw_os_error().unwrap_or(1);
+                    }
+
+                    callback(
+                        Event::NewEvents(StartCause::WaitCancelled {
+                            start: Instant::now(),
+                            requested_resume: None,
+                        }),
+                        &self.window_target,
+                        &mut control_flow,
+                    );
+                }
+                ControlFlow::WaitUntil(deadline) => {
+                    let start = Instant::now();
+
+                    // Compute the amount of time we'll block for.
+                    let duration = if deadline > start && !instant_wakeup {
+                        deadline - start
+                    } else {
+                        Duration::from_millis(0)
+                    };
+
+                    if let Err(error) = self.loop_dispatch(Some(duration)) {
+                        break error.raw_os_error().unwrap_or(1);
+                    }
+
+                    let now = Instant::now();
+
+                    if now < deadline {
+                        callback(
+                            Event::NewEvents(StartCause::WaitCancelled {
+                                start,
+                                requested_resume: Some(deadline),
+                            }),
+                            &self.window_target,
+                            &mut control_flow,
+                        )
+                    } else {
+                        callback(
+                            Event::NewEvents(StartCause::ResumeTimeReached {
+                                start,
+                                requested_resume: deadline,
+                            }),
+                            &self.window_target,
+                            &mut control_flow,
+                        )
+                    }
+                }
+            }
+
+            // 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 pending_user_events.borrow_mut().drain(..) {
+                sticky_exit_callback(
+                    Event::UserEvent(user_event),
+                    &self.window_target,
+                    &mut control_flow,
+                    &mut callback,
+                );
+            }
+
+            // Process 'new' pending updates from compositor.
+            self.with_state(|state| {
+                window_compositor_updates.clear();
+                window_compositor_updates.extend(
+                    state
+                        .window_compositor_updates
+                        .iter_mut()
+                        .map(|(wid, window_update)| (*wid, mem::take(window_update))),
+                );
+            });
+
+            for (window_id, window_compositor_update) in window_compositor_updates.iter_mut() {
+                if let Some(scale_factor) = window_compositor_update.scale_factor {
+                    let mut physical_size = self.with_state(|state| {
+                        let window_handle = state.window_map.get(window_id).unwrap();
+                        *window_handle.scale_factor.lock().unwrap() = scale_factor;
+
+                        let mut size = window_handle.size.lock().unwrap();
+
+                        // Update the new logical size if it was changed.
+                        let window_size = window_compositor_update.size.unwrap_or(*size);
+                        *size = window_size;
+
+                        logical_to_physical_rounded(window_size, scale_factor)
+                    });
+
+                    sticky_exit_callback(
+                        Event::WindowEvent {
+                            window_id: crate::window::WindowId(*window_id),
+                            event: WindowEvent::ScaleFactorChanged {
+                                scale_factor,
+                                new_inner_size: &mut physical_size,
+                            },
+                        },
+                        &self.window_target,
+                        &mut control_flow,
+                        &mut callback,
+                    );
+
+                    // We don't update size on a window handle since we'll do that later
+                    // when handling size update.
+                    let new_logical_size = physical_size.to_logical(scale_factor);
+                    window_compositor_update.size = Some(new_logical_size);
+                }
+
+                if let Some(size) = window_compositor_update.size.take() {
+                    let physical_size = self.with_state(|state| {
+                        let window_handle = state.window_map.get_mut(window_id).unwrap();
+
+                        if let Some(fs_state) = window_handle.fractional_scaling_state.as_ref() {
+                            // If we have a viewport then we support fractional scaling. As per the
+                            // protocol, we have to set the viewport size of the size prior scaling.
+                            fs_state
+                                .viewport
+                                .set_destination(size.width as _, size.height as _);
+                        }
+
+                        let mut window_size = window_handle.size.lock().unwrap();
+
+                        // Always issue resize event on scale factor change.
+                        let physical_size = if window_compositor_update.scale_factor.is_none()
+                            && *window_size == size
+                        {
+                            // The size hasn't changed, don't inform downstream about that.
+                            None
+                        } else {
+                            *window_size = size;
+                            let scale_factor = window_handle.scale_factor();
+                            let physical_size = logical_to_physical_rounded(size, scale_factor);
+                            Some(physical_size)
+                        };
+
+                        // We still perform all of those resize related logic even if the size
+                        // hasn't changed, since GNOME relies on `set_geometry` calls after
+                        // configures.
+                        window_handle.window.resize(size.width, size.height);
+                        window_handle.window.refresh();
+
+                        // Update the opaque region.
+                        window_handle.set_transparent(window_handle.transparent.get());
+
+                        // Mark that refresh isn't required, since we've done it right now.
+                        state
+                            .window_user_requests
+                            .get_mut(window_id)
+                            .unwrap()
+                            .refresh_frame = false;
+
+                        // Queue redraw requested.
+                        state
+                            .window_user_requests
+                            .get_mut(window_id)
+                            .unwrap()
+                            .redraw_requested = true;
+
+                        physical_size
+                    });
+
+                    if let Some(physical_size) = physical_size {
+                        sticky_exit_callback(
+                            Event::WindowEvent {
+                                window_id: crate::window::WindowId(*window_id),
+                                event: WindowEvent::Resized(physical_size),
+                            },
+                            &self.window_target,
+                            &mut control_flow,
+                            &mut callback,
+                        );
+                    }
+                }
+
+                // If the close is requested, send it here.
+                if window_compositor_update.close_window {
+                    sticky_exit_callback(
+                        Event::WindowEvent {
+                            window_id: crate::window::WindowId(*window_id),
+                            event: WindowEvent::CloseRequested,
+                        },
+                        &self.window_target,
+                        &mut control_flow,
+                        &mut callback,
+                    );
+                }
+            }
+
+            // The purpose of the back buffer and that swap is to not hold borrow_mut when
+            // we're doing callback to the user, since we can double borrow if the user decides
+            // to create a window in one of those callbacks.
+            self.with_state(|state| {
+                std::mem::swap(
+                    &mut event_sink_back_buffer,
+                    &mut state.event_sink.window_events,
+                )
+            });
+
+            // Handle pending window events.
+            for event in event_sink_back_buffer.drain(..) {
+                let event = event.map_nonuser_event().unwrap();
+                sticky_exit_callback(event, &self.window_target, &mut control_flow, &mut callback);
+            }
+
+            // Send events cleared.
+            sticky_exit_callback(
+                Event::MainEventsCleared,
+                &self.window_target,
+                &mut control_flow,
+                &mut callback,
+            );
+
+            // Apply user requests, so every event required resize and latter surface commit will
+            // be applied right before drawing. This will also ensure that every `RedrawRequested`
+            // event will be delivered in time.
+            self.with_state(|state| {
+                shim::handle_window_requests(state);
+            });
+
+            // Process 'new' pending updates from compositor.
+            self.with_state(|state| {
+                window_user_requests.clear();
+                window_user_requests.extend(
+                    state
+                        .window_user_requests
+                        .iter_mut()
+                        .map(|(wid, window_request)| (*wid, mem::take(window_request))),
+                );
+            });
+
+            // Handle RedrawRequested events.
+            for (window_id, mut window_request) in window_user_requests.iter() {
+                // Handle refresh of the frame.
+                if window_request.refresh_frame {
+                    self.with_state(|state| {
+                        let window_handle = state.window_map.get_mut(window_id).unwrap();
+                        window_handle.window.refresh();
+                    });
+
+                    // In general refreshing the frame requires surface commit, those force user
+                    // to redraw.
+                    window_request.redraw_requested = true;
+                }
+
+                // Handle redraw request.
+                if window_request.redraw_requested {
+                    sticky_exit_callback(
+                        Event::RedrawRequested(crate::window::WindowId(*window_id)),
+                        &self.window_target,
+                        &mut control_flow,
+                        &mut callback,
+                    );
+                }
+            }
+
+            // Send RedrawEventCleared.
+            sticky_exit_callback(
+                Event::RedrawEventsCleared,
+                &self.window_target,
+                &mut control_flow,
+                &mut callback,
+            );
+        };
+
+        callback(Event::LoopDestroyed, &self.window_target, &mut control_flow);
+        exit_code
+    }
+
+    #[inline]
+    pub fn create_proxy(&self) -> EventLoopProxy<T> {
+        EventLoopProxy::new(self.user_events_sender.clone())
+    }
+
+    #[inline]
+    pub fn window_target(&self) -> &RootEventLoopWindowTarget<T> {
+        &self.window_target
+    }
+
+    fn with_state<U, F: FnOnce(&mut WinitState) -> U>(&mut self, f: F) -> U {
+        let state = match &mut self.window_target.p {
+            PlatformEventLoopWindowTarget::Wayland(window_target) => window_target.state.get_mut(),
+            #[cfg(x11_platform)]
+            _ => unreachable!(),
+        };
+
+        f(state)
+    }
+
+    fn loop_dispatch<D: Into<Option<std::time::Duration>>>(&mut self, timeout: D) -> IOResult<()> {
+        let state = match &mut self.window_target.p {
+            PlatformEventLoopWindowTarget::Wayland(window_target) => window_target.state.get_mut(),
+            #[cfg(x11_platform)]
+            _ => unreachable!(),
+        };
+
+        self.event_loop
+            .dispatch(timeout, state)
+            .map_err(|error| error.into())
+    }
+}
+
+// The default routine does floor, but we need round on Wayland.
+fn logical_to_physical_rounded(size: LogicalSize<u32>, scale_factor: f64) -> PhysicalSize<u32> {
+    let width = size.width as f64 * scale_factor;
+    let height = size.height as f64 * scale_factor;
+    (width.round(), height.round()).into()
+}

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

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

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

@@ -0,0 +1,36 @@
+//! An event loop's sink to deliver events from the Wayland event callbacks.
+
+use crate::event::{DeviceEvent, DeviceId as RootDeviceId, Event, WindowEvent};
+use crate::platform_impl::platform::DeviceId as PlatformDeviceId;
+use crate::window::WindowId as RootWindowId;
+
+use super::{DeviceId, WindowId};
+
+/// An event loop's sink to deliver events from the Wayland event callbacks
+/// to the winit's user.
+#[derive(Default)]
+pub struct EventSink {
+    pub window_events: Vec<Event<'static, ()>>,
+}
+
+impl EventSink {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Add new device event to a queue.
+    pub fn push_device_event(&mut self, event: DeviceEvent, device_id: DeviceId) {
+        self.window_events.push(Event::DeviceEvent {
+            event,
+            device_id: RootDeviceId(PlatformDeviceId::Wayland(device_id)),
+        });
+    }
+
+    /// Add new window event to a queue.
+    pub fn push_window_event(&mut self, event: WindowEvent<'static>, window_id: WindowId) {
+        self.window_events.push(Event::WindowEvent {
+            event,
+            window_id: RootWindowId(window_id),
+        });
+    }
+}

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

@@ -0,0 +1,31 @@
+//! A state that we pass around in a dispatch.
+
+use std::collections::HashMap;
+
+use super::EventSink;
+use crate::platform_impl::wayland::window::shim::{
+    WindowCompositorUpdate, WindowHandle, WindowUserRequest,
+};
+use crate::platform_impl::wayland::WindowId;
+
+/// Wrapper to carry winit's state.
+pub struct WinitState {
+    /// A sink for window and device events that is being filled during dispatching
+    /// event loop and forwarded downstream afterwards.
+    pub event_sink: EventSink,
+
+    /// Window updates comming from the user requests. Those are separatelly dispatched right after
+    /// `MainEventsCleared`.
+    pub window_user_requests: HashMap<WindowId, WindowUserRequest>,
+
+    /// Window updates, which are coming from SCTK or the compositor, which require
+    /// calling back to the winit's downstream. They are handled right in the event loop,
+    /// unlike the ones coming from buffers on the `WindowHandle`'s.
+    pub window_compositor_updates: HashMap<WindowId, WindowCompositorUpdate>,
+
+    /// Window map containing all SCTK windows. Since those windows aren't allowed
+    /// to be sent to other threads, they live on the event loop's thread
+    /// and requests from winit's windows are being forwarded to them either via
+    /// `WindowUpdate` or buffer on the associated with it `WindowHandle`.
+    pub window_map: HashMap<WindowId, WindowHandle>,
+}

src/platform_impl/linux/wayland/keyboard.rs

@@ -1,388 +0,0 @@
-use std::sync::{Arc, Mutex};
-
-use super::{make_wid, DeviceId};
-use smithay_client_toolkit::{
-    keyboard::{
-        self, map_keyboard_auto_with_repeat, Event as KbEvent, KeyRepeatEvent, KeyRepeatKind,
-    },
-    reexports::client::protocol::{wl_keyboard, wl_seat},
-};
-
-use crate::event::{ElementState, KeyboardInput, ModifiersState, VirtualKeyCode, WindowEvent};
-
-pub fn init_keyboard(
-    seat: &wl_seat::WlSeat,
-    sink: ::calloop::channel::Sender<(crate::event::WindowEvent, super::WindowId)>,
-    modifiers_tracker: Arc<Mutex<ModifiersState>>,
-) -> wl_keyboard::WlKeyboard {
-    // { variables to be captured by the closures
-    let target = Arc::new(Mutex::new(None));
-    let my_sink = sink.clone();
-    let repeat_sink = sink.clone();
-    let repeat_target = target.clone();
-    let my_modifiers = modifiers_tracker.clone();
-    // }
-    let ret = map_keyboard_auto_with_repeat(
-        seat,
-        KeyRepeatKind::System,
-        move |evt: KbEvent<'_>, _| {
-            match evt {
-                KbEvent::Enter { surface, .. } => {
-                    let wid = make_wid(&surface);
-                    my_sink.send((WindowEvent::Focused(true), wid)).unwrap();
-                    *target.lock().unwrap() = Some(wid);
-                }
-                KbEvent::Leave { surface, .. } => {
-                    let wid = make_wid(&surface);
-                    my_sink.send((WindowEvent::Focused(false), wid)).unwrap();
-                    *target.lock().unwrap() = None;
-                }
-                KbEvent::Key {
-                    rawkey,
-                    keysym,
-                    state,
-                    utf8,
-                    ..
-                } => {
-                    if let Some(wid) = *target.lock().unwrap() {
-                        let state = match state {
-                            wl_keyboard::KeyState::Pressed => ElementState::Pressed,
-                            wl_keyboard::KeyState::Released => ElementState::Released,
-                            _ => unreachable!(),
-                        };
-                        let vkcode = key_to_vkey(rawkey, keysym);
-                        my_sink
-                            .send((
-                                WindowEvent::KeyboardInput {
-                                    device_id: crate::event::DeviceId(
-                                        crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                    ),
-                                    input: KeyboardInput {
-                                        state,
-                                        scancode: rawkey,
-                                        virtual_keycode: vkcode,
-                                        modifiers: modifiers_tracker.lock().unwrap().clone(),
-                                    },
-                                },
-                                wid,
-                            ))
-                            .unwrap();
-                        // send char event only on key press, not release
-                        if let ElementState::Released = state {
-                            return;
-                        }
-                        if let Some(txt) = utf8 {
-                            for chr in txt.chars() {
-                                my_sink
-                                    .send((WindowEvent::ReceivedCharacter(chr), wid))
-                                    .unwrap();
-                            }
-                        }
-                    }
-                }
-                KbEvent::RepeatInfo { .. } => { /* Handled by smithay client toolkit */ }
-                KbEvent::Modifiers {
-                    modifiers: event_modifiers,
-                } => {
-                    let modifiers = event_modifiers.into();
-
-                    *modifiers_tracker.lock().unwrap() = modifiers;
-
-                    if let Some(wid) = *target.lock().unwrap() {
-                        my_sink
-                            .send((WindowEvent::ModifiersChanged { modifiers }, wid))
-                            .unwrap();
-                    }
-                }
-            }
-        },
-        move |repeat_event: KeyRepeatEvent, _| {
-            if let Some(wid) = *repeat_target.lock().unwrap() {
-                let state = ElementState::Pressed;
-                let vkcode = key_to_vkey(repeat_event.rawkey, repeat_event.keysym);
-                repeat_sink
-                    .send((
-                        WindowEvent::KeyboardInput {
-                            device_id: crate::event::DeviceId(
-                                crate::platform_impl::DeviceId::Wayland(DeviceId),
-                            ),
-                            input: KeyboardInput {
-                                state,
-                                scancode: repeat_event.rawkey,
-                                virtual_keycode: vkcode,
-                                modifiers: my_modifiers.lock().unwrap().clone(),
-                            },
-                        },
-                        wid,
-                    ))
-                    .unwrap();
-                if let Some(txt) = repeat_event.utf8 {
-                    for chr in txt.chars() {
-                        repeat_sink
-                            .send((WindowEvent::ReceivedCharacter(chr), wid))
-                            .unwrap();
-                    }
-                }
-            }
-        },
-    );
-
-    match ret {
-        Ok(keyboard) => keyboard,
-        Err(_) => {
-            // This is a fallback impl if libxkbcommon was not available
-            // This case should probably never happen, as most wayland
-            // compositors _need_ libxkbcommon anyway...
-            //
-            // In this case, we don't have the keymap information (it is
-            // supposed to be serialized by the compositor using libxkbcommon)
-
-            seat.get_keyboard(|keyboard| {
-                // { variables to be captured by the closure
-                let mut target = None;
-                let my_sink = sink;
-                // }
-
-                keyboard.implement_closure(
-                    move |evt, _| match evt {
-                        wl_keyboard::Event::Enter { surface, .. } => {
-                            let wid = make_wid(&surface);
-                            my_sink.send((WindowEvent::Focused(true), wid)).unwrap();
-                            target = Some(wid);
-                        }
-                        wl_keyboard::Event::Leave { surface, .. } => {
-                            let wid = make_wid(&surface);
-                            my_sink.send((WindowEvent::Focused(false), wid)).unwrap();
-                            target = None;
-                        }
-                        wl_keyboard::Event::Key { key, state, .. } => {
-                            if let Some(wid) = target {
-                                let state = match state {
-                                    wl_keyboard::KeyState::Pressed => ElementState::Pressed,
-                                    wl_keyboard::KeyState::Released => ElementState::Released,
-                                    _ => unreachable!(),
-                                };
-                                my_sink
-                                    .send((
-                                        WindowEvent::KeyboardInput {
-                                            device_id: crate::event::DeviceId(
-                                                crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                            ),
-                                            input: KeyboardInput {
-                                                state,
-                                                scancode: key,
-                                                virtual_keycode: None,
-                                                modifiers: ModifiersState::default(),
-                                            },
-                                        },
-                                        wid,
-                                    ))
-                                    .unwrap();
-                            }
-                        }
-                        _ => (),
-                    },
-                    (),
-                )
-            })
-            .unwrap()
-        }
-    }
-}
-
-fn key_to_vkey(rawkey: u32, keysym: u32) -> Option<VirtualKeyCode> {
-    match rawkey {
-        1 => Some(VirtualKeyCode::Escape),
-        2 => Some(VirtualKeyCode::Key1),
-        3 => Some(VirtualKeyCode::Key2),
-        4 => Some(VirtualKeyCode::Key3),
-        5 => Some(VirtualKeyCode::Key4),
-        6 => Some(VirtualKeyCode::Key5),
-        7 => Some(VirtualKeyCode::Key6),
-        8 => Some(VirtualKeyCode::Key7),
-        9 => Some(VirtualKeyCode::Key8),
-        10 => Some(VirtualKeyCode::Key9),
-        11 => Some(VirtualKeyCode::Key0),
-        _ => keysym_to_vkey(keysym),
-    }
-}
-
-fn keysym_to_vkey(keysym: u32) -> Option<VirtualKeyCode> {
-    use smithay_client_toolkit::keyboard::keysyms;
-    match keysym {
-        // letters
-        keysyms::XKB_KEY_A | keysyms::XKB_KEY_a => Some(VirtualKeyCode::A),
-        keysyms::XKB_KEY_B | keysyms::XKB_KEY_b => Some(VirtualKeyCode::B),
-        keysyms::XKB_KEY_C | keysyms::XKB_KEY_c => Some(VirtualKeyCode::C),
-        keysyms::XKB_KEY_D | keysyms::XKB_KEY_d => Some(VirtualKeyCode::D),
-        keysyms::XKB_KEY_E | keysyms::XKB_KEY_e => Some(VirtualKeyCode::E),
-        keysyms::XKB_KEY_F | keysyms::XKB_KEY_f => Some(VirtualKeyCode::F),
-        keysyms::XKB_KEY_G | keysyms::XKB_KEY_g => Some(VirtualKeyCode::G),
-        keysyms::XKB_KEY_H | keysyms::XKB_KEY_h => Some(VirtualKeyCode::H),
-        keysyms::XKB_KEY_I | keysyms::XKB_KEY_i => Some(VirtualKeyCode::I),
-        keysyms::XKB_KEY_J | keysyms::XKB_KEY_j => Some(VirtualKeyCode::J),
-        keysyms::XKB_KEY_K | keysyms::XKB_KEY_k => Some(VirtualKeyCode::K),
-        keysyms::XKB_KEY_L | keysyms::XKB_KEY_l => Some(VirtualKeyCode::L),
-        keysyms::XKB_KEY_M | keysyms::XKB_KEY_m => Some(VirtualKeyCode::M),
-        keysyms::XKB_KEY_N | keysyms::XKB_KEY_n => Some(VirtualKeyCode::N),
-        keysyms::XKB_KEY_O | keysyms::XKB_KEY_o => Some(VirtualKeyCode::O),
-        keysyms::XKB_KEY_P | keysyms::XKB_KEY_p => Some(VirtualKeyCode::P),
-        keysyms::XKB_KEY_Q | keysyms::XKB_KEY_q => Some(VirtualKeyCode::Q),
-        keysyms::XKB_KEY_R | keysyms::XKB_KEY_r => Some(VirtualKeyCode::R),
-        keysyms::XKB_KEY_S | keysyms::XKB_KEY_s => Some(VirtualKeyCode::S),
-        keysyms::XKB_KEY_T | keysyms::XKB_KEY_t => Some(VirtualKeyCode::T),
-        keysyms::XKB_KEY_U | keysyms::XKB_KEY_u => Some(VirtualKeyCode::U),
-        keysyms::XKB_KEY_V | keysyms::XKB_KEY_v => Some(VirtualKeyCode::V),
-        keysyms::XKB_KEY_W | keysyms::XKB_KEY_w => Some(VirtualKeyCode::W),
-        keysyms::XKB_KEY_X | keysyms::XKB_KEY_x => Some(VirtualKeyCode::X),
-        keysyms::XKB_KEY_Y | keysyms::XKB_KEY_y => Some(VirtualKeyCode::Y),
-        keysyms::XKB_KEY_Z | keysyms::XKB_KEY_z => Some(VirtualKeyCode::Z),
-        // F--
-        keysyms::XKB_KEY_F1 => Some(VirtualKeyCode::F1),
-        keysyms::XKB_KEY_F2 => Some(VirtualKeyCode::F2),
-        keysyms::XKB_KEY_F3 => Some(VirtualKeyCode::F3),
-        keysyms::XKB_KEY_F4 => Some(VirtualKeyCode::F4),
-        keysyms::XKB_KEY_F5 => Some(VirtualKeyCode::F5),
-        keysyms::XKB_KEY_F6 => Some(VirtualKeyCode::F6),
-        keysyms::XKB_KEY_F7 => Some(VirtualKeyCode::F7),
-        keysyms::XKB_KEY_F8 => Some(VirtualKeyCode::F8),
-        keysyms::XKB_KEY_F9 => Some(VirtualKeyCode::F9),
-        keysyms::XKB_KEY_F10 => Some(VirtualKeyCode::F10),
-        keysyms::XKB_KEY_F11 => Some(VirtualKeyCode::F11),
-        keysyms::XKB_KEY_F12 => Some(VirtualKeyCode::F12),
-        keysyms::XKB_KEY_F13 => Some(VirtualKeyCode::F13),
-        keysyms::XKB_KEY_F14 => Some(VirtualKeyCode::F14),
-        keysyms::XKB_KEY_F15 => Some(VirtualKeyCode::F15),
-        keysyms::XKB_KEY_F16 => Some(VirtualKeyCode::F16),
-        keysyms::XKB_KEY_F17 => Some(VirtualKeyCode::F17),
-        keysyms::XKB_KEY_F18 => Some(VirtualKeyCode::F18),
-        keysyms::XKB_KEY_F19 => Some(VirtualKeyCode::F19),
-        keysyms::XKB_KEY_F20 => Some(VirtualKeyCode::F20),
-        keysyms::XKB_KEY_F21 => Some(VirtualKeyCode::F21),
-        keysyms::XKB_KEY_F22 => Some(VirtualKeyCode::F22),
-        keysyms::XKB_KEY_F23 => Some(VirtualKeyCode::F23),
-        keysyms::XKB_KEY_F24 => Some(VirtualKeyCode::F24),
-        // flow control
-        keysyms::XKB_KEY_Print => Some(VirtualKeyCode::Snapshot),
-        keysyms::XKB_KEY_Scroll_Lock => Some(VirtualKeyCode::Scroll),
-        keysyms::XKB_KEY_Pause => Some(VirtualKeyCode::Pause),
-        keysyms::XKB_KEY_Insert => Some(VirtualKeyCode::Insert),
-        keysyms::XKB_KEY_Home => Some(VirtualKeyCode::Home),
-        keysyms::XKB_KEY_Delete => Some(VirtualKeyCode::Delete),
-        keysyms::XKB_KEY_End => Some(VirtualKeyCode::End),
-        keysyms::XKB_KEY_Page_Down => Some(VirtualKeyCode::PageDown),
-        keysyms::XKB_KEY_Page_Up => Some(VirtualKeyCode::PageUp),
-        // arrows
-        keysyms::XKB_KEY_Left => Some(VirtualKeyCode::Left),
-        keysyms::XKB_KEY_Up => Some(VirtualKeyCode::Up),
-        keysyms::XKB_KEY_Right => Some(VirtualKeyCode::Right),
-        keysyms::XKB_KEY_Down => Some(VirtualKeyCode::Down),
-        //
-        keysyms::XKB_KEY_BackSpace => Some(VirtualKeyCode::Back),
-        keysyms::XKB_KEY_Return => Some(VirtualKeyCode::Return),
-        keysyms::XKB_KEY_space => Some(VirtualKeyCode::Space),
-        // keypad
-        keysyms::XKB_KEY_Num_Lock => Some(VirtualKeyCode::Numlock),
-        keysyms::XKB_KEY_KP_0 => Some(VirtualKeyCode::Numpad0),
-        keysyms::XKB_KEY_KP_1 => Some(VirtualKeyCode::Numpad1),
-        keysyms::XKB_KEY_KP_2 => Some(VirtualKeyCode::Numpad2),
-        keysyms::XKB_KEY_KP_3 => Some(VirtualKeyCode::Numpad3),
-        keysyms::XKB_KEY_KP_4 => Some(VirtualKeyCode::Numpad4),
-        keysyms::XKB_KEY_KP_5 => Some(VirtualKeyCode::Numpad5),
-        keysyms::XKB_KEY_KP_6 => Some(VirtualKeyCode::Numpad6),
-        keysyms::XKB_KEY_KP_7 => Some(VirtualKeyCode::Numpad7),
-        keysyms::XKB_KEY_KP_8 => Some(VirtualKeyCode::Numpad8),
-        keysyms::XKB_KEY_KP_9 => Some(VirtualKeyCode::Numpad9),
-        // misc
-        // => Some(VirtualKeyCode::AbntC1),
-        // => Some(VirtualKeyCode::AbntC2),
-        keysyms::XKB_KEY_plus => Some(VirtualKeyCode::Add),
-        keysyms::XKB_KEY_apostrophe => Some(VirtualKeyCode::Apostrophe),
-        // => Some(VirtualKeyCode::Apps),
-        // => Some(VirtualKeyCode::At),
-        // => Some(VirtualKeyCode::Ax),
-        keysyms::XKB_KEY_backslash => Some(VirtualKeyCode::Backslash),
-        // => Some(VirtualKeyCode::Calculator),
-        // => Some(VirtualKeyCode::Capital),
-        keysyms::XKB_KEY_colon => Some(VirtualKeyCode::Colon),
-        keysyms::XKB_KEY_comma => Some(VirtualKeyCode::Comma),
-        // => Some(VirtualKeyCode::Convert),
-        // => Some(VirtualKeyCode::Decimal),
-        // => Some(VirtualKeyCode::Divide),
-        keysyms::XKB_KEY_equal => Some(VirtualKeyCode::Equals),
-        // => Some(VirtualKeyCode::Grave),
-        // => Some(VirtualKeyCode::Kana),
-        // => Some(VirtualKeyCode::Kanji),
-        keysyms::XKB_KEY_Alt_L => Some(VirtualKeyCode::LAlt),
-        // => Some(VirtualKeyCode::LBracket),
-        keysyms::XKB_KEY_Control_L => Some(VirtualKeyCode::LControl),
-        keysyms::XKB_KEY_Shift_L => Some(VirtualKeyCode::LShift),
-        // => Some(VirtualKeyCode::LWin),
-        // => Some(VirtualKeyCode::Mail),
-        // => Some(VirtualKeyCode::MediaSelect),
-        // => Some(VirtualKeyCode::MediaStop),
-        keysyms::XKB_KEY_minus => Some(VirtualKeyCode::Minus),
-        keysyms::XKB_KEY_asterisk => Some(VirtualKeyCode::Multiply),
-        // => Some(VirtualKeyCode::Mute),
-        // => Some(VirtualKeyCode::MyComputer),
-        // => Some(VirtualKeyCode::NextTrack),
-        // => Some(VirtualKeyCode::NoConvert),
-        keysyms::XKB_KEY_KP_Separator => Some(VirtualKeyCode::NumpadComma),
-        keysyms::XKB_KEY_KP_Enter => Some(VirtualKeyCode::NumpadEnter),
-        keysyms::XKB_KEY_KP_Equal => Some(VirtualKeyCode::NumpadEquals),
-        keysyms::XKB_KEY_KP_Add => Some(VirtualKeyCode::Add),
-        keysyms::XKB_KEY_KP_Subtract => Some(VirtualKeyCode::Subtract),
-        keysyms::XKB_KEY_KP_Divide => Some(VirtualKeyCode::Divide),
-        keysyms::XKB_KEY_KP_Page_Up => Some(VirtualKeyCode::PageUp),
-        keysyms::XKB_KEY_KP_Page_Down => Some(VirtualKeyCode::PageDown),
-        keysyms::XKB_KEY_KP_Home => Some(VirtualKeyCode::Home),
-        keysyms::XKB_KEY_KP_End => Some(VirtualKeyCode::End),
-        // => Some(VirtualKeyCode::OEM102),
-        // => Some(VirtualKeyCode::Period),
-        // => Some(VirtualKeyCode::Playpause),
-        // => Some(VirtualKeyCode::Power),
-        // => Some(VirtualKeyCode::Prevtrack),
-        keysyms::XKB_KEY_Alt_R => Some(VirtualKeyCode::RAlt),
-        // => Some(VirtualKeyCode::RBracket),
-        keysyms::XKB_KEY_Control_R => Some(VirtualKeyCode::RControl),
-        keysyms::XKB_KEY_Shift_R => Some(VirtualKeyCode::RShift),
-        // => Some(VirtualKeyCode::RWin),
-        keysyms::XKB_KEY_semicolon => Some(VirtualKeyCode::Semicolon),
-        keysyms::XKB_KEY_slash => Some(VirtualKeyCode::Slash),
-        // => Some(VirtualKeyCode::Sleep),
-        // => Some(VirtualKeyCode::Stop),
-        // => Some(VirtualKeyCode::Subtract),
-        // => Some(VirtualKeyCode::Sysrq),
-        keysyms::XKB_KEY_Tab => Some(VirtualKeyCode::Tab),
-        keysyms::XKB_KEY_ISO_Left_Tab => Some(VirtualKeyCode::Tab),
-        // => Some(VirtualKeyCode::Underline),
-        // => Some(VirtualKeyCode::Unlabeled),
-        keysyms::XKB_KEY_XF86AudioLowerVolume => Some(VirtualKeyCode::VolumeDown),
-        keysyms::XKB_KEY_XF86AudioRaiseVolume => Some(VirtualKeyCode::VolumeUp),
-        // => Some(VirtualKeyCode::Wake),
-        // => Some(VirtualKeyCode::Webback),
-        // => Some(VirtualKeyCode::WebFavorites),
-        // => Some(VirtualKeyCode::WebForward),
-        // => Some(VirtualKeyCode::WebHome),
-        // => Some(VirtualKeyCode::WebRefresh),
-        // => Some(VirtualKeyCode::WebSearch),
-        // => Some(VirtualKeyCode::WebStop),
-        // => Some(VirtualKeyCode::Yen),
-        keysyms::XKB_KEY_XF86Copy => Some(VirtualKeyCode::Copy),
-        keysyms::XKB_KEY_XF86Paste => Some(VirtualKeyCode::Paste),
-        keysyms::XKB_KEY_XF86Cut => Some(VirtualKeyCode::Cut),
-        // fallback
-        _ => None,
-    }
-}
-
-impl From<keyboard::ModifiersState> for ModifiersState {
-    fn from(mods: keyboard::ModifiersState) -> ModifiersState {
-        ModifiersState {
-            shift: mods.shift,
-            ctrl: mods.ctrl,
-            alt: mods.alt,
-            logo: mods.logo,
-        }
-    }
-}

src/platform_impl/linux/wayland/mod.rs

@@ -1,41 +1,29 @@
-#![cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd",
-           target_os = "netbsd", target_os = "openbsd"))]
+#![cfg(wayland_platform)]
 
-pub use self::{
-    event_loop::{
-        EventLoop, EventLoopProxy, EventLoopWindowTarget, MonitorHandle, VideoMode,
-        WindowEventsSink,
-    },
-    window::Window,
-};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
 
-use smithay_client_toolkit::reexports::client::protocol::wl_surface;
+pub use crate::platform_impl::platform::WindowId;
+pub use event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget};
+pub use output::{MonitorHandle, VideoMode};
+pub use window::Window;
 
+mod env;
 mod event_loop;
-mod keyboard;
-mod pointer;
-mod touch;
+mod output;
+mod protocols;
+mod seat;
 mod window;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct DeviceId;
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         DeviceId
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct WindowId(usize);
-
-impl WindowId {
-    pub unsafe fn dummy() -> Self {
-        WindowId(0)
-    }
-}
-
 #[inline]
-fn make_wid(s: &wl_surface::WlSurface) -> WindowId {
-    WindowId(s.as_ref().c_ptr() as usize)
+fn make_wid(surface: &WlSurface) -> WindowId {
+    WindowId(surface.as_ref().c_ptr() as u64)
 }

src/platform_impl/linux/wayland/output.rs

@@ -0,0 +1,247 @@
+use std::collections::VecDeque;
+use std::sync::{Arc, Mutex};
+
+use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::client::Display;
+
+use sctk::environment::Environment;
+use sctk::output::OutputStatusListener;
+
+use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::platform_impl::platform::{
+    MonitorHandle as PlatformMonitorHandle, VideoMode as PlatformVideoMode,
+};
+
+use super::env::WinitEnv;
+use super::event_loop::EventLoopWindowTarget;
+
+/// Output manager.
+pub struct OutputManager {
+    /// A handle that actually performs all operations on outputs.
+    handle: OutputManagerHandle,
+
+    _output_listener: OutputStatusListener,
+}
+
+impl OutputManager {
+    pub fn new(env: &Environment<WinitEnv>) -> Self {
+        let handle = OutputManagerHandle::new();
+
+        // Handle existing outputs.
+        for output in env.get_all_outputs() {
+            match sctk::output::with_output_info(&output, |info| info.obsolete) {
+                Some(false) => (),
+                // The output is obsolete or we've failed to access its data, skipping.
+                _ => continue,
+            }
+
+            // The output is present and unusable, add it to the output manager manager.
+            handle.add_output(output);
+        }
+
+        let handle_for_listener = handle.clone();
+
+        let output_listener = env.listen_for_outputs(move |output, info, _| {
+            if info.obsolete {
+                handle_for_listener.remove_output(output)
+            } else {
+                handle_for_listener.add_output(output)
+            }
+        });
+
+        Self {
+            handle,
+            _output_listener: output_listener,
+        }
+    }
+
+    pub fn handle(&self) -> OutputManagerHandle {
+        self.handle.clone()
+    }
+}
+
+/// A handle to output manager.
+#[derive(Debug, Clone)]
+pub struct OutputManagerHandle {
+    outputs: Arc<Mutex<VecDeque<MonitorHandle>>>,
+}
+
+impl OutputManagerHandle {
+    fn new() -> Self {
+        let outputs = Arc::new(Mutex::new(VecDeque::new()));
+        Self { outputs }
+    }
+
+    /// Handle addition of the output.
+    fn add_output(&self, output: WlOutput) {
+        let mut outputs = self.outputs.lock().unwrap();
+        let position = outputs.iter().position(|handle| handle.proxy == output);
+        if position.is_none() {
+            outputs.push_back(MonitorHandle::new(output));
+        }
+    }
+
+    /// Handle removal of the output.
+    fn remove_output(&self, output: WlOutput) {
+        let mut outputs = self.outputs.lock().unwrap();
+        let position = outputs.iter().position(|handle| handle.proxy == output);
+        if let Some(position) = position {
+            outputs.remove(position);
+        }
+    }
+
+    /// Get all observed outputs.
+    pub fn available_outputs(&self) -> VecDeque<MonitorHandle> {
+        self.outputs.lock().unwrap().clone()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct MonitorHandle {
+    pub(crate) proxy: WlOutput,
+}
+
+impl PartialEq for MonitorHandle {
+    fn eq(&self, other: &Self) -> bool {
+        self.native_identifier() == other.native_identifier()
+    }
+}
+
+impl Eq for MonitorHandle {}
+
+impl PartialOrd for MonitorHandle {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for MonitorHandle {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.native_identifier().cmp(&other.native_identifier())
+    }
+}
+
+impl std::hash::Hash for MonitorHandle {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.native_identifier().hash(state);
+    }
+}
+
+impl MonitorHandle {
+    #[inline]
+    pub(crate) fn new(proxy: WlOutput) -> Self {
+        Self { proxy }
+    }
+
+    #[inline]
+    pub fn name(&self) -> Option<String> {
+        sctk::output::with_output_info(&self.proxy, |info| {
+            format!("{} ({})", info.model, info.make)
+        })
+    }
+
+    #[inline]
+    pub fn native_identifier(&self) -> u32 {
+        sctk::output::with_output_info(&self.proxy, |info| info.id).unwrap_or(0)
+    }
+
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        match sctk::output::with_output_info(&self.proxy, |info| {
+            info.modes
+                .iter()
+                .find(|mode| mode.is_current)
+                .map(|mode| mode.dimensions)
+        }) {
+            Some(Some((w, h))) => (w as u32, h as u32),
+            _ => (0, 0),
+        }
+        .into()
+    }
+
+    #[inline]
+    pub fn position(&self) -> PhysicalPosition<i32> {
+        sctk::output::with_output_info(&self.proxy, |info| info.location)
+            .unwrap_or((0, 0))
+            .into()
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> Option<u32> {
+        sctk::output::with_output_info(&self.proxy, |info| {
+            info.modes
+                .iter()
+                .find_map(|mode| mode.is_current.then(|| mode.refresh_rate as u32))
+        })
+        .flatten()
+    }
+
+    #[inline]
+    pub fn scale_factor(&self) -> i32 {
+        sctk::output::with_output_info(&self.proxy, |info| info.scale_factor).unwrap_or(1)
+    }
+
+    #[inline]
+    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoMode> {
+        let modes = sctk::output::with_output_info(&self.proxy, |info| info.modes.clone())
+            .unwrap_or_default();
+
+        let monitor = self.clone();
+
+        modes.into_iter().map(move |mode| {
+            PlatformVideoMode::Wayland(VideoMode {
+                size: (mode.dimensions.0 as u32, mode.dimensions.1 as u32).into(),
+                refresh_rate_millihertz: mode.refresh_rate as u32,
+                bit_depth: 32,
+                monitor: monitor.clone(),
+            })
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct VideoMode {
+    pub(crate) size: PhysicalSize<u32>,
+    pub(crate) bit_depth: u16,
+    pub(crate) refresh_rate_millihertz: u32,
+    pub(crate) monitor: MonitorHandle,
+}
+
+impl VideoMode {
+    #[inline]
+    pub fn size(&self) -> PhysicalSize<u32> {
+        self.size
+    }
+
+    #[inline]
+    pub fn bit_depth(&self) -> u16 {
+        self.bit_depth
+    }
+
+    #[inline]
+    pub fn refresh_rate_millihertz(&self) -> u32 {
+        self.refresh_rate_millihertz
+    }
+
+    pub fn monitor(&self) -> PlatformMonitorHandle {
+        PlatformMonitorHandle::Wayland(self.monitor.clone())
+    }
+}
+
+impl<T> EventLoopWindowTarget<T> {
+    #[inline]
+    pub fn display(&self) -> &Display {
+        &self.display
+    }
+
+    #[inline]
+    pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
+        self.output_manager.handle.available_outputs()
+    }
+
+    #[inline]
+    pub fn primary_monitor(&self) -> Option<PlatformMonitorHandle> {
+        // There's no primary monitor on Wayland.
+        None
+    }
+}

src/platform_impl/linux/wayland/pointer.rs

@@ -1,268 +0,0 @@
-use std::sync::{Arc, Mutex};
-
-use crate::event::{
-    DeviceEvent, ElementState, ModifiersState, MouseButton, MouseScrollDelta, TouchPhase,
-    WindowEvent,
-};
-
-use super::{
-    event_loop::{CursorManager, WindowEventsSink},
-    window::WindowStore,
-    DeviceId,
-};
-
-use smithay_client_toolkit::reexports::client::protocol::{
-    wl_pointer::{self, Event as PtrEvent, WlPointer},
-    wl_seat,
-};
-
-use smithay_client_toolkit::reexports::protocols::unstable::relative_pointer::v1::client::{
-    zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1, zwp_relative_pointer_v1::Event,
-    zwp_relative_pointer_v1::ZwpRelativePointerV1,
-};
-
-use smithay_client_toolkit::reexports::protocols::unstable::pointer_constraints::v1::client::{
-    zwp_locked_pointer_v1::ZwpLockedPointerV1, zwp_pointer_constraints_v1::Lifetime,
-    zwp_pointer_constraints_v1::ZwpPointerConstraintsV1,
-};
-
-use smithay_client_toolkit::reexports::client::protocol::wl_surface::WlSurface;
-
-pub fn implement_pointer<T: 'static>(
-    seat: &wl_seat::WlSeat,
-    sink: Arc<Mutex<WindowEventsSink<T>>>,
-    store: Arc<Mutex<WindowStore>>,
-    modifiers_tracker: Arc<Mutex<ModifiersState>>,
-    cursor_manager: Arc<Mutex<CursorManager>>,
-) -> WlPointer {
-    seat.get_pointer(|pointer| {
-        let mut mouse_focus = None;
-        let mut axis_buffer = None;
-        let mut axis_discrete_buffer = None;
-        let mut axis_state = TouchPhase::Ended;
-
-        pointer.implement_closure(
-            move |evt, pointer| {
-                let mut sink = sink.lock().unwrap();
-                let store = store.lock().unwrap();
-                let mut cursor_manager = cursor_manager.lock().unwrap();
-                match evt {
-                    PtrEvent::Enter {
-                        surface,
-                        surface_x,
-                        surface_y,
-                        ..
-                    } => {
-                        let wid = store.find_wid(&surface);
-                        if let Some(wid) = wid {
-                            mouse_focus = Some(wid);
-                            sink.send_window_event(
-                                WindowEvent::CursorEntered {
-                                    device_id: crate::event::DeviceId(
-                                        crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                    ),
-                                },
-                                wid,
-                            );
-                            sink.send_window_event(
-                                WindowEvent::CursorMoved {
-                                    device_id: crate::event::DeviceId(
-                                        crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                    ),
-                                    position: (surface_x, surface_y).into(),
-                                    modifiers: modifiers_tracker.lock().unwrap().clone(),
-                                },
-                                wid,
-                            );
-                        }
-
-                        cursor_manager.reload_cursor_style();
-                    }
-                    PtrEvent::Leave { surface, .. } => {
-                        mouse_focus = None;
-                        let wid = store.find_wid(&surface);
-                        if let Some(wid) = wid {
-                            sink.send_window_event(
-                                WindowEvent::CursorLeft {
-                                    device_id: crate::event::DeviceId(
-                                        crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                    ),
-                                },
-                                wid,
-                            );
-                        }
-                    }
-                    PtrEvent::Motion {
-                        surface_x,
-                        surface_y,
-                        ..
-                    } => {
-                        if let Some(wid) = mouse_focus {
-                            sink.send_window_event(
-                                WindowEvent::CursorMoved {
-                                    device_id: crate::event::DeviceId(
-                                        crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                    ),
-                                    position: (surface_x, surface_y).into(),
-                                    modifiers: modifiers_tracker.lock().unwrap().clone(),
-                                },
-                                wid,
-                            );
-                        }
-                    }
-                    PtrEvent::Button { button, state, .. } => {
-                        if let Some(wid) = mouse_focus {
-                            let state = match state {
-                                wl_pointer::ButtonState::Pressed => ElementState::Pressed,
-                                wl_pointer::ButtonState::Released => ElementState::Released,
-                                _ => unreachable!(),
-                            };
-                            let button = match button {
-                                0x110 => MouseButton::Left,
-                                0x111 => MouseButton::Right,
-                                0x112 => MouseButton::Middle,
-                                // TODO figure out the translation ?
-                                _ => return,
-                            };
-                            sink.send_window_event(
-                                WindowEvent::MouseInput {
-                                    device_id: crate::event::DeviceId(
-                                        crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                    ),
-                                    state,
-                                    button,
-                                    modifiers: modifiers_tracker.lock().unwrap().clone(),
-                                },
-                                wid,
-                            );
-                        }
-                    }
-                    PtrEvent::Axis { axis, value, .. } => {
-                        if let Some(wid) = mouse_focus {
-                            if pointer.as_ref().version() < 5 {
-                                let (mut x, mut y) = (0.0, 0.0);
-                                // old seat compatibility
-                                match axis {
-                                    // wayland vertical sign convention is the inverse of winit
-                                    wl_pointer::Axis::VerticalScroll => y -= value as f32,
-                                    wl_pointer::Axis::HorizontalScroll => x += value as f32,
-                                    _ => unreachable!(),
-                                }
-                                sink.send_window_event(
-                                    WindowEvent::MouseWheel {
-                                        device_id: crate::event::DeviceId(
-                                            crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                        ),
-                                        delta: MouseScrollDelta::PixelDelta(
-                                            (x as f64, y as f64).into(),
-                                        ),
-                                        phase: TouchPhase::Moved,
-                                        modifiers: modifiers_tracker.lock().unwrap().clone(),
-                                    },
-                                    wid,
-                                );
-                            } else {
-                                let (mut x, mut y) = axis_buffer.unwrap_or((0.0, 0.0));
-                                match axis {
-                                    // wayland vertical sign convention is the inverse of winit
-                                    wl_pointer::Axis::VerticalScroll => y -= value as f32,
-                                    wl_pointer::Axis::HorizontalScroll => x += value as f32,
-                                    _ => unreachable!(),
-                                }
-                                axis_buffer = Some((x, y));
-                                axis_state = match axis_state {
-                                    TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
-                                    _ => TouchPhase::Started,
-                                }
-                            }
-                        }
-                    }
-                    PtrEvent::Frame => {
-                        let axis_buffer = axis_buffer.take();
-                        let axis_discrete_buffer = axis_discrete_buffer.take();
-                        if let Some(wid) = mouse_focus {
-                            if let Some((x, y)) = axis_discrete_buffer {
-                                sink.send_window_event(
-                                    WindowEvent::MouseWheel {
-                                        device_id: crate::event::DeviceId(
-                                            crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                        ),
-                                        delta: MouseScrollDelta::LineDelta(x as f32, y as f32),
-                                        phase: axis_state,
-                                        modifiers: modifiers_tracker.lock().unwrap().clone(),
-                                    },
-                                    wid,
-                                );
-                            } else if let Some((x, y)) = axis_buffer {
-                                sink.send_window_event(
-                                    WindowEvent::MouseWheel {
-                                        device_id: crate::event::DeviceId(
-                                            crate::platform_impl::DeviceId::Wayland(DeviceId),
-                                        ),
-                                        delta: MouseScrollDelta::PixelDelta(
-                                            (x as f64, y as f64).into(),
-                                        ),
-                                        phase: axis_state,
-                                        modifiers: modifiers_tracker.lock().unwrap().clone(),
-                                    },
-                                    wid,
-                                );
-                            }
-                        }
-                    }
-                    PtrEvent::AxisSource { .. } => (),
-                    PtrEvent::AxisStop { .. } => {
-                        axis_state = TouchPhase::Ended;
-                    }
-                    PtrEvent::AxisDiscrete { axis, discrete } => {
-                        let (mut x, mut y) = axis_discrete_buffer.unwrap_or((0, 0));
-                        match axis {
-                            // wayland vertical sign convention is the inverse of winit
-                            wl_pointer::Axis::VerticalScroll => y -= discrete,
-                            wl_pointer::Axis::HorizontalScroll => x += discrete,
-                            _ => unreachable!(),
-                        }
-                        axis_discrete_buffer = Some((x, y));
-                        axis_state = match axis_state {
-                            TouchPhase::Started | TouchPhase::Moved => TouchPhase::Moved,
-                            _ => TouchPhase::Started,
-                        }
-                    }
-                    _ => unreachable!(),
-                }
-            },
-            (),
-        )
-    })
-    .unwrap()
-}
-
-pub fn implement_relative_pointer<T: 'static>(
-    sink: Arc<Mutex<WindowEventsSink<T>>>,
-    pointer: &WlPointer,
-    manager: &ZwpRelativePointerManagerV1,
-) -> Result<ZwpRelativePointerV1, ()> {
-    manager.get_relative_pointer(pointer, |rel_pointer| {
-        rel_pointer.implement_closure(
-            move |evt, _rel_pointer| {
-                let mut sink = sink.lock().unwrap();
-                match evt {
-                    Event::RelativeMotion { dx, dy, .. } => sink
-                        .send_device_event(DeviceEvent::MouseMotion { delta: (dx, dy) }, DeviceId),
-                    _ => unreachable!(),
-                }
-            },
-            (),
-        )
-    })
-}
-
-pub fn implement_locked_pointer(
-    surface: &WlSurface,
-    pointer: &WlPointer,
-    constraints: &ZwpPointerConstraintsV1,
-) -> Result<ZwpLockedPointerV1, ()> {
-    constraints.lock_pointer(surface, pointer, None, Lifetime::Persistent.to_raw(), |c| {
-        c.implement_closure(|_, _| (), ())
-    })
-}