Update to newest master

Signed-off-by: John Nunley <dev@notgull.net>

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "deps/apk-builder"]
-	path = deps/apk-builder
-	url = https://github.com/rust-windowing/android-rs-glue

CHANGELOG.md

@@ -11,6 +11,45 @@ Unreleased` header.
 
 # Unreleased
 
+- On Windows, macOS, X11, Wayland and Web, implement setting images as cursors. See the `custom_cursors.rs` example.
+  - Add `Window::set_custom_cursor`
+  - Add `CustomCursor`
+  - Add `CustomCursor::from_rgba` to allow creating cursor images from RGBA data.
+  - Add `CustomCursorExtWebSys::from_url` to allow loading cursor images from URLs.
+- On macOS, add services menu.
+- On macOS, remove spurious error logging when handling `Fn`.
+- On X11, fix an issue where floating point data from the server is
+  misinterpreted during a drag and drop operation.
+- On X11, fix a bug where focusing the window would panic.
+- On macOS, fix `refresh_rate_millihertz`.
+- On Wayland, disable Client Side Decorations when `wl_subcompositor` is not supported.
+- On X11, fix `Xft.dpi` detection from Xresources.
+- On Windows, fix consecutive calls to `window.set_fullscreen(Some(Fullscreen::Borderless(None)))` resulting in losing previous window state when eventually exiting fullscreen using `window.set_fullscreen(None)`.
+- On Web, remove queuing fullscreen request in absence of transient activation.
+- On Web, fix setting cursor icon overriding cursor visibility.
+
+# 0.29.4
+
+- Fix crash when running iOS app on macOS.
+- On X11, check common alternative cursor names when loading cursor.
+- On X11, reload the DPI after a property change event.
+- On Windows, fix so `drag_window` and `drag_resize_window` can be called from another thread.
+- On Windows, fix `set_control_flow` in `AboutToWait` not being taken in account.
+- On macOS, send a `Resized` event after each `ScaleFactorChanged` event.
+- On Wayland, fix `wl_surface` being destroyed before associated objects.
+- On macOS, fix assertion when pressing `Fn` key.
+
+# 0.29.3
+
+- On Wayland, apply correct scale to `PhysicalSize` passed in `WindowBuilder::with_inner_size` when possible.
+- On Wayland, fix `RedrawRequsted` being always sent without decorations and `sctk-adwaita` feature.
+- On Wayland, ignore resize requests when the window is fully tiled.
+- On Wayland, use `configure_bounds` to constrain `with_inner_size` when compositor wants users to pick size.
+- On Windows, fix deadlock when accessing the state during `Cursor{Enter,Leave}`.
+- On Windows, add support for `Window::set_transparent`.
+- On macOS, fix deadlock when entering a nested event loop from an event handler.
+- On macOS, add support for `Window::set_blur`.
+
 # 0.29.2
 
 - **Breaking:** Bump MSRV from `1.60` to `1.65`.

CONTRIBUTING.md

@@ -11,7 +11,7 @@ may be worth creating a separate crate that extends Winit's API to add that func
 When reporting an issue, in order to help the maintainers understand what the problem is, please make
 your description of the issue as detailed as possible:
 
-- if it is a bug, please provide clear explanation of what happens, what should happen, and how to
+- if it is a bug, please provide a clear explanation of what happens, what should happen, and how to
   reproduce the issue, ideally by providing a minimal program exhibiting the problem
 - if it is a feature request, please provide a clear argumentation about why you believe this feature
   should be supported by winit
@@ -21,7 +21,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.65.
-- you tested your modifications on all the platforms impacted, or if not possible detail which platforms
+- you tested your modifications on all the platforms impacted, or if not possible, detail which platforms
   were not tested, and what should be tested, so that a maintainer or another contributor can test them
 - you updated any relevant documentation in winit
 - you left comments in your code explaining any part that is not straightforward, so that the
@@ -34,7 +34,7 @@ When making a code contribution to winit, before opening your pull request, plea
   relevant sections in [`FEATURES.md`](https://github.com/rust-windowing/winit/blob/master/FEATURES.md#features)
   should be updated.
 
-Once your PR is open, you can ask for review by a maintainer of your platform. Winit's merging policy
+Once your PR is open, you can ask for a review by a maintainer of your platform. Winit's merging policy
 is that a PR must be approved by at least two maintainers of winit before being merged, including
 at least a maintainer of the platform (a maintainer making a PR themselves counts as approving it).
 
@@ -46,27 +46,26 @@ Once your PR is deemed ready, the merging maintainer will take care of resolving
 
 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!
+If you are interested in being pinged when testing is needed for a specific platform, please add yourself to the [Testers and Contributors](https://github.com/rust-windowing/winit/wiki/Testers-and-Contributors) table!
 
 ## Release process
 
-Given that winit is a widely used library we should be able to make a patch
+Given that winit is a widely used library, we should be able to make a patch
 releases at any time we want without blocking the development of new features.
 
-To achieve these goals, a new branch is created for every new release. Releases
-and later patch releases are committed and tagged in this branch.
+To achieve these goals, a new branch is created for every new release. Releases and later patch releases are committed and tagged in this branch.
 
 The exact steps for an exemplary `0.2.0` release might look like this:
-  1. Initially the version on the latest master is `0.1.0`
+  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
+  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`
+When doing a patch release, the process is similar:
+  1. Initially, the version of the latest release is `0.2.0`
   2. Checkout the `v0.2.x` branch
   3. Cherry-pick the required non-breaking changes into the `v0.2.x`
   4. Follow steps 3-7 of the regular release example

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.29.2"
+version = "0.29.4"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 edition = "2021"
@@ -13,7 +13,14 @@ categories = ["gui"]
 rust-version = "1.65.0"
 
 [package.metadata.docs.rs]
-features = ["rwh_04", "rwh_05", "rwh_06", "serde"]
+features = [
+    "rwh_04",
+    "rwh_05",
+    "rwh_06",
+    "serde",
+    # Enabled to get docs to compile
+    "android-native-activity",
+]
 default-target = "x86_64-unknown-linux-gnu"
 # These are all tested in CI
 targets = [
@@ -36,7 +43,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
 default = ["rwh_06", "x11", "wayland", "wayland-dlopen", "wayland-csd-adwaita"]
-x11 = ["x11-dl", "bytemuck", "percent-encoding", "xkbcommon-dl/x11", "x11rb"]
+x11 = ["x11-dl", "bytemuck", "percent-encoding", "xkbcommon-dl/x11", "x11rb", "xim"]
 wayland = ["wayland-client", "wayland-backend", "wayland-protocols", "wayland-protocols-plasma", "sctk", "ahash", "memmap2"]
 wayland-dlopen = ["wayland-backend/dlopen"]
 wayland-csd-adwaita = ["sctk-adwaita", "sctk-adwaita/ab_glyph"]
@@ -54,7 +61,7 @@ cfg_aliases = "0.1.1"
 
 [dependencies]
 bitflags = "2"
-cursor-icon = "1.0.0"
+cursor-icon = "1.1.0"
 log = "0.4"
 mint = { version = "0.5.6", optional = true }
 once_cell = "1.12"
@@ -74,7 +81,7 @@ softbuffer = "0.3.0"
 
 [target.'cfg(target_os = "android")'.dependencies]
 android-activity = "0.5.0"
-ndk = "0.8.0"
+ndk = { version = "0.8.0", default-features = false }
 ndk-sys = "0.5.0"
 
 [target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
@@ -153,13 +160,14 @@ memmap2 = { version = "0.9.0", optional = true }
 percent-encoding = { version = "2.0", optional = true }
 rustix = { version = "0.38.4", default-features = false, features = ["std", "system", "thread", "process"] }
 sctk = { package = "smithay-client-toolkit", version = "0.18.0", default-features = false, features = ["calloop"], optional = true }
-sctk-adwaita = { version = "0.7.0", default_features = false, optional = true }
+sctk-adwaita = { version = "0.8.0", default_features = false, optional = true }
 wayland-backend = { version = "0.3.0", default_features = false, features = ["client_system"], optional = true }
 wayland-client = { version = "0.31.1", optional = true }
 wayland-protocols = { version = "0.31.0", features = [ "staging"], optional = true }
 wayland-protocols-plasma = { version = "0.2.0", features = [ "client" ], optional = true }
 x11-dl = { version = "2.18.5", optional = true }
-x11rb = { version = "0.12.0", default-features = false, features = ["allow-unsafe-code", "dl-libxcb", "randr", "resource_manager", "xinput", "xkb"], optional = true }
+x11rb = { version = "0.13.0", default-features = false, features = ["allow-unsafe-code", "dl-libxcb", "randr", "resource_manager", "xinput", "xkb"], optional = true }
+xim = { version = "0.3.0", features = ["x11rb-client", "client"], optional = true }
 xkbcommon-dl = "0.4.0"
 
 [target.'cfg(target_os = "redox")'.dependencies]
@@ -172,6 +180,7 @@ version = "0.3.64"
 features = [
     'AbortController',
     'AbortSignal',
+    'Blob',
     'console',
     'CssStyleDeclaration',
     'Document',
@@ -183,6 +192,10 @@ features = [
     'FocusEvent',
     'HtmlCanvasElement',
     'HtmlElement',
+    'ImageBitmap',
+    'ImageBitmapOptions',
+    'ImageBitmapRenderingContext',
+    'ImageData',
     'IntersectionObserver',
     'IntersectionObserverEntry',
     'KeyboardEvent',
@@ -192,6 +205,7 @@ features = [
     'Node',
     'PageTransitionEvent',
     'PointerEvent',
+    'PremultiplyAlpha',
     'ResizeObserver',
     'ResizeObserverBoxOptions',
     'ResizeObserverEntry',
@@ -199,7 +213,8 @@ features = [
     'ResizeObserverSize',
     'VisibilityState',
     'Window',
-    'WheelEvent'
+    'WheelEvent',
+    'Url',
 ]
 
 [target.'cfg(target_family = "wasm")'.dependencies]
@@ -217,3 +232,6 @@ web-sys = { version = "0.3.22", features = ['CanvasRenderingContext2d'] }
 members = [
     "run-wasm",
 ]
+
+[patch.crates-io]
+xim = { git = "https://github.com/forkgull/xim-rs", branch = "x11rb-13" }

FEATURES.md

@@ -1,6 +1,6 @@
 # Winit Scope
 
-Winit aims to expose an interface that abstracts over window creation and input handling, and can
+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:
 - Desktop
   - Windows 7+ (10+ is tested regularly)
@@ -45,10 +45,10 @@ be released and the library will enter maintenance mode. For the most part, new
 be added past this point. New platform features may be accepted and exposed through point releases.
 
 ### Tier upgrades
-Some platform features could in theory be exposed across multiple platforms, but have not gone
+Some platform features could, in theory, be exposed across multiple platforms, but have not gone
 through the implementation work necessary to function on all platforms. When one of these features
 gets implemented across all platforms, a PR can be opened to upgrade the feature to a core feature.
-If that gets accepted, the platform-specific functions gets deprecated and become permanently
+If that gets accepted, the platform-specific functions get deprecated and become permanently
 exposed through the core, cross-platform API.
 
 # Features
@@ -88,7 +88,7 @@ If your PR makes notable changes to Winit's features, please update this section
 - **Fullscreen toggle**: The windows created by winit can be switched to and from fullscreen after
   creation.
 - **Exclusive fullscreen**: Winit allows changing the video mode of the monitor
-  for fullscreen windows, and if applicable, captures the monitor for exclusive
+  for fullscreen windows and, if applicable, captures the monitor for exclusive
   use by this application.
 - **HiDPI support**: Winit assists developers in appropriately scaling HiDPI content.
 - **Popup / modal windows**: Windows can be created relative to the client area of other windows, and parent
@@ -105,7 +105,8 @@ If your PR makes notable changes to Winit's features, please update this section
 - **Mouse set location**: Forcibly changing the location of the pointer.
 - **Cursor locking**: Locking the cursor inside the window so it cannot move.
 - **Cursor confining**: Confining the cursor to the window bounds so it cannot leave them.
-- **Cursor icon**: Changing the cursor icon, or hiding the cursor.
+- **Cursor icon**: Changing the cursor icon or hiding the cursor.
+- **Cursor image**: Changing the cursor to your own image.
 - **Cursor hittest**: Handle or ignore mouse events for a window.
 - **Touch events**: Single-touch events.
 - **Touch pressure**: Touch events contain information about the amount of force being applied.
@@ -151,12 +152,12 @@ If your PR makes notable changes to Winit's features, please update this section
 * Valid orientations
 * Home indicator visibility
 * Status bar visibility and style
-* Deferrring system gestures
+* Deferring system gestures
 * Getting the device idiom
 * Getting the preferred video mode
 
 ### Web
-* Get if systems preferred color scheme is "dark"
+* Get if the systems preferred color scheme is "dark"
 
 ## Usability
 * `serde`: Enables serialization/deserialization of certain types with Serde. (Maintainer: @Osspial)
@@ -166,7 +167,7 @@ If your PR makes notable changes to Winit's features, please update this section
 Legend:
 
 - ✔️: Works as intended
-- ▢: Mostly works but some bugs are known
+- ▢: Mostly works, but some bugs are known
 - ❌: Missing feature or large bugs making it unusable
 - **N/A**: Not applicable for this platform
 - ❓: Unknown status
@@ -206,6 +207,7 @@ Legend:
 |Cursor locking          |❌       |✔️      |❌       |✔️          |**N/A**|**N/A**|✔️        |❌      |
 |Cursor confining        |✔️       |❌      |✔️       |✔️          |**N/A**|**N/A**|❌       |❌      |
 |Cursor icon             |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|✔️        |**N/A** |
+|Cursor image            |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|✔️        |**N/A** |
 |Cursor hittest          |✔️       |✔️      |✔️       |✔️          |**N/A**|**N/A**|❌        |❌      |
 |Touch events            |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |✔️        |**N/A** |
 |Touch pressure          |✔️       |❌      |❌       |❌          |❌    |✔️     |✔️        |**N/A** |

HALL_OF_CHAMPIONS.md

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

README.md

@@ -6,7 +6,7 @@
 
 ```toml
 [dependencies]
-winit = "0.29.2"
+winit = "0.29.4"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -26,7 +26,7 @@ Join us in any of these:
 
 Winit is a window creation and management library. It can create windows and lets you handle
 events (for example: the window being resized, a key being pressed, a mouse movement, etc.)
-produced by window.
+produced by the window.
 
 Winit is designed to be a low-level brick in a hierarchy of libraries. Consequently, in order to
 show something on the window you need to use the platform-specific getters provided by winit, or
@@ -42,7 +42,7 @@ Winit provides the following features, which can be enabled in your `Cargo.toml`
 
 ## MSRV Policy
 
-The Minimum Supported Rust Version (MSRV) of this crate is **1.65**. Changes to
+This crate's Minimum Supported Rust Version (MSRV) is **1.65**. Changes to
 the MSRV will be accompanied by a minor version bump.
 
 As a **tentative** policy, the upper bound of the MSRV is given by the following
@@ -53,12 +53,11 @@ min(sid, stable - 3)
 ```
 
 Where `sid` is the current version of `rustc` provided by [Debian Sid], and
-`stable` is the latest stable version of Rust. This bound may be broken in the
-event of a major ecosystem shift or a security vulnerability.
+`stable` is the latest stable version of Rust. This bound may be broken in case of a major ecosystem shift or a security vulnerability.
 
 [Debian Sid]: https://packages.debian.org/sid/rustc
 
-The exception to this is for the Android platform, where a higher Rust version
+The exception is for the Android platform, where a higher Rust version
 must be used for certain Android features. In this case, the MSRV will be
 capped at the latest stable version of Rust minus three. This inconsistency is
 not reflected in Cargo metadata, as it is not powerful enough to expose this
@@ -86,7 +85,7 @@ either [provide Winit with a `<canvas>` element][web with_canvas], or [let Winit
 create a `<canvas>` element which you can then retrieve][web canvas getter] and
 insert it into the DOM yourself.
 
-For example code using Winit with WebAssembly, check out the [web example]. For
+For the example code using Winit with WebAssembly, check out the [web example]. For
 information on using Rust on WebAssembly, check out the [Rust and WebAssembly
 book].
 
@@ -109,14 +108,14 @@ glue crate (prior to `0.28` it used
 
 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
+application's main entry point. If Cargo resolves multiple versions, they will
 clash.
 
 `winit` glue compatibility table:
 
 | winit |       ndk-glue               |
 | :---: | :--------------------------: |
-| 0.29.2| `android-activity = "0.5"`   |
+| 0.29  | `android-activity = "0.5"`   |
 | 0.28  | `android-activity = "0.4"`   |
 | 0.27  | `ndk-glue = "0.7"`           |
 | 0.26  | `ndk-glue = "0.5"`           |
@@ -127,7 +126,7 @@ The recommended way to avoid a conflict with the glue version is to avoid explic
 depending on the `android-activity` crate, and instead consume the API that
 is re-exported by Winit under `winit::platform::android::activity::*`
 
-Running on an Android device needs a dynamic system library, add this to Cargo.toml:
+Running on an Android device needs a dynamic system library. Add this to Cargo.toml:
 
 ```toml
 [lib]
@@ -135,14 +134,14 @@ name = "main"
 crate-type = ["cdylib"]
 ```
 
-All Android applications are based on an `Activity` subclass and the
+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`] | `android-game-activity`   | Derives from [`AndroidAppCompat`], 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
@@ -155,9 +154,9 @@ For more details, refer to these `android-activity` [example applications](https
 
 ##### Converting from `ndk-glue` to `android-activity`
 
-If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building with `cargo apk` then the minimal changes would be:
+If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building with `cargo apk`, then the minimal changes would be:
 1. Remove `ndk-glue` from your `Cargo.toml`
-2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.2", features = [ "android-native-activity" ] }`
+2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.4", 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).
 
@@ -173,7 +172,7 @@ If you encounter problems, you should try doing your initialization inside
 #### 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
+by all UI-related code (see issue [#1705]). It would be best to consider creating your windows
 inside `Event::Resumed`.
 
 
@@ -184,5 +183,5 @@ inside `Event::Resumed`.
 
 #### Redox OS
 
-Redox OS has some functionality not present yet, that will be implemented when
+Redox OS has some functionality not yet present that will be implemented when
 its orbital display server provides it.

clippy.toml

@@ -6,6 +6,7 @@ disallowed-methods = [
     { path = "web_sys::HtmlCanvasElement::set_height", reason = "Winit shouldn't touch the internal canvas size" },
     { path = "web_sys::Window::document", reason = "cache this to reduce calls to JS" },
     { path = "web_sys::Window::get_computed_style", reason = "cache this to reduce calls to JS" },
+    { path = "web_sys::HtmlElement::style", reason = "cache this to reduce calls to JS" },
     { path = "web_sys::Element::request_fullscreen", reason = "Doesn't account for compatibility with Safari" },
     { path = "web_sys::Document::exit_fullscreen", reason = "Doesn't account for compatibility with Safari" },
     { path = "web_sys::Document::fullscreen_element", reason = "Doesn't account for compatibility with Safari" },

docs/res/ATTRIBUTION.md

@@ -5,7 +5,7 @@ These images are used in the documentation of `winit`.
 ## keyboard_*.svg
 
 These files are a modified version of "[ANSI US QWERTY (Windows)](https://commons.wikimedia.org/wiki/File:ANSI_US_QWERTY_(Windows).svg)"
-by [Tomiĉo] (https://commons.wikimedia.org/wiki/User:Tomi%C4%89o). It is
+by [Tomiĉo] (https://commons.wikimedia.org/wiki/User:Tomi%C4%89o). It was
 originally released under the [CC-BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/deed.en)
 License. Minor modifications have been made by [John Nunley](https://github.com/notgull),
 which have been released under the same license as a derivative work.

examples/custom_cursors.rs

@@ -0,0 +1,92 @@
+#![allow(clippy::single_match, clippy::disallowed_methods)]
+
+#[cfg(not(wasm_platform))]
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{ElementState, Event, KeyEvent, WindowEvent},
+    event_loop::EventLoop,
+    keyboard::Key,
+    window::{CustomCursor, WindowBuilder},
+};
+
+fn decode_cursor(bytes: &[u8]) -> CustomCursor {
+    let img = image::load_from_memory(bytes).unwrap().to_rgba8();
+    let samples = img.into_flat_samples();
+    let (_, w, h) = samples.extents();
+    let (w, h) = (w as u16, h as u16);
+    CustomCursor::from_rgba(samples.samples, w, h, w / 2, h / 2).unwrap()
+}
+
+#[cfg(not(wasm_platform))]
+#[path = "util/fill.rs"]
+mod fill;
+
+fn main() -> Result<(), impl std::error::Error> {
+    #[cfg(not(wasm_platform))]
+    SimpleLogger::new()
+        .with_level(log::LevelFilter::Info)
+        .init()
+        .unwrap();
+    #[cfg(wasm_platform)]
+    console_log::init_with_level(log::Level::Debug).unwrap();
+
+    let event_loop = EventLoop::new().unwrap();
+    let builder = WindowBuilder::new().with_title("A fantastic window!");
+    #[cfg(wasm_platform)]
+    let builder = {
+        use winit::platform::web::WindowBuilderExtWebSys;
+        builder.with_append(true)
+    };
+    let window = builder.build(&event_loop).unwrap();
+
+    let mut cursor_idx = 0;
+    let mut cursor_visible = true;
+
+    let custom_cursors = [
+        decode_cursor(include_bytes!("data/cross.png")),
+        decode_cursor(include_bytes!("data/cross2.png")),
+    ];
+
+    event_loop.run(move |event, _elwt| match event {
+        Event::WindowEvent { event, .. } => match event {
+            WindowEvent::KeyboardInput {
+                event:
+                    KeyEvent {
+                        state: ElementState::Pressed,
+                        logical_key: key,
+                        ..
+                    },
+                ..
+            } => match key.as_ref() {
+                Key::Character("1") => {
+                    log::debug!("Setting cursor to {:?}", cursor_idx);
+                    window.set_custom_cursor(&custom_cursors[cursor_idx]);
+                    cursor_idx = (cursor_idx + 1) % 2;
+                }
+                Key::Character("2") => {
+                    log::debug!("Setting cursor icon to default");
+                    window.set_cursor_icon(Default::default());
+                }
+                Key::Character("3") => {
+                    cursor_visible = !cursor_visible;
+                    log::debug!("Setting cursor visibility to {:?}", cursor_visible);
+                    window.set_cursor_visible(cursor_visible);
+                }
+                _ => {}
+            },
+            WindowEvent::RedrawRequested => {
+                #[cfg(not(wasm_platform))]
+                fill::fill_window(&window);
+            }
+            WindowEvent::CloseRequested => {
+                #[cfg(not(wasm_platform))]
+                _elwt.exit();
+            }
+            _ => (),
+        },
+        Event::AboutToWait => {
+            window.request_redraw();
+        }
+        _ => {}
+    })
+}

examples/focus.rs

@@ -0,0 +1,56 @@
+#![allow(clippy::single_match)]
+
+//! Example for focusing a window.
+
+use simple_logger::SimpleLogger;
+#[cfg(not(wasm_platform))]
+use std::time;
+#[cfg(wasm_platform)]
+use web_time as time;
+use winit::{
+    event::{Event, StartCause, WindowEvent},
+    event_loop::EventLoop,
+    window::WindowBuilder,
+};
+
+#[path = "util/fill.rs"]
+mod fill;
+
+fn main() -> Result<(), impl std::error::Error> {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new().unwrap();
+
+    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 deadline = time::Instant::now() + time::Duration::from_secs(3);
+    event_loop.run(move |event, elwt| {
+        match event {
+            Event::NewEvents(StartCause::ResumeTimeReached { .. }) => {
+                // Timeout reached; focus the window.
+                println!("Re-focusing the window.");
+                deadline += time::Duration::from_secs(3);
+                window.focus_window();
+            }
+            Event::WindowEvent { event, window_id } if window_id == window.id() => match event {
+                WindowEvent::CloseRequested => elwt.exit(),
+                WindowEvent::RedrawRequested => {
+                    // Notify the windowing system that we'll be presenting to the window.
+                    window.pre_present_notify();
+                    fill::fill_window(&window);
+                }
+                _ => (),
+            },
+            Event::AboutToWait => {
+                window.request_redraw();
+            }
+
+            _ => (),
+        }
+
+        elwt.set_control_flow(winit::event_loop::ControlFlow::WaitUntil(deadline));
+    })
+}

examples/util/fill.rs

@@ -53,6 +53,13 @@ pub(super) fn fill_window(window: &Window) {
     }
 
     GC.with(|gc| {
+        let size = window.inner_size();
+        let (Some(width), Some(height)) =
+            (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
+        else {
+            return;
+        };
+
         // Either get the last context used or create a new one.
         let mut gc = gc.borrow_mut();
         let surface = gc
@@ -61,13 +68,9 @@ pub(super) fn fill_window(window: &Window) {
 
         // Fill a buffer with a solid color.
         const DARK_GRAY: u32 = 0xFF181818;
-        let size = window.inner_size();
 
         surface
-            .resize(
-                NonZeroU32::new(size.width).expect("Width must be greater than zero"),
-                NonZeroU32::new(size.height).expect("Height must be greater than zero"),
-            )
+            .resize(width, height)
             .expect("Failed to resize the softbuffer surface");
 
         let mut buffer = surface

src/cursor.rs

@@ -0,0 +1,198 @@
+use core::fmt;
+use std::{error::Error, sync::Arc};
+
+use crate::platform_impl::PlatformCustomCursor;
+
+/// The maximum width and height for a cursor when using [`CustomCursor::from_rgba`].
+pub const MAX_CURSOR_SIZE: u16 = 2048;
+
+const PIXEL_SIZE: usize = 4;
+
+/// Use a custom image as a cursor (mouse pointer).
+///
+/// ## Platform-specific
+///
+/// **Web**: Some browsers have limits on cursor sizes usually at 128x128.
+///
+/// # Example
+///
+/// ```
+/// use winit::window::CustomCursor;
+///
+/// let w = 10;
+/// let h = 10;
+/// let rgba = vec![255; (w * h * 4) as usize];
+/// let custom_cursor = CustomCursor::from_rgba(rgba, w, h, w / 2, h / 2).unwrap();
+///
+/// #[cfg(target_family = "wasm")]
+/// let custom_cursor_url = {
+///     use winit::platform::web::CustomCursorExtWebSys;
+///     CustomCursor::from_url("http://localhost:3000/cursor.png", 0, 0).unwrap()
+/// };
+/// ```
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CustomCursor {
+    pub(crate) inner: Arc<PlatformCustomCursor>,
+}
+
+impl CustomCursor {
+    /// Creates a new cursor from an rgba buffer.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Web:** Setting cursor could be delayed due to the creation of `Blob` objects,
+    ///   which are async by nature.
+    pub fn from_rgba(
+        rgba: impl Into<Vec<u8>>,
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    ) -> Result<Self, BadImage> {
+        Ok(Self {
+            inner: PlatformCustomCursor::from_rgba(
+                rgba.into(),
+                width,
+                height,
+                hotspot_x,
+                hotspot_y,
+            )?
+            .into(),
+        })
+    }
+}
+
+/// An error produced when using [`CustomCursor::from_rgba`] with invalid arguments.
+#[derive(Debug, Clone)]
+pub enum BadImage {
+    /// Produced when the image dimensions are larger than [`MAX_CURSOR_SIZE`]. This doesn't
+    /// guarantee that the cursor will work, but should avoid many platform and device specific
+    /// limits.
+    TooLarge { width: u16, height: u16 },
+    /// Produced when the length of the `rgba` argument isn't divisible by 4, thus `rgba` can't be
+    /// safely interpreted as 32bpp RGBA pixels.
+    ByteCountNotDivisibleBy4 { byte_count: usize },
+    /// Produced when the number of pixels (`rgba.len() / 4`) isn't equal to `width * height`.
+    /// At least one of your arguments is incorrect.
+    DimensionsVsPixelCount {
+        width: u16,
+        height: u16,
+        width_x_height: u64,
+        pixel_count: u64,
+    },
+    /// Produced when the hotspot is outside the image bounds
+    HotspotOutOfBounds {
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    },
+}
+
+impl fmt::Display for BadImage {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BadImage::TooLarge { width, height } => write!(f,
+                "The specified dimensions ({width:?}x{height:?}) are too large. The maximum is {MAX_CURSOR_SIZE:?}x{MAX_CURSOR_SIZE:?}.",
+            ),
+            BadImage::ByteCountNotDivisibleBy4 { byte_count } => write!(f,
+                "The length of the `rgba` argument ({byte_count:?}) isn't divisible by 4, making it impossible to interpret as 32bpp RGBA pixels.",
+            ),
+            BadImage::DimensionsVsPixelCount {
+                width,
+                height,
+                width_x_height,
+                pixel_count,
+            } => write!(f,
+                "The specified dimensions ({width:?}x{height:?}) don't match the number of pixels supplied by the `rgba` argument ({pixel_count:?}). For those dimensions, the expected pixel count is {width_x_height:?}.",
+            ),
+            BadImage::HotspotOutOfBounds {
+                width,
+                height,
+                hotspot_x,
+                hotspot_y,
+            } => write!(f,
+                "The specified hotspot ({hotspot_x:?}, {hotspot_y:?}) is outside the image bounds ({width:?}x{height:?}).",
+            ),
+        }
+    }
+}
+
+impl Error for BadImage {}
+
+/// Platforms export this directly as `PlatformCustomCursor` if they need to only work with images.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CursorImage {
+    pub(crate) rgba: Vec<u8>,
+    pub(crate) width: u16,
+    pub(crate) height: u16,
+    pub(crate) hotspot_x: u16,
+    pub(crate) hotspot_y: u16,
+}
+
+#[allow(dead_code)]
+impl CursorImage {
+    pub fn from_rgba(
+        rgba: Vec<u8>,
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    ) -> Result<Self, BadImage> {
+        if width > MAX_CURSOR_SIZE || height > MAX_CURSOR_SIZE {
+            return Err(BadImage::TooLarge { width, height });
+        }
+
+        if rgba.len() % PIXEL_SIZE != 0 {
+            return Err(BadImage::ByteCountNotDivisibleBy4 {
+                byte_count: rgba.len(),
+            });
+        }
+
+        let pixel_count = (rgba.len() / PIXEL_SIZE) as u64;
+        let width_x_height = width as u64 * height as u64;
+        if pixel_count != width_x_height {
+            return Err(BadImage::DimensionsVsPixelCount {
+                width,
+                height,
+                width_x_height,
+                pixel_count,
+            });
+        }
+
+        if hotspot_x >= width || hotspot_y >= height {
+            return Err(BadImage::HotspotOutOfBounds {
+                width,
+                height,
+                hotspot_x,
+                hotspot_y,
+            });
+        }
+
+        Ok(CursorImage {
+            rgba,
+            width,
+            height,
+            hotspot_x,
+            hotspot_y,
+        })
+    }
+}
+
+// Platforms that don't support cursors will export this as `PlatformCustomCursor`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct NoCustomCursor;
+
+#[allow(dead_code)]
+impl NoCustomCursor {
+    pub fn from_rgba(
+        rgba: Vec<u8>,
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    ) -> Result<Self, BadImage> {
+        CursorImage::from_rgba(rgba, width, height, hotspot_x, hotspot_y)?;
+        Ok(Self)
+    }
+}

src/dpi.rs

@@ -4,13 +4,13 @@
 //!
 //! Modern computer screens don't have a consistent relationship between resolution and size.
 //! 1920x1080 is a common resolution for both desktop and mobile screens, despite mobile screens
-//! normally being less than a quarter the size of their desktop counterparts. What's more, neither
-//! desktop nor mobile screens are consistent resolutions within their own size classes - common
+//! typically being less than a quarter the size of their desktop counterparts. Moreover, neither
+//! desktop nor mobile screens have consistent resolutions within their own size classes - common
 //! mobile screens range from below 720p to above 1440p, and desktop screens range from 720p to 5K
 //! and beyond.
 //!
 //! Given that, it's a mistake to assume that 2D content will only be displayed on screens with
-//! a consistent pixel density. If you were to render a 96-pixel-square image on a 1080p screen,
+//! a consistent pixel density. If you were to render a 96-pixel-square image on a 1080p screen and
 //! then render the same image on a similarly-sized 4K screen, the 4K rendition would only take up
 //! about a quarter of the physical space as it did on the 1080p screen. That issue is especially
 //! problematic with text rendering, where quarter-sized text becomes a significant legibility
@@ -25,12 +25,12 @@
 //!
 //! The solution to this problem is to account for the device's *scale factor*. The scale factor is
 //! the factor UI elements should be scaled by to be consistent with the rest of the user's system -
-//! for example, a button that's normally 50 pixels across would be 100 pixels across on a device
+//! for example, a button that's usually 50 pixels across would be 100 pixels across on a device
 //! with a scale factor of `2.0`, or 75 pixels across with a scale factor of `1.5`.
 //!
 //! Many UI systems, such as CSS, expose DPI-dependent units like [points] or [picas]. That's
-//! usually a mistake, since there's no consistent mapping between the scale factor and the screen's
-//! actual DPI. Unless you're printing to a physical medium, you should work in scaled pixels rather
+//! usually a mistake since there's no consistent mapping between the scale factor and the screen's
+//! actual DPI. Unless printing to a physical medium, you should work in scaled pixels rather
 //! than any DPI-dependent units.
 //!
 //! ### Position and Size types
@@ -42,11 +42,11 @@
 //! coordinates as input, allowing you to use the most convenient coordinate system for your
 //! particular application.
 //!
-//! Winit's position and size types types are generic over their exact pixel type, `P`, to allow the
+//! Winit's position and size types are generic over their exact pixel type, `P`, to allow the
 //! API to have integer precision where appropriate (e.g. most window manipulation functions) and
 //! floating precision when necessary (e.g. logical sizes for fractional scale factors and touch
 //! input). If `P` is a floating-point type, please do not cast the values with `as {int}`. Doing so
-//! will truncate the fractional part of the float, rather than properly round to the nearest
+//! will truncate the fractional part of the float rather than properly round to the nearest
 //! integer. Use the provided `cast` function or [`From`]/[`Into`] conversions, which handle the
 //! rounding properly. Note that precision loss will still occur when rounding from a float to an
 //! int, although rounding lessens the problem.
@@ -55,34 +55,35 @@
 //!
 //! Winit will dispatch a [`ScaleFactorChanged`] event whenever a window's scale factor has changed.
 //! This can happen if the user drags their window from a standard-resolution monitor to a high-DPI
-//! monitor, or if the user changes their DPI settings. This gives you a chance to rescale your
-//! application's UI elements and adjust how the platform changes the window's size to reflect the new
-//! scale factor. If a window hasn't received a [`ScaleFactorChanged`] event,  then its scale factor
+//! monitor or if the user changes their DPI settings. This allows you to rescale your application's
+//! UI elements and adjust how the platform changes the window's size to reflect the new scale
+//! factor. If a window hasn't received a [`ScaleFactorChanged`] event, its scale factor
 //! can be found by calling [`window.scale_factor()`].
 //!
 //! ## How is the scale factor calculated?
 //!
-//! Scale factor is calculated differently on different platforms:
+//! The scale factor is calculated differently on different platforms:
 //!
 //! - **Windows:** On Windows 8 and 10, per-monitor scaling is readily configured by users from the
 //!   display settings. While users are free to select any option they want, they're only given a
-//!   selection of "nice" scale factors, i.e. 1.0, 1.25, 1.5... on Windows 7, the scale factor is
+//!   selection of "nice" scale factors, i.e. 1.0, 1.25, 1.5... on Windows 7. The scale factor is
 //!   global and changing it requires logging out. See [this article][windows_1] for technical
 //!   details.
-//! - **macOS:** Recent versions of macOS allow the user to change the scaling factor for certain
-//!   displays. When this is available, the user may pick a per-monitor scaling factor from a set
-//!   of pre-defined settings. All "retina displays" have a scaling factor above 1.0 by default but
-//!   the specific value varies across devices.
+//! - **macOS:** Recent macOS versions allow the user to change the scaling factor for specific
+//!   displays. When available, the user may pick a per-monitor scaling factor from a set of
+//!   pre-defined settings. All "retina displays" have a scaling factor above 1.0 by default,
+//!   but the specific value varies across devices.
 //! - **X11:** Many man-hours have been spent trying to figure out how to handle DPI in X11. Winit
 //!   currently uses a three-pronged approach:
-//!   + Use the value in the `WINIT_X11_SCALE_FACTOR` environment variable, if present.
+//!   + Use the value in the `WINIT_X11_SCALE_FACTOR` environment variable if present.
 //!   + If not present, use the value set in `Xft.dpi` in Xresources.
 //!   + Otherwise, calculate the scale factor based on the millimeter monitor dimensions provided by XRandR.
 //!
 //!   If `WINIT_X11_SCALE_FACTOR` is set to `randr`, it'll ignore the `Xft.dpi` field and use the
 //!   XRandR scaling method. Generally speaking, you should try to configure the standard system
 //!   variables to do what you want before resorting to `WINIT_X11_SCALE_FACTOR`.
-//! - **Wayland:** Scale factor is suggested by the the compositor.
+//! - **Wayland:** The scale factor is suggested by the compositor for each window individually. The
+//!   monitor scale factor may differ from the window scale factor.
 //! - **iOS:** Scale factors are set by Apple to the value that best suits the device, and range
 //!   from `1.0` to `3.0`. See [this article][apple_1] and [this article][apple_2] for more
 //!   information.

src/event_loop.rs

@@ -224,14 +224,22 @@ impl<T> EventLoop<T> {
     ///   (that Rust doesn't see) that will also mean that the rest of the function is never executed
     ///   and any values not passed to this function will *not* be dropped.
     ///
-    ///   Web applications are recommended to use `spawn()` instead of `run()` to avoid the need
+    ///   Web applications are recommended to use
+    #[cfg_attr(
+        wasm_platform,
+        doc = "[`EventLoopExtWebSys::spawn()`][crate::platform::web::EventLoopExtWebSys::spawn()]"
+    )]
+    #[cfg_attr(not(wasm_platform), doc = "`EventLoopExtWebSys::spawn()`")]
+    ///   [^1] instead of [`run()`] to avoid the need
     ///   for the Javascript exception trick, and to make it clearer that the event loop runs
     ///   asynchronously (via the browser's own, internal, event loop) and doesn't block the
     ///   current thread of execution like it does on other platforms.
     ///
     ///   This function won't be available with `target_feature = "exception-handling"`.
     ///
-    /// [`set_control_flow()`]: EventLoopWindowTarget::set_control_flow
+    /// [`set_control_flow()`]: EventLoopWindowTarget::set_control_flow()
+    /// [`run()`]: Self::run()
+    /// [^1]: `EventLoopExtWebSys::spawn()` is only available on WASM.
     #[inline]
     #[cfg(not(all(wasm_platform, target_feature = "exception-handling")))]
     pub fn run<F>(self, event_handler: F) -> Result<(), EventLoopError>

src/icon.rs

@@ -49,11 +49,7 @@ impl fmt::Display for BadIcon {
     }
 }
 
-impl Error for BadIcon {
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        Some(self)
-    }
-}
+impl Error for BadIcon {}
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) struct RgbaIcon {

src/lib.rs

@@ -10,12 +10,12 @@
 //! let event_loop = EventLoop::new().unwrap();
 //! ```
 //!
-//! Once this is done there are two ways to create a [`Window`]:
+//! Once this is done, there are two ways to create a [`Window`]:
 //!
 //!  - Calling [`Window::new(&event_loop)`][window_new].
 //!  - Calling [`let builder = WindowBuilder::new()`][window_builder_new] then [`builder.build(&event_loop)`][window_builder_build].
 //!
-//! The first method is the simplest, and will give you default values for everything. The second
+//! The first method is the simplest and will give you default values for everything. The second
 //! method allows you to customize the way your [`Window`] will look and behave by modifying the
 //! fields of the [`WindowBuilder`] object before you create the [`Window`].
 //!
@@ -26,17 +26,37 @@
 //! window or a key getting pressed while the window is focused. Devices can generate
 //! [`DeviceEvent`]s, which contain unfiltered event data that isn't specific to a certain window.
 //! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
-//! [`DeviceEvent`]. You can also create and handle your own custom [`UserEvent`]s, if desired.
+//! [`DeviceEvent`]. You can also create and handle your own custom [`Event::UserEvent`]s, if desired.
 //!
-//! You can retrieve events by calling [`EventLoop::run`][event_loop_run]. This function will
+//! You can retrieve events by calling [`EventLoop::run()`]. This function will
 //! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
-//! will run until [`exit()`] is used, at which point [`Event`]`::`[`LoopExiting`].
+//! will run until [`exit()`] is used, at which point [`Event::LoopExiting`].
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
 //! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works poorly on
 //! most other platforms. However, this model can be re-implemented to an extent with
-//! [`EventLoopExtPumpEvents::pump_events`]. See that method's documentation for more reasons about why
-//! it's discouraged, beyond compatibility reasons.
+#![cfg_attr(
+    any(
+        windows_platform,
+        macos_platform,
+        android_platform,
+        x11_platform,
+        wayland_platform
+    ),
+    doc = "[`EventLoopExtPumpEvents::pump_events()`][platform::pump_events::EventLoopExtPumpEvents::pump_events()]"
+)]
+#![cfg_attr(
+    not(any(
+        windows_platform,
+        macos_platform,
+        android_platform,
+        x11_platform,
+        wayland_platform
+    )),
+    doc = "`EventLoopExtPumpEvents::pump_events()`"
+)]
+//! [^1]. See that method's documentation for more reasons about why
+//! it's discouraged beyond compatibility reasons.
 //!
 //!
 //! ```no_run
@@ -72,9 +92,9 @@
 //!
 //!             // Queue a RedrawRequested event.
 //!             //
-//!             // You only need to call this if you've determined that you need to redraw, in
+//!             // You only need to call this if you've determined that you need to redraw in
 //!             // applications which do not always need to. Applications that redraw continuously
-//!             // can just render here instead.
+//!             // can render here instead.
 //!             window.request_redraw();
 //!         },
 //!         Event::WindowEvent {
@@ -92,16 +112,16 @@
 //! });
 //! ```
 //!
-//! [`Event`]`::`[`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
-//! compared to the value returned by [`Window::id()`][window_id_fn] to determine which [`Window`]
+//! [`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
+//! compared to the value returned by [`Window::id()`] to determine which [`Window`]
 //! dispatched the event.
 //!
 //! # Drawing on the window
 //!
-//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However it allows you to
+//! Winit doesn't directly provide any methods for drawing on a [`Window`]. However, it allows you to
 //! retrieve the raw handle of the window and display (see the [`platform`] module and/or the
 //! [`raw_window_handle`] and [`raw_display_handle`] methods), which in turn allows
-//!  you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
+//! you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
 //!
 //! Note that many platforms will display garbage data in the window's client area if the
 //! application doesn't render anything to the window by the time the desktop compositor is ready to
@@ -110,9 +130,8 @@
 //! window visible only once you're ready to render into it.
 //!
 //! [`EventLoop`]: event_loop::EventLoop
-//! [`EventLoopExtPumpEvents::pump_events`]: ./platform/pump_events/trait.EventLoopExtPumpEvents.html#tymethod.pump_events
 //! [`EventLoop::new()`]: event_loop::EventLoop::new
-//! [event_loop_run]: event_loop::EventLoop::run
+//! [`EventLoop::run()`]: event_loop::EventLoop::run
 //! [`exit()`]: event_loop::EventLoopWindowTarget::exit
 //! [`Window`]: window::Window
 //! [`WindowId`]: window::WindowId
@@ -120,15 +139,14 @@
 //! [window_new]: window::Window::new
 //! [window_builder_new]: window::WindowBuilder::new
 //! [window_builder_build]: window::WindowBuilder::build
-//! [window_id_fn]: window::Window::id
-//! [`Event`]: event::Event
+//! [`Window::id()`]: window::Window::id
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
-//! [`UserEvent`]: event::Event::UserEvent
-//! [`LoopExiting`]: event::Event::LoopExiting
-//! [`platform`]: platform
+//! [`Event::UserEvent`]: event::Event::UserEvent
+//! [`Event::LoopExiting`]: event::Event::LoopExiting
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 //! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
+//! [^1]: `EventLoopExtPumpEvents::pump_events()` is only available on Windows, macOS, Android, X11 and Wayland.
 
 #![deny(rust_2018_idioms)]
 #![deny(rustdoc::broken_intra_doc_links)]
@@ -154,6 +172,7 @@ extern crate bitflags;
 pub mod dpi;
 #[macro_use]
 pub mod error;
+mod cursor;
 pub mod event;
 pub mod event_loop;
 mod icon;
@@ -165,13 +184,13 @@ pub mod window;
 pub mod platform;
 
 /// Wrapper for objects which winit will access on the main thread so they are effectively `Send`
-/// and `Sync`, since they always excute on a single thread.
+/// and `Sync`, since they always execute on a single thread.
 ///
 /// # Safety
 ///
-/// Winit can run only one event loop at the time and the event loop itself is tied to some thread.
-/// The objects could be send across the threads, but once passed to winit, they execute on the
-/// mean thread if the platform demands it. Thus marking such objects as `Send + Sync` is safe.
+/// Winit can run only one event loop at a time, and the event loop itself is tied to some thread.
+/// The objects could be sent across the threads, but once passed to winit, they execute on the
+/// main thread if the platform demands it. Thus, marking such objects as `Send + Sync` is safe.
 #[doc(hidden)]
 #[derive(Clone, Debug)]
 pub(crate) struct SendSyncWrapper<T>(pub(crate) T);

src/monitor.rs

@@ -138,14 +138,18 @@ impl MonitorHandle {
         self.inner.refresh_rate_millihertz()
     }
 
-    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.
+    /// Returns the scale factor of the underlying monitor. To map logical pixels to physical
+    /// pixels and vice versa, use [`Window::scale_factor`].
     ///
     /// See the [`dpi`](crate::dpi) module for more information.
     ///
     /// ## Platform-specific
     ///
     /// - **X11:** Can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
+    /// - **Wayland:** May differ from [`Window::scale_factor`].
     /// - **Android:** Always returns 1.0.
+    ///
+    /// [`Window::scale_factor`]: crate::window::Window::scale_factor
     #[inline]
     pub fn scale_factor(&self) -> f64 {
         self.inner.scale_factor()

src/platform/android.rs

@@ -84,5 +84,10 @@ impl<T> EventLoopBuilderExtAndroid for EventLoopBuilder<T> {
 /// use winit::platform::android::activity::AndroidApp;
 /// ```
 pub mod activity {
+    // We enable the `"native-activity"` feature just so that we can build the
+    // docs, but it'll be very confusing for users to see the docs with that
+    // feature enabled, so we avoid inlining it so that they're forced to view
+    // it on the crate's own docs.rs page.
+    #[doc(no_inline)]
     pub use android_activity::*;
 }

src/platform/run_on_demand.rs

@@ -35,9 +35,9 @@ pub trait EventLoopExtRunOnDemand {
     /// See the [`set_control_flow()`] docs on how to change the event loop's behavior.
     ///
     /// # Caveats
-    /// - This extension isn't available on all platforms, since it's not always possible to
-    ///   return to the caller (specifically this is impossible on iOS and Web - though with
-    ///   the Web backend it is possible to use `spawn()` more than once instead).
+    /// - This extension isn't available on all platforms, since it's not always possible to return
+    ///   to the caller (specifically this is impossible on iOS and Web - though with the Web
+    ///   backend it is possible to use `EventLoopExtWebSys::spawn()`[^1] more than once instead).
     /// - No [`Window`] state can be carried between separate runs of the event loop.
     ///
     /// You are strongly encouraged to use [`EventLoop::run()`] for portability, unless you specifically need
@@ -57,8 +57,13 @@ pub trait EventLoopExtRunOnDemand {
     ///   on an event loop that is internal to the browser itself.
     /// - **iOS:** It's not possible to stop and start an `NSApplication` repeatedly on iOS.
     ///
-    /// [`exit()`]: EventLoopWindowTarget::exit
-    /// [`set_control_flow()`]: EventLoopWindowTarget::set_control_flow
+    #[cfg_attr(
+        not(wasm_platform),
+        doc = "[^1]: `spawn()` is only available on `wasm` platforms."
+    )]
+    ///
+    /// [`exit()`]: EventLoopWindowTarget::exit()
+    /// [`set_control_flow()`]: EventLoopWindowTarget::set_control_flow()
     fn run_on_demand<F>(&mut self, event_handler: F) -> Result<(), EventLoopError>
     where
         F: FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>);

src/platform/web.rs

@@ -27,9 +27,11 @@
 //! [`border`]: https://developer.mozilla.org/en-US/docs/Web/CSS/border
 //! [`padding`]: https://developer.mozilla.org/en-US/docs/Web/CSS/padding
 
+use crate::cursor::CustomCursor;
 use crate::event::Event;
 use crate::event_loop::EventLoop;
 use crate::event_loop::EventLoopWindowTarget;
+use crate::platform_impl::PlatformCustomCursor;
 use crate::window::{Window, WindowBuilder};
 use crate::SendSyncWrapper;
 
@@ -109,13 +111,28 @@ pub trait EventLoopExtWebSys {
 
     /// Initializes the winit event loop.
     ///
-    /// Unlike `run`, this returns immediately, and doesn't throw an exception in order to
-    /// satisfy its `!` return type.
+    /// Unlike
+    #[cfg_attr(
+        all(wasm_platform, target_feature = "exception-handling"),
+        doc = "`run()`"
+    )]
+    #[cfg_attr(
+        not(all(wasm_platform, target_feature = "exception-handling")),
+        doc = "[`run()`]"
+    )]
+    /// [^1], this returns immediately, and doesn't throw an exception in order to
+    /// satisfy its [`!`] return type.
     ///
     /// Once the event loop has been destroyed, it's possible to reinitialize another event loop
     /// by calling this function again. This can be useful if you want to recreate the event loop
     /// while the WebAssembly module is still loaded. For example, this can be used to recreate the
     /// event loop when switching between tabs on a single page application.
+    ///
+    #[cfg_attr(
+        not(all(wasm_platform, target_feature = "exception-handling")),
+        doc = "[`run()`]: EventLoop::run()"
+    )]
+    /// [^1]: `run()` is _not_ available on WASM when the target supports `exception-handling`.
     fn spawn<F>(self, event_handler: F)
     where
         F: 'static + FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>);
@@ -185,3 +202,25 @@ pub enum PollStrategy {
     #[default]
     Scheduler,
 }
+
+pub trait CustomCursorExtWebSys {
+    /// Creates a new cursor from a URL pointing to an image.
+    /// It uses the [url css function](https://developer.mozilla.org/en-US/docs/Web/CSS/url),
+    /// but browser support for image formats is inconsistent. Using [PNG] is recommended.
+    ///
+    /// [PNG]: https://en.wikipedia.org/wiki/PNG
+    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> Self;
+}
+
+impl CustomCursorExtWebSys for CustomCursor {
+    fn from_url(url: String, hotspot_x: u16, hotspot_y: u16) -> Self {
+        Self {
+            inner: PlatformCustomCursor::Url {
+                url,
+                hotspot_x,
+                hotspot_y,
+            }
+            .into(),
+        }
+    }
+}

src/platform_impl/android/mod.rs

@@ -18,6 +18,7 @@ use android_activity::{
 use once_cell::sync::Lazy;
 
 use crate::{
+    cursor::CustomCursor,
     dpi::{PhysicalPosition, PhysicalSize, Position, Size},
     error,
     event::{self, Force, InnerSizeWriter, StartCause},
@@ -906,6 +907,8 @@ impl Window {
 
     pub fn set_cursor_icon(&self, _: window::CursorIcon) {}
 
+    pub fn set_custom_cursor(&self, _: CustomCursor) {}
+
     pub fn set_cursor_position(&self, _: Position) -> Result<(), error::ExternalError> {
         Err(error::ExternalError::NotSupported(
             error::NotSupportedError::new(),
@@ -1031,6 +1034,7 @@ impl Display for OsError {
     }
 }
 
+pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursor;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]

src/platform_impl/ios/app_state.rs

@@ -200,6 +200,10 @@ impl AppState {
         )
     }
 
+    fn has_terminated(&self) -> bool {
+        matches!(self.state(), AppStateImpl::Terminated)
+    }
+
     fn will_launch_transition(&mut self, queued_event_handler: Box<dyn EventHandler>) {
         let (queued_windows, queued_events, queued_gpu_redraws) = match self.take_state() {
             AppStateImpl::NotLaunched {
@@ -243,7 +247,7 @@ impl AppState {
     fn wakeup_transition(&mut self) -> Option<EventWrapper> {
         // before `AppState::did_finish_launching` is called, pretend there is no running
         // event loop.
-        if !self.has_launched() {
+        if !self.has_launched() || self.has_terminated() {
             return None;
         }
 
@@ -390,7 +394,7 @@ impl AppState {
     }
 
     fn events_cleared_transition(&mut self) {
-        if !self.has_launched() {
+        if !self.has_launched() || self.has_terminated() {
             return;
         }
         let (waiting_event_handler, old) = match self.take_state() {
@@ -586,6 +590,10 @@ pub(crate) fn handle_nonuser_events<I: IntoIterator<Item = EventWrapper>>(
     events: I,
 ) {
     let mut this = AppState::get_mut(mtm);
+    if this.has_terminated() {
+        return;
+    }
+
     let (mut event_handler, active_control_flow, processing_redraws) =
         match this.try_user_callback_transition() {
             UserCallbackTransitionResult::ReentrancyPrevented { queued_events } => {
@@ -737,7 +745,7 @@ fn handle_user_events(mtm: MainThreadMarker) {
 
 pub fn handle_main_events_cleared(mtm: MainThreadMarker) {
     let mut this = AppState::get_mut(mtm);
-    if !this.has_launched() {
+    if !this.has_launched() || this.has_terminated() {
         return;
     }
     match this.state_mut() {

src/platform_impl/ios/event_loop.rs

@@ -289,7 +289,7 @@ fn setup_control_flow_observers() {
             #[allow(non_upper_case_globals)]
             match activity {
                 kCFRunLoopBeforeWaiting => app_state::handle_main_events_cleared(mtm),
-                kCFRunLoopExit => unimplemented!(), // not expected to ever happen
+                kCFRunLoopExit => {} // may happen when running on macOS
                 _ => unreachable!(),
             }
         }
@@ -304,7 +304,7 @@ fn setup_control_flow_observers() {
             #[allow(non_upper_case_globals)]
             match activity {
                 kCFRunLoopBeforeWaiting => app_state::handle_events_cleared(mtm),
-                kCFRunLoopExit => unimplemented!(), // not expected to ever happen
+                kCFRunLoopExit => {} // may happen when running on macOS
                 _ => unreachable!(),
             }
         }

src/platform_impl/ios/mod.rs

@@ -77,6 +77,7 @@ pub(crate) use self::{
 };
 
 use self::uikit::UIScreen;
+pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursor;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
 

src/platform_impl/ios/window.rs

@@ -11,6 +11,7 @@ use super::app_state::EventWrapper;
 use super::uikit::{UIApplication, UIScreen, UIScreenOverscanCompensation};
 use super::view::{WinitUIWindow, WinitView, WinitViewController};
 use crate::{
+    cursor::CustomCursor,
     dpi::{self, LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size},
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
     event::{Event, WindowEvent},
@@ -177,6 +178,10 @@ impl Inner {
         debug!("`Window::set_cursor_icon` ignored on iOS")
     }
 
+    pub fn set_custom_cursor(&self, _: CustomCursor) {
+        debug!("`Window::set_custom_cursor` ignored on iOS")
+    }
+
     pub fn set_cursor_position(&self, _position: Position) -> Result<(), ExternalError> {
         Err(ExternalError::NotSupported(NotSupportedError::new()))
     }

src/platform_impl/linux/mod.rs

@@ -14,6 +14,7 @@ use std::{ffi::CStr, mem::MaybeUninit, os::raw::*, sync::Mutex};
 use once_cell::sync::Lazy;
 use smol_str::SmolStr;
 
+use crate::cursor::CustomCursor;
 #[cfg(x11_platform)]
 use crate::platform::x11::XlibErrorHook;
 use crate::{
@@ -40,6 +41,7 @@ pub use x11::XNotSupported;
 #[cfg(x11_platform)]
 use x11::{util::WindowType as XWindowType, X11Error, XConnection, XError};
 
+pub(crate) use crate::cursor::CursorImage as PlatformCustomCursor;
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
 
@@ -424,6 +426,11 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.set_cursor_icon(cursor))
     }
 
+    #[inline]
+    pub fn set_custom_cursor(&self, cursor: CustomCursor) {
+        x11_or_wayland!(match self; Window(w) => w.set_custom_cursor(cursor))
+    }
+
     #[inline]
     pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
         x11_or_wayland!(match self; Window(window) => window.set_cursor_grab(mode))

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

@@ -393,7 +393,7 @@ impl<T: 'static> EventLoop<T> {
                     self.with_state(|state| {
                         let windows = state.windows.get_mut();
                         let mut window = windows.get(&window_id).unwrap().lock().unwrap();
-                        window.resize(new_logical_size);
+                        window.request_inner_size(new_logical_size.into());
                     });
                 }
 

src/platform_impl/linux/wayland/state.rs

@@ -19,6 +19,7 @@ use sctk::seat::SeatState;
 use sctk::shell::xdg::window::{Window, WindowConfigure, WindowHandler};
 use sctk::shell::xdg::XdgShell;
 use sctk::shell::WaylandSurface;
+use sctk::shm::slot::SlotPool;
 use sctk::shm::{Shm, ShmHandler};
 use sctk::subcompositor::SubcompositorState;
 
@@ -50,7 +51,7 @@ pub struct WinitState {
     pub compositor_state: Arc<CompositorState>,
 
     /// The state of the subcompositor.
-    pub subcompositor_state: Arc<SubcompositorState>,
+    pub subcompositor_state: Option<Arc<SubcompositorState>>,
 
     /// The seat state responsible for all sorts of input.
     pub seat_state: SeatState,
@@ -58,6 +59,9 @@ pub struct WinitState {
     /// The shm for software buffers, such as cursors.
     pub shm: Shm,
 
+    /// The pool where custom cursors are allocated.
+    pub custom_cursor_pool: Arc<Mutex<SlotPool>>,
+
     /// The XDG shell that is used for widnows.
     pub xdg_shell: XdgShell,
 
@@ -124,12 +128,17 @@ impl WinitState {
         let registry_state = RegistryState::new(globals);
         let compositor_state =
             CompositorState::bind(globals, queue_handle).map_err(WaylandError::Bind)?;
-        let subcompositor_state = SubcompositorState::bind(
+        let subcompositor_state = match SubcompositorState::bind(
             compositor_state.wl_compositor().clone(),
             globals,
             queue_handle,
-        )
-        .map_err(WaylandError::Bind)?;
+        ) {
+            Ok(c) => Some(c),
+            Err(e) => {
+                warn!("Subcompositor protocol not available, ignoring CSD: {e:?}");
+                None
+            }
+        };
 
         let output_state = OutputState::new(globals, queue_handle);
         let monitors = output_state.outputs().map(MonitorHandle::new).collect();
@@ -148,13 +157,17 @@ impl WinitState {
                 (None, None)
             };
 
+        let shm = Shm::bind(globals, queue_handle).map_err(WaylandError::Bind)?;
+        let custom_cursor_pool = Arc::new(Mutex::new(SlotPool::new(2, &shm).unwrap()));
+
         Ok(Self {
             registry_state,
             compositor_state: Arc::new(compositor_state),
-            subcompositor_state: Arc::new(subcompositor_state),
+            subcompositor_state: subcompositor_state.map(Arc::new),
             output_state,
             seat_state,
-            shm: Shm::bind(globals, queue_handle).map_err(WaylandError::Bind)?,
+            shm,
+            custom_cursor_pool,
 
             xdg_shell: XdgShell::bind(globals, queue_handle).map_err(WaylandError::Bind)?,
             xdg_activation: XdgActivationState::bind(globals, queue_handle).ok(),

src/platform_impl/linux/wayland/types/cursor.rs

@@ -0,0 +1,56 @@
+use cursor_icon::CursorIcon;
+
+use sctk::reexports::client::protocol::wl_shm::Format;
+use sctk::shm::slot::{Buffer, SlotPool};
+
+use crate::cursor::CursorImage;
+
+#[derive(Debug)]
+pub enum SelectedCursor {
+    Named(CursorIcon),
+    Custom(CustomCursor),
+}
+
+impl Default for SelectedCursor {
+    fn default() -> Self {
+        Self::Named(Default::default())
+    }
+}
+
+#[derive(Debug)]
+pub struct CustomCursor {
+    pub buffer: Buffer,
+    pub w: i32,
+    pub h: i32,
+    pub hotspot_x: i32,
+    pub hotspot_y: i32,
+}
+
+impl CustomCursor {
+    pub fn new(pool: &mut SlotPool, image: &CursorImage) -> Self {
+        let (buffer, canvas) = pool
+            .create_buffer(
+                image.width as i32,
+                image.height as i32,
+                4 * (image.width as i32),
+                Format::Argb8888,
+            )
+            .unwrap();
+
+        for (canvas_chunk, rgba_chunk) in canvas.chunks_exact_mut(4).zip(image.rgba.chunks_exact(4))
+        {
+            canvas_chunk[0] = rgba_chunk[2];
+            canvas_chunk[1] = rgba_chunk[1];
+            canvas_chunk[2] = rgba_chunk[0];
+            canvas_chunk[3] = rgba_chunk[3];
+        }
+
+        CustomCursor {
+            buffer,
+            w: image.width as i32,
+            h: image.height as i32,
+            hotspot_x: image.hotspot_x as i32,
+            hotspot_y: image.hotspot_y as i32,
+        }
+    }
+}

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

@@ -1,5 +1,6 @@
 //! Wayland protocol implementation boilerplate.
 
+pub mod cursor;
 pub mod kwin_blur;
 pub mod wp_fractional_scaling;
 pub mod wp_viewporter;

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

@@ -15,6 +15,7 @@ use sctk::shell::xdg::window::Window as SctkWindow;
 use sctk::shell::xdg::window::WindowDecorations;
 use sctk::shell::WaylandSurface;
 
+use crate::cursor::CustomCursor;
 use crate::dpi::{LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
 use crate::event::{Ime, WindowEvent};
@@ -97,11 +98,9 @@ impl Window {
             .map(|activation_state| activation_state.global().clone());
         let display = event_loop_window_target.connection.display();
 
-        // XXX The initial scale factor must be 1, but it might cause sizing issues on HiDPI.
-        let size: LogicalSize<u32> = attributes
+        let size: Size = attributes
             .inner_size
-            .map(|size| size.to_logical::<u32>(1.))
-            .unwrap_or((800, 600).into());
+            .unwrap_or(LogicalSize::new(800., 600.).into());
 
         // We prefer server side decorations, however to not have decorations we ask for client
         // side decorations instead.
@@ -141,7 +140,8 @@ impl Window {
         // Set the window title.
         window_state.set_title(attributes.title);
 
-        // Set the min and max sizes.
+        // Set the min and max sizes. We must set the hints upon creating a window, so
+        // we use the default `1.` scaling...
         let min_size = attributes.min_inner_size.map(|size| size.to_logical(1.));
         let max_size = attributes.max_inner_size.map(|size| size.to_logical(1.));
         window_state.set_min_inner_size(min_size);
@@ -315,12 +315,9 @@ impl Window {
     #[inline]
     pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let mut window_state = self.window_state.lock().unwrap();
-        let scale_factor = window_state.scale_factor();
-        window_state.resize(size.to_logical::<u32>(scale_factor));
-
+        let new_size = window_state.request_inner_size(size);
         self.request_redraw();
-
-        Some(window_state.inner_size().to_physical(scale_factor))
+        Some(new_size)
     }
 
     /// Set the minimum inner size for the window.
@@ -510,6 +507,11 @@ impl Window {
         self.window_state.lock().unwrap().set_cursor(cursor);
     }
 
+    #[inline]
+    pub fn set_custom_cursor(&self, cursor: CustomCursor) {
+        self.window_state.lock().unwrap().set_custom_cursor(cursor);
+    }
+
     #[inline]
     pub fn set_cursor_visible(&self, visible: bool) {
         self.window_state

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

@@ -1,8 +1,7 @@
 //! The state of the window, which is shared with the event-loop.
 
-use std::mem::ManuallyDrop;
 use std::num::NonZeroU32;
-use std::sync::{Arc, Weak};
+use std::sync::{Arc, Mutex, Weak};
 use std::time::Duration;
 
 use log::{info, warn};
@@ -19,20 +18,23 @@ use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::
 use sctk::reexports::protocols::wp::viewporter::client::wp_viewport::WpViewport;
 use sctk::reexports::protocols::xdg::shell::client::xdg_toplevel::ResizeEdge as XdgResizeEdge;
 
-use sctk::compositor::{CompositorState, Region};
-use sctk::seat::pointer::ThemedPointer;
+use sctk::compositor::{CompositorState, Region, SurfaceData, SurfaceDataExt};
+use sctk::seat::pointer::{PointerDataExt, ThemedPointer};
 use sctk::shell::xdg::window::{DecorationMode, Window, WindowConfigure};
 use sctk::shell::xdg::XdgSurface;
 use sctk::shell::WaylandSurface;
+use sctk::shm::slot::SlotPool;
 use sctk::shm::Shm;
 use sctk::subcompositor::SubcompositorState;
 use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 
-use crate::dpi::{LogicalPosition, LogicalSize};
+use crate::cursor::CustomCursor as RootCustomCursor;
+use crate::dpi::{LogicalPosition, LogicalSize, PhysicalSize, Size};
 use crate::error::{ExternalError, NotSupportedError};
 use crate::event::WindowEvent;
 use crate::platform_impl::wayland::event_loop::sink::EventSink;
 use crate::platform_impl::wayland::make_wid;
+use crate::platform_impl::wayland::types::cursor::{CustomCursor, SelectedCursor};
 use crate::platform_impl::wayland::types::kwin_blur::KWinBlurManager;
 use crate::platform_impl::WindowId;
 use crate::window::{CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme};
@@ -55,23 +57,22 @@ pub struct WindowState {
     /// The connection to Wayland server.
     pub connection: Connection,
 
-    /// The underlying SCTK window.
-    pub window: ManuallyDrop<Window>,
-
     /// The window frame, which is created from the configure request.
     frame: Option<WinitFrame>,
 
     /// The `Shm` to set cursor.
     pub shm: WlShm,
 
+    // A shared pool where to allocate custom cursors.
+    custom_cursor_pool: Arc<Mutex<SlotPool>>,
+
     /// The last received configure.
     pub last_configure: Option<WindowConfigure>,
 
     /// The pointers observed on the window.
     pub pointers: Vec<Weak<ThemedPointer<WinitPointerData>>>,
 
-    /// Cursor icon.
-    pub cursor_icon: CursorIcon,
+    selected_cursor: SelectedCursor,
 
     /// Wether the cursor is visible.
     pub cursor_visible: bool,
@@ -133,6 +134,10 @@ pub struct WindowState {
     /// sends `None` for the new size in the configure.
     stateless_size: LogicalSize<u32>,
 
+    /// Initial window size provided by the user. Removed on the first
+    /// configure.
+    initial_size: Option<Size>,
+
     /// The state of the frame callback.
     frame_callback_state: FrameCallbackState,
 
@@ -145,6 +150,9 @@ pub struct WindowState {
     ///
     /// The value is the serial of the event triggered moved.
     has_pending_move: Option<u32>,
+
+    /// The underlying SCTK window.
+    pub window: Window,
 }
 
 impl WindowState {
@@ -153,7 +161,7 @@ impl WindowState {
         connection: Connection,
         queue_handle: &QueueHandle<WinitState>,
         winit_state: &WinitState,
-        size: LogicalSize<u32>,
+        initial_size: Size,
         window: Window,
         theme: Option<Theme>,
     ) -> Self {
@@ -175,7 +183,7 @@ impl WindowState {
             connection,
             csd_fails: false,
             cursor_grab_mode: GrabState::new(),
-            cursor_icon: CursorIcon::Default,
+            selected_cursor: Default::default(),
             cursor_visible: true,
             decorate: true,
             fractional_scale,
@@ -194,14 +202,16 @@ impl WindowState {
             resizable: true,
             scale_factor: 1.,
             shm: winit_state.shm.wl_shm().clone(),
-            size,
-            stateless_size: size,
+            custom_cursor_pool: winit_state.custom_cursor_pool.clone(),
+            size: initial_size.to_logical(1.),
+            stateless_size: initial_size.to_logical(1.),
+            initial_size: Some(initial_size),
             text_inputs: Vec::new(),
             theme,
             title: String::default(),
             transparent: false,
             viewport,
-            window: ManuallyDrop::new(window),
+            window,
         }
     }
 
@@ -250,16 +260,27 @@ impl WindowState {
         &mut self,
         configure: WindowConfigure,
         shm: &Shm,
-        subcompositor: &Arc<SubcompositorState>,
+        subcompositor: &Option<Arc<SubcompositorState>>,
         event_sink: &mut EventSink,
     ) -> LogicalSize<u32> {
-        if configure.decoration_mode == DecorationMode::Client
-            && self.frame.is_none()
-            && !self.csd_fails
-        {
+        // NOTE: when using fractional scaling or wl_compositor@v6 the scaling
+        // should be delivered before the first configure, thus apply it to
+        // properly scale the physical sizes provided by the users.
+        if let Some(initial_size) = self.initial_size.take() {
+            self.size = initial_size.to_logical(self.scale_factor());
+            self.stateless_size = self.size;
+        }
+
+        if let Some(subcompositor) = subcompositor.as_ref().filter(|_| {
+            configure.decoration_mode == DecorationMode::Client
+                && self.frame.is_none()
+                && !self.csd_fails
+        }) {
             match WinitFrame::new(
-                &*self.window,
+                &self.window,
                 shm,
+                #[cfg(feature = "sctk-adwaita")]
+                self.compositor.clone(),
                 subcompositor.clone(),
                 self.queue_handle.clone(),
                 #[cfg(feature = "sctk-adwaita")]
@@ -297,7 +318,7 @@ impl WindowState {
             event_sink.push_window_event(WindowEvent::Occluded(occluded), window_id);
         }
 
-        let new_size = if let Some(frame) = self.frame.as_mut() {
+        let (mut new_size, constrain) = if let Some(frame) = self.frame.as_mut() {
             // Configure the window states.
             frame.update_state(configure.state);
 
@@ -305,22 +326,38 @@ impl WindowState {
                 (Some(width), Some(height)) => {
                     let (width, height) = frame.subtract_borders(width, height);
                     (
-                        width.map(|w| w.get()).unwrap_or(1),
-                        height.map(|h| h.get()).unwrap_or(1),
+                        (
+                            width.map(|w| w.get()).unwrap_or(1),
+                            height.map(|h| h.get()).unwrap_or(1),
+                        )
+                            .into(),
+                        false,
                     )
-                        .into()
                 }
-                (_, _) if stateless => self.stateless_size,
-                _ => self.size,
+                (_, _) if stateless => (self.stateless_size, true),
+                _ => (self.size, true),
             }
         } else {
             match configure.new_size {
-                (Some(width), Some(height)) => (width.get(), height.get()).into(),
-                _ if stateless => self.stateless_size,
-                _ => self.size,
+                (Some(width), Some(height)) => ((width.get(), height.get()).into(), false),
+                _ if stateless => (self.stateless_size, true),
+                _ => (self.size, true),
             }
         };
 
+        // Apply configure bounds only when compositor let the user decide what size to pick.
+        if constrain {
+            let bounds = self.inner_size_bounds(&configure);
+            new_size.width = bounds
+                .0
+                .map(|bound_w| new_size.width.min(bound_w.get()))
+                .unwrap_or(new_size.width);
+            new_size.height = bounds
+                .1
+                .map(|bound_h| new_size.height.min(bound_h.get()))
+                .unwrap_or(new_size.height);
+        }
+
         // XXX Set the configure before doing a resize.
         self.last_configure = Some(configure);
 
@@ -330,6 +367,30 @@ impl WindowState {
         new_size
     }
 
+    /// Compute the bounds for the inner size of the surface.
+    fn inner_size_bounds(
+        &self,
+        configure: &WindowConfigure,
+    ) -> (Option<NonZeroU32>, Option<NonZeroU32>) {
+        let configure_bounds = match configure.suggested_bounds {
+            Some((width, height)) => (NonZeroU32::new(width), NonZeroU32::new(height)),
+            None => (None, None),
+        };
+
+        if let Some(frame) = self.frame.as_ref() {
+            let (width, height) = frame.subtract_borders(
+                configure_bounds.0.unwrap_or(NonZeroU32::new(1).unwrap()),
+                configure_bounds.1.unwrap_or(NonZeroU32::new(1).unwrap()),
+            );
+            (
+                configure_bounds.0.and(width),
+                configure_bounds.1.and(height),
+            )
+        } else {
+            configure_bounds
+        }
+    }
+
     #[inline]
     fn is_stateless(configure: &WindowConfigure) -> bool {
         !(configure.is_maximized() || configure.is_fullscreen() || configure.is_tiled())
@@ -537,7 +598,7 @@ impl WindowState {
     /// Refresh the decorations frame if it's present returning whether the client should redraw.
     pub fn refresh_frame(&mut self) -> bool {
         if let Some(frame) = self.frame.as_mut() {
-            if frame.is_dirty() {
+            if !frame.is_hidden() && frame.is_dirty() {
                 return frame.draw();
             }
         }
@@ -548,7 +609,10 @@ impl WindowState {
     /// Reload the cursor style on the given window.
     pub fn reload_cursor_style(&mut self) {
         if self.cursor_visible {
-            self.set_cursor(self.cursor_icon);
+            match &self.selected_cursor {
+                SelectedCursor::Named(icon) => self.set_cursor(*icon),
+                SelectedCursor::Custom(cursor) => self.apply_custom_cursor(cursor),
+            }
         } else {
             self.set_cursor_visible(self.cursor_visible);
         }
@@ -568,8 +632,22 @@ impl WindowState {
         }
     }
 
+    /// Try to resize the window when the user can do so.
+    pub fn request_inner_size(&mut self, inner_size: Size) -> PhysicalSize<u32> {
+        if self
+            .last_configure
+            .as_ref()
+            .map(Self::is_stateless)
+            .unwrap_or(true)
+        {
+            self.resize(inner_size.to_logical(self.scale_factor()))
+        }
+
+        self.inner_size().to_physical(self.scale_factor())
+    }
+
     /// Resize the window to the new inner size.
-    pub fn resize(&mut self, inner_size: LogicalSize<u32>) {
+    fn resize(&mut self, inner_size: LogicalSize<u32>) {
         self.size = inner_size;
 
         // Update the stateless size.
@@ -620,10 +698,8 @@ impl WindowState {
     }
 
     /// Set the cursor icon.
-    ///
-    /// Providing `None` will hide the cursor.
     pub fn set_cursor(&mut self, cursor_icon: CursorIcon) {
-        self.cursor_icon = cursor_icon;
+        self.selected_cursor = SelectedCursor::Named(cursor_icon);
 
         if !self.cursor_visible {
             return;
@@ -636,6 +712,54 @@ impl WindowState {
         })
     }
 
+    /// Set the custom cursor icon.
+    pub fn set_custom_cursor(&mut self, cursor: RootCustomCursor) {
+        let cursor = {
+            let mut pool = self.custom_cursor_pool.lock().unwrap();
+            CustomCursor::new(&mut pool, &cursor.inner)
+        };
+
+        if self.cursor_visible {
+            self.apply_custom_cursor(&cursor);
+        }
+
+        self.selected_cursor = SelectedCursor::Custom(cursor);
+    }
+
+    fn apply_custom_cursor(&self, cursor: &CustomCursor) {
+        self.apply_on_poiner(|pointer, _| {
+            let surface = pointer.surface();
+
+            let scale = surface
+                .data::<SurfaceData>()
+                .unwrap()
+                .surface_data()
+                .scale_factor();
+
+            surface.set_buffer_scale(scale);
+            surface.attach(Some(cursor.buffer.wl_buffer()), 0, 0);
+            if surface.version() >= 4 {
+                surface.damage_buffer(0, 0, cursor.w, cursor.h);
+            } else {
+                surface.damage(0, 0, cursor.w / scale, cursor.h / scale);
+            }
+            surface.commit();
+
+            let serial = pointer
+                .pointer()
+                .data::<WinitPointerData>()
+                .and_then(|data| data.pointer_data().latest_enter_serial())
+                .unwrap();
+
+            pointer.pointer().set_cursor(
+                serial,
+                Some(surface),
+                cursor.hotspot_x / scale,
+                cursor.hotspot_y / scale,
+            );
+        });
+    }
+
     /// Set maximum inner window size.
     pub fn set_min_inner_size(&mut self, size: Option<LogicalSize<u32>>) {
         // Ensure that the window has the right minimum size.
@@ -770,7 +894,10 @@ impl WindowState {
         self.cursor_visible = cursor_visible;
 
         if self.cursor_visible {
-            self.set_cursor(self.cursor_icon);
+            match &self.selected_cursor {
+                SelectedCursor::Named(icon) => self.set_cursor(*icon),
+                SelectedCursor::Custom(cursor) => self.apply_custom_cursor(cursor),
+            }
         } else {
             for pointer in self.pointers.iter().filter_map(|pointer| pointer.upgrade()) {
                 let latest_enter_serial = pointer.pointer().winit_data().latest_enter_serial();
@@ -959,13 +1086,6 @@ impl WindowState {
 
 impl Drop for WindowState {
     fn drop(&mut self) {
-        let surface = self.window.wl_surface().clone();
-        unsafe {
-            ManuallyDrop::drop(&mut self.window);
-        }
-
-        // Cleanup objects.
-
         if let Some(blur) = self.blur.take() {
             blur.release();
         }
@@ -978,7 +1098,8 @@ impl Drop for WindowState {
             viewport.destroy();
         }
 
-        surface.destroy();
+        // NOTE: the wl_surface used by the window is being cleaned up when
+        // dropping SCTK `Window`.
     }
 }
 

src/platform_impl/linux/x11/atoms.rs

@@ -40,7 +40,6 @@ atom_manager! {
     WM_DELETE_WINDOW,
     WM_PROTOCOLS,
     WM_STATE,
-    XIM_SERVERS,
 
     // Assorted ICCCM Atoms
     _NET_WM_ICON,

src/platform_impl/linux/x11/dnd.rs

@@ -44,7 +44,7 @@ impl From<io::Error> for DndDataParseError {
 pub(crate) struct Dnd {
     xconn: Arc<XConnection>,
     // Populated by XdndEnter event handler
-    pub version: Option<c_long>,
+    pub version: Option<u32>,
     pub type_list: Option<Vec<xproto::Atom>>,
     // Populated by XdndPosition event handler
     pub source_window: Option<xproto::Window>,

src/platform_impl/linux/x11/ffi.rs

@@ -1,8 +1 @@
-use x11_dl::xmd::CARD32;
-pub use x11_dl::{
-    error::OpenError, keysym::*, xcursor::*, xinput::*, xinput2::*, xlib::*, xlib_xcb::*,
-};
-
-// Isn't defined by x11_dl
-#[allow(non_upper_case_globals)]
-pub const IconicState: CARD32 = 3;
+pub use x11_dl::{error::OpenError, xcursor::*, xinput2::*, xlib::*, xlib_xcb::*};

src/platform_impl/linux/x11/ime.rs

@@ -0,0 +1,862 @@
+//! IME handler, using the xim-rs crate.
+
+use super::{X11Error, X11rbConnection, XConnection};
+
+use x11rb::connection::Connection;
+use x11rb::protocol::xproto::Window;
+use x11rb::protocol::Event;
+
+use xim::x11rb::{HasConnection, X11rbClient};
+use xim::{AttributeName, Client as _, ClientError, ClientHandler, InputStyle, Point};
+
+use std::cell::RefCell;
+use std::collections::{HashMap, VecDeque};
+use std::fmt;
+use std::rc::Rc;
+use std::sync::Arc;
+
+impl HasConnection for XConnection {
+    type Connection = X11rbConnection;
+
+    fn conn(&self) -> &Self::Connection {
+        self.xcb_connection()
+    }
+}
+
+/// A collection of the IME events that can occur.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum ImeEvent {
+    Enabled,
+    Start,
+    Update(String, Option<usize>),
+    Commit(String),
+    End,
+    Disabled,
+}
+
+/// Invalid states that an IME client can enter.
+#[derive(Debug, Clone)]
+pub enum InvalidImeState {
+    /// The IME has no style information.
+    NoStyle,
+
+    /// No windows in the pending window queue.
+    NoWindows,
+
+    /// Invalid input context.
+    InvalidIc(u16),
+}
+
+impl fmt::Display for InvalidImeState {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            InvalidImeState::NoStyle => write!(f, "IME has no style information"),
+            InvalidImeState::NoWindows => {
+                write!(f, "IME has no windows in the pending window queue")
+            }
+            InvalidImeState::InvalidIc(ic) => write!(f, "IME has invalid input context {}", ic),
+        }
+    }
+}
+
+/// Request to control XIM handler from the window.
+pub enum ImeRequest {
+    /// Set IME spot position for given `window_id`.
+    Position(Window, i16, i16),
+
+    /// Allow IME input for the given `window_id`.
+    Allow(Window, bool),
+}
+
+/// The IME data for winit.
+pub(super) struct ImeData {
+    /// The XIM client manager.
+    client: X11rbClient<Arc<XConnection>>,
+
+    /// Relevant IME data.
+    handler: ImeHandler,
+}
+
+/// Inner IME handler.
+struct ImeHandler {
+    /// Handle to the event queue.
+    event_queue: Rc<RefCell<VecDeque<Event>>>,
+
+    /// Whether IME is currently disconnected.
+    disconnected: bool,
+
+    /// IME events waiting to be read.
+    ime_events: VecDeque<(Window, ImeEvent)>,
+
+    /// Windows waiting to be assigned an input context.
+    pending_windows: VecDeque<WindowData>,
+
+    /// Currently registered input styles.
+    styles: Option<(Style, Style)>,
+
+    /// The input method for the display, if there is one.
+    input_method: Option<u16>,
+
+    /// Hash map between input contexts and their associated data.
+    input_contexts: HashMap<u16, IcData>,
+
+    /// Map between window IDs and their associated input contexts.
+    window_contexts: HashMap<Window, u16>,
+}
+
+/// Data relevant for each input context.
+struct IcData {
+    /// Data associated with the window.
+    window: WindowData,
+
+    /// Newly set point for the context.
+    new_spot: Option<Point>,
+
+    /// The current preedit string.
+    ///
+    /// We use a `Vec<char>` here instead of a string because the IME indices operate on chars,
+    /// not bytes.
+    text: Vec<char>,
+
+    /// The current cursor position in the preedit string.
+    cursor: usize,
+}
+
+/// Windows waiting for IME events.
+struct WindowData {
+    /// The window ID.
+    id: Window,
+
+    /// The style of the window.
+    style: Style,
+
+    /// Current "spot" for the context.
+    spot: Point,
+}
+
+#[derive(Copy, Clone)]
+enum Style {
+    Preedit,
+    Nothing,
+    None,
+}
+
+impl ImeData {
+    /// Creates the IME data for the display.
+    pub(super) fn new(
+        conn: &Arc<XConnection>,
+        screen: usize,
+        event_queue: &Rc<RefCell<VecDeque<Event>>>,
+    ) -> Result<Self, X11Error> {
+        // IM servers to try, in order:
+        //  - None, which defaults to the environment variable `XMODIFIERS` in xim's impl.
+        //  - "local", which is the default for most IMEs.
+        //  - empty string, which may work in some cases.
+        let input_methods = [None, Some("local"), Some("")];
+        let mut last_error = X11Error::Ime(ClientError::NoXimServer);
+
+        for im in input_methods {
+            // Try to initialize a client here.
+            match X11rbClient::init(conn.clone(), screen, im) {
+                Ok(client) => {
+                    return Ok(Self {
+                        client,
+                        handler: ImeHandler {
+                            event_queue: event_queue.clone(),
+                            disconnected: true,
+                            ime_events: VecDeque::new(),
+                            pending_windows: VecDeque::new(),
+                            styles: None,
+                            input_method: None,
+                            input_contexts: HashMap::new(),
+                            window_contexts: HashMap::new(),
+                        },
+                    })
+                }
+
+                Err(err) => {
+                    log::warn!("Failed to create XIM client for {:?}: {err}", ImData(im));
+                    last_error = X11Error::Ime(err);
+                }
+            }
+        }
+
+        Err(last_error)
+    }
+
+    /// Filter an event.
+    pub(super) fn filter_event(&mut self, event: &Event) -> Result<bool, X11Error> {
+        self.client
+            .filter_event(event, &mut self.handler)
+            .map_err(X11Error::Ime)
+    }
+
+    /// Connection to the X server.
+    fn conn(&self) -> &X11rbConnection {
+        self.client.conn()
+    }
+
+    /// Get an IME event.
+    pub(super) fn next_ime_event(&mut self) -> Option<(Window, ImeEvent)> {
+        self.handler.ime_events.pop_front()
+    }
+
+    /// Create a new IME context for the provided window.
+    pub(super) fn create_context(
+        &mut self,
+        window: Window,
+        with_preedit: bool,
+        spot: Option<Point>,
+    ) -> Result<bool, X11Error> {
+        // If we aren't connected, nothing can be done.
+        if self.handler.disconnected {
+            return Ok(false);
+        }
+        let method = match self.handler.input_method {
+            Some(im) => im,
+            None => return Ok(false),
+        };
+
+        // Get the current style.
+        let style = match (self.handler.styles, with_preedit) {
+            (None, _) => return Err(X11Error::InvalidImeState(InvalidImeState::NoStyle)),
+            (Some((preedit_style, _)), true) => preedit_style,
+            (Some((_, none_style)), false) => none_style,
+        };
+
+        // Setup IC attributes.
+        let ic_attributes = {
+            let mut ic_attributes = self
+                .client
+                .build_ic_attributes()
+                .push(AttributeName::ClientWindow, window);
+
+            let ic_style = match style {
+                Style::Preedit => InputStyle::PREEDIT_POSITION | InputStyle::STATUS_NOTHING,
+                Style::Nothing => InputStyle::PREEDIT_NOTHING | InputStyle::STATUS_NOTHING,
+                Style::None => InputStyle::PREEDIT_NONE | InputStyle::STATUS_NONE,
+            };
+
+            if let Some(spot) = spot.clone() {
+                ic_attributes = ic_attributes.push(AttributeName::SpotLocation, spot);
+            }
+
+            ic_attributes
+                .push(AttributeName::InputStyle, ic_style)
+                .build()
+        };
+
+        // Create the IC.
+        self.client.create_ic(method, ic_attributes)?;
+
+        // Add to the waiting window list.
+        self.handler.pending_windows.push_back(WindowData {
+            id: window,
+            style,
+            spot: spot.unwrap_or(Point { x: 0, y: 0 }),
+        });
+
+        Ok(true)
+    }
+
+    /// Remove an IME context for a window.
+    pub(super) fn remove_context(&mut self, window: Window) -> Result<bool, X11Error> {
+        if self.handler.disconnected {
+            return Ok(false);
+        }
+        let method = match self.handler.input_method {
+            Some(im) => im,
+            None => return Ok(false),
+        };
+
+        // Remove the pending window if it's still pending.
+        let mut removed = false;
+        self.handler.pending_windows.retain(|pending| {
+            if pending.id == window {
+                removed = true;
+                false
+            } else {
+                true
+            }
+        });
+
+        if removed {
+            return Ok(true);
+        }
+
+        // Remove the IC if it's already created.
+        if let Some(ic) = self.handler.window_contexts.remove(&window) {
+            self.handler.input_contexts.remove(&ic);
+
+            // Destroy the IC.
+            self.client.destroy_ic(method, ic)?;
+        }
+
+        Ok(false)
+    }
+
+    /// Focus an IME context.
+    pub(super) fn focus_window(&mut self, window: Window) -> Result<bool, X11Error> {
+        if self.handler.disconnected {
+            return Ok(false);
+        }
+
+        let method = self.wait_for_method()?;
+        let ic = self.wait_for_context(window)?;
+
+        if let Some(ic) = ic {
+            self.client.set_focus(method, ic)?;
+            return Ok(true);
+        }
+
+        Ok(false)
+    }
+
+    /// Unfocus an IME context.
+    pub(super) fn unfocus_window(&mut self, window: Window) -> Result<bool, X11Error> {
+        if self.handler.disconnected {
+            return Ok(false);
+        }
+
+        let method = self.wait_for_method()?;
+        let ic = self.wait_for_context(window)?;
+
+        if let Some(ic) = ic {
+            self.client.unset_focus(method, ic)?;
+            return Ok(true);
+        }
+
+        Ok(false)
+    }
+
+    /// Set the spot for an IME context.
+    pub(super) fn set_spot(&mut self, window: Window, x: i16, y: i16) -> Result<(), X11Error> {
+        if self.handler.disconnected {
+            return Ok(());
+        }
+
+        let method = self.wait_for_method()?;
+        let ic = self.wait_for_context(window)?;
+
+        if let Some(ic) = ic {
+            // If the IC is not available, or if the spot is the same, then we don't need to update.
+            let ic_data = match self.handler.input_contexts.get_mut(&ic) {
+                Some(ic_data) => ic_data,
+                None => return Ok(()),
+            };
+
+            let new_point = Point { x, y };
+            if !matches!(ic_data.window.style, Style::None) || ic_data.window.spot == new_point {
+                return Ok(());
+            }
+
+            let new_attrs = self
+                .client
+                .build_ic_attributes()
+                .push(AttributeName::SpotLocation, new_point.clone())
+                .build();
+            self.client.set_ic_values(method, ic, new_attrs)?;
+
+            // Indicate that we have a new spot.
+            debug_assert!(ic_data.new_spot.is_none());
+            ic_data.new_spot = Some(new_point);
+        }
+
+        Ok(())
+    }
+
+    pub(super) fn set_ime_allowed(
+        &mut self,
+        window: Window,
+        allowed: bool,
+    ) -> Result<(), X11Error> {
+        if self.handler.disconnected {
+            return Ok(());
+        }
+
+        // Get the client info.
+        let _ = self.wait_for_method()?;
+        let ic = self.wait_for_context(window)?;
+
+        if let Some(ic) = ic {
+            let mut spot = None;
+
+            // See if we need to update the allowed state.
+            if let Some(ic_data) = self.handler.input_contexts.get(&ic) {
+                spot = Some(ic_data.window.spot.clone());
+                if matches!(ic_data.window.style, Style::None) != allowed {
+                    return Ok(());
+                }
+            }
+
+            // Delete and re-install the IC.
+            self.remove_context(window)?;
+            self.create_context(window, allowed, spot)?;
+        }
+
+        Ok(())
+    }
+
+    /// Wait for the input method to be set.
+    fn wait_for_method(&mut self) -> Result<u16, X11Error> {
+        loop {
+            if let Some(im) = self.handler.input_method {
+                return Ok(im);
+            }
+
+            // Wait and hope the input method is set.
+            self.block_for_ime()?;
+        }
+    }
+
+    /// Wait for an input context to be set.
+    fn wait_for_context(&mut self, window: Window) -> Result<Option<u16>, X11Error> {
+        if let Some(cid) = self.handler.window_contexts.get(&window) {
+            return Ok(Some(*cid));
+        }
+
+        // If the window isn't in our pending windows queue, there's no way for it to get an IC.
+        if !self
+            .handler
+            .pending_windows
+            .iter()
+            .any(|WindowData { id, .. }| *id == window)
+        {
+            return Ok(None);
+        }
+
+        loop {
+            self.block_for_ime()?;
+            if let Some(cid) = self.handler.window_contexts.get(&window) {
+                return Ok(Some(*cid));
+            }
+        }
+    }
+
+    /// Wait until we've acted on an IME event.
+    fn block_for_ime(&mut self) -> Result<(), X11Error> {
+        let mut last_event = self.conn().poll_for_event()?;
+
+        loop {
+            if let Some(last_event) = last_event.as_ref() {
+                if self.filter_event(last_event)? {
+                    return Ok(());
+                }
+            }
+
+            // This scope keeps track of the event queue handle.
+            {
+                // Check the event queue for events.
+                let event_queue = self.handler.event_queue.clone();
+                let mut event_queue = event_queue.borrow_mut();
+
+                // Check the event queue for events we can use.
+                let mut found_event = false;
+                let mut last_err = None;
+                event_queue.retain(|event| match self.filter_event(event) {
+                    Ok(false) => {
+                        found_event = true;
+                        true
+                    }
+                    Ok(true) => false,
+                    Err(err) => {
+                        last_err = Some(err);
+                        true
+                    }
+                });
+
+                // Push our own event to the queue.
+                if let Some(last_event) = last_event.take() {
+                    event_queue.push_back(last_event);
+                }
+
+                // Check for errors.
+                if let Some(err) = last_err {
+                    return Err(err);
+                }
+
+                // If we found an event, then we're done.
+                if found_event {
+                    return Ok(());
+                }
+            }
+
+            log::info!("Waiting for IME event");
+            last_event = Some(self.conn().wait_for_event()?);
+        }
+    }
+}
+
+impl<C: xim::Client> ClientHandler<C> for ImeHandler {
+    fn handle_connect(&mut self, client: &mut C) -> Result<(), ClientError> {
+        // We have been connected, now request a new input method for our current locale.
+        self.disconnected = false;
+        client.open(&locale())
+    }
+
+    fn handle_disconnect(&mut self) {
+        // We are now disconnected.
+        self.disconnected = true;
+    }
+
+    fn handle_open(&mut self, client: &mut C, input_method_id: u16) -> Result<(), ClientError> {
+        // We now have an input method.
+        debug_assert!(self.input_method.is_none());
+        self.input_method = Some(input_method_id);
+
+        // Ask for the IM's attributes.
+        client.get_im_values(input_method_id, &[AttributeName::QueryInputStyle])
+    }
+
+    fn handle_close(&mut self, _client: &mut C, input_method_id: u16) -> Result<(), ClientError> {
+        // No more input method.
+        debug_assert_eq!(self.input_method, Some(input_method_id));
+        self.input_method = None;
+
+        Ok(())
+    }
+
+    fn handle_get_im_values(
+        &mut self,
+        _client: &mut C,
+        input_method_id: u16,
+        mut attributes: xim::AHashMap<xim::AttributeName, Vec<u8>>,
+    ) -> Result<(), ClientError> {
+        debug_assert_eq!(self.input_method, Some(input_method_id));
+
+        // Get the input styles.
+        let mut preedit_style = None;
+        let mut none_style = None;
+
+        let styles = {
+            let style = attributes
+                .remove(&AttributeName::QueryInputStyle)
+                .expect("No query input style");
+            let mut result = vec![0u32; style.len() / 4];
+
+            bytemuck::cast_slice_mut::<u32, u8>(&mut result).copy_from_slice(&style);
+
+            result
+        };
+
+        {
+            // The styles that we're looking for.
+            let lu_preedit_style = InputStyle::PREEDIT_CALLBACKS | InputStyle::STATUS_NOTHING;
+            let lu_nothing_style = InputStyle::PREEDIT_NOTHING | InputStyle::STATUS_NOTHING;
+            let lu_none_style = InputStyle::PREEDIT_NONE | InputStyle::STATUS_NONE;
+
+            for style in styles {
+                let style = InputStyle::from_bits_truncate(style);
+
+                if style == lu_preedit_style {
+                    preedit_style = Some(Style::Preedit);
+                } else if style == lu_nothing_style {
+                    preedit_style = Some(Style::Nothing);
+                } else if style == lu_none_style {
+                    none_style = Some(Style::None);
+                }
+            }
+        }
+
+        let (preedit_style, none_style) = match (preedit_style, none_style) {
+            (None, None) => {
+                log::error!("No supported input styles found");
+                return Ok(());
+            }
+
+            (Some(style), None) | (None, Some(style)) => (style, style),
+
+            (Some(preedit_style), Some(none_style)) => (preedit_style, none_style),
+        };
+
+        self.styles = Some((preedit_style, none_style));
+
+        Ok(())
+    }
+
+    fn handle_create_ic(
+        &mut self,
+        _client: &mut C,
+        input_method_id: u16,
+        input_context_id: u16,
+    ) -> Result<(), ClientError> {
+        debug_assert_eq!(self.input_method, Some(input_method_id));
+
+        // Get the window that wanted the IC context.
+        let window = self
+            .pending_windows
+            .pop_front()
+            .ok_or_else(|| invalid_state(InvalidImeState::NoWindows))?;
+
+        // Create the IC data.
+        let ic_data = IcData {
+            window,
+            new_spot: None,
+            text: Vec::new(),
+            cursor: 0,
+        };
+
+        // Store the context.
+        let (window, style) = (ic_data.window.id, ic_data.window.style);
+        self.input_contexts.insert(input_context_id, ic_data);
+        self.window_contexts.insert(window, input_context_id);
+
+        // Indicate our status.
+        let event = if matches!(style, Style::Nothing) {
+            ImeEvent::Disabled
+        } else {
+            ImeEvent::Enabled
+        };
+        self.ime_events.push_back((window, event));
+
+        Ok(())
+    }
+
+    fn handle_destroy_ic(
+        &mut self,
+        _client: &mut C,
+        _input_method_id: u16,
+        _input_context_id: u16,
+    ) -> Result<(), ClientError> {
+        // This is already handled by the higher-level function.
+        Ok(())
+    }
+
+    fn handle_set_ic_values(
+        &mut self,
+        _client: &mut C,
+        input_method_id: u16,
+        input_context_id: u16,
+    ) -> Result<(), ClientError> {
+        debug_assert_eq!(self.input_method, Some(input_method_id));
+
+        // Get the IC data.
+        let ic_data = self
+            .input_contexts
+            .get_mut(&input_context_id)
+            .ok_or_else(|| invalid_state(InvalidImeState::InvalidIc(input_context_id)))?;
+
+        // Move up the new spot
+        if let Some(spot) = ic_data.new_spot.take() {
+            ic_data.window.spot = spot;
+        }
+
+        Ok(())
+    }
+
+    fn handle_preedit_start(
+        &mut self,
+        _client: &mut C,
+        input_method_id: u16,
+        input_context_id: u16,
+    ) -> Result<(), ClientError> {
+        debug_assert_eq!(self.input_method, Some(input_method_id));
+
+        if let Some(ic_data) = self.input_contexts.get_mut(&input_context_id) {
+            // Start a pre-edit.
+            ic_data.text.clear();
+            ic_data.cursor = 0;
+
+            // Indicate the start.
+            self.ime_events
+                .push_back((ic_data.window.id, ImeEvent::Start));
+        }
+
+        Ok(())
+    }
+
+    fn handle_preedit_draw(
+        &mut self,
+        _client: &mut C,
+        input_method_id: u16,
+        input_context_id: u16,
+        caret: i32,
+        chg_first: i32,
+        chg_len: i32,
+        _status: xim::PreeditDrawStatus,
+        preedit_string: &str,
+        _feedbacks: Vec<xim::Feedback>,
+    ) -> Result<(), ClientError> {
+        debug_assert_eq!(self.input_method, Some(input_method_id));
+
+        if let Some(ic_data) = self.input_contexts.get_mut(&input_context_id) {
+            // Set the cursor.
+            ic_data.cursor = caret as usize;
+
+            // Figure out the range of text to change.
+            let change_range = chg_first as usize..(chg_first + chg_len) as usize;
+
+            // If the range doesn't fit our current text, warn and return.
+            if change_range.start > ic_data.text.len() || change_range.end > ic_data.text.len() {
+                warn!(
+                    "Preedit draw range {}..{} doesn't fit text of length {}",
+                    change_range.start,
+                    change_range.end,
+                    ic_data.text.len()
+                );
+                return Ok(());
+            }
+
+            // Update the text in the changed range.
+            {
+                let text = &mut ic_data.text;
+                let mut old_text_tail = text.split_off(change_range.end);
+
+                text.truncate(change_range.start);
+                text.extend(preedit_string.chars());
+                text.append(&mut old_text_tail);
+            }
+
+            // Send the event.
+            let cursor_byte_pos = calc_byte_position(&ic_data.text, ic_data.cursor);
+            let event = ImeEvent::Update(ic_data.text.iter().collect(), Some(cursor_byte_pos));
+
+            self.ime_events.push_back((ic_data.window.id, event));
+        }
+
+        Ok(())
+    }
+
+    fn handle_preedit_caret(
+        &mut self,
+        _client: &mut C,
+        input_method_id: u16,
+        input_context_id: u16,
+        position: &mut i32,
+        direction: xim::CaretDirection,
+        _style: xim::CaretStyle,
+    ) -> Result<(), ClientError> {
+        // We only care about absolute position.
+        if matches!(direction, xim::CaretDirection::AbsolutePosition) {
+            debug_assert_eq!(self.input_method, Some(input_method_id));
+
+            if let Some(ic_data) = self.input_contexts.get_mut(&input_context_id) {
+                ic_data.cursor = *position as usize;
+
+                // Send the event
+                let event =
+                    ImeEvent::Update(ic_data.text.iter().collect(), Some(*position as usize));
+                self.ime_events.push_back((ic_data.window.id, event));
+            }
+        }
+
+        Ok(())
+    }
+
+    fn handle_preedit_done(
+        &mut self,
+        _client: &mut C,
+        input_method_id: u16,
+        input_context_id: u16,
+    ) -> Result<(), ClientError> {
+        debug_assert_eq!(self.input_method, Some(input_method_id));
+
+        // Get the client data.
+        if let Some(ic_data) = self.input_contexts.get_mut(&input_context_id) {
+            // We're done with a preedit.
+            ic_data.text.clear();
+            ic_data.cursor = 0;
+
+            // Send a message to the window.
+            let window = ic_data.window.id;
+            self.ime_events.push_back((window, ImeEvent::End));
+        }
+
+        Ok(())
+    }
+
+    fn handle_commit(
+        &mut self,
+        _client: &mut C,
+        input_method_id: u16,
+        input_context_id: u16,
+        text: &str,
+    ) -> Result<(), ClientError> {
+        debug_assert_eq!(self.input_method, Some(input_method_id));
+
+        // Get the client data.
+        if let Some(ic_data) = self.input_contexts.get_mut(&input_context_id) {
+            // Send a message to the window.
+            let window = ic_data.window.id;
+            self.ime_events
+                .push_back((window, ImeEvent::Commit(text.to_owned())));
+        }
+
+        Ok(())
+    }
+
+    fn handle_query_extension(
+        &mut self,
+        _client: &mut C,
+        _extensions: &[xim::Extension],
+    ) -> Result<(), ClientError> {
+        // Don't care.
+        Ok(())
+    }
+
+    fn handle_forward_event(
+        &mut self,
+        _client: &mut C,
+        _input_method_id: u16,
+        _input_context_id: u16,
+        _flag: xim::ForwardEventFlag,
+        _xev: C::XEvent,
+    ) -> Result<(), ClientError> {
+        // Don't care.
+        Ok(())
+    }
+
+    fn handle_set_event_mask(
+        &mut self,
+        _client: &mut C,
+        _input_method_id: u16,
+        _input_context_id: u16,
+        _forward_event_mask: u32,
+        _synchronous_event_mask: u32,
+    ) -> Result<(), ClientError> {
+        // Don't care.
+        Ok(())
+    }
+}
+
+#[inline(always)]
+fn invalid_state(state: InvalidImeState) -> ClientError {
+    ClientError::Other(Box::new(X11Error::InvalidImeState(state)))
+}
+
+struct ImData(Option<&'static str>);
+
+impl fmt::Debug for ImData {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.0 {
+            Some(name) => write!(f, "\"{}\"", name),
+            None => write!(f, "default input method"),
+        }
+    }
+}
+
+/// Get the current locale.
+fn locale() -> String {
+    use std::ffi::CStr;
+
+    const EN_US: &str = "en_US.UTF-8";
+
+    // Get the pointer to the current locale.
+    let locale_ptr = unsafe { libc::setlocale(libc::LC_CTYPE, std::ptr::null()) };
+
+    // If locale_ptr is null, just default to en_US.UTF-8.
+    if locale_ptr.is_null() {
+        return EN_US.to_owned();
+    }
+
+    // Convert the pointer to a CStr.
+    let locale_cstr = unsafe { CStr::from_ptr(locale_ptr) };
+
+    // Convert the CStr to a String to prevent the result from getting clobbered.
+    locale_cstr.to_str().unwrap_or(EN_US).to_owned()
+}
+
+fn calc_byte_position(text: &[char], pos: usize) -> usize {
+    text.iter().take(pos).map(|c| c.len_utf8()).sum()
+}

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

@@ -1,215 +0,0 @@
-use std::{collections::HashMap, os::raw::c_char, ptr, sync::Arc};
-
-use super::{ffi, XConnection, XError};
-
-use super::{
-    context::{ImeContext, ImeContextCreationError},
-    inner::{close_im, ImeInner},
-    input_method::PotentialInputMethods,
-};
-
-pub(crate) unsafe fn xim_set_callback(
-    xconn: &Arc<XConnection>,
-    xim: ffi::XIM,
-    field: *const c_char,
-    callback: *mut ffi::XIMCallback,
-) -> Result<(), XError> {
-    // It's advisable to wrap variadic FFI functions in our own functions, as we want to minimize
-    // access that isn't type-checked.
-    unsafe { (xconn.xlib.XSetIMValues)(xim, field, callback, ptr::null_mut::<()>()) };
-    xconn.check_errors()
-}
-
-// Set a callback for when an input method matching the current locale modifiers becomes
-// available. Note that this has nothing to do with what input methods are open or able to be
-// opened, and simply uses the modifiers that are set when the callback is set.
-// * 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(
-    xconn: &Arc<XConnection>,
-    client_data: ffi::XPointer,
-) -> Result<(), XError> {
-    unsafe {
-        (xconn.xlib.XRegisterIMInstantiateCallback)(
-            xconn.display,
-            ptr::null_mut(),
-            ptr::null_mut(),
-            ptr::null_mut(),
-            Some(xim_instantiate_callback),
-            client_data,
-        )
-    };
-    xconn.check_errors()
-}
-
-pub(crate) unsafe fn unset_instantiate_callback(
-    xconn: &Arc<XConnection>,
-    client_data: ffi::XPointer,
-) -> Result<(), XError> {
-    unsafe {
-        (xconn.xlib.XUnregisterIMInstantiateCallback)(
-            xconn.display,
-            ptr::null_mut(),
-            ptr::null_mut(),
-            ptr::null_mut(),
-            Some(xim_instantiate_callback),
-            client_data,
-        )
-    };
-    xconn.check_errors()
-}
-
-pub(crate) unsafe fn set_destroy_callback(
-    xconn: &Arc<XConnection>,
-    im: ffi::XIM,
-    inner: &ImeInner,
-) -> Result<(), XError> {
-    unsafe {
-        xim_set_callback(
-            xconn,
-            im,
-            ffi::XNDestroyCallback_0.as_ptr() as *const _,
-            &inner.destroy_callback as *const _ as *mut _,
-        )
-    }
-}
-
-#[derive(Debug)]
-#[allow(clippy::enum_variant_names)]
-enum ReplaceImError {
-    // Boxed to prevent large error type
-    MethodOpenFailed(Box<PotentialInputMethods>),
-    ContextCreationFailed(ImeContextCreationError),
-    SetDestroyCallbackFailed(XError),
-}
-
-// Attempt to replace current IM (which may or may not be presently valid) with a new one. This
-// includes replacing all existing input contexts and free'ing resources as necessary. This only
-// modifies existing state if all operations succeed.
-unsafe fn replace_im(inner: *mut ImeInner) -> Result<(), ReplaceImError> {
-    let xconn = unsafe { &(*inner).xconn };
-
-    let (new_im, is_fallback) = {
-        let new_im = unsafe { (*inner).potential_input_methods.open_im(xconn, None) };
-        let is_fallback = new_im.is_fallback();
-        (
-            new_im.ok().ok_or_else(|| {
-                ReplaceImError::MethodOpenFailed(Box::new(unsafe {
-                    (*inner).potential_input_methods.clone()
-                }))
-            })?,
-            is_fallback,
-        )
-    };
-
-    // It's important to always set a destroy callback, since there's otherwise potential for us
-    // to try to use or free a resource that's already been destroyed on the server.
-    {
-        let result = unsafe { set_destroy_callback(xconn, new_im.im, &*inner) };
-        if result.is_err() {
-            let _ = unsafe { close_im(xconn, new_im.im) };
-        }
-        result
-    }
-    .map_err(ReplaceImError::SetDestroyCallbackFailed)?;
-
-    let mut new_contexts = HashMap::new();
-    for (window, old_context) in unsafe { (*inner).contexts.iter() } {
-        let spot = old_context.as_ref().map(|old_context| old_context.ic_spot);
-
-        // Check if the IME was allowed on that context.
-        let is_allowed = old_context
-            .as_ref()
-            .map(|old_context| old_context.is_allowed())
-            .unwrap_or_default();
-
-        // We can't use the style from the old context here, since it may change on reload, so
-        // pick style from the new XIM based on the old state.
-        let style = if is_allowed {
-            new_im.preedit_style
-        } else {
-            new_im.none_style
-        };
-
-        let new_context = {
-            let result = unsafe {
-                ImeContext::new(
-                    xconn,
-                    new_im.im,
-                    style,
-                    *window,
-                    spot,
-                    (*inner).event_sender.clone(),
-                )
-            };
-            if result.is_err() {
-                let _ = unsafe { close_im(xconn, new_im.im) };
-            }
-            result.map_err(ReplaceImError::ContextCreationFailed)?
-        };
-        new_contexts.insert(*window, Some(new_context));
-    }
-
-    // If we've made it this far, everything succeeded.
-    unsafe {
-        let _ = (*inner).destroy_all_contexts_if_necessary();
-        let _ = (*inner).close_im_if_necessary();
-        (*inner).im = Some(new_im);
-        (*inner).contexts = new_contexts;
-        (*inner).is_destroyed = false;
-        (*inner).is_fallback = is_fallback;
-    }
-    Ok(())
-}
-
-pub unsafe extern "C" fn xim_instantiate_callback(
-    _display: *mut ffi::Display,
-    client_data: ffi::XPointer,
-    // This field is unsupplied.
-    _call_data: ffi::XPointer,
-) {
-    let inner: *mut ImeInner = client_data as _;
-    if !inner.is_null() {
-        let xconn = unsafe { &(*inner).xconn };
-        match unsafe { replace_im(inner) } {
-            Ok(()) => unsafe {
-                let _ = unset_instantiate_callback(xconn, client_data);
-                (*inner).is_fallback = false;
-            },
-            Err(err) => unsafe {
-                if (*inner).is_destroyed {
-                    // We have no usable input methods!
-                    panic!("Failed to reopen input method: {err:?}");
-                }
-            },
-        }
-    }
-}
-
-// This callback is triggered when the input method is closed on the server end. When this
-// happens, XCloseIM/XDestroyIC doesn't need to be called, as the resources have already been
-// free'd (attempting to do so causes our connection to freeze).
-pub unsafe extern "C" fn xim_destroy_callback(
-    _xim: ffi::XIM,
-    client_data: ffi::XPointer,
-    // This field is unsupplied.
-    _call_data: ffi::XPointer,
-) {
-    let inner: *mut ImeInner = client_data as _;
-    if !inner.is_null() {
-        unsafe { (*inner).is_destroyed = true };
-        let xconn = unsafe { &(*inner).xconn };
-        if unsafe { !(*inner).is_fallback } {
-            let _ = unsafe { set_instantiate_callback(xconn, client_data) };
-            // Attempt to open fallback input method.
-            match unsafe { replace_im(inner) } {
-                Ok(()) => unsafe { (*inner).is_fallback = true },
-                Err(err) => {
-                    // We have no usable input methods!
-                    panic!("Failed to open fallback input method: {err:?}");
-                }
-            }
-        }
-    }
-}

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

@@ -1,385 +0,0 @@
-use std::ffi::CStr;
-use std::os::raw::c_short;
-use std::sync::Arc;
-use std::{mem, ptr};
-
-use x11_dl::xlib::{XIMCallback, XIMPreeditCaretCallbackStruct, XIMPreeditDrawCallbackStruct};
-
-use crate::platform_impl::platform::x11::ime::input_method::{Style, XIMStyle};
-use crate::platform_impl::platform::x11::ime::{ImeEvent, ImeEventSender};
-
-use super::{ffi, util, XConnection, XError};
-
-/// IME creation error.
-#[derive(Debug)]
-pub enum ImeContextCreationError {
-    /// Got the error from Xlib.
-    XError(XError),
-
-    /// Got null pointer from Xlib but without exact reason.
-    Null,
-}
-
-/// The callback used by XIM preedit functions.
-type XIMProcNonnull = unsafe extern "C" fn(ffi::XIM, ffi::XPointer, ffi::XPointer);
-
-/// Wrapper for creating XIM callbacks.
-#[inline]
-fn create_xim_callback(client_data: ffi::XPointer, callback: XIMProcNonnull) -> ffi::XIMCallback {
-    XIMCallback {
-        client_data,
-        callback: Some(callback),
-    }
-}
-
-/// The server started preedit.
-extern "C" fn preedit_start_callback(
-    _xim: ffi::XIM,
-    client_data: ffi::XPointer,
-    _call_data: ffi::XPointer,
-) -> i32 {
-    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
-
-    client_data.text.clear();
-    client_data.cursor_pos = 0;
-    client_data
-        .event_sender
-        .send((client_data.window, ImeEvent::Start))
-        .expect("failed to send preedit start event");
-    -1
-}
-
-/// Done callback is used when the preedit should be hidden.
-extern "C" fn preedit_done_callback(
-    _xim: ffi::XIM,
-    client_data: ffi::XPointer,
-    _call_data: ffi::XPointer,
-) {
-    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
-
-    // Drop text buffer and reset cursor position on done.
-    client_data.text = Vec::new();
-    client_data.cursor_pos = 0;
-
-    client_data
-        .event_sender
-        .send((client_data.window, ImeEvent::End))
-        .expect("failed to send preedit end event");
-}
-
-fn calc_byte_position(text: &[char], pos: usize) -> usize {
-    text.iter()
-        .take(pos)
-        .fold(0, |byte_pos, text| byte_pos + text.len_utf8())
-}
-
-/// Preedit text information to be drawn inline by the client.
-extern "C" fn preedit_draw_callback(
-    _xim: ffi::XIM,
-    client_data: ffi::XPointer,
-    call_data: ffi::XPointer,
-) {
-    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
-    let call_data = unsafe { &mut *(call_data as *mut XIMPreeditDrawCallbackStruct) };
-    client_data.cursor_pos = call_data.caret as usize;
-
-    let chg_range =
-        call_data.chg_first as usize..(call_data.chg_first + call_data.chg_length) as usize;
-    if chg_range.start > client_data.text.len() || chg_range.end > client_data.text.len() {
-        warn!(
-            "invalid chg range: buffer length={}, but chg_first={} chg_lengthg={}",
-            client_data.text.len(),
-            call_data.chg_first,
-            call_data.chg_length
-        );
-        return;
-    }
-
-    // NULL indicate text deletion
-    let mut new_chars = if call_data.text.is_null() {
-        Vec::new()
-    } else {
-        let xim_text = unsafe { &mut *(call_data.text) };
-        if xim_text.encoding_is_wchar > 0 {
-            return;
-        }
-
-        let new_text = unsafe { xim_text.string.multi_byte };
-
-        if new_text.is_null() {
-            return;
-        }
-
-        let new_text = unsafe { CStr::from_ptr(new_text) };
-
-        String::from(new_text.to_str().expect("Invalid UTF-8 String from IME"))
-            .chars()
-            .collect()
-    };
-    let mut old_text_tail = client_data.text.split_off(chg_range.end);
-    client_data.text.truncate(chg_range.start);
-    client_data.text.append(&mut new_chars);
-    client_data.text.append(&mut old_text_tail);
-    let cursor_byte_pos = calc_byte_position(&client_data.text, client_data.cursor_pos);
-
-    client_data
-        .event_sender
-        .send((
-            client_data.window,
-            ImeEvent::Update(client_data.text.iter().collect(), cursor_byte_pos),
-        ))
-        .expect("failed to send preedit update event");
-}
-
-/// Handling of cursor movements in preedit text.
-extern "C" fn preedit_caret_callback(
-    _xim: ffi::XIM,
-    client_data: ffi::XPointer,
-    call_data: ffi::XPointer,
-) {
-    let client_data = unsafe { &mut *(client_data as *mut ImeContextClientData) };
-    let call_data = unsafe { &mut *(call_data as *mut XIMPreeditCaretCallbackStruct) };
-
-    if call_data.direction == ffi::XIMCaretDirection::XIMAbsolutePosition {
-        client_data.cursor_pos = call_data.position as usize;
-        let cursor_byte_pos = calc_byte_position(&client_data.text, client_data.cursor_pos);
-
-        client_data
-            .event_sender
-            .send((
-                client_data.window,
-                ImeEvent::Update(client_data.text.iter().collect(), cursor_byte_pos),
-            ))
-            .expect("failed to send preedit update event");
-    }
-}
-
-/// Struct to simplify callback creation and latter passing into Xlib XIM.
-struct PreeditCallbacks {
-    start_callback: ffi::XIMCallback,
-    done_callback: ffi::XIMCallback,
-    draw_callback: ffi::XIMCallback,
-    caret_callback: ffi::XIMCallback,
-}
-
-impl PreeditCallbacks {
-    pub fn new(client_data: ffi::XPointer) -> PreeditCallbacks {
-        let start_callback = create_xim_callback(client_data, unsafe {
-            mem::transmute(preedit_start_callback as usize)
-        });
-        let done_callback = create_xim_callback(client_data, preedit_done_callback);
-        let caret_callback = create_xim_callback(client_data, preedit_caret_callback);
-        let draw_callback = create_xim_callback(client_data, preedit_draw_callback);
-
-        PreeditCallbacks {
-            start_callback,
-            done_callback,
-            caret_callback,
-            draw_callback,
-        }
-    }
-}
-
-struct ImeContextClientData {
-    window: ffi::Window,
-    event_sender: ImeEventSender,
-    text: Vec<char>,
-    cursor_pos: usize,
-}
-
-// XXX: this struct doesn't destroy its XIC resource when dropped.
-// This is intentional, as it doesn't have enough information to know whether or not the context
-// still exists on the server. Since `ImeInner` has that awareness, destruction must be handled
-// through `ImeInner`.
-pub struct ImeContext {
-    pub(crate) ic: ffi::XIC,
-    pub(crate) ic_spot: ffi::XPoint,
-    pub(crate) style: Style,
-    // Since the data is passed shared between X11 XIM callbacks, but couldn't be direclty free from
-    // there we keep the pointer to automatically deallocate it.
-    _client_data: Box<ImeContextClientData>,
-}
-
-impl ImeContext {
-    pub(crate) unsafe fn new(
-        xconn: &Arc<XConnection>,
-        im: ffi::XIM,
-        style: Style,
-        window: ffi::Window,
-        ic_spot: Option<ffi::XPoint>,
-        event_sender: ImeEventSender,
-    ) -> Result<Self, ImeContextCreationError> {
-        let client_data = Box::into_raw(Box::new(ImeContextClientData {
-            window,
-            event_sender,
-            text: Vec::new(),
-            cursor_pos: 0,
-        }));
-
-        let ic = match style as _ {
-            Style::Preedit(style) => unsafe {
-                ImeContext::create_preedit_ic(
-                    xconn,
-                    im,
-                    style,
-                    window,
-                    client_data as ffi::XPointer,
-                )
-            },
-            Style::Nothing(style) => unsafe {
-                ImeContext::create_nothing_ic(xconn, im, style, window)
-            },
-            Style::None(style) => unsafe { ImeContext::create_none_ic(xconn, im, style, window) },
-        }
-        .ok_or(ImeContextCreationError::Null)?;
-
-        xconn
-            .check_errors()
-            .map_err(ImeContextCreationError::XError)?;
-
-        let mut context = ImeContext {
-            ic,
-            ic_spot: ffi::XPoint { x: 0, y: 0 },
-            style,
-            _client_data: unsafe { Box::from_raw(client_data) },
-        };
-
-        // Set the spot location, if it's present.
-        if let Some(ic_spot) = ic_spot {
-            context.set_spot(xconn, ic_spot.x, ic_spot.y)
-        }
-
-        Ok(context)
-    }
-
-    unsafe fn create_none_ic(
-        xconn: &Arc<XConnection>,
-        im: ffi::XIM,
-        style: XIMStyle,
-        window: ffi::Window,
-    ) -> Option<ffi::XIC> {
-        let ic = unsafe {
-            (xconn.xlib.XCreateIC)(
-                im,
-                ffi::XNInputStyle_0.as_ptr() as *const _,
-                style,
-                ffi::XNClientWindow_0.as_ptr() as *const _,
-                window,
-                ptr::null_mut::<()>(),
-            )
-        };
-
-        (!ic.is_null()).then_some(ic)
-    }
-
-    unsafe fn create_preedit_ic(
-        xconn: &Arc<XConnection>,
-        im: ffi::XIM,
-        style: XIMStyle,
-        window: ffi::Window,
-        client_data: ffi::XPointer,
-    ) -> Option<ffi::XIC> {
-        let preedit_callbacks = PreeditCallbacks::new(client_data);
-        let preedit_attr = util::memory::XSmartPointer::new(xconn, unsafe {
-            (xconn.xlib.XVaCreateNestedList)(
-                0,
-                ffi::XNPreeditStartCallback_0.as_ptr() as *const _,
-                &(preedit_callbacks.start_callback) as *const _,
-                ffi::XNPreeditDoneCallback_0.as_ptr() as *const _,
-                &(preedit_callbacks.done_callback) as *const _,
-                ffi::XNPreeditCaretCallback_0.as_ptr() as *const _,
-                &(preedit_callbacks.caret_callback) as *const _,
-                ffi::XNPreeditDrawCallback_0.as_ptr() as *const _,
-                &(preedit_callbacks.draw_callback) as *const _,
-                ptr::null_mut::<()>(),
-            )
-        })
-        .expect("XVaCreateNestedList returned NULL");
-
-        let ic = unsafe {
-            (xconn.xlib.XCreateIC)(
-                im,
-                ffi::XNInputStyle_0.as_ptr() as *const _,
-                style,
-                ffi::XNClientWindow_0.as_ptr() as *const _,
-                window,
-                ffi::XNPreeditAttributes_0.as_ptr() as *const _,
-                preedit_attr.ptr,
-                ptr::null_mut::<()>(),
-            )
-        };
-
-        (!ic.is_null()).then_some(ic)
-    }
-
-    unsafe fn create_nothing_ic(
-        xconn: &Arc<XConnection>,
-        im: ffi::XIM,
-        style: XIMStyle,
-        window: ffi::Window,
-    ) -> Option<ffi::XIC> {
-        let ic = unsafe {
-            (xconn.xlib.XCreateIC)(
-                im,
-                ffi::XNInputStyle_0.as_ptr() as *const _,
-                style,
-                ffi::XNClientWindow_0.as_ptr() as *const _,
-                window,
-                ptr::null_mut::<()>(),
-            )
-        };
-
-        (!ic.is_null()).then_some(ic)
-    }
-
-    pub(crate) 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> {
-        unsafe {
-            (xconn.xlib.XUnsetICFocus)(self.ic);
-        }
-        xconn.check_errors()
-    }
-
-    pub fn is_allowed(&self) -> bool {
-        !matches!(self.style, Style::None(_))
-    }
-
-    // Set the spot for preedit text. Setting spot isn't working with libX11 when preedit callbacks
-    // are being used. Certain IMEs do show selection window, but it's placed in bottom left of the
-    // 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) {
-        if !self.is_allowed() || self.ic_spot.x == x && self.ic_spot.y == y {
-            return;
-        }
-
-        self.ic_spot = ffi::XPoint { x, y };
-
-        unsafe {
-            let preedit_attr = util::memory::XSmartPointer::new(
-                xconn,
-                (xconn.xlib.XVaCreateNestedList)(
-                    0,
-                    ffi::XNSpotLocation_0.as_ptr(),
-                    &self.ic_spot,
-                    ptr::null_mut::<()>(),
-                ),
-            )
-            .expect("XVaCreateNestedList returned NULL");
-
-            (xconn.xlib.XSetICValues)(
-                self.ic,
-                ffi::XNPreeditAttributes_0.as_ptr() as *const _,
-                preedit_attr.ptr,
-                ptr::null_mut::<()>(),
-            );
-        }
-    }
-}

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

@@ -1,75 +0,0 @@
-use std::{collections::HashMap, mem, sync::Arc};
-
-use super::{ffi, XConnection, XError};
-
-use super::{
-    context::ImeContext,
-    input_method::{InputMethod, PotentialInputMethods},
-};
-use crate::platform_impl::platform::x11::ime::ImeEventSender;
-
-pub(crate) unsafe fn close_im(xconn: &Arc<XConnection>, im: ffi::XIM) -> Result<(), XError> {
-    unsafe { (xconn.xlib.XCloseIM)(im) };
-    xconn.check_errors()
-}
-
-pub(crate) unsafe fn destroy_ic(xconn: &Arc<XConnection>, ic: ffi::XIC) -> Result<(), XError> {
-    unsafe { (xconn.xlib.XDestroyIC)(ic) };
-    xconn.check_errors()
-}
-
-pub(crate) struct ImeInner {
-    pub xconn: Arc<XConnection>,
-    pub im: Option<InputMethod>,
-    pub potential_input_methods: PotentialInputMethods,
-    pub contexts: HashMap<ffi::Window, Option<ImeContext>>,
-    // WARNING: this is initially zeroed!
-    pub destroy_callback: ffi::XIMCallback,
-    pub event_sender: ImeEventSender,
-    // Indicates whether or not the the input method was destroyed on the server end
-    // (i.e. if ibus/fcitx/etc. was terminated/restarted)
-    pub is_destroyed: bool,
-    pub is_fallback: bool,
-}
-
-impl ImeInner {
-    pub(crate) fn new(
-        xconn: Arc<XConnection>,
-        potential_input_methods: PotentialInputMethods,
-        event_sender: ImeEventSender,
-    ) -> Self {
-        ImeInner {
-            xconn,
-            im: None,
-            potential_input_methods,
-            contexts: HashMap::new(),
-            destroy_callback: unsafe { mem::zeroed() },
-            event_sender,
-            is_destroyed: false,
-            is_fallback: false,
-        }
-    }
-
-    pub unsafe fn close_im_if_necessary(&self) -> Result<bool, XError> {
-        if !self.is_destroyed && self.im.is_some() {
-            unsafe { close_im(&self.xconn, self.im.as_ref().unwrap().im) }.map(|_| true)
-        } else {
-            Ok(false)
-        }
-    }
-
-    pub unsafe fn destroy_ic_if_necessary(&self, ic: ffi::XIC) -> Result<bool, XError> {
-        if !self.is_destroyed {
-            unsafe { destroy_ic(&self.xconn, ic) }.map(|_| true)
-        } else {
-            Ok(false)
-        }
-    }
-
-    pub unsafe fn destroy_all_contexts_if_necessary(&self) -> Result<bool, XError> {
-        for context in self.contexts.values().flatten() {
-            unsafe { self.destroy_ic_if_necessary(context.ic)? };
-        }
-        Ok(!self.is_destroyed)
-    }
-}

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

@@ -1,370 +0,0 @@
-use std::{
-    env,
-    ffi::{CStr, CString, IntoStringError},
-    fmt,
-    os::raw::{c_char, c_ulong, c_ushort},
-    ptr,
-    sync::{Arc, Mutex},
-};
-
-use super::{super::atoms::*, ffi, util, XConnection, XError};
-use once_cell::sync::Lazy;
-use x11rb::protocol::xproto;
-
-static GLOBAL_LOCK: Lazy<Mutex<()>> = Lazy::new(Default::default);
-
-unsafe fn open_im(xconn: &Arc<XConnection>, locale_modifiers: &CStr) -> Option<ffi::XIM> {
-    let _lock = GLOBAL_LOCK.lock();
-
-    // XSetLocaleModifiers returns...
-    // * The current locale modifiers if it's given a NULL pointer.
-    // * The new locale modifiers if we succeeded in setting them.
-    // * NULL if the locale modifiers string is malformed or if the
-    //   current locale is not supported by Xlib.
-    unsafe { (xconn.xlib.XSetLocaleModifiers)(locale_modifiers.as_ptr()) };
-
-    let im = unsafe {
-        (xconn.xlib.XOpenIM)(
-            xconn.display,
-            ptr::null_mut(),
-            ptr::null_mut(),
-            ptr::null_mut(),
-        )
-    };
-
-    if im.is_null() {
-        None
-    } else {
-        Some(im)
-    }
-}
-
-#[derive(Debug)]
-pub struct InputMethod {
-    pub im: ffi::XIM,
-    pub preedit_style: Style,
-    pub none_style: Style,
-    _name: String,
-}
-
-impl InputMethod {
-    fn new(xconn: &Arc<XConnection>, im: ffi::XIM, name: String) -> Option<Self> {
-        let mut styles: *mut XIMStyles = std::ptr::null_mut();
-
-        // Query the styles supported by the XIM.
-        unsafe {
-            if !(xconn.xlib.XGetIMValues)(
-                im,
-                ffi::XNQueryInputStyle_0.as_ptr() as *const _,
-                (&mut styles) as *mut _,
-                std::ptr::null_mut::<()>(),
-            )
-            .is_null()
-            {
-                return None;
-            }
-        }
-
-        let mut preedit_style = None;
-        let mut none_style = None;
-
-        unsafe {
-            std::slice::from_raw_parts((*styles).supported_styles, (*styles).count_styles as _)
-                .iter()
-                .for_each(|style| match *style {
-                    XIM_PREEDIT_STYLE => {
-                        preedit_style = Some(Style::Preedit(*style));
-                    }
-                    XIM_NOTHING_STYLE if preedit_style.is_none() => {
-                        preedit_style = Some(Style::Nothing(*style))
-                    }
-                    XIM_NONE_STYLE => none_style = Some(Style::None(*style)),
-                    _ => (),
-                });
-
-            (xconn.xlib.XFree)(styles.cast());
-        };
-
-        if preedit_style.is_none() && none_style.is_none() {
-            return None;
-        }
-
-        let preedit_style = preedit_style.unwrap_or_else(|| none_style.unwrap());
-        let none_style = none_style.unwrap_or(preedit_style);
-
-        Some(InputMethod {
-            im,
-            _name: name,
-            preedit_style,
-            none_style,
-        })
-    }
-}
-
-const XIM_PREEDIT_STYLE: XIMStyle = (ffi::XIMPreeditCallbacks | ffi::XIMStatusNothing) as XIMStyle;
-const XIM_NOTHING_STYLE: XIMStyle = (ffi::XIMPreeditNothing | ffi::XIMStatusNothing) as XIMStyle;
-const XIM_NONE_STYLE: XIMStyle = (ffi::XIMPreeditNone | ffi::XIMStatusNone) as XIMStyle;
-
-/// Style of the IME context.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Style {
-    /// Preedit callbacks.
-    Preedit(XIMStyle),
-
-    /// Nothing.
-    Nothing(XIMStyle),
-
-    /// No IME.
-    None(XIMStyle),
-}
-
-impl Default for Style {
-    fn default() -> Self {
-        Style::None(XIM_NONE_STYLE)
-    }
-}
-
-#[repr(C)]
-#[derive(Debug)]
-struct XIMStyles {
-    count_styles: c_ushort,
-    supported_styles: *const XIMStyle,
-}
-
-pub(crate) type XIMStyle = c_ulong;
-
-#[derive(Debug)]
-pub enum InputMethodResult {
-    /// Input method used locale modifier from `XMODIFIERS` environment variable.
-    XModifiers(InputMethod),
-    /// Input method used internal fallback locale modifier.
-    Fallback(InputMethod),
-    /// Input method could not be opened using any locale modifier tried.
-    Failure,
-}
-
-impl InputMethodResult {
-    pub fn is_fallback(&self) -> bool {
-        matches!(self, InputMethodResult::Fallback(_))
-    }
-
-    pub fn ok(self) -> Option<InputMethod> {
-        use self::InputMethodResult::*;
-        match self {
-            XModifiers(im) | Fallback(im) => Some(im),
-            Failure => None,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-enum GetXimServersError {
-    XError(XError),
-    GetPropertyError(util::GetPropertyError),
-    InvalidUtf8(IntoStringError),
-}
-
-impl From<util::GetPropertyError> for GetXimServersError {
-    fn from(error: util::GetPropertyError) -> Self {
-        GetXimServersError::GetPropertyError(error)
-    }
-}
-
-// The root window has a property named XIM_SERVERS, which contains a list of atoms represeting
-// the availabile XIM servers. For instance, if you're using ibus, it would contain an atom named
-// "@server=ibus". It's possible for this property to contain multiple atoms, though presumably
-// rare. Note that we replace "@server=" with "@im=" in order to match the format of locale
-// modifiers, since we don't want a user who's looking at logs to ask "am I supposed to set
-// XMODIFIERS to `@server=ibus`?!?"
-unsafe fn get_xim_servers(xconn: &Arc<XConnection>) -> Result<Vec<String>, GetXimServersError> {
-    let atoms = xconn.atoms();
-    let servers_atom = atoms[XIM_SERVERS];
-
-    let root = unsafe { (xconn.xlib.XDefaultRootWindow)(xconn.display) };
-
-    let mut atoms: Vec<ffi::Atom> = xconn
-        .get_property::<xproto::Atom>(
-            root as xproto::Window,
-            servers_atom,
-            xproto::Atom::from(xproto::AtomEnum::ATOM),
-        )
-        .map_err(GetXimServersError::GetPropertyError)?
-        .into_iter()
-        .map(ffi::Atom::from)
-        .collect::<Vec<_>>();
-
-    let mut names: Vec<*const c_char> = Vec::with_capacity(atoms.len());
-    unsafe {
-        (xconn.xlib.XGetAtomNames)(
-            xconn.display,
-            atoms.as_mut_ptr(),
-            atoms.len() as _,
-            names.as_mut_ptr() as _,
-        )
-    };
-    unsafe { names.set_len(atoms.len()) };
-
-    let mut formatted_names = Vec::with_capacity(names.len());
-    for name in names {
-        let string = unsafe { CStr::from_ptr(name) }
-            .to_owned()
-            .into_string()
-            .map_err(GetXimServersError::InvalidUtf8)?;
-        unsafe { (xconn.xlib.XFree)(name as _) };
-        formatted_names.push(string.replace("@server=", "@im="));
-    }
-    xconn.check_errors().map_err(GetXimServersError::XError)?;
-    Ok(formatted_names)
-}
-
-#[derive(Clone)]
-struct InputMethodName {
-    c_string: CString,
-    string: String,
-}
-
-impl InputMethodName {
-    pub fn from_string(string: String) -> Self {
-        let c_string = CString::new(string.clone())
-            .expect("String used to construct CString contained null byte");
-        InputMethodName { c_string, string }
-    }
-
-    pub fn from_str(string: &str) -> Self {
-        let c_string =
-            CString::new(string).expect("String used to construct CString contained null byte");
-        InputMethodName {
-            c_string,
-            string: string.to_owned(),
-        }
-    }
-}
-
-impl fmt::Debug for InputMethodName {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.string.fmt(f)
-    }
-}
-
-#[derive(Debug, Clone)]
-struct PotentialInputMethod {
-    name: InputMethodName,
-    successful: Option<bool>,
-}
-
-impl PotentialInputMethod {
-    pub fn from_string(string: String) -> Self {
-        PotentialInputMethod {
-            name: InputMethodName::from_string(string),
-            successful: None,
-        }
-    }
-
-    pub fn from_str(string: &str) -> Self {
-        PotentialInputMethod {
-            name: InputMethodName::from_str(string),
-            successful: None,
-        }
-    }
-
-    pub fn reset(&mut self) {
-        self.successful = None;
-    }
-
-    pub fn open_im(&mut self, xconn: &Arc<XConnection>) -> Option<InputMethod> {
-        let im = unsafe { open_im(xconn, &self.name.c_string) };
-        self.successful = Some(im.is_some());
-        im.and_then(|im| InputMethod::new(xconn, im, self.name.string.clone()))
-    }
-}
-
-// 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 {
-    // On correctly configured systems, the XMODIFIERS environment variable tells us everything we
-    // need to know.
-    xmodifiers: Option<PotentialInputMethod>,
-    // We have some standard options at our disposal that should ostensibly always work. For users
-    // who only need compose sequences, this ensures that the program launches without a hitch
-    // For users who need more sophisticated IME features, this is more or less a silent failure.
-    // Logging features should be added in the future to allow both audiences to be effectively
-    // served.
-    fallbacks: [PotentialInputMethod; 2],
-    // For diagnostic purposes, we include the list of XIM servers that the server reports as
-    // being available.
-    _xim_servers: Result<Vec<String>, GetXimServersError>,
-}
-
-impl PotentialInputMethods {
-    pub fn new(xconn: &Arc<XConnection>) -> Self {
-        let xmodifiers = env::var("XMODIFIERS")
-            .ok()
-            .map(PotentialInputMethod::from_string);
-        PotentialInputMethods {
-            // Since passing "" to XSetLocaleModifiers results in it defaulting to the value of
-            // XMODIFIERS, it's worth noting what happens if XMODIFIERS is also "". If simply
-            // running the program with `XMODIFIERS="" cargo run`, then assuming XMODIFIERS is
-            // defined in the profile (or parent environment) then that parent XMODIFIERS is used.
-            // If that XMODIFIERS value is also "" (i.e. if you ran `export XMODIFIERS=""`), then
-            // XSetLocaleModifiers uses the default local input method. Note that defining
-            // XMODIFIERS as "" is different from XMODIFIERS not being defined at all, since in
-            // that case, we get `None` and end up skipping ahead to the next method.
-            xmodifiers,
-            fallbacks: [
-                // This is a standard input method that supports compose sequences, which should
-                // always be available. `@im=none` appears to mean the same thing.
-                PotentialInputMethod::from_str("@im=local"),
-                // This explicitly specifies to use the implementation-dependent default, though
-                // that seems to be equivalent to just using the local input method.
-                PotentialInputMethod::from_str("@im="),
-            ],
-            // The XIM_SERVERS property can have surprising values. For instance, when I exited
-            // ibus to run fcitx, it retained the value denoting ibus. Even more surprising is
-            // that the fcitx input method could only be successfully opened using "@im=ibus".
-            // Presumably due to this quirk, it's actually possible to alternate between ibus and
-            // fcitx in a running application.
-            _xim_servers: unsafe { get_xim_servers(xconn) },
-        }
-    }
-
-    // This resets the `successful` field of every potential input method, ensuring we have
-    // accurate information when this struct is re-used by the destruction/instantiation callbacks.
-    fn reset(&mut self) {
-        if let Some(ref mut input_method) = self.xmodifiers {
-            input_method.reset();
-        }
-
-        for input_method in &mut self.fallbacks {
-            input_method.reset();
-        }
-    }
-
-    pub fn open_im(
-        &mut self,
-        xconn: &Arc<XConnection>,
-        callback: Option<&dyn Fn()>,
-    ) -> InputMethodResult {
-        use self::InputMethodResult::*;
-
-        self.reset();
-
-        if let Some(ref mut input_method) = self.xmodifiers {
-            let im = input_method.open_im(xconn);
-            if let Some(im) = im {
-                return XModifiers(im);
-            } else if let Some(ref callback) = callback {
-                callback();
-            }
-        }
-
-        for input_method in &mut self.fallbacks {
-            let im = input_method.open_im(xconn);
-            if let Some(im) = im {
-                return Fallback(im);
-            }
-        }
-
-        Failure
-    }
-}

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

@@ -1,249 +0,0 @@
-// Important: all XIM calls need to happen from the same thread!
-
-mod callbacks;
-mod context;
-mod inner;
-mod input_method;
-
-use std::sync::{
-    mpsc::{Receiver, Sender},
-    Arc,
-};
-
-use super::{ffi, util, XConnection, XError};
-
-pub use self::context::ImeContextCreationError;
-use self::{
-    callbacks::*,
-    context::ImeContext,
-    inner::{close_im, ImeInner},
-    input_method::{PotentialInputMethods, Style},
-};
-
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum ImeEvent {
-    Enabled,
-    Start,
-    Update(String, usize),
-    End,
-    Disabled,
-}
-
-pub type ImeReceiver = Receiver<ImeRequest>;
-pub type ImeSender = Sender<ImeRequest>;
-pub type ImeEventReceiver = Receiver<(ffi::Window, ImeEvent)>;
-pub type ImeEventSender = Sender<(ffi::Window, ImeEvent)>;
-
-/// Request to control XIM handler from the window.
-pub enum ImeRequest {
-    /// Set IME spot position for given `window_id`.
-    Position(ffi::Window, i16, i16),
-
-    /// Allow IME input for the given `window_id`.
-    Allow(ffi::Window, bool),
-}
-
-#[derive(Debug)]
-pub(crate) enum ImeCreationError {
-    // Boxed to prevent large error type
-    OpenFailure(Box<PotentialInputMethods>),
-    SetDestroyCallbackFailed(XError),
-}
-
-pub(crate) 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.
-    inner: Box<ImeInner>,
-}
-
-impl Ime {
-    pub fn new(
-        xconn: Arc<XConnection>,
-        event_sender: ImeEventSender,
-    ) -> Result<Self, ImeCreationError> {
-        let potential_input_methods = PotentialInputMethods::new(&xconn);
-
-        let (mut inner, client_data) = {
-            let mut inner = Box::new(ImeInner::new(xconn, potential_input_methods, event_sender));
-            let inner_ptr = Box::into_raw(inner);
-            let client_data = inner_ptr as _;
-            let destroy_callback = ffi::XIMCallback {
-                client_data,
-                callback: Some(xim_destroy_callback),
-            };
-            inner = unsafe { Box::from_raw(inner_ptr) };
-            inner.destroy_callback = destroy_callback;
-            (inner, client_data)
-        };
-
-        let xconn = Arc::clone(&inner.xconn);
-
-        let input_method = inner.potential_input_methods.open_im(
-            &xconn,
-            Some(&|| {
-                let _ = unsafe { set_instantiate_callback(&xconn, client_data) };
-            }),
-        );
-
-        let is_fallback = input_method.is_fallback();
-        if let Some(input_method) = input_method.ok() {
-            inner.is_fallback = is_fallback;
-            unsafe {
-                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);
-                }
-                result?;
-            }
-            inner.im = Some(input_method);
-            Ok(Ime { xconn, inner })
-        } else {
-            Err(ImeCreationError::OpenFailure(Box::new(
-                inner.potential_input_methods,
-            )))
-        }
-    }
-
-    pub fn is_destroyed(&self) -> bool {
-        self.inner.is_destroyed
-    }
-
-    // This pattern is used for various methods here:
-    // Ok(_) indicates that nothing went wrong internally
-    // Ok(true) indicates that the action was actually performed
-    // Ok(false) indicates that the action is not presently applicable
-    pub fn create_context(
-        &mut self,
-        window: ffi::Window,
-        with_preedit: bool,
-    ) -> Result<bool, ImeContextCreationError> {
-        let context = if self.is_destroyed() {
-            // Create empty entry in map, so that when IME is rebuilt, this window has a context.
-            None
-        } else {
-            let im = self.inner.im.as_ref().unwrap();
-            let style = if with_preedit {
-                im.preedit_style
-            } else {
-                im.none_style
-            };
-
-            let context = unsafe {
-                ImeContext::new(
-                    &self.inner.xconn,
-                    im.im,
-                    style,
-                    window,
-                    None,
-                    self.inner.event_sender.clone(),
-                )?
-            };
-
-            // Check the state on the context, since it could fail to enable or disable preedit.
-            let event = if matches!(style, Style::None(_)) {
-                if with_preedit {
-                    debug!("failed to create IME context with preedit support.")
-                }
-                ImeEvent::Disabled
-            } else {
-                if !with_preedit {
-                    debug!("failed to create IME context without preedit support.")
-                }
-                ImeEvent::Enabled
-            };
-
-            self.inner
-                .event_sender
-                .send((window, event))
-                .expect("Failed to send enabled event");
-
-            Some(context)
-        };
-
-        self.inner.contexts.insert(window, context);
-        Ok(!self.is_destroyed())
-    }
-
-    pub fn get_context(&self, window: ffi::Window) -> Option<ffi::XIC> {
-        if self.is_destroyed() {
-            return None;
-        }
-        if let Some(Some(context)) = self.inner.contexts.get(&window) {
-            Some(context.ic)
-        } else {
-            None
-        }
-    }
-
-    pub fn remove_context(&mut self, window: ffi::Window) -> Result<bool, XError> {
-        if let Some(Some(context)) = self.inner.contexts.remove(&window) {
-            unsafe {
-                self.inner.destroy_ic_if_necessary(context.ic)?;
-            }
-            Ok(true)
-        } else {
-            Ok(false)
-        }
-    }
-
-    pub fn focus(&mut self, window: ffi::Window) -> Result<bool, XError> {
-        if self.is_destroyed() {
-            return Ok(false);
-        }
-        if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
-            context.focus(&self.xconn).map(|_| true)
-        } else {
-            Ok(false)
-        }
-    }
-
-    pub fn unfocus(&mut self, window: ffi::Window) -> Result<bool, XError> {
-        if self.is_destroyed() {
-            return Ok(false);
-        }
-        if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
-            context.unfocus(&self.xconn).map(|_| true)
-        } else {
-            Ok(false)
-        }
-    }
-
-    pub fn send_xim_spot(&mut self, window: ffi::Window, x: i16, y: i16) {
-        if self.is_destroyed() {
-            return;
-        }
-        if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
-            context.set_spot(&self.xconn, x as _, y as _);
-        }
-    }
-
-    pub fn set_ime_allowed(&mut self, window: ffi::Window, allowed: bool) {
-        if self.is_destroyed() {
-            return;
-        }
-
-        if let Some(&mut Some(ref mut context)) = self.inner.contexts.get_mut(&window) {
-            if allowed == context.is_allowed() {
-                return;
-            }
-        }
-
-        // Remove context for that window.
-        let _ = self.remove_context(window);
-
-        // Create new context supporting IME input.
-        let _ = self.create_context(window, allowed);
-    }
-}
-
-impl Drop for Ime {
-    fn drop(&mut self) {
-        unsafe {
-            let _ = self.inner.destroy_all_contexts_if_necessary();
-            let _ = self.inner.close_im_if_necessary();
-        }
-    }
-}

src/platform_impl/linux/x11/mod.rs

@@ -28,13 +28,11 @@ use std::{
     collections::{HashMap, HashSet},
     ffi::CStr,
     fmt,
-    mem::MaybeUninit,
     ops::Deref,
     os::{
         raw::*,
         unix::io::{AsFd, AsRawFd, BorrowedFd, RawFd},
     },
-    ptr,
     rc::Rc,
     slice, str,
     sync::mpsc::{Receiver, Sender, TryRecvError},
@@ -42,19 +40,14 @@ use std::{
     time::{Duration, Instant},
 };
 
-use libc::{self, setlocale, LC_CTYPE};
-
 use atoms::*;
 
-use x11rb::x11_utils::X11Error as LogicalError;
-use x11rb::{
-    connection::RequestConnection,
-    protocol::{
-        xinput::{self, ConnectionExt as _},
-        xkb,
-        xproto::{self, ConnectionExt as _},
-    },
+use x11rb::protocol::{
+    xinput::{self, ConnectionExt as _},
+    xkb,
+    xproto::{self, ConnectionExt as _},
 };
+use x11rb::x11_utils::X11Error as LogicalError;
 use x11rb::{
     errors::{ConnectError, ConnectionError, IdsExhausted, ReplyError},
     xcb_ffi::ReplyOrIdError,
@@ -63,7 +56,6 @@ use x11rb::{
 use self::{
     dnd::{Dnd, DndState},
     event_processor::EventProcessor,
-    ime::{Ime, ImeCreationError, ImeReceiver, ImeRequest, ImeSender},
 };
 use super::{common::xkb_state::KbdState, ControlFlow, OsError};
 use crate::{
@@ -81,6 +73,7 @@ use crate::{
 // Xinput constants not defined in x11rb
 const ALL_DEVICES: u16 = 0;
 const ALL_MASTER_DEVICES: u16 = 1;
+const ICONIC_STATE: u32 = 3;
 
 type X11Source = Generic<BorrowedFd<'static>>;
 
@@ -146,15 +139,18 @@ pub struct EventLoopWindowTarget<T> {
     xconn: Arc<XConnection>,
     wm_delete_window: xproto::Atom,
     net_wm_ping: xproto::Atom,
-    ime_sender: ImeSender,
+    ime_sender: mpsc::Sender<ime::ImeRequest>,
     control_flow: Cell<ControlFlow>,
     exit: Cell<Option<i32>>,
     root: xproto::Window,
-    ime: RefCell<Ime>,
     windows: RefCell<HashMap<WindowId, Weak<UnownedWindow>>>,
     redraw_sender: WakeSender<WindowId>,
     activation_sender: WakeSender<ActivationToken>,
     device_events: Cell<DeviceEvents>,
+
+    /// State of IME.
+    ime: Option<RefCell<ime::ImeData>>,
+
     _marker: ::std::marker::PhantomData<T>,
 }
 
@@ -200,57 +196,26 @@ impl<T: 'static> EventLoop<T> {
         let wm_delete_window = atoms[WM_DELETE_WINDOW];
         let net_wm_ping = atoms[_NET_WM_PING];
 
+        // Create an event queue.
+        let event_queue = Rc::new(RefCell::new(std::collections::VecDeque::with_capacity(4)));
+
         let dnd = Dnd::new(Arc::clone(&xconn))
             .expect("Failed to call XInternAtoms when initializing drag and drop");
 
         let (ime_sender, ime_receiver) = mpsc::channel();
-        let (ime_event_sender, ime_event_receiver) = mpsc::channel();
-        // Input methods will open successfully without setting the locale, but it won't be
-        // possible to actually commit pre-edit sequences.
-        unsafe {
-            // Remember default locale to restore it if target locale is unsupported
-            // by Xlib
-            let default_locale = setlocale(LC_CTYPE, ptr::null());
-            setlocale(LC_CTYPE, b"\0".as_ptr() as *const _);
 
-            // Check if set locale is supported by Xlib.
-            // If not, calls to some Xlib functions like `XSetLocaleModifiers`
-            // will fail.
-            let locale_supported = (xconn.xlib.XSupportsLocale)() == 1;
-            if !locale_supported {
-                let unsupported_locale = setlocale(LC_CTYPE, ptr::null());
-                warn!(
-                    "Unsupported locale \"{}\". Restoring default locale \"{}\".",
-                    CStr::from_ptr(unsupported_locale).to_string_lossy(),
-                    CStr::from_ptr(default_locale).to_string_lossy()
-                );
-                // Restore default locale
-                setlocale(LC_CTYPE, default_locale);
+        let ime = match ime::ImeData::new(&xconn, xconn.default_screen_index(), &event_queue) {
+            Ok(ime) => Some(ime),
+            Err(e) => {
+                log::error!("Failed to open IME: {e}");
+                None
             }
-        }
-        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:#?}");
-            }
-            result.expect("Failed to set input method destruction callback")
-        });
+        };
 
-        let randr_event_offset = xconn
+        xconn
             .select_xrandr_input(root)
             .expect("Failed to query XRandR extension");
 
-        let xi2ext = xconn
-            .xcb_connection()
-            .extension_information(xinput::X11_EXTENSION_NAME)
-            .expect("Failed to query XInput extension")
-            .expect("X server missing XInput extension");
-        let xkbext = xconn
-            .xcb_connection()
-            .extension_information(xkb::X11_EXTENSION_NAME)
-            .expect("Failed to query XKB extension")
-            .expect("X server missing XKB extension");
-
         // Check for XInput2 support.
         xconn
             .xcb_connection()
@@ -302,12 +267,12 @@ impl<T: 'static> EventLoop<T> {
             KbdState::from_x11_xkb(xconn.xcb_connection().get_raw_xcb_connection()).unwrap();
 
         let window_target = EventLoopWindowTarget {
-            ime,
             root,
             control_flow: Cell::new(ControlFlow::default()),
             exit: Cell::new(None),
             windows: Default::default(),
             _marker: ::std::marker::PhantomData,
+            ime: ime.map(RefCell::new),
             ime_sender,
             xconn,
             wm_delete_window,
@@ -332,14 +297,11 @@ impl<T: 'static> EventLoop<T> {
         });
 
         let event_processor = EventProcessor {
+            event_queue,
             target: target.clone(),
             dnd,
             devices: Default::default(),
-            randr_event_offset,
-            ime_receiver,
-            ime_event_receiver,
-            xi2ext,
-            xkbext,
+            ime_requests: ime_receiver,
             kb_state,
             num_touch: 0,
             held_key_press: None,
@@ -622,12 +584,10 @@ impl<T: 'static> EventLoop<T> {
         F: FnMut(Event<T>, &RootELW<T>),
     {
         let target = &self.target;
-        let mut xev = MaybeUninit::uninit();
         let wt = get_xtarget(&self.target);
 
-        while unsafe { self.event_processor.poll_one_event(xev.as_mut_ptr()) } {
-            let mut xev = unsafe { xev.assume_init() };
-            self.event_processor.process_event(&mut xev, |event| {
+        while let Some(event) = self.event_processor.poll_one_event() {
+            self.event_processor.process_event(event, |event| {
                 if let Event::WindowEvent {
                     window_id: crate::window::WindowId(wid),
                     event: WindowEvent::RedrawRequested,
@@ -879,8 +839,11 @@ pub enum X11Error {
     /// The XID range has been exhausted.
     XidsExhausted(IdsExhausted),
 
-    /// Got `null` from an Xlib function without a reason.
-    UnexpectedNull(&'static str),
+    /// An IME client error occurred.
+    Ime(xim::ClientError),
+
+    /// The IME client has entered an invalid state.
+    InvalidImeState(ime::InvalidImeState),
 
     /// Got an invalid activation token.
     InvalidActivationToken(Vec<u8>),
@@ -899,8 +862,9 @@ impl fmt::Display for X11Error {
             X11Error::Connect(e) => write!(f, "X11 connection error: {}", e),
             X11Error::Connection(e) => write!(f, "X11 connection error: {}", e),
             X11Error::XidsExhausted(e) => write!(f, "XID range exhausted: {}", e),
+            X11Error::Ime(e) => write!(f, "An IME error occurred: {}", e),
+            X11Error::InvalidImeState(e) => write!(f, "Invalid IME state: {}", e),
             X11Error::X11(e) => write!(f, "X11 error: {:?}", e),
-            X11Error::UnexpectedNull(s) => write!(f, "Xlib function returned null: {}", s),
             X11Error::InvalidActivationToken(s) => write!(
                 f,
                 "Invalid activation token: {}",
@@ -963,15 +927,6 @@ impl From<ReplyError> for X11Error {
     }
 }
 
-impl From<ime::ImeContextCreationError> for X11Error {
-    fn from(value: ime::ImeContextCreationError) -> Self {
-        match value {
-            ime::ImeContextCreationError::XError(e) => e.into(),
-            ime::ImeContextCreationError::Null => Self::UnexpectedNull("XOpenIM"),
-        }
-    }
-}
-
 impl From<ReplyOrIdError> for X11Error {
     fn from(value: ReplyOrIdError) -> Self {
         match value {
@@ -982,6 +937,18 @@ impl From<ReplyOrIdError> for X11Error {
     }
 }
 
+impl From<xim::ClientError> for X11Error {
+    fn from(e: xim::ClientError) -> Self {
+        match e {
+            xim::ClientError::Other(other) => match other.downcast::<X11Error>() {
+                Ok(x11) => *x11,
+                Err(other) => X11Error::Ime(xim::ClientError::Other(other)),
+            },
+            e => X11Error::Ime(e),
+        }
+    }
+}
+
 /// The underlying x11rb connection that we are using.
 type X11rbConnection = x11rb::xcb_ffi::XCBConnection;
 
@@ -1000,34 +967,6 @@ impl<'a, E: fmt::Debug> CookieResultExt for Result<VoidCookie<'a>, E> {
     }
 }
 
-/// XEvents of type GenericEvent store their actual data in an XGenericEventCookie data structure. This is a wrapper to
-/// extract the cookie from a GenericEvent XEvent and release the cookie data once it has been processed
-struct GenericEventCookie<'a> {
-    xconn: &'a XConnection,
-    cookie: ffi::XGenericEventCookie,
-}
-
-impl<'a> GenericEventCookie<'a> {
-    fn from_event(xconn: &XConnection, event: ffi::XEvent) -> Option<GenericEventCookie<'_>> {
-        unsafe {
-            let mut cookie: ffi::XGenericEventCookie = From::from(event);
-            if (xconn.xlib.XGetEventData)(xconn.display, &mut cookie) == ffi::True {
-                Some(GenericEventCookie { xconn, cookie })
-            } else {
-                None
-            }
-        }
-    }
-}
-
-impl<'a> Drop for GenericEventCookie<'a> {
-    fn drop(&mut self) {
-        unsafe {
-            (self.xconn.xlib.XFreeEventData)(self.xconn.display, &mut self.cookie);
-        }
-    }
-}
-
 fn mkwid(w: xproto::Window) -> crate::window::WindowId {
     crate::window::WindowId(crate::platform_impl::platform::WindowId(w as _))
 }
@@ -1128,3 +1067,16 @@ impl Device {
         }
     }
 }
+
+/// Convert the raw X11 representation for a 32-bit fixed point to a double.
+#[inline]
+fn xinput_fp1616_to_float(fp: xinput::Fp1616) -> f64 {
+    (fp as f64) / ((1 << 16) as f64)
+}
+
+/// Conver the raw X11 representation for a 64-bit fixed point number to a double.
+#[inline]
+fn xinput_fp3232_to_float(fp: xinput::Fp3232) -> f64 {
+    let xinput::Fp3232 { integral, frac } = fp;
+    integral as f64 + (frac as f64 / (1u64 << 32) as f64)
+}

src/platform_impl/linux/x11/monitor.rs

@@ -212,7 +212,7 @@ impl XConnection {
             return Ok(MonitorHandle::dummy());
         }
 
-        let default = monitors.get(0).unwrap();
+        let default = monitors.first().unwrap();
 
         let window_rect = match window_rect {
             Some(rect) => rect,

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

@@ -1,8 +1,8 @@
-use std::ffi::CString;
+use std::{ffi::CString, iter, slice, sync::Arc};
 
 use x11rb::connection::Connection;
 
-use crate::window::CursorIcon;
+use crate::{cursor::CursorImage, window::CursorIcon};
 
 use super::*;
 
@@ -19,6 +19,11 @@ impl XConnection {
             .expect("Failed to set cursor");
     }
 
+    pub fn set_custom_cursor(&self, window: xproto::Window, cursor: &CustomCursor) {
+        self.update_cursor(window, cursor.inner.cursor)
+            .expect("Failed to set cursor");
+    }
+
     fn create_empty_cursor(&self) -> ffi::Cursor {
         let data = 0;
         let pixmap = unsafe {
@@ -56,10 +61,22 @@ impl XConnection {
             None => return self.create_empty_cursor(),
         };
 
-        let name = CString::new(cursor.name()).unwrap();
-        unsafe {
-            (self.xcursor.XcursorLibraryLoadCursor)(self.display, name.as_ptr() as *const c_char)
+        let mut xcursor = 0;
+        for &name in iter::once(&cursor.name()).chain(cursor.alt_names().iter()) {
+            let name = CString::new(name).unwrap();
+            xcursor = unsafe {
+                (self.xcursor.XcursorLibraryLoadCursor)(
+                    self.display,
+                    name.as_ptr() as *const c_char,
+                )
+            };
+
+            if xcursor != 0 {
+                break;
+            }
         }
+
+        xcursor
     }
 
     fn update_cursor(&self, window: xproto::Window, cursor: ffi::Cursor) -> Result<(), X11Error> {
@@ -74,3 +91,74 @@ impl XConnection {
         Ok(())
     }
 }
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SelectedCursor {
+    Custom(CustomCursor),
+    Named(CursorIcon),
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CustomCursor {
+    inner: Arc<CustomCursorInner>,
+}
+
+impl CustomCursor {
+    pub(crate) unsafe fn new(xconn: &Arc<XConnection>, image: &CursorImage) -> Self {
+        unsafe {
+            let ximage =
+                (xconn.xcursor.XcursorImageCreate)(image.width as i32, image.height as i32);
+            if ximage.is_null() {
+                panic!("failed to allocate cursor image");
+            }
+            (*ximage).xhot = image.hotspot_x as u32;
+            (*ximage).yhot = image.hotspot_y as u32;
+            (*ximage).delay = 0;
+
+            let dst = slice::from_raw_parts_mut((*ximage).pixels, image.rgba.len() / 4);
+            for (dst, chunk) in dst.iter_mut().zip(image.rgba.chunks_exact(4)) {
+                *dst = (chunk[0] as u32) << 16
+                    | (chunk[1] as u32) << 8
+                    | (chunk[2] as u32)
+                    | (chunk[3] as u32) << 24;
+            }
+
+            let cursor = (xconn.xcursor.XcursorImageLoadCursor)(xconn.display, ximage);
+            (xconn.xcursor.XcursorImageDestroy)(ximage);
+            Self {
+                inner: Arc::new(CustomCursorInner {
+                    xconn: xconn.clone(),
+                    cursor,
+                }),
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+struct CustomCursorInner {
+    xconn: Arc<XConnection>,
+    cursor: ffi::Cursor,
+}
+
+impl Drop for CustomCursorInner {
+    fn drop(&mut self) {
+        unsafe {
+            (self.xconn.xlib.XFreeCursor)(self.xconn.display, self.cursor);
+        }
+    }
+}
+
+impl PartialEq for CustomCursorInner {
+    fn eq(&self, other: &Self) -> bool {
+        self.cursor == other.cursor
+    }
+}
+
+impl Eq for CustomCursorInner {}
+
+impl Default for SelectedCursor {
+    fn default() -> Self {
+        SelectedCursor::Named(Default::default())
+    }
+}

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

@@ -1,4 +1,3 @@
-use std::{slice, str};
 use x11rb::protocol::{
     xinput::{self, ConnectionExt as _},
     xkb,
@@ -9,11 +8,6 @@ use super::*;
 pub const VIRTUAL_CORE_POINTER: u16 = 2;
 pub const VIRTUAL_CORE_KEYBOARD: u16 = 3;
 
-// A base buffer size of 1kB uses a negligible amount of RAM while preventing us from having to
-// re-allocate (and make another round-trip) in the *vast* majority of cases.
-// To test if `lookup_utf8` works correctly, set this to 1.
-const TEXT_BUFFER_SIZE: usize = 1024;
-
 impl XConnection {
     pub fn select_xinput_events(
         &self,
@@ -60,52 +54,4 @@ impl XConnection {
             .reply()
             .map_err(Into::into)
     }
-
-    fn lookup_utf8_inner(
-        &self,
-        ic: ffi::XIC,
-        key_event: &mut ffi::XKeyEvent,
-        buffer: *mut u8,
-        size: usize,
-    ) -> (ffi::KeySym, ffi::Status, c_int) {
-        let mut keysym: ffi::KeySym = 0;
-        let mut status: ffi::Status = 0;
-        let count = unsafe {
-            (self.xlib.Xutf8LookupString)(
-                ic,
-                key_event,
-                buffer as *mut c_char,
-                size as c_int,
-                &mut keysym,
-                &mut status,
-            )
-        };
-        (keysym, status, count)
-    }
-
-    pub fn lookup_utf8(&self, ic: ffi::XIC, key_event: &mut ffi::XKeyEvent) -> String {
-        // `assume_init` is safe here because the array consists of `MaybeUninit` values,
-        // which do not require initialization.
-        let mut buffer: [MaybeUninit<u8>; TEXT_BUFFER_SIZE] =
-            unsafe { MaybeUninit::uninit().assume_init() };
-        // If the buffer overflows, we'll make a new one on the heap.
-        let mut vec;
-
-        let (_, status, count) =
-            self.lookup_utf8_inner(ic, key_event, buffer.as_mut_ptr() as *mut u8, buffer.len());
-
-        let bytes = if status == ffi::XBufferOverflow {
-            vec = Vec::with_capacity(count as usize);
-            let (_, _, new_count) =
-                self.lookup_utf8_inner(ic, key_event, vec.as_mut_ptr(), vec.capacity());
-            debug_assert_eq!(count, new_count);
-
-            unsafe { vec.set_len(count as usize) };
-            &vec[..count as usize]
-        } else {
-            unsafe { slice::from_raw_parts(buffer.as_ptr() as *const u8, count as usize) }
-        };
-
-        str::from_utf8(bytes).unwrap_or("").to_string()
-    }
 }

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

@@ -7,18 +7,6 @@ pub(crate) struct XSmartPointer<'a, T> {
     pub ptr: *mut T,
 }
 
-impl<'a, T> XSmartPointer<'a, T> {
-    // You're responsible for only passing things to this that should be XFree'd.
-    // Returns None if ptr is null.
-    pub fn new(xconn: &'a XConnection, ptr: *mut T) -> Option<Self> {
-        if !ptr.is_null() {
-            Some(XSmartPointer { xconn, ptr })
-        } else {
-            None
-        }
-    }
-}
-
 impl<'a, T> Deref for XSmartPointer<'a, T> {
     type Target = T;
 

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

@@ -13,13 +13,10 @@ mod randr;
 mod window_property;
 mod wm;
 
-pub use self::{
-    client_msg::*, geometry::*, hint::*, icon::*, input::*, randr::*, window_property::*, wm::*,
-};
+pub use self::{cursor::*, geometry::*, hint::*, input::*, window_property::*, wm::*};
 
 use std::{
     mem::{self, MaybeUninit},
-    ops::BitAnd,
     os::raw::*,
 };
 
@@ -36,13 +33,6 @@ pub fn maybe_change<T: PartialEq>(field: &mut Option<T>, value: T) -> bool {
     }
 }
 
-pub fn has_flag<T>(bitset: T, flag: T) -> bool
-where
-    T: Copy + PartialEq + BitAnd<T, Output = T>,
-{
-    bitset & flag == flag
-}
-
 impl XConnection {
     // This is impoartant, so pay attention!
     // Xlib has an output buffer, and tries to hide the async nature of X from you.

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

@@ -38,7 +38,7 @@ impl XConnection {
     // Retrieve DPI from Xft.dpi property
     pub fn get_xft_dpi(&self) -> Option<f64> {
         self.database()
-            .get_string("Xfi.dpi", "")
+            .get_string("Xft.dpi", "")
             .and_then(|s| f64::from_str(s).ok())
     }
     pub fn get_output_info(

src/platform_impl/linux/x11/window.rs

@@ -4,9 +4,12 @@ use std::{
     mem::replace,
     os::raw::*,
     path::Path,
-    sync::{Arc, Mutex, MutexGuard},
+    sync::{mpsc, Arc, Mutex, MutexGuard},
 };
 
+use crate::cursor::CustomCursor as RootCustomCursor;
+
+use cursor_icon::CursorIcon;
 use x11rb::{
     connection::Connection,
     properties::{WmHints, WmHintsState, WmSizeHints, WmSizeHintsSpecification},
@@ -22,21 +25,27 @@ use x11rb::{
 use crate::{
     dpi::{PhysicalPosition, PhysicalSize, Position, Size},
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
+    event::{Event, InnerSizeWriter, WindowEvent},
     event_loop::AsyncRequestSerial,
     platform_impl::{
-        x11::{atoms::*, MonitorHandle as X11MonitorHandle, WakeSender, X11Error},
+        x11::{
+            atoms::*, xinput_fp1616_to_float, MonitorHandle as X11MonitorHandle, WakeSender,
+            X11Error,
+        },
         Fullscreen, MonitorHandle as PlatformMonitorHandle, OsError, PlatformIcon,
         PlatformSpecificWindowBuilderAttributes, VideoMode as PlatformVideoMode,
     },
     window::{
-        CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
-        WindowAttributes, WindowButtons, WindowLevel,
+        CursorGrabMode, ImePurpose, ResizeDirection, Theme, UserAttentionType, WindowAttributes,
+        WindowButtons, WindowLevel,
     },
 };
 
 use super::{
-    ffi, util, CookieResultExt, EventLoopWindowTarget, ImeRequest, ImeSender, VoidCookie, WindowId,
-    XConnection,
+    ffi,
+    ime::ImeRequest,
+    util::{self, CustomCursor, SelectedCursor},
+    CookieResultExt, EventLoopWindowTarget, VoidCookie, WindowId, XConnection,
 };
 
 #[derive(Debug)]
@@ -122,11 +131,11 @@ pub(crate) struct UnownedWindow {
     root: xproto::Window,               // never changes
     #[allow(dead_code)]
     screen_id: i32, // never changes
-    cursor: Mutex<CursorIcon>,
+    selected_cursor: Mutex<SelectedCursor>,
     cursor_grabbed_mode: Mutex<CursorGrabMode>,
     #[allow(clippy::mutex_atomic)]
     cursor_visible: Mutex<bool>,
-    ime_sender: Mutex<ImeSender>,
+    ime_sender: Mutex<mpsc::Sender<ImeRequest>>,
     pub shared_state: Mutex<SharedState>,
     redraw_sender: WakeSender<WindowId>,
     activation_sender: WakeSender<super::ActivationToken>,
@@ -276,7 +285,8 @@ impl UnownedWindow {
                 | EventMask::KEYMAP_STATE
                 | EventMask::BUTTON_PRESS
                 | EventMask::BUTTON_RELEASE
-                | EventMask::POINTER_MOTION;
+                | EventMask::POINTER_MOTION
+                | EventMask::PROPERTY_CHANGE;
 
             aux = aux.event_mask(event_mask).border_pixel(0);
 
@@ -350,7 +360,7 @@ impl UnownedWindow {
             visual,
             root,
             screen_id,
-            cursor: Default::default(),
+            selected_cursor: Default::default(),
             cursor_grabbed_mode: Mutex::new(CursorGrabMode::None),
             cursor_visible: Mutex::new(true),
             ime_sender: Mutex::new(event_loop.ime_sender.clone()),
@@ -537,11 +547,10 @@ impl UnownedWindow {
                 .ignore_error();
 
             {
-                let result = event_loop
-                    .ime
-                    .borrow_mut()
-                    .create_context(window.xwindow as ffi::Window, false);
-                leap!(result);
+                if let Some(ime) = event_loop.ime.as_ref() {
+                    let result = ime.borrow_mut().create_context(window.xwindow, false, None);
+                    leap!(result);
+                }
             }
 
             // These properties must be set after mapping
@@ -923,6 +932,51 @@ impl UnownedWindow {
         })
     }
 
+    /// Refresh the API for the given monitor.
+    #[inline]
+    pub(super) fn refresh_dpi_for_monitor<T: 'static>(
+        &self,
+        new_monitor: &X11MonitorHandle,
+        maybe_prev_scale_factor: Option<f64>,
+        mut callback: impl FnMut(Event<T>),
+    ) {
+        // Check if the self is on this monitor
+        let monitor = self.shared_state_lock().last_monitor.clone();
+        if monitor.name == new_monitor.name {
+            let (width, height) = self.inner_size_physical();
+            let (new_width, new_height) = self.adjust_for_dpi(
+                // If we couldn't determine the previous scale
+                // factor (e.g., because all monitors were closed
+                // before), just pick whatever the current monitor
+                // has set as a baseline.
+                maybe_prev_scale_factor.unwrap_or(monitor.scale_factor),
+                new_monitor.scale_factor,
+                width,
+                height,
+                &self.shared_state_lock(),
+            );
+
+            let window_id = crate::window::WindowId(self.id());
+            let old_inner_size = PhysicalSize::new(width, height);
+            let inner_size = Arc::new(Mutex::new(PhysicalSize::new(new_width, new_height)));
+            callback(Event::WindowEvent {
+                window_id,
+                event: WindowEvent::ScaleFactorChanged {
+                    scale_factor: new_monitor.scale_factor,
+                    inner_size_writer: InnerSizeWriter::new(Arc::downgrade(&inner_size)),
+                },
+            });
+
+            let new_inner_size = *inner_size.lock().unwrap();
+            drop(inner_size);
+
+            if new_inner_size != old_inner_size {
+                let (new_width, new_height) = new_inner_size.into();
+                self.request_inner_size_physical(new_width, new_height);
+            }
+        }
+    }
+
     fn set_minimized_inner(&self, minimized: bool) -> Result<VoidCookie<'_>, X11Error> {
         let atoms = self.xconn.atoms();
 
@@ -1327,7 +1381,8 @@ impl UnownedWindow {
             self.xwindow as xproto::Window,
             xproto::AtomEnum::WM_NORMAL_HINTS,
         )?
-        .reply()?;
+        .reply()?
+        .unwrap_or_default();
         callback(&mut normal_hints);
         normal_hints
             .set(
@@ -1380,6 +1435,7 @@ impl UnownedWindow {
         )
         .ok()
         .and_then(|cookie| cookie.reply().ok())
+        .flatten()
         .and_then(|hints| hints.size_increment)
         .map(|(width, height)| (width as u32, height as u32).into())
     }
@@ -1483,13 +1539,29 @@ impl UnownedWindow {
 
     #[inline]
     pub fn set_cursor_icon(&self, cursor: CursorIcon) {
-        let old_cursor = replace(&mut *self.cursor.lock().unwrap(), cursor);
+        let old_cursor = replace(
+            &mut *self.selected_cursor.lock().unwrap(),
+            SelectedCursor::Named(cursor),
+        );
+
         #[allow(clippy::mutex_atomic)]
-        if cursor != old_cursor && *self.cursor_visible.lock().unwrap() {
+        if SelectedCursor::Named(cursor) != old_cursor && *self.cursor_visible.lock().unwrap() {
             self.xconn.set_cursor_icon(self.xwindow, Some(cursor));
         }
     }
 
+    #[inline]
+    pub fn set_custom_cursor(&self, cursor: RootCustomCursor) {
+        let new_cursor = unsafe { CustomCursor::new(&self.xconn, &cursor.inner) };
+
+        #[allow(clippy::mutex_atomic)]
+        if *self.cursor_visible.lock().unwrap() {
+            self.xconn.set_custom_cursor(self.xwindow, &new_cursor);
+        }
+
+        *self.selected_cursor.lock().unwrap() = SelectedCursor::Custom(new_cursor);
+    }
+
     #[inline]
     pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
         let mut grabbed_lock = self.cursor_grabbed_mode.lock().unwrap();
@@ -1576,13 +1648,23 @@ impl UnownedWindow {
             return;
         }
         let cursor = if visible {
-            Some(*self.cursor.lock().unwrap())
+            Some((*self.selected_cursor.lock().unwrap()).clone())
         } else {
             None
         };
         *visible_lock = visible;
         drop(visible_lock);
-        self.xconn.set_cursor_icon(self.xwindow, cursor);
+        match cursor {
+            Some(SelectedCursor::Custom(cursor)) => {
+                self.xconn.set_custom_cursor(self.xwindow, &cursor);
+            }
+            Some(SelectedCursor::Named(cursor)) => {
+                self.xconn.set_cursor_icon(self.xwindow, Some(cursor));
+            }
+            None => {
+                self.xconn.set_cursor_icon(self.xwindow, None);
+            }
+        }
     }
 
     #[inline]
@@ -1692,8 +1774,8 @@ impl UnownedWindow {
                         | xproto::EventMask::SUBSTRUCTURE_NOTIFY,
                 ),
                 [
-                    (window.x as u32 + pointer.win_x as u32),
-                    (window.y as u32 + pointer.win_y as u32),
+                    (window.x as u32 + xinput_fp1616_to_float(pointer.win_x) as u32),
+                    (window.y as u32 + xinput_fp1616_to_float(pointer.win_y) as u32),
                     action.try_into().unwrap(),
                     1, // Button 1
                     1,
@@ -1709,11 +1791,11 @@ impl UnownedWindow {
     #[inline]
     pub fn set_ime_cursor_area(&self, spot: Position, _size: Size) {
         let (x, y) = spot.to_physical::<i32>(self.scale_factor()).into();
-        let _ = self.ime_sender.lock().unwrap().send(ImeRequest::Position(
-            self.xwindow as ffi::Window,
-            x,
-            y,
-        ));
+        let _ = self
+            .ime_sender
+            .lock()
+            .unwrap()
+            .send(ImeRequest::Position(self.xwindow, x, y));
     }
 
     #[inline]
@@ -1722,7 +1804,7 @@ impl UnownedWindow {
             .ime_sender
             .lock()
             .unwrap()
-            .send(ImeRequest::Allow(self.xwindow as ffi::Window, allowed));
+            .send(ImeRequest::Allow(self.xwindow, allowed));
     }
 
     #[inline]
@@ -1735,9 +1817,9 @@ impl UnownedWindow {
         let state_type_atom = atoms[CARD32];
         let is_minimized = if let Ok(state) =
             self.xconn
-                .get_property(self.xwindow, state_atom, state_type_atom)
+                .get_property::<u32>(self.xwindow, state_atom, state_type_atom)
         {
-            state.contains(&(ffi::IconicState as c_ulong))
+            state.contains(&super::ICONIC_STATE)
         } else {
             false
         };
@@ -1774,6 +1856,7 @@ impl UnownedWindow {
             WmHints::get(self.xconn.xcb_connection(), self.xwindow as xproto::Window)
                 .ok()
                 .and_then(|cookie| cookie.reply().ok())
+                .flatten()
                 .unwrap_or_default();
 
         wm_hints.urgent = request_type.is_some();

src/platform_impl/linux/x11/xdisplay.rs

@@ -91,6 +91,14 @@ impl XConnection {
             conn.map_err(|e| XNotSupported::XcbConversionError(Arc::new(WrapConnectError(e))))?
         };
 
+        // Make sure Xlib knows XCB is handling events.
+        unsafe {
+            (xlib_xcb.XSetEventQueueOwner)(
+                display,
+                x11_dl::xlib_xcb::XEventQueueOwner::XCBOwnsEventQueue,
+            );
+        }
+
         // Get the default screen.
         let default_screen = unsafe { (xlib.XDefaultScreen)(display) } as usize;
 

src/platform_impl/macos/app_state.rs

@@ -329,7 +329,7 @@ impl Handler {
     ) {
         if let Some(ref mut callback) = *self.callback.lock().unwrap() {
             let new_inner_size = Arc::new(Mutex::new(suggested_size));
-            let event = Event::WindowEvent {
+            let scale_factor_changed_event = Event::WindowEvent {
                 window_id: WindowId(window.id()),
                 event: WindowEvent::ScaleFactorChanged {
                     scale_factor,
@@ -337,13 +337,19 @@ impl Handler {
                 },
             };
 
-            callback.handle_nonuser_event(event);
+            callback.handle_nonuser_event(scale_factor_changed_event);
 
             let physical_size = *new_inner_size.lock().unwrap();
             drop(new_inner_size);
             let logical_size = physical_size.to_logical(scale_factor);
             let size = NSSize::new(logical_size.width, logical_size.height);
             window.setContentSize(size);
+
+            let resized_event = Event::WindowEvent {
+                window_id: WindowId(window.id()),
+                event: WindowEvent::Resized(physical_size),
+            };
+            callback.handle_nonuser_event(resized_event);
         }
     }
 }
@@ -494,9 +500,9 @@ impl AppState {
 
         // Return when in callback due to https://github.com/rust-windowing/winit/issues/1779
         if panic_info.is_panicking()
+            || HANDLER.get_in_callback()
             || !HANDLER.have_callback()
             || !HANDLER.is_running()
-            || HANDLER.get_in_callback()
         {
             return;
         }
@@ -601,9 +607,9 @@ impl AppState {
         // XXX: how does it make sense that `get_in_callback()` can ever return `true` here if we're
         // about to return to the `CFRunLoop` to poll for new events?
         if panic_info.is_panicking()
+            || HANDLER.get_in_callback()
             || !HANDLER.have_callback()
             || !HANDLER.is_running()
-            || HANDLER.get_in_callback()
         {
             return;
         }

src/platform_impl/macos/appkit/application.rs

@@ -80,6 +80,9 @@ extern_methods!(
         #[method(setMainMenu:)]
         pub fn setMainMenu(&self, menu: &NSMenu);
 
+        #[method(setServicesMenu:)]
+        pub fn setServicesMenu(&self, menu: &NSMenu);
+
         #[method_id(effectiveAppearance)]
         pub fn effectiveAppearance(&self) -> Id<NSAppearance>;
 

src/platform_impl/macos/appkit/bitmap_image_rep.rs

@@ -0,0 +1,56 @@
+use std::ffi::c_uchar;
+
+use icrate::Foundation::{NSInteger, NSObject, NSString};
+use objc2::rc::Id;
+use objc2::runtime::Bool;
+use objc2::{extern_class, extern_methods, msg_send, msg_send_id, mutability, ClassType};
+
+extern_class!(
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub struct NSImageRep;
+
+    unsafe impl ClassType for NSImageRep {
+        type Super = NSObject;
+        type Mutability = mutability::InteriorMutable;
+    }
+);
+
+extern "C" {
+    static NSDeviceRGBColorSpace: &'static NSString;
+}
+
+extern_class!(
+    // <https://developer.apple.com/documentation/appkit/nsbitmapimagerep?language=objc>
+    #[derive(Debug, PartialEq, Eq, Hash)]
+    pub(crate) struct NSBitmapImageRep;
+
+    unsafe impl ClassType for NSBitmapImageRep {
+        type Super = NSImageRep;
+        type Mutability = mutability::InteriorMutable;
+    }
+);
+
+extern_methods!(
+    unsafe impl NSBitmapImageRep {
+        pub fn init_rgba(width: NSInteger, height: NSInteger) -> Id<Self> {
+            unsafe {
+                msg_send_id![Self::alloc(),
+                    initWithBitmapDataPlanes: std::ptr::null_mut::<*mut c_uchar>(),
+                    pixelsWide: width,
+                    pixelsHigh: height,
+                    bitsPerSample: 8 as NSInteger,
+                    samplesPerPixel: 4 as NSInteger,
+                    hasAlpha: Bool::new(true),
+                    isPlanar: Bool::new(false),
+                    colorSpaceName: NSDeviceRGBColorSpace,
+                    bytesPerRow: width * 4,
+                    bitsPerPixel: 32 as NSInteger,
+                ]
+            }
+        }
+
+        pub fn bitmap_data(&self) -> *mut u8 {
+            unsafe { msg_send![self, bitmapData] }
+        }
+    }
+);

src/platform_impl/macos/appkit/cursor.rs

@@ -2,13 +2,14 @@ use once_cell::sync::Lazy;
 
 use icrate::ns_string;
 use icrate::Foundation::{
-    NSData, NSDictionary, NSNumber, NSObject, NSObjectProtocol, NSPoint, NSString,
+    NSData, NSDictionary, NSNumber, NSObject, NSObjectProtocol, NSPoint, NSSize, NSString,
 };
 use objc2::rc::{DefaultId, Id};
 use objc2::runtime::Sel;
 use objc2::{extern_class, extern_methods, msg_send_id, mutability, sel, ClassType};
 
-use super::NSImage;
+use super::{NSBitmapImageRep, NSImage};
+use crate::cursor::CursorImage;
 use crate::window::CursorIcon;
 
 extern_class!(
@@ -232,6 +233,23 @@ impl NSCursor {
             _ => Default::default(),
         }
     }
+
+    pub fn from_image(cursor: &CursorImage) -> Id<Self> {
+        let width = cursor.width;
+        let height = cursor.height;
+
+        let bitmap = NSBitmapImageRep::init_rgba(width as isize, height as isize);
+        let bitmap_data =
+            unsafe { std::slice::from_raw_parts_mut(bitmap.bitmap_data(), cursor.rgba.len()) };
+        bitmap_data.copy_from_slice(&cursor.rgba);
+
+        let image = NSImage::init_with_size(NSSize::new(width.into(), height.into()));
+        image.add_representation(&bitmap);
+
+        let hotspot = NSPoint::new(cursor.hotspot_x as f64, cursor.hotspot_y as f64);
+
+        NSCursor::new(&image, hotspot)
+    }
 }
 
 impl DefaultId for NSCursor {

src/platform_impl/macos/appkit/image.rs

@@ -1,6 +1,8 @@
-use icrate::Foundation::{NSData, NSObject, NSString};
+use icrate::Foundation::{NSData, NSObject, NSSize, NSString};
 use objc2::rc::Id;
-use objc2::{extern_class, extern_methods, msg_send_id, mutability, ClassType};
+use objc2::{extern_class, extern_methods, msg_send, msg_send_id, mutability, ClassType};
+
+use super::NSBitmapImageRep;
 
 extern_class!(
     // TODO: Can this be mutable?
@@ -32,5 +34,13 @@ extern_methods!(
         pub fn new_with_data(data: &NSData) -> Id<Self> {
             unsafe { msg_send_id![Self::alloc(), initWithData: data] }
         }
+
+        pub fn init_with_size(size: NSSize) -> Id<Self> {
+            unsafe { msg_send_id![Self::alloc(), initWithSize: size] }
+        }
+
+        pub fn add_representation(&self, representation: &NSBitmapImageRep) {
+            unsafe { msg_send![self, addRepresentation: representation] }
+        }
     }
 );

src/platform_impl/macos/appkit/menu_item.rs

@@ -20,7 +20,11 @@ extern_methods!(
         #[method_id(new)]
         pub fn new() -> Id<Self>;
 
-        pub fn newWithTitle(title: &NSString, action: Sel, key_equivalent: &NSString) -> Id<Self> {
+        pub fn newWithTitle(
+            title: &NSString,
+            action: Option<Sel>,
+            key_equivalent: &NSString,
+        ) -> Id<Self> {
             unsafe {
                 msg_send_id![
                     Self::alloc(),

src/platform_impl/macos/appkit/mod.rs

@@ -13,6 +13,7 @@
 
 mod appearance;
 mod application;
+mod bitmap_image_rep;
 mod button;
 mod color;
 mod control;
@@ -36,6 +37,7 @@ pub(crate) use self::application::{
     NSApp, NSApplication, NSApplicationActivationPolicy, NSApplicationPresentationOptions,
     NSRequestUserAttentionType,
 };
+pub(crate) use self::bitmap_image_rep::NSBitmapImageRep;
 pub(crate) use self::button::NSButton;
 pub(crate) use self::color::NSColor;
 pub(crate) use self::control::NSControl;

src/platform_impl/macos/appkit/window.rs

@@ -36,6 +36,9 @@ extern_methods!(
         #[method(frame)]
         pub(crate) fn frame(&self) -> NSRect;
 
+        #[method(windowNumber)]
+        pub(crate) fn windowNumber(&self) -> NSInteger;
+
         #[method(backingScaleFactor)]
         pub(crate) fn backingScaleFactor(&self) -> CGFloat;
 

src/platform_impl/macos/event.rs

@@ -88,7 +88,9 @@ pub fn get_modifierless_char(scancode: u16) -> Key {
         return Key::Unidentified(NativeKey::MacOS(scancode));
     }
     if result_len == 0 {
-        log::error!("`UCKeyTranslate` was succesful but gave a string of 0 length.");
+        // This is fine - not all keys have text representation.
+        // For instance, users that have mapped the `Fn` key to toggle
+        // keyboard layouts will hit this code path.
         return Key::Unidentified(NativeKey::MacOS(scancode));
     }
     let chars = String::from_utf16_lossy(&string[0..result_len as usize]);
@@ -156,13 +158,11 @@ pub(crate) fn create_key_event(
             // Also not checking if this is a release event because then this issue would
             // still affect the key release.
             Some(text) if !has_ctrl => Key::Character(text.clone()),
-            _ => {
-                let modifierless_chars = match key_without_modifiers.as_ref() {
-                    Key::Character(ch) => ch,
-                    _ => "",
-                };
-                get_logical_key_char(ns_event, modifierless_chars)
-            }
+            _ => match key_without_modifiers.as_ref() {
+                Key::Character(ch) => get_logical_key_char(ns_event, ch),
+                // Don't try to get text for events which likely don't have it.
+                _ => key_without_modifiers.clone(),
+            },
         };
 
         (logical_key, key_without_modifiers)

src/platform_impl/macos/ffi.rs

@@ -11,6 +11,7 @@ use core_graphics::{
     base::CGError,
     display::{CGDirectDisplayID, CGDisplayConfigRef},
 };
+use objc2::{ffi::NSInteger, runtime::AnyObject};
 
 pub type CGDisplayFadeInterval = f32;
 pub type CGDisplayReservationInterval = f32;
@@ -113,6 +114,14 @@ extern "C" {
     pub fn CGDisplayModeCopyPixelEncoding(mode: CGDisplayModeRef) -> CFStringRef;
     pub fn CGDisplayModeRetain(mode: CGDisplayModeRef);
     pub fn CGDisplayModeRelease(mode: CGDisplayModeRef);
+
+    // Wildly used private APIs; Apple uses them for their Terminal.app.
+    pub fn CGSMainConnectionID() -> *mut AnyObject;
+    pub fn CGSSetWindowBackgroundBlurRadius(
+        connection_id: *mut AnyObject,
+        window_id: NSInteger,
+        radius: i64,
+    ) -> i32;
 }
 
 mod core_video {

src/platform_impl/macos/menu.rs

@@ -21,7 +21,16 @@ pub fn initialize() {
 
     // About menu item
     let about_item_title = ns_string!("About ").stringByAppendingString(&process_name);
-    let about_item = menu_item(&about_item_title, sel!(orderFrontStandardAboutPanel:), None);
+    let about_item = menu_item(
+        &about_item_title,
+        Some(sel!(orderFrontStandardAboutPanel:)),
+        None,
+    );
+
+    // Services menu item
+    let services_menu = NSMenu::new();
+    let services_item = menu_item(ns_string!("Services"), None, None);
+    services_item.setSubmenu(&services_menu);
 
     // Seperator menu item
     let sep_first = NSMenuItem::separatorItem();
@@ -30,7 +39,7 @@ pub fn initialize() {
     let hide_item_title = ns_string!("Hide ").stringByAppendingString(&process_name);
     let hide_item = menu_item(
         &hide_item_title,
-        sel!(hide:),
+        Some(sel!(hide:)),
         Some(KeyEquivalent {
             key: ns_string!("h"),
             masks: None,
@@ -41,7 +50,7 @@ pub fn initialize() {
     let hide_others_item_title = ns_string!("Hide Others");
     let hide_others_item = menu_item(
         hide_others_item_title,
-        sel!(hideOtherApplications:),
+        Some(sel!(hideOtherApplications:)),
         Some(KeyEquivalent {
             key: ns_string!("h"),
             masks: Some(
@@ -52,7 +61,11 @@ pub fn initialize() {
 
     // Show applications menu item
     let show_all_item_title = ns_string!("Show All");
-    let show_all_item = menu_item(show_all_item_title, sel!(unhideAllApplications:), None);
+    let show_all_item = menu_item(
+        show_all_item_title,
+        Some(sel!(unhideAllApplications:)),
+        None,
+    );
 
     // Seperator menu item
     let sep = NSMenuItem::separatorItem();
@@ -61,7 +74,7 @@ pub fn initialize() {
     let quit_item_title = ns_string!("Quit ").stringByAppendingString(&process_name);
     let quit_item = menu_item(
         &quit_item_title,
-        sel!(terminate:),
+        Some(sel!(terminate:)),
         Some(KeyEquivalent {
             key: ns_string!("q"),
             masks: None,
@@ -70,6 +83,7 @@ pub fn initialize() {
 
     app_menu.addItem(&about_item);
     app_menu.addItem(&sep_first);
+    app_menu.addItem(&services_item);
     app_menu.addItem(&hide_item);
     app_menu.addItem(&hide_others_item);
     app_menu.addItem(&show_all_item);
@@ -78,12 +92,13 @@ pub fn initialize() {
     app_menu_item.setSubmenu(&app_menu);
 
     let app = NSApp();
+    app.setServicesMenu(&services_menu);
     app.setMainMenu(&menubar);
 }
 
 fn menu_item(
     title: &NSString,
-    selector: Sel,
+    selector: Option<Sel>,
     key_equivalent: Option<KeyEquivalent<'_>>,
 ) -> Id<NSMenuItem> {
     let (key, masks) = match key_equivalent {

src/platform_impl/macos/mod.rs

@@ -28,6 +28,7 @@ pub(crate) use self::{
 use crate::event::DeviceId as RootDeviceId;
 
 pub(crate) use self::window::Window;
+pub(crate) use crate::cursor::CursorImage as PlatformCustomCursor;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
 

src/platform_impl/macos/monitor.rs

@@ -7,7 +7,9 @@ use core_foundation::{
     base::{CFRelease, TCFType},
     string::CFString,
 };
-use core_graphics::display::{CGDirectDisplayID, CGDisplay, CGDisplayBounds};
+use core_graphics::display::{
+    CGDirectDisplayID, CGDisplay, CGDisplayBounds, CGDisplayCopyDisplayMode,
+};
 use objc2::rc::Id;
 
 use super::appkit::NSScreen;
@@ -216,6 +218,12 @@ impl MonitorHandle {
 
     pub fn refresh_rate_millihertz(&self) -> Option<u32> {
         unsafe {
+            let current_display_mode = NativeDisplayMode(CGDisplayCopyDisplayMode(self.0) as _);
+            let refresh_rate = ffi::CGDisplayModeGetRefreshRate(current_display_mode.0);
+            if refresh_rate > 0.0 {
+                return Some((refresh_rate * 1000.0).round() as u32);
+            }
+
             let mut display_link = std::ptr::null_mut();
             if ffi::CVDisplayLinkCreateWithCGDisplay(self.0, &mut display_link)
                 != ffi::kCVReturnSuccess

src/platform_impl/macos/view.rs

@@ -74,8 +74,8 @@ enum ImeState {
 bitflags! {
     #[derive(Debug, Clone, Copy, PartialEq)]
     struct ModLocationMask: u8 {
-        const LEFT = 1;
-        const RIGHT = 2;
+        const LEFT     = 0b0001;
+        const RIGHT    = 0b0010;
     }
 }
 impl ModLocationMask {
@@ -88,13 +88,13 @@ impl ModLocationMask {
     }
 }
 
-fn key_to_modifier(key: &Key) -> ModifiersState {
+fn key_to_modifier(key: &Key) -> Option<ModifiersState> {
     match key {
-        Key::Named(NamedKey::Alt) => ModifiersState::ALT,
-        Key::Named(NamedKey::Control) => ModifiersState::CONTROL,
-        Key::Named(NamedKey::Super) => ModifiersState::SUPER,
-        Key::Named(NamedKey::Shift) => ModifiersState::SHIFT,
-        _ => unreachable!(),
+        Key::Named(NamedKey::Alt) => Some(ModifiersState::ALT),
+        Key::Named(NamedKey::Control) => Some(ModifiersState::CONTROL),
+        Key::Named(NamedKey::Super) => Some(ModifiersState::SUPER),
+        Key::Named(NamedKey::Shift) => Some(ModifiersState::SHIFT),
+        _ => None,
     }
 }
 
@@ -924,91 +924,96 @@ impl WinitView {
         // event, thus we can't generate regular presses based on that. The `ModifiersChanged`
         // later will work though, since the flags are attached to the event and contain valid
         // information.
-        if is_flags_changed_event && ns_event.key_code() != 0 {
-            let scancode = ns_event.key_code();
-            let physical_key = PhysicalKey::from_scancode(scancode as u32);
+        'send_event: {
+            if is_flags_changed_event && ns_event.key_code() != 0 {
+                let scancode = ns_event.key_code();
+                let physical_key = PhysicalKey::from_scancode(scancode as u32);
 
-            // We'll correct the `is_press` later.
-            let mut event = create_key_event(ns_event, false, false, Some(physical_key));
+                // We'll correct the `is_press` later.
+                let mut event = create_key_event(ns_event, false, false, Some(physical_key));
 
-            let key = code_to_key(physical_key, scancode);
-            let event_modifier = key_to_modifier(&key);
-            event.physical_key = physical_key;
-            event.logical_key = key.clone();
-            event.location = code_to_location(physical_key);
-            let location_mask = ModLocationMask::from_location(event.location);
+                let key = code_to_key(physical_key, scancode);
+                // Ignore processing of unkown modifiers because we can't determine whether
+                // it was pressed or release reliably.
+                let Some(event_modifier) = key_to_modifier(&key) else {
+                    break 'send_event;
+                };
+                event.physical_key = physical_key;
+                event.logical_key = key.clone();
+                event.location = code_to_location(physical_key);
+                let location_mask = ModLocationMask::from_location(event.location);
 
-            let mut phys_mod_state = self.state.phys_modifiers.borrow_mut();
-            let phys_mod = phys_mod_state
-                .entry(key)
-                .or_insert(ModLocationMask::empty());
+                let mut phys_mod_state = self.state.phys_modifiers.borrow_mut();
+                let phys_mod = phys_mod_state
+                    .entry(key)
+                    .or_insert(ModLocationMask::empty());
 
-            let is_active = current_modifiers.state().contains(event_modifier);
-            let mut events = VecDeque::with_capacity(2);
+                let is_active = current_modifiers.state().contains(event_modifier);
+                let mut events = VecDeque::with_capacity(2);
 
-            // There is no API for getting whether the button was pressed or released
-            // during this event. For this reason we have to do a bit of magic below
-            // to come up with a good guess whether this key was pressed or released.
-            // (This is not trivial because there are multiple buttons that may affect
-            // the same modifier)
-            if !is_active {
-                event.state = Released;
-                if phys_mod.contains(ModLocationMask::LEFT) {
-                    let mut event = event.clone();
-                    event.location = KeyLocation::Left;
-                    event.physical_key = get_left_modifier_code(&event.logical_key).into();
-                    events.push_back(WindowEvent::KeyboardInput {
-                        device_id: DEVICE_ID,
-                        event,
-                        is_synthetic: false,
-                    });
-                }
-                if phys_mod.contains(ModLocationMask::RIGHT) {
-                    event.location = KeyLocation::Right;
-                    event.physical_key = get_right_modifier_code(&event.logical_key).into();
-                    events.push_back(WindowEvent::KeyboardInput {
-                        device_id: DEVICE_ID,
-                        event,
-                        is_synthetic: false,
-                    });
-                }
-                *phys_mod = ModLocationMask::empty();
-            } else {
-                // is_active
-                if *phys_mod == location_mask {
-                    // Here we hit a contradiction:
-                    // The modifier state was "changed" to active,
-                    // yet the only pressed modifier key was the one that we
-                    // just got a change event for.
-                    // This seemingly means that the only pressed modifier is now released,
-                    // but at the same time the modifier became active.
-                    //
-                    // But this scenario is possible if we released modifiers
-                    // while the application was not in focus. (Because we don't
-                    // get informed of modifier key events while the application
-                    // is not focused)
-
-                    // In this case we prioritize the information
-                    // about the current modifier state which means
-                    // that the button was pressed.
-                    event.state = Pressed;
+                // There is no API for getting whether the button was pressed or released
+                // during this event. For this reason we have to do a bit of magic below
+                // to come up with a good guess whether this key was pressed or released.
+                // (This is not trivial because there are multiple buttons that may affect
+                // the same modifier)
+                if !is_active {
+                    event.state = Released;
+                    if phys_mod.contains(ModLocationMask::LEFT) {
+                        let mut event = event.clone();
+                        event.location = KeyLocation::Left;
+                        event.physical_key = get_left_modifier_code(&event.logical_key).into();
+                        events.push_back(WindowEvent::KeyboardInput {
+                            device_id: DEVICE_ID,
+                            event,
+                            is_synthetic: false,
+                        });
+                    }
+                    if phys_mod.contains(ModLocationMask::RIGHT) {
+                        event.location = KeyLocation::Right;
+                        event.physical_key = get_right_modifier_code(&event.logical_key).into();
+                        events.push_back(WindowEvent::KeyboardInput {
+                            device_id: DEVICE_ID,
+                            event,
+                            is_synthetic: false,
+                        });
+                    }
+                    *phys_mod = ModLocationMask::empty();
                 } else {
-                    phys_mod.toggle(location_mask);
-                    let is_pressed = phys_mod.contains(location_mask);
-                    event.state = if is_pressed { Pressed } else { Released };
+                    if *phys_mod == location_mask {
+                        // Here we hit a contradiction:
+                        // The modifier state was "changed" to active,
+                        // yet the only pressed modifier key was the one that we
+                        // just got a change event for.
+                        // This seemingly means that the only pressed modifier is now released,
+                        // but at the same time the modifier became active.
+                        //
+                        // But this scenario is possible if we released modifiers
+                        // while the application was not in focus. (Because we don't
+                        // get informed of modifier key events while the application
+                        // is not focused)
+
+                        // In this case we prioritize the information
+                        // about the current modifier state which means
+                        // that the button was pressed.
+                        event.state = Pressed;
+                    } else {
+                        phys_mod.toggle(location_mask);
+                        let is_pressed = phys_mod.contains(location_mask);
+                        event.state = if is_pressed { Pressed } else { Released };
+                    }
+
+                    events.push_back(WindowEvent::KeyboardInput {
+                        device_id: DEVICE_ID,
+                        event,
+                        is_synthetic: false,
+                    });
                 }
 
-                events.push_back(WindowEvent::KeyboardInput {
-                    device_id: DEVICE_ID,
-                    event,
-                    is_synthetic: false,
-                });
-            }
+                drop(phys_mod_state);
 
-            drop(phys_mod_state);
-
-            for event in events {
-                self.queue_event(event);
+                for event in events {
+                    self.queue_event(event);
+                }
             }
         }
 

src/platform_impl/macos/window.rs

@@ -7,6 +7,7 @@ use std::os::raw::c_void;
 use std::ptr::NonNull;
 use std::sync::{Mutex, MutexGuard};
 
+use crate::cursor::CustomCursor;
 use crate::{
     dpi::{
         LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize, Position, Size, Size::Logical,
@@ -46,6 +47,8 @@ use super::appkit::{
     NSView, NSWindow, NSWindowButton, NSWindowLevel, NSWindowSharingType, NSWindowStyleMask,
     NSWindowTabbingMode, NSWindowTitleVisibility,
 };
+use super::ffi::CGSMainConnectionID;
+use super::ffi::CGSSetWindowBackgroundBlurRadius;
 
 pub(crate) struct Window {
     window: MainThreadBound<Id<WinitWindow>>,
@@ -494,6 +497,10 @@ impl WinitWindow {
             this.setBackgroundColor(&NSColor::clear());
         }
 
+        if attrs.blur {
+            this.set_blur(attrs.blur);
+        }
+
         if let Some(dim) = attrs.min_inner_size {
             this.set_min_inner_size(Some(dim));
         }
@@ -582,7 +589,15 @@ impl WinitWindow {
         self.setOpaque(!transparent)
     }
 
-    pub fn set_blur(&self, _blur: bool) {}
+    pub fn set_blur(&self, blur: bool) {
+        // NOTE: in general we want to specify the blur radius, but the choice of 80
+        // should be a reasonable default.
+        let radius = if blur { 80 } else { 0 };
+        let window_number = self.windowNumber();
+        unsafe {
+            CGSSetWindowBackgroundBlurRadius(CGSMainConnectionID(), window_number, radius);
+        }
+    }
 
     pub fn set_visible(&self, visible: bool) {
         match visible {
@@ -820,6 +835,13 @@ impl WinitWindow {
         self.invalidateCursorRectsForView(&view);
     }
 
+    #[inline]
+    pub fn set_custom_cursor(&self, cursor: CustomCursor) {
+        let view = self.view();
+        view.set_cursor_icon(NSCursor::from_image(&cursor.inner));
+        self.invalidateCursorRectsForView(&view);
+    }
+
     #[inline]
     pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
         let associate_mouse_cursor = match mode {

src/platform_impl/orbital/mod.rs

@@ -193,6 +193,7 @@ impl Display for OsError {
     }
 }
 
+pub(crate) use crate::cursor::NoCustomCursor as PlatformCustomCursor;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]

src/platform_impl/orbital/window.rs

@@ -4,6 +4,7 @@ use std::{
 };
 
 use crate::{
+    cursor::CustomCursor,
     dpi::{PhysicalPosition, PhysicalSize, Position, Size},
     error,
     platform_impl::Fullscreen,
@@ -352,6 +353,8 @@ impl Window {
     #[inline]
     pub fn set_cursor_icon(&self, _: window::CursorIcon) {}
 
+    pub fn set_custom_cursor(&self, _: CustomCursor) {}
+
     #[inline]
     pub fn set_cursor_position(&self, _: Position) -> Result<(), error::ExternalError> {
         Err(error::ExternalError::NotSupported(

src/platform_impl/web/cursor.rs

@@ -0,0 +1,364 @@
+use std::{
+    cell::{Cell, RefCell},
+    ops::Deref,
+    rc::{Rc, Weak},
+};
+
+use crate::cursor::{BadImage, CursorImage};
+use cursor_icon::CursorIcon;
+use wasm_bindgen::{closure::Closure, JsCast};
+use wasm_bindgen_futures::JsFuture;
+use web_sys::{
+    Blob, Document, HtmlCanvasElement, ImageBitmap, ImageBitmapOptions,
+    ImageBitmapRenderingContext, ImageData, PremultiplyAlpha, Url, Window,
+};
+
+use super::backend::Style;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum WebCustomCursor {
+    Image(CursorImage),
+    Url {
+        url: String,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    },
+}
+
+impl WebCustomCursor {
+    pub fn from_rgba(
+        rgba: Vec<u8>,
+        width: u16,
+        height: u16,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    ) -> Result<Self, BadImage> {
+        Ok(Self::Image(CursorImage::from_rgba(
+            rgba, width, height, hotspot_x, hotspot_y,
+        )?))
+    }
+
+    pub(super) fn build(
+        &self,
+        window: &Window,
+        document: &Document,
+        style: &Style,
+        previous: SelectedCursor,
+        cursor_visible: Rc<Cell<bool>>,
+    ) -> SelectedCursor {
+        let previous = previous.into();
+
+        match self {
+            WebCustomCursor::Image(image) => SelectedCursor::Image(CursorImageState::from_image(
+                window,
+                document.clone(),
+                style.clone(),
+                image,
+                previous,
+                cursor_visible,
+            )),
+            WebCustomCursor::Url {
+                url,
+                hotspot_x,
+                hotspot_y,
+            } => {
+                let value = previous.style_with_url(url, *hotspot_x, *hotspot_y);
+
+                if cursor_visible.get() {
+                    style.set("cursor", &value);
+                }
+
+                SelectedCursor::Url {
+                    style: value,
+                    previous,
+                    url: url.clone(),
+                    hotspot_x: *hotspot_x,
+                    hotspot_y: *hotspot_y,
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum SelectedCursor {
+    Named(CursorIcon),
+    Url {
+        style: String,
+        previous: Previous,
+        url: String,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    },
+    Image(Rc<RefCell<Option<CursorImageState>>>),
+}
+
+impl Default for SelectedCursor {
+    fn default() -> Self {
+        Self::Named(Default::default())
+    }
+}
+
+impl SelectedCursor {
+    pub fn set_style(&self, style: &Style) {
+        let value = match self {
+            SelectedCursor::Named(icon) => icon.name(),
+            SelectedCursor::Url { style, .. } => style,
+            SelectedCursor::Image(image) => {
+                let image = image.borrow();
+                let value = match image.deref().as_ref().unwrap() {
+                    CursorImageState::Loading { previous, .. } => previous.style(),
+                    CursorImageState::Failed(previous) => previous.style(),
+                    CursorImageState::Ready { style, .. } => style,
+                };
+                return style.set("cursor", value);
+            }
+        };
+
+        style.set("cursor", value);
+    }
+}
+
+#[derive(Debug)]
+pub enum Previous {
+    Named(CursorIcon),
+    Url {
+        style: String,
+        url: String,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    },
+    Image {
+        style: String,
+        image: WebCursorImage,
+    },
+}
+
+impl Previous {
+    fn style(&self) -> &str {
+        match self {
+            Previous::Named(icon) => icon.name(),
+            Previous::Url { style: url, .. } => url,
+            Previous::Image { style, .. } => style,
+        }
+    }
+
+    fn style_with_url(&self, new_url: &str, new_hotspot_x: u16, new_hotspot_y: u16) -> String {
+        match self {
+            Previous::Named(icon) => format!("url({new_url}) {new_hotspot_x} {new_hotspot_y}, {}", icon.name()),
+            Previous::Url {
+                url,
+                hotspot_x,
+                hotspot_y,
+                ..
+            }
+            | Previous::Image {
+                image:
+                    WebCursorImage {
+                        data_url: url,
+                        hotspot_x,
+                        hotspot_y,
+                        ..
+                    },
+                ..
+            } => format!(
+                "url({new_url}) {new_hotspot_x} {new_hotspot_y}, url({url}) {hotspot_x} {hotspot_y}, auto",
+            ),
+        }
+    }
+}
+
+impl From<SelectedCursor> for Previous {
+    fn from(value: SelectedCursor) -> Self {
+        match value {
+            SelectedCursor::Named(icon) => Self::Named(icon),
+            SelectedCursor::Url {
+                style,
+                url,
+                hotspot_x,
+                hotspot_y,
+                ..
+            } => Self::Url {
+                style,
+                url,
+                hotspot_x,
+                hotspot_y,
+            },
+            SelectedCursor::Image(image) => {
+                match Rc::try_unwrap(image).unwrap().into_inner().unwrap() {
+                    CursorImageState::Loading { previous, .. } => previous,
+                    CursorImageState::Failed(previous) => previous,
+                    CursorImageState::Ready {
+                        style,
+                        image: current,
+                        ..
+                    } => Self::Image {
+                        style,
+                        image: current,
+                    },
+                }
+            }
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum CursorImageState {
+    Loading {
+        style: Style,
+        cursor_visible: Rc<Cell<bool>>,
+        previous: Previous,
+        hotspot_x: u16,
+        hotspot_y: u16,
+    },
+    Failed(Previous),
+    Ready {
+        style: String,
+        image: WebCursorImage,
+        previous: Previous,
+    },
+}
+
+impl CursorImageState {
+    fn from_image(
+        window: &Window,
+        document: Document,
+        style: Style,
+        image: &CursorImage,
+        previous: Previous,
+        cursor_visible: Rc<Cell<bool>>,
+    ) -> Rc<RefCell<Option<Self>>> {
+        // Can't create array directly when backed by SharedArrayBuffer.
+        // Adapted from https://github.com/rust-windowing/softbuffer/blob/ab7688e2ed2e2eca51b3c4e1863a5bd7fe85800e/src/web.rs#L196-L223
+        #[cfg(target_feature = "atomics")]
+        let image_data = {
+            use js_sys::{Uint8Array, Uint8ClampedArray};
+            use wasm_bindgen::prelude::wasm_bindgen;
+            use wasm_bindgen::JsValue;
+
+            #[wasm_bindgen]
+            extern "C" {
+                #[wasm_bindgen(js_namespace = ImageData)]
+                type ImageDataExt;
+                #[wasm_bindgen(catch, constructor, js_class = ImageData)]
+                fn new(array: Uint8ClampedArray, sw: u32) -> Result<ImageDataExt, JsValue>;
+            }
+
+            let array = Uint8Array::new_with_length(image.rgba.len() as u32);
+            array.copy_from(&image.rgba);
+            let array = Uint8ClampedArray::new(&array);
+            ImageDataExt::new(array, image.width as u32)
+                .map(JsValue::from)
+                .map(ImageData::unchecked_from_js)
+                .unwrap()
+        };
+        #[cfg(not(target_feature = "atomics"))]
+        let image_data = ImageData::new_with_u8_clamped_array(
+            wasm_bindgen::Clamped(&image.rgba),
+            image.width as u32,
+        )
+        .unwrap();
+
+        let mut options = ImageBitmapOptions::new();
+        options.premultiply_alpha(PremultiplyAlpha::None);
+        let bitmap = JsFuture::from(
+            window
+                .create_image_bitmap_with_image_data_and_image_bitmap_options(&image_data, &options)
+                .unwrap(),
+        );
+
+        let state = Rc::new(RefCell::new(Some(Self::Loading {
+            style,
+            cursor_visible,
+            previous,
+            hotspot_x: image.hotspot_x,
+            hotspot_y: image.hotspot_y,
+        })));
+
+        wasm_bindgen_futures::spawn_local({
+            let weak = Rc::downgrade(&state);
+            let CursorImage { width, height, .. } = *image;
+            async move {
+                if weak.strong_count() == 0 {
+                    return;
+                }
+
+                let bitmap: ImageBitmap = bitmap.await.unwrap().unchecked_into();
+
+                if weak.strong_count() == 0 {
+                    return;
+                }
+
+                let canvas: HtmlCanvasElement =
+                    document.create_element("canvas").unwrap().unchecked_into();
+                #[allow(clippy::disallowed_methods)]
+                canvas.set_width(width as u32);
+                #[allow(clippy::disallowed_methods)]
+                canvas.set_height(height as u32);
+
+                let context: ImageBitmapRenderingContext = canvas
+                    .get_context("bitmaprenderer")
+                    .unwrap()
+                    .unwrap()
+                    .unchecked_into();
+                context.transfer_from_image_bitmap(&bitmap);
+
+                thread_local! {
+                    static CURRENT_STATE: RefCell<Option<Weak<RefCell<Option<CursorImageState>>>>> = RefCell::new(None);
+                    // `HTMLCanvasElement.toBlob()` can't be interrupted. So we have to use a
+                    // `Closure` that doesn't need to be garbage-collected.
+                    static CALLBACK: Closure<dyn Fn(Option<Blob>)> = Closure::new(|blob| {
+                        CURRENT_STATE.with(|weak| {
+                            let Some(state) = weak.borrow_mut().take().and_then(|weak| weak.upgrade()) else {
+                                return;
+                            };
+                            let mut state = state.borrow_mut();
+                            // Extract old state.
+                            let CursorImageState::Loading { style, cursor_visible, previous, hotspot_x, hotspot_y, .. } = state.take().unwrap() else {
+                                unreachable!("found invalid state")
+                            };
+
+                            let Some(blob) = blob else {
+                                *state = Some(CursorImageState::Failed(previous));
+                                return;
+                            };
+                            let data_url = Url::create_object_url_with_blob(&blob).unwrap();
+
+                            let value = previous.style_with_url(&data_url, hotspot_x, hotspot_y);
+
+                            if cursor_visible.get() {
+                                style.set("cursor", &value);
+                            }
+
+                            *state = Some(
+                                CursorImageState::Ready {
+                                    style: value,
+                                    image: WebCursorImage{ data_url, hotspot_x, hotspot_y },
+                                    previous,
+                                });
+                        });
+                    });
+                }
+
+                CURRENT_STATE.with(|state| *state.borrow_mut() = Some(weak));
+                CALLBACK
+                    .with(|callback| canvas.to_blob(callback.as_ref().unchecked_ref()).unwrap());
+            }
+        });
+
+        state
+    }
+}
+
+#[derive(Debug)]
+pub struct WebCursorImage {
+    data_url: String,
+    hotspot_x: u16,
+    hotspot_y: u16,
+}
+
+impl Drop for WebCursorImage {
+    fn drop(&mut self) {
+        Url::revoke_object_url(&self.data_url).unwrap();
+    }
+}

src/platform_impl/web/event_loop/runner.rs

@@ -67,7 +67,6 @@ pub struct Execution {
     on_key_press: OnEventHandle<KeyboardEvent>,
     on_key_release: OnEventHandle<KeyboardEvent>,
     on_visibility_change: OnEventHandle<web_sys::Event>,
-    on_touch_end: OnEventHandle<web_sys::Event>,
 }
 
 enum RunnerEnum {
@@ -181,7 +180,6 @@ impl Shared {
                 on_key_press: RefCell::new(None),
                 on_key_release: RefCell::new(None),
                 on_visibility_change: RefCell::new(None),
-                on_touch_end: RefCell::new(None),
             }
         }))
     }
@@ -342,8 +340,6 @@ impl Shared {
             self.window().clone(),
             "pointerdown",
             Closure::new(move |event: PointerEvent| {
-                runner.transient_activation();
-
                 if !runner.device_events() {
                     return;
                 }
@@ -367,8 +363,6 @@ impl Shared {
             self.window().clone(),
             "pointerup",
             Closure::new(move |event: PointerEvent| {
-                runner.transient_activation();
-
                 if !runner.device_events() {
                     return;
                 }
@@ -392,8 +386,6 @@ impl Shared {
             self.window().clone(),
             "keydown",
             Closure::new(move |event: KeyboardEvent| {
-                runner.transient_activation();
-
                 if !runner.device_events() {
                     return;
                 }
@@ -452,14 +444,6 @@ impl Shared {
                 }
             }),
         ));
-        let runner = self.clone();
-        *self.0.on_touch_end.borrow_mut() = Some(EventListenerHandle::new(
-            self.window().clone(),
-            "touchend",
-            Closure::new(move |_| {
-                runner.transient_activation();
-            }),
-        ));
     }
 
     // Generate a strictly increasing ID
@@ -788,18 +772,6 @@ impl Shared {
         }
     }
 
-    fn transient_activation(&self) {
-        self.0
-            .all_canvases
-            .borrow()
-            .iter()
-            .for_each(|(_, canvas, _)| {
-                if let Some(canvas) = canvas.upgrade() {
-                    canvas.borrow().transient_activation();
-                }
-            });
-    }
-
     pub fn event_loop_recreation(&self, allow: bool) {
         self.0.event_loop_recreation.set(allow)
     }

src/platform_impl/web/event_loop/window_target.rs

@@ -647,8 +647,6 @@ impl<T> EventLoopWindowTarget<T> {
 
         let runner = self.runner.clone();
         canvas.on_animation_frame(move || runner.request_redraw(RootWindowId(id)));
-
-        canvas.on_touch_end();
     }
 
     pub fn available_monitors(&self) -> VecDequeIter<MonitorHandle> {

src/platform_impl/web/mod.rs

@@ -18,6 +18,7 @@
 // compliant way.
 
 mod r#async;
+mod cursor;
 mod device;
 mod error;
 mod event_loop;
@@ -39,3 +40,4 @@ pub use self::window::{PlatformSpecificWindowBuilderAttributes, Window, WindowId
 pub(crate) use self::keyboard::KeyEventExtra;
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub(crate) use crate::platform_impl::Fullscreen;
+pub(crate) use cursor::WebCustomCursor as PlatformCustomCursor;

src/platform_impl/web/web_sys/canvas.rs

@@ -1,5 +1,5 @@
 use std::cell::Cell;
-use std::rc::{Rc, Weak};
+use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 
 use smol_str::SmolStr;
@@ -18,11 +18,10 @@ use crate::window::{WindowAttributes, WindowId as RootWindowId};
 use super::super::WindowId;
 use super::animation_frame::AnimationFrameHandler;
 use super::event_handle::EventListenerHandle;
-use super::fullscreen::FullscreenHandler;
 use super::intersection_handle::IntersectionObserverHandle;
 use super::media_query_handle::MediaQueryListHandle;
 use super::pointer::PointerHandler;
-use super::{event, ButtonsState, ResizeScaleHandle};
+use super::{event, fullscreen, ButtonsState, ResizeScaleHandle};
 
 #[allow(dead_code)]
 pub struct Canvas {
@@ -49,10 +48,15 @@ pub struct Common {
     pub document: Document,
     /// Note: resizing the HTMLCanvasElement should go through `backend::set_canvas_size` to ensure the DPI factor is maintained.
     pub raw: HtmlCanvasElement,
-    style: CssStyleDeclaration,
+    style: Style,
     old_size: Rc<Cell<PhysicalSize<u32>>>,
     current_size: Rc<Cell<PhysicalSize<u32>>>,
-    fullscreen_handler: Rc<FullscreenHandler>,
+}
+
+#[derive(Clone, Debug)]
+pub struct Style {
+    read: CssStyleDeclaration,
+    write: CssStyleDeclaration,
 }
 
 impl Canvas {
@@ -90,12 +94,7 @@ impl Canvas {
                 .map_err(|_| os_error!(OsError("Failed to set a tabindex".to_owned())))?;
         }
 
-        #[allow(clippy::disallowed_methods)]
-        let style = window
-            .get_computed_style(&canvas)
-            .expect("Failed to obtain computed style")
-            // this can't fail: we aren't using a pseudo-element
-            .expect("Invalid pseudo-element");
+        let style = Style::new(&window, &canvas);
 
         let common = Common {
             window: window.clone(),
@@ -104,7 +103,6 @@ impl Canvas {
             style,
             old_size: Rc::default(),
             current_size: Rc::default(),
-            fullscreen_handler: Rc::new(FullscreenHandler::new(document.clone(), canvas.clone())),
         };
 
         if let Some(size) = attr.inner_size {
@@ -128,7 +126,7 @@ impl Canvas {
         }
 
         if attr.fullscreen.0.is_some() {
-            common.fullscreen_handler.request_fullscreen();
+            fullscreen::request_fullscreen(&document, &canvas);
         }
 
         if attr.active {
@@ -178,9 +176,7 @@ impl Canvas {
             y: bounds.y(),
         };
 
-        if self.document().contains(Some(self.raw()))
-            && self.style().get_property_value("display").unwrap() != "none"
-        {
+        if self.document().contains(Some(self.raw())) && self.style().get("display") != "none" {
             position.x += super::style_size_property(self.style(), "border-left-width")
                 + super::style_size_property(self.style(), "padding-left");
             position.y += super::style_size_property(self.style(), "border-top-width")
@@ -226,7 +222,7 @@ impl Canvas {
     }
 
     #[inline]
-    pub fn style(&self) -> &CssStyleDeclaration {
+    pub fn style(&self) -> &Style {
         &self.common.style
     }
 
@@ -282,7 +278,7 @@ impl Canvas {
     where
         F: 'static + FnMut(PhysicalKey, Key, Option<SmolStr>, KeyLocation, bool, ModifiersState),
     {
-        self.on_keyboard_press = Some(self.common.add_transient_event(
+        self.on_keyboard_press = Some(self.common.add_event(
             "keydown",
             move |event: KeyboardEvent| {
                 if prevent_default {
@@ -442,20 +438,16 @@ impl Canvas {
         self.animation_frame_handler.on_animation_frame(f)
     }
 
-    pub(crate) fn on_touch_end(&mut self) {
-        self.on_touch_end = Some(self.common.add_transient_event("touchend", |_| {}));
-    }
-
     pub fn request_fullscreen(&self) {
-        self.common.fullscreen_handler.request_fullscreen()
+        fullscreen::request_fullscreen(self.document(), self.raw());
     }
 
     pub fn exit_fullscreen(&self) {
-        self.common.fullscreen_handler.exit_fullscreen()
+        fullscreen::exit_fullscreen(self.document(), self.raw());
     }
 
     pub fn is_fullscreen(&self) -> bool {
-        self.common.fullscreen_handler.is_fullscreen()
+        fullscreen::is_fullscreen(self.document(), self.raw())
     }
 
     pub fn request_animation_frame(&self) {
@@ -506,10 +498,6 @@ impl Canvas {
         }
     }
 
-    pub(crate) fn transient_activation(&self) {
-        self.common.fullscreen_handler.transient_activation()
-    }
-
     pub fn remove_listeners(&mut self) {
         self.on_touch_start = None;
         self.on_focus = None;
@@ -523,7 +511,6 @@ impl Canvas {
         self.on_intersect = None;
         self.animation_frame_handler.cancel();
         self.on_touch_end = None;
-        self.common.fullscreen_handler.cancel();
     }
 }
 
@@ -539,27 +526,38 @@ impl Common {
     {
         EventListenerHandle::new(self.raw.clone(), event_name, Closure::new(handler))
     }
+}
 
-    // The difference between add_event and add_user_event is that the latter has a special meaning
-    // for browser security. A user event is a deliberate action by the user (like a mouse or key
-    // press) and is the only time things like a fullscreen request may be successfully completed.)
-    pub fn add_transient_event<E, F>(
-        &self,
-        event_name: &'static str,
-        mut handler: F,
-    ) -> EventListenerHandle<dyn FnMut(E)>
-    where
-        E: 'static + AsRef<web_sys::Event> + wasm_bindgen::convert::FromWasmAbi,
-        F: 'static + FnMut(E),
-    {
-        let fullscreen_handler = Rc::downgrade(&self.fullscreen_handler);
+impl Style {
+    fn new(window: &web_sys::Window, canvas: &HtmlCanvasElement) -> Self {
+        #[allow(clippy::disallowed_methods)]
+        let read = window
+            .get_computed_style(canvas)
+            .expect("Failed to obtain computed style")
+            // this can't fail: we aren't using a pseudo-element
+            .expect("Invalid pseudo-element");
 
-        self.add_event(event_name, move |event: E| {
-            handler(event);
+        #[allow(clippy::disallowed_methods)]
+        let write = canvas.style();
 
-            if let Some(fullscreen_handler) = Weak::upgrade(&fullscreen_handler) {
-                fullscreen_handler.transient_activation()
-            }
-        })
+        Self { read, write }
+    }
+
+    pub(crate) fn get(&self, property: &str) -> String {
+        self.read
+            .get_property_value(property)
+            .expect("Invalid property")
+    }
+
+    pub(crate) fn remove(&self, property: &str) {
+        self.write
+            .remove_property(property)
+            .expect("Property is read only");
+    }
+
+    pub(crate) fn set(&self, property: &str, value: &str) {
+        self.write
+            .set_property(property, value)
+            .expect("Property is read only");
     }
 }

src/platform_impl/web/web_sys/fullscreen.rs

@@ -1,6 +1,3 @@
-use std::cell::Cell;
-use std::rc::Rc;
-
 use js_sys::Promise;
 use once_cell::unsync::OnceCell;
 use wasm_bindgen::closure::Closure;
@@ -8,138 +5,86 @@ use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::{JsCast, JsValue};
 use web_sys::{Document, Element, HtmlCanvasElement};
 
-use super::EventListenerHandle;
+pub fn request_fullscreen(document: &Document, canvas: &HtmlCanvasElement) {
+    if is_fullscreen(document, canvas) {
+        return;
+    }
 
-thread_local! {
-    static FULLSCREEN_API_SUPPORT: OnceCell<bool> = OnceCell::new();
+    #[wasm_bindgen]
+    extern "C" {
+        #[wasm_bindgen(extends = HtmlCanvasElement)]
+        type RequestFullscreen;
+
+        #[wasm_bindgen(method, js_name = requestFullscreen)]
+        fn request_fullscreen(this: &RequestFullscreen) -> Promise;
+
+        #[wasm_bindgen(method, js_name = webkitRequestFullscreen)]
+        fn webkit_request_fullscreen(this: &RequestFullscreen);
+    }
+
+    let canvas: &RequestFullscreen = canvas.unchecked_ref();
+
+    if has_fullscreen_api_support(canvas) {
+        thread_local! {
+            static REJECT_HANDLER: Closure<dyn FnMut(JsValue)> = Closure::new(|_| ());
+        }
+        REJECT_HANDLER.with(|handler| {
+            let _ = canvas.request_fullscreen().catch(handler);
+        });
+    } else {
+        canvas.webkit_request_fullscreen();
+    }
 }
 
-pub struct FullscreenHandler {
-    document: Document,
-    canvas: HtmlCanvasElement,
-    fullscreen_requested: Rc<Cell<bool>>,
-    _fullscreen_change: EventListenerHandle<dyn FnMut()>,
+pub fn is_fullscreen(document: &Document, canvas: &HtmlCanvasElement) -> bool {
+    #[wasm_bindgen]
+    extern "C" {
+        type FullscreenElement;
+
+        #[wasm_bindgen(method, getter, js_name = webkitFullscreenElement)]
+        fn webkit_fullscreen_element(this: &FullscreenElement) -> Option<Element>;
+    }
+
+    let element = if has_fullscreen_api_support(canvas) {
+        #[allow(clippy::disallowed_methods)]
+        document.fullscreen_element()
+    } else {
+        let document: &FullscreenElement = document.unchecked_ref();
+        document.webkit_fullscreen_element()
+    };
+
+    match element {
+        Some(element) => {
+            let canvas: &Element = canvas;
+            canvas == &element
+        }
+        None => false,
+    }
 }
 
-impl FullscreenHandler {
-    pub fn new(document: Document, canvas: HtmlCanvasElement) -> Self {
-        let fullscreen_requested = Rc::new(Cell::new(false));
-        let fullscreen_change = EventListenerHandle::new(
-            canvas.clone(),
-            if has_fullscreen_api_support(&canvas) {
-                "fullscreenchange"
-            } else {
-                "webkitfullscreenchange"
-            },
-            Closure::new({
-                let fullscreen_requested = fullscreen_requested.clone();
-                move || {
-                    // It doesn't matter if the canvas entered or exitted fullscreen mode,
-                    // we don't want to request it again later.
-                    fullscreen_requested.set(false);
-                }
-            }),
-        );
+pub fn exit_fullscreen(document: &Document, canvas: &HtmlCanvasElement) {
+    #[wasm_bindgen]
+    extern "C" {
+        type ExitFullscreen;
 
-        Self {
-            document,
-            canvas,
-            fullscreen_requested,
-            _fullscreen_change: fullscreen_change,
-        }
+        #[wasm_bindgen(method, js_name = webkitExitFullscreen)]
+        fn webkit_exit_fullscreen(this: &ExitFullscreen);
     }
 
-    fn internal_request_fullscreen(&self) {
-        #[wasm_bindgen]
-        extern "C" {
-            type RequestFullscreen;
-
-            #[wasm_bindgen(method, js_name = requestFullscreen)]
-            fn request_fullscreen(this: &RequestFullscreen) -> Promise;
-
-            #[wasm_bindgen(method, js_name = webkitRequestFullscreen)]
-            fn webkit_request_fullscreen(this: &RequestFullscreen);
-        }
-
-        let canvas: &RequestFullscreen = self.canvas.unchecked_ref();
-
-        if has_fullscreen_api_support(&self.canvas) {
-            thread_local! {
-                static REJECT_HANDLER: Closure<dyn FnMut(JsValue)> = Closure::new(|_| ());
-            }
-            REJECT_HANDLER.with(|handler| {
-                let _ = canvas.request_fullscreen().catch(handler);
-            });
-        } else {
-            canvas.webkit_request_fullscreen();
-        }
-    }
-
-    pub fn request_fullscreen(&self) {
-        if !self.is_fullscreen() {
-            self.internal_request_fullscreen();
-            self.fullscreen_requested.set(true);
-        }
-    }
-
-    pub fn transient_activation(&self) {
-        if self.fullscreen_requested.get() {
-            self.internal_request_fullscreen()
-        }
-    }
-
-    pub fn is_fullscreen(&self) -> bool {
-        #[wasm_bindgen]
-        extern "C" {
-            type FullscreenElement;
-
-            #[wasm_bindgen(method, getter, js_name = webkitFullscreenElement)]
-            fn webkit_fullscreen_element(this: &FullscreenElement) -> Option<Element>;
-        }
-
-        let element = if has_fullscreen_api_support(&self.canvas) {
-            #[allow(clippy::disallowed_methods)]
-            self.document.fullscreen_element()
-        } else {
-            let document: &FullscreenElement = self.document.unchecked_ref();
-            document.webkit_fullscreen_element()
-        };
-
-        match element {
-            Some(element) => {
-                let canvas: &Element = &self.canvas;
-                canvas == &element
-            }
-            None => false,
-        }
-    }
-
-    pub fn exit_fullscreen(&self) {
-        #[wasm_bindgen]
-        extern "C" {
-            type ExitFullscreen;
-
-            #[wasm_bindgen(method, js_name = webkitExitFullscreen)]
-            fn webkit_exit_fullscreen(this: &ExitFullscreen);
-        }
-
-        if has_fullscreen_api_support(&self.canvas) {
-            #[allow(clippy::disallowed_methods)]
-            self.document.exit_fullscreen()
-        } else {
-            let document: &ExitFullscreen = self.document.unchecked_ref();
-            document.webkit_exit_fullscreen()
-        }
-
-        self.fullscreen_requested.set(false);
-    }
-
-    pub fn cancel(&self) {
-        self.fullscreen_requested.set(false);
+    if has_fullscreen_api_support(canvas) {
+        #[allow(clippy::disallowed_methods)]
+        document.exit_fullscreen()
+    } else {
+        let document: &ExitFullscreen = document.unchecked_ref();
+        document.webkit_exit_fullscreen()
     }
 }
 
 fn has_fullscreen_api_support(canvas: &HtmlCanvasElement) -> bool {
+    thread_local! {
+        static FULLSCREEN_API_SUPPORT: OnceCell<bool> = OnceCell::new();
+    }
+
     FULLSCREEN_API_SUPPORT.with(|support| {
         *support.get_or_init(|| {
             #[wasm_bindgen]

src/platform_impl/web/web_sys/mod.rs

@@ -10,6 +10,7 @@ mod resize_scaling;
 mod schedule;
 
 pub use self::canvas::Canvas;
+pub use self::canvas::Style;
 pub use self::event::ButtonsState;
 pub use self::event_handle::EventListenerHandle;
 pub use self::resize_scaling::ResizeScaleHandle;
@@ -17,9 +18,7 @@ pub use self::schedule::Schedule;
 
 use crate::dpi::{LogicalPosition, LogicalSize};
 use wasm_bindgen::closure::Closure;
-use web_sys::{
-    CssStyleDeclaration, Document, HtmlCanvasElement, PageTransitionEvent, VisibilityState,
-};
+use web_sys::{Document, HtmlCanvasElement, PageTransitionEvent, VisibilityState};
 
 pub fn throw(msg: &str) {
     wasm_bindgen::throw_str(msg);
@@ -51,8 +50,8 @@ pub fn scale_factor(window: &web_sys::Window) -> f64 {
     window.device_pixel_ratio()
 }
 
-fn fix_canvas_size(style: &CssStyleDeclaration, mut size: LogicalSize<f64>) -> LogicalSize<f64> {
-    if style.get_property_value("box-sizing").unwrap() == "border-box" {
+fn fix_canvas_size(style: &Style, mut size: LogicalSize<f64>) -> LogicalSize<f64> {
+    if style.get("box-sizing") == "border-box" {
         size.width += style_size_property(style, "border-left-width")
             + style_size_property(style, "border-right-width")
             + style_size_property(style, "padding-left")
@@ -69,76 +68,68 @@ fn fix_canvas_size(style: &CssStyleDeclaration, mut size: LogicalSize<f64>) -> L
 pub fn set_canvas_size(
     document: &Document,
     raw: &HtmlCanvasElement,
-    style: &CssStyleDeclaration,
+    style: &Style,
     new_size: LogicalSize<f64>,
 ) {
-    if !document.contains(Some(raw)) || style.get_property_value("display").unwrap() == "none" {
+    if !document.contains(Some(raw)) || style.get("display") == "none" {
         return;
     }
 
     let new_size = fix_canvas_size(style, new_size);
 
-    set_canvas_style_property(raw, "width", &format!("{}px", new_size.width));
-    set_canvas_style_property(raw, "height", &format!("{}px", new_size.height));
+    style.set("width", &format!("{}px", new_size.width));
+    style.set("height", &format!("{}px", new_size.height));
 }
 
 pub fn set_canvas_min_size(
     document: &Document,
     raw: &HtmlCanvasElement,
-    style: &CssStyleDeclaration,
+    style: &Style,
     dimensions: Option<LogicalSize<f64>>,
 ) {
     if let Some(dimensions) = dimensions {
-        if !document.contains(Some(raw)) || style.get_property_value("display").unwrap() == "none" {
+        if !document.contains(Some(raw)) || style.get("display") == "none" {
             return;
         }
 
         let new_size = fix_canvas_size(style, dimensions);
 
-        set_canvas_style_property(raw, "min-width", &format!("{}px", new_size.width));
-        set_canvas_style_property(raw, "min-height", &format!("{}px", new_size.height));
+        style.set("min-width", &format!("{}px", new_size.width));
+        style.set("min-height", &format!("{}px", new_size.height));
     } else {
-        style
-            .remove_property("min-width")
-            .expect("Property is read only");
-        style
-            .remove_property("min-height")
-            .expect("Property is read only");
+        style.remove("min-width");
+        style.remove("min-height");
     }
 }
 
 pub fn set_canvas_max_size(
     document: &Document,
     raw: &HtmlCanvasElement,
-    style: &CssStyleDeclaration,
+    style: &Style,
     dimensions: Option<LogicalSize<f64>>,
 ) {
     if let Some(dimensions) = dimensions {
-        if !document.contains(Some(raw)) || style.get_property_value("display").unwrap() == "none" {
+        if !document.contains(Some(raw)) || style.get("display") == "none" {
             return;
         }
 
         let new_size = fix_canvas_size(style, dimensions);
 
-        set_canvas_style_property(raw, "max-width", &format!("{}px", new_size.width));
-        set_canvas_style_property(raw, "max-height", &format!("{}px", new_size.height));
+        style.set("max-width", &format!("{}px", new_size.width));
+        style.set("max-height", &format!("{}px", new_size.height));
     } else {
-        style
-            .remove_property("max-width")
-            .expect("Property is read only");
-        style
-            .remove_property("max-height")
-            .expect("Property is read only");
+        style.remove("max-width");
+        style.remove("max-height");
     }
 }
 
 pub fn set_canvas_position(
     document: &Document,
     raw: &HtmlCanvasElement,
-    style: &CssStyleDeclaration,
+    style: &Style,
     mut position: LogicalPosition<f64>,
 ) {
-    if document.contains(Some(raw)) && style.get_property_value("display").unwrap() != "none" {
+    if document.contains(Some(raw)) && style.get("display") != "none" {
         position.x -= style_size_property(style, "margin-left")
             + style_size_property(style, "border-left-width")
             + style_size_property(style, "padding-left");
@@ -147,30 +138,21 @@ pub fn set_canvas_position(
             + style_size_property(style, "padding-top");
     }
 
-    set_canvas_style_property(raw, "position", "fixed");
-    set_canvas_style_property(raw, "left", &format!("{}px", position.x));
-    set_canvas_style_property(raw, "top", &format!("{}px", position.y));
+    style.set("position", "fixed");
+    style.set("left", &format!("{}px", position.x));
+    style.set("top", &format!("{}px", position.y));
 }
 
 /// This function will panic if the element is not inserted in the DOM
 /// or is not a CSS property that represents a size in pixel.
-pub fn style_size_property(style: &CssStyleDeclaration, property: &str) -> f64 {
-    let prop = style
-        .get_property_value(property)
-        .expect("Found invalid property");
+pub fn style_size_property(style: &Style, property: &str) -> f64 {
+    let prop = style.get(property);
     prop.strip_suffix("px")
         .expect("Element was not inserted into the DOM or is not a size in pixel")
         .parse()
         .expect("CSS property is not a size in pixel")
 }
 
-pub fn set_canvas_style_property(raw: &HtmlCanvasElement, property: &str, value: &str) {
-    let style = raw.style();
-    style
-        .set_property(property, value)
-        .unwrap_or_else(|err| panic!("error: {err:?}\nFailed to set {property}"))
-}
-
 pub fn is_dark_mode(window: &web_sys::Window) -> Option<bool> {
     window
         .match_media("(prefers-color-scheme: dark)")

src/platform_impl/web/web_sys/pointer.rs

@@ -80,7 +80,7 @@ impl PointerHandler {
         T: 'static + FnMut(ModifiersState, i32, PhysicalPosition<f64>, Force),
     {
         let window = canvas_common.window.clone();
-        self.on_pointer_release = Some(canvas_common.add_transient_event(
+        self.on_pointer_release = Some(canvas_common.add_event(
             "pointerup",
             move |event: PointerEvent| {
                 let modifiers = event::mouse_modifiers(&event);
@@ -118,7 +118,7 @@ impl PointerHandler {
     {
         let window = canvas_common.window.clone();
         let canvas = canvas_common.raw.clone();
-        self.on_pointer_press = Some(canvas_common.add_transient_event(
+        self.on_pointer_press = Some(canvas_common.add_event(
             "pointerdown",
             move |event: PointerEvent| {
                 if prevent_default {

src/platform_impl/web/web_sys/resize_scaling.rs

@@ -2,14 +2,14 @@ use js_sys::{Array, Object};
 use wasm_bindgen::prelude::{wasm_bindgen, Closure};
 use wasm_bindgen::{JsCast, JsValue};
 use web_sys::{
-    CssStyleDeclaration, Document, HtmlCanvasElement, MediaQueryList, ResizeObserver,
-    ResizeObserverBoxOptions, ResizeObserverEntry, ResizeObserverOptions, ResizeObserverSize,
-    Window,
+    Document, HtmlCanvasElement, MediaQueryList, ResizeObserver, ResizeObserverBoxOptions,
+    ResizeObserverEntry, ResizeObserverOptions, ResizeObserverSize, Window,
 };
 
 use crate::dpi::{LogicalSize, PhysicalSize};
 
 use super::super::backend;
+use super::canvas::Style;
 use super::media_query_handle::MediaQueryListHandle;
 
 use std::cell::{Cell, RefCell};
@@ -22,7 +22,7 @@ impl ResizeScaleHandle {
         window: Window,
         document: Document,
         canvas: HtmlCanvasElement,
-        style: CssStyleDeclaration,
+        style: Style,
         scale_handler: S,
         resize_handler: R,
     ) -> Self
@@ -51,7 +51,7 @@ struct ResizeScaleInternal {
     window: Window,
     document: Document,
     canvas: HtmlCanvasElement,
-    style: CssStyleDeclaration,
+    style: Style,
     mql: MediaQueryListHandle,
     observer: ResizeObserver,
     _observer_closure: Closure<dyn FnMut(Array, ResizeObserver)>,
@@ -65,7 +65,7 @@ impl ResizeScaleInternal {
         window: Window,
         document: Document,
         canvas: HtmlCanvasElement,
-        style: CssStyleDeclaration,
+        style: Style,
         scale_handler: S,
         resize_handler: R,
     ) -> Rc<RefCell<Self>>
@@ -152,9 +152,7 @@ impl ResizeScaleInternal {
     }
 
     fn notify(&mut self) {
-        if !self.document.contains(Some(&self.canvas))
-            || self.style.get_property_value("display").unwrap() == "none"
-        {
+        if !self.document.contains(Some(&self.canvas)) || self.style.get("display") == "none" {
             let size = PhysicalSize::new(0, 0);
 
             if self.notify_scale.replace(false) {
@@ -180,7 +178,7 @@ impl ResizeScaleInternal {
             backend::style_size_property(&self.style, "height"),
         );
 
-        if self.style.get_property_value("box-sizing").unwrap() == "border-box" {
+        if self.style.get("box-sizing") == "border-box" {
             size.width -= backend::style_size_property(&self.style, "border-left-width")
                 + backend::style_size_property(&self.style, "border-right-width")
                 + backend::style_size_property(&self.style, "padding-left")
@@ -246,10 +244,7 @@ impl ResizeScaleInternal {
             .get(0)
             .unchecked_into();
 
-        let writing_mode = self
-            .style
-            .get_property_value("writing-mode")
-            .expect("`writing-mode` is a valid CSS property");
+        let writing_mode = self.style.get("writing-mode");
 
         // means the canvas is not inserted into the DOM
         if writing_mode.is_empty() {

src/platform_impl/web/window.rs

@@ -1,3 +1,4 @@
+use crate::cursor::CustomCursor;
 use crate::dpi::{PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{ExternalError, NotSupportedError, OsError as RootOE};
 use crate::icon::Icon;
@@ -7,12 +8,12 @@ use crate::window::{
 };
 use crate::SendSyncWrapper;
 
-use web_sys::HtmlCanvasElement;
-
+use super::cursor::SelectedCursor;
 use super::r#async::Dispatcher;
 use super::{backend, monitor::MonitorHandle, EventLoopWindowTarget, Fullscreen};
+use web_sys::HtmlCanvasElement;
 
-use std::cell::RefCell;
+use std::cell::{Cell, RefCell};
 use std::collections::VecDeque;
 use std::rc::Rc;
 
@@ -24,7 +25,8 @@ pub struct Inner {
     id: WindowId,
     pub window: web_sys::Window,
     canvas: Rc<RefCell<backend::Canvas>>,
-    previous_pointer: RefCell<&'static str>,
+    selected_cursor: RefCell<SelectedCursor>,
+    cursor_visible: Rc<Cell<bool>>,
     destroy_fn: Option<Box<dyn FnOnce()>>,
 }
 
@@ -53,7 +55,8 @@ impl Window {
             id,
             window: window.clone(),
             canvas,
-            previous_pointer: RefCell::new("auto"),
+            selected_cursor: Default::default(),
+            cursor_visible: Rc::new(Cell::new(true)),
             destroy_fn: Some(destroy_fn),
         };
 
@@ -195,8 +198,24 @@ impl Inner {
 
     #[inline]
     pub fn set_cursor_icon(&self, cursor: CursorIcon) {
-        *self.previous_pointer.borrow_mut() = cursor.name();
-        backend::set_canvas_style_property(self.canvas.borrow().raw(), "cursor", cursor.name());
+        *self.selected_cursor.borrow_mut() = SelectedCursor::Named(cursor);
+
+        if self.cursor_visible.get() {
+            self.canvas.borrow().style().set("cursor", cursor.name());
+        }
+    }
+
+    #[inline]
+    pub fn set_custom_cursor(&self, cursor: CustomCursor) {
+        let canvas = self.canvas.borrow();
+        let new_cursor = cursor.inner.build(
+            canvas.window(),
+            canvas.document(),
+            canvas.style(),
+            self.selected_cursor.take(),
+            self.cursor_visible.clone(),
+        );
+        *self.selected_cursor.borrow_mut() = new_cursor;
     }
 
     #[inline]
@@ -222,14 +241,14 @@ impl Inner {
 
     #[inline]
     pub fn set_cursor_visible(&self, visible: bool) {
-        if !visible {
-            backend::set_canvas_style_property(self.canvas.borrow().raw(), "cursor", "none");
-        } else {
-            backend::set_canvas_style_property(
-                self.canvas.borrow().raw(),
-                "cursor",
-                &self.previous_pointer.borrow(),
-            );
+        if !visible && self.cursor_visible.get() {
+            self.canvas.borrow().style().set("cursor", "none");
+            self.cursor_visible.set(false);
+        } else if visible && !self.cursor_visible.get() {
+            self.selected_cursor
+                .borrow()
+                .set_style(self.canvas.borrow().style());
+            self.cursor_visible.set(true);
         }
     }
 

src/platform_impl/windows/event_loop.rs

@@ -101,7 +101,7 @@ use runner::{EventLoopRunner, EventLoopRunnerShared};
 
 use self::runner::RunnerState;
 
-use super::window::set_skip_taskbar;
+use super::{window::set_skip_taskbar, SelectedCursor};
 
 type GetPointerFrameInfoHistory = unsafe extern "system" fn(
     pointerId: u32,
@@ -356,19 +356,6 @@ impl<T: 'static> EventLoop<T> {
 
     /// Wait for one message and dispatch it, optionally with a timeout
     fn wait_and_dispatch_message(&mut self, timeout: Option<Duration>) {
-        let start = Instant::now();
-
-        let runner = &self.window_target.p.runner_shared;
-
-        let control_flow_timeout = match runner.control_flow() {
-            ControlFlow::Wait => None,
-            ControlFlow::Poll => Some(Duration::ZERO),
-            ControlFlow::WaitUntil(wait_deadline) => {
-                Some(wait_deadline.saturating_duration_since(start))
-            }
-        };
-        let timeout = min_timeout(control_flow_timeout, timeout);
-
         fn get_msg_with_timeout(msg: &mut MSG, timeout: Option<Duration>) -> PumpStatus {
             unsafe {
                 // A timeout of None means wait indefinitely (so we don't need to call SetTimer)
@@ -404,6 +391,8 @@ impl<T: 'static> EventLoop<T> {
             }
         }
 
+        let runner = &self.window_target.p.runner_shared;
+
         // We aim to be consistent with the MacOS backend which has a RunLoop
         // observer that will dispatch AboutToWait when about to wait for
         // events, and NewEvents after the RunLoop wakes up.
@@ -415,6 +404,16 @@ impl<T: 'static> EventLoop<T> {
         //
         runner.prepare_wait();
 
+        let control_flow_timeout = match runner.control_flow() {
+            ControlFlow::Wait => None,
+            ControlFlow::Poll => Some(Duration::ZERO),
+            ControlFlow::WaitUntil(wait_deadline) => {
+                let start = Instant::now();
+                Some(wait_deadline.saturating_duration_since(start))
+            }
+        };
+        let timeout = min_timeout(control_flow_timeout, timeout);
+
         // # Safety
         // The Windows API has no documented requirement for bitwise
         // initializing a `MSG` struct (it can be uninitialized memory for the C
@@ -1465,6 +1464,7 @@ unsafe fn public_window_callback_inner<T: 'static>(
                             .set_cursor_flags(window, |f| f.set(CursorFlags::IN_WINDOW, true))
                             .ok();
 
+                        drop(w);
                         userdata.send_event(Event::WindowEvent {
                             window_id: RootWindowId(WindowId(window)),
                             event: CursorEntered {
@@ -1487,6 +1487,7 @@ unsafe fn public_window_callback_inner<T: 'static>(
                             .set_cursor_flags(window, |f| f.set(CursorFlags::IN_WINDOW, false))
                             .ok();
 
+                        drop(w);
                         userdata.send_event(Event::WindowEvent {
                             window_id: RootWindowId(WindowId(window)),
                             event: CursorLeft {
@@ -1494,12 +1495,13 @@ unsafe fn public_window_callback_inner<T: 'static>(
                             },
                         });
                     }
-                    PointerMoveKind::None => (),
+                    PointerMoveKind::None => drop(w),
                 }
 
                 // handle spurious WM_MOUSEMOVE messages
                 // see https://devblogs.microsoft.com/oldnewthing/20031001-00/?p=42343
                 // and http://debugandconquer.blogspot.com/2015/08/the-cause-of-spurious-mouse-move.html
+                let mut w = userdata.window_state_lock();
                 cursor_moved = w.mouse.last_position != Some(position);
                 w.mouse.last_position = Some(position);
             }
@@ -2009,16 +2011,21 @@ unsafe fn public_window_callback_inner<T: 'static>(
                 // `WM_MOUSEMOVE` seems to come after `WM_SETCURSOR` for a given cursor movement.
                 let in_client_area = super::loword(lparam as u32) as u32 == HTCLIENT;
                 if in_client_area {
-                    Some(window_state.mouse.cursor)
+                    Some(window_state.mouse.selected_cursor.clone())
                 } else {
                     None
                 }
             };
 
             match set_cursor_to {
-                Some(cursor) => {
-                    let cursor = unsafe { LoadCursorW(0, util::to_windows_cursor(cursor)) };
-                    unsafe { SetCursor(cursor) };
+                Some(selected_cursor) => {
+                    let hcursor = match selected_cursor {
+                        SelectedCursor::Named(cursor_icon) => unsafe {
+                            LoadCursorW(0, util::to_windows_cursor(cursor_icon))
+                        },
+                        SelectedCursor::Custom(cursor) => cursor.as_raw_handle(),
+                    };
+                    unsafe { SetCursor(hcursor) };
                     result = ProcResult::Value(0);
                 }
                 None => result = ProcResult::DefWindowProc(wparam),

src/platform_impl/windows/icon.rs

@@ -1,18 +1,23 @@
-use std::{fmt, io, mem, path::Path, sync::Arc};
+use std::{ffi::c_void, fmt, io, mem, path::Path, sync::Arc};
 
+use cursor_icon::CursorIcon;
 use windows_sys::{
     core::PCWSTR,
     Win32::{
         Foundation::HWND,
+        Graphics::Gdi::{
+            CreateBitmap, CreateCompatibleBitmap, DeleteObject, GetDC, ReleaseDC, SetBitmapBits,
+        },
         UI::WindowsAndMessaging::{
-            CreateIcon, DestroyIcon, LoadImageW, SendMessageW, HICON, ICON_BIG, ICON_SMALL,
-            IMAGE_ICON, LR_DEFAULTSIZE, LR_LOADFROMFILE, WM_SETICON,
+            CreateIcon, CreateIconIndirect, DestroyCursor, DestroyIcon, LoadImageW, SendMessageW,
+            HCURSOR, HICON, ICONINFO, ICON_BIG, ICON_SMALL, IMAGE_ICON, LR_DEFAULTSIZE,
+            LR_LOADFROMFILE, WM_SETICON,
         },
     },
 };
 
-use crate::dpi::PhysicalSize;
 use crate::icon::*;
+use crate::{cursor::CursorImage, dpi::PhysicalSize};
 
 use super::util;
 
@@ -160,3 +165,92 @@ pub fn unset_for_window(hwnd: HWND, icon_type: IconType) {
         SendMessageW(hwnd, WM_SETICON, icon_type as usize, 0);
     }
 }
+
+#[derive(Debug, Clone)]
+pub enum SelectedCursor {
+    Named(CursorIcon),
+    Custom(WinCursor),
+}
+
+impl Default for SelectedCursor {
+    fn default() -> Self {
+        Self::Named(Default::default())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct WinCursor {
+    inner: Arc<RaiiCursor>,
+}
+
+impl WinCursor {
+    pub fn as_raw_handle(&self) -> HICON {
+        self.inner.handle
+    }
+
+    fn from_handle(handle: HCURSOR) -> Self {
+        Self {
+            inner: Arc::new(RaiiCursor { handle }),
+        }
+    }
+
+    pub fn new(image: &CursorImage) -> Result<Self, io::Error> {
+        let mut bgra = image.rgba.clone();
+        bgra.chunks_exact_mut(4).for_each(|chunk| chunk.swap(0, 2));
+
+        let w = image.width as i32;
+        let h = image.height as i32;
+
+        unsafe {
+            let hdc_screen = GetDC(0);
+            if hdc_screen == 0 {
+                return Err(io::Error::last_os_error());
+            }
+            let hbm_color = CreateCompatibleBitmap(hdc_screen, w, h);
+            ReleaseDC(0, hdc_screen);
+            if hbm_color == 0 {
+                return Err(io::Error::last_os_error());
+            }
+            if SetBitmapBits(hbm_color, bgra.len() as u32, bgra.as_ptr() as *const c_void) == 0 {
+                DeleteObject(hbm_color);
+                return Err(io::Error::last_os_error());
+            };
+
+            // Mask created according to https://learn.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-createbitmap#parameters
+            let mask_bits: Vec<u8> = vec![0xff; ((((w + 15) >> 4) << 1) * h) as usize];
+            let hbm_mask = CreateBitmap(w, h, 1, 1, mask_bits.as_ptr() as *const _);
+            if hbm_mask == 0 {
+                DeleteObject(hbm_color);
+                return Err(io::Error::last_os_error());
+            }
+
+            let icon_info = ICONINFO {
+                fIcon: 0,
+                xHotspot: image.hotspot_x as u32,
+                yHotspot: image.hotspot_y as u32,
+                hbmMask: hbm_mask,
+                hbmColor: hbm_color,
+            };
+
+            let handle = CreateIconIndirect(&icon_info as *const _);
+            DeleteObject(hbm_color);
+            DeleteObject(hbm_mask);
+            if handle == 0 {
+                return Err(io::Error::last_os_error());
+            }
+
+            Ok(Self::from_handle(handle))
+        }
+    }
+}
+
+#[derive(Debug)]
+struct RaiiCursor {
+    handle: HCURSOR,
+}
+
+impl Drop for RaiiCursor {
+    fn drop(&mut self) {
+        unsafe { DestroyCursor(self.handle) };
+    }
+}

src/platform_impl/windows/mod.rs

@@ -10,12 +10,13 @@ pub(crate) use self::{
     event_loop::{
         EventLoop, EventLoopProxy, EventLoopWindowTarget, PlatformSpecificEventLoopAttributes,
     },
-    icon::WinIcon,
+    icon::{SelectedCursor, WinIcon},
     monitor::{MonitorHandle, VideoMode},
     window::Window,
 };
 
 pub use self::icon::WinIcon as PlatformIcon;
+pub(crate) use crate::cursor::CursorImage as PlatformCustomCursor;
 use crate::platform_impl::Fullscreen;
 
 use crate::event::DeviceId as RootDeviceId;

src/platform_impl/windows/monitor.rs

@@ -230,37 +230,45 @@ impl MonitorHandle {
         // EnumDisplaySettingsExW can return duplicate values (or some of the
         // fields are probably changing, but we aren't looking at those fields
         // anyway), so we're using a BTreeSet deduplicate
-        let mut modes = BTreeSet::new();
-        let mut i = 0;
+        let mut modes = BTreeSet::<RootVideoMode>::new();
+        let mod_map = |mode: RootVideoMode| mode.video_mode;
 
-        loop {
-            unsafe {
-                let monitor_info = get_monitor_info(self.0).unwrap();
-                let device_name = monitor_info.szDevice.as_ptr();
-                let mut mode: DEVMODEW = mem::zeroed();
-                mode.dmSize = mem::size_of_val(&mode) as u16;
-                if EnumDisplaySettingsExW(device_name, i, &mut mode, 0) == false.into() {
-                    break;
-                }
-                i += 1;
-
-                const REQUIRED_FIELDS: u32 =
-                    DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
-                assert!(has_flag(mode.dmFields, REQUIRED_FIELDS));
-
-                // Use Ord impl of RootVideoMode
-                modes.insert(RootVideoMode {
-                    video_mode: VideoMode {
-                        size: (mode.dmPelsWidth, mode.dmPelsHeight),
-                        bit_depth: mode.dmBitsPerPel as u16,
-                        refresh_rate_millihertz: mode.dmDisplayFrequency * 1000,
-                        monitor: self.clone(),
-                        native_video_mode: Box::new(mode),
-                    },
-                });
+        let monitor_info = match get_monitor_info(self.0) {
+            Ok(monitor_info) => monitor_info,
+            Err(error) => {
+                log::warn!("Error from get_monitor_info: {error}");
+                return modes.into_iter().map(mod_map);
             }
+        };
+
+        let device_name = monitor_info.szDevice.as_ptr();
+
+        let mut i = 0;
+        loop {
+            let mut mode: DEVMODEW = unsafe { mem::zeroed() };
+            mode.dmSize = mem::size_of_val(&mode) as u16;
+            if unsafe { EnumDisplaySettingsExW(device_name, i, &mut mode, 0) } == false.into() {
+                break;
+            }
+
+            const REQUIRED_FIELDS: u32 =
+                DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;
+            assert!(has_flag(mode.dmFields, REQUIRED_FIELDS));
+
+            // Use Ord impl of RootVideoMode
+            modes.insert(RootVideoMode {
+                video_mode: VideoMode {
+                    size: (mode.dmPelsWidth, mode.dmPelsHeight),
+                    bit_depth: mode.dmBitsPerPel as u16,
+                    refresh_rate_millihertz: mode.dmDisplayFrequency * 1000,
+                    monitor: self.clone(),
+                    native_video_mode: Box::new(mode),
+                },
+            });
+
+            i += 1;
         }
 
-        modes.into_iter().map(|mode| mode.video_mode)
+        modes.into_iter().map(mod_map)
     }
 }

src/platform_impl/windows/window.rs

@@ -55,6 +55,7 @@ use windows_sys::Win32::{
 };
 
 use crate::{
+    cursor::CustomCursor,
     dpi::{PhysicalPosition, PhysicalSize, Position, Size},
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
     icon::Icon,
@@ -66,13 +67,13 @@ use crate::{
         dpi::{dpi_to_scale_factor, enable_non_client_dpi_scaling, hwnd_dpi},
         drop_handler::FileDropHandler,
         event_loop::{self, EventLoopWindowTarget, DESTROY_MSG_ID},
-        icon::{self, IconType},
+        icon::{self, IconType, WinCursor},
         ime::ImeContext,
         keyboard::KeyEventBuilder,
         monitor::{self, MonitorHandle},
         util,
         window_state::{CursorFlags, SavedWindow, WindowFlags, WindowState},
-        Fullscreen, PlatformSpecificWindowBuilderAttributes, WindowId,
+        Fullscreen, PlatformSpecificWindowBuilderAttributes, SelectedCursor, WindowId,
     },
     window::{
         CursorGrabMode, CursorIcon, ImePurpose, ResizeDirection, Theme, UserAttentionType,
@@ -126,7 +127,16 @@ impl Window {
         }
     }
 
-    pub fn set_transparent(&self, _transparent: bool) {}
+    pub fn set_transparent(&self, transparent: bool) {
+        let window = self.window.clone();
+        let window_state = Arc::clone(&self.window_state);
+        self.thread_executor.execute_in_thread(move || {
+            let _ = &window;
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
+                f.set(WindowFlags::TRANSPARENT, transparent)
+            });
+        });
+    }
 
     pub fn set_blur(&self, _blur: bool) {}
 
@@ -387,13 +397,28 @@ impl Window {
 
     #[inline]
     pub fn set_cursor_icon(&self, cursor: CursorIcon) {
-        self.window_state_lock().mouse.cursor = cursor;
+        self.window_state_lock().mouse.selected_cursor = SelectedCursor::Named(cursor);
         self.thread_executor.execute_in_thread(move || unsafe {
             let cursor = LoadCursorW(0, util::to_windows_cursor(cursor));
             SetCursor(cursor);
         });
     }
 
+    #[inline]
+    pub fn set_custom_cursor(&self, cursor: CustomCursor) {
+        let new_cursor = match WinCursor::new(&cursor.inner) {
+            Ok(cursor) => cursor,
+            Err(err) => {
+                warn!("Failed to create custom cursor: {err}");
+                return;
+            }
+        };
+        self.window_state_lock().mouse.selected_cursor = SelectedCursor::Custom(new_cursor.clone());
+        self.thread_executor.execute_in_thread(move || unsafe {
+            SetCursor(new_cursor.as_raw_handle());
+        });
+    }
+
     #[inline]
     pub fn set_cursor_grab(&self, mode: CursorGrabMode) -> Result<(), ExternalError> {
         let confine = match mode {
@@ -463,27 +488,41 @@ impl Window {
     }
 
     unsafe fn handle_os_dragging(&self, wparam: WPARAM) {
-        let points = {
-            let mut pos = unsafe { mem::zeroed() };
-            unsafe { GetCursorPos(&mut pos) };
-            pos
-        };
-        let points = POINTS {
-            x: points.x as i16,
-            y: points.y as i16,
-        };
-        unsafe { ReleaseCapture() };
+        let window = self.window.clone();
+        let window_state = self.window_state.clone();
 
-        self.window_state_lock().dragging = true;
+        self.thread_executor.execute_in_thread(move || {
+            {
+                let mut guard = window_state.lock().unwrap();
+                if !guard.dragging {
+                    guard.dragging = true;
+                } else {
+                    return;
+                }
+            }
 
-        unsafe {
-            PostMessageW(
-                self.hwnd(),
-                WM_NCLBUTTONDOWN,
-                wparam,
-                &points as *const _ as LPARAM,
-            )
-        };
+            let points = {
+                let mut pos = unsafe { mem::zeroed() };
+                unsafe { GetCursorPos(&mut pos) };
+                pos
+            };
+            let points = POINTS {
+                x: points.x as i16,
+                y: points.y as i16,
+            };
+
+            // ReleaseCapture needs to execute on the main thread
+            unsafe { ReleaseCapture() };
+
+            unsafe {
+                PostMessageW(
+                    window.0,
+                    WM_NCLBUTTONDOWN,
+                    wparam,
+                    &points as *const _ as LPARAM,
+                )
+            };
+        });
     }
 
     #[inline]
@@ -663,9 +702,19 @@ impl Window {
 
         let mut window_state_lock = window_state.lock().unwrap();
         let old_fullscreen = window_state_lock.fullscreen.clone();
-        if window_state_lock.fullscreen == fullscreen {
-            return;
+
+        match (&old_fullscreen, &fullscreen) {
+            // Return if we already are in the same fullscreen mode
+            _ if old_fullscreen == fullscreen => return,
+            // Return if saved Borderless(monitor) is the same as current monitor when requested fullscreen is Borderless(None)
+            (Some(Fullscreen::Borderless(Some(monitor))), Some(Fullscreen::Borderless(None)))
+                if *monitor == monitor::current_monitor(window.0) =>
+            {
+                return
+            }
+            _ => {}
         }
+
         window_state_lock.fullscreen = fullscreen.clone();
         drop(window_state_lock);
 

src/platform_impl/windows/window_state.rs

@@ -2,8 +2,8 @@ use crate::{
     dpi::{PhysicalPosition, PhysicalSize, Size},
     icon::Icon,
     keyboard::ModifiersState,
-    platform_impl::platform::{event_loop, util, Fullscreen},
-    window::{CursorIcon, Theme, WindowAttributes},
+    platform_impl::platform::{event_loop, util, Fullscreen, SelectedCursor},
+    window::{Theme, WindowAttributes},
 };
 use std::io;
 use std::sync::MutexGuard;
@@ -67,7 +67,7 @@ pub struct SavedWindow {
 
 #[derive(Clone)]
 pub struct MouseProperties {
-    pub cursor: CursorIcon,
+    pub(crate) selected_cursor: SelectedCursor,
     pub capture_count: u32,
     cursor_flags: CursorFlags,
     pub last_position: Option<PhysicalPosition<f64>>,
@@ -143,7 +143,7 @@ impl WindowState {
     ) -> WindowState {
         WindowState {
             mouse: MouseProperties {
-                cursor: CursorIcon::default(),
+                selected_cursor: SelectedCursor::default(),
                 capture_count: 0,
                 cursor_flags: CursorFlags::empty(),
                 last_position: None,

src/window.rs

@@ -9,6 +9,7 @@ use crate::{
     platform_impl, SendSyncWrapper,
 };
 
+pub use crate::cursor::{BadImage, CustomCursor, MAX_CURSOR_SIZE};
 pub use crate::icon::{BadIcon, Icon};
 
 #[doc(inline)]
@@ -543,14 +544,17 @@ impl Window {
         self.window.maybe_wait_on_main(|w| WindowId(w.id()))
     }
 
-    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.
-    ///
-    /// See the [`dpi`](crate::dpi) module for more information.
+    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and
+    /// vice versa.
     ///
     /// Note that this value can change depending on user action (for example if the window is
     /// moved to another screen); as such, tracking [`WindowEvent::ScaleFactorChanged`] events is
     /// the most robust way to track the DPI you need to use to draw.
     ///
+    /// This value may differ from [`MonitorHandle::scale_factor`].
+    ///
+    /// See the [`dpi`](crate::dpi) module for more information.
+    ///
     /// ## Platform-specific
     ///
     /// - **X11:** This respects Xft.dpi, and can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
@@ -597,11 +601,11 @@ impl Window {
         self.window.maybe_queue_on_main(|w| w.request_redraw())
     }
 
-    /// Notify the windowing system that you're before presenting to the window.
+    /// Notify the windowing system before presenting to the window.
     ///
-    /// You should call this event after you've done drawing operations, but before you submit
+    /// You should call this event after your drawing operations, but before you submit
     /// the buffer to the display or commit your drawings. Doing so will help winit to properly
-    /// schedule and do assumptions about its internal state. For example, it could properly
+    /// schedule and make assumptions about its internal state. For example, it could properly
     /// throttle [`WindowEvent::RedrawRequested`].
     ///
     /// ## Example
@@ -904,7 +908,7 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// - **Windows / Web / iOS / Android / Orbital:** Unsupported.
+    /// - **Web / iOS / Android / Orbital:** Unsupported.
     /// - **X11:** Can only be set while building the window, with [`WindowBuilder::with_transparent`].
     #[inline]
     pub fn set_transparent(&self, transparent: bool) {
@@ -918,7 +922,7 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// - **Android / iOS / macOS / X11 / Web / Windows:** Unsupported.
+    /// - **Android / iOS / X11 / Web / Windows:** Unsupported.
     /// - **Wayland:** Only works with org_kde_kwin_blur_manager protocol.
     #[inline]
     pub fn set_blur(&self, blur: bool) {
@@ -1074,8 +1078,7 @@ impl Window {
     /// - **Wayland:** Does not support exclusive fullscreen mode and will no-op a request.
     /// - **Windows:** Screen saver is disabled in fullscreen mode.
     /// - **Android / Orbital:** Unsupported.
-    /// - **Web:** Does nothing without a [transient activation], but queues the request
-    ///   for the next activation.
+    /// - **Web:** Does nothing without a [transient activation].
     ///
     /// [transient activation]: https://developer.mozilla.org/en-US/docs/Glossary/Transient_activation
     #[inline]
@@ -1333,6 +1336,7 @@ impl Window {
 /// Cursor functions.
 impl Window {
     /// Modifies the cursor icon of the window.
+    /// Overwrites cursors set in [`Window::set_custom_cursor`].
     ///
     /// ## Platform-specific
     ///
@@ -1343,6 +1347,19 @@ impl Window {
             .maybe_queue_on_main(move |w| w.set_cursor_icon(cursor))
     }
 
+    /// Modifies the cursor icon of the window with a custom cursor.
+    /// Overwrites cursors set in [`Window::set_cursor_icon`].
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Orbital:** Unsupported.
+    #[inline]
+    pub fn set_custom_cursor(&self, cursor: &CustomCursor) {
+        let cursor = cursor.clone();
+        self.window
+            .maybe_queue_on_main(move |w| w.set_custom_cursor(cursor))
+    }
+
     /// Changes the position of the cursor in window coordinates.
     ///
     /// ```no_run

tests/send_objects.rs

@@ -28,3 +28,8 @@ fn ids_send() {
     needs_send::<winit::event::DeviceId>();
     needs_send::<winit::monitor::MonitorHandle>();
 }
+
+#[test]
+fn custom_cursor_send() {
+    needs_send::<winit::window::CustomCursor>();
+}

tests/sync_object.rs

@@ -11,3 +11,8 @@ fn window_sync() {
 fn window_builder_sync() {
     needs_sync::<winit::window::WindowBuilder>();
 }
+
+#[test]
+fn custom_cursor_sync() {
+    needs_sync::<winit::window::CustomCursor>();
+}