Release 0.27.4 version

During reload we were picking old styles, but the styles could
change during reload leading to errors during IME building.

Fixes #2510.

.github/CODEOWNERS

@@ -9,18 +9,17 @@
 /src/platform_impl/android          @msiglreith
 
 # iOS
-/src/platform/ios.rs                @madsmtm
-/src/platform_impl/ios              @madsmtm
+/src/platform/ios.rs                @francesca64
+/src/platform_impl/ios              @francesca64
 
-# Unix
+# Unix in general
+/src/platform/unix.rs               @kchibisov
 /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
@@ -34,7 +33,3 @@
 # 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/workflows/ci.yml

@@ -22,7 +22,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        rust_version: ['1.60.0', stable, nightly]
+        rust_version: [1.57.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,  }
@@ -33,8 +33,7 @@ jobs:
           - { 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: aarch64-linux-android,    os: ubuntu-latest,  cmd: 'apk --' }
           - { target: x86_64-apple-darwin,      os: macos-latest,    }
           - { target: x86_64-apple-ios,         os: macos-latest,    }
           - { target: aarch64-apple-ios,        os: macos-latest,    }
@@ -45,6 +44,7 @@ jobs:
     env:
       RUST_BACKTRACE: 1
       CARGO_INCREMENTAL: 0
+      PKG_CONFIG_ALLOW_CROSS: 1
       RUSTFLAGS: "-C debuginfo=0 --deny warnings"
       OPTIONS: ${{ matrix.platform.options }}
       FEATURES: ${{ format(',{0}', matrix.platform.features ) }}
@@ -67,55 +67,44 @@ jobs:
         targets: ${{ matrix.platform.target }}
         components: clippy
 
+    - name: Install Linux dependencies
+      if: (matrix.platform.os == 'ubuntu-latest')
+      run: sudo apt-get update && sudo apt-get install pkg-config cmake libfreetype6-dev libfontconfig1-dev
+
     - 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
+      run: sudo dpkg --add-architecture i386 && sudo apt-get update && sudo apt-get install g++-multilib gcc-multilib libfreetype6-dev:i386 libfontconfig1-dev:i386
     - 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
+      run: cargo $CMD doc --no-deps --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES --document-private-items
 
     - 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: >
+      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'
+        !contains(matrix.platform.target, 'wasm32'))
       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')
+      if: (matrix.rust_version == '1.57.0') && !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: >
+      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'
+        !contains(matrix.platform.target, 'wasm32'))
       run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features serde,$FEATURES

.gitignore

@@ -7,4 +7,4 @@ rls/
 *.ts
 *.js
 #*#
-.DS_Store
+.DS_Store

CHANGELOG.md

@@ -8,99 +8,13 @@ And please only add new entries to the top of this list, right below the `# Unre
 
 # 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
+# 0.27.3 (2022-9-10)
 
 - 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.
@@ -196,7 +110,6 @@ And please only add new entries to the top of this list, right below the `# Unre
 - 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)
 

CONTRIBUTING.md

@@ -20,7 +20,7 @@ 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.
+- your patch builds with Winit's minimal supported rust version - Rust 1.57.0.
 - 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
@@ -48,25 +48,15 @@ The current maintainers are listed in the [CODEOWNERS](.github/CODEOWNERS) file.
 
 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
+## Making a new release
 
-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.
+If you believe a new release is warranted, you can make a pull-request with:
+- An updated version number (remember to change the version everywhere it is used).
+- A new section in the changelog (below the `# Unreleased` section).
 
-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.
+This gives contributors an opportunity to squeeze in an extra PR or two that they feel is valuable
+enough to warrant blocking the release a little.
 
-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
+Once the PR is merged, a maintainer will create a new tag matching the version name (e.g. `v0.26.1`),
+and a CI job will automatically release the new version. Remember that the release date in the
+changelog must be kept in check with the actual release date.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.28.3"
+version = "0.27.4"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 edition = "2021"
@@ -10,7 +10,7 @@ readme = "README.md"
 repository = "https://github.com/rust-windowing/winit"
 documentation = "https://docs.rs/winit"
 categories = ["gui"]
-rust-version = "1.60.0"
+rust-version = "1.57.0"
 
 [package.metadata.docs.rs]
 features = ["serde"]
@@ -32,30 +32,24 @@ targets = [
     # WebAssembly
     "wasm32-unknown-unknown",
 ]
-rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
 default = ["x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
-x11 = ["x11-dl", "mio", "percent-encoding"]
-wayland = ["wayland-client", "wayland-protocols", "sctk", "wayland-commons"]
+x11 = ["x11-dl", "mio", "percent-encoding", "parking_lot"]
+wayland = ["wayland-client", "wayland-protocols", "sctk"]
 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 = ["sctk-adwaita", "sctk-adwaita/title"]
 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]
-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" }
+log = "0.4"
 serde = { version = "1", optional = true, features = ["serde_derive"] }
+raw_window_handle = { package = "raw-window-handle", version = "0.5" }
+raw_window_handle_04 = { package = "raw-window-handle", version = "0.4.3" }
+bitflags = "1"
+mint = { version = "0.5.6", optional = true }
 
 [dev-dependencies]
 image = { version = "0.24.0", default-features = false, features = ["png"] }
@@ -63,19 +57,23 @@ simple_logger = { version = "2.1.0", default_features = false }
 
 [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"
+ndk-glue = "0.7.0"
 
 [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`
+objc = "0.2.7"
 
 [target.'cfg(target_os = "macos")'.dependencies]
-core-graphics = "0.22.3"
+cocoa = "0.24"
+core-foundation = "0.9"
+core-graphics = "0.22"
 dispatch = "0.2.0"
 
+[target.'cfg(target_os = "windows")'.dependencies]
+parking_lot = "0.12"
+
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
-version = "0.45"
+version = "0.36"
 features = [
     "Win32_Devices_HumanInterfaceDevice",
     "Win32_Foundation",
@@ -103,23 +101,16 @@ features = [
     "Win32_UI_WindowsAndMessaging",
 ]
 
-[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 }
+[target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.dependencies]
+wayland-client = { version = "0.29.4", default_features = false,  features = ["use_system_lib"], optional = true }
+wayland-protocols = { version = "0.29.4", features = [ "staging_protocols"], 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 }
+sctk-adwaita = { version = "0.4.1", optional = true }
+mio = { version = "0.8", features = ["os-ext"], optional = true }
 x11-dl = { version = "2.18.5", optional = true }
-
-[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"
+percent-encoding = { version = "2.0", optional = true }
+parking_lot = { version = "0.12.0", optional = true }
+libc = "0.2.64"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies.web_sys]
 package = "web-sys"
@@ -133,7 +124,6 @@ features = [
     'DomRect',
     'Element',
     'Event',
-    "EventListenerOptions",
     'EventTarget',
     'FocusEvent',
     'HtmlCanvasElement',
@@ -153,7 +143,6 @@ version = "0.2.45"
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 console_log = "0.2"
-web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }
 
 [workspace]
 members = [

FEATURES.md

@@ -1,14 +1,13 @@
 # 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 following main graphical platforms:
+be used to create both games and applications. It supports the main graphical platforms:
 - Desktop
-  - Windows 7+ (10+ is tested regularly)
-  - macOS 10.7+ (10.14+ is tested regularly)
+  - Windows
+  - macOS
   - Unix
     - via X11
     - via Wayland
-  - Redox OS, via Orbital
 - Mobile
   - iOS
   - Android
@@ -130,8 +129,6 @@ 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
@@ -139,7 +136,6 @@ 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
@@ -152,6 +148,7 @@ 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
 
@@ -172,63 +169,62 @@ Legend:
 - ❓: Unknown status
 
 ### Windowing
-|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** |
+|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               |✔️     |✔️     |✔️         |✔️             |**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**|
+|Window minimization              |✔️     |✔️     |✔️         |✔️             |**N/A**|**N/A**|**N/A**|
+|Fullscreen                       |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |
+|Fullscreen toggle                |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |
+|Exclusive fullscreen             |✔️     |✔️     |✔️         |**N/A**         |❌    |✔️     |**N/A**|
+|HiDPI support                    |✔️     |✔️     |✔️         |✔️             |▢[#721]|✔️    |✔️    |
+|Popup windows                    |❌     |❌     |❌         |❌             |❌    |❌     |**N/A**|
 
 ### System information
-|Feature          |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS      |WASM      |Redox OS|
-|---------------- | ----- | ---- | ------- | ----------- | ----- | ------- | -------- | ------ |
-|Monitor list     |✔️    |✔️    |✔️       |✔️          |✔️     |✔️      |**N/A**|❌      |
-|Video mode query |✔️    |✔️    |✔️       |✔️          |✔️     |✔️      |**N/A**|❌      |
+|Feature          |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS      |WASM      |
+|---------------- | ----- | ---- | ------- | ----------- | ----- | ------- | -------- |
+|Monitor list     |✔️    |✔️    |✔️       |✔️          |**N/A**|✔️       |**N/A**|
+|Video mode query |✔️    |✔️    |✔️       |✔️          |❌     |✔️      |**N/A**|
 
 ### Input handling
-|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** |
+|Feature                 |Windows   |MacOS   |Linux x11|Linux Wayland|Android|iOS    |WASM      |
+|----------------------- | -----    | ----   | ------- | ----------- | ----- | ----- | -------- |
+|Mouse events            |✔️       |▢[#63]  |✔️       |✔️          |**N/A**|**N/A**|✔️        |
+|Mouse set location      |✔️       |✔️      |✔️       |✔️(when locked)  |**N/A**|**N/A**|**N/A**|
+|Cursor locking          |❌      |✔️      |❌    |✔️         |**N/A**|**N/A**|✔️        |
+|Cursor confining        |✔️       |❌     |✔️     |✔️         |**N/A**|**N/A**|❌       |
+|Cursor icon             |✔️       |✔️      |✔️       |✔️           |**N/A**|**N/A**|✔️        |
+|Cursor hittest          |✔️       |✔️      |❌       |✔️           |**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  |❓        |❓       |❓       |❓           |❌    |❌     |❓        |
+|Drag window with cursor |✔️         |✔️       |✔️        |✔️            |**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      |Redox OS|
-|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- | ------ |
-|New API for HiDPI ([#315] [#319])   |✔️    |✔️    |✔️       |✔️          |✔️     |✔️    |❓        |❓      |
-|Event Loop 2.0 ([#459])             |✔️    |✔️    |✔️       |✔️          |✔️     |✔️    |❓        |❓      |
-|Keyboard Input ([#812])             |❌    |❌    |❌       |❌          |❌     |❌    |❓        |❓      |
+|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])             |❌    |❌    |❌       |❌          |❌     |❌    |❓        |
 
 ### Completed API Reworks
-|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |WASM      |Redox OS|
-|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- | ------ |
+|Feature                             |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS    |WASM      |
+|------------------------------      | ----- | ---- | ------- | ----------- | ----- | ----- | -------- |
 
 [#165]: https://github.com/rust-windowing/winit/issues/165
 [#219]: https://github.com/rust-windowing/winit/issues/219

README.md

@@ -6,7 +6,7 @@
 
 ```toml
 [dependencies]
-winit = "0.28.3"
+winit = "0.27.4"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -99,95 +99,36 @@ book].
 
 #### Android
 
-The Android backend builds on (and exposes types from) the [`ndk`](https://docs.rs/ndk/0.7.0/ndk/) crate.
+This library makes use of the [ndk-rs](https://github.com/rust-windowing/android-ndk-rs) crates, refer to that repo for more documentation.
 
-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.
+The `ndk-glue` version needs to match the version used by `winit`. Otherwise, the application will not start correctly as `ndk-glue`'s internal `NativeActivity` static is not the same due to version mismatch.
 
-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)).
+`winit` compatibility table with `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::*`
+| winit |       ndk-glue       |
+| :---: | :------------------: |
+| 0.24  | `ndk-glue = "0.2.0"` |
+| 0.25  | `ndk-glue = "0.3.0"` |
+| 0.26  | `ndk-glue = "0.5.0"` |
+| 0.27  | `ndk-glue = "0.7.0"` |
 
 Running on an Android device needs a dynamic system library, add this to Cargo.toml:
 
 ```toml
-[lib]
-name = "main"
+[[example]]
+name = "request_redraw_threaded"
 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:
+And add this to the example file to add the native activity glue:
 ```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);
+#[cfg_attr(target_os = "android", ndk_glue::main(backtrace = "on"))]
+fn main() {
+    ...
 }
 ```
 
-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).
+And run the application with `cargo apk run --example request_redraw_threaded`
 
 #### MacOS
 
@@ -198,19 +139,6 @@ 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.

build.rs

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

@@ -1,80 +0,0 @@
-#[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

@@ -41,7 +41,7 @@ fn main() {
 
     event_loop.run(move |event, _, control_flow| {
         use winit::event::{ElementState, StartCause, VirtualKeyCode};
-        println!("{event:?}");
+        println!("{:?}", event);
         match event {
             Event::NewEvents(start_cause) => {
                 wait_cancelled = match start_cause {
@@ -64,19 +64,19 @@ fn main() {
                 } => match virtual_code {
                     VirtualKeyCode::Key1 => {
                         mode = Mode::Wait;
-                        println!("\nmode: {mode:?}\n");
+                        println!("\nmode: {:?}\n", mode);
                     }
                     VirtualKeyCode::Key2 => {
                         mode = Mode::WaitUntil;
-                        println!("\nmode: {mode:?}\n");
+                        println!("\nmode: {:?}\n", mode);
                     }
                     VirtualKeyCode::Key3 => {
                         mode = Mode::Poll;
-                        println!("\nmode: {mode:?}\n");
+                        println!("\nmode: {:?}\n", mode);
                     }
                     VirtualKeyCode::R => {
                         request_redraw = !request_redraw;
-                        println!("\nrequest_redraw: {request_redraw}\n");
+                        println!("\nrequest_redraw: {}\n", request_redraw);
                     }
                     VirtualKeyCode::Escape => {
                         close_requested = true;

examples/cursor_grab.rs

@@ -50,17 +50,17 @@ fn main() {
                     };
 
                     if let Err(err) = result {
-                        println!("error: {err}");
+                        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 {button} pressed"),
-                    ElementState::Released => println!("mouse button {button} released"),
+                    ElementState::Pressed => println!("mouse button {} pressed", button),
+                    ElementState::Released => println!("mouse button {} released", button),
                 },
                 _ => (),
             },

examples/custom_events.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::single_match)]
 
-#[cfg(not(wasm_platform))]
+#[cfg(not(target_arch = "wasm32"))]
 fn main() {
     use simple_logger::SimpleLogger;
     use winit::{
@@ -39,7 +39,7 @@ fn main() {
         control_flow.set_wait();
 
         match event {
-            Event::UserEvent(event) => println!("user event: {event:?}"),
+            Event::UserEvent(event) => println!("user event: {:?}", event),
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
                 ..
@@ -49,7 +49,7 @@ fn main() {
     });
 }
 
-#[cfg(wasm_platform)]
+#[cfg(target_arch = "wasm32")]
 fn main() {
     panic!("This example is not supported on web.");
 }

examples/fullscreen.rs

@@ -5,9 +5,6 @@ use winit::event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEve
 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();
@@ -29,14 +26,12 @@ fn main() {
 
     let mut mode_index = 0;
     let mut mode = monitor.video_modes().next().expect("no mode found");
-    println!("Mode: {mode}");
+    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");
@@ -64,18 +59,14 @@ fn main() {
                     }
                     VirtualKeyCode::F => {
                         let fullscreen = Some(Fullscreen::Exclusive(mode.clone()));
-                        println!("Setting mode: {fullscreen:?}");
+                        println!("Setting mode: {:?}", fullscreen);
                         window.set_fullscreen(fullscreen);
                     }
                     VirtualKeyCode::B => {
                         let fullscreen = Some(Fullscreen::Borderless(Some(monitor.clone())));
-                        println!("Setting mode: {fullscreen:?}");
+                        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) {
@@ -88,7 +79,7 @@ fn main() {
 
                         mode_index = 0;
                         mode = monitor.video_modes().next().expect("no mode found");
-                        println!("Mode: {mode}");
+                        println!("Mode: {}", mode);
                     }
                     VirtualKeyCode::M => {
                         mode_index += 1;
@@ -98,7 +89,7 @@ fn main() {
                             mode_index = 0;
                             mode = monitor.video_modes().next().expect("no mode found");
                         }
-                        println!("Mode: {mode}");
+                        println!("Mode: {}", mode);
                     }
                     VirtualKeyCode::D => {
                         decorations = !decorations;

examples/ime.rs

@@ -6,7 +6,7 @@ use winit::{
     dpi::PhysicalPosition,
     event::{ElementState, Event, Ime, VirtualKeyCode, WindowEvent},
     event_loop::{ControlFlow, EventLoop},
-    window::{ImePurpose, WindowBuilder},
+    window::WindowBuilder,
 };
 
 fn main() {
@@ -18,7 +18,6 @@ fn main() {
     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();
 
@@ -27,7 +26,6 @@ fn main() {
         .build(&event_loop)
         .unwrap();
 
-    let mut ime_purpose = ImePurpose::Normal;
     let mut ime_allowed = true;
     window.set_ime_allowed(ime_allowed);
 
@@ -69,7 +67,7 @@ fn main() {
                 event: WindowEvent::Ime(event),
                 ..
             } => {
-                println!("{event:?}");
+                println!("{:?}", event);
                 may_show_ime = event != Ime::Disabled;
                 if may_show_ime {
                     window.set_ime_position(ime_pos);
@@ -79,31 +77,20 @@ fn main() {
                 event: WindowEvent::ReceivedCharacter(ch),
                 ..
             } => {
-                println!("ch: {ch:?}");
+                println!("ch: {:?}", ch);
             }
             Event::WindowEvent {
                 event: WindowEvent::KeyboardInput { input, .. },
                 ..
             } => {
-                println!("key: {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");
+                    println!("\nIME: {}\n", ime_allowed);
                 }
             }
             _ => (),

examples/monitor_list.rs

@@ -1,8 +1,6 @@
 #![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() {
@@ -10,49 +8,6 @@ fn main() {
     let event_loop = EventLoop::new();
     let window = WindowBuilder::new().build(&event_loop).unwrap();
 
-    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
-        );
-    }
+    dbg!(window.available_monitors().collect::<Vec<_>>());
+    dbg!(window.primary_monitor());
 }

examples/mouse_wheel.rs

@@ -39,7 +39,7 @@ In other words, the deltas indicate the direction in which to move the content (
                 WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::MouseWheel { delta, .. } => match delta {
                     winit::event::MouseScrollDelta::LineDelta(x, y) => {
-                        println!("mouse wheel Line Delta: ({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;

examples/multithreaded.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::single_match)]
 
-#[cfg(not(wasm_platform))]
+#[cfg(not(target_arch = "wasm32"))]
 fn main() {
     use std::{collections::HashMap, sync::mpsc, thread, time::Duration};
 
@@ -9,7 +9,7 @@ fn main() {
         dpi::{PhysicalPosition, PhysicalSize, Position, Size},
         event::{ElementState, Event, KeyboardInput, VirtualKeyCode, WindowEvent},
         event_loop::EventLoop,
-        window::{CursorGrabMode, CursorIcon, Fullscreen, WindowBuilder, WindowLevel},
+        window::{CursorGrabMode, CursorIcon, Fullscreen, WindowBuilder},
     };
 
     const WINDOW_COUNT: usize = 3;
@@ -62,13 +62,11 @@ fn main() {
                             },
                         ..
                     } => {
-                        window.set_title(&format!("{key:?}"));
+                        window.set_title(&format!("{:?}", key));
                         let state = !modifiers.shift();
                         use VirtualKeyCode::*;
                         match key {
-                            Key1 => window.set_window_level(WindowLevel::AlwaysOnTop),
-                            Key2 => window.set_window_level(WindowLevel::AlwaysOnBottom),
-                            Key3 => window.set_window_level(WindowLevel::Normal),
+                            A => window.set_always_on_top(state),
                             C => window.set_cursor_icon(match state {
                                 true => CursorIcon::Progress,
                                 false => CursorIcon::Default,
@@ -92,17 +90,17 @@ fn main() {
                             }),
                             L if state => {
                                 if let Err(err) = window.set_cursor_grab(CursorGrabMode::Locked) {
-                                    println!("error: {err}");
+                                    println!("error: {}", err);
                                 }
                             }
                             G if state => {
                                 if let Err(err) = window.set_cursor_grab(CursorGrabMode::Confined) {
-                                    println!("error: {err}");
+                                    println!("error: {}", err);
                                 }
                             }
                             G | L if !state => {
                                 if let Err(err) = window.set_cursor_grab(CursorGrabMode::None) {
-                                    println!("error: {err}");
+                                    println!("error: {}", err);
                                 }
                             }
                             H => window.set_cursor_visible(!state),
@@ -193,7 +191,7 @@ fn main() {
     })
 }
 
-#[cfg(wasm_platform)]
+#[cfg(target_arch = "wasm32")]
 fn main() {
     panic!("Example not supported on Wasm");
 }

examples/multiwindow.rs

@@ -29,7 +29,7 @@ fn main() {
             Event::WindowEvent { event, window_id } => {
                 match event {
                     WindowEvent::CloseRequested => {
-                        println!("Window {window_id:?} has received the signal to close");
+                        println!("Window {:?} has received the signal to close", window_id);
 
                         // This drops the window, causing it to close.
                         windows.remove(&window_id);

examples/request_redraw.rs

@@ -17,7 +17,7 @@ fn main() {
         .unwrap();
 
     event_loop.run(move |event, _, control_flow| {
-        println!("{event:?}");
+        println!("{:?}", event);
 
         control_flow.set_wait();
 

examples/request_redraw_threaded.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::single_match)]
 
-#[cfg(not(wasm_platform))]
+#[cfg(not(target_arch = "wasm32"))]
 fn main() {
     use std::{thread, time};
 
@@ -25,7 +25,7 @@ fn main() {
     });
 
     event_loop.run(move |event, _, control_flow| {
-        println!("{event:?}");
+        println!("{:?}", event);
 
         control_flow.set_wait();
 
@@ -42,7 +42,7 @@ fn main() {
     });
 }
 
-#[cfg(wasm_platform)]
+#[cfg(target_arch = "wasm32")]
 fn main() {
     unimplemented!() // `Window` can't be sent between threads
 }

examples/resizable.rs

@@ -39,7 +39,7 @@ fn main() {
                     ..
                 } => {
                     resizable = !resizable;
-                    println!("Resizable: {resizable}");
+                    println!("Resizable: {}", resizable);
                     window.set_resizable(resizable);
                 }
                 _ => (),

examples/theme.rs

@@ -1,71 +0,0 @@
-#![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

@@ -22,7 +22,7 @@ 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) => {

examples/touchpad_gestures.rs

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

@@ -21,7 +21,7 @@ fn main() {
 
     event_loop.run(move |event, _, control_flow| {
         control_flow.set_wait();
-        println!("{event:?}");
+        println!("{:?}", event);
 
         match event {
             Event::WindowEvent {

examples/video_modes.rs

@@ -17,6 +17,6 @@ fn main() {
     println!("Listing available video modes:");
 
     for mode in monitor.video_modes() {
-        println!("{mode}");
+        println!("{}", mode);
     }
 }

examples/web.rs

@@ -14,13 +14,13 @@ pub fn main() {
         .build(&event_loop)
         .unwrap();
 
-    #[cfg(wasm_platform)]
-    let log_list = wasm::insert_canvas_and_create_log_list(&window);
+    #[cfg(target_arch = "wasm32")]
+    let log_list = wasm::create_log_list(&window);
 
     event_loop.run(move |event, _, control_flow| {
         control_flow.set_wait();
 
-        #[cfg(wasm_platform)]
+        #[cfg(target_arch = "wasm32")]
         wasm::log_event(&log_list, &event);
 
         match event {
@@ -36,7 +36,7 @@ pub fn main() {
     });
 }
 
-#[cfg(wasm_platform)]
+#[cfg(target_arch = "wasm32")]
 mod wasm {
     use wasm_bindgen::prelude::*;
     use winit::{event::Event, window::Window};
@@ -49,7 +49,7 @@ mod wasm {
         super::main();
     }
 
-    pub fn insert_canvas_and_create_log_list(window: &Window) -> web_sys::Element {
+    pub fn create_log_list(window: &Window) -> web_sys::Element {
         use winit::platform::web::WindowExtWebSys;
 
         let canvas = window.canvas();
@@ -58,7 +58,7 @@ mod wasm {
         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.
+        // Set a background color for the canvas to make it easier to tell the where the canvas is for debugging purposes.
         canvas.style().set_css_text("background-color: crimson;");
         body.append_child(&canvas).unwrap();
 
@@ -81,7 +81,7 @@ mod wasm {
             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.set_text_content(Some(&format!("{:?}", event)));
             log_list
                 .insert_before(&log, log_list.first_child().as_ref())
                 .unwrap();

examples/web_aspect_ratio.rs

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

@@ -19,7 +19,7 @@ fn main() {
 
     event_loop.run(move |event, _, control_flow| {
         control_flow.set_wait();
-        println!("{event:?}");
+        println!("{:?}", event);
 
         match event {
             Event::WindowEvent {

examples/window_buttons.rs

@@ -1,68 +0,0 @@
-#![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

@@ -51,7 +51,6 @@ fn main() {
                     if minimized {
                         minimized = !minimized;
                         window.set_minimized(minimized);
-                        window.focus_window();
                     }
                 }
                 VirtualKeyCode::V => {

examples/window_drag_resize.rs

@@ -1,141 +0,0 @@
-//! 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_option_as_alt.rs

@@ -1,67 +0,0 @@
-#![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

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

@@ -2,12 +2,14 @@
 
 // Limit this example to only compatible platforms.
 #[cfg(any(
-    windows_platform,
-    macos_platform,
-    x11_platform,
-    wayland_platform,
-    android_platform,
-    orbital_platform,
+    target_os = "windows",
+    target_os = "macos",
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd",
+    target_os = "android",
 ))]
 fn main() {
     use std::{thread::sleep, time::Duration};
@@ -35,7 +37,7 @@ fn main() {
 
             if let Event::WindowEvent { event, .. } = &event {
                 // Print only Window events to reduce noise
-                println!("{event:?}");
+                println!("{:?}", event);
             }
 
             match event {
@@ -58,7 +60,7 @@ fn main() {
     }
 }
 
-#[cfg(any(ios_platform, wasm_platform))]
+#[cfg(any(target_os = "ios", target_arch = "wasm32"))]
 fn main() {
     println!("This platform doesn't support run_return.");
 }

run-wasm/Cargo.toml

@@ -6,4 +6,4 @@ 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"
+cargo-run-wasm = "0.1.0"

run-wasm/src/main.rs

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

src/dpi.rs

@@ -519,8 +519,18 @@ impl Size {
             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);
+        let clamp = |input: f64, min: f64, max: f64| {
+            if input < min {
+                min
+            } else if input > max {
+                max
+            } else {
+                input
+            }
+        };
+
+        let width = clamp(input.width, min.width, max.width);
+        let height = clamp(input.height, min.height, max.height);
 
         PhysicalSize::new(width, height).into()
     }

src/event.rs

@@ -202,16 +202,7 @@ pub enum Event<'a, T: 'static> {
     /// Mainly of interest to applications with mostly-static graphics that avoid redrawing unless
     /// something changes, like most non-game GUIs.
     ///
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **macOS / iOS:** Due to implementation difficulties, this will often, but not always, be
-    ///   emitted directly inside `drawRect:`, with neither a preceding [`MainEventsCleared`] nor
-    ///   subsequent `RedrawEventsCleared`. See [#2640] for work on this.
-    ///
     /// [`MainEventsCleared`]: Self::MainEventsCleared
-    /// [`RedrawEventsCleared`]: Self::RedrawEventsCleared
-    /// [#2640]: https://github.com/rust-windowing/winit/issues/2640
     RedrawRequested(WindowId),
 
     /// Emitted after all [`RedrawRequested`] events have been processed and control flow is about to
@@ -400,7 +391,7 @@ pub enum WindowEvent<'a> {
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Web / Orbital:** Unsupported.
+    /// - **iOS / Android / Web:** Unsupported.
     Ime(Ime),
 
     /// The cursor has moved on the window.
@@ -439,53 +430,6 @@ pub enum WindowEvent<'a> {
         modifiers: ModifiersState,
     },
 
-    /// Touchpad magnification event with two-finger pinch gesture.
-    ///
-    /// Positive delta values indicate magnification (zooming in) and
-    /// negative delta values indicate shrinking (zooming out).
-    ///
-    /// ## Platform-specific
-    ///
-    /// - Only available on **macOS**.
-    TouchpadMagnify {
-        device_id: DeviceId,
-        delta: f64,
-        phase: TouchPhase,
-    },
-
-    /// Smart magnification event.
-    ///
-    /// On a Mac, smart magnification is triggered by a double tap with two fingers
-    /// on the trackpad and is commonly used to zoom on a certain object
-    /// (e.g. a paragraph of a PDF) or (sort of like a toggle) to reset any zoom.
-    /// The gesture is also supported in Safari, Pages, etc.
-    ///
-    /// The event is general enough that its generating gesture is allowed to vary
-    /// across platforms. It could also be generated by another device.
-    ///
-    /// Unfortunatly, neither [Windows](https://support.microsoft.com/en-us/windows/touch-gestures-for-windows-a9d28305-4818-a5df-4e2b-e5590f850741)
-    /// nor [Wayland](https://wayland.freedesktop.org/libinput/doc/latest/gestures.html)
-    /// support this gesture or any other gesture with the same effect.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - Only available on **macOS 10.8** and later.
-    SmartMagnify { device_id: DeviceId },
-
-    /// Touchpad rotation event with two-finger rotation gesture.
-    ///
-    /// Positive delta values indicate rotation counterclockwise and
-    /// negative delta values indicate rotation clockwise.
-    ///
-    /// ## Platform-specific
-    ///
-    /// - Only available on **macOS**.
-    TouchpadRotate {
-        device_id: DeviceId,
-        delta: f32,
-        phase: TouchPhase,
-    },
-
     /// Touchpad pressure event.
     ///
     /// At the moment, only supported on Apple forcetouch-capable macbooks.
@@ -505,10 +449,6 @@ pub enum WindowEvent<'a> {
     },
 
     /// Touch event has been received
-    ///
-    /// ## Platform-specific
-    ///
-    /// - **macOS:** Unsupported.
     Touch(Touch),
 
     /// The window's scale factor has changed.
@@ -536,7 +476,7 @@ pub enum WindowEvent<'a> {
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / X11 / Wayland / Orbital:** Unsupported.
+    /// At the moment this is only supported on Windows.
     ThemeChanged(Theme),
 
     /// The window has been occluded (completely hidden from view).
@@ -545,7 +485,7 @@ pub enum WindowEvent<'a> {
     /// minimised, set invisible, or fully occluded by another window.
     ///
     /// Platform-specific behavior:
-    /// - **iOS / Android / Web / Wayland / Windows / Orbital:** Unsupported.
+    /// - **iOS / Android / Web / Wayland / Windows:** Unsupported.
     Occluded(bool),
 }
 
@@ -613,27 +553,6 @@ impl Clone for WindowEvent<'static> {
                 button: *button,
                 modifiers: *modifiers,
             },
-            TouchpadMagnify {
-                device_id,
-                delta,
-                phase,
-            } => TouchpadMagnify {
-                device_id: *device_id,
-                delta: *delta,
-                phase: *phase,
-            },
-            SmartMagnify { device_id } => SmartMagnify {
-                device_id: *device_id,
-            },
-            TouchpadRotate {
-                device_id,
-                delta,
-                phase,
-            } => TouchpadRotate {
-                device_id: *device_id,
-                delta: *delta,
-                phase: *phase,
-            },
             TouchpadPressure {
                 device_id,
                 pressure,
@@ -722,25 +641,6 @@ impl<'a> WindowEvent<'a> {
                 button,
                 modifiers,
             }),
-            TouchpadMagnify {
-                device_id,
-                delta,
-                phase,
-            } => Some(TouchpadMagnify {
-                device_id,
-                delta,
-                phase,
-            }),
-            SmartMagnify { device_id } => Some(SmartMagnify { device_id }),
-            TouchpadRotate {
-                device_id,
-                delta,
-                phase,
-            } => Some(TouchpadRotate {
-                device_id,
-                delta,
-                phase,
-            }),
             TouchpadPressure {
                 device_id,
                 pressure,
@@ -960,10 +860,6 @@ pub enum TouchPhase {
 /// A [`TouchPhase::Cancelled`] event is emitted when the system has canceled tracking this
 /// touch, such as when the window loses focus, or on iOS if the user moves the
 /// device against their face.
-///
-/// ## Platform-specific
-///
-/// - **macOS:** Unsupported.
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct Touch {
     pub device_id: DeviceId,

src/event_loop.rs

@@ -11,7 +11,7 @@ use std::marker::PhantomData;
 use std::ops::Deref;
 use std::{error, fmt};
 
-use instant::{Duration, Instant};
+use instant::Instant;
 use once_cell::sync::OnceCell;
 use raw_window_handle::{HasRawDisplayHandle, RawDisplayHandle};
 
@@ -97,18 +97,8 @@ impl<T> EventLoopBuilder<T> {
     ///   `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();
@@ -163,10 +153,8 @@ pub enum ControlFlow {
     ///   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.
     ///
@@ -176,7 +164,6 @@ pub enum ControlFlow {
     ///
     /// [`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 `ExitWithCode`, and any future attempts to do so will
     /// result in the `control_flow` parameter being reset to `ExitWithCode`.
@@ -224,20 +211,6 @@ impl ControlFlow {
         *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
@@ -313,13 +286,6 @@ impl<T> EventLoop<T> {
     }
 }
 
-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()
-    }
-}
-
 impl<T> Deref for EventLoop<T> {
     type Target = EventLoopWindowTarget<T>;
     fn deref(&self) -> &EventLoopWindowTarget<T> {
@@ -346,9 +312,7 @@ impl<T> EventLoopWindowTarget<T> {
     /// **Wayland:** Always returns `None`.
     #[inline]
     pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        self.p
-            .primary_monitor()
-            .map(|inner| MonitorHandle { inner })
+        self.p.primary_monitor()
     }
 
     /// Change [`DeviceEvent`] filter mode.
@@ -359,11 +323,18 @@ impl<T> EventLoopWindowTarget<T> {
     ///
     /// ## Platform-specific
     ///
-    /// - **Wayland / macOS / iOS / Android / Web / Orbital:** Unsupported.
+    /// - **Wayland / macOS / iOS / Android / Web:** Unsupported.
     ///
     /// [`DeviceEvent`]: crate::event::DeviceEvent
     pub fn set_device_event_filter(&self, _filter: DeviceEventFilter) {
-        #[cfg(any(x11_platform, wayland_platform, windows))]
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "netbsd",
+            target_os = "openbsd",
+            target_os = "windows"
+        ))]
         self.p.set_device_event_filter(_filter);
     }
 }

src/icon.rs

@@ -34,7 +34,8 @@ impl fmt::Display for BadIcon {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             BadIcon::ByteCountNotDivisibleBy4 { byte_count } => write!(f,
-                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
+                "The length of the `rgba` argument ({:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
+                byte_count,
             ),
             BadIcon::DimensionsVsPixelCount {
                 width,
@@ -42,9 +43,10 @@ impl fmt::Display for BadIcon {
                 width_x_height,
                 pixel_count,
             } => write!(f,
-                "The specified dimensions ({width:?}x{height:?}) don't match the number of pixels supplied by the `rgba` argument ({pixel_count:?}). For those dimensions, the expected pixel count is {width_x_height:?}.",
+                "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,
             ),
-            BadIcon::OsError(e) => write!(f, "OS error when instantiating the icon: {e:?}"),
+            BadIcon::OsError(e) => write!(f, "OS error when instantiating the icon: {:?}", e),
         }
     }
 }

src/lib.rs

@@ -135,8 +135,6 @@
 #![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)]
@@ -147,6 +145,9 @@ extern crate log;
 extern crate serde;
 #[macro_use]
 extern crate bitflags;
+#[cfg(any(target_os = "macos", target_os = "ios"))]
+#[macro_use]
+extern crate objc;
 
 pub mod dpi;
 #[macro_use]

src/monitor.rs

@@ -61,7 +61,7 @@ impl VideoMode {
     ///
     /// ## Platform-specific
     ///
-    /// - **Wayland / Orbital:** Always returns 32.
+    /// - **Wayland:** Always returns 32.
     /// - **iOS:** Always returns 32.
     #[inline]
     pub fn bit_depth(&self) -> u16 {
@@ -78,9 +78,7 @@ impl VideoMode {
     /// a separate set of valid video modes.
     #[inline]
     pub fn monitor(&self) -> MonitorHandle {
-        MonitorHandle {
-            inner: self.video_mode.monitor(),
-        }
+        self.video_mode.monitor()
     }
 }
 
@@ -143,9 +141,6 @@ impl MonitorHandle {
 
     /// The monitor refresh rate used by the system.
     ///
-    /// 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]
@@ -174,8 +169,6 @@ impl MonitorHandle {
     /// - **Web:** Always returns an empty iterator
     #[inline]
     pub fn video_modes(&self) -> impl Iterator<Item = VideoMode> {
-        self.inner
-            .video_modes()
-            .map(|video_mode| VideoMode { video_mode })
+        self.inner.video_modes()
     }
 }

src/platform/android.rs

@@ -1,9 +1,11 @@
+#![cfg(any(target_os = "android"))]
+
 use crate::{
-    event_loop::{EventLoop, EventLoopBuilder, EventLoopWindowTarget},
+    event_loop::{EventLoop, EventLoopWindowTarget},
     window::{Window, WindowBuilder},
 };
-
-use android_activity::{AndroidApp, ConfigurationRef, Rect};
+use ndk::configuration::Configuration;
+use ndk_glue::Rect;
 
 /// Additional methods on [`EventLoop`] that are specific to Android.
 pub trait EventLoopExtAndroid {}
@@ -17,7 +19,7 @@ pub trait EventLoopWindowTargetExtAndroid {}
 pub trait WindowExtAndroid {
     fn content_rect(&self) -> Rect;
 
-    fn config(&self) -> ConfigurationRef;
+    fn config(&self) -> Configuration;
 }
 
 impl WindowExtAndroid for Window {
@@ -25,7 +27,7 @@ impl WindowExtAndroid for Window {
         self.window.content_rect()
     }
 
-    fn config(&self) -> ConfigurationRef {
+    fn config(&self) -> Configuration {
         self.window.config()
     }
 }
@@ -36,43 +38,3 @@ impl<T> EventLoopWindowTargetExtAndroid for EventLoopWindowTarget<T> {}
 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/ios.rs

@@ -1,6 +1,6 @@
-use std::os::raw::c_void;
+#![cfg(target_os = "ios")]
 
-use objc2::rc::Id;
+use std::os::raw::c_void;
 
 use crate::{
     event_loop::EventLoop,
@@ -99,17 +99,17 @@ pub trait WindowExtIOS {
 impl WindowExtIOS for Window {
     #[inline]
     fn ui_window(&self) -> *mut c_void {
-        self.window.ui_window()
+        self.window.ui_window() as _
     }
 
     #[inline]
     fn ui_view_controller(&self) -> *mut c_void {
-        self.window.ui_view_controller()
+        self.window.ui_view_controller() as _
     }
 
     #[inline]
     fn ui_view(&self) -> *mut c_void {
-        self.window.ui_view()
+        self.window.ui_view() as _
     }
 
     #[inline]
@@ -141,6 +141,13 @@ 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 `scale_factor`.
     ///
     /// The default value is device dependent, and it's recommended GLES or Metal applications set
@@ -190,6 +197,12 @@ 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_scale_factor(mut self, scale_factor: f64) -> WindowBuilder {
         self.platform_specific.scale_factor = Some(scale_factor);
@@ -241,14 +254,12 @@ pub trait MonitorHandleExtIOS {
 impl MonitorHandleExtIOS for MonitorHandle {
     #[inline]
     fn ui_screen(&self) -> *mut c_void {
-        Id::as_ptr(self.inner.ui_screen()) as *mut c_void
+        self.inner.ui_screen() as _
     }
 
     #[inline]
     fn preferred_video_mode(&self) -> VideoMode {
-        VideoMode {
-            video_mode: self.inner.preferred_video_mode(),
-        }
+        self.inner.preferred_video_mode()
     }
 }
 

src/platform/macos.rs

@@ -1,8 +1,9 @@
+#![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},
@@ -37,36 +38,6 @@ pub trait WindowExtMacOS {
 
     /// 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 {
@@ -99,26 +70,6 @@ impl WindowExtMacOS for Window {
     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`.
@@ -160,15 +111,10 @@ 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<f64>) -> 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 {
@@ -211,6 +157,12 @@ impl WindowBuilderExtMacOS for WindowBuilder {
         self
     }
 
+    #[inline]
+    fn with_resize_increments(mut self, increments: LogicalSize<f64>) -> WindowBuilder {
+        self.platform_specific.resize_increments = Some(increments);
+        self
+    }
+
     #[inline]
     fn with_disallow_hidpi(mut self, disallow_hidpi: bool) -> WindowBuilder {
         self.platform_specific.disallow_hidpi = disallow_hidpi;
@@ -222,18 +174,6 @@ impl WindowBuilderExtMacOS for 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
-    }
 }
 
 pub trait EventLoopBuilderExtMacOS {
@@ -280,12 +220,6 @@ pub trait EventLoopBuilderExtMacOS {
     /// # }
     /// ```
     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> {
@@ -300,12 +234,6 @@ impl<T> EventLoopBuilderExtMacOS for EventLoopBuilder<T> {
         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.
@@ -323,7 +251,7 @@ impl MonitorHandleExtMacOS for MonitorHandle {
     }
 
     fn ns_screen(&self) -> Option<*mut c_void> {
-        self.inner.ns_screen().map(|s| Id::as_ptr(&s) as _)
+        self.inner.ns_screen().map(|s| s as *mut c_void)
     }
 }
 
@@ -344,28 +272,3 @@ impl<T> EventLoopWindowTargetExtMacOS for EventLoopWindowTarget<T> {
         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

@@ -15,29 +15,11 @@
 //!
 //! 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;
-#[cfg(orbital_platform)]
-pub mod orbital;
-#[cfg(wayland_platform)]
-pub mod wayland;
-#[cfg(wasm_platform)]
+pub mod unix;
 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

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

src/platform/run_return.rs

@@ -1,3 +1,14 @@
+#![cfg(any(
+    target_os = "windows",
+    target_os = "macos",
+    target_os = "android",
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+
 use crate::{
     event::Event,
     event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},

src/platform/unix.rs

@@ -0,0 +1,464 @@
+#![cfg(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
+
+use std::os::raw;
+#[cfg(feature = "x11")]
+use std::{ptr, sync::Arc};
+
+use crate::{
+    event_loop::{EventLoopBuilder, EventLoopWindowTarget},
+    monitor::MonitorHandle,
+    window::{Window, WindowBuilder},
+};
+
+#[cfg(feature = "x11")]
+use crate::dpi::Size;
+#[cfg(feature = "x11")]
+use crate::platform_impl::{x11::ffi::XVisualInfo, x11::XConnection, XLIB_ERROR_HOOKS};
+use crate::platform_impl::{
+    ApplicationName, Backend, EventLoopWindowTarget as LinuxEventLoopWindowTarget,
+    Window as LinuxWindow,
+};
+
+// TODO: stupid hack so that glutin can do its work
+#[doc(hidden)]
+#[cfg(feature = "x11")]
+pub use crate::platform_impl::x11;
+#[cfg(feature = "x11")]
+pub use crate::platform_impl::{x11::util::WindowType as XWindowType, XNotSupported};
+
+#[cfg(feature = "wayland")]
+pub use crate::window::Theme;
+
+/// 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
+#[cfg(feature = "x11")]
+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`].
+///
+/// [`unsafe`]: https://www.remlab.net/op/xlib.shtml
+#[inline]
+#[cfg(feature = "x11")]
+pub fn register_xlib_error_hook(hook: XlibErrorHook) {
+    // Append new hook.
+    unsafe {
+        XLIB_ERROR_HOOKS.lock().push(hook);
+    }
+}
+
+/// Additional methods on [`EventLoopWindowTarget`] that are specific to Unix.
+pub trait EventLoopWindowTargetExtUnix {
+    /// True if the [`EventLoopWindowTarget`] uses Wayland.
+    #[cfg(feature = "wayland")]
+    fn is_wayland(&self) -> bool;
+
+    /// True if the [`EventLoopWindowTarget`] uses X11.
+    #[cfg(feature = "x11")]
+    fn is_x11(&self) -> bool;
+
+    #[doc(hidden)]
+    #[cfg(feature = "x11")]
+    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.
+    ///
+    /// [`EventLoop`]: crate::event_loop::EventLoop
+    #[cfg(feature = "wayland")]
+    fn wayland_display(&self) -> Option<*mut raw::c_void>;
+}
+
+impl<T> EventLoopWindowTargetExtUnix for EventLoopWindowTarget<T> {
+    #[inline]
+    #[cfg(feature = "wayland")]
+    fn is_wayland(&self) -> bool {
+        self.p.is_wayland()
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn is_x11(&self) -> bool {
+        !self.p.is_wayland()
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn xlib_xconnection(&self) -> Option<Arc<XConnection>> {
+        match self.p {
+            LinuxEventLoopWindowTarget::X(ref e) => Some(e.x_connection().clone()),
+            #[cfg(feature = "wayland")]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "wayland")]
+    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(feature = "x11")]
+            _ => None,
+        }
+    }
+}
+
+/// Additional methods on [`EventLoopBuilder`] that are specific to Unix.
+pub trait EventLoopBuilderExtUnix {
+    /// Force using X11.
+    #[cfg(feature = "x11")]
+    fn with_x11(&mut self) -> &mut Self;
+
+    /// Force using Wayland.
+    #[cfg(feature = "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> EventLoopBuilderExtUnix for EventLoopBuilder<T> {
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn with_x11(&mut self) -> &mut Self {
+        self.platform_specific.forced_backend = Some(Backend::X);
+        self
+    }
+
+    #[inline]
+    #[cfg(feature = "wayland")]
+    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 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).
+    #[cfg(feature = "x11")]
+    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.
+    #[cfg(feature = "x11")]
+    fn xlib_display(&self) -> Option<*mut raw::c_void>;
+
+    #[cfg(feature = "x11")]
+    fn xlib_screen_id(&self) -> Option<raw::c_int>;
+
+    #[doc(hidden)]
+    #[cfg(feature = "x11")]
+    fn xlib_xconnection(&self) -> Option<Arc<XConnection>>;
+
+    /// 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.
+    #[cfg(feature = "x11")]
+    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 [`Window`] is destroyed.
+    #[cfg(feature = "wayland")]
+    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.
+    #[cfg(feature = "wayland")]
+    fn wayland_display(&self) -> Option<*mut raw::c_void>;
+
+    /// Updates [`Theme`] of window decorations.
+    ///
+    /// You can also use `WINIT_WAYLAND_CSD_THEME` env variable to set the theme.
+    /// Possible values for env variable are: "dark" and light"
+    #[cfg(feature = "wayland")]
+    fn wayland_set_csd_theme(&self, config: Theme);
+
+    /// 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]
+    #[cfg(feature = "x11")]
+    fn xlib_window(&self) -> Option<raw::c_ulong> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_window()),
+            #[cfg(feature = "wayland")]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn xlib_display(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_display()),
+            #[cfg(feature = "wayland")]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn xlib_screen_id(&self) -> Option<raw::c_int> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_screen_id()),
+            #[cfg(feature = "wayland")]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn xlib_xconnection(&self) -> Option<Arc<XConnection>> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xlib_xconnection()),
+            #[cfg(feature = "wayland")]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn xcb_connection(&self) -> Option<*mut raw::c_void> {
+        match self.window {
+            LinuxWindow::X(ref w) => Some(w.xcb_connection()),
+            #[cfg(feature = "wayland")]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "wayland")]
+    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(feature = "x11")]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "wayland")]
+    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(feature = "x11")]
+            _ => None,
+        }
+    }
+
+    #[inline]
+    #[cfg(feature = "wayland")]
+    fn wayland_set_csd_theme(&self, theme: Theme) {
+        #[allow(clippy::single_match)]
+        match self.window {
+            LinuxWindow::Wayland(ref w) => w.set_csd_theme(theme),
+            #[cfg(feature = "x11")]
+            _ => (),
+        }
+    }
+
+    #[inline]
+    fn is_ready(&self) -> bool {
+        true
+    }
+}
+
+/// Additional methods on [`WindowBuilder`] that are specific to Unix.
+pub trait WindowBuilderExtUnix {
+    #[cfg(feature = "x11")]
+    fn with_x11_visual<T>(self, visual_infos: *const T) -> Self;
+
+    #[cfg(feature = "x11")]
+    fn with_x11_screen(self, screen_id: i32) -> Self;
+
+    /// Build window with the given `general` and `instance` names.
+    ///
+    /// On Wayland, the `general` name sets an application ID, which should match the `.desktop`
+    /// file destributed with your program. The `instance` is a `no-op`.
+    ///
+    /// On X11, 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.
+    #[cfg(feature = "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.
+    #[cfg(feature = "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.
+    #[cfg(feature = "x11")]
+    fn with_gtk_theme_variant(self, variant: String) -> Self;
+
+    /// Build window with certain decoration [`Theme`]
+    ///
+    /// You can also use `WINIT_WAYLAND_CSD_THEME` env variable to set the theme.
+    /// Possible values for env variable are: "dark" and light"
+    #[cfg(feature = "wayland")]
+    fn with_wayland_csd_theme(self, theme: Theme) -> Self;
+
+    /// Build window with resize increment hint. Only implemented on X11.
+    ///
+    /// ```
+    /// # use winit::dpi::{LogicalSize, PhysicalSize};
+    /// # use winit::window::WindowBuilder;
+    /// # use winit::platform::unix::WindowBuilderExtUnix;
+    /// // Specify the size in logical dimensions like this:
+    /// WindowBuilder::new().with_resize_increments(LogicalSize::new(400.0, 200.0));
+    ///
+    /// // Or specify the size in physical dimensions like this:
+    /// WindowBuilder::new().with_resize_increments(PhysicalSize::new(400, 200));
+    /// ```
+    #[cfg(feature = "x11")]
+    fn with_resize_increments<S: Into<Size>>(self, increments: S) -> Self;
+
+    /// Build window with base size hint. Only implemented on X11.
+    ///
+    /// ```
+    /// # use winit::dpi::{LogicalSize, PhysicalSize};
+    /// # use winit::window::WindowBuilder;
+    /// # use winit::platform::unix::WindowBuilderExtUnix;
+    /// // 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));
+    /// ```
+    #[cfg(feature = "x11")]
+    fn with_base_size<S: Into<Size>>(self, base_size: S) -> Self;
+}
+
+impl WindowBuilderExtUnix for WindowBuilder {
+    #[inline]
+    #[cfg(feature = "x11")]
+    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]
+    #[cfg(feature = "x11")]
+    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]
+    #[cfg(feature = "x11")]
+    fn with_override_redirect(mut self, override_redirect: bool) -> Self {
+        self.platform_specific.override_redirect = override_redirect;
+        self
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn with_x11_window_type(mut self, x11_window_types: Vec<XWindowType>) -> Self {
+        self.platform_specific.x11_window_types = x11_window_types;
+        self
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn with_gtk_theme_variant(mut self, variant: String) -> Self {
+        self.platform_specific.gtk_theme_variant = Some(variant);
+        self
+    }
+
+    #[inline]
+    #[cfg(feature = "wayland")]
+    fn with_wayland_csd_theme(mut self, theme: Theme) -> Self {
+        self.platform_specific.csd_theme = Some(theme);
+        self
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    fn with_resize_increments<S: Into<Size>>(mut self, increments: S) -> Self {
+        self.platform_specific.resize_increments = Some(increments.into());
+        self
+    }
+
+    #[inline]
+    #[cfg(feature = "x11")]
+    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 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

@@ -1,144 +0,0 @@
-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,3 +1,5 @@
+#![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 [`WindowExtWebSys`] trait
 //! to retrieve the canvas from the Window. Alternatively, use the [`WindowBuilderExtWebSys`] trait

src/platform/windows.rs

@@ -1,3 +1,5 @@
+#![cfg(target_os = "windows")]
+
 use std::{ffi::c_void, path::Path};
 
 use crate::{
@@ -5,8 +7,8 @@ use crate::{
     event::DeviceId,
     event_loop::EventLoopBuilder,
     monitor::MonitorHandle,
-    platform_impl::WinIcon,
-    window::{BadIcon, Icon, Window, WindowBuilder},
+    platform_impl::{Parent, WinIcon},
+    window::{BadIcon, Icon, Theme, Window, WindowBuilder},
 };
 
 /// Window Handle type used by Win32 API
@@ -136,6 +138,9 @@ pub trait WindowExtWindows {
     /// This sets `ICON_BIG`. A good ceiling here is 256x256.
     fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>);
 
+    /// Returns the current window theme.
+    fn theme(&self) -> Theme;
+
     /// Whether to show or hide the window icon in the taskbar.
     fn set_skip_taskbar(&self, skip: bool);
 
@@ -166,6 +171,11 @@ impl WindowExtWindows for Window {
         self.window.set_taskbar_icon(taskbar_icon)
     }
 
+    #[inline]
+    fn theme(&self) -> Theme {
+        self.window.theme()
+    }
+
     #[inline]
     fn set_skip_taskbar(&self, skip: bool) {
         self.window.set_skip_taskbar(skip)
@@ -179,8 +189,14 @@ impl WindowExtWindows for Window {
 
 /// Additional methods on `WindowBuilder` that are specific to Windows.
 pub trait WindowBuilderExtWindows {
+    /// Sets a parent to the window to be created.
+    ///
+    /// A child window has the WS_CHILD style and is confined to the client area of its parent window.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#child-windows>
+    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.
     ///
@@ -218,6 +234,9 @@ pub trait WindowBuilderExtWindows {
     /// 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;
 
+    /// Forces a theme or uses the system settings if `None` was provided.
+    fn with_theme(self, theme: Option<Theme>) -> WindowBuilder;
+
     /// Whether show or hide the window icon in the taskbar.
     fn with_skip_taskbar(self, skip: bool) -> WindowBuilder;
 
@@ -229,9 +248,15 @@ pub trait WindowBuilderExtWindows {
 }
 
 impl WindowBuilderExtWindows for WindowBuilder {
+    #[inline]
+    fn with_parent_window(mut self, parent: HWND) -> WindowBuilder {
+        self.platform_specific.parent = Parent::ChildOf(parent);
+        self
+    }
+
     #[inline]
     fn with_owner_window(mut self, parent: HWND) -> WindowBuilder {
-        self.platform_specific.owner = Some(parent);
+        self.platform_specific.parent = Parent::OwnedBy(parent);
         self
     }
 
@@ -259,6 +284,12 @@ impl WindowBuilderExtWindows for WindowBuilder {
         self
     }
 
+    #[inline]
+    fn with_theme(mut self, theme: Option<Theme>) -> WindowBuilder {
+        self.platform_specific.preferred_theme = theme;
+        self
+    }
+
     #[inline]
     fn with_skip_taskbar(mut self, skip: bool) -> WindowBuilder {
         self.platform_specific.skip_taskbar = skip;

src/platform/x11.rs

@@ -1,233 +0,0 @@
-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/ios/app_state.rs

@@ -9,27 +9,21 @@ use std::{
     time::Instant,
 };
 
-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 objc::runtime::{BOOL, YES};
 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, EventProxy, EventWrapper, Never},
-        ffi::NSOperatingSystemVersion,
+        ffi::{
+            id, kCFRunLoopCommonModes, CFAbsoluteTimeGetCurrent, CFRelease, CFRunLoopAddTimer,
+            CFRunLoopGetMain, CFRunLoopRef, CFRunLoopTimerCreate, CFRunLoopTimerInvalidate,
+            CFRunLoopTimerRef, CFRunLoopTimerSetNextFireDate, CGRect, CGSize, NSInteger,
+            NSOperatingSystemVersion, NSUInteger,
+        },
     },
     window::WindowId as RootWindowId,
 };
@@ -68,25 +62,25 @@ impl Event<'static, Never> {
 #[must_use = "dropping `AppStateImpl` without inspecting it is probably a bug"]
 enum AppStateImpl {
     NotLaunched {
-        queued_windows: Vec<Id<WinitUIWindow, Shared>>,
+        queued_windows: Vec<id>,
         queued_events: Vec<EventWrapper>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
+        queued_gpu_redraws: HashSet<id>,
     },
     Launching {
-        queued_windows: Vec<Id<WinitUIWindow, Shared>>,
+        queued_windows: Vec<id>,
         queued_events: Vec<EventWrapper>,
         queued_event_handler: Box<dyn EventHandler>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
+        queued_gpu_redraws: HashSet<id>,
     },
     ProcessingEvents {
         event_handler: Box<dyn EventHandler>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
+        queued_gpu_redraws: HashSet<id>,
         active_control_flow: ControlFlow,
     },
     // special state to deal with reentrancy and prevent mutable aliasing.
     InUserCallback {
         queued_events: Vec<EventWrapper>,
-        queued_gpu_redraws: HashSet<Id<WinitUIWindow, Shared>>,
+        queued_gpu_redraws: HashSet<id>,
     },
     ProcessingRedraws {
         event_handler: Box<dyn EventHandler>,
@@ -109,6 +103,28 @@ 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> {
@@ -204,9 +220,7 @@ impl AppState {
         });
     }
 
-    fn did_finish_launching_transition(
-        &mut self,
-    ) -> (Vec<Id<WinitUIWindow, Shared>>, Vec<EventWrapper>) {
+    fn did_finish_launching_transition(&mut self) -> (Vec<id>, Vec<EventWrapper>) {
         let (windows, events, event_handler, queued_gpu_redraws) = match self.take_state() {
             AppStateImpl::Launching {
                 queued_windows,
@@ -363,7 +377,7 @@ impl AppState {
         }
     }
 
-    fn main_events_cleared_transition(&mut self) -> HashSet<Id<WinitUIWindow, Shared>> {
+    fn main_events_cleared_transition(&mut self) -> HashSet<id> {
         let (event_handler, queued_gpu_redraws, active_control_flow) = match self.take_state() {
             AppStateImpl::ProcessingEvents {
                 event_handler,
@@ -456,13 +470,20 @@ impl AppState {
 
 // requires main thread and window is a UIWindow
 // retains window
-pub(crate) unsafe fn set_key_window(window: &Id<WinitUIWindow, Shared>) {
+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"
+    );
     let mut this = AppState::get_mut();
     match this.state_mut() {
         &mut AppStateImpl::NotLaunched {
             ref mut queued_windows,
             ..
-        } => return queued_windows.push(window.clone()),
+        } => return queued_windows.push(msg_send![window, retain]),
         &mut AppStateImpl::ProcessingEvents { .. }
         | &mut AppStateImpl::InUserCallback { .. }
         | &mut AppStateImpl::ProcessingRedraws { .. } => {}
@@ -474,12 +495,19 @@ pub(crate) unsafe fn set_key_window(window: &Id<WinitUIWindow, Shared>) {
         }
     }
     drop(this);
-    window.makeKeyAndVisible();
+    msg_send![window, makeKeyAndVisible]
 }
 
 // requires main thread and window is a UIWindow
 // retains window
-pub(crate) unsafe fn queue_gl_or_metal_redraw(window: Id<WinitUIWindow, Shared>) {
+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"
+    );
     let mut this = AppState::get_mut();
     match this.state_mut() {
         &mut AppStateImpl::NotLaunched {
@@ -507,6 +535,8 @@ pub(crate) unsafe fn queue_gl_or_metal_redraw(window: Id<WinitUIWindow, Shared>)
             panic!("Attempt to create a `Window` after the app has terminated")
         }
     }
+
+    drop(this);
 }
 
 // requires main thread
@@ -533,25 +563,30 @@ pub unsafe fn did_finish_launching() {
     drop(this);
 
     for window in windows {
-        // 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 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];
     }
 
     let (windows, events) = AppState::get_mut().did_finish_launching_transition();
@@ -565,7 +600,12 @@ pub unsafe fn did_finish_launching() {
     // 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 {
-        window.makeKeyAndVisible();
+        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];
     }
 }
 
@@ -583,12 +623,12 @@ pub unsafe fn handle_wakeup_transition() {
 }
 
 // requires main thread
-pub(crate) unsafe fn handle_nonuser_event(event: EventWrapper) {
+pub unsafe fn handle_nonuser_event(event: EventWrapper) {
     handle_nonuser_events(std::iter::once(event))
 }
 
 // requires main thread
-pub(crate) unsafe fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(events: I) {
+pub 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() {
@@ -766,7 +806,9 @@ pub unsafe fn handle_main_events_cleared() {
     let mut redraw_events: Vec<EventWrapper> = this
         .main_events_cleared_transition()
         .into_iter()
-        .map(|window| EventWrapper::StaticEvent(Event::RedrawRequested(RootWindowId(window.id()))))
+        .map(|window| {
+            EventWrapper::StaticEvent(Event::RedrawRequested(RootWindowId(window.into())))
+        })
         .collect();
 
     redraw_events.push(EventWrapper::StaticEvent(Event::RedrawEventsCleared));
@@ -799,13 +841,13 @@ fn handle_event_proxy(
         EventProxy::DpiChangedProxy {
             suggested_size,
             scale_factor,
-            window,
+            window_id,
         } => handle_hidpi_proxy(
             event_handler,
             control_flow,
             suggested_size,
             scale_factor,
-            window,
+            window_id,
         ),
     }
 }
@@ -815,34 +857,39 @@ fn handle_hidpi_proxy(
     mut control_flow: ControlFlow,
     suggested_size: LogicalSize<f64>,
     scale_factor: f64,
-    window: Id<WinitUIWindow, Shared>,
+    window_id: id,
 ) {
     let mut size = suggested_size.to_physical(scale_factor);
     let new_inner_size = &mut size;
     let event = Event::WindowEvent {
-        window_id: RootWindowId(window.id()),
+        window_id: RootWindowId(window_id.into()),
         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 (view, screen_frame) = get_view_and_screen_frame(window_id);
     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 size = CGSize::new(logical_size);
     let new_frame: CGRect = CGRect::new(screen_frame.origin, size);
-    view.setFrame(new_frame);
+    unsafe {
+        let _: () = msg_send![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)
+fn get_view_and_screen_frame(window_id: id) -> (id, CGRect) {
+    unsafe {
+        let view_controller: id = msg_send![window_id, rootViewController];
+        let view: id = msg_send![view_controller, view];
+        let bounds: CGRect = msg_send![window_id, bounds];
+        let screen: id = msg_send![window_id, screen];
+        let screen_space: id = msg_send![screen, coordinateSpace];
+        let screen_frame: CGRect =
+            msg_send![window_id, convertRect:bounds toCoordinateSpace:screen_space];
+        (view, screen_frame)
+    }
 }
 
 struct EventLoopWaker {
@@ -971,9 +1018,9 @@ impl NSOperatingSystemVersion {
 pub fn os_capabilities() -> OSCapabilities {
     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,
+            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.
@@ -983,8 +1030,11 @@ pub fn os_capabilities() -> OSCapabilities {
             // 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]
+            assert!(
+                atleast_ios_8 == YES,
+                "`winit` requires iOS version 8 or greater"
+            );
+            msg_send![process_info, operatingSystemVersion]
         };
         version.into()
     });

src/platform_impl/ios/event_loop.rs

@@ -3,44 +3,47 @@ use std::{
     ffi::c_void,
     fmt::{self, Debug},
     marker::PhantomData,
-    ptr,
+    mem, 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 objc::runtime::Object;
 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,
     },
+    monitor::MonitorHandle as RootMonitorHandle,
     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, NSStringRust, UIApplicationMain,
+        UIUserInterfaceIdiom,
+    },
+    monitor, view, MonitorHandle,
+};
+
 #[derive(Debug)]
-pub(crate) enum EventWrapper {
+pub enum EventWrapper {
     StaticEvent(Event<'static, Never>),
     EventProxy(EventProxy),
 }
 
 #[derive(Debug, PartialEq)]
-pub(crate) enum EventProxy {
+pub enum EventProxy {
     DpiChangedProxy {
-        window: Id<WinitUIWindow, Shared>,
+        window_id: id,
         suggested_size: LogicalSize<f64>,
         scale_factor: f64,
     },
@@ -53,13 +56,15 @@ pub struct EventLoopWindowTarget<T: 'static> {
 
 impl<T: 'static> EventLoopWindowTarget<T> {
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        monitor::uiscreens(MainThreadMarker::new().unwrap())
+        // guaranteed to be on main thread
+        unsafe { monitor::uiscreens() }
     }
 
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle::new(UIScreen::main(
-            MainThreadMarker::new().unwrap(),
-        )))
+    pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+        // guaranteed to be on main thread
+        let monitor = unsafe { monitor::main_uiscreen() };
+
+        Some(RootMonitorHandle { inner: monitor })
     }
 
     pub fn raw_display_handle(&self) -> RawDisplayHandle {
@@ -76,16 +81,16 @@ pub(crate) struct PlatformSpecificEventLoopAttributes {}
 
 impl<T: 'static> 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();
@@ -109,26 +114,24 @@ impl<T: 'static> EventLoop<T> {
         F: 'static + FnMut(Event<'_, T>, &RootEventLoopWindowTarget<T>, &mut ControlFlow),
     {
         unsafe {
-            let application = UIApplication::shared(MainThreadMarker::new().unwrap());
-            assert!(
-                application.is_none(),
+            let application: *mut Object = msg_send![class!(UIApplication), sharedApplication];
+            assert_eq!(
+                application,
+                ptr::null_mut(),
                 "\
-                `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(),
-                None,
-                Some(&NSString::from_str("WinitApplicationDelegate")),
+                nil,
+                NSStringRust::alloc(nil).init_str("AppDelegate"),
             );
             unreachable!()
         }
@@ -146,9 +149,8 @@ impl<T: 'static> EventLoop<T> {
 // EventLoopExtIOS
 impl<T: 'static> EventLoop<T> {
     pub fn idiom(&self) -> Idiom {
-        UIDevice::current(MainThreadMarker::new().unwrap())
-            .userInterfaceIdiom()
-            .into()
+        // guaranteed to be on main thread
+        unsafe { self::get_idiom() }
     }
 }
 
@@ -178,23 +180,14 @@ impl<T> EventLoopProxy<T> {
     fn new(sender: Sender<T>) -> EventLoopProxy<T> {
         unsafe {
             // just wake up the eventloop
-            extern "C" fn event_loop_proxy_handler(_: *const c_void) {}
+            extern "C" fn event_loop_proxy_handler(_: *mut 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();
-            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,
-            };
+            // 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 source =
                 CFRunLoopSourceCreate(ptr::null_mut(), CFIndex::max_value() - 1, &mut context);
             CFRunLoopAddSource(rl, source, kCFRunLoopCommonModes);
@@ -230,6 +223,7 @@ 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!(),
                 }
             }
@@ -281,7 +275,7 @@ fn setup_control_flow_observers() {
 
         let begin_observer = CFRunLoopObserverCreate(
             ptr::null_mut(),
-            kCFRunLoopAfterWaiting,
+            kCFRunLoopEntry | kCFRunLoopAfterWaiting,
             1, // repeat = true
             CFIndex::min_value(),
             control_flow_begin_handler,
@@ -351,3 +345,10 @@ 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,11 +1,24 @@
 #![allow(non_camel_case_types, non_snake_case, non_upper_case_globals)]
 
-use std::convert::TryInto;
+use std::{convert::TryInto, ffi::CString, ops::BitOr, os::raw::*};
 
-use objc2::encode::{Encode, Encoding};
-use objc2::foundation::{NSInteger, NSUInteger};
+use objc::{runtime::Object, Encode, Encoding};
 
-use crate::platform::ios::{Idiom, ScreenEdge};
+use crate::{
+    dpi::LogicalSize,
+    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;
 
 #[repr(C)]
 #[derive(Clone, Debug)]
@@ -15,15 +28,91 @@ pub struct NSOperatingSystemVersion {
     pub patch: NSInteger,
 }
 
-unsafe impl Encode for NSOperatingSystemVersion {
-    const ENCODING: Encoding = Encoding::Struct(
-        "NSOperatingSystemVersion",
-        &[
-            NSInteger::ENCODING,
-            NSInteger::ENCODING,
-            NSInteger::ENCODING,
-        ],
-    );
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CGPoint {
+    pub x: CGFloat,
+    pub y: CGFloat,
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CGSize {
+    pub width: CGFloat,
+    pub height: CGFloat,
+}
+
+impl CGSize {
+    pub fn new(size: LogicalSize<f64>) -> CGSize {
+        CGSize {
+            width: size.width as _,
+            height: size.height as _,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct CGRect {
+    pub origin: CGPoint,
+    pub size: CGSize,
+}
+
+impl CGRect {
+    pub fn new(origin: CGPoint, size: CGSize) -> CGRect {
+        CGRect { origin, size }
+    }
+}
+
+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, Eq)]
+#[allow(dead_code)]
+#[repr(isize)]
+pub enum UIForceTouchCapability {
+    Unknown = 0,
+    Unavailable,
+    Available,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+#[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,
 }
 
 #[repr(transparent)]
@@ -31,7 +120,9 @@ unsafe impl Encode for NSOperatingSystemVersion {
 pub struct UIUserInterfaceIdiom(NSInteger);
 
 unsafe impl Encode for UIUserInterfaceIdiom {
-    const ENCODING: Encoding = NSInteger::ENCODING;
+    fn encode() -> Encoding {
+        NSInteger::encode()
+    }
 }
 
 impl UIUserInterfaceIdiom {
@@ -66,12 +157,65 @@ impl From<UIUserInterfaceIdiom> for Idiom {
     }
 }
 
+#[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 {
-    const ENCODING: Encoding = NSUInteger::ENCODING;
+    fn encode() -> Encoding {
+        NSUInteger::encode()
+    }
 }
 
 impl From<ScreenEdge> for UIRectEdge {
@@ -91,3 +235,158 @@ impl From<UIRectEdge> for ScreenEdge {
         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)>,
+}
+
+// This is named NSStringRust rather than NSString because the "Debug View Heirarchy" feature of
+// Xcode requires a non-ambiguous reference to NSString for unclear reasons. This makes Xcode happy
+// so please test if you change the name back to NSString.
+pub trait NSStringRust: 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 NSStringRust for id {
+    unsafe fn initWithUTF8String_(self, c_string: *const c_char) -> id {
+        msg_send![self, initWithUTF8String: c_string]
+    }
+
+    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,7 +55,7 @@
 //!
 //! Also note that app may not receive the LoopDestroyed event if suspended; it might be SIGKILL'ed.
 
-#![cfg(ios_platform)]
+#![cfg(target_os = "ios")]
 #![allow(clippy::let_unit_value)]
 
 // TODO: (mtak-) UIKit requires main thread for virtually all function/method calls. This could be
@@ -63,7 +63,8 @@
 // window size/position.
 macro_rules! assert_main_thread {
     ($($t:tt)*) => {
-        if !::objc2::foundation::is_main_thread() {
+        let is_main_thread: ::objc::runtime::BOOL = msg_send!(class!(NSThread), isMainThread);
+        if is_main_thread == ::objc::runtime::NO {
             panic!($($t)*);
         }
     };
@@ -73,7 +74,6 @@ mod app_state;
 mod event_loop;
 mod ffi;
 mod monitor;
-mod uikit;
 mod view;
 mod window;
 
@@ -87,19 +87,17 @@ pub(crate) use self::{
     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: *const UIScreen,
+    uiscreen: ffi::id,
 }
 
 impl DeviceId {
     pub const unsafe fn dummy() -> Self {
         DeviceId {
-            uiscreen: std::ptr::null(),
+            uiscreen: std::ptr::null_mut(),
         }
     }
 }

src/platform_impl/ios/monitor.rs

@@ -1,48 +1,74 @@
-#![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::VideoMode as RootVideoMode,
-    platform_impl::platform::app_state,
+    monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
+    platform_impl::platform::{
+        app_state,
+        ffi::{id, nil, CGFloat, CGRect, CGSize, NSInteger, NSUInteger},
+    },
 };
 
-// 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)]
+#[derive(Debug, PartialEq, Eq, Hash)]
 pub struct VideoMode {
     pub(crate) size: (u32, u32),
     pub(crate) bit_depth: u16,
     pub(crate) refresh_rate_millihertz: u32,
-    pub(crate) screen_mode: ScreenModeSendSync,
+    pub(crate) screen_mode: NativeDisplayMode,
     pub(crate) monitor: MonitorHandle,
 }
 
+#[derive(Debug, PartialEq, Eq, Hash)]
+pub struct NativeDisplayMode(pub id);
+
+unsafe impl Send for NativeDisplayMode {}
+
+impl Drop for NativeDisplayMode {
+    fn drop(&mut self) {
+        unsafe {
+            let _: () = msg_send![self.0, release];
+        }
+    }
+}
+
+impl Clone for NativeDisplayMode {
+    fn clone(&self) -> Self {
+        unsafe {
+            let _: id = msg_send![self.0, retain];
+        }
+        NativeDisplayMode(self.0)
+    }
+}
+
+impl Clone for VideoMode {
+    fn clone(&self) -> VideoMode {
+        VideoMode {
+            size: self.size,
+            bit_depth: self.bit_depth,
+            refresh_rate_millihertz: self.refresh_rate_millihertz,
+            screen_mode: self.screen_mode.clone(),
+            monitor: self.monitor.clone(),
+        }
+    }
+}
+
 impl VideoMode {
-    fn new(uiscreen: Id<UIScreen, Shared>, screen_mode: Id<UIScreenMode, Shared>) -> VideoMode {
+    unsafe fn retained_new(uiscreen: id, screen_mode: id) -> 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();
+        let refresh_rate_millihertz = refresh_rate_millihertz(uiscreen);
+        let size: CGSize = msg_send![screen_mode, size];
+        let screen_mode: id = msg_send![screen_mode, retain];
+        let screen_mode = NativeDisplayMode(screen_mode);
         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),
+            screen_mode,
+            monitor: MonitorHandle::retained_new(uiscreen),
         }
     }
 
@@ -58,46 +84,51 @@ impl VideoMode {
         self.refresh_rate_millihertz
     }
 
-    pub fn monitor(&self) -> MonitorHandle {
-        self.monitor.clone()
+    pub fn monitor(&self) -> RootMonitorHandle {
+        RootMonitorHandle {
+            inner: self.monitor.clone(),
+        }
     }
 }
 
-#[derive(Clone, PartialEq, Eq, Hash)]
+#[derive(PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Inner {
-    uiscreen: Id<UIScreen, Shared>,
+    uiscreen: id,
 }
 
-#[derive(Clone, PartialEq, Eq, Hash)]
+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 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");
+        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 {
-        assert_main_thread!("`MonitorHandle` methods can only be run on the main thread on iOS");
+        unsafe {
+            assert_main_thread!(
+                "`MonitorHandle` methods can only be run on the main thread on iOS"
+            );
+        }
         &mut self.inner
     }
 }
@@ -105,9 +136,17 @@ impl DerefMut for MonitorHandle {
 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) {
-        assert_main_thread!("`MonitorHandle` can only be dropped on the main thread on iOS");
+        unsafe {
+            assert_main_thread!("`MonitorHandle` can only be dropped on the main thread on iOS");
+        }
     }
 }
 
@@ -135,9 +174,12 @@ impl fmt::Debug for MonitorHandle {
 }
 
 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 {
+    pub fn retained_new(uiscreen: id) -> MonitorHandle {
+        unsafe {
+            assert_main_thread!("`MonitorHandle` can only be cloned on the main thread on iOS");
+            let _: id = msg_send![uiscreen, retain];
+        }
+        MonitorHandle {
             inner: Inner { uiscreen },
         }
     }
@@ -145,62 +187,69 @@ impl MonitorHandle {
 
 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())
+        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<u32> {
-        let bounds = self.uiscreen.nativeBounds();
-        PhysicalSize::new(bounds.size.width as u32, bounds.size.height as u32)
+        unsafe {
+            let bounds: CGRect = msg_send![self.ui_screen(), 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()
+        unsafe {
+            let bounds: CGRect = msg_send![self.ui_screen(), nativeBounds];
+            (bounds.origin.x as f64, bounds.origin.y as f64).into()
+        }
     }
 
     pub fn scale_factor(&self) -> f64 {
-        self.uiscreen.nativeScale() as f64
+        unsafe {
+            let scale: CGFloat = msg_send![self.ui_screen(), nativeScale];
+            scale as f64
+        }
     }
 
     pub fn refresh_rate_millihertz(&self) -> Option<u32> {
-        Some(refresh_rate_millihertz(&self.uiscreen))
+        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() };
+    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];
 
-                RootVideoMode {
-                    video_mode: VideoMode::new(self.uiscreen.clone(), mode),
-                }
-            })
-            .collect();
+            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().map(|mode| mode.video_mode)
+        modes.into_iter()
     }
 }
 
-fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
-    let refresh_rate_millihertz: NSInteger = {
+fn refresh_rate_millihertz(uiscreen: id) -> u32 {
+    let refresh_rate_millihertz: NSInteger = unsafe {
         let os_capabilities = app_state::os_capabilities();
         if os_capabilities.maximum_frames_per_second {
-            uiscreen.maximumFramesPerSecond()
+            msg_send![uiscreen, maximumFramesPerSecond]
         } else {
             // https://developer.apple.com/library/archive/technotes/tn2460/_index.html
             // https://en.wikipedia.org/wiki/IPad_Pro#Model_comparison
@@ -222,25 +271,43 @@ fn refresh_rate_millihertz(uiscreen: &UIScreen) -> u32 {
 
 // MonitorHandleExtIOS
 impl Inner {
-    pub(crate) fn ui_screen(&self) -> &Id<UIScreen, Shared> {
-        &self.uiscreen
+    pub fn ui_screen(&self) -> id {
+        self.uiscreen
     }
 
-    pub fn preferred_video_mode(&self) -> VideoMode {
-        VideoMode::new(
-            self.uiscreen.clone(),
-            self.uiscreen.preferredMode().unwrap(),
-        )
+    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 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()
+// 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));
+    }
 }

src/platform_impl/ios/uikit/application.rs

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

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

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

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

@@ -1,44 +0,0 @@
-#![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

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

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

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

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

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

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

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

@@ -1,35 +0,0 @@
-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,55 +1,64 @@
-#![allow(clippy::unnecessary_cast)]
-
 use std::{
     collections::VecDeque,
-    ffi::c_void,
     ops::{Deref, DerefMut},
 };
 
-use objc2::foundation::{CGFloat, CGPoint, CGRect, CGSize, MainThreadMarker};
-use objc2::rc::{Id, Shared};
-use objc2::runtime::Object;
-use objc2::{class, msg_send};
+use objc::runtime::{Class, Object, BOOL, NO, YES};
 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, PhysicalPosition, PhysicalSize, Position, Size},
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
     event::{Event, WindowEvent},
     icon::Icon,
-    platform::ios::{ScreenEdge, ValidOrientations},
+    monitor::MonitorHandle as RootMonitorHandle,
+    platform::ios::{MonitorHandleExtIOS, ScreenEdge, ValidOrientations},
     platform_impl::platform::{
         app_state,
-        event_loop::{EventProxy, EventWrapper},
-        ffi::UIRectEdge,
-        monitor, EventLoopWindowTarget, Fullscreen, MonitorHandle,
+        event_loop::{self, EventProxy, EventWrapper},
+        ffi::{
+            id, CGFloat, CGPoint, CGRect, CGSize, UIEdgeInsets, UIInterfaceOrientationMask,
+            UIRectEdge, UIScreenOverscanCompensation,
+        },
+        monitor, view, EventLoopWindowTarget, MonitorHandle,
     },
     window::{
-        CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-        WindowAttributes, WindowButtons, WindowId as RootWindowId, WindowLevel,
+        CursorGrabMode, CursorIcon, Fullscreen, UserAttentionType, WindowAttributes,
+        WindowId as RootWindowId,
     },
 };
 
 pub struct Inner {
-    pub(crate) window: Id<WinitUIWindow, Shared>,
-    pub(crate) view_controller: Id<WinitViewController, Shared>,
-    pub(crate) view: Id<WinitView, Shared>,
+    pub window: id,
+    pub view_controller: id,
+    pub view: id,
     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) {
-        self.window.setHidden(!visible)
+        match visible {
+            true => unsafe {
+                let _: () = msg_send![self.window, setHidden: NO];
+            },
+            false => unsafe {
+                let _: () = msg_send![self.window, setHidden: YES];
+            },
+        }
     }
 
     pub fn is_visible(&self) -> Option<bool> {
@@ -68,9 +77,9 @@ impl Inner {
                 // testing.
                 //
                 // https://developer.apple.com/documentation/uikit/uiview/1622437-setneedsdisplay?language=objc
-                app_state::queue_gl_or_metal_redraw(self.window.clone());
+                app_state::queue_gl_or_metal_redraw(self.window);
             } else {
-                self.view.setNeedsDisplay();
+                let _: () = msg_send![self.view, setNeedsDisplay];
             }
         }
     }
@@ -112,7 +121,7 @@ impl Inner {
                 size: screen_frame.size,
             };
             let bounds = self.rect_from_screen_space(new_screen_frame);
-            self.window.setBounds(bounds);
+            let _: () = msg_send![self.window, setBounds: bounds];
         }
     }
 
@@ -152,15 +161,6 @@ impl Inner {
         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")
     }
@@ -170,19 +170,11 @@ impl Inner {
         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 _
+        unsafe {
+            let hidpi: CGFloat = msg_send![self.view, contentScaleFactor];
+            hidpi as _
+        }
     }
 
     pub fn set_cursor_icon(&self, _cursor: CursorIcon) {
@@ -205,10 +197,6 @@ impl Inner {
         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()))
     }
@@ -217,11 +205,6 @@ impl Inner {
         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")
     }
@@ -231,42 +214,49 @@ impl Inner {
         false
     }
 
-    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;
-            }
-        };
+    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.0];
+                    uiscreen
+                }
+                Some(Fullscreen::Borderless(monitor)) => monitor
+                    .unwrap_or_else(|| self.current_monitor_inner())
+                    .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 = self.window.screen();
-        if uiscreen != current {
-            self.window.setScreen(&uiscreen);
+            // 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
+            ];
         }
-
-        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> {
+    pub fn fullscreen(&self) -> Option<Fullscreen> {
         unsafe {
             let monitor = self.current_monitor_inner();
-            let uiscreen = monitor.ui_screen();
+            let uiscreen = monitor.inner.ui_screen();
             let screen_space_bounds = self.screen_frame();
-            let screen_bounds = uiscreen.bounds();
+            let screen_bounds: CGRect = msg_send![uiscreen, bounds];
 
             // TODO: track fullscreen instead of relying on brittle float comparisons
             if screen_space_bounds.origin.x == screen_bounds.origin.x
@@ -281,14 +271,17 @@ impl Inner {
         }
     }
 
-    pub fn set_decorations(&self, _decorations: bool) {}
+    pub fn set_decorations(&self, _decorations: bool) {
+        warn!("`Window::set_decorations` is ignored on iOS")
+    }
 
     pub fn is_decorated(&self) -> bool {
+        warn!("`Window::is_decorated` is ignored on iOS");
         true
     }
 
-    pub fn set_window_level(&self, _level: WindowLevel) {
-        warn!("`Window::set_window_level` is ignored on iOS")
+    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_icon(&self, _icon: Option<Icon>) {
@@ -303,10 +296,6 @@ impl Inner {
         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")
     }
@@ -316,58 +305,43 @@ impl Inner {
     }
 
     // Allow directly accessing the current monitor internally without unwrapping.
-    fn current_monitor_inner(&self) -> MonitorHandle {
-        MonitorHandle::new(self.window.screen())
+    fn current_monitor_inner(&self) -> RootMonitorHandle {
+        unsafe {
+            let uiscreen: id = msg_send![self.window, screen];
+            RootMonitorHandle {
+                inner: MonitorHandle::retained_new(uiscreen),
+            }
+        }
     }
 
-    pub fn current_monitor(&self) -> Option<MonitorHandle> {
+    pub fn current_monitor(&self) -> Option<RootMonitorHandle> {
         Some(self.current_monitor_inner())
     }
 
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
-        monitor::uiscreens(MainThreadMarker::new().unwrap())
+        unsafe { monitor::uiscreens() }
     }
 
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
-        Some(MonitorHandle::new(UIScreen::main(
-            MainThreadMarker::new().unwrap(),
-        )))
+    pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
+        let monitor = unsafe { monitor::main_uiscreen() };
+        Some(RootMonitorHandle { inner: monitor })
     }
 
     pub fn id(&self) -> WindowId {
-        self.window.id()
+        self.window.into()
     }
 
     pub fn raw_window_handle(&self) -> RawWindowHandle {
         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 _;
+        window_handle.ui_window = self.window as _;
+        window_handle.ui_view = self.view as _;
+        window_handle.ui_view_controller = 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()
-    }
 }
 
 pub struct Window {
@@ -376,7 +350,9 @@ pub struct Window {
 
 impl Drop for Window {
     fn drop(&mut self) {
-        assert_main_thread!("`Window::drop` can only be run on the main thread on iOS");
+        unsafe {
+            assert_main_thread!("`Window::drop` can only be run on the main thread on iOS");
+        }
     }
 }
 
@@ -387,14 +363,18 @@ impl Deref for Window {
     type Target = Inner;
 
     fn deref(&self) -> &Inner {
-        assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
+        unsafe {
+            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 {
-        assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
+        unsafe {
+            assert_main_thread!("`Window` methods can only be run on the main thread on iOS");
+        }
         &mut self.inner
     }
 }
@@ -405,174 +385,210 @@ impl Window {
         window_attributes: WindowAttributes,
         platform_attributes: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Window, RootOsError> {
-        let mtm = MainThreadMarker::new().unwrap();
-
         if window_attributes.min_inner_size.is_some() {
             warn!("`WindowAttributes::min_inner_size` is ignored on iOS");
         }
         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
 
-        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 = screen.bounds();
-
-        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: size.width as _,
-                        height: size.height as _,
-                    },
+        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(Some(ref monitor))) => monitor.inner.ui_screen(),
+                Some(Fullscreen::Borderless(None)) | None => {
+                    monitor::main_uiscreen().ui_screen() as id
                 }
-            }
-            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 window_id = RootWindowId(window.id());
-            unsafe {
+
+            let screen_bounds: CGRect = msg_send![screen, bounds];
+
+            let frame = match window_attributes.inner_size {
+                Some(dim) => {
+                    let scale_factor: CGFloat = msg_send![screen, scale];
+                    let size = dim.to_logical::<f64>(scale_factor as f64);
+                    CGRect {
+                        origin: screen_bounds.origin,
+                        size: CGSize {
+                            width: size.width as _,
+                            height: size.height as _,
+                        },
+                    }
+                }
+                None => screen_bounds,
+            };
+
+            let view = view::create_view(&window_attributes, &platform_attributes, frame);
+
+            let gl_or_metal_backed = {
+                let view_class: *const Class = msg_send![view, class];
+                let layer_class: *const Class = 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 `ScaleFactorChanged` and `Resized`
+            // event on window creation if the DPI factor != 1.0
+            let scale_factor: CGFloat = msg_send![view, contentScaleFactor];
+            let scale_factor = scale_factor as f64;
+            if scale_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 _,
+                };
                 app_state::handle_nonuser_events(
                     std::iter::once(EventWrapper::EventProxy(EventProxy::DpiChangedProxy {
-                        window: window.clone(),
+                        window_id: window,
                         scale_factor,
                         suggested_size: size,
                     }))
                     .chain(std::iter::once(EventWrapper::StaticEvent(
                         Event::WindowEvent {
-                            window_id,
+                            window_id: RootWindowId(window.into()),
                             event: WindowEvent::Resized(size.to_physical(scale_factor)),
                         },
                     ))),
                 );
             }
-        }
 
-        Ok(Window {
-            inner: Inner {
-                window,
-                view_controller,
-                view,
-                gl_or_metal_backed,
-            },
-        })
+            Ok(result)
+        }
     }
 }
 
 // WindowExtIOS
 impl Inner {
-    pub fn ui_window(&self) -> *mut c_void {
-        Id::as_ptr(&self.window) as *mut c_void
+    pub fn ui_window(&self) -> id {
+        self.window
     }
-    pub fn ui_view_controller(&self) -> *mut c_void {
-        Id::as_ptr(&self.view_controller) as *mut c_void
+    pub fn ui_view_controller(&self) -> id {
+        self.view_controller
     }
-    pub fn ui_view(&self) -> *mut c_void {
-        Id::as_ptr(&self.view) as *mut c_void
+    pub fn ui_view(&self) -> id {
+        self.view
     }
 
     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);
+        unsafe {
+            assert!(
+                dpi::validate_scale_factor(scale_factor),
+                "`WindowExtIOS::set_scale_factor` received an invalid hidpi factor"
+            );
+            let scale_factor = scale_factor as CGFloat;
+            let _: () = msg_send![self.view, setContentScaleFactor: scale_factor];
+        }
     }
 
     pub fn set_valid_orientations(&self, valid_orientations: ValidOrientations) {
-        self.view_controller.set_supported_interface_orientations(
-            MainThreadMarker::new().unwrap(),
-            valid_orientations,
-        );
+        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
+            ]
+        }
     }
 
     pub fn set_prefers_home_indicator_hidden(&self, hidden: bool) {
-        self.view_controller
-            .setPrefersHomeIndicatorAutoHidden(hidden);
+        unsafe {
+            let prefers_home_indicator_hidden = if hidden { YES } else { NO };
+            let _: () = msg_send![
+                self.view_controller,
+                setPrefersHomeIndicatorAutoHidden: prefers_home_indicator_hidden
+            ];
+        }
     }
 
     pub fn set_preferred_screen_edges_deferring_system_gestures(&self, edges: ScreenEdge) {
         let edges: UIRectEdge = edges.into();
-        self.view_controller
-            .setPreferredScreenEdgesDeferringSystemGestures(edges);
+        unsafe {
+            let _: () = msg_send![
+                self.view_controller,
+                setPreferredScreenEdgesDeferringSystemGestures: edges
+            ];
+        }
     }
 
     pub fn set_prefers_status_bar_hidden(&self, hidden: bool) {
-        self.view_controller.setPrefersStatusBarHidden(hidden);
+        unsafe {
+            let status_bar_hidden = if hidden { YES } else { NO };
+            let _: () = msg_send![
+                self.view_controller,
+                setPrefersStatusBarHidden: status_bar_hidden
+            ];
+        }
     }
 }
 
 impl Inner {
     // requires main thread
     unsafe fn screen_frame(&self) -> CGRect {
-        self.rect_to_screen_space(self.window.bounds())
+        self.rect_to_screen_space(msg_send![self.window, bounds])
     }
 
     // requires main thread
     unsafe fn rect_to_screen_space(&self, rect: CGRect) -> CGRect {
-        let screen_space = self.window.screen().coordinateSpace();
-        self.window
-            .convertRect_toCoordinateSpace(rect, &screen_space)
+        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
+        }
     }
 
     // requires main thread
     unsafe fn rect_from_screen_space(&self, rect: CGRect) -> CGRect {
-        let screen_space = self.window.screen().coordinateSpace();
-        self.window
-            .convertRect_fromCoordinateSpace(rect, &screen_space)
+        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
+        }
     }
 
     // requires main thread
     unsafe fn safe_area_screen_space(&self) -> CGRect {
-        let bounds = self.window.bounds();
+        let bounds: CGRect = msg_send![self.window, bounds];
         if app_state::os_capabilities().safe_area {
-            let safe_area = self.window.safeAreaInsets();
+            let safe_area: UIEdgeInsets = msg_send![self.window, safeAreaInsets];
             let safe_bounds = CGRect {
                 origin: CGPoint {
                     x: bounds.origin.x + safe_area.left,
@@ -586,11 +602,13 @@ impl Inner {
             self.rect_to_screen_space(safe_bounds)
         } else {
             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",
+            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"
                 );
-                app.statusBarFrame()
+                msg_send![app, statusBarFrame]
             };
             let (y, height) = if screen_frame.origin.y > status_bar_frame.size.height {
                 (screen_frame.origin.y, screen_frame.size.height)
@@ -616,7 +634,7 @@ impl Inner {
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct WindowId {
-    window: *mut WinitUIWindow,
+    window: id,
 }
 
 impl WindowId {
@@ -652,11 +670,39 @@ impl From<&Object> for WindowId {
     }
 }
 
-#[derive(Clone, Default)]
+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)]
 pub struct PlatformSpecificWindowBuilderAttributes {
+    pub root_view_class: &'static Class,
     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),
+            scale_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/mod.rs

@@ -1,30 +1,35 @@
-#![cfg(free_unix)]
+#![cfg(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 
-#[cfg(all(not(x11_platform), not(wayland_platform)))]
+#[cfg(all(not(feature = "x11"), not(feature = "wayland")))]
 compile_error!("Please select a feature to build for unix: `x11`, `wayland`");
 
-#[cfg(wayland_platform)]
+#[cfg(feature = "wayland")]
 use std::error::Error;
 
 use std::{collections::VecDeque, env, fmt};
-#[cfg(x11_platform)]
-use std::{
-    ffi::CStr,
-    mem::MaybeUninit,
-    os::raw::*,
-    sync::{Arc, Mutex},
-};
+#[cfg(feature = "x11")]
+use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Arc};
 
-#[cfg(x11_platform)]
+#[cfg(feature = "x11")]
 use once_cell::sync::Lazy;
+#[cfg(feature = "x11")]
+use parking_lot::Mutex;
 use raw_window_handle::{RawDisplayHandle, RawWindowHandle};
 
-#[cfg(x11_platform)]
+#[cfg(feature = "x11")]
 pub use self::x11::XNotSupported;
-#[cfg(x11_platform)]
+#[cfg(feature = "x11")]
 use self::x11::{ffi::XVisualInfo, util::WindowType as XWindowType, XConnection, XError};
-#[cfg(x11_platform)]
-use crate::platform::x11::XlibErrorHook;
+#[cfg(feature = "x11")]
+use crate::platform::unix::XlibErrorHook;
+#[cfg(feature = "wayland")]
+use crate::window::Theme;
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize, Position, Size},
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
@@ -33,18 +38,15 @@ use crate::{
         ControlFlow, DeviceEventFilter, EventLoopClosed, EventLoopWindowTarget as RootELW,
     },
     icon::Icon,
-    window::{
-        CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-        WindowAttributes, WindowButtons, WindowLevel,
-    },
+    monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
+    window::{CursorGrabMode, CursorIcon, Fullscreen, UserAttentionType, WindowAttributes},
 };
 
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
-pub(self) use crate::platform_impl::Fullscreen;
 
-#[cfg(wayland_platform)]
+#[cfg(feature = "wayland")]
 pub mod wayland;
-#[cfg(x11_platform)]
+#[cfg(feature = "x11")]
 pub mod x11;
 
 /// Environment variable specifying which backend should be used on unix platform.
@@ -58,9 +60,9 @@ const BACKEND_PREFERENCE_ENV_VAR: &str = "WINIT_UNIX_BACKEND";
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) enum Backend {
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     X,
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     Wayland,
 }
 
@@ -85,67 +87,79 @@ impl ApplicationName {
 #[derive(Clone)]
 pub struct PlatformSpecificWindowBuilderAttributes {
     pub name: Option<ApplicationName>,
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub visual_infos: Option<XVisualInfo>,
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub screen_id: Option<i32>,
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
+    pub resize_increments: Option<Size>,
+    #[cfg(feature = "x11")]
     pub base_size: Option<Size>,
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub override_redirect: bool,
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     pub x11_window_types: Vec<XWindowType>,
+    #[cfg(feature = "x11")]
+    pub gtk_theme_variant: Option<String>,
+    #[cfg(feature = "wayland")]
+    pub csd_theme: Option<Theme>,
 }
 
 impl Default for PlatformSpecificWindowBuilderAttributes {
     fn default() -> Self {
         Self {
             name: None,
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             visual_infos: None,
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             screen_id: None,
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
+            resize_increments: None,
+            #[cfg(feature = "x11")]
             base_size: None,
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             override_redirect: false,
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             x11_window_types: vec![XWindowType::Normal],
+            #[cfg(feature = "x11")]
+            gtk_theme_variant: None,
+            #[cfg(feature = "wayland")]
+            csd_theme: None,
         }
     }
 }
 
-#[cfg(x11_platform)]
-pub(crate) static X11_BACKEND: Lazy<Mutex<Result<Arc<XConnection>, XNotSupported>>> =
+#[cfg(feature = "x11")]
+pub static X11_BACKEND: Lazy<Mutex<Result<Arc<XConnection>, XNotSupported>>> =
     Lazy::new(|| Mutex::new(XConnection::new(Some(x_error_callback)).map(Arc::new)));
 
 #[derive(Debug, Clone)]
 pub enum OsError {
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     XError(XError),
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     XMisc(&'static str),
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     WaylandMisc(&'static str),
 }
 
 impl fmt::Display for OsError {
     fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         match *self {
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             OsError::XError(ref e) => _f.pad(&e.description),
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             OsError::XMisc(e) => _f.pad(e),
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             OsError::WaylandMisc(e) => _f.pad(e),
         }
     }
 }
 
-pub(crate) enum Window {
-    #[cfg(x11_platform)]
+pub enum Window {
+    #[cfg(feature = "x11")]
     X(x11::Window),
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     Wayland(wayland::Window),
 }
 
@@ -172,26 +186,26 @@ impl WindowId {
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum DeviceId {
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     X(x11::DeviceId),
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     Wayland(wayland::DeviceId),
 }
 
 impl DeviceId {
     pub const unsafe fn dummy() -> Self {
-        #[cfg(wayland_platform)]
+        #[cfg(feature = "wayland")]
         return DeviceId::Wayland(wayland::DeviceId::dummy());
-        #[cfg(all(not(wayland_platform), x11_platform))]
+        #[cfg(all(not(feature = "wayland"), feature = "x11"))]
         return DeviceId::X(x11::DeviceId::dummy());
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum MonitorHandle {
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     X(x11::MonitorHandle),
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     Wayland(wayland::MonitorHandle),
 }
 
@@ -207,17 +221,17 @@ pub enum MonitorHandle {
 macro_rules! x11_or_wayland {
     (match $what:expr; $enum:ident ( $($c1:tt)* ) => $x:expr; as $enum2:ident ) => {
         match $what {
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             $enum::X($($c1)*) => $enum2::X($x),
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             $enum::Wayland($($c1)*) => $enum2::Wayland($x),
         }
     };
     (match $what:expr; $enum:ident ( $($c1:tt)* ) => $x:expr) => {
         match $what {
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             $enum::X($($c1)*) => $x,
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             $enum::Wayland($($c1)*) => $x,
         }
     };
@@ -251,20 +265,20 @@ impl MonitorHandle {
 
     #[inline]
     pub fn scale_factor(&self) -> f64 {
-        x11_or_wayland!(match self; MonitorHandle(m) => m.scale_factor() as _)
+        x11_or_wayland!(match self; MonitorHandle(m) => m.scale_factor() as f64)
     }
 
     #[inline]
-    pub fn video_modes(&self) -> Box<dyn Iterator<Item = VideoMode>> {
+    pub fn video_modes(&self) -> Box<dyn Iterator<Item = RootVideoMode>> {
         x11_or_wayland!(match self; MonitorHandle(m) => Box::new(m.video_modes()))
     }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum VideoMode {
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     X(x11::VideoMode),
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     Wayland(wayland::VideoMode),
 }
 
@@ -285,7 +299,7 @@ impl VideoMode {
     }
 
     #[inline]
-    pub fn monitor(&self) -> MonitorHandle {
+    pub fn monitor(&self) -> RootMonitorHandle {
         x11_or_wayland!(match self; VideoMode(m) => m.monitor())
     }
 }
@@ -298,11 +312,11 @@ impl Window {
         pl_attribs: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Self, RootOsError> {
         match *window_target {
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             EventLoopWindowTarget::Wayland(ref window_target) => {
                 wayland::Window::new(window_target, attribs, pl_attribs).map(Window::Wayland)
             }
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             EventLoopWindowTarget::X(ref window_target) => {
                 x11::Window::new(window_target, attribs, pl_attribs).map(Window::X)
             }
@@ -312,9 +326,9 @@ impl Window {
     #[inline]
     pub fn id(&self) -> WindowId {
         match self {
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             Self::Wayland(window) => window.id(),
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             Self::X(window) => window.id(),
         }
     }
@@ -324,11 +338,6 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.set_title(title));
     }
 
-    #[inline]
-    pub fn set_transparent(&self, transparent: bool) {
-        x11_or_wayland!(match self; Window(w) => w.set_transparent(transparent));
-    }
-
     #[inline]
     pub fn set_visible(&self, visible: bool) {
         x11_or_wayland!(match self; Window(w) => w.set_visible(visible))
@@ -379,16 +388,6 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.set_max_inner_size(dimensions))
     }
 
-    #[inline]
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
-        x11_or_wayland!(match self; Window(w) => w.resize_increments())
-    }
-
-    #[inline]
-    pub fn set_resize_increments(&self, increments: Option<Size>) {
-        x11_or_wayland!(match self; Window(w) => w.set_resize_increments(increments))
-    }
-
     #[inline]
     pub fn set_resizable(&self, resizable: bool) {
         x11_or_wayland!(match self; Window(w) => w.set_resizable(resizable))
@@ -399,16 +398,6 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.is_resizable())
     }
 
-    #[inline]
-    pub fn set_enabled_buttons(&self, buttons: WindowButtons) {
-        x11_or_wayland!(match self; Window(w) => w.set_enabled_buttons(buttons))
-    }
-
-    #[inline]
-    pub fn enabled_buttons(&self) -> WindowButtons {
-        x11_or_wayland!(match self; Window(w) => w.enabled_buttons())
-    }
-
     #[inline]
     pub fn set_cursor_icon(&self, cursor: CursorIcon) {
         x11_or_wayland!(match self; Window(w) => w.set_cursor_icon(cursor))
@@ -429,11 +418,6 @@ impl Window {
         x11_or_wayland!(match self; Window(window) => window.drag_window())
     }
 
-    #[inline]
-    pub fn drag_resize_window(&self, direction: ResizeDirection) -> Result<(), ExternalError> {
-        x11_or_wayland!(match self; Window(window) => window.drag_resize_window(direction))
-    }
-
     #[inline]
     pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
         x11_or_wayland!(match self; Window(w) => w.set_cursor_hittest(hittest))
@@ -441,7 +425,7 @@ impl Window {
 
     #[inline]
     pub fn scale_factor(&self) -> f64 {
-        x11_or_wayland!(match self; Window(w) => w.scale_factor())
+        x11_or_wayland!(match self; Window(w) => w.scale_factor() as f64)
     }
 
     #[inline]
@@ -465,17 +449,12 @@ impl Window {
     }
 
     #[inline]
-    pub fn is_minimized(&self) -> Option<bool> {
-        x11_or_wayland!(match self; Window(w) => w.is_minimized())
-    }
-
-    #[inline]
-    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
+    pub fn fullscreen(&self) -> Option<Fullscreen> {
         x11_or_wayland!(match self; Window(w) => w.fullscreen())
     }
 
     #[inline]
-    pub(crate) fn set_fullscreen(&self, monitor: Option<Fullscreen>) {
+    pub fn set_fullscreen(&self, monitor: Option<Fullscreen>) {
         x11_or_wayland!(match self; Window(w) => w.set_fullscreen(monitor))
     }
 
@@ -490,11 +469,11 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_window_level(&self, _level: WindowLevel) {
+    pub fn set_always_on_top(&self, _always_on_top: bool) {
         match self {
-            #[cfg(x11_platform)]
-            Window::X(ref w) => w.set_window_level(_level),
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "x11")]
+            Window::X(ref w) => w.set_always_on_top(_always_on_top),
+            #[cfg(feature = "wayland")]
             Window::Wayland(_) => (),
         }
     }
@@ -502,9 +481,9 @@ impl Window {
     #[inline]
     pub fn set_window_icon(&self, _window_icon: Option<Icon>) {
         match self {
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             Window::X(ref w) => w.set_window_icon(_window_icon),
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             Window::Wayland(_) => (),
         }
     }
@@ -519,25 +498,20 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.set_ime_allowed(allowed))
     }
 
-    #[inline]
-    pub fn set_ime_purpose(&self, purpose: ImePurpose) {
-        x11_or_wayland!(match self; Window(w) => w.set_ime_purpose(purpose))
-    }
-
     #[inline]
     pub fn focus_window(&self) {
         match self {
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             Window::X(ref w) => w.focus_window(),
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             Window::Wayland(_) => (),
         }
     }
     pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
         match self {
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             Window::X(ref w) => w.request_user_attention(request_type),
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             Window::Wayland(ref w) => w.request_user_attention(request_type),
         }
     }
@@ -548,17 +522,21 @@ impl Window {
     }
 
     #[inline]
-    pub fn current_monitor(&self) -> Option<MonitorHandle> {
+    pub fn current_monitor(&self) -> Option<RootMonitorHandle> {
         match self {
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             Window::X(ref window) => {
                 let current_monitor = MonitorHandle::X(window.current_monitor());
-                Some(current_monitor)
+                Some(RootMonitorHandle {
+                    inner: current_monitor,
+                })
             }
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             Window::Wayland(ref window) => {
                 let current_monitor = MonitorHandle::Wayland(window.current_monitor()?);
-                Some(current_monitor)
+                Some(RootMonitorHandle {
+                    inner: current_monitor,
+                })
             }
         }
     }
@@ -566,13 +544,13 @@ impl Window {
     #[inline]
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
         match self {
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             Window::X(ref window) => window
                 .available_monitors()
                 .into_iter()
                 .map(MonitorHandle::X)
                 .collect(),
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             Window::Wayland(ref window) => window
                 .available_monitors()
                 .into_iter()
@@ -582,14 +560,16 @@ impl Window {
     }
 
     #[inline]
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+    pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
         match self {
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             Window::X(ref window) => {
                 let primary_monitor = MonitorHandle::X(window.primary_monitor());
-                Some(primary_monitor)
+                Some(RootMonitorHandle {
+                    inner: primary_monitor,
+                })
             }
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             Window::Wayland(ref window) => window.primary_monitor(),
         }
     }
@@ -603,42 +583,23 @@ impl Window {
     pub fn raw_display_handle(&self) -> RawDisplayHandle {
         x11_or_wayland!(match self; Window(window) => window.raw_display_handle())
     }
-
-    #[inline]
-    pub fn set_theme(&self, theme: Option<Theme>) {
-        x11_or_wayland!(match self; Window(window) => window.set_theme(theme))
-    }
-
-    #[inline]
-    pub fn theme(&self) -> Option<Theme> {
-        x11_or_wayland!(match self; Window(window) => window.theme())
-    }
-
-    #[inline]
-    pub fn has_focus(&self) -> bool {
-        x11_or_wayland!(match self; Window(window) => window.has_focus())
-    }
-
-    pub fn title(&self) -> String {
-        x11_or_wayland!(match self; Window(window) => window.title())
-    }
 }
 
 /// Hooks for X11 errors.
-#[cfg(x11_platform)]
+#[cfg(feature = "x11")]
 pub(crate) static mut XLIB_ERROR_HOOKS: Lazy<Mutex<Vec<XlibErrorHook>>> =
     Lazy::new(|| Mutex::new(Vec::new()));
 
-#[cfg(x11_platform)]
+#[cfg(feature = "x11")]
 unsafe extern "C" fn x_error_callback(
     display: *mut x11::ffi::Display,
     event: *mut x11::ffi::XErrorEvent,
 ) -> c_int {
-    let xconn_lock = X11_BACKEND.lock().unwrap();
+    let xconn_lock = X11_BACKEND.lock();
     if let Ok(ref xconn) = *xconn_lock {
         // Call all the hooks.
         let mut error_handled = false;
-        for hook in XLIB_ERROR_HOOKS.lock().unwrap().iter() {
+        for hook in XLIB_ERROR_HOOKS.lock().iter() {
             error_handled |= hook(display as *mut _, event as *mut _);
         }
 
@@ -663,25 +624,25 @@ unsafe extern "C" fn x_error_callback(
         // Don't log error.
         if !error_handled {
             error!("X11 error: {:#?}", error);
-            // XXX only update the error, if it wasn't handled by any of the hooks.
-            *xconn.latest_error.lock().unwrap() = Some(error);
         }
+
+        *xconn.latest_error.lock() = Some(error);
     }
     // Fun fact: this return value is completely ignored.
     0
 }
 
 pub enum EventLoop<T: 'static> {
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     Wayland(Box<wayland::EventLoop<T>>),
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     X(x11::EventLoop<T>),
 }
 
 pub enum EventLoopProxy<T: 'static> {
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     X(x11::EventLoopProxy<T>),
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     Wayland(wayland::EventLoopProxy<T>),
 }
 
@@ -702,13 +663,13 @@ impl<T: 'static> EventLoop<T> {
             );
         }
 
-        #[cfg(x11_platform)]
+        #[cfg(feature = "x11")]
         if attributes.forced_backend == Some(Backend::X) {
             // TODO: Propagate
             return EventLoop::new_x11_any_thread().unwrap();
         }
 
-        #[cfg(wayland_platform)]
+        #[cfg(feature = "wayland")]
         if attributes.forced_backend == Some(Backend::Wayland) {
             // TODO: Propagate
             return EventLoop::new_wayland_any_thread().expect("failed to open Wayland connection");
@@ -718,55 +679,57 @@ impl<T: 'static> EventLoop<T> {
             match env_var.as_str() {
                 "x11" => {
                     // TODO: propagate
-                    #[cfg(x11_platform)]
+                    #[cfg(feature = "x11")]
                     return EventLoop::new_x11_any_thread()
                         .expect("Failed to initialize X11 backend");
-                    #[cfg(not(x11_platform))]
+                    #[cfg(not(feature = "x11"))]
                     panic!("x11 feature is not enabled")
                 }
                 "wayland" => {
-                    #[cfg(wayland_platform)]
+                    #[cfg(feature = "wayland")]
                     return EventLoop::new_wayland_any_thread()
                         .expect("Failed to initialize Wayland backend");
-                    #[cfg(not(wayland_platform))]
+                    #[cfg(not(feature = "wayland"))]
                     panic!("wayland feature is not enabled");
                 }
                 _ => panic!(
-                    "Unknown environment variable value for {BACKEND_PREFERENCE_ENV_VAR}, try one of `x11`,`wayland`",
+                    "Unknown environment variable value for {}, try one of `x11`,`wayland`",
+                    BACKEND_PREFERENCE_ENV_VAR,
                 ),
             }
         }
 
-        #[cfg(wayland_platform)]
+        #[cfg(feature = "wayland")]
         let wayland_err = match EventLoop::new_wayland_any_thread() {
             Ok(event_loop) => return event_loop,
             Err(err) => err,
         };
 
-        #[cfg(x11_platform)]
+        #[cfg(feature = "x11")]
         let x11_err = match EventLoop::new_x11_any_thread() {
             Ok(event_loop) => return event_loop,
             Err(err) => err,
         };
 
-        #[cfg(not(wayland_platform))]
+        #[cfg(not(feature = "wayland"))]
         let wayland_err = "backend disabled";
-        #[cfg(not(x11_platform))]
+        #[cfg(not(feature = "x11"))]
         let x11_err = "backend disabled";
 
         panic!(
-            "Failed to initialize any backend! Wayland status: {wayland_err:?} X11 status: {x11_err:?}",
+            "Failed to initialize any backend! Wayland status: {:?} X11 status: {:?}",
+            wayland_err, x11_err,
         );
     }
 
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     fn new_wayland_any_thread() -> Result<EventLoop<T>, Box<dyn Error>> {
         wayland::EventLoop::new().map(|evlp| EventLoop::Wayland(Box::new(evlp)))
     }
 
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     fn new_x11_any_thread() -> Result<EventLoop<T>, XNotSupported> {
-        let xconn = match X11_BACKEND.lock().unwrap().as_ref() {
+        let xconn = match X11_BACKEND.lock().as_ref() {
             Ok(xconn) => xconn.clone(),
             Err(err) => return Err(err.clone()),
         };
@@ -804,9 +767,9 @@ impl<T: 'static> EventLoopProxy<T> {
 }
 
 pub enum EventLoopWindowTarget<T> {
-    #[cfg(wayland_platform)]
+    #[cfg(feature = "wayland")]
     Wayland(wayland::EventLoopWindowTarget<T>),
-    #[cfg(x11_platform)]
+    #[cfg(feature = "x11")]
     X(x11::EventLoopWindowTarget<T>),
 }
 
@@ -814,9 +777,9 @@ impl<T> EventLoopWindowTarget<T> {
     #[inline]
     pub fn is_wayland(&self) -> bool {
         match *self {
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             EventLoopWindowTarget::Wayland(_) => true,
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             _ => false,
         }
     }
@@ -824,13 +787,13 @@ impl<T> EventLoopWindowTarget<T> {
     #[inline]
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
         match *self {
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             EventLoopWindowTarget::Wayland(ref evlp) => evlp
                 .available_monitors()
                 .into_iter()
                 .map(MonitorHandle::Wayland)
                 .collect(),
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             EventLoopWindowTarget::X(ref evlp) => evlp
                 .x_connection()
                 .available_monitors()
@@ -841,14 +804,16 @@ impl<T> EventLoopWindowTarget<T> {
     }
 
     #[inline]
-    pub fn primary_monitor(&self) -> Option<MonitorHandle> {
+    pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
         match *self {
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             EventLoopWindowTarget::Wayland(ref evlp) => evlp.primary_monitor(),
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             EventLoopWindowTarget::X(ref evlp) => {
                 let primary_monitor = MonitorHandle::X(evlp.x_connection().primary_monitor());
-                Some(primary_monitor)
+                Some(RootMonitorHandle {
+                    inner: primary_monitor,
+                })
             }
         }
     }
@@ -856,9 +821,9 @@ impl<T> EventLoopWindowTarget<T> {
     #[inline]
     pub fn set_device_event_filter(&self, _filter: DeviceEventFilter) {
         match *self {
-            #[cfg(wayland_platform)]
+            #[cfg(feature = "wayland")]
             EventLoopWindowTarget::Wayland(_) => (),
-            #[cfg(x11_platform)]
+            #[cfg(feature = "x11")]
             EventLoopWindowTarget::X(ref evlp) => evlp.set_device_event_filter(_filter),
         }
     }

src/platform_impl/linux/wayland/env.rs

@@ -14,7 +14,6 @@ use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_rela
 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};
@@ -22,8 +21,6 @@ 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 {
@@ -64,8 +61,6 @@ sctk::environment!(WinitEnv,
         ZwpPointerConstraintsV1 => pointer_constraints,
         ZwpTextInputManagerV3 => text_input_manager,
         XdgActivationV1 => xdg_activation,
-        WpFractionalScaleManagerV1 => fractional_scale_manager,
-        WpViewporter => viewporter,
     ],
     multis = [
         WlSeat => seats,
@@ -96,10 +91,6 @@ pub struct WinitEnv {
     decoration_manager: SimpleGlobal<ZxdgDecorationManagerV1>,
 
     xdg_activation: SimpleGlobal<XdgActivationV1>,
-
-    fractional_scale_manager: SimpleGlobal<WpFractionalScaleManagerV1>,
-
-    viewporter: SimpleGlobal<WpViewporter>,
 }
 
 impl WinitEnv {
@@ -134,12 +125,6 @@ impl WinitEnv {
         // 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,
@@ -152,8 +137,6 @@ impl WinitEnv {
             pointer_constraints,
             text_input_manager,
             xdg_activation,
-            fractional_scale_manager,
-            viewporter,
         }
     }
 }

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

@@ -19,7 +19,6 @@ 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;
@@ -269,7 +268,7 @@ impl<T: 'static> EventLoop<T> {
                     PlatformEventLoopWindowTarget::Wayland(window_target) => {
                         window_target.state.get_mut()
                     }
-                    #[cfg(x11_platform)]
+                    #[cfg(feature = "x11")]
                     _ => unreachable!(),
                 };
 
@@ -375,18 +374,17 @@ impl<T: 'static> EventLoop<T> {
             });
 
             for (window_id, window_compositor_update) in window_compositor_updates.iter_mut() {
-                if let Some(scale_factor) = window_compositor_update.scale_factor {
+                if let Some(scale_factor) = window_compositor_update.scale_factor.map(|f| f as f64)
+                {
                     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)
+                        window_size.to_physical(scale_factor)
                     });
 
                     sticky_exit_callback(
@@ -411,15 +409,6 @@ impl<T: 'static> EventLoop<T> {
                 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.
@@ -430,8 +419,9 @@ impl<T: 'static> EventLoop<T> {
                             None
                         } else {
                             *window_size = size;
-                            let scale_factor = window_handle.scale_factor();
-                            let physical_size = logical_to_physical_rounded(size, scale_factor);
+                            let scale_factor =
+                                sctk::get_surface_scale_factor(window_handle.window.surface());
+                            let physical_size = size.to_physical(scale_factor as f64);
                             Some(physical_size)
                         };
 
@@ -441,9 +431,6 @@ impl<T: 'static> EventLoop<T> {
                         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
@@ -451,13 +438,6 @@ impl<T: 'static> EventLoop<T> {
                             .unwrap()
                             .refresh_frame = false;
 
-                        // Queue redraw requested.
-                        state
-                            .window_user_requests
-                            .get_mut(window_id)
-                            .unwrap()
-                            .redraw_requested = true;
-
                         physical_size
                     });
 
@@ -581,7 +561,7 @@ impl<T: 'static> EventLoop<T> {
     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)]
+            #[cfg(feature = "x11")]
             _ => unreachable!(),
         };
 
@@ -591,7 +571,7 @@ impl<T: 'static> EventLoop<T> {
     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)]
+            #[cfg(feature = "x11")]
             _ => unreachable!(),
         };
 
@@ -600,10 +580,3 @@ impl<T: 'static> EventLoop<T> {
             .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/mod.rs

@@ -1,4 +1,10 @@
-#![cfg(wayland_platform)]
+#![cfg(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 
 use sctk::reexports::client::protocol::wl_surface::WlSurface;
 
@@ -10,7 +16,6 @@ pub use window::Window;
 mod env;
 mod event_loop;
 mod output;
-mod protocols;
 mod seat;
 mod window;
 

src/platform_impl/linux/wayland/output.rs

@@ -8,6 +8,7 @@ use sctk::environment::Environment;
 use sctk::output::OutputStatusListener;
 
 use crate::dpi::{PhysicalPosition, PhysicalSize};
+use crate::monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode};
 use crate::platform_impl::platform::{
     MonitorHandle as PlatformMonitorHandle, VideoMode as PlatformVideoMode,
 };
@@ -182,19 +183,19 @@ impl MonitorHandle {
     }
 
     #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoMode> {
+    pub fn video_modes(&self) -> impl Iterator<Item = RootVideoMode> {
         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 {
+        modes.into_iter().map(move |mode| RootVideoMode {
+            video_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(),
-            })
+            }),
         })
     }
 }
@@ -223,8 +224,10 @@ impl VideoMode {
         self.refresh_rate_millihertz
     }
 
-    pub fn monitor(&self) -> PlatformMonitorHandle {
-        PlatformMonitorHandle::Wayland(self.monitor.clone())
+    pub fn monitor(&self) -> RootMonitorHandle {
+        RootMonitorHandle {
+            inner: PlatformMonitorHandle::Wayland(self.monitor.clone()),
+        }
     }
 }
 
@@ -240,7 +243,7 @@ impl<T> EventLoopWindowTarget<T> {
     }
 
     #[inline]
-    pub fn primary_monitor(&self) -> Option<PlatformMonitorHandle> {
+    pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
         // There's no primary monitor on Wayland.
         None
     }

src/platform_impl/linux/wayland/protocols.rs

@@ -1,13 +0,0 @@
-#![allow(dead_code, non_camel_case_types, unused_unsafe, unused_variables)]
-#![allow(non_upper_case_globals, non_snake_case, unused_imports)]
-#![allow(missing_docs, clippy::all)]
-
-use wayland_client::protocol::wl_surface;
-use wayland_client::sys;
-use wayland_client::{AnonymousObject, Attached, Main, Proxy, ProxyMap};
-use wayland_commons::map::{Object, ObjectMetadata};
-use wayland_commons::smallvec;
-use wayland_commons::wire::{Argument, ArgumentType, Message, MessageDesc};
-use wayland_commons::{Interface, MessageGroup};
-
-include!(concat!(env!("OUT_DIR"), "/fractional_scale_v1.rs"));

src/platform_impl/linux/wayland/seat/keyboard/handlers.rs

@@ -1,7 +1,5 @@
 //! Handling of various keyboard events.
 
-use std::sync::atomic::Ordering;
-
 use sctk::reexports::client::protocol::wl_keyboard::KeyState;
 
 use sctk::seat::keyboard::Event as KeyboardEvent;
@@ -24,12 +22,6 @@ pub(super) fn handle_keyboard(
         KeyboardEvent::Enter { surface, .. } => {
             let window_id = wayland::make_wid(&surface);
 
-            let window_handle = match winit_state.window_map.get_mut(&window_id) {
-                Some(window_handle) => window_handle,
-                None => return,
-            };
-            window_handle.has_focus.store(true, Ordering::Relaxed);
-
             // Window gained focus.
             event_sink.push_window_event(WindowEvent::Focused(true), window_id);
 
@@ -42,14 +34,7 @@ pub(super) fn handle_keyboard(
             inner.target_window_id = Some(window_id);
         }
         KeyboardEvent::Leave { surface, .. } => {
-            // Reset the id.
-            inner.target_window_id = None;
-
             let window_id = wayland::make_wid(&surface);
-            let window_handle = match winit_state.window_map.get_mut(&window_id) {
-                Some(window_handle) => window_handle,
-                None => return,
-            };
 
             // Notify that no modifiers are being pressed.
             if !inner.modifiers_state.borrow().is_empty() {
@@ -59,10 +44,11 @@ pub(super) fn handle_keyboard(
                 );
             }
 
-            window_handle.has_focus.store(false, Ordering::Relaxed);
-
             // Window lost focus.
             event_sink.push_window_event(WindowEvent::Focused(false), window_id);
+
+            // Reset the id.
+            inner.target_window_id = None;
         }
         KeyboardEvent::Key {
             rawkey,

src/platform_impl/linux/wayland/seat/pointer/handlers.rs

@@ -45,12 +45,15 @@ pub(super) fn handle_pointer(
             pointer_data.latest_enter_serial.replace(serial);
 
             let window_id = wayland::make_wid(&surface);
+            if !winit_state.window_map.contains_key(&window_id) {
+                return;
+            }
             let window_handle = match winit_state.window_map.get_mut(&window_id) {
                 Some(window_handle) => window_handle,
                 None => return,
             };
 
-            let scale_factor = window_handle.scale_factor();
+            let scale_factor = sctk::get_surface_scale_factor(&surface) as f64;
             pointer_data.surface = Some(surface);
 
             // Notify window that pointer entered the surface.
@@ -130,12 +133,8 @@ pub(super) fn handle_pointer(
             };
 
             let window_id = wayland::make_wid(surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
 
-            let scale_factor = window_handle.scale_factor();
+            let scale_factor = sctk::get_surface_scale_factor(surface) as f64;
             let position = LogicalPosition::new(surface_x, surface_y).to_physical(scale_factor);
 
             event_sink.push_window_event(
@@ -193,10 +192,6 @@ pub(super) fn handle_pointer(
             };
 
             let window_id = wayland::make_wid(surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
 
             if pointer.as_ref().version() < 5 {
                 let (mut x, mut y) = (0.0, 0.0);
@@ -209,7 +204,7 @@ pub(super) fn handle_pointer(
                     _ => unreachable!(),
                 }
 
-                let scale_factor = window_handle.scale_factor();
+                let scale_factor = sctk::get_surface_scale_factor(surface) as f64;
                 let delta = LogicalPosition::new(x as f64, y as f64).to_physical(scale_factor);
 
                 event_sink.push_window_event(
@@ -273,10 +268,6 @@ pub(super) fn handle_pointer(
                 None => return,
             };
             let window_id = wayland::make_wid(surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
 
             let window_event = if let Some((x, y)) = axis_discrete_buffer {
                 WindowEvent::MouseWheel {
@@ -288,7 +279,7 @@ pub(super) fn handle_pointer(
                     modifiers: *pointer_data.modifiers_state.borrow(),
                 }
             } else if let Some((x, y)) = axis_buffer {
-                let scale_factor = window_handle.scale_factor();
+                let scale_factor = sctk::get_surface_scale_factor(surface) as f64;
                 let delta = LogicalPosition::new(x, y).to_physical(scale_factor);
 
                 WindowEvent::MouseWheel {

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

@@ -143,7 +143,7 @@ impl WinitPointer {
         *confined_pointer.borrow_mut() = Some(init_confined_pointer(
             pointer_constraints,
             surface,
-            &self.pointer,
+            &*self.pointer,
         ));
     }
 
@@ -177,7 +177,7 @@ impl WinitPointer {
         *locked_pointer.borrow_mut() = Some(init_locked_pointer(
             pointer_constraints,
             surface,
-            &self.pointer,
+            &*self.pointer,
         ));
     }
 
@@ -267,7 +267,7 @@ impl Pointers {
         let relative_pointer = relative_pointer_manager
             .as_ref()
             .map(|relative_pointer_manager| {
-                init_relative_pointer(relative_pointer_manager, &pointer)
+                init_relative_pointer(relative_pointer_manager, &*pointer)
             });
 
         Self {

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

@@ -9,7 +9,7 @@ use crate::event::{Ime, WindowEvent};
 use crate::platform_impl::wayland;
 use crate::platform_impl::wayland::event_loop::WinitState;
 
-use super::{Preedit, TextInputHandler, TextInputInner, ZwpTextInputV3Ext};
+use super::{Preedit, TextInputHandler, TextInputInner};
 
 #[inline]
 pub(super) fn handle_text_input(
@@ -32,7 +32,6 @@ pub(super) fn handle_text_input(
             // Enable text input on that surface.
             if window_handle.ime_allowed.get() {
                 text_input.enable();
-                text_input.set_content_type_by_purpose(window_handle.ime_purpose.get());
                 text_input.commit();
                 event_sink.push_window_event(WindowEvent::Ime(Ime::Enabled), window_id);
             }
@@ -69,14 +68,9 @@ pub(super) fn handle_text_input(
             cursor_begin,
             cursor_end,
         } => {
+            let cursor_begin = usize::try_from(cursor_begin).ok();
+            let cursor_end = usize::try_from(cursor_end).ok();
             let text = text.unwrap_or_default();
-            let cursor_begin = usize::try_from(cursor_begin)
-                .ok()
-                .and_then(|idx| text.is_char_boundary(idx).then(|| idx));
-            let cursor_end = usize::try_from(cursor_end)
-                .ok()
-                .and_then(|idx| text.is_char_boundary(idx).then(|| idx));
-
             inner.pending_preedit = Some(Preedit {
                 text,
                 cursor_begin,

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

@@ -1,13 +1,10 @@
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
 use sctk::reexports::client::Attached;
 use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
-use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_v3::{
-    ContentHint, ContentPurpose, ZwpTextInputV3,
-};
+use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_v3::ZwpTextInputV3;
 
 use crate::platform_impl::wayland::event_loop::WinitState;
 use crate::platform_impl::wayland::WindowId;
-use crate::window::ImePurpose;
 
 mod handlers;
 
@@ -17,21 +14,6 @@ pub struct TextInputHandler {
     text_input: ZwpTextInputV3,
 }
 
-trait ZwpTextInputV3Ext {
-    fn set_content_type_by_purpose(&self, purpose: ImePurpose);
-}
-
-impl ZwpTextInputV3Ext for ZwpTextInputV3 {
-    fn set_content_type_by_purpose(&self, purpose: ImePurpose) {
-        let (hint, purpose) = match purpose {
-            ImePurpose::Normal => (ContentHint::None, ContentPurpose::Normal),
-            ImePurpose::Password => (ContentHint::SensitiveData, ContentPurpose::Password),
-            ImePurpose::Terminal => (ContentHint::None, ContentPurpose::Terminal),
-        };
-        self.set_content_type(hint, purpose);
-    }
-}
-
 impl TextInputHandler {
     #[inline]
     pub fn set_ime_position(&self, x: i32, y: i32) {
@@ -40,15 +22,8 @@ impl TextInputHandler {
     }
 
     #[inline]
-    pub fn set_content_type_by_purpose(&self, purpose: ImePurpose) {
-        self.text_input.set_content_type_by_purpose(purpose);
-        self.text_input.commit();
-    }
-
-    #[inline]
-    pub fn set_input_allowed(&self, allowed: Option<ImePurpose>) {
-        if let Some(purpose) = allowed {
-            self.text_input.set_content_type_by_purpose(purpose);
+    pub fn set_input_allowed(&self, allowed: bool) {
+        if allowed {
             self.text_input.enable();
         } else {
             self.text_input.disable();

src/platform_impl/linux/wayland/seat/touch/handlers.rs

@@ -24,12 +24,11 @@ pub(super) fn handle_touch(
             surface, id, x, y, ..
         } => {
             let window_id = wayland::make_wid(&surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
+            if !winit_state.window_map.contains_key(&window_id) {
+                return;
+            }
 
-            let scale_factor = window_handle.scale_factor();
+            let scale_factor = sctk::get_surface_scale_factor(&surface) as f64;
             let position = LogicalPosition::new(x, y);
 
             event_sink.push_window_event(
@@ -61,12 +60,7 @@ pub(super) fn handle_touch(
                 None => return,
             };
 
-            let window_id = wayland::make_wid(&touch_point.surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
-            let scale_factor = window_handle.scale_factor();
+            let scale_factor = sctk::get_surface_scale_factor(&touch_point.surface) as f64;
             let location = touch_point.position.to_physical(scale_factor);
             let window_id = wayland::make_wid(&touch_point.surface);
 
@@ -88,15 +82,10 @@ pub(super) fn handle_touch(
                 Some(touch_point) => touch_point,
                 None => return,
             };
-            let window_id = wayland::make_wid(&touch_point.surface);
-            let window_handle = match winit_state.window_map.get(&window_id) {
-                Some(w) => w,
-                _ => return,
-            };
 
             touch_point.position = LogicalPosition::new(x, y);
 
-            let scale_factor = window_handle.scale_factor();
+            let scale_factor = sctk::get_surface_scale_factor(&touch_point.surface) as f64;
             let location = touch_point.position.to_physical(scale_factor);
             let window_id = wayland::make_wid(&touch_point.surface);
 
@@ -116,14 +105,9 @@ pub(super) fn handle_touch(
         TouchEvent::Frame => (),
         TouchEvent::Cancel => {
             for touch_point in inner.touch_points.drain(..) {
-                let window_id = wayland::make_wid(&touch_point.surface);
-                let window_handle = match winit_state.window_map.get(&window_id) {
-                    Some(w) => w,
-                    _ => return,
-                };
-
-                let scale_factor = window_handle.scale_factor();
+                let scale_factor = sctk::get_surface_scale_factor(&touch_point.surface) as f64;
                 let location = touch_point.position.to_physical(scale_factor);
+                let window_id = wayland::make_wid(&touch_point.surface);
 
                 event_sink.push_window_event(
                     WindowEvent::Touch(crate::event::Touch {

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

@@ -11,18 +11,16 @@ use raw_window_handle::{
     RawDisplayHandle, RawWindowHandle, WaylandDisplayHandle, WaylandWindowHandle,
 };
 use sctk::window::Decorations;
-use wayland_protocols::viewporter::client::wp_viewporter::WpViewporter;
 
 use crate::dpi::{LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
+use crate::monitor::MonitorHandle as RootMonitorHandle;
 use crate::platform_impl::{
-    wayland::protocols::wp_fractional_scale_manager_v1::WpFractionalScaleManagerV1,
-    wayland::protocols::wp_fractional_scale_v1, Fullscreen, MonitorHandle as PlatformMonitorHandle,
-    OsError, PlatformSpecificWindowBuilderAttributes as PlatformAttributes,
+    MonitorHandle as PlatformMonitorHandle, OsError,
+    PlatformSpecificWindowBuilderAttributes as PlatformAttributes,
 };
 use crate::window::{
-    CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-    WindowAttributes, WindowButtons,
+    CursorGrabMode, CursorIcon, Fullscreen, Theme, UserAttentionType, WindowAttributes,
 };
 
 use super::env::WindowingFeatures;
@@ -32,9 +30,7 @@ use super::{EventLoopWindowTarget, WindowId};
 
 pub mod shim;
 
-use shim::{
-    FractionalScalingState, WindowCompositorUpdate, WindowHandle, WindowRequest, WindowUserRequest,
-};
+use shim::{WindowCompositorUpdate, WindowHandle, WindowRequest, WindowUserRequest};
 
 #[cfg(feature = "sctk-adwaita")]
 pub type WinitFrame = sctk_adwaita::AdwaitaFrame;
@@ -54,9 +50,6 @@ pub struct Window {
     /// The underlying wl_surface.
     surface: WlSurface,
 
-    /// The scale factor.
-    scale_factor: Arc<Mutex<f64>>,
-
     /// The current window size.
     size: Arc<Mutex<LogicalSize<u32>>>,
 
@@ -86,9 +79,6 @@ pub struct Window {
 
     /// Grabbing mode.
     cursor_grab_mode: Mutex<CursorGrabMode>,
-
-    /// Whether the window has keyboard focus.
-    has_focus: Arc<AtomicBool>,
 }
 
 impl Window {
@@ -97,56 +87,33 @@ impl Window {
         attributes: WindowAttributes,
         platform_attributes: PlatformAttributes,
     ) -> Result<Self, RootOsError> {
-        let viewporter = event_loop_window_target.env.get_global::<WpViewporter>();
-        let fractional_scale_manager = event_loop_window_target
+        let surface = event_loop_window_target
             .env
-            .get_global::<WpFractionalScaleManagerV1>();
-
-        // Create surface and register callback for the scale factor changes.
-        let mut scale_factor = 1.;
-        let (surface, fractional_scaling_state) =
-            if let (Some(viewporter), Some(fractional_scale_manager)) =
-                (viewporter, fractional_scale_manager)
-            {
-                let surface = event_loop_window_target.env.create_surface().detach();
-                let fractional_scale = fractional_scale_manager.get_fractional_scale(&surface);
+            .create_surface_with_scale_callback(move |scale, surface, mut dispatch_data| {
+                let winit_state = dispatch_data.get::<WinitState>().unwrap();
 
+                // Get the window that received the event.
                 let window_id = super::make_wid(&surface);
-                fractional_scale.quick_assign(move |_, event, mut dispatch_data| {
-                    let wp_fractional_scale_v1::Event::PreferredScale { scale } = event;
-                    let winit_state = dispatch_data.get::<WinitState>().unwrap();
-                    apply_scale(window_id, scale as f64 / 120., winit_state);
-                });
+                let mut window_compositor_update = winit_state
+                    .window_compositor_updates
+                    .get_mut(&window_id)
+                    .unwrap();
 
-                let fractional_scale = fractional_scale.detach();
-                let viewport = viewporter.get_viewport(&surface).detach();
-                let fractional_scaling_state =
-                    FractionalScalingState::new(viewport, fractional_scale);
+                // Mark that we need a frame refresh on the DPI change.
+                winit_state
+                    .window_user_requests
+                    .get_mut(&window_id)
+                    .unwrap()
+                    .refresh_frame = true;
 
-                (surface, Some(fractional_scaling_state))
-            } else {
-                let surface = event_loop_window_target
-                    .env
-                    .create_surface_with_scale_callback(move |scale, surface, mut dispatch_data| {
-                        // While I'm not sure how this could happen, we can safely ignore it
-                        // for now as a quickfix.
-                        if !surface.as_ref().is_alive() {
-                            return;
-                        }
+                // Set pending scale factor.
+                window_compositor_update.scale_factor = Some(scale);
 
-                        let winit_state = dispatch_data.get::<WinitState>().unwrap();
+                surface.set_buffer_scale(scale);
+            })
+            .detach();
 
-                        // Get the window that received the event.
-                        let window_id = super::make_wid(&surface);
-                        apply_scale(window_id, scale as f64, winit_state);
-                        surface.set_buffer_scale(scale);
-                    })
-                    .detach();
-
-                scale_factor = sctk::get_surface_scale_factor(&surface) as _;
-
-                (surface, None)
-            };
+        let scale_factor = sctk::get_surface_scale_factor(&surface);
 
         let window_id = super::make_wid(&surface);
         let maximized = Arc::new(AtomicBool::new(false));
@@ -156,7 +123,7 @@ impl Window {
 
         let (width, height) = attributes
             .inner_size
-            .map(|size| size.to_logical::<f64>(scale_factor).into())
+            .map(|size| size.to_logical::<f64>(scale_factor as f64).into())
             .unwrap_or((800, 600));
 
         let theme_manager = event_loop_window_target.theme_manager.clone();
@@ -203,14 +170,17 @@ impl Window {
             )
             .map_err(|_| os_error!(OsError::WaylandMisc("failed to create window.")))?;
 
-        // Set CSD frame config from theme if specified,
-        // otherwise use upstream automatic selection.
+        // Set CSD frame config
         #[cfg(feature = "sctk-adwaita")]
-        if let Some(theme) = attributes.preferred_theme.or_else(|| {
-            std::env::var(WAYLAND_CSD_THEME_ENV_VAR)
-                .ok()
-                .and_then(|s| s.as_str().try_into().ok())
-        }) {
+        {
+            let theme = platform_attributes.csd_theme.unwrap_or_else(|| {
+                let env = std::env::var(WAYLAND_CSD_THEME_ENV_VAR).unwrap_or_default();
+                match env.to_lowercase().as_str() {
+                    "dark" => Theme::Dark,
+                    _ => Theme::Light,
+                }
+            });
+
             window.set_frame_config(theme.into());
         }
 
@@ -224,13 +194,13 @@ impl Window {
         // Min dimensions.
         let min_size = attributes
             .min_inner_size
-            .map(|size| size.to_logical::<f64>(scale_factor).into());
+            .map(|size| size.to_logical::<f64>(scale_factor as f64).into());
         window.set_min_size(min_size);
 
         // Max dimensions.
         let max_size = attributes
             .max_inner_size
-            .map(|size| size.to_logical::<f64>(scale_factor).into());
+            .map(|size| size.to_logical::<f64>(scale_factor as f64).into());
         window.set_max_size(max_size);
 
         // Set Wayland specific window attributes.
@@ -246,16 +216,17 @@ impl Window {
         window.set_title(attributes.title);
 
         // Set fullscreen/maximized if so was requested.
-        match attributes.fullscreen.map(Into::into) {
+        match attributes.fullscreen {
             Some(Fullscreen::Exclusive(_)) => {
                 warn!("`Fullscreen::Exclusive` is ignored on Wayland")
             }
             Some(Fullscreen::Borderless(monitor)) => {
-                let monitor = monitor.and_then(|monitor| match monitor {
-                    PlatformMonitorHandle::Wayland(monitor) => Some(monitor.proxy),
-                    #[cfg(x11_platform)]
-                    PlatformMonitorHandle::X(_) => None,
-                });
+                let monitor =
+                    monitor.and_then(|RootMonitorHandle { inner: monitor }| match monitor {
+                        PlatformMonitorHandle::Wayland(monitor) => Some(monitor.proxy),
+                        #[cfg(feature = "x11")]
+                        PlatformMonitorHandle::X(_) => None,
+                    });
 
                 window.set_fullscreen(monitor.as_ref());
             }
@@ -277,7 +248,6 @@ impl Window {
         window.surface().commit();
 
         let size = Arc::new(Mutex::new(LogicalSize::new(width, height)));
-        let has_focus = Arc::new(AtomicBool::new(true));
 
         // We should trigger redraw and commit the surface for the newly created window.
         let mut window_user_request = WindowUserRequest::new();
@@ -292,15 +262,9 @@ impl Window {
             &event_loop_window_target.env,
             window,
             size.clone(),
-            has_focus.clone(),
-            fractional_scaling_state,
-            scale_factor,
             window_requests.clone(),
         );
 
-        // Set opaque region.
-        window_handle.set_transparent(attributes.transparent);
-
         // Set resizable state, so we can determine how to handle `Window::set_inner_size`.
         window_handle.is_resizable.set(attributes.resizable);
 
@@ -355,8 +319,6 @@ impl Window {
             resizeable: AtomicBool::new(attributes.resizable),
             decorated: AtomicBool::new(attributes.decorations),
             cursor_grab_mode: Mutex::new(CursorGrabMode::None),
-            has_focus,
-            scale_factor: window_handle.scale_factor.clone(),
         };
 
         Ok(window)
@@ -374,11 +336,6 @@ impl Window {
         self.send_request(WindowRequest::Title(title.to_owned()));
     }
 
-    #[inline]
-    pub fn set_transparent(&self, transparent: bool) {
-        self.send_request(WindowRequest::Transparent(transparent));
-    }
-
     #[inline]
     pub fn set_visible(&self, _visible: bool) {
         // Not possible on Wayland.
@@ -405,7 +362,10 @@ impl Window {
     }
 
     pub fn inner_size(&self) -> PhysicalSize<u32> {
-        self.size.lock().unwrap().to_physical(self.scale_factor())
+        self.size
+            .lock()
+            .unwrap()
+            .to_physical(self.scale_factor() as f64)
     }
 
     #[inline]
@@ -415,12 +375,15 @@ impl Window {
 
     #[inline]
     pub fn outer_size(&self) -> PhysicalSize<u32> {
-        self.size.lock().unwrap().to_physical(self.scale_factor())
+        self.size
+            .lock()
+            .unwrap()
+            .to_physical(self.scale_factor() as f64)
     }
 
     #[inline]
     pub fn set_inner_size(&self, size: Size) {
-        let scale_factor = self.scale_factor();
+        let scale_factor = self.scale_factor() as f64;
 
         let size = size.to_logical::<u32>(scale_factor);
         *self.size.lock().unwrap() = size;
@@ -430,7 +393,7 @@ impl Window {
 
     #[inline]
     pub fn set_min_inner_size(&self, dimensions: Option<Size>) {
-        let scale_factor = self.scale_factor();
+        let scale_factor = self.scale_factor() as f64;
         let size = dimensions.map(|size| size.to_logical::<u32>(scale_factor));
 
         self.send_request(WindowRequest::MinSize(size));
@@ -438,22 +401,12 @@ impl Window {
 
     #[inline]
     pub fn set_max_inner_size(&self, dimensions: Option<Size>) {
-        let scale_factor = self.scale_factor();
+        let scale_factor = self.scale_factor() as f64;
         let size = dimensions.map(|size| size.to_logical::<u32>(scale_factor));
 
         self.send_request(WindowRequest::MaxSize(size));
     }
 
-    #[inline]
-    pub fn resize_increments(&self) -> Option<PhysicalSize<u32>> {
-        None
-    }
-
-    #[inline]
-    pub fn set_resize_increments(&self, _increments: Option<Size>) {
-        warn!("`set_resize_increments` is not implemented for Wayland");
-    }
-
     #[inline]
     pub fn set_resizable(&self, resizable: bool) {
         self.resizeable.store(resizable, Ordering::Relaxed);
@@ -466,16 +419,10 @@ impl Window {
     }
 
     #[inline]
-    pub fn set_enabled_buttons(&self, _buttons: WindowButtons) {}
-
-    #[inline]
-    pub fn enabled_buttons(&self) -> WindowButtons {
-        WindowButtons::all()
-    }
-
-    #[inline]
-    pub fn scale_factor(&self) -> f64 {
-        *self.scale_factor.lock().unwrap()
+    pub fn scale_factor(&self) -> u32 {
+        // The scale factor from `get_surface_scale_factor` is always greater than zero, so
+        // u32 conversion is safe.
+        sctk::get_surface_scale_factor(&self.surface) as u32
     }
 
     #[inline]
@@ -490,8 +437,8 @@ impl Window {
     }
 
     #[inline]
-    pub fn is_minimized(&self) -> Option<bool> {
-        None
+    pub fn set_csd_theme(&self, theme: Theme) {
+        self.send_request(WindowRequest::CsdThemeVariant(theme));
     }
 
     #[inline]
@@ -515,9 +462,11 @@ impl Window {
     }
 
     #[inline]
-    pub(crate) fn fullscreen(&self) -> Option<Fullscreen> {
+    pub fn fullscreen(&self) -> Option<Fullscreen> {
         if self.fullscreen.load(Ordering::Relaxed) {
-            let current_monitor = self.current_monitor().map(PlatformMonitorHandle::Wayland);
+            let current_monitor = self.current_monitor().map(|monitor| RootMonitorHandle {
+                inner: PlatformMonitorHandle::Wayland(monitor),
+            });
 
             Some(Fullscreen::Borderless(current_monitor))
         } else {
@@ -526,18 +475,19 @@ impl Window {
     }
 
     #[inline]
-    pub(crate) fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
+    pub fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
         let fullscreen_request = match fullscreen {
             Some(Fullscreen::Exclusive(_)) => {
                 warn!("`Fullscreen::Exclusive` is ignored on Wayland");
                 return;
             }
             Some(Fullscreen::Borderless(monitor)) => {
-                let monitor = monitor.and_then(|monitor| match monitor {
-                    PlatformMonitorHandle::Wayland(monitor) => Some(monitor.proxy),
-                    #[cfg(x11_platform)]
-                    PlatformMonitorHandle::X(_) => None,
-                });
+                let monitor =
+                    monitor.and_then(|RootMonitorHandle { inner: monitor }| match monitor {
+                        PlatformMonitorHandle::Wayland(monitor) => Some(monitor.proxy),
+                        #[cfg(feature = "x11")]
+                        PlatformMonitorHandle::X(_) => None,
+                    });
 
                 WindowRequest::Fullscreen(monitor)
             }
@@ -591,7 +541,7 @@ impl Window {
             ))));
         }
 
-        let scale_factor = self.scale_factor();
+        let scale_factor = self.scale_factor() as f64;
         let position = position.to_logical(scale_factor);
         self.send_request(WindowRequest::SetLockedCursorPosition(position));
 
@@ -605,11 +555,6 @@ impl Window {
         Ok(())
     }
 
-    #[inline]
-    pub fn drag_resize_window(&self, _direction: ResizeDirection) -> Result<(), ExternalError> {
-        Err(ExternalError::NotSupported(NotSupportedError::new()))
-    }
-
     #[inline]
     pub fn set_cursor_hittest(&self, hittest: bool) -> Result<(), ExternalError> {
         self.send_request(WindowRequest::PassthroughMouseInput(!hittest));
@@ -619,7 +564,7 @@ impl Window {
 
     #[inline]
     pub fn set_ime_position(&self, position: Position) {
-        let scale_factor = self.scale_factor();
+        let scale_factor = self.scale_factor() as f64;
         let position = position.to_logical(scale_factor);
         self.send_request(WindowRequest::ImePosition(position));
     }
@@ -629,11 +574,6 @@ impl Window {
         self.send_request(WindowRequest::AllowIme(allowed));
     }
 
-    #[inline]
-    pub fn set_ime_purpose(&self, purpose: ImePurpose) {
-        self.send_request(WindowRequest::ImePurpose(purpose));
-    }
-
     #[inline]
     pub fn display(&self) -> &Display {
         &self.display
@@ -656,7 +596,7 @@ impl Window {
     }
 
     #[inline]
-    pub fn primary_monitor(&self) -> Option<PlatformMonitorHandle> {
+    pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
         None
     }
 
@@ -679,25 +619,6 @@ impl Window {
         self.window_requests.lock().unwrap().push(request);
         self.event_loop_awakener.ping();
     }
-
-    #[inline]
-    pub fn set_theme(&self, theme: Option<Theme>) {
-        self.send_request(WindowRequest::Theme(theme));
-    }
-
-    #[inline]
-    pub fn theme(&self) -> Option<Theme> {
-        None
-    }
-
-    #[inline]
-    pub fn has_focus(&self) -> bool {
-        self.has_focus.load(Ordering::Relaxed)
-    }
-
-    pub fn title(&self) -> String {
-        String::new()
-    }
 }
 
 impl Drop for Window {
@@ -715,40 +636,3 @@ impl From<Theme> for sctk_adwaita::FrameConfig {
         }
     }
 }
-
-impl TryFrom<&str> for Theme {
-    type Error = ();
-
-    /// ```
-    /// use winit::window::Theme;
-    ///
-    /// assert_eq!("dark".try_into(), Ok(Theme::Dark));
-    /// assert_eq!("lIghT".try_into(), Ok(Theme::Light));
-    /// ```
-    fn try_from(theme: &str) -> Result<Self, Self::Error> {
-        if theme.eq_ignore_ascii_case("dark") {
-            Ok(Self::Dark)
-        } else if theme.eq_ignore_ascii_case("light") {
-            Ok(Self::Light)
-        } else {
-            Err(())
-        }
-    }
-}
-
-/// Set pending scale for the provided `window_id`.
-fn apply_scale(window_id: WindowId, scale: f64, winit_state: &mut WinitState) {
-    // Set pending scale factor.
-    winit_state
-        .window_compositor_updates
-        .get_mut(&window_id)
-        .unwrap()
-        .scale_factor = Some(scale);
-
-    // Mark that we need a frame refresh on the DPI change.
-    winit_state
-        .window_user_requests
-        .get_mut(&window_id)
-        .unwrap()
-        .refresh_frame = true;
-}

src/platform_impl/linux/wayland/window/shim.rs

@@ -1,6 +1,5 @@
 use std::cell::Cell;
 use std::mem::ManuallyDrop;
-use std::sync::atomic::AtomicBool;
 use std::sync::{Arc, Mutex};
 
 use sctk::reexports::client::protocol::wl_compositor::WlCompositor;
@@ -11,7 +10,6 @@ use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activat
 
 use sctk::environment::Environment;
 use sctk::window::{Decorations, Window};
-use wayland_protocols::viewporter::client::wp_viewport::WpViewport;
 
 use crate::dpi::{LogicalPosition, LogicalSize};
 
@@ -19,11 +17,10 @@ use crate::event::{Ime, WindowEvent};
 use crate::platform_impl::wayland;
 use crate::platform_impl::wayland::env::WinitEnv;
 use crate::platform_impl::wayland::event_loop::{EventSink, WinitState};
-use crate::platform_impl::wayland::protocols::wp_fractional_scale_v1::WpFractionalScaleV1;
 use crate::platform_impl::wayland::seat::pointer::WinitPointer;
 use crate::platform_impl::wayland::seat::text_input::TextInputHandler;
 use crate::platform_impl::wayland::WindowId;
-use crate::window::{CursorGrabMode, CursorIcon, ImePurpose, Theme, UserAttentionType};
+use crate::window::{CursorGrabMode, CursorIcon, Theme, UserAttentionType};
 
 use super::WinitFrame;
 
@@ -62,6 +59,9 @@ pub enum WindowRequest {
     /// Request decorations change.
     Decorate(bool),
 
+    /// Request decorations change.
+    CsdThemeVariant(Theme),
+
     /// Make the window resizeable.
     Resizeable(bool),
 
@@ -83,12 +83,6 @@ pub enum WindowRequest {
     /// Enable IME on the given window.
     AllowIme(bool),
 
-    /// Set the IME purpose.
-    ImePurpose(ImePurpose),
-
-    /// Mark the window as opaque.
-    Transparent(bool),
-
     /// Request Attention.
     ///
     /// `None` unsets the attention request.
@@ -102,9 +96,6 @@ pub enum WindowRequest {
 
     /// Window should be closed.
     Close,
-
-    /// Change window theme.
-    Theme(Option<Theme>),
 }
 
 // The window update comming from the compositor.
@@ -114,7 +105,7 @@ pub struct WindowCompositorUpdate {
     pub size: Option<LogicalSize<u32>>,
 
     /// New scale factor.
-    pub scale_factor: Option<f64>,
+    pub scale_factor: Option<i32>,
 
     /// Close the window.
     pub close_window: bool,
@@ -148,12 +139,6 @@ pub struct WindowHandle {
     /// An actual window.
     pub window: ManuallyDrop<Window<WinitFrame>>,
 
-    /// The state of the fractional scaling handlers for the window.
-    pub fractional_scaling_state: Option<FractionalScalingState>,
-
-    /// The scale factor of the window.
-    pub scale_factor: Arc<Mutex<f64>>,
-
     /// The current size of the window.
     pub size: Arc<Mutex<LogicalSize<u32>>>,
 
@@ -166,18 +151,9 @@ pub struct WindowHandle {
     /// Whether the window is resizable.
     pub is_resizable: Cell<bool>,
 
-    /// Whether the window has keyboard focus.
-    pub has_focus: Arc<AtomicBool>,
-
     /// Allow IME events for that window.
     pub ime_allowed: Cell<bool>,
 
-    /// IME purpose for that window.
-    pub ime_purpose: Cell<ImePurpose>,
-
-    /// Wether the window is transparent.
-    pub transparent: Cell<bool>,
-
     /// Visible cursor or not.
     cursor_visible: Cell<bool>,
 
@@ -205,9 +181,6 @@ impl WindowHandle {
         env: &Environment<WinitEnv>,
         window: Window<WinitFrame>,
         size: Arc<Mutex<LogicalSize<u32>>>,
-        has_focus: Arc<AtomicBool>,
-        fractional_scaling_state: Option<FractionalScalingState>,
-        scale_factor: f64,
         pending_window_requests: Arc<Mutex<Vec<WindowRequest>>>,
     ) -> Self {
         let xdg_activation = env.get_global::<XdgActivationV1>();
@@ -217,13 +190,10 @@ impl WindowHandle {
 
         Self {
             window: ManuallyDrop::new(window),
-            fractional_scaling_state,
-            scale_factor: Arc::new(Mutex::new(scale_factor)),
             size,
             pending_window_requests,
             cursor_icon: Cell::new(CursorIcon::Default),
             is_resizable: Cell::new(true),
-            transparent: Cell::new(false),
             cursor_grab_mode: Cell::new(CursorGrabMode::None),
             cursor_visible: Cell::new(true),
             pointers: Vec::new(),
@@ -232,15 +202,9 @@ impl WindowHandle {
             attention_requested: Cell::new(false),
             compositor,
             ime_allowed: Cell::new(false),
-            ime_purpose: Cell::new(ImePurpose::default()),
-            has_focus,
         }
     }
 
-    pub fn scale_factor(&self) -> f64 {
-        *self.scale_factor.lock().unwrap()
-    }
-
     pub fn set_cursor_grab(&self, mode: CursorGrabMode) {
         // The new requested state matches the current confine status, return.
         let old_mode = self.cursor_grab_mode.replace(mode);
@@ -385,19 +349,6 @@ impl WindowHandle {
         }
     }
 
-    pub fn set_transparent(&self, transparent: bool) {
-        self.transparent.set(transparent);
-        let surface = self.window.surface();
-        if transparent {
-            surface.set_opaque_region(None);
-        } else {
-            let region = self.compositor.create_region();
-            region.add(0, 0, i32::MAX, i32::MAX);
-            surface.set_opaque_region(Some(&region.detach()));
-            region.destroy();
-        }
-    }
-
     pub fn set_ime_allowed(&self, allowed: bool, event_sink: &mut EventSink) {
         if self.ime_allowed.get() == allowed {
             return;
@@ -406,9 +357,8 @@ impl WindowHandle {
         self.ime_allowed.replace(allowed);
         let window_id = wayland::make_wid(self.window.surface());
 
-        let purpose = allowed.then(|| self.ime_purpose.get());
         for text_input in self.text_inputs.iter() {
-            text_input.set_input_allowed(purpose);
+            text_input.set_input_allowed(allowed);
         }
 
         let event = if allowed {
@@ -420,20 +370,6 @@ impl WindowHandle {
         event_sink.push_window_event(event, window_id);
     }
 
-    pub fn set_ime_purpose(&self, purpose: ImePurpose) {
-        if self.ime_purpose.get() == purpose {
-            return;
-        }
-
-        self.ime_purpose.replace(purpose);
-
-        if self.ime_allowed.get() {
-            for text_input in self.text_inputs.iter() {
-                text_input.set_content_type_by_purpose(purpose);
-            }
-        }
-    }
-
     pub fn set_cursor_visible(&self, visible: bool) {
         self.cursor_visible.replace(visible);
         let cursor_icon = match visible {
@@ -497,9 +433,6 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
                     let event_sink = &mut winit_state.event_sink;
                     window_handle.set_ime_allowed(allow, event_sink);
                 }
-                WindowRequest::ImePurpose(purpose) => {
-                    window_handle.set_ime_purpose(purpose);
-                }
                 WindowRequest::SetCursorGrabMode(mode) => {
                     window_handle.set_cursor_grab(mode);
                 }
@@ -519,13 +452,6 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
                 WindowRequest::Minimize => {
                     window_handle.window.set_minimized();
                 }
-                WindowRequest::Transparent(transparent) => {
-                    window_handle.set_transparent(transparent);
-
-                    // This requires surface commit.
-                    let window_request = window_user_requests.get_mut(window_id).unwrap();
-                    window_request.redraw_requested = true;
-                }
                 WindowRequest::Decorate(decorate) => {
                     let decorations = match decorate {
                         true => Decorations::FollowServer,
@@ -538,6 +464,15 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
                     let window_request = window_user_requests.get_mut(window_id).unwrap();
                     window_request.refresh_frame = true;
                 }
+                #[cfg(feature = "sctk-adwaita")]
+                WindowRequest::CsdThemeVariant(theme) => {
+                    window_handle.window.set_frame_config(theme.into());
+
+                    let window_requst = window_user_requests.get_mut(window_id).unwrap();
+                    window_requst.refresh_frame = true;
+                }
+                #[cfg(not(feature = "sctk-adwaita"))]
+                WindowRequest::CsdThemeVariant(_) => {}
                 WindowRequest::Resizeable(resizeable) => {
                     window_handle.window.set_resizable(resizeable);
 
@@ -602,18 +537,6 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
                     let event_sink = &mut winit_state.event_sink;
                     event_sink.push_window_event(WindowEvent::Destroyed, *window_id);
                 }
-                WindowRequest::Theme(_theme) => {
-                    #[cfg(feature = "sctk-adwaita")]
-                    {
-                        window_handle.window.set_frame_config(match _theme {
-                            Some(theme) => theme.into(),
-                            None => sctk_adwaita::FrameConfig::auto(),
-                        });
-
-                        let window_requst = window_user_requests.get_mut(window_id).unwrap();
-                        window_requst.refresh_frame = true;
-                    }
-                }
             };
         }
     }
@@ -628,9 +551,6 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
 
 impl Drop for WindowHandle {
     fn drop(&mut self) {
-        // Drop the fractional scaling before the surface.
-        let _ = self.fractional_scaling_state.take();
-
         unsafe {
             let surface = self.window.surface().clone();
             // The window must be destroyed before wl_surface.
@@ -639,28 +559,3 @@ impl Drop for WindowHandle {
         }
     }
 }
-
-/// Fractional scaling objects.
-pub struct FractionalScalingState {
-    /// The wp-viewport of the window.
-    pub viewport: WpViewport,
-
-    /// The wp-fractional-scale of the window surface.
-    pub fractional_scale: WpFractionalScaleV1,
-}
-
-impl FractionalScalingState {
-    pub fn new(viewport: WpViewport, fractional_scale: WpFractionalScaleV1) -> Self {
-        Self {
-            viewport,
-            fractional_scale,
-        }
-    }
-}
-
-impl Drop for FractionalScalingState {
-    fn drop(&mut self) {
-        self.viewport.destroy();
-        self.fractional_scale.destroy();
-    }
-}

src/platform_impl/linux/x11/dnd.rs

@@ -11,7 +11,8 @@ use percent_encoding::percent_decode;
 use super::{ffi, util, XConnection, XError};
 
 #[derive(Debug)]
-pub(crate) struct DndAtoms {
+pub struct DndAtoms {
+    pub aware: ffi::Atom,
     pub enter: ffi::Atom,
     pub leave: ffi::Atom,
     pub drop: ffi::Atom,
@@ -28,6 +29,7 @@ pub(crate) struct DndAtoms {
 impl DndAtoms {
     pub fn new(xconn: &Arc<XConnection>) -> Result<Self, XError> {
         let names = [
+            b"XdndAware\0".as_ptr() as *mut c_char,
             b"XdndEnter\0".as_ptr() as *mut c_char,
             b"XdndLeave\0".as_ptr() as *mut c_char,
             b"XdndDrop\0".as_ptr() as *mut c_char,
@@ -42,17 +44,18 @@ impl DndAtoms {
         ];
         let atoms = unsafe { xconn.get_atoms(&names) }?;
         Ok(DndAtoms {
-            enter: atoms[0],
-            leave: atoms[1],
-            drop: atoms[2],
-            position: atoms[3],
-            status: atoms[4],
-            action_private: atoms[5],
-            selection: atoms[6],
-            finished: atoms[7],
-            type_list: atoms[8],
-            uri_list: atoms[9],
-            none: atoms[10],
+            aware: atoms[0],
+            enter: atoms[1],
+            leave: atoms[2],
+            drop: atoms[3],
+            position: atoms[4],
+            status: atoms[5],
+            action_private: atoms[6],
+            selection: atoms[7],
+            finished: atoms[8],
+            type_list: atoms[9],
+            uri_list: atoms[10],
+            none: atoms[11],
         })
     }
 }
@@ -84,7 +87,7 @@ impl From<io::Error> for DndDataParseError {
     }
 }
 
-pub(crate) struct Dnd {
+pub struct Dnd {
     xconn: Arc<XConnection>,
     pub atoms: DndAtoms,
     // Populated by XdndEnter event handler
@@ -185,7 +188,7 @@ impl Dnd {
             .get_property(window, self.atoms.selection, self.atoms.uri_list)
     }
 
-    pub fn parse_data(&self, data: &mut [c_uchar]) -> Result<Vec<PathBuf>, DndDataParseError> {
+    pub fn parse_data(&self, data: &mut Vec<c_uchar>) -> Result<Vec<PathBuf>, DndDataParseError> {
         if !data.is_empty() {
             let mut path_list = Vec::new();
             let decoded = percent_decode(data).decode_utf8()?.into_owned();

src/platform_impl/linux/x11/event_processor.rs

@@ -2,6 +2,8 @@ use std::{cell::RefCell, collections::HashMap, rc::Rc, slice, sync::Arc};
 
 use libc::{c_char, c_int, c_long, c_uint, c_ulong};
 
+use parking_lot::MutexGuard;
+
 use super::{
     events, ffi, get_xtarget, mkdid, mkwid, monitor, util, Device, DeviceId, DeviceInfo, Dnd,
     DndState, GenericEventCookie, ImeReceiver, ScrollOrientation, UnownedWindow, WindowId,
@@ -57,7 +59,7 @@ impl<T: 'static> EventProcessor<T> {
         F: Fn(&Arc<UnownedWindow>) -> Ret,
     {
         let mut deleted = false;
-        let window_id = WindowId(window_id as _);
+        let window_id = WindowId(window_id as u64);
         let wt = get_xtarget(&self.target);
         let result = wt
             .windows
@@ -347,11 +349,11 @@ impl<T: 'static> EventProcessor<T> {
 
                     // These are both in physical space.
                     let new_inner_size = (xev.width as u32, xev.height as u32);
-                    let new_inner_position = (xev.x, xev.y);
+                    let new_inner_position = (xev.x as i32, xev.y as i32);
+
+                    let mut shared_state_lock = window.shared_state.lock();
 
                     let (mut resized, moved) = {
-                        let mut shared_state_lock = window.shared_state_lock();
-
                         let resized =
                             util::maybe_change(&mut shared_state_lock.size, new_inner_size);
                         let moved = if is_synthetic {
@@ -378,13 +380,7 @@ impl<T: 'static> EventProcessor<T> {
                         (resized, moved)
                     };
 
-                    let position = window.shared_state_lock().position;
-
-                    let new_outer_position = if let (Some(position), false) = (position, moved) {
-                        position
-                    } else {
-                        let mut shared_state_lock = window.shared_state_lock();
-
+                    let new_outer_position = if moved || shared_state_lock.position.is_none() {
                         // We need to convert client area position to window position.
                         let frame_extents = shared_state_lock
                             .frame_extents
@@ -399,21 +395,21 @@ impl<T: 'static> EventProcessor<T> {
                         let outer = frame_extents
                             .inner_pos_to_outer(new_inner_position.0, new_inner_position.1);
                         shared_state_lock.position = Some(outer);
-
-                        // Unlock shared state to prevent deadlock in callback below
-                        drop(shared_state_lock);
-
                         if moved {
-                            callback(Event::WindowEvent {
-                                window_id,
-                                event: WindowEvent::Moved(outer.into()),
+                            // Temporarily unlock shared state to prevent deadlock
+                            MutexGuard::unlocked(&mut shared_state_lock, || {
+                                callback(Event::WindowEvent {
+                                    window_id,
+                                    event: WindowEvent::Moved(outer.into()),
+                                });
                             });
                         }
                         outer
+                    } else {
+                        shared_state_lock.position.unwrap()
                     };
 
                     if is_synthetic {
-                        let mut shared_state_lock = window.shared_state_lock();
                         // If we don't use the existing adjusted value when available, then the user can screw up the
                         // resizing by dragging across monitors *without* dropping the window.
                         let (width, height) = shared_state_lock
@@ -445,15 +441,15 @@ impl<T: 'static> EventProcessor<T> {
                             let old_inner_size = PhysicalSize::new(width, height);
                             let mut new_inner_size = PhysicalSize::new(new_width, new_height);
 
-                            // Unlock shared state to prevent deadlock in callback below
-                            drop(shared_state_lock);
-
-                            callback(Event::WindowEvent {
-                                window_id,
-                                event: WindowEvent::ScaleFactorChanged {
-                                    scale_factor: new_scale_factor,
-                                    new_inner_size: &mut new_inner_size,
-                                },
+                            // Temporarily unlock shared state to prevent deadlock
+                            MutexGuard::unlocked(&mut shared_state_lock, || {
+                                callback(Event::WindowEvent {
+                                    window_id,
+                                    event: WindowEvent::ScaleFactorChanged {
+                                        scale_factor: new_scale_factor,
+                                        new_inner_size: &mut new_inner_size,
+                                    },
+                                });
                             });
 
                             if new_inner_size != old_inner_size {
@@ -461,8 +457,7 @@ impl<T: 'static> EventProcessor<T> {
                                     new_inner_size.width,
                                     new_inner_size.height,
                                 );
-                                window.shared_state_lock().dpi_adjusted =
-                                    Some(new_inner_size.into());
+                                shared_state_lock.dpi_adjusted = Some(new_inner_size.into());
                                 // if the DPI factor changed, force a resize event to ensure the logical
                                 // size is computed with the right DPI factor
                                 resized = true;
@@ -470,8 +465,6 @@ impl<T: 'static> EventProcessor<T> {
                         }
                     }
 
-                    let mut shared_state_lock = window.shared_state_lock();
-
                     // This is a hack to ensure that the DPI adjusted resize is actually applied on all WMs. KWin
                     // doesn't need this, but Xfwm does. The hack should not be run on other WMs, since tiling
                     // WMs constrain the window size, making the resize fail. This would cause an endless stream of
@@ -485,10 +478,10 @@ impl<T: 'static> EventProcessor<T> {
                         }
                     }
 
-                    // Unlock shared state to prevent deadlock in callback below
-                    drop(shared_state_lock);
-
                     if resized {
+                        // Drop the shared state lock to prevent deadlock
+                        drop(shared_state_lock);
+
                         callback(Event::WindowEvent {
                             window_id,
                             event: WindowEvent::Resized(new_inner_size.into()),
@@ -511,24 +504,7 @@ impl<T: 'static> EventProcessor<T> {
                     window.invalidate_cached_frame_extents();
                 });
             }
-            ffi::MapNotify => {
-                let xev: &ffi::XMapEvent = xev.as_ref();
-                let window = xev.window;
-                let window_id = mkwid(window);
 
-                // XXX re-issue the focus state when mapping the window.
-                //
-                // The purpose of it is to deliver initial focused state of the newly created
-                // window, given that we can't rely on `CreateNotify`, due to it being not
-                // sent.
-                let focus = self
-                    .with_window(window, |window| window.has_focus())
-                    .unwrap_or_default();
-                callback(Event::WindowEvent {
-                    window_id,
-                    event: WindowEvent::Focused(focus),
-                });
-            }
             ffi::DestroyNotify => {
                 let xev: &ffi::XDestroyWindowEvent = xev.as_ref();
 
@@ -537,7 +513,7 @@ impl<T: 'static> EventProcessor<T> {
 
                 // In the event that the window's been destroyed without being dropped first, we
                 // cleanup again here.
-                wt.windows.borrow_mut().remove(&WindowId(window as _));
+                wt.windows.borrow_mut().remove(&WindowId(window as u64));
 
                 // Since all XIM stuff needs to happen from the same thread, we destroy the input
                 // context here instead of when dropping the window.
@@ -777,7 +753,7 @@ impl<T: 'static> EventProcessor<T> {
                         update_modifiers!(modifiers, None);
 
                         let cursor_moved = self.with_window(xev.event, |window| {
-                            let mut shared_state_lock = window.shared_state_lock();
+                            let mut shared_state_lock = window.shared_state.lock();
                             util::maybe_change(&mut shared_state_lock.cursor_pos, new_cursor_pos)
                         });
                         if cursor_moved == Some(true) {
@@ -947,10 +923,6 @@ impl<T: 'static> EventProcessor<T> {
                             let window_id = mkwid(xev.event);
                             let position = PhysicalPosition::new(xev.event_x, xev.event_y);
 
-                            if let Some(window) = self.with_window(xev.event, Arc::clone) {
-                                window.shared_state_lock().has_focus = true;
-                            }
-
                             callback(Event::WindowEvent {
                                 window_id,
                                 event: Focused(true),
@@ -1023,10 +995,6 @@ impl<T: 'static> EventProcessor<T> {
                                 event: WindowEvent::ModifiersChanged(ModifiersState::empty()),
                             });
 
-                            if let Some(window) = self.with_window(xev.event, Arc::clone) {
-                                window.shared_state_lock().has_focus = false;
-                            }
-
                             callback(Event::WindowEvent {
                                 window_id,
                                 event: Focused(false),
@@ -1046,7 +1014,8 @@ impl<T: 'static> EventProcessor<T> {
                         if self.window_exists(xev.event) {
                             let id = xev.detail as u64;
                             let modifiers = self.device_mod_state.modifiers();
-                            let location = PhysicalPosition::new(xev.event_x, xev.event_y);
+                            let location =
+                                PhysicalPosition::new(xev.event_x as f64, xev.event_y as f64);
 
                             // Mouse cursor position changes when touch events are received.
                             // Only the first concurrently active touch ID moves the mouse cursor.
@@ -1252,7 +1221,7 @@ impl<T: 'static> EventProcessor<T> {
                                                 new_monitor.scale_factor,
                                                 width,
                                                 height,
-                                                &window.shared_state_lock(),
+                                                &*window.shared_state.lock(),
                                             );
 
                                             let window_id = crate::window::WindowId(*window_id);

src/platform_impl/linux/x11/ime/callbacks.rs

@@ -8,7 +8,7 @@ use super::{
     input_method::PotentialInputMethods,
 };
 
-pub(crate) unsafe fn xim_set_callback(
+pub unsafe fn xim_set_callback(
     xconn: &Arc<XConnection>,
     xim: ffi::XIM,
     field: *const c_char,
@@ -26,7 +26,7 @@ pub(crate) unsafe fn xim_set_callback(
 // * This is called per locale modifier, not per input method opened with that locale modifier.
 // * Trying to set this for multiple locale modifiers causes problems, i.e. one of the rebuilt
 //   input contexts would always silently fail to use the input method.
-pub(crate) unsafe fn set_instantiate_callback(
+pub unsafe fn set_instantiate_callback(
     xconn: &Arc<XConnection>,
     client_data: ffi::XPointer,
 ) -> Result<(), XError> {
@@ -41,7 +41,7 @@ pub(crate) unsafe fn set_instantiate_callback(
     xconn.check_errors()
 }
 
-pub(crate) unsafe fn unset_instantiate_callback(
+pub unsafe fn unset_instantiate_callback(
     xconn: &Arc<XConnection>,
     client_data: ffi::XPointer,
 ) -> Result<(), XError> {
@@ -56,7 +56,7 @@ pub(crate) unsafe fn unset_instantiate_callback(
     xconn.check_errors()
 }
 
-pub(crate) unsafe fn set_destroy_callback(
+pub unsafe fn set_destroy_callback(
     xconn: &Arc<XConnection>,
     im: ffi::XIM,
     inner: &ImeInner,
@@ -72,8 +72,7 @@ pub(crate) unsafe fn set_destroy_callback(
 #[derive(Debug)]
 #[allow(clippy::enum_variant_names)]
 enum ReplaceImError {
-    // Boxed to prevent large error type
-    MethodOpenFailed(Box<PotentialInputMethods>),
+    MethodOpenFailed(PotentialInputMethods),
     ContextCreationFailed(ImeContextCreationError),
     SetDestroyCallbackFailed(XError),
 }
@@ -89,7 +88,7 @@ unsafe fn replace_im(inner: *mut ImeInner) -> Result<(), ReplaceImError> {
         let is_fallback = new_im.is_fallback();
         (
             new_im.ok().ok_or_else(|| {
-                ReplaceImError::MethodOpenFailed(Box::new((*inner).potential_input_methods.clone()))
+                ReplaceImError::MethodOpenFailed((*inner).potential_input_methods.clone())
             })?,
             is_fallback,
         )
@@ -168,7 +167,7 @@ pub unsafe extern "C" fn xim_instantiate_callback(
             Err(err) => {
                 if (*inner).is_destroyed {
                     // We have no usable input methods!
-                    panic!("Failed to reopen input method: {err:?}");
+                    panic!("Failed to reopen input method: {:?}", err);
                 }
             }
         }
@@ -195,7 +194,7 @@ pub unsafe extern "C" fn xim_destroy_callback(
                 Ok(()) => (*inner).is_fallback = true,
                 Err(err) => {
                     // We have no usable input methods!
-                    panic!("Failed to open fallback input method: {err:?}");
+                    panic!("Failed to open fallback input method: {:?}", err);
                 }
             }
         }

src/platform_impl/linux/x11/ime/context.rs

@@ -201,7 +201,7 @@ pub struct ImeContext {
 }
 
 impl ImeContext {
-    pub(crate) unsafe fn new(
+    pub unsafe fn new(
         xconn: &Arc<XConnection>,
         im: ffi::XIM,
         style: Style,
@@ -323,14 +323,14 @@ impl ImeContext {
         (!ic.is_null()).then(|| ic)
     }
 
-    pub(crate) fn focus(&self, xconn: &Arc<XConnection>) -> Result<(), XError> {
+    pub fn focus(&self, xconn: &Arc<XConnection>) -> Result<(), XError> {
         unsafe {
             (xconn.xlib.XSetICFocus)(self.ic);
         }
         xconn.check_errors()
     }
 
-    pub(crate) fn unfocus(&self, xconn: &Arc<XConnection>) -> Result<(), XError> {
+    pub fn unfocus(&self, xconn: &Arc<XConnection>) -> Result<(), XError> {
         unsafe {
             (xconn.xlib.XUnsetICFocus)(self.ic);
         }
@@ -346,7 +346,7 @@ impl ImeContext {
     // window and couldn't be changed.
     //
     // For me see: https://bugs.freedesktop.org/show_bug.cgi?id=1580.
-    pub(crate) fn set_spot(&mut self, xconn: &Arc<XConnection>, x: c_short, y: c_short) {
+    pub fn set_spot(&mut self, xconn: &Arc<XConnection>, x: c_short, y: c_short) {
         if !self.is_allowed() || self.ic_spot.x == x && self.ic_spot.y == y {
             return;
         }

src/platform_impl/linux/x11/ime/inner.rs

@@ -8,17 +8,17 @@ use super::{
 };
 use crate::platform_impl::platform::x11::ime::ImeEventSender;
 
-pub(crate) unsafe fn close_im(xconn: &Arc<XConnection>, im: ffi::XIM) -> Result<(), XError> {
+pub unsafe fn close_im(xconn: &Arc<XConnection>, im: ffi::XIM) -> Result<(), XError> {
     (xconn.xlib.XCloseIM)(im);
     xconn.check_errors()
 }
 
-pub(crate) unsafe fn destroy_ic(xconn: &Arc<XConnection>, ic: ffi::XIC) -> Result<(), XError> {
+pub unsafe fn destroy_ic(xconn: &Arc<XConnection>, ic: ffi::XIC) -> Result<(), XError> {
     (xconn.xlib.XDestroyIC)(ic);
     xconn.check_errors()
 }
 
-pub(crate) struct ImeInner {
+pub struct ImeInner {
     pub xconn: Arc<XConnection>,
     pub im: Option<InputMethod>,
     pub potential_input_methods: PotentialInputMethods,
@@ -33,7 +33,7 @@ pub(crate) struct ImeInner {
 }
 
 impl ImeInner {
-    pub(crate) fn new(
+    pub fn new(
         xconn: Arc<XConnection>,
         potential_input_methods: PotentialInputMethods,
         event_sender: ImeEventSender,

src/platform_impl/linux/x11/ime/input_method.rs

@@ -4,10 +4,11 @@ use std::{
     fmt,
     os::raw::{c_char, c_ulong, c_ushort},
     ptr,
-    sync::{Arc, Mutex},
+    sync::Arc,
 };
 
 use once_cell::sync::Lazy;
+use parking_lot::Mutex;
 
 use super::{ffi, util, XConnection, XError};
 
@@ -263,7 +264,7 @@ impl PotentialInputMethod {
 // By logging this struct, you get a sequential listing of every locale modifier tried, where it
 // came from, and if it succeeded.
 #[derive(Debug, Clone)]
-pub(crate) struct PotentialInputMethods {
+pub struct PotentialInputMethods {
     // On correctly configured systems, the XMODIFIERS environment variable tells us everything we
     // need to know.
     xmodifiers: Option<PotentialInputMethod>,

src/platform_impl/linux/x11/ime/mod.rs

@@ -45,13 +45,12 @@ pub enum ImeRequest {
 }
 
 #[derive(Debug)]
-pub(crate) enum ImeCreationError {
-    // Boxed to prevent large error type
-    OpenFailure(Box<PotentialInputMethods>),
+pub enum ImeCreationError {
+    OpenFailure(PotentialInputMethods),
     SetDestroyCallbackFailed(XError),
 }
 
-pub(crate) struct Ime {
+pub struct Ime {
     xconn: Arc<XConnection>,
     // The actual meat of this struct is boxed away, since it needs to have a fixed location in
     // memory so we can pass a pointer to it around.
@@ -91,7 +90,7 @@ impl Ime {
         if let Some(input_method) = input_method.ok() {
             inner.is_fallback = is_fallback;
             unsafe {
-                let result = set_destroy_callback(&xconn, input_method.im, &inner)
+                let result = set_destroy_callback(&xconn, input_method.im, &*inner)
                     .map_err(ImeCreationError::SetDestroyCallbackFailed);
                 if result.is_err() {
                     let _ = close_im(&xconn, input_method.im);
@@ -101,9 +100,7 @@ impl Ime {
             inner.im = Some(input_method);
             Ok(Ime { xconn, inner })
         } else {
-            Err(ImeCreationError::OpenFailure(Box::new(
-                inner.potential_input_methods,
-            )))
+            Err(ImeCreationError::OpenFailure(inner.potential_input_methods))
         }
     }
 
@@ -171,7 +168,7 @@ impl Ime {
         if self.is_destroyed() {
             return None;
         }
-        if let Some(Some(context)) = self.inner.contexts.get(&window) {
+        if let Some(&Some(ref context)) = self.inner.contexts.get(&window) {
             Some(context.ic)
         } else {
             None

src/platform_impl/linux/x11/mod.rs

@@ -1,4 +1,10 @@
-#![cfg(x11_platform)]
+#![cfg(any(
+    target_os = "linux",
+    target_os = "dragonfly",
+    target_os = "freebsd",
+    target_os = "netbsd",
+    target_os = "openbsd"
+))]
 
 mod dnd;
 mod event_processor;
@@ -10,14 +16,12 @@ pub mod util;
 mod window;
 mod xdisplay;
 
-pub(crate) use self::{
+pub use self::{
     monitor::{MonitorHandle, VideoMode},
     window::UnownedWindow,
-    xdisplay::XConnection,
+    xdisplay::{XConnection, XError, XNotSupported},
 };
 
-pub use self::xdisplay::{XError, XNotSupported};
-
 use std::{
     cell::{Cell, RefCell},
     collections::{HashMap, HashSet},
@@ -137,7 +141,7 @@ impl<T: 'static> Clone for EventLoopProxy<T> {
 }
 
 impl<T: 'static> EventLoop<T> {
-    pub(crate) fn new(xconn: Arc<XConnection>) -> EventLoop<T> {
+    pub fn new(xconn: Arc<XConnection>) -> EventLoop<T> {
         let root = unsafe { (xconn.xlib.XDefaultRootWindow)(xconn.display) };
 
         let wm_delete_window = unsafe { xconn.get_atom_unchecked(b"WM_DELETE_WINDOW\0") };
@@ -175,7 +179,7 @@ impl<T: 'static> EventLoop<T> {
         let ime = RefCell::new({
             let result = Ime::new(Arc::clone(&xconn), ime_event_sender);
             if let Err(ImeCreationError::OpenFailure(ref state)) = result {
-                panic!("Failed to open input method: {state:#?}");
+                panic!("Failed to open input method: {:#?}", state);
             }
             result.expect("Failed to set input method destruction callback")
         });
@@ -212,7 +216,8 @@ impl<T: 'static> EventLoop<T> {
             ) != ffi::Success as libc::c_int
             {
                 panic!(
-                    "X server has XInput extension {xinput_major_ver}.{xinput_minor_ver} but does not support XInput2",
+                    "X server has XInput extension {}.{} but does not support XInput2",
+                    xinput_major_ver, xinput_minor_ver,
                 );
             }
         }
@@ -453,7 +458,7 @@ impl<T: 'static> EventLoop<T> {
                 // Wait until
                 if let Err(e) = self.poll.poll(&mut events, iter_result.timeout) {
                     if e.raw_os_error() != Some(libc::EINTR) {
-                        panic!("epoll returned an error: {e:?}");
+                        panic!("epoll returned an error: {:?}", e);
                     }
                 }
                 events.clear();
@@ -531,7 +536,7 @@ impl<T: 'static> EventLoop<T> {
 pub(crate) fn get_xtarget<T>(target: &RootELW<T>) -> &EventLoopWindowTarget<T> {
     match target.p {
         super::EventLoopWindowTarget::X(ref target) => target,
-        #[cfg(wayland_platform)]
+        #[cfg(feature = "wayland")]
         _ => unreachable!(),
     }
 }
@@ -539,7 +544,7 @@ pub(crate) fn get_xtarget<T>(target: &RootELW<T>) -> &EventLoopWindowTarget<T> {
 impl<T> EventLoopWindowTarget<T> {
     /// Returns the `XConnection` of this events loop.
     #[inline]
-    pub(crate) fn x_connection(&self) -> &Arc<XConnection> {
+    pub fn x_connection(&self) -> &Arc<XConnection> {
         &self.xconn
     }
 
@@ -628,19 +633,18 @@ impl<'a> Deref for DeviceInfo<'a> {
 pub struct DeviceId(c_int);
 
 impl DeviceId {
-    #[allow(unused)]
     pub const unsafe fn dummy() -> Self {
         DeviceId(0)
     }
 }
 
-pub(crate) struct Window(Arc<UnownedWindow>);
+pub struct Window(Arc<UnownedWindow>);
 
 impl Deref for Window {
     type Target = UnownedWindow;
     #[inline]
     fn deref(&self) -> &UnownedWindow {
-        &self.0
+        &*self.0
     }
 }
 
@@ -707,7 +711,7 @@ struct XExtension {
 }
 
 fn mkwid(w: ffi::Window) -> crate::window::WindowId {
-    crate::window::WindowId(crate::platform_impl::platform::WindowId(w as _))
+    crate::window::WindowId(crate::platform_impl::platform::WindowId(w as u64))
 }
 fn mkdid(w: c_int) -> crate::event::DeviceId {
     crate::event::DeviceId(crate::platform_impl::DeviceId::X(DeviceId(w)))

src/platform_impl/linux/x11/monitor.rs

@@ -1,8 +1,8 @@
 use std::os::raw::*;
 use std::slice;
-use std::sync::Mutex;
 
 use once_cell::sync::Lazy;
+use parking_lot::Mutex;
 
 use super::{
     ffi::{
@@ -13,6 +13,7 @@ use super::{
 };
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize},
+    monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
     platform_impl::{MonitorHandle as PlatformMonitorHandle, VideoMode as PlatformVideoMode},
 };
 
@@ -23,7 +24,7 @@ static MONITORS: Lazy<Mutex<Option<Vec<MonitorHandle>>>> = Lazy::new(Mutex::defa
 
 pub fn invalidate_cached_monitor_list() -> Option<Vec<MonitorHandle>> {
     // We update this lazily.
-    (*MONITORS.lock().unwrap()).take()
+    (*MONITORS.lock()).take()
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -52,8 +53,10 @@ impl VideoMode {
     }
 
     #[inline]
-    pub fn monitor(&self) -> PlatformMonitorHandle {
-        PlatformMonitorHandle::X(self.monitor.clone().unwrap())
+    pub fn monitor(&self) -> RootMonitorHandle {
+        RootMonitorHandle {
+            inner: PlatformMonitorHandle::X(self.monitor.clone().unwrap()),
+        }
     }
 }
 
@@ -108,7 +111,6 @@ impl std::hash::Hash for MonitorHandle {
 #[inline]
 pub fn mode_refresh_rate_millihertz(mode: &XRRModeInfo) -> Option<u32> {
     if mode.dotClock > 0 && mode.hTotal > 0 && mode.vTotal > 0 {
-        #[allow(clippy::unnecessary_cast)]
         Some((mode.dotClock as u64 * 1000 / (mode.hTotal as u64 * mode.vTotal as u64)) as u32)
     } else {
         None
@@ -124,8 +126,8 @@ impl MonitorHandle {
         primary: bool,
     ) -> Option<Self> {
         let (name, scale_factor, video_modes) = unsafe { xconn.get_output_info(resources, crtc)? };
-        let dimensions = unsafe { ((*crtc).width, (*crtc).height) };
-        let position = unsafe { ((*crtc).x, (*crtc).y) };
+        let dimensions = unsafe { ((*crtc).width as u32, (*crtc).height as u32) };
+        let position = unsafe { ((*crtc).x as i32, (*crtc).y as i32) };
 
         // Get the refresh rate of the current video mode.
         let current_mode = unsafe { (*crtc).mode };
@@ -176,7 +178,7 @@ impl MonitorHandle {
 
     #[inline]
     pub fn native_identifier(&self) -> u32 {
-        self.id as _
+        self.id as u32
     }
 
     pub fn size(&self) -> PhysicalSize<u32> {
@@ -197,11 +199,13 @@ impl MonitorHandle {
     }
 
     #[inline]
-    pub fn video_modes(&self) -> impl Iterator<Item = PlatformVideoMode> {
+    pub fn video_modes(&self) -> impl Iterator<Item = RootVideoMode> {
         let monitor = self.clone();
         self.video_modes.clone().into_iter().map(move |mut x| {
             x.monitor = Some(monitor.clone());
-            PlatformVideoMode::X(x)
+            RootVideoMode {
+                video_mode: PlatformVideoMode::X(x),
+            }
         })
     }
 }
@@ -289,7 +293,7 @@ impl XConnection {
     }
 
     pub fn available_monitors(&self) -> Vec<MonitorHandle> {
-        let mut monitors_lock = MONITORS.lock().unwrap();
+        let mut monitors_lock = MONITORS.lock();
         (*monitors_lock)
             .as_ref()
             .cloned()

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

@@ -3,10 +3,10 @@ use std::{
     ffi::{CStr, CString},
     fmt::Debug,
     os::raw::*,
-    sync::Mutex,
 };
 
 use once_cell::sync::Lazy;
+use parking_lot::Mutex;
 
 use super::*;
 
@@ -17,7 +17,7 @@ static ATOM_CACHE: Lazy<Mutex<AtomCache>> = Lazy::new(|| Mutex::new(HashMap::wit
 impl XConnection {
     pub fn get_atom<T: AsRef<CStr> + Debug>(&self, name: T) -> ffi::Atom {
         let name = name.as_ref();
-        let mut atom_cache_lock = ATOM_CACHE.lock().unwrap();
+        let mut atom_cache_lock = ATOM_CACHE.lock();
         let cached_atom = (*atom_cache_lock).get(name).cloned();
         if let Some(atom) = cached_atom {
             atom