Release 0.26.0 version

* Update raw-window-handle to `0.4.2`

See:
- https://github.com/rust-windowing/raw-window-handle/issues/72
- https://github.com/rust-windowing/raw-window-handle/pull/73
- https://github.com/rust-windowing/raw-window-handle/pull/74

* Clean up raw_window_handle functions a bit

.github/workflows/ci.yml

@@ -38,15 +38,14 @@ jobs:
           - { target: i686-unknown-linux-gnu,   os: ubuntu-latest,   }
           - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest,   }
           - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: --no-default-features, features: x11 }
-          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: --no-default-features, features: wayland }
+          - { target: x86_64-unknown-linux-gnu, os: ubuntu-latest, options: --no-default-features, features: "wayland,wayland-dlopen" }
           - { target: aarch64-linux-android,    os: ubuntu-latest,  cmd: 'apk --' }
           - { target: x86_64-apple-darwin,      os: macos-latest,    }
           - { target: x86_64-apple-ios,         os: macos-latest,    }
           - { target: aarch64-apple-ios,        os: macos-latest,    }
           # We're using Windows rather than Ubuntu to run the wasm tests because caching cargo-web
           # doesn't currently work on Linux.
-          - { target: wasm32-unknown-unknown,   os: windows-latest, features: stdweb,  cmd: web }
-          - { target: wasm32-unknown-unknown,   os: windows-latest, features: web-sys, cmd: web }
+          - { target: wasm32-unknown-unknown,   os: windows-latest,  }
 
     env:
       RUST_BACKTRACE: 1
@@ -77,10 +76,6 @@ jobs:
     - name: Install cargo-apk
       if: contains(matrix.platform.target, 'android')
       run: cargo install cargo-apk
-    - name: Install cargo-web
-      continue-on-error: true
-      if: contains(matrix.platform.target, 'wasm32')
-      run: cargo install cargo-web
 
     - name: Check documentation
       shell: bash

.github/workflows/publish.yml

@@ -2,8 +2,8 @@ name: Publish
 
 on:
   push:
-    branches: [master]
-    paths: "Cargo.toml"
+    tags:
+    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
 
 jobs:
   Publish:

.gitignore

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

CHANGELOG.md

@@ -1,4 +1,92 @@
-# Unreleased
+# 0.26.0 (2021-12-01)
+
+- Update `raw-window-handle` to `v0.4`. This is _not_ a breaking change, we still implement `HasRawWindowHandle` from `v0.3`, see [rust-windowing/raw-window-handle#74](https://github.com/rust-windowing/raw-window-handle/pull/74).
+- On X11, bump `mio` to 0.8.
+- On Android, fixed `WindowExtAndroid::config` initially returning an empty `Configuration`.
+- On Android, fixed `Window::scale_factor` and `MonitorHandle::scale_factor` initially always returning 1.0.
+- On X11, select an appropriate visual for transparency if is requested
+- On Wayland and X11, fix diagonal window resize cursor orientation.
+- On macOS, drop the event callback before exiting.
+- On Android, implement `Window::request_redraw`
+- **Breaking:** On Web, remove the `stdweb` backend.
+- Added `Window::focus_window`to bring the window to the front and set input focus.
+- On Wayland and X11, implement `is_maximized` method on `Window`.
+- On Windows, prevent ghost window from showing up in the taskbar after either several hours of use or restarting `explorer.exe`.
+- On macOS, fix issue where `ReceivedCharacter` was not being emitted during some key repeat events.
+- On Wayland, load cursor icons `hand2` and `hand1` for `CursorIcon::Hand`.
+- **Breaking:** On Wayland, Theme trait and its support types are dropped.
+- On Wayland, bump `smithay-client-toolkit` to 0.15.1.
+- On Wayland, implement `request_user_attention` with `xdg_activation_v1`.
+- On X11, emit missing `WindowEvent::ScaleFactorChanged` when the only monitor gets reconnected.
+- On X11, if RANDR based scale factor is higher than 20 reset it to 1
+- On Wayland, add an enabled-by-default feature called `wayland-dlopen` so users can opt out of using `dlopen` to load system libraries.
+- **Breaking:** On Android, bump `ndk` and `ndk-glue` to 0.5.
+- On Windows, increase wait timer resolution for more accurate timing when using `WaitUntil`.
+- On macOS, fix native file dialogs hanging the event loop.
+- On Wayland, implement a workaround for wrong configure size when using `xdg_decoration` in `kwin_wayland`
+- On macOS, fix an issue that prevented the menu bar from showing in borderless fullscreen mode.
+- On X11, EINTR while polling for events no longer causes a panic. Instead it will be treated as a spurious wakeup.
+
+# 0.25.0 (2021-05-15)
+
+- **Breaking:** On macOS, replace `WindowBuilderExtMacOS::with_activation_policy` with `EventLoopExtMacOS::set_activation_policy`
+- On macOS, wait with activating the application until the application has initialized.
+- On macOS, fix creating new windows when the application has a main menu.
+- On Windows, fix fractional deltas for mouse wheel device events.
+- On macOS, fix segmentation fault after dropping the main window.
+- On Android, `InputEvent::KeyEvent` is partially implemented providing the key scancode.
+- Added `is_maximized` method to `Window`.
+- On Windows, fix bug where clicking the decoration bar would make the cursor blink.
+- On Windows, fix bug causing newly created windows to erroneously display the "wait" (spinning) cursor.
+- On macOS, wake up the event loop immediately when a redraw is requested.
+- On Windows, change the default window size (1024x768) to match the default on other desktop platforms (800x600).
+- On Windows, fix bug causing mouse capture to not be released.
+- On Windows, fix fullscreen not preserving minimized/maximized state.
+- On Android, unimplemented events are marked as unhandled on the native event loop.
+- On Windows, added `WindowBuilderExtWindows::with_menu` to set a custom menu at window creation time.
+- On Android, bump `ndk` and `ndk-glue` to 0.3: use predefined constants for event `ident`.
+- On macOS, fix objects captured by the event loop closure not being dropped on panic.
+- On Windows, fixed `WindowEvent::ThemeChanged` not properly firing and fixed `Window::theme` returning the wrong theme.
+- On Web, added support for `DeviceEvent::MouseMotion` to listen for relative mouse movements.
+- Added `WindowBuilder::with_position` to allow setting the position of a `Window` on creation. Supported on Windows, macOS and X11.
+- Added `Window::drag_window`. Implemented on Windows, macOS, X11 and Wayland.
+- On X11, bump `mio` to 0.7.
+- On Windows, added `WindowBuilderExtWindows::with_owner_window` to allow creating popup windows.
+- On Windows, added `WindowExtWindows::set_enable` to allow creating modal popup windows.
+- On macOS, emit `RedrawRequested` events immediately while the window is being resized.
+- Implement `Default`, `Hash`, and `Eq` for `LogicalPosition`, `PhysicalPosition`, `LogicalSize`, and `PhysicalSize`.
+- On macOS, initialize the Menu Bar with minimal defaults. (Can be prevented using `enable_default_menu_creation`)
+- On macOS, change the default behavior for first click when the window was unfocused. Now the window becomes focused and then emits a `MouseInput` event on a "first mouse click".
+- Implement mint (math interoperability standard types) conversions (under feature flag `mint`).
+
+# 0.24.0 (2020-12-09)
+
+- On Windows, fix applications not exiting gracefully due to thread_event_target_callback accessing corrupted memory.
+- On Windows, implement `Window::set_ime_position`.
+- **Breaking:** On Windows, Renamed `WindowBuilderExtWindows`'s `is_dark_mode` to `theme`.
+- **Breaking:** On Windows, renamed `WindowBuilderExtWindows::is_dark_mode` to `theme`.
+- On Windows, add `WindowBuilderExtWindows::with_theme` to set a preferred theme.
+- On Windows, fix bug causing message boxes to appear delayed.
+- On Android, calling `WindowEvent::Focused` now works properly instead of always returning false.
+- On Windows, fix Alt-Tab behaviour by removing borderless fullscreen "always on top" flag.
+- On Windows, fix bug preventing windows with transparency enabled from having fully-opaque regions.
+- **Breaking:** On Windows, include prefix byte in scancodes.
+- On Wayland, fix window not being resizeable when using `WindowBuilder::with_min_inner_size`.
+- On Unix, fix cross-compiling to wasm32 without enabling X11 or Wayland.
+- On Windows, fix use-after-free crash during window destruction.
+- On Web, fix `WindowEvent::ReceivedCharacter` never being sent on key input.
+- On macOS, fix compilation when targeting aarch64.
+- On X11, fix `Window::request_redraw` not waking the event loop.
+- On Wayland, the keypad arrow keys are now recognized.
+- **Breaking** Rename `desktop::EventLoopExtDesktop` to `run_return::EventLoopExtRunReturn`.
+- Added `request_user_attention` method to `Window`.
+- **Breaking:** On macOS, removed `WindowExt::request_user_attention`, use `Window::request_user_attention`.
+- **Breaking:** On X11, removed `WindowExt::set_urgent`, use `Window::request_user_attention`.
+- On Wayland, default font size in CSD increased from 11 to 17.
+- On Windows, fix bug causing message boxes to appear delayed.
+- On Android, support multi-touch.
+- On Wayland, extra mouse buttons are not dropped anymore.
+- **Breaking**: `MouseButton::Other` now uses `u16`.
 
 # 0.23.0 (2020-10-02)
 
@@ -8,7 +96,7 @@
 - On X11, fix deadlock when calling `set_fullscreen_inner`.
 - On Web, prevent the webpage from scrolling when the user is focused on a winit canvas
 - On Web, calling `window.set_cursor_icon` no longer breaks HiDPI scaling
-- On Windows, drag and drop is now optional and must be enabled with `WindowBuilderExtWindows::with_drag_and_drop(true)`.
+- On Windows, drag and drop is now optional (enabled by default) and can be disabled with `WindowBuilderExtWindows::with_drag_and_drop(false)`.
 - On Wayland, fix deadlock when calling to `set_inner_size` from a callback.
 - On macOS, add `hide__other_applications` to `EventLoopWindowTarget` via existing `EventLoopWindowTargetExtMacOS` trait. `hide_other_applications` will hide other applications by calling `-[NSApplication hideOtherApplications: nil]`.
 - On android added support for `run_return`.
@@ -81,7 +169,6 @@
 - On Web, replaced zero timeout for `ControlFlow::Poll` with `requestAnimationFrame`
 - On Web, fix a possible panic during event handling
 - On macOS, fix `EventLoopProxy` leaking memory for every instance.
-- On Windows, drag and drop can now be disabled with `WindowBuilderExtWindows::with_drag_and_drop(false)`.
 
 # 0.22.0 (2020-03-09)
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.23.0"
+version = "0.26.0"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 edition = "2018"
@@ -12,57 +12,60 @@ documentation = "https://docs.rs/winit"
 categories = ["gui"]
 
 [package.metadata.docs.rs]
-features = ["serde", "web-sys"]
+features = ["serde"]
 default-target = "x86_64-unknown-linux-gnu"
 targets = ["i686-pc-windows-msvc", "x86_64-pc-windows-msvc", "i686-unknown-linux-gnu", "x86_64-unknown-linux-gnu", "x86_64-apple-darwin", "wasm32-unknown-unknown"]
 
 [features]
-default = ["x11", "wayland"]
-web-sys = ["web_sys", "wasm-bindgen", "instant/wasm-bindgen"]
-stdweb = ["std_web", "instant/stdweb"]
-x11 = ["x11-dl"]
-wayland = ["wayland-client", "sctk"]
+default = ["x11", "wayland", "wayland-dlopen"]
+x11 = ["x11-dl", "mio", "percent-encoding", "parking_lot"]
+wayland = ["wayland-client", "wayland-protocols", "sctk"]
+wayland-dlopen = ["sctk/dlopen", "wayland-client/dlopen"]
 
 [dependencies]
-instant = "0.1"
+instant = { version = "0.1", features = ["wasm-bindgen"] }
 lazy_static = "1"
-libc = "0.2.64"
 log = "0.4"
 serde = { version = "1", optional = true, features = ["serde_derive"] }
-raw-window-handle = "0.3"
+raw-window-handle = "0.4.2"
 bitflags = "1"
+mint = { version = "0.5.6", optional = true }
 
 [dev-dependencies]
-image = "0.23"
+image = "0.23.12"
 simple_logger = "1.9"
 
 [target.'cfg(target_os = "android")'.dependencies]
-ndk = "0.2.0"
+ndk = "0.5"
 ndk-sys = "0.2.0"
-ndk-glue = "0.2.0"
+ndk-glue = "0.5"
 
-[target.'cfg(target_os = "ios")'.dependencies]
-objc = "0.2.3"
+[target.'cfg(any(target_os = "ios", target_os = "macos"))'.dependencies]
+objc = "0.2.7"
 
 [target.'cfg(target_os = "macos")'.dependencies]
-cocoa = "0.23"
+cocoa = "0.24"
 core-foundation = "0.9"
 core-graphics = "0.22"
 dispatch = "0.2.0"
-objc = "0.2.6"
+block = "0.1"
 
 [target.'cfg(target_os = "macos")'.dependencies.core-video-sys]
 version = "0.1.4"
 default_features = false
 features = ["display_link"]
 
+[target.'cfg(target_os = "windows")'.dependencies]
+parking_lot = "0.11"
+
 [target.'cfg(target_os = "windows")'.dependencies.winapi]
-version = "0.3.6"
+version = "0.3.9"
 features = [
     "combaseapi",
     "commctrl",
     "dwmapi",
     "errhandlingapi",
+    "imm",
     "hidusage",
     "libloaderapi",
     "objbase",
@@ -78,23 +81,23 @@ features = [
     "wingdi",
     "winnt",
     "winuser",
+    "mmsystem",
+    "timeapi"
 ]
 
 [target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.dependencies]
-wayland-client = { version = "0.28", features = [ "dlopen"] , optional = true }
-sctk = { package = "smithay-client-toolkit", version = "0.12", optional = true }
-mio = "0.6"
-mio-extras = "2.0"
+wayland-client = { version = "0.29", default_features = false,  features = ["use_system_lib"], optional = true }
+wayland-protocols = { version = "0.29", features = [ "staging_protocols"], optional = true }
+sctk = { package = "smithay-client-toolkit", version = "0.15.1", default_features = false, features = ["calloop"],  optional = true }
+mio = { version = "0.8", features = ["os-ext"], optional = true }
 x11-dl = { version = "2.18.5", optional = true }
-percent-encoding = "2.0"
-
-[target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd", target_os = "windows"))'.dependencies.parking_lot]
-version = "0.11"
+percent-encoding = { version = "2.0", optional = true }
+parking_lot = { version = "0.11.0", optional = true }
+libc = "0.2.64"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies.web_sys]
 package = "web-sys"
 version = "0.3.22"
-optional = true
 features = [
     'console',
     "AddEventListenerOptions",
@@ -120,13 +123,6 @@ features = [
 
 [target.'cfg(target_arch = "wasm32")'.dependencies.wasm-bindgen]
 version = "0.2.45"
-optional = true
-
-[target.'cfg(target_arch = "wasm32")'.dependencies.std_web]
-package = "stdweb"
-version = "=0.4.20"
-optional = true
-features = ["experimental_features_which_may_break_on_minor_version_bumps"]
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies]
 console_log = "0.2"

FEATURES.md

@@ -116,8 +116,9 @@ If your PR makes notable changes to Winit's features, please update this section
 ### Windows
 * Setting the taskbar icon
 * Setting the parent window
+* Setting a menu bar
 * `WS_EX_NOREDIRECTIONBITMAP` support
-* Theme the title bar according to Windows 10 Dark Mode setting
+* Theme the title bar according to Windows 10 Dark Mode setting or set a preferred theme
 
 ### macOS
 * Window activation policy
@@ -182,11 +183,9 @@ Legend:
 |Fullscreen                       |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |
 |Fullscreen toggle                |✔️     |✔️     |✔️         |✔️             |**N/A**|✔️     |✔️        |
 |Exclusive fullscreen             |✔️     |✔️     |✔️         |**N/A**         |❌    |✔️     |**N/A**|
-|HiDPI support                    |✔️     |✔️     |✔️         |✔️             |▢[#721]|✔️    |✔️ \*1|
+|HiDPI support                    |✔️     |✔️     |✔️         |✔️             |▢[#721]|✔️    |✔️    |
 |Popup windows                    |❌     |❌     |❌         |❌             |❌    |❌     |**N/A**|
 
-\*1: `WindowEvent::ScaleFactorChanged` is not sent on `stdweb` backend.
-
 ### System information
 |Feature          |Windows|MacOS |Linux x11|Linux Wayland|Android|iOS      |WASM      |
 |---------------- | ----- | ---- | ------- | ----------- | ----- | ------- | -------- |
@@ -202,12 +201,13 @@ Legend:
 |Cursor icon             |✔️       |✔️      |✔️       |✔️           |**N/A**|**N/A**|✔️        |
 |Touch events            |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |❌        |
 |Touch pressure          |✔️       |❌      |❌       |❌          |❌    |✔️     |❌        |
-|Multitouch              |✔️       |❌      |✔️       |✔️          |❓     |✔️     |❌        |
+|Multitouch              |✔️       |❌      |✔️       |✔️          |✔️    |✔️     |❌        |
 |Keyboard events         |✔️       |✔️      |✔️       |✔️          |❓     |❌     |✔️        |
 |Drag & Drop             |▢[#720]  |▢[#720] |▢[#720]  |❌[#306]    |**N/A**|**N/A**|❓        |
 |Raw Device Events       |▢[#750]  |▢[#750] |▢[#750]  |❌          |❌    |❌     |❓        |
 |Gamepad/Joystick events |❌[#804] |❌      |❌       |❌          |❌    |❌     |❓        |
 |Device movement events  |❓        |❓       |❓       |❓           |❌    |❌     |❓        |
+|Drag window with cursor |✔️         |✔️       |✔️        |✔️            |**N/A**|**N/A**|**N/A**   |
 
 ### Pending API Reworks
 Changes in the API that have been agreed upon but aren't implemented across all platforms.

HALL_OF_CHAMPIONS.md

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

README.md

@@ -6,7 +6,7 @@
 
 ```toml
 [dependencies]
-winit = "0.23.0"
+winit = "0.26.0"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -66,15 +66,13 @@ Winit provides the following features, which can be enabled in your `Cargo.toml`
 * `serde`: Enables serialization/deserialization of certain types with [Serde](https://crates.io/crates/serde).
 * `x11` (enabled by default): On Unix platform, compiles with the X11 backend
 * `wayland` (enabled by default): On Unix platform, compiles with the Wayland backend
+* `mint`: Enables mint (math interoperability standard types) conversions.
 
 ### Platform-specific usage
 
 #### WebAssembly
 
-Winit supports compiling to the `wasm32-unknown-unknown` target with either a
-`stdweb` or a `web-sys` backend for use on web browsers. However, please note
-that **the `stdweb` backend is being deprecated and may be removed in a future
-release of Winit**. The `web-sys` backend is also more feature complete.
+Winit supports compiling to the `wasm32-unknown-unknown` target with `web-sys`.
 
 On the web platform, a Winit window is backed by a `<canvas>` element. You can
 either [provide Winit with a `<canvas>` element][web with_canvas], or [let Winit
@@ -94,7 +92,18 @@ book].
 
 This library makes use of the [ndk-rs](https://github.com/rust-windowing/android-ndk-rs) crates, refer to that repo for more documentation.
 
+The `ndk_glue` version needs to match the version used by `winit`. Otherwise, the application will not start correctly as `ndk_glue`'s internal NativeActivity static is not the same due to version mismatch.
+
+`ndk_glue` <-> `winit` version comparison compatibility:
+
+| winit |       ndk_glue       |
+| :---: | :------------------: |
+| 0.24  | `ndk_glue = "0.2.0"` |
+| 0.25  | `ndk_glue = "0.3.0"` |
+| 0.26  | `ndk_glue = "0.5.0"` |
+
 Running on an Android device needs a dynamic system library, add this to Cargo.toml:
+
 ```toml
 [[example]]
 name = "request_redraw_threaded"
@@ -110,3 +119,13 @@ fn main() {
 ```
 
 And run the application with `cargo apk run --example request_redraw_threaded`
+
+#### MacOS
+
+To ensure compatibility with older MacOS systems, winit links to
+CGDisplayCreateUUIDFromDisplayID through the CoreGraphics framework.
+However, under certain setups this function is only available to be linked
+through the newer ColorSync framework. So, winit provides the
+`WINIT_LINK_COLORSYNC` environment variable which can be set to `1` or `true`
+while compiling to enable linking via ColorSync.
+

build.rs

@@ -1,21 +1,10 @@
-#[cfg(all(
-    any(
-        target_os = "linux",
-        target_os = "dragonfly",
-        target_os = "freebsd",
-        target_os = "netbsd",
-        target_os = "openbsd"
-    ),
-    not(feature = "x11"),
-    not(feature = "wayland")
-))]
-compile_error!("at least one of the \"x11\"/\"wayland\" features must be enabled");
-
-#[cfg(all(
-    target_arch = "wasm32",
-    not(feature = "web-sys"),
-    not(feature = "stdweb")
-))]
-compile_error!("at least one of the \"web-sys\"/\"stdweb\" features must be enabled");
-
-fn main() {}
+fn main() {
+    // If building for macos and WINIT_LINK_COLORSYNC is set to true
+    // use CGDisplayCreateUUIDFromDisplayID from ColorSync instead of CoreGraphics
+    if std::env::var("CARGO_CFG_TARGET_OS").map_or(false, |os| os == "macos")
+        && std::env::var("WINIT_LINK_COLORSYNC")
+            .map_or(false, |v| v == "1" || v.eq_ignore_ascii_case("true"))
+    {
+        println!("cargo:rustc-cfg=use_colorsync_cgdisplaycreateuuidfromdisplayid");
+    }
+}

examples/control_flow.rs

@@ -99,7 +99,7 @@ fn main() {
                         if wait_cancelled {
                             *control_flow
                         } else {
-                            ControlFlow::WaitUntil(time::Instant::now() + WAIT_TIME)
+                            ControlFlow::WaitUntil(instant::Instant::now() + WAIT_TIME)
                         }
                     }
                     Mode::Poll => {

examples/drag_window.rs

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

examples/fullscreen.rs

@@ -23,7 +23,6 @@ fn main() {
         _ => panic!("Please enter a valid number"),
     });
 
-    let mut is_maximized = false;
     let mut decorations = true;
 
     let window = WindowBuilder::new()
@@ -59,8 +58,8 @@ fn main() {
                         println!("window.fullscreen {:?}", window.fullscreen());
                     }
                     (VirtualKeyCode::M, ElementState::Pressed) => {
-                        is_maximized = !is_maximized;
-                        window.set_maximized(is_maximized);
+                        let is_maximized = window.is_maximized();
+                        window.set_maximized(!is_maximized);
                     }
                     (VirtualKeyCode::D, ElementState::Pressed) => {
                         decorations = !decorations;

examples/mouse_wheel.rs

@@ -0,0 +1,48 @@
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{DeviceEvent, Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::WindowBuilder,
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("Mouse Wheel events")
+        .build(&event_loop)
+        .unwrap();
+
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            Event::WindowEvent { event, .. } => match event {
+                WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
+                _ => (),
+            },
+            Event::DeviceEvent { event, .. } => match event {
+                DeviceEvent::MouseWheel { delta } => match delta {
+                    winit::event::MouseScrollDelta::LineDelta(x, y) => {
+                        println!("mouse wheel Line Delta: ({},{})", x, y);
+                        let pixels_per_line = 120.0;
+                        let mut pos = window.outer_position().unwrap();
+                        pos.x -= (x * pixels_per_line) as i32;
+                        pos.y -= (y * pixels_per_line) as i32;
+                        window.set_outer_position(pos)
+                    }
+                    winit::event::MouseScrollDelta::PixelDelta(p) => {
+                        println!("mouse wheel Pixel Delta: ({},{})", p.x, p.y);
+                        let mut pos = window.outer_position().unwrap();
+                        pos.x -= p.x as i32;
+                        pos.y -= p.y as i32;
+                        window.set_outer_position(pos)
+                    }
+                },
+                _ => (),
+            },
+            _ => (),
+        }
+    });
+}

examples/request_redraw_threaded.rs

@@ -7,6 +7,7 @@ use winit::{
     window::WindowBuilder,
 };
 
+#[cfg(not(target_arch = "wasm32"))]
 fn main() {
     SimpleLogger::new().init().unwrap();
     let event_loop = EventLoop::new();
@@ -38,3 +39,8 @@ fn main() {
         }
     });
 }
+
+#[cfg(target_arch = "wasm32")]
+fn main() {
+    unimplemented!() // `Window` can't be sent between threads
+}

examples/set_ime_position.rs

@@ -0,0 +1,54 @@
+use simple_logger::SimpleLogger;
+use winit::{
+    dpi::PhysicalPosition,
+    event::{ElementState, Event, WindowEvent},
+    event_loop::{ControlFlow, EventLoop},
+    window::WindowBuilder,
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new().build(&event_loop).unwrap();
+    window.set_title("A fantastic window!");
+
+    println!("Ime position will system default");
+    println!("Click to set ime position to cursor's");
+
+    let mut cursor_position = PhysicalPosition::new(0.0, 0.0);
+    event_loop.run(move |event, _, control_flow| {
+        *control_flow = ControlFlow::Wait;
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CursorMoved { position, .. },
+                ..
+            } => {
+                cursor_position = position;
+            }
+            Event::WindowEvent {
+                event:
+                    WindowEvent::MouseInput {
+                        state: ElementState::Released,
+                        ..
+                    },
+                ..
+            } => {
+                println!(
+                    "Setting ime position to {}, {}",
+                    cursor_position.x, cursor_position.y
+                );
+                window.set_ime_position(cursor_position);
+            }
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => {
+                *control_flow = ControlFlow::Exit;
+                return;
+            }
+            _ => (),
+        }
+    });
+}

examples/web.rs

@@ -12,7 +12,7 @@ pub fn main() {
         .build(&event_loop)
         .unwrap();
 
-    #[cfg(feature = "web-sys")]
+    #[cfg(target_arch = "wasm32")]
     {
         use winit::platform::web::WindowExtWebSys;
 
@@ -26,28 +26,12 @@ pub fn main() {
             .expect("Append canvas to HTML body");
     }
 
-    #[cfg(feature = "stdweb")]
-    {
-        use std_web::web::INode;
-        use winit::platform::web::WindowExtStdweb;
-
-        let canvas = window.canvas();
-
-        let document = std_web::web::document();
-        let body: std_web::web::Node = document.body().expect("Get HTML body").into();
-
-        body.append_child(&canvas);
-    }
-
     event_loop.run(move |event, _, control_flow| {
         *control_flow = ControlFlow::Wait;
 
-        #[cfg(feature = "web-sys")]
+        #[cfg(target_arch = "wasm32")]
         log::debug!("{:?}", event);
 
-        #[cfg(feature = "stdweb")]
-        std_web::console!(log, "%s", format!("{:?}", event));
-
         match event {
             Event::WindowEvent {
                 event: WindowEvent::CloseRequested,
@@ -61,7 +45,7 @@ pub fn main() {
     });
 }
 
-#[cfg(feature = "web-sys")]
+#[cfg(target_arch = "wasm32")]
 mod wasm {
     use wasm_bindgen::prelude::*;
 

examples/window_debug.rs

@@ -28,7 +28,6 @@ fn main() {
     eprintln!("  (X) Toggle maximized");
 
     let mut minimized = false;
-    let mut maximized = false;
     let mut visible = true;
 
     event_loop.run(move |event, _, control_flow| {
@@ -109,8 +108,8 @@ fn main() {
                         window.set_visible(visible);
                     }
                     VirtualKeyCode::X => {
-                        maximized = !maximized;
-                        window.set_maximized(maximized);
+                        let is_maximized = window.is_maximized();
+                        window.set_maximized(!is_maximized);
                     }
                     _ => (),
                 },

examples/window_icon.rs

@@ -49,7 +49,7 @@ fn load_icon(path: &Path) -> Icon {
     let (icon_rgba, icon_width, icon_height) = {
         let image = image::open(path)
             .expect("Failed to open icon path")
-            .into_rgba();
+            .into_rgba8();
         let (width, height) = image.dimensions();
         let rgba = image.into_raw();
         (rgba, width, height)

examples/window_run_return.rs

@@ -15,7 +15,7 @@ fn main() {
     use winit::{
         event::{Event, WindowEvent},
         event_loop::{ControlFlow, EventLoop},
-        platform::desktop::EventLoopExtDesktop,
+        platform::run_return::EventLoopExtRunReturn,
         window::WindowBuilder,
     };
     let mut event_loop = EventLoop::new();

src/dpi.rs

@@ -58,7 +58,7 @@
 //! 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`](crate::event::WindowEvent::ScaleFactorChanged) event,
-//! then its scale factor is `1.0`.
+//! then its scale factor can be found by calling [window.scale_factor()].
 //!
 //! ## How is the scale factor calculated?
 //!
@@ -69,9 +69,10 @@
 //!   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:** "retina displays" have a scale factor of 2.0. Otherwise, the scale factor is 1.0.
-//!   Intermediate scale factors are never used. It's possible for any display to use that 2.0 scale
-//!   factor, given the use of the command line.
+//! - **macOS:** Recent versions of macOS allow the user to change the scaling factor for certain
+//!   displays. When this is available, the user may pick a per-monitor scaling factor from a set
+//!   of pre-defined settings. All "retina displays" have a scaling factor above 1.0 by default but
+//!   the specific value varies across devices.
 //! - **X11:** Many man-hours have been spent trying to figure out how to handle DPI in X11. Winit
 //!   currently uses a three-pronged approach:
 //!   + Use the value in the `WINIT_X11_SCALE_FACTOR` environment variable, if present.
@@ -94,6 +95,7 @@
 //!
 //! [points]: https://en.wikipedia.org/wiki/Point_(typography)
 //! [picas]: https://en.wikipedia.org/wiki/Pica_(typography)
+//! [window.scale_factor()]: crate::window::Window::scale_factor
 //! [windows_1]: https://docs.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows
 //! [apple_1]: https://developer.apple.com/library/archive/documentation/DeviceInformation/Reference/iOSDeviceCompatibility/Displays/Displays.html
 //! [apple_2]: https://developer.apple.com/design/human-interface-guidelines/macos/icons-and-images/image-size-and-resolution/
@@ -163,7 +165,7 @@ pub fn validate_scale_factor(scale_factor: f64) -> bool {
 /// The position is stored as floats, so please be careful. Casting floats to integers truncates the
 /// fractional part, which can cause noticable issues. To help with that, an `Into<(i32, i32)>`
 /// implementation is provided which does the rounding for you.
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct LogicalPosition<P> {
     pub x: P,
@@ -209,9 +211,9 @@ impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalPosition<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> Into<(X, X)> for LogicalPosition<P> {
-    fn into(self: Self) -> (X, X) {
-        (self.x.cast(), self.y.cast())
+impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for (X, X) {
+    fn from(p: LogicalPosition<P>) -> (X, X) {
+        (p.x.cast(), p.y.cast())
     }
 }
 
@@ -221,14 +223,28 @@ impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalPosition<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> Into<[X; 2]> for LogicalPosition<P> {
-    fn into(self: Self) -> [X; 2] {
-        [self.x.cast(), self.y.cast()]
+impl<P: Pixel, X: Pixel> From<LogicalPosition<P>> for [X; 2] {
+    fn from(p: LogicalPosition<P>) -> [X; 2] {
+        [p.x.cast(), p.y.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Point2<P>> for LogicalPosition<P> {
+    fn from(p: mint::Point2<P>) -> Self {
+        Self::new(p.x, p.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<LogicalPosition<P>> for mint::Point2<P> {
+    fn from(p: LogicalPosition<P>) -> Self {
+        mint::Point2 { x: p.x, y: p.y }
     }
 }
 
 /// A position represented in physical pixels.
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PhysicalPosition<P> {
     pub x: P,
@@ -274,9 +290,9 @@ impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalPosition<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> Into<(X, X)> for PhysicalPosition<P> {
-    fn into(self: Self) -> (X, X) {
-        (self.x.cast(), self.y.cast())
+impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for (X, X) {
+    fn from(p: PhysicalPosition<P>) -> (X, X) {
+        (p.x.cast(), p.y.cast())
     }
 }
 
@@ -286,14 +302,28 @@ impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalPosition<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> Into<[X; 2]> for PhysicalPosition<P> {
-    fn into(self: Self) -> [X; 2] {
-        [self.x.cast(), self.y.cast()]
+impl<P: Pixel, X: Pixel> From<PhysicalPosition<P>> for [X; 2] {
+    fn from(p: PhysicalPosition<P>) -> [X; 2] {
+        [p.x.cast(), p.y.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Point2<P>> for PhysicalPosition<P> {
+    fn from(p: mint::Point2<P>) -> Self {
+        Self::new(p.x, p.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<PhysicalPosition<P>> for mint::Point2<P> {
+    fn from(p: PhysicalPosition<P>) -> Self {
+        mint::Point2 { x: p.x, y: p.y }
     }
 }
 
 /// A size represented in logical pixels.
-#[derive(Debug, Copy, Clone, PartialEq)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct LogicalSize<P> {
     pub width: P,
@@ -339,9 +369,9 @@ impl<P: Pixel, X: Pixel> From<(X, X)> for LogicalSize<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> Into<(X, X)> for LogicalSize<P> {
-    fn into(self: LogicalSize<P>) -> (X, X) {
-        (self.width.cast(), self.height.cast())
+impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for (X, X) {
+    fn from(s: LogicalSize<P>) -> (X, X) {
+        (s.width.cast(), s.height.cast())
     }
 }
 
@@ -351,14 +381,31 @@ impl<P: Pixel, X: Pixel> From<[X; 2]> for LogicalSize<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> Into<[X; 2]> for LogicalSize<P> {
-    fn into(self: Self) -> [X; 2] {
-        [self.width.cast(), self.height.cast()]
+impl<P: Pixel, X: Pixel> From<LogicalSize<P>> for [X; 2] {
+    fn from(s: LogicalSize<P>) -> [X; 2] {
+        [s.width.cast(), s.height.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Vector2<P>> for LogicalSize<P> {
+    fn from(v: mint::Vector2<P>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<LogicalSize<P>> for mint::Vector2<P> {
+    fn from(s: LogicalSize<P>) -> Self {
+        mint::Vector2 {
+            x: s.width,
+            y: s.height,
+        }
     }
 }
 
 /// A size represented in physical pixels.
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Default, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PhysicalSize<P> {
     pub width: P,
@@ -401,9 +448,9 @@ impl<P: Pixel, X: Pixel> From<(X, X)> for PhysicalSize<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> Into<(X, X)> for PhysicalSize<P> {
-    fn into(self: Self) -> (X, X) {
-        (self.width.cast(), self.height.cast())
+impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for (X, X) {
+    fn from(s: PhysicalSize<P>) -> (X, X) {
+        (s.width.cast(), s.height.cast())
     }
 }
 
@@ -413,9 +460,26 @@ impl<P: Pixel, X: Pixel> From<[X; 2]> for PhysicalSize<P> {
     }
 }
 
-impl<P: Pixel, X: Pixel> Into<[X; 2]> for PhysicalSize<P> {
-    fn into(self: Self) -> [X; 2] {
-        [self.width.cast(), self.height.cast()]
+impl<P: Pixel, X: Pixel> From<PhysicalSize<P>> for [X; 2] {
+    fn from(s: PhysicalSize<P>) -> [X; 2] {
+        [s.width.cast(), s.height.cast()]
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<mint::Vector2<P>> for PhysicalSize<P> {
+    fn from(v: mint::Vector2<P>) -> Self {
+        Self::new(v.x, v.y)
+    }
+}
+
+#[cfg(feature = "mint")]
+impl<P: Pixel> From<PhysicalSize<P>> for mint::Vector2<P> {
+    fn from(s: PhysicalSize<P>) -> Self {
+        mint::Vector2 {
+            x: s.width,
+            y: s.height,
+        }
     }
 }
 

src/event.rs

@@ -113,7 +113,7 @@ pub enum Event<'a, T: 'static> {
 
     /// Emitted when the event loop is being shut down.
     ///
-    /// This is irreversable - if this event is emitted, it is guaranteed to be the last event that
+    /// This is irreversible - if this event is emitted, it is guaranteed to be the last event that
     /// gets emitted. You generally want to treat this as an "do on quit" event.
     LoopDestroyed,
 }
@@ -131,7 +131,7 @@ impl<T: Clone> Clone for Event<'static, T> {
                 device_id: *device_id,
                 event: event.clone(),
             },
-            NewEvents(cause) => NewEvents(cause.clone()),
+            NewEvents(cause) => NewEvents(*cause),
             MainEventsCleared => MainEventsCleared,
             RedrawRequested(wid) => RedrawRequested(*wid),
             RedrawEventsCleared => RedrawEventsCleared,
@@ -358,8 +358,8 @@ impl Clone for WindowEvent<'static> {
     fn clone(&self) -> Self {
         use self::WindowEvent::*;
         return match self {
-            Resized(size) => Resized(size.clone()),
-            Moved(pos) => Moved(pos.clone()),
+            Resized(size) => Resized(*size),
+            Moved(pos) => Moved(*pos),
             CloseRequested => CloseRequested,
             Destroyed => Destroyed,
             DroppedFile(file) => DroppedFile(file.clone()),
@@ -377,7 +377,7 @@ impl Clone for WindowEvent<'static> {
                 is_synthetic: *is_synthetic,
             },
 
-            ModifiersChanged(modifiers) => ModifiersChanged(modifiers.clone()),
+            ModifiersChanged(modifiers) => ModifiersChanged(*modifiers),
             #[allow(deprecated)]
             CursorMoved {
                 device_id,
@@ -437,7 +437,7 @@ impl Clone for WindowEvent<'static> {
                 value: *value,
             },
             Touch(touch) => Touch(*touch),
-            ThemeChanged(theme) => ThemeChanged(theme.clone()),
+            ThemeChanged(theme) => ThemeChanged(*theme),
             ScaleFactorChanged { .. } => {
                 unreachable!("Static event can't be about scale factor changing")
             }
@@ -538,12 +538,16 @@ impl<'a> WindowEvent<'a> {
 pub struct DeviceId(pub(crate) platform_impl::DeviceId);
 
 impl DeviceId {
-    /// Returns a dummy `DeviceId`, useful for unit testing. The only guarantee made about the return
-    /// value of this function is that it will always be equal to itself and to future values returned
-    /// by this function.  No other guarantees are made. This may be equal to a real `DeviceId`.
+    /// Returns a dummy `DeviceId`, useful for unit testing.
+    ///
+    /// # Safety
+    ///
+    /// The only guarantee made about the return value of this function is that
+    /// it will always be equal to itself and to future values returned by this function.
+    /// No other guarantees are made. This may be equal to a real `DeviceId`.
     ///
     /// **Passing this into a winit function will result in undefined behavior.**
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         DeviceId(platform_impl::DeviceId::dummy())
     }
 }
@@ -745,7 +749,7 @@ pub enum MouseButton {
     Left,
     Right,
     Middle,
-    Other(u8),
+    Other(u16),
 }
 
 /// Describes a difference in the mouse scroll wheel state.
@@ -998,9 +1002,9 @@ bitflags! {
         // left and right modifiers are currently commented out, but we should be able to support
         // them in a future release
         /// The "shift" key.
-        const SHIFT = 0b100 << 0;
-        // const LSHIFT = 0b010 << 0;
-        // const RSHIFT = 0b001 << 0;
+        const SHIFT = 0b100;
+        // const LSHIFT = 0b010;
+        // const RSHIFT = 0b001;
         /// The "control" key.
         const CTRL = 0b100 << 3;
         // const LCTRL = 0b010 << 3;

src/lib.rs

@@ -35,10 +35,10 @@
 //! entire program terminates.
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
-//! model, since that can't be implemented properly on web and mobile platforms and works poorly on
-//! most desktop platforms. However, this model can be re-implemented to an extent on desktops with
-//! [`EventLoopExtDesktop::run_return`]. See that method's documentation for more reasons about why
-//! it's discouraged, beyond mobile/web compatibility reasons.
+//! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works poorly on
+//! most other platforms. However, this model can be re-implemented to an extent with
+//! [`EventLoopExtRunReturn::run_return`]. See that method's documentation for more reasons about why
+//! it's discouraged, beyond compatibility reasons.
 //!
 //!
 //! ```no_run
@@ -109,7 +109,7 @@
 //! window visible only once you're ready to render into it.
 //!
 //! [`EventLoop`]: event_loop::EventLoop
-//! [`EventLoopExtDesktop::run_return`]: ./platform/desktop/trait.EventLoopExtDesktop.html#tymethod.run_return
+//! [`EventLoopExtRunReturn::run_return`]: ./platform/run_return/trait.EventLoopExtRunReturn.html#tymethod.run_return
 //! [`EventLoop::new()`]: event_loop::EventLoop::new
 //! [event_loop_run]: event_loop::EventLoop::run
 //! [`ControlFlow`]: event_loop::ControlFlow
@@ -130,7 +130,7 @@
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 
 #![deny(rust_2018_idioms)]
-#![deny(intra_doc_link_resolution_failure)]
+#![deny(rustdoc::broken_intra_doc_links)]
 
 #[allow(unused_imports)]
 #[macro_use]
@@ -146,8 +146,6 @@ extern crate bitflags;
 #[cfg(any(target_os = "macos", target_os = "ios"))]
 #[macro_use]
 extern crate objc;
-#[cfg(all(target_arch = "wasm32", feature = "std_web"))]
-extern crate std_web as stdweb;
 
 pub mod dpi;
 #[macro_use]

src/platform/macos.rs

@@ -4,31 +4,12 @@ use std::os::raw::c_void;
 
 use crate::{
     dpi::LogicalSize,
-    event_loop::EventLoopWindowTarget,
+    event_loop::{EventLoop, EventLoopWindowTarget},
     monitor::MonitorHandle,
+    platform_impl::get_aux_state_mut,
     window::{Window, WindowBuilder},
 };
 
-/// Corresponds to `NSRequestUserAttentionType`.
-#[derive(Debug, Clone, Copy, PartialEq)]
-pub enum RequestUserAttentionType {
-    /// Corresponds to `NSCriticalRequest`.
-    ///
-    /// Dock icon will bounce until the application is focused.
-    Critical,
-
-    /// Corresponds to `NSInformationalRequest`.
-    ///
-    /// Dock icon will bounce once.
-    Informational,
-}
-
-impl Default for RequestUserAttentionType {
-    fn default() -> Self {
-        RequestUserAttentionType::Critical
-    }
-}
-
 /// Additional methods on `Window` that are specific to MacOS.
 pub trait WindowExtMacOS {
     /// Returns a pointer to the cocoa `NSWindow` that is used by this window.
@@ -41,10 +22,6 @@ pub trait WindowExtMacOS {
     /// The pointer will become invalid when the `Window` is destroyed.
     fn ns_view(&self) -> *mut c_void;
 
-    /// Request user attention, causing the application's dock icon to bounce.
-    /// Note that this has no effect if the application is already focused.
-    fn request_user_attention(&self, request_type: RequestUserAttentionType);
-
     /// Returns whether or not the window is in simple fullscreen mode.
     fn simple_fullscreen(&self) -> bool;
 
@@ -75,11 +52,6 @@ impl WindowExtMacOS for Window {
         self.window.ns_view()
     }
 
-    #[inline]
-    fn request_user_attention(&self, request_type: RequestUserAttentionType) {
-        self.window.request_user_attention(request_type)
-    }
-
     #[inline]
     fn simple_fullscreen(&self) -> bool {
         self.window.simple_fullscreen()
@@ -129,8 +101,6 @@ impl Default for ActivationPolicy {
 ///  - `with_titlebar_buttons_hidden`
 ///  - `with_fullsize_content_view`
 pub trait WindowBuilderExtMacOS {
-    /// Sets the activation policy for the window being built.
-    fn with_activation_policy(self, activation_policy: ActivationPolicy) -> WindowBuilder;
     /// Enables click-and-drag behavior for the entire window, not just the titlebar.
     fn with_movable_by_window_background(self, movable_by_window_background: bool)
         -> WindowBuilder;
@@ -151,12 +121,6 @@ pub trait WindowBuilderExtMacOS {
 }
 
 impl WindowBuilderExtMacOS for WindowBuilder {
-    #[inline]
-    fn with_activation_policy(mut self, activation_policy: ActivationPolicy) -> WindowBuilder {
-        self.platform_specific.activation_policy = activation_policy;
-        self
-    }
-
     #[inline]
     fn with_movable_by_window_background(
         mut self,
@@ -215,6 +179,39 @@ impl WindowBuilderExtMacOS for WindowBuilder {
     }
 }
 
+pub trait EventLoopExtMacOS {
+    /// Sets the activation policy for the application. It is set to
+    /// `NSApplicationActivationPolicyRegular` by default.
+    ///
+    /// This function only takes effect if it's called before calling [`run`](crate::event_loop::EventLoop::run) or
+    /// [`run_return`](crate::platform::run_return::EventLoopExtRunReturn::run_return)
+    fn set_activation_policy(&mut self, activation_policy: ActivationPolicy);
+
+    /// Used to prevent a default menubar menu from getting created
+    ///
+    /// The default menu creation is enabled by default.
+    ///
+    /// This function only takes effect if it's called before calling
+    /// [`run`](crate::event_loop::EventLoop::run) or
+    /// [`run_return`](crate::platform::run_return::EventLoopExtRunReturn::run_return)
+    fn enable_default_menu_creation(&mut self, enable: bool);
+}
+impl<T> EventLoopExtMacOS for EventLoop<T> {
+    #[inline]
+    fn set_activation_policy(&mut self, activation_policy: ActivationPolicy) {
+        unsafe {
+            get_aux_state_mut(&**self.event_loop.delegate).activation_policy = activation_policy;
+        }
+    }
+
+    #[inline]
+    fn enable_default_menu_creation(&mut self, enable: bool) {
+        unsafe {
+            get_aux_state_mut(&**self.event_loop.delegate).create_default_menu = enable;
+        }
+    }
+}
+
 /// Additional methods on `MonitorHandle` that are specific to MacOS.
 pub trait MonitorHandleExtMacOS {
     /// Returns the identifier of the monitor for Cocoa.
@@ -244,14 +241,10 @@ pub trait EventLoopWindowTargetExtMacOS {
 
 impl<T> EventLoopWindowTargetExtMacOS for EventLoopWindowTarget<T> {
     fn hide_application(&self) {
-        let cls = objc::runtime::Class::get("NSApplication").unwrap();
-        let app: cocoa::base::id = unsafe { msg_send![cls, sharedApplication] };
-        unsafe { msg_send![app, hide: 0] }
+        self.p.hide_application()
     }
 
     fn hide_other_applications(&self) {
-        let cls = objc::runtime::Class::get("NSApplication").unwrap();
-        let app: cocoa::base::id = unsafe { msg_send![cls, sharedApplication] };
-        unsafe { msg_send![app, hideOtherApplications: 0] }
+        self.p.hide_other_applications()
     }
 }

src/platform/mod.rs

@@ -11,7 +11,7 @@
 //!
 //! And the following platform-specific module:
 //!
-//! - `desktop` (available on `windows`, `unix`, and `macos`)
+//! - `run_return` (available on `windows`, `unix`, `macos`, and `android`)
 //!
 //! However only the module corresponding to the platform you're compiling to will be available.
 
@@ -21,5 +21,5 @@ pub mod macos;
 pub mod unix;
 pub mod windows;
 
-pub mod desktop;
+pub mod run_return;
 pub mod web;

src/platform/run_return.rs

@@ -14,8 +14,8 @@ use crate::{
     event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
 };
 
-/// Additional methods on `EventLoop` that are specific to desktop platforms.
-pub trait EventLoopExtDesktop {
+/// Additional methods on `EventLoop` to return control flow to the caller.
+pub trait EventLoopExtRunReturn {
     /// A type provided by the user that can be passed through `Event::UserEvent`.
     type UserEvent;
 
@@ -25,12 +25,12 @@ pub trait EventLoopExtDesktop {
     /// control flow to the caller when `control_flow` is set to `ControlFlow::Exit`.
     ///
     /// # Caveats
-    /// Despite its apperance at first glance, this is *not* a perfect replacement for
+    /// Despite its appearance at first glance, this is *not* a perfect replacement for
     /// `poll_events`. For example, this function will not return on Windows or macOS while a
     /// window is getting resized, resulting in all application logic outside of the
     /// `event_handler` closure not running until the resize operation ends. Other OS operations
     /// may also result in such freezes. This behavior is caused by fundamental limitations in the
-    /// underyling OS APIs, which cannot be hidden by Winit without severe stability reprecussions.
+    /// underlying OS APIs, which cannot be hidden by `winit` without severe stability repercussions.
     ///
     /// You are strongly encouraged to use `run`, unless the use of this is absolutely necessary.
     fn run_return<F>(&mut self, event_handler: F)
@@ -42,7 +42,7 @@ pub trait EventLoopExtDesktop {
         );
 }
 
-impl<T> EventLoopExtDesktop for EventLoop<T> {
+impl<T> EventLoopExtRunReturn for EventLoop<T> {
     type UserEvent = T;
 
     fn run_return<F>(&mut self, event_handler: F)

src/platform/unix.rs

@@ -213,10 +213,6 @@ pub trait WindowExtUnix {
     #[cfg(feature = "x11")]
     fn xlib_xconnection(&self) -> Option<Arc<XConnection>>;
 
-    /// Set window urgency hint (`XUrgencyHint`). Only relevant on X.
-    #[cfg(feature = "x11")]
-    fn set_urgent(&self, is_urgent: bool);
-
     /// This function returns the underlying `xcb_connection_t` of an xlib `Display`.
     ///
     /// Returns `None` if the window doesn't use xlib (if it uses wayland for example).
@@ -241,10 +237,6 @@ pub trait WindowExtUnix {
     #[cfg(feature = "wayland")]
     fn wayland_display(&self) -> Option<*mut raw::c_void>;
 
-    /// Sets the color theme of the client side window decorations on wayland
-    #[cfg(feature = "wayland")]
-    fn set_wayland_theme<T: Theme>(&self, theme: T);
-
     /// Check if the window is ready for drawing
     ///
     /// It is a remnant of a previous implementation detail for the
@@ -297,16 +289,6 @@ impl WindowExtUnix for Window {
         }
     }
 
-    #[inline]
-    #[cfg(feature = "x11")]
-    fn set_urgent(&self, is_urgent: bool) {
-        match self.window {
-            LinuxWindow::X(ref w) => w.set_urgent(is_urgent),
-            #[cfg(feature = "wayland")]
-            _ => (),
-        }
-    }
-
     #[inline]
     #[cfg(feature = "x11")]
     fn xcb_connection(&self) -> Option<*mut raw::c_void> {
@@ -337,16 +319,6 @@ impl WindowExtUnix for Window {
         }
     }
 
-    #[inline]
-    #[cfg(feature = "wayland")]
-    fn set_wayland_theme<T: Theme>(&self, theme: T) {
-        match self.window {
-            LinuxWindow::Wayland(ref w) => w.set_theme(theme),
-            #[cfg(feature = "x11")]
-            _ => {}
-        }
-    }
-
     #[inline]
     fn is_ready(&self) -> bool {
         true
@@ -468,78 +440,3 @@ impl MonitorHandleExtUnix for MonitorHandle {
         self.inner.native_identifier()
     }
 }
-
-/// A theme for a Wayland's client side decorations.
-#[cfg(feature = "wayland")]
-pub trait Theme: Send + 'static {
-    /// Title bar color.
-    fn element_color(&self, element: Element, window_active: bool) -> ARGBColor;
-
-    /// Color for a given button part.
-    fn button_color(
-        &self,
-        button: Button,
-        state: ButtonState,
-        foreground: bool,
-        window_active: bool,
-    ) -> ARGBColor;
-
-    /// Font name and the size for the title bar.
-    ///
-    /// By default the font is `sans-serif` at the size of 11.
-    ///
-    /// Returning `None` means that title won't be drawn.
-    fn font(&self) -> Option<(String, f32)> {
-        // Not having any title isn't something desirable for the users, so setting it to
-        // something generic.
-        Some((String::from("sans-serif"), 11.))
-    }
-}
-
-/// A button on Wayland's client side decorations.
-#[cfg(feature = "wayland")]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Button {
-    /// Button that maximizes the window.
-    Maximize,
-
-    /// Button that minimizes the window.
-    Minimize,
-
-    /// Button that closes the window.
-    Close,
-}
-
-/// A button state of the button on Wayland's client side decorations.
-#[cfg(feature = "wayland")]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum ButtonState {
-    /// Button is being hovered over by pointer.
-    Hovered,
-    /// Button is not being hovered over by pointer.
-    Idle,
-    /// Button is disabled.
-    Disabled,
-}
-
-#[cfg(feature = "wayland")]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Element {
-    /// Bar itself.
-    Bar,
-
-    /// Separator between window and title bar.
-    Separator,
-
-    /// Title bar text.
-    Text,
-}
-
-#[cfg(feature = "wayland")]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct ARGBColor {
-    pub a: u8,
-    pub r: u8,
-    pub g: u8,
-    pub b: u8,
-}

src/platform/web.rs

@@ -1,28 +1,14 @@
 #![cfg(target_arch = "wasm32")]
 
 //! The web target does not automatically insert the canvas element object into the web page, to
-//! allow end users to determine how the page should be laid out. Use the `WindowExtStdweb` or
-//! `WindowExtWebSys` traits (depending on your web backend) to retrieve the canvas from the
-//! Window. Alternatively, use the `WindowBuilderExtStdweb` or `WindowBuilderExtWebSys` to provide
-//! your own canvas.
+//! allow end users to determine how the page should be laid out. Use the `WindowExtWebSys` trait
+//! to retrieve the canvas from the Window. Alternatively, use the `WindowBuilderExtWebSys` trait
+//! to provide your own canvas.
 
 use crate::window::WindowBuilder;
 
-#[cfg(feature = "stdweb")]
-use stdweb::web::html_element::CanvasElement;
-
-#[cfg(feature = "stdweb")]
-pub trait WindowExtStdweb {
-    fn canvas(&self) -> CanvasElement;
-
-    /// Whether the browser reports the preferred color scheme to be "dark".
-    fn is_dark_mode(&self) -> bool;
-}
-
-#[cfg(feature = "web-sys")]
 use web_sys::HtmlCanvasElement;
 
-#[cfg(feature = "web-sys")]
 pub trait WindowExtWebSys {
     fn canvas(&self) -> HtmlCanvasElement;
 
@@ -30,26 +16,10 @@ pub trait WindowExtWebSys {
     fn is_dark_mode(&self) -> bool;
 }
 
-#[cfg(feature = "stdweb")]
-pub trait WindowBuilderExtStdweb {
-    fn with_canvas(self, canvas: Option<CanvasElement>) -> Self;
-}
-
-#[cfg(feature = "stdweb")]
-impl WindowBuilderExtStdweb for WindowBuilder {
-    fn with_canvas(mut self, canvas: Option<CanvasElement>) -> Self {
-        self.platform_specific.canvas = canvas;
-
-        self
-    }
-}
-
-#[cfg(feature = "web-sys")]
 pub trait WindowBuilderExtWebSys {
     fn with_canvas(self, canvas: Option<HtmlCanvasElement>) -> Self;
 }
 
-#[cfg(feature = "web-sys")]
 impl WindowBuilderExtWebSys for WindowBuilder {
     fn with_canvas(mut self, canvas: Option<HtmlCanvasElement>) -> Self {
         self.platform_specific.canvas = canvas;

src/platform/windows.rs

@@ -3,17 +3,16 @@
 use std::os::raw::c_void;
 use std::path::Path;
 
-use libc;
 use winapi::shared::minwindef::WORD;
-use winapi::shared::windef::HWND;
+use winapi::shared::windef::{HMENU, HWND};
 
 use crate::{
     dpi::PhysicalSize,
     event::DeviceId,
     event_loop::EventLoop,
     monitor::MonitorHandle,
-    platform_impl::{EventLoop as WindowsEventLoop, WinIcon},
-    window::{BadIcon, Icon, Window, WindowBuilder},
+    platform_impl::{EventLoop as WindowsEventLoop, Parent, WinIcon},
+    window::{BadIcon, Icon, Theme, Window, WindowBuilder},
 };
 
 /// Additional methods on `EventLoop` that are specific to Windows.
@@ -72,46 +71,92 @@ impl<T> EventLoopExtWindows for EventLoop<T> {
 /// Additional methods on `Window` that are specific to Windows.
 pub trait WindowExtWindows {
     /// Returns the HINSTANCE of the window
-    fn hinstance(&self) -> *mut libc::c_void;
+    fn hinstance(&self) -> *mut c_void;
     /// Returns the native handle that is used by this window.
     ///
     /// The pointer will become invalid when the native window was destroyed.
-    fn hwnd(&self) -> *mut libc::c_void;
+    fn hwnd(&self) -> *mut c_void;
+
+    /// Enables or disables mouse and keyboard input to the specified window.
+    ///
+    /// A window must be enabled before it can be activated.
+    /// If an application has create a modal dialog box by disabling its owner window
+    /// (as described in [`WindowBuilderExtWindows::with_owner_window`]), the application must enable
+    /// the owner window before destroying the dialog box.
+    /// Otherwise, another window will receive the keyboard focus and be activated.
+    ///
+    /// If a child window is disabled, it is ignored when the system tries to determine which
+    /// window should receive mouse messages.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-enablewindow#remarks>
+    /// and <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#disabled-windows>
+    fn set_enable(&self, enabled: bool);
 
     /// This sets `ICON_BIG`. A good ceiling here is 256x256.
     fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>);
 
-    /// Whether the system theme is currently Windows 10's "Dark Mode".
-    fn is_dark_mode(&self) -> bool;
+    /// Returns the current window theme.
+    fn theme(&self) -> Theme;
 }
 
 impl WindowExtWindows for Window {
     #[inline]
-    fn hinstance(&self) -> *mut libc::c_void {
+    fn hinstance(&self) -> *mut c_void {
         self.window.hinstance() as *mut _
     }
 
     #[inline]
-    fn hwnd(&self) -> *mut libc::c_void {
+    fn hwnd(&self) -> *mut c_void {
         self.window.hwnd() as *mut _
     }
 
+    #[inline]
+    fn set_enable(&self, enabled: bool) {
+        self.window.set_enable(enabled)
+    }
+
     #[inline]
     fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
         self.window.set_taskbar_icon(taskbar_icon)
     }
 
     #[inline]
-    fn is_dark_mode(&self) -> bool {
-        self.window.is_dark_mode()
+    fn theme(&self) -> Theme {
+        self.window.theme()
     }
 }
 
 /// Additional methods on `WindowBuilder` that are specific to Windows.
 pub trait WindowBuilderExtWindows {
     /// Sets a parent to the window to be created.
+    ///
+    /// A child window has the WS_CHILD style and is confined to the client area of its parent window.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#child-windows>
     fn with_parent_window(self, parent: HWND) -> WindowBuilder;
 
+    /// Set an owner to the window to be created. Can be used to create a dialog box, for example.
+    /// Can be used in combination with [`WindowExtWindows::set_enable(false)`](WindowExtWindows::set_enable)
+    /// on the owner window to create a modal dialog box.
+    ///
+    /// From MSDN:
+    /// - An owned window is always above its owner in the z-order.
+    /// - The system automatically destroys an owned window when its owner is destroyed.
+    /// - An owned window is hidden when its owner is minimized.
+    ///
+    /// For more information, see <https://docs.microsoft.com/en-us/windows/win32/winmsg/window-features#owned-windows>
+    fn with_owner_window(self, parent: HWND) -> WindowBuilder;
+
+    /// Sets a menu on the window to be created.
+    ///
+    /// Parent and menu are mutually exclusive; a child window cannot have a menu!
+    ///
+    /// The menu must have been manually created beforehand with [`winapi::um::winuser::CreateMenu`] or similar.
+    ///
+    /// Note: Dark mode cannot be supported for win32 menus, it's simply not possible to change how the menus look.
+    /// If you use this, it is recommended that you combine it with `with_theme(Some(Theme::Light))` to avoid a jarring effect.
+    fn with_menu(self, menu: HMENU) -> WindowBuilder;
+
     /// This sets `ICON_BIG`. A good ceiling here is 256x256.
     fn with_taskbar_icon(self, taskbar_icon: Option<Icon>) -> WindowBuilder;
 
@@ -123,14 +168,29 @@ pub trait WindowBuilderExtWindows {
     /// `COINIT_APARTMENTTHREADED`) on the same thread. Note that winit may still attempt to initialize
     /// COM API regardless of this option. Currently only fullscreen mode does that, but there may be more in the future.
     /// If you need COM API with `COINIT_MULTITHREADED` you must initialize it before calling any winit functions.
-    /// See https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks for more information.
+    /// See <https://docs.microsoft.com/en-us/windows/win32/api/objbase/nf-objbase-coinitialize#remarks> for more information.
     fn with_drag_and_drop(self, flag: bool) -> WindowBuilder;
+
+    /// Forces a theme or uses the system settings if `None` was provided.
+    fn with_theme(self, theme: Option<Theme>) -> WindowBuilder;
 }
 
 impl WindowBuilderExtWindows for WindowBuilder {
     #[inline]
     fn with_parent_window(mut self, parent: HWND) -> WindowBuilder {
-        self.platform_specific.parent = Some(parent);
+        self.platform_specific.parent = Parent::ChildOf(parent);
+        self
+    }
+
+    #[inline]
+    fn with_owner_window(mut self, parent: HWND) -> WindowBuilder {
+        self.platform_specific.parent = Parent::OwnedBy(parent);
+        self
+    }
+
+    #[inline]
+    fn with_menu(mut self, menu: HMENU) -> WindowBuilder {
+        self.platform_specific.menu = Some(menu);
         self
     }
 
@@ -151,6 +211,12 @@ impl WindowBuilderExtWindows for WindowBuilder {
         self.platform_specific.drag_and_drop = flag;
         self
     }
+
+    #[inline]
+    fn with_theme(mut self, theme: Option<Theme>) -> WindowBuilder {
+        self.platform_specific.preferred_theme = theme;
+        self
+    }
 }
 
 /// Additional methods on `MonitorHandle` that are specific to Windows.

src/platform_impl/android/mod.rs

@@ -8,10 +8,11 @@ use crate::{
 };
 use ndk::{
     configuration::Configuration,
-    event::{InputEvent, MotionAction},
+    event::{InputEvent, KeyAction, MotionAction},
     looper::{ForeignLooper, Poll, ThreadLooper},
 };
 use ndk_glue::{Event, Rect};
+use raw_window_handle::{AndroidNdkHandle, RawWindowHandle};
 use std::{
     collections::VecDeque,
     sync::{Arc, Mutex, RwLock},
@@ -19,24 +20,44 @@ use std::{
 };
 
 lazy_static! {
-    static ref CONFIG: RwLock<Configuration> = RwLock::new(Configuration::new());
+    static ref CONFIG: RwLock<Configuration> = RwLock::new(Configuration::from_asset_manager(
+        &ndk_glue::native_activity().asset_manager()
+    ));
+    // If this is `Some()` a `Poll::Wake` is considered an `EventSource::Internal` with the event
+    // contained in the `Option`. The event is moved outside of the `Option` replacing it with a
+    // `None`.
+    //
+    // This allows us to inject event into the event loop without going through `ndk-glue` and
+    // calling unsafe function that should only be called by Android.
+    static ref INTERNAL_EVENT: RwLock<Option<InternalEvent>> = RwLock::new(None);
+}
+
+enum InternalEvent {
+    RedrawRequested,
 }
 
 enum EventSource {
     Callback,
     InputQueue,
     User,
+    Internal(InternalEvent),
 }
 
 fn poll(poll: Poll) -> Option<EventSource> {
     match poll {
-        Poll::Event { data, .. } => match data as usize {
-            0 => Some(EventSource::Callback),
-            1 => Some(EventSource::InputQueue),
+        Poll::Event { ident, .. } => match ident {
+            ndk_glue::NDK_GLUE_LOOPER_EVENT_PIPE_IDENT => Some(EventSource::Callback),
+            ndk_glue::NDK_GLUE_LOOPER_INPUT_QUEUE_IDENT => Some(EventSource::InputQueue),
             _ => unreachable!(),
         },
         Poll::Timeout => None,
-        Poll::Wake => Some(EventSource::User),
+        Poll::Wake => Some(
+            INTERNAL_EVENT
+                .write()
+                .unwrap()
+                .take()
+                .map_or(EventSource::User, EventSource::Internal),
+        ),
         Poll::Callback => unreachable!(),
     }
 }
@@ -148,54 +169,126 @@ impl<T: 'static> EventLoop<T> {
                             );
                         }
                     }
+                    Event::WindowHasFocus => {
+                        call_event_handler!(
+                            event_handler,
+                            self.window_target(),
+                            control_flow,
+                            event::Event::WindowEvent {
+                                window_id: window::WindowId(WindowId),
+                                event: event::WindowEvent::Focused(true),
+                            }
+                        );
+                    }
+                    Event::WindowLostFocus => {
+                        call_event_handler!(
+                            event_handler,
+                            self.window_target(),
+                            control_flow,
+                            event::Event::WindowEvent {
+                                window_id: window::WindowId(WindowId),
+                                event: event::WindowEvent::Focused(false),
+                            }
+                        );
+                    }
                     _ => {}
                 },
                 Some(EventSource::InputQueue) => {
                     if let Some(input_queue) = ndk_glue::input_queue().as_ref() {
                         while let Some(event) = input_queue.get_event() {
-                            println!("event {:?}", event);
                             if let Some(event) = input_queue.pre_dispatch(event) {
+                                let mut handled = true;
                                 let window_id = window::WindowId(WindowId);
                                 let device_id = event::DeviceId(DeviceId);
                                 match &event {
                                     InputEvent::MotionEvent(motion_event) => {
                                         let phase = match motion_event.action() {
-                                            MotionAction::Down => Some(event::TouchPhase::Started),
-                                            MotionAction::Up => Some(event::TouchPhase::Ended),
+                                            MotionAction::Down | MotionAction::PointerDown => {
+                                                Some(event::TouchPhase::Started)
+                                            }
+                                            MotionAction::Up | MotionAction::PointerUp => {
+                                                Some(event::TouchPhase::Ended)
+                                            }
                                             MotionAction::Move => Some(event::TouchPhase::Moved),
                                             MotionAction::Cancel => {
                                                 Some(event::TouchPhase::Cancelled)
                                             }
-                                            _ => None, // TODO mouse events
+                                            _ => {
+                                                handled = false;
+                                                None // TODO mouse events
+                                            }
                                         };
-                                        let pointer = motion_event.pointer_at_index(0);
-                                        let location = PhysicalPosition {
-                                            x: pointer.x() as _,
-                                            y: pointer.y() as _,
-                                        };
-
                                         if let Some(phase) = phase {
-                                            let event = event::Event::WindowEvent {
-                                                window_id,
-                                                event: event::WindowEvent::Touch(event::Touch {
-                                                    device_id,
-                                                    phase,
-                                                    location,
-                                                    id: 0,
-                                                    force: None,
-                                                }),
+                                            let pointers: Box<
+                                                dyn Iterator<Item = ndk::event::Pointer<'_>>,
+                                            > = match phase {
+                                                event::TouchPhase::Started
+                                                | event::TouchPhase::Ended => Box::new(
+                                                    std::iter::once(motion_event.pointer_at_index(
+                                                        motion_event.pointer_index(),
+                                                    )),
+                                                ),
+                                                event::TouchPhase::Moved
+                                                | event::TouchPhase::Cancelled => {
+                                                    Box::new(motion_event.pointers())
+                                                }
                                             };
-                                            call_event_handler!(
-                                                event_handler,
-                                                self.window_target(),
-                                                control_flow,
-                                                event
-                                            );
+
+                                            for pointer in pointers {
+                                                let location = PhysicalPosition {
+                                                    x: pointer.x() as _,
+                                                    y: pointer.y() as _,
+                                                };
+                                                let event = event::Event::WindowEvent {
+                                                    window_id,
+                                                    event: event::WindowEvent::Touch(
+                                                        event::Touch {
+                                                            device_id,
+                                                            phase,
+                                                            location,
+                                                            id: pointer.pointer_id() as u64,
+                                                            force: None,
+                                                        },
+                                                    ),
+                                                };
+                                                call_event_handler!(
+                                                    event_handler,
+                                                    self.window_target(),
+                                                    control_flow,
+                                                    event
+                                                );
+                                            }
                                         }
                                     }
-                                    InputEvent::KeyEvent(_) => {} // TODO
+                                    InputEvent::KeyEvent(key) => {
+                                        let state = match key.action() {
+                                            KeyAction::Down => event::ElementState::Pressed,
+                                            KeyAction::Up => event::ElementState::Released,
+                                            _ => event::ElementState::Released,
+                                        };
+                                        #[allow(deprecated)]
+                                        let event = event::Event::WindowEvent {
+                                            window_id,
+                                            event: event::WindowEvent::KeyboardInput {
+                                                device_id,
+                                                input: event::KeyboardInput {
+                                                    scancode: key.scan_code() as u32,
+                                                    state,
+                                                    virtual_keycode: None,
+                                                    modifiers: event::ModifiersState::default(),
+                                                },
+                                                is_synthetic: false,
+                                            },
+                                        };
+                                        call_event_handler!(
+                                            event_handler,
+                                            self.window_target(),
+                                            control_flow,
+                                            event
+                                        );
+                                    }
                                 };
-                                input_queue.finish_event(event, true);
+                                input_queue.finish_event(event, handled);
                             }
                         }
                     }
@@ -211,6 +304,9 @@ impl<T: 'static> EventLoop<T> {
                         );
                     }
                 }
+                Some(EventSource::Internal(internal)) => match internal {
+                    InternalEvent::RedrawRequested => redraw = true,
+                },
                 None => {}
             }
 
@@ -350,7 +446,7 @@ impl<T: 'static> EventLoopWindowTarget<T> {
 pub struct WindowId;
 
 impl WindowId {
-    pub fn dummy() -> Self {
+    pub const fn dummy() -> Self {
         WindowId
     }
 }
@@ -359,7 +455,7 @@ impl WindowId {
 pub struct DeviceId;
 
 impl DeviceId {
-    pub fn dummy() -> Self {
+    pub const fn dummy() -> Self {
         DeviceId
     }
 }
@@ -406,7 +502,8 @@ impl Window {
     }
 
     pub fn request_redraw(&self) {
-        // TODO
+        *INTERNAL_EVENT.write().unwrap() = Some(InternalEvent::RedrawRequested);
+        ForeignLooper::for_thread().unwrap().wake();
     }
 
     pub fn inner_position(&self) -> Result<PhysicalPosition<i32>, error::NotSupportedError> {
@@ -447,6 +544,10 @@ impl Window {
 
     pub fn set_maximized(&self, _maximized: bool) {}
 
+    pub fn is_maximized(&self) -> bool {
+        false
+    }
+
     pub fn set_fullscreen(&self, _monitor: Option<window::Fullscreen>) {
         warn!("Cannot set fullscreen on Android");
     }
@@ -463,6 +564,10 @@ impl Window {
 
     pub fn set_ime_position(&self, _position: Position) {}
 
+    pub fn focus_window(&self) {}
+
+    pub fn request_user_attention(&self, _request_type: Option<window::UserAttentionType>) {}
+
     pub fn set_cursor_icon(&self, _: window::CursorIcon) {}
 
     pub fn set_cursor_position(&self, _: Position) -> Result<(), error::ExternalError> {
@@ -479,15 +584,20 @@ impl Window {
 
     pub fn set_cursor_visible(&self, _: bool) {}
 
-    pub fn raw_window_handle(&self) -> raw_window_handle::RawWindowHandle {
-        let a_native_window = if let Some(native_window) = ndk_glue::native_window().as_ref() {
-            unsafe { native_window.ptr().as_mut() as *mut _ as *mut _ }
+    pub fn drag_window(&self) -> Result<(), error::ExternalError> {
+        Err(error::ExternalError::NotSupported(
+            error::NotSupportedError::new(),
+        ))
+    }
+
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        let mut handle = AndroidNdkHandle::empty();
+        if let Some(native_window) = ndk_glue::native_window().as_ref() {
+            handle.a_native_window = unsafe { native_window.ptr().as_mut() as *mut _ as *mut _ }
         } else {
-            panic!("native window null");
+            panic!("Cannot get the native window, it's null and will always be null before Event::Resumed and after Event::Suspended. Make sure you only call this function between those events.");
         };
-        let mut handle = raw_window_handle::android::AndroidHandle::empty();
-        handle.a_native_window = a_native_window;
-        raw_window_handle::RawWindowHandle::Android(handle)
+        RawWindowHandle::AndroidNdk(handle)
     }
 
     pub fn config(&self) -> Configuration {

src/platform_impl/ios/mod.rs

@@ -91,7 +91,7 @@ pub struct DeviceId {
 }
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         DeviceId {
             uiscreen: std::ptr::null_mut(),
         }

src/platform_impl/ios/window.rs

@@ -1,4 +1,4 @@
-use raw_window_handle::{ios::IOSHandle, RawWindowHandle};
+use raw_window_handle::{RawWindowHandle, UiKitHandle};
 use std::{
     collections::VecDeque,
     ops::{Deref, DerefMut},
@@ -22,7 +22,9 @@ use crate::{
         },
         monitor, view, EventLoopWindowTarget, MonitorHandle,
     },
-    window::{CursorIcon, Fullscreen, WindowAttributes, WindowId as RootWindowId},
+    window::{
+        CursorIcon, Fullscreen, UserAttentionType, WindowAttributes, WindowId as RootWindowId,
+    },
 };
 
 pub struct Inner {
@@ -180,6 +182,10 @@ impl Inner {
         debug!("`Window::set_cursor_visible` is ignored on iOS")
     }
 
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
     pub fn set_minimized(&self, _minimized: bool) {
         warn!("`Window::set_minimized` is ignored on iOS")
     }
@@ -188,6 +194,11 @@ impl Inner {
         warn!("`Window::set_maximized` is ignored on iOS")
     }
 
+    pub fn is_maximized(&self) -> bool {
+        warn!("`Window::is_maximized` is ignored on iOS");
+        false
+    }
+
     pub fn set_fullscreen(&self, monitor: Option<Fullscreen>) {
         unsafe {
             let uiscreen = match monitor {
@@ -260,6 +271,14 @@ impl Inner {
         warn!("`Window::set_ime_position` is ignored on iOS")
     }
 
+    pub fn focus_window(&self) {
+        warn!("`Window::set_focus` is ignored on iOS")
+    }
+
+    pub fn request_user_attention(&self, _request_type: Option<UserAttentionType>) {
+        warn!("`Window::request_user_attention` is ignored on iOS")
+    }
+
     // Allow directly accessing the current monitor internally without unwrapping.
     fn current_monitor_inner(&self) -> RootMonitorHandle {
         unsafe {
@@ -288,13 +307,11 @@ impl Inner {
     }
 
     pub fn raw_window_handle(&self) -> RawWindowHandle {
-        let handle = IOSHandle {
-            ui_window: self.window as _,
-            ui_view: self.view as _,
-            ui_view_controller: self.view_controller as _,
-            ..IOSHandle::empty()
-        };
-        RawWindowHandle::IOS(handle)
+        let mut handle = UiKitHandle::empty();
+        handle.ui_window = self.window as _;
+        handle.ui_view = self.view as _;
+        handle.ui_view_controller = self.view_controller as _;
+        RawWindowHandle::UiKit(handle)
     }
 }
 
@@ -592,7 +609,7 @@ pub struct WindowId {
 }
 
 impl WindowId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         WindowId {
             window: std::ptr::null_mut(),
         }

src/platform_impl/linux/mod.rs

@@ -30,7 +30,7 @@ use crate::{
     event_loop::{ControlFlow, EventLoopClosed, EventLoopWindowTarget as RootELW},
     icon::Icon,
     monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
-    window::{CursorIcon, Fullscreen, WindowAttributes},
+    window::{CursorIcon, Fullscreen, UserAttentionType, WindowAttributes},
 };
 
 pub(crate) use crate::icon::RgbaIcon as PlatformIcon;
@@ -141,7 +141,7 @@ pub enum WindowId {
 }
 
 impl WindowId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         #[cfg(feature = "wayland")]
         return WindowId::Wayland(wayland::WindowId::dummy());
         #[cfg(all(not(feature = "wayland"), feature = "x11"))]
@@ -158,7 +158,7 @@ pub enum DeviceId {
 }
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         #[cfg(feature = "wayland")]
         return DeviceId::Wayland(wayland::DeviceId::dummy());
         #[cfg(all(not(feature = "wayland"), feature = "x11"))]
@@ -358,6 +358,11 @@ impl Window {
         x11_or_wayland!(match self; Window(window) => window.set_cursor_visible(visible))
     }
 
+    #[inline]
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        x11_or_wayland!(match self; Window(window) => window.drag_window())
+    }
+
     #[inline]
     pub fn scale_factor(&self) -> f64 {
         x11_or_wayland!(match self; Window(w) => w.scale_factor() as f64)
@@ -373,6 +378,11 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.set_maximized(maximized))
     }
 
+    #[inline]
+    pub fn is_maximized(&self) -> bool {
+        x11_or_wayland!(match self; Window(w) => w.is_maximized())
+    }
+
     #[inline]
     pub fn set_minimized(&self, minimized: bool) {
         x11_or_wayland!(match self; Window(w) => w.set_minimized(minimized))
@@ -397,7 +407,7 @@ impl Window {
     pub fn set_always_on_top(&self, _always_on_top: bool) {
         match self {
             #[cfg(feature = "x11")]
-            &Window::X(ref w) => w.set_always_on_top(_always_on_top),
+            Window::X(ref w) => w.set_always_on_top(_always_on_top),
             #[cfg(feature = "wayland")]
             _ => (),
         }
@@ -407,7 +417,7 @@ impl Window {
     pub fn set_window_icon(&self, _window_icon: Option<Icon>) {
         match self {
             #[cfg(feature = "x11")]
-            &Window::X(ref w) => w.set_window_icon(_window_icon),
+            Window::X(ref w) => w.set_window_icon(_window_icon),
             #[cfg(feature = "wayland")]
             _ => (),
         }
@@ -418,6 +428,24 @@ impl Window {
         x11_or_wayland!(match self; Window(w) => w.set_ime_position(position))
     }
 
+    #[inline]
+    pub fn focus_window(&self) {
+        match self {
+            #[cfg(feature = "x11")]
+            Window::X(ref w) => w.focus_window(),
+            #[cfg(feature = "wayland")]
+            _ => (),
+        }
+    }
+    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        match self {
+            #[cfg(feature = "x11")]
+            Window::X(ref w) => w.request_user_attention(request_type),
+            #[cfg(feature = "wayland")]
+            Window::Wayland(ref w) => w.request_user_attention(request_type),
+        }
+    }
+
     #[inline]
     pub fn request_redraw(&self) {
         x11_or_wayland!(match self; Window(w) => w.request_redraw())
@@ -427,14 +455,14 @@ impl Window {
     pub fn current_monitor(&self) -> Option<RootMonitorHandle> {
         match self {
             #[cfg(feature = "x11")]
-            &Window::X(ref window) => {
+            Window::X(ref window) => {
                 let current_monitor = MonitorHandle::X(window.current_monitor());
                 Some(RootMonitorHandle {
                     inner: current_monitor,
                 })
             }
             #[cfg(feature = "wayland")]
-            &Window::Wayland(ref window) => {
+            Window::Wayland(ref window) => {
                 let current_monitor = MonitorHandle::Wayland(window.current_monitor()?);
                 Some(RootMonitorHandle {
                     inner: current_monitor,
@@ -447,13 +475,13 @@ impl Window {
     pub fn available_monitors(&self) -> VecDeque<MonitorHandle> {
         match self {
             #[cfg(feature = "x11")]
-            &Window::X(ref window) => window
+            Window::X(ref window) => window
                 .available_monitors()
                 .into_iter()
                 .map(MonitorHandle::X)
                 .collect(),
             #[cfg(feature = "wayland")]
-            &Window::Wayland(ref window) => window
+            Window::Wayland(ref window) => window
                 .available_monitors()
                 .into_iter()
                 .map(MonitorHandle::Wayland)
@@ -465,23 +493,23 @@ impl Window {
     pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
         match self {
             #[cfg(feature = "x11")]
-            &Window::X(ref window) => {
+            Window::X(ref window) => {
                 let primary_monitor = MonitorHandle::X(window.primary_monitor());
                 Some(RootMonitorHandle {
                     inner: primary_monitor,
                 })
             }
             #[cfg(feature = "wayland")]
-            &Window::Wayland(ref window) => window.primary_monitor(),
+            Window::Wayland(ref window) => window.primary_monitor(),
         }
     }
 
     pub fn raw_window_handle(&self) -> RawWindowHandle {
         match self {
             #[cfg(feature = "x11")]
-            &Window::X(ref window) => RawWindowHandle::Xlib(window.raw_window_handle()),
+            Window::X(ref window) => RawWindowHandle::Xlib(window.raw_window_handle()),
             #[cfg(feature = "wayland")]
-            &Window::Wayland(ref window) => RawWindowHandle::Wayland(window.raw_window_handle()),
+            Window::Wayland(ref window) => RawWindowHandle::Wayland(window.raw_window_handle()),
         }
     }
 }
@@ -588,11 +616,10 @@ impl<T: 'static> EventLoop<T> {
         #[cfg(not(feature = "x11"))]
         let x11_err = "backend disabled";
 
-        let err_string = format!(
+        panic!(
             "Failed to initialize any backend! Wayland status: {:?} X11 status: {:?}",
             wayland_err, x11_err,
         );
-        panic!(err_string);
     }
 
     #[cfg(feature = "wayland")]

src/platform_impl/linux/wayland/env.rs

@@ -13,6 +13,7 @@ use sctk::reexports::protocols::xdg_shell::client::xdg_wm_base::XdgWmBase;
 use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_manager_v1::ZwpRelativePointerManagerV1;
 use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_pointer_constraints_v1::ZwpPointerConstraintsV1;
 use sctk::reexports::protocols::unstable::text_input::v3::client::zwp_text_input_manager_v3::ZwpTextInputManagerV3;
+use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_v1::XdgActivationV1;
 
 use sctk::environment::{Environment, SimpleGlobal};
 use sctk::output::{OutputHandler, OutputHandling, OutputInfo, OutputStatusListener};
@@ -24,18 +25,27 @@ use sctk::shm::ShmHandler;
 #[derive(Debug, Clone, Copy)]
 pub struct WindowingFeatures {
     cursor_grab: bool,
+    xdg_activation: bool,
 }
 
 impl WindowingFeatures {
     /// Create `WindowingFeatures` based on the presented interfaces.
     pub fn new(env: &Environment<WinitEnv>) -> Self {
         let cursor_grab = env.get_global::<ZwpPointerConstraintsV1>().is_some();
-        Self { cursor_grab }
+        let xdg_activation = env.get_global::<XdgActivationV1>().is_some();
+        Self {
+            cursor_grab,
+            xdg_activation,
+        }
     }
 
     pub fn cursor_grab(&self) -> bool {
         self.cursor_grab
     }
+
+    pub fn xdg_activation(&self) -> bool {
+        self.xdg_activation
+    }
 }
 
 sctk::environment!(WinitEnv,
@@ -50,6 +60,7 @@ sctk::environment!(WinitEnv,
         ZwpRelativePointerManagerV1 => relative_pointer_manager,
         ZwpPointerConstraintsV1 => pointer_constraints,
         ZwpTextInputManagerV3 => text_input_manager,
+        XdgActivationV1 => xdg_activation,
     ],
     multis = [
         WlSeat => seats,
@@ -78,6 +89,8 @@ pub struct WinitEnv {
     text_input_manager: SimpleGlobal<ZwpTextInputManagerV3>,
 
     decoration_manager: SimpleGlobal<ZxdgDecorationManagerV1>,
+
+    xdg_activation: SimpleGlobal<XdgActivationV1>,
 }
 
 impl WinitEnv {
@@ -109,6 +122,9 @@ impl WinitEnv {
         // IME handling.
         let text_input_manager = SimpleGlobal::new();
 
+        // Surface activation.
+        let xdg_activation = SimpleGlobal::new();
+
         Self {
             seats,
             outputs,
@@ -120,6 +136,7 @@ impl WinitEnv {
             relative_pointer_manager,
             pointer_constraints,
             text_input_manager,
+            xdg_activation,
         }
     }
 }

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

@@ -1,6 +1,7 @@
 use std::cell::RefCell;
 use std::collections::HashMap;
 use std::error::Error;
+use std::io::Result as IOResult;
 use std::process;
 use std::rc::Rc;
 use std::time::{Duration, Instant};
@@ -18,6 +19,7 @@ use sctk::WaylandSource;
 use crate::event::{Event, StartCause, WindowEvent};
 use crate::event_loop::{ControlFlow, EventLoopWindowTarget as RootEventLoopWindowTarget};
 use crate::platform_impl::platform::sticky_exit_callback;
+use crate::platform_impl::EventLoopWindowTarget as PlatformEventLoopWindowTarget;
 
 use super::env::{WindowingFeatures, WinitEnv};
 use super::output::OutputManager;
@@ -34,6 +36,8 @@ pub use state::WinitState;
 
 use sink::EventSink;
 
+type WinitDispatcher = calloop::Dispatcher<'static, WaylandSource, WinitState>;
+
 pub struct EventLoopWindowTarget<T> {
     /// Wayland display.
     pub display: Display,
@@ -42,7 +46,7 @@ pub struct EventLoopWindowTarget<T> {
     pub env: Environment<WinitEnv>,
 
     /// Event loop handle.
-    pub event_loop_handle: calloop::LoopHandle<WinitState>,
+    pub event_loop_handle: calloop::LoopHandle<'static, WinitState>,
 
     /// Output manager.
     pub output_manager: OutputManager,
@@ -50,8 +54,8 @@ pub struct EventLoopWindowTarget<T> {
     /// State that we share across callbacks.
     pub state: RefCell<WinitState>,
 
-    /// Wayland source.
-    pub wayland_source: Rc<calloop::Source<WaylandSource>>,
+    /// Dispatcher of Wayland events.
+    pub wayland_dispatcher: WinitDispatcher,
 
     /// A proxy to wake up event loop.
     pub event_loop_awakener: calloop::ping::Ping,
@@ -70,7 +74,7 @@ pub struct EventLoopWindowTarget<T> {
 
 pub struct EventLoop<T: 'static> {
     /// Event loop.
-    event_loop: calloop::EventLoop<WinitState>,
+    event_loop: calloop::EventLoop<'static, WinitState>,
 
     /// Wayland display.
     display: Display,
@@ -81,8 +85,8 @@ pub struct EventLoop<T: 'static> {
     /// Sender of user events.
     user_events_sender: calloop::channel::Sender<T>,
 
-    /// Wayland source of events.
-    wayland_source: Rc<calloop::Source<WaylandSource>>,
+    /// Dispatcher of Wayland events.
+    pub wayland_dispatcher: WinitDispatcher,
 
     /// Window target.
     window_target: RootEventLoopWindowTarget<T>,
@@ -102,7 +106,7 @@ impl<T: 'static> EventLoop<T> {
         let env = Environment::new(&display_proxy, &mut event_queue, WinitEnv::new())?;
 
         // Create event loop.
-        let event_loop = calloop::EventLoop::<WinitState>::new()?;
+        let event_loop = calloop::EventLoop::<'static, WinitState>::try_new()?;
         // Build windowing features.
         let windowing_features = WindowingFeatures::new(&env);
 
@@ -116,8 +120,22 @@ impl<T: 'static> EventLoop<T> {
         let output_manager = OutputManager::new(&env);
 
         // A source of events that we plug into our event loop.
-        let wayland_source = WaylandSource::new(event_queue).quick_insert(event_loop.handle())?;
-        let wayland_source = Rc::new(wayland_source);
+        let wayland_source = WaylandSource::new(event_queue);
+        let wayland_dispatcher =
+            calloop::Dispatcher::new(wayland_source, |_, queue, winit_state| {
+                queue.dispatch_pending(winit_state, |event, object, _| {
+                    panic!(
+                        "[calloop] Encountered an orphan event: {}@{} : {}",
+                        event.interface,
+                        object.as_ref().id(),
+                        event.name
+                    );
+                })
+            });
+
+        let _wayland_source_dispatcher = event_loop
+            .handle()
+            .register_dispatcher(wayland_dispatcher.clone())?;
 
         // A source of user events.
         let pending_user_events = Rc::new(RefCell::new(Vec::new()));
@@ -161,7 +179,7 @@ impl<T: 'static> EventLoop<T> {
             event_loop_handle,
             output_manager,
             event_loop_awakener,
-            wayland_source: wayland_source.clone(),
+            wayland_dispatcher: wayland_dispatcher.clone(),
             windowing_features,
             theme_manager,
             _marker: std::marker::PhantomData,
@@ -172,11 +190,11 @@ impl<T: 'static> EventLoop<T> {
             event_loop,
             display,
             pending_user_events,
-            wayland_source,
+            wayland_dispatcher,
             _seat_manager: seat_manager,
             user_events_sender,
             window_target: RootEventLoopWindowTarget {
-                p: crate::platform_impl::EventLoopWindowTarget::Wayland(event_loop_window_target),
+                p: PlatformEventLoopWindowTarget::Wayland(event_loop_window_target),
                 _marker: std::marker::PhantomData,
             },
         };
@@ -243,7 +261,7 @@ impl<T: 'static> EventLoop<T> {
             for (window_id, window_update) in window_updates.iter_mut() {
                 if let Some(scale_factor) = window_update.scale_factor.map(|f| f as f64) {
                     let mut physical_size = self.with_state(|state| {
-                        let window_handle = state.window_map.get(&window_id).unwrap();
+                        let window_handle = state.window_map.get(window_id).unwrap();
                         let mut size = window_handle.size.lock().unwrap();
 
                         // Update the new logical size if it was changed.
@@ -276,7 +294,7 @@ impl<T: 'static> EventLoop<T> {
 
                 if let Some(size) = window_update.size.take() {
                     let physical_size = self.with_state(|state| {
-                        let window_handle = state.window_map.get_mut(&window_id).unwrap();
+                        let window_handle = state.window_map.get_mut(window_id).unwrap();
                         let mut window_size = window_handle.size.lock().unwrap();
 
                         // Always issue resize event on scale factor change.
@@ -287,7 +305,7 @@ impl<T: 'static> EventLoop<T> {
                             } else {
                                 *window_size = size;
                                 let scale_factor =
-                                    sctk::get_surface_scale_factor(&window_handle.window.surface());
+                                    sctk::get_surface_scale_factor(window_handle.window.surface());
                                 let physical_size = size.to_physical(scale_factor as f64);
                                 Some(physical_size)
                             };
@@ -363,7 +381,7 @@ impl<T: 'static> EventLoop<T> {
                 // Handle refresh of the frame.
                 if window_update.refresh_frame {
                     self.with_state(|state| {
-                        let window_handle = state.window_map.get_mut(&window_id).unwrap();
+                        let window_handle = state.window_map.get_mut(window_id).unwrap();
                         window_handle.window.refresh();
                         if !window_update.redraw_requested {
                             window_handle.window.surface().commit();
@@ -403,16 +421,17 @@ impl<T: 'static> EventLoop<T> {
             // woken up by messages arriving from the Wayland socket, to avoid delaying the
             // dispatch of these events until we're woken up again.
             let instant_wakeup = {
-                let handle = self.event_loop.handle();
-                let source = self.wayland_source.clone();
-                let dispatched = handle.with_source(&source, |wayland_source| {
-                    let queue = wayland_source.queue();
-                    self.with_state(|state| {
-                        queue.dispatch_pending(state, |_, _, _| unimplemented!())
-                    })
-                });
+                let mut wayland_source = self.wayland_dispatcher.as_source_mut();
+                let queue = wayland_source.queue();
+                let state = match &mut self.window_target.p {
+                    PlatformEventLoopWindowTarget::Wayland(window_target) => {
+                        window_target.state.get_mut()
+                    }
+                    #[cfg(feature = "x11")]
+                    _ => unreachable!(),
+                };
 
-                if let Ok(dispatched) = dispatched {
+                if let Ok(dispatched) = queue.dispatch_pending(state, |_, _, _| unimplemented!()) {
                     dispatched > 0
                 } else {
                     break;
@@ -508,9 +527,7 @@ impl<T: 'static> EventLoop<T> {
 
     fn with_state<U, F: FnOnce(&mut WinitState) -> U>(&mut self, f: F) -> U {
         let state = match &mut self.window_target.p {
-            crate::platform_impl::EventLoopWindowTarget::Wayland(ref mut window_target) => {
-                window_target.state.get_mut()
-            }
+            PlatformEventLoopWindowTarget::Wayland(window_target) => window_target.state.get_mut(),
             #[cfg(feature = "x11")]
             _ => unreachable!(),
         };
@@ -518,14 +535,9 @@ impl<T: 'static> EventLoop<T> {
         f(state)
     }
 
-    fn loop_dispatch<D: Into<Option<std::time::Duration>>>(
-        &mut self,
-        timeout: D,
-    ) -> std::io::Result<()> {
+    fn loop_dispatch<D: Into<Option<std::time::Duration>>>(&mut self, timeout: D) -> IOResult<()> {
         let mut state = match &mut self.window_target.p {
-            crate::platform_impl::EventLoopWindowTarget::Wayland(ref mut window_target) => {
-                window_target.state.get_mut()
-            }
+            PlatformEventLoopWindowTarget::Wayland(window_target) => window_target.state.get_mut(),
             #[cfg(feature = "x11")]
             _ => unreachable!(),
         };

src/platform_impl/linux/wayland/mod.rs

@@ -22,7 +22,7 @@ mod window;
 pub struct DeviceId;
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         DeviceId
     }
 }
@@ -31,7 +31,7 @@ impl DeviceId {
 pub struct WindowId(usize);
 
 impl WindowId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         WindowId(0)
     }
 }

src/platform_impl/linux/wayland/output.rs

@@ -112,7 +112,7 @@ impl Eq for MonitorHandle {}
 
 impl PartialOrd for MonitorHandle {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(self.cmp(&other))
+        Some(self.cmp(other))
     }
 }
 

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

@@ -149,6 +149,10 @@ pub fn keysym_to_vkey(keysym: u32) -> Option<VirtualKeyCode> {
         keysyms::XKB_KEY_KP_Page_Down => Some(VirtualKeyCode::PageDown),
         keysyms::XKB_KEY_KP_Home => Some(VirtualKeyCode::Home),
         keysyms::XKB_KEY_KP_End => Some(VirtualKeyCode::End),
+        keysyms::XKB_KEY_KP_Left => Some(VirtualKeyCode::Left),
+        keysyms::XKB_KEY_KP_Up => Some(VirtualKeyCode::Up),
+        keysyms::XKB_KEY_KP_Right => Some(VirtualKeyCode::Right),
+        keysyms::XKB_KEY_KP_Down => Some(VirtualKeyCode::Down),
         // => Some(VirtualKeyCode::OEM102),
         keysyms::XKB_KEY_period => Some(VirtualKeyCode::Period),
         // => Some(VirtualKeyCode::Playpause),

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

@@ -7,9 +7,9 @@ use sctk::reexports::client::protocol::wl_keyboard::WlKeyboard;
 use sctk::reexports::client::protocol::wl_seat::WlSeat;
 use sctk::reexports::client::Attached;
 
-use sctk::reexports::calloop::{LoopHandle, Source};
+use sctk::reexports::calloop::{LoopHandle, RegistrationToken};
 
-use sctk::seat::keyboard::{self, RepeatSource};
+use sctk::seat::keyboard;
 
 use crate::event::ModifiersState;
 use crate::platform_impl::wayland::event_loop::WinitState;
@@ -22,22 +22,22 @@ pub(crate) struct Keyboard {
     pub keyboard: WlKeyboard,
 
     /// The source for repeat keys.
-    pub repeat_source: Option<Source<RepeatSource>>,
+    pub repeat_token: Option<RegistrationToken>,
 
     /// LoopHandle to drop `RepeatSource`, when dropping the keyboard.
-    pub loop_handle: LoopHandle<WinitState>,
+    pub loop_handle: LoopHandle<'static, WinitState>,
 }
 
 impl Keyboard {
     pub fn new(
         seat: &Attached<WlSeat>,
-        loop_handle: LoopHandle<WinitState>,
+        loop_handle: LoopHandle<'static, WinitState>,
         modifiers_state: Rc<RefCell<ModifiersState>>,
     ) -> Option<Self> {
         let mut inner = KeyboardInner::new(modifiers_state);
         let keyboard_data = keyboard::map_keyboard_repeat(
             loop_handle.clone(),
-            &seat,
+            seat,
             None,
             keyboard::RepeatKind::System,
             move |event, _, mut dispatch_data| {
@@ -46,12 +46,12 @@ impl Keyboard {
             },
         );
 
-        let (keyboard, repeat_source) = keyboard_data.ok()?;
+        let (keyboard, repeat_token) = keyboard_data.ok()?;
 
         Some(Self {
             keyboard,
             loop_handle,
-            repeat_source: Some(repeat_source),
+            repeat_token: Some(repeat_token),
         })
     }
 }
@@ -62,8 +62,8 @@ impl Drop for Keyboard {
             self.keyboard.release();
         }
 
-        if let Some(repeat_source) = self.repeat_source.take() {
-            self.loop_handle.remove(repeat_source);
+        if let Some(repeat_token) = self.repeat_token.take() {
+            self.loop_handle.remove(repeat_token);
         }
     }
 }

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

@@ -37,7 +37,7 @@ pub struct SeatManager {
 impl SeatManager {
     pub fn new(
         env: &Environment<WinitEnv>,
-        loop_handle: LoopHandle<WinitState>,
+        loop_handle: LoopHandle<'static, WinitState>,
         theme_manager: ThemeManager,
     ) -> Self {
         let relative_pointer_manager = env.get_global::<ZwpRelativePointerManagerV1>();
@@ -63,7 +63,7 @@ impl SeatManager {
         }
 
         let seat_listener = env.listen_for_seats(move |seat, seat_data, _| {
-            inner.process_seat_update(&seat, &seat_data);
+            inner.process_seat_update(&seat, seat_data);
         });
 
         Self {
@@ -78,7 +78,7 @@ struct SeatManagerInner {
     seats: Vec<SeatInfo>,
 
     /// Loop handle.
-    loop_handle: LoopHandle<WinitState>,
+    loop_handle: LoopHandle<'static, WinitState>,
 
     /// Relative pointer manager.
     relative_pointer_manager: Option<Attached<ZwpRelativePointerManagerV1>>,
@@ -99,7 +99,7 @@ impl SeatManagerInner {
         relative_pointer_manager: Option<Attached<ZwpRelativePointerManagerV1>>,
         pointer_constraints: Option<Attached<ZwpPointerConstraintsV1>>,
         text_input_manager: Option<Attached<ZwpTextInputManagerV3>>,
-        loop_handle: LoopHandle<WinitState>,
+        loop_handle: LoopHandle<'static, WinitState>,
     ) -> Self {
         Self {
             seats: Vec::new(),
@@ -127,7 +127,7 @@ impl SeatManagerInner {
         if seat_data.has_pointer && !seat_data.defunct {
             if seat_info.pointer.is_none() {
                 seat_info.pointer = Some(Pointers::new(
-                    &seat,
+                    seat,
                     &self.theme_manager,
                     &self.relative_pointer_manager,
                     &self.pointer_constraints,
@@ -142,7 +142,7 @@ impl SeatManagerInner {
         if seat_data.has_keyboard && !seat_data.defunct {
             if seat_info.keyboard.is_none() {
                 seat_info.keyboard = Keyboard::new(
-                    &seat,
+                    seat,
                     self.loop_handle.clone(),
                     seat_info.modifiers_state.clone(),
                 );
@@ -154,7 +154,7 @@ impl SeatManagerInner {
         // Handle touch.
         if seat_data.has_touch && !seat_data.defunct {
             if seat_info.touch.is_none() {
-                seat_info.touch = Some(Touch::new(&seat));
+                seat_info.touch = Some(Touch::new(seat));
             }
         } else {
             seat_info.touch = None;
@@ -165,7 +165,7 @@ impl SeatManagerInner {
             if seat_data.defunct {
                 seat_info.text_input = None;
             } else if seat_info.text_input.is_none() {
-                seat_info.text_input = Some(TextInput::new(&seat, &text_input_manager));
+                seat_info.text_input = Some(TextInput::new(seat, text_input_manager));
             }
         }
     }

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

@@ -4,6 +4,7 @@ use std::cell::RefCell;
 use std::rc::Rc;
 
 use sctk::reexports::client::protocol::wl_pointer::{self, Event as PointerEvent};
+use sctk::reexports::client::protocol::wl_seat::WlSeat;
 use sctk::reexports::protocols::unstable::relative_pointer::v1::client::zwp_relative_pointer_v1::Event as RelativePointerEvent;
 
 use sctk::seat::pointer::ThemedPointer;
@@ -17,12 +18,18 @@ use crate::platform_impl::wayland::{self, DeviceId};
 
 use super::{PointerData, WinitPointer};
 
+// These values are comming from <linux/input-event-codes.h>.
+const BTN_LEFT: u32 = 0x110;
+const BTN_RIGHT: u32 = 0x111;
+const BTN_MIDDLE: u32 = 0x112;
+
 #[inline]
 pub(super) fn handle_pointer(
     pointer: ThemedPointer,
     event: PointerEvent,
     pointer_data: &Rc<RefCell<PointerData>>,
     winit_state: &mut WinitState,
+    seat: WlSeat,
 ) {
     let event_sink = &mut winit_state.event_sink;
     let mut pointer_data = pointer_data.borrow_mut();
@@ -54,6 +61,7 @@ pub(super) fn handle_pointer(
                 confined_pointer: Rc::downgrade(&pointer_data.confined_pointer),
                 pointer_constraints: pointer_data.pointer_constraints.clone(),
                 latest_serial: pointer_data.latest_serial.clone(),
+                seat,
             };
             window_handle.pointer_entered(winit_pointer);
 
@@ -96,6 +104,7 @@ pub(super) fn handle_pointer(
                 confined_pointer: Rc::downgrade(&pointer_data.confined_pointer),
                 pointer_constraints: pointer_data.pointer_constraints.clone(),
                 latest_serial: pointer_data.latest_serial.clone(),
+                seat,
             };
             window_handle.pointer_left(winit_pointer);
 
@@ -120,7 +129,7 @@ pub(super) fn handle_pointer(
 
             let window_id = wayland::make_wid(surface);
 
-            let scale_factor = sctk::get_surface_scale_factor(&surface) as f64;
+            let scale_factor = sctk::get_surface_scale_factor(surface) as f64;
             let position = LogicalPosition::new(surface_x, surface_y).to_physical(scale_factor);
 
             event_sink.push_window_event(
@@ -153,11 +162,10 @@ pub(super) fn handle_pointer(
             };
 
             let button = match button {
-                0x110 => MouseButton::Left,
-                0x111 => MouseButton::Right,
-                0x112 => MouseButton::Middle,
-                // TODO - figure out the translation.
-                _ => return,
+                BTN_LEFT => MouseButton::Left,
+                BTN_RIGHT => MouseButton::Right,
+                BTN_MIDDLE => MouseButton::Middle,
+                button => MouseButton::Other(button as u16),
             };
 
             event_sink.push_window_event(
@@ -178,7 +186,7 @@ pub(super) fn handle_pointer(
                 None => return,
             };
 
-            let window_id = wayland::make_wid(&surface);
+            let window_id = wayland::make_wid(surface);
 
             if pointer.as_ref().version() < 5 {
                 let (mut x, mut y) = (0.0, 0.0);
@@ -191,7 +199,7 @@ pub(super) fn handle_pointer(
                     _ => unreachable!(),
                 }
 
-                let scale_factor = sctk::get_surface_scale_factor(&surface) as f64;
+                let scale_factor = sctk::get_surface_scale_factor(surface) as f64;
                 let delta = LogicalPosition::new(x as f64, y as f64).to_physical(scale_factor);
 
                 event_sink.push_window_event(
@@ -254,7 +262,7 @@ pub(super) fn handle_pointer(
                 Some(surface) => surface,
                 None => return,
             };
-            let window_id = wayland::make_wid(&surface);
+            let window_id = wayland::make_wid(surface);
 
             let window_event = if let Some((x, y)) = axis_discrete_buffer {
                 WindowEvent::MouseWheel {
@@ -266,7 +274,7 @@ pub(super) fn handle_pointer(
                     modifiers: *pointer_data.modifiers_state.borrow(),
                 }
             } else if let Some((x, y)) = axis_buffer {
-                let scale_factor = sctk::get_surface_scale_factor(&surface) as f64;
+                let scale_factor = sctk::get_surface_scale_factor(surface) as f64;
                 let delta = LogicalPosition::new(x, y).to_physical(scale_factor);
 
                 WindowEvent::MouseWheel {

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

@@ -13,6 +13,7 @@ use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_p
 use sctk::reexports::protocols::unstable::pointer_constraints::v1::client::zwp_confined_pointer_v1::ZwpConfinedPointerV1;
 
 use sctk::seat::pointer::{ThemeManager, ThemedPointer};
+use sctk::window::{FallbackFrame, Window};
 
 use crate::event::ModifiersState;
 use crate::platform_impl::wayland::event_loop::WinitState;
@@ -35,6 +36,9 @@ pub struct WinitPointer {
 
     /// Latest observed serial in pointer events.
     latest_serial: Rc<Cell<u32>>,
+
+    /// Seat.
+    seat: WlSeat,
 }
 
 impl PartialEq for WinitPointer {
@@ -66,7 +70,7 @@ impl WinitPointer {
             CursorIcon::Copy => &["copy"],
             CursorIcon::Crosshair => &["crosshair"],
             CursorIcon::Default => &["left_ptr"],
-            CursorIcon::Hand => &["hand"],
+            CursorIcon::Hand => &["hand2", "hand1"],
             CursorIcon::Help => &["question_arrow"],
             CursorIcon::Move => &["move"],
             CursorIcon::Grab => &["openhand", "grab"],
@@ -89,8 +93,8 @@ impl WinitPointer {
             CursorIcon::WResize => &["left_side"],
             CursorIcon::EwResize => &["h_double_arrow"],
             CursorIcon::NsResize => &["v_double_arrow"],
-            CursorIcon::NwseResize => &["bd_double_arrow", "size_bdiag"],
-            CursorIcon::NeswResize => &["fd_double_arrow", "size_fdiag"],
+            CursorIcon::NwseResize => &["bd_double_arrow", "size_fdiag"],
+            CursorIcon::NeswResize => &["fd_double_arrow", "size_bdiag"],
             CursorIcon::ColResize => &["split_h", "h_double_arrow"],
             CursorIcon::RowResize => &["split_v", "v_double_arrow"],
             CursorIcon::Text => &["text", "xterm"],
@@ -105,9 +109,10 @@ impl WinitPointer {
         let serial = Some(self.latest_serial.get());
         for cursor in cursors {
             if self.pointer.set_cursor(cursor, serial).is_ok() {
-                break;
+                return;
             }
         }
+        warn!("Failed to set cursor to {:?}", cursor_icon);
     }
 
     /// Confine the pointer to a surface.
@@ -124,8 +129,8 @@ impl WinitPointer {
         };
 
         *confined_pointer.borrow_mut() = Some(init_confined_pointer(
-            &pointer_constraints,
-            &surface,
+            pointer_constraints,
+            surface,
             &*self.pointer,
         ));
     }
@@ -144,6 +149,10 @@ impl WinitPointer {
             confined_pointer.destroy();
         }
     }
+
+    pub fn drag_window(&self, window: &Window<FallbackFrame>) {
+        window.start_interactive_move(&self.seat, self.latest_serial.get());
+    }
 }
 
 /// A pointer wrapper for easy releasing and managing pointers.
@@ -172,21 +181,27 @@ impl Pointers {
             pointer_constraints.clone(),
             modifiers_state,
         )));
+        let pointer_seat = seat.detach();
         let pointer = theme_manager.theme_pointer_with_impl(
             seat,
             move |event, pointer, mut dispatch_data| {
                 let winit_state = dispatch_data.get::<WinitState>().unwrap();
-                handlers::handle_pointer(pointer, event, &pointer_data, winit_state);
+                handlers::handle_pointer(
+                    pointer,
+                    event,
+                    &pointer_data,
+                    winit_state,
+                    pointer_seat.clone(),
+                );
             },
         );
 
         // Setup relative_pointer if it's available.
-        let relative_pointer = match relative_pointer_manager.as_ref() {
-            Some(relative_pointer_manager) => {
-                Some(init_relative_pointer(&relative_pointer_manager, &*pointer))
-            }
-            None => None,
-        };
+        let relative_pointer = relative_pointer_manager
+            .as_ref()
+            .map(|relative_pointer_manager| {
+                init_relative_pointer(relative_pointer_manager, &*pointer)
+            });
 
         Self {
             pointer,
@@ -234,7 +249,7 @@ pub(super) fn init_confined_pointer(
     pointer: &WlPointer,
 ) -> ZwpConfinedPointerV1 {
     let confined_pointer =
-        pointer_constraints.confine_pointer(surface, pointer, None, Lifetime::Persistent.to_raw());
+        pointer_constraints.confine_pointer(surface, pointer, None, Lifetime::Persistent);
 
     confined_pointer.quick_assign(move |_, _, _| {});
 

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

@@ -7,21 +7,17 @@ use sctk::reexports::client::Display;
 
 use sctk::reexports::calloop;
 
-use sctk::window::{
-    ARGBColor, ButtonColorSpec, ColorSpec, ConceptConfig, ConceptFrame, Decorations,
-};
-
-use raw_window_handle::unix::WaylandHandle;
+use raw_window_handle::WaylandHandle;
+use sctk::window::{Decorations, FallbackFrame};
 
 use crate::dpi::{LogicalSize, PhysicalPosition, PhysicalSize, Position, Size};
 use crate::error::{ExternalError, NotSupportedError, OsError as RootOsError};
 use crate::monitor::MonitorHandle as RootMonitorHandle;
-use crate::platform::unix::{ARGBColor as LocalARGBColor, Button, ButtonState, Element, Theme};
 use crate::platform_impl::{
     MonitorHandle as PlatformMonitorHandle, OsError,
     PlatformSpecificWindowBuilderAttributes as PlatformAttributes,
 };
-use crate::window::{CursorIcon, Fullscreen, WindowAttributes};
+use crate::window::{CursorIcon, Fullscreen, UserAttentionType, WindowAttributes};
 
 use super::env::WindowingFeatures;
 use super::event_loop::WinitState;
@@ -54,6 +50,9 @@ pub struct Window {
     /// Fullscreen state.
     fullscreen: Arc<AtomicBool>,
 
+    /// Maximized state.
+    maximized: Arc<AtomicBool>,
+
     /// Available windowing features.
     windowing_features: WindowingFeatures,
 
@@ -87,6 +86,8 @@ impl Window {
         let scale_factor = sctk::get_surface_scale_factor(&surface);
 
         let window_id = super::make_wid(&surface);
+        let maximized = Arc::new(AtomicBool::new(false));
+        let maximzied_clone = maximized.clone();
         let fullscreen = Arc::new(AtomicBool::new(false));
         let fullscreen_clone = fullscreen.clone();
 
@@ -98,7 +99,7 @@ impl Window {
         let theme_manager = event_loop_window_target.theme_manager.clone();
         let mut window = event_loop_window_target
             .env
-            .create_window::<ConceptFrame, _>(
+            .create_window::<FallbackFrame, _>(
                 surface.clone(),
                 Some(theme_manager),
                 (width, height),
@@ -113,6 +114,8 @@ impl Window {
                             window_update.refresh_frame = true;
                         }
                         Event::Configure { new_size, states } => {
+                            let is_maximized = states.contains(&State::Maximized);
+                            maximzied_clone.store(is_maximized, Ordering::Relaxed);
                             let is_fullscreen = states.contains(&State::Fullscreen);
                             fullscreen_clone.store(is_fullscreen, Ordering::Relaxed);
 
@@ -136,6 +139,12 @@ impl Window {
         } else {
             window.set_decorate(Decorations::None);
         }
+        // Without this commit here at least on kwin 5.23.3 the initial configure
+        // will have a size (1,1), the second configure including the decoration
+        // mode will have the min_size as its size. With this commit the initial
+        // configure will have no size, the application will draw it's content
+        // with the initial size and everything works as expected afterwards.
+        window.surface().commit();
 
         // Min dimensions.
         let min_size = attributes
@@ -145,7 +154,7 @@ impl Window {
 
         // Max dimensions.
         let max_size = attributes
-            .min_inner_size
+            .max_inner_size
             .map(|size| size.to_logical::<f64>(scale_factor as f64).into());
         window.set_max_size(max_size);
 
@@ -194,7 +203,12 @@ impl Window {
         let window_requests = Arc::new(Mutex::new(Vec::with_capacity(64)));
 
         // Create a handle that performs all the requests on underlying sctk a window.
-        let window_handle = WindowHandle::new(window, size.clone(), window_requests.clone());
+        let window_handle = WindowHandle::new(
+            &event_loop_window_target.env,
+            window,
+            size.clone(),
+            window_requests.clone(),
+        );
 
         let mut winit_state = event_loop_window_target.state.borrow_mut();
 
@@ -206,17 +220,14 @@ impl Window {
 
         let windowing_features = event_loop_window_target.windowing_features;
 
-        // Send all updates to the server.
-        let wayland_source = &event_loop_window_target.wayland_source;
-        let event_loop_handle = &event_loop_window_target.event_loop_handle;
-
         // To make our window usable for drawing right away we must `ack` a `configure`
         // from the server, the acking part here is done by SCTK window frame, so we just
         // need to sync with server so it'll be done automatically for us.
-        event_loop_handle.with_source(&wayland_source, |event_queue| {
-            let event_queue = event_queue.queue();
+        {
+            let mut wayland_source = event_loop_window_target.wayland_dispatcher.as_source_mut();
+            let event_queue = wayland_source.queue();
             let _ = event_queue.sync_roundtrip(&mut *winit_state, |_, _, _| unreachable!());
-        });
+        }
 
         // We all praise GNOME for these 3 lines of pure magic. If we don't do that,
         // GNOME will shrink our window a bit for the size of the decorations. I guess it
@@ -235,6 +246,7 @@ impl Window {
             window_requests,
             event_loop_awakener: event_loop_window_target.event_loop_awakener.clone(),
             fullscreen,
+            maximized,
             windowing_features,
         };
 
@@ -250,9 +262,7 @@ impl Window {
 
     #[inline]
     pub fn set_title(&self, title: &str) {
-        let title_request = WindowRequest::Title(title.to_owned());
-        self.window_requests.lock().unwrap().push(title_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::Title(title.to_owned()));
     }
 
     #[inline]
@@ -284,9 +294,7 @@ impl Window {
 
     #[inline]
     pub fn request_redraw(&self) {
-        let redraw_request = WindowRequest::Redraw;
-        self.window_requests.lock().unwrap().push(redraw_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::Redraw);
     }
 
     #[inline]
@@ -304,12 +312,7 @@ impl Window {
         let size = size.to_logical::<u32>(scale_factor);
         *self.size.lock().unwrap() = size;
 
-        let frame_size_request = WindowRequest::FrameSize(size);
-        self.window_requests
-            .lock()
-            .unwrap()
-            .push(frame_size_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::FrameSize(size));
     }
 
     #[inline]
@@ -317,9 +320,7 @@ impl Window {
         let scale_factor = self.scale_factor() as f64;
         let size = dimensions.map(|size| size.to_logical::<u32>(scale_factor));
 
-        let min_size_request = WindowRequest::MinSize(size);
-        self.window_requests.lock().unwrap().push(min_size_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::MinSize(size));
     }
 
     #[inline]
@@ -327,19 +328,12 @@ impl Window {
         let scale_factor = self.scale_factor() as f64;
         let size = dimensions.map(|size| size.to_logical::<u32>(scale_factor));
 
-        let max_size_request = WindowRequest::MaxSize(size);
-        self.window_requests.lock().unwrap().push(max_size_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::MaxSize(size));
     }
 
     #[inline]
     pub fn set_resizable(&self, resizable: bool) {
-        let resizeable_request = WindowRequest::Resizeable(resizable);
-        self.window_requests
-            .lock()
-            .unwrap()
-            .push(resizeable_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::Resizeable(resizable));
     }
 
     #[inline]
@@ -351,9 +345,7 @@ impl Window {
 
     #[inline]
     pub fn set_decorations(&self, decorate: bool) {
-        let decorate_request = WindowRequest::Decorate(decorate);
-        self.window_requests.lock().unwrap().push(decorate_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::Decorate(decorate));
     }
 
     #[inline]
@@ -363,16 +355,17 @@ impl Window {
             return;
         }
 
-        let minimize_request = WindowRequest::Minimize;
-        self.window_requests.lock().unwrap().push(minimize_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::Minimize);
+    }
+
+    #[inline]
+    pub fn is_maximized(&self) -> bool {
+        self.maximized.load(Ordering::Relaxed)
     }
 
     #[inline]
     pub fn set_maximized(&self, maximized: bool) {
-        let maximize_request = WindowRequest::Maximize(maximized);
-        self.window_requests.lock().unwrap().push(maximize_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::Maximize(maximized));
     }
 
     #[inline]
@@ -408,154 +401,17 @@ impl Window {
             None => WindowRequest::UnsetFullscreen,
         };
 
-        self.window_requests
-            .lock()
-            .unwrap()
-            .push(fullscreen_request);
-        self.event_loop_awakener.ping();
-    }
-
-    #[inline]
-    pub fn set_theme<T: Theme>(&self, theme: T) {
-        // First buttons is minimize, then maximize, and then close.
-        let buttons: Vec<(ButtonColorSpec, ButtonColorSpec)> =
-            [Button::Minimize, Button::Maximize, Button::Close]
-                .iter()
-                .map(|button| {
-                    let button = *button;
-                    let idle_active_bg = theme
-                        .button_color(button, ButtonState::Idle, false, true)
-                        .into();
-                    let idle_inactive_bg = theme
-                        .button_color(button, ButtonState::Idle, false, false)
-                        .into();
-                    let idle_active_icon = theme
-                        .button_color(button, ButtonState::Idle, true, true)
-                        .into();
-                    let idle_inactive_icon = theme
-                        .button_color(button, ButtonState::Idle, true, false)
-                        .into();
-                    let idle_bg = ColorSpec {
-                        active: idle_active_bg,
-                        inactive: idle_inactive_bg,
-                    };
-                    let idle_icon = ColorSpec {
-                        active: idle_active_icon,
-                        inactive: idle_inactive_icon,
-                    };
-
-                    let hovered_active_bg = theme
-                        .button_color(button, ButtonState::Hovered, false, true)
-                        .into();
-                    let hovered_inactive_bg = theme
-                        .button_color(button, ButtonState::Hovered, false, false)
-                        .into();
-                    let hovered_active_icon = theme
-                        .button_color(button, ButtonState::Hovered, true, true)
-                        .into();
-                    let hovered_inactive_icon = theme
-                        .button_color(button, ButtonState::Hovered, true, false)
-                        .into();
-                    let hovered_bg = ColorSpec {
-                        active: hovered_active_bg,
-                        inactive: hovered_inactive_bg,
-                    };
-                    let hovered_icon = ColorSpec {
-                        active: hovered_active_icon,
-                        inactive: hovered_inactive_icon,
-                    };
-
-                    let disabled_active_bg = theme
-                        .button_color(button, ButtonState::Disabled, false, true)
-                        .into();
-                    let disabled_inactive_bg = theme
-                        .button_color(button, ButtonState::Disabled, false, false)
-                        .into();
-                    let disabled_active_icon = theme
-                        .button_color(button, ButtonState::Disabled, true, true)
-                        .into();
-                    let disabled_inactive_icon = theme
-                        .button_color(button, ButtonState::Disabled, true, false)
-                        .into();
-                    let disabled_bg = ColorSpec {
-                        active: disabled_active_bg,
-                        inactive: disabled_inactive_bg,
-                    };
-                    let disabled_icon = ColorSpec {
-                        active: disabled_active_icon,
-                        inactive: disabled_inactive_icon,
-                    };
-
-                    let button_bg = ButtonColorSpec {
-                        idle: idle_bg,
-                        hovered: hovered_bg,
-                        disabled: disabled_bg,
-                    };
-                    let button_icon = ButtonColorSpec {
-                        idle: idle_icon,
-                        hovered: hovered_icon,
-                        disabled: disabled_icon,
-                    };
-
-                    (button_icon, button_bg)
-                })
-                .collect();
-
-        let minimize_button = Some(buttons[0]);
-        let maximize_button = Some(buttons[1]);
-        let close_button = Some(buttons[2]);
-
-        // The first color is bar, then separator, and then text color.
-        let titlebar_colors: Vec<ColorSpec> = [Element::Bar, Element::Separator, Element::Text]
-            .iter()
-            .map(|element| {
-                let element = *element;
-                let active = theme.element_color(element, true).into();
-                let inactive = theme.element_color(element, false).into();
-
-                ColorSpec { active, inactive }
-            })
-            .collect();
-
-        let primary_color = titlebar_colors[0];
-        let secondary_color = titlebar_colors[1];
-        let title_color = titlebar_colors[2];
-
-        let title_font = theme.font();
-
-        let concept_config = ConceptConfig {
-            primary_color,
-            secondary_color,
-            title_color,
-            title_font,
-            minimize_button,
-            maximize_button,
-            close_button,
-        };
-
-        let theme_request = WindowRequest::Theme(concept_config);
-        self.window_requests.lock().unwrap().push(theme_request);
-        self.event_loop_awakener.ping();
+        self.send_request(fullscreen_request);
     }
 
     #[inline]
     pub fn set_cursor_icon(&self, cursor: CursorIcon) {
-        let cursor_icon_request = WindowRequest::NewCursorIcon(cursor);
-        self.window_requests
-            .lock()
-            .unwrap()
-            .push(cursor_icon_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::NewCursorIcon(cursor));
     }
 
     #[inline]
     pub fn set_cursor_visible(&self, visible: bool) {
-        let cursor_visible_request = WindowRequest::ShowCursor(visible);
-        self.window_requests
-            .lock()
-            .unwrap()
-            .push(cursor_visible_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::ShowCursor(visible));
     }
 
     #[inline]
@@ -564,16 +420,20 @@ impl Window {
             return Err(ExternalError::NotSupported(NotSupportedError::new()));
         }
 
-        let cursor_grab_request = WindowRequest::GrabCursor(grab);
-        self.window_requests
-            .lock()
-            .unwrap()
-            .push(cursor_grab_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::GrabCursor(grab));
 
         Ok(())
     }
 
+    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        if !self.windowing_features.xdg_activation() {
+            warn!("`request_user_attention` isn't supported");
+            return;
+        }
+
+        self.send_request(WindowRequest::Attention(request_type));
+    }
+
     #[inline]
     pub fn set_cursor_position(&self, _: Position) -> Result<(), ExternalError> {
         // XXX This is possible if the locked pointer is being used. We don't have any
@@ -586,16 +446,18 @@ impl Window {
         Err(ExternalError::NotSupported(NotSupportedError::new()))
     }
 
+    #[inline]
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        self.send_request(WindowRequest::DragWindow);
+
+        Ok(())
+    }
+
     #[inline]
     pub fn set_ime_position(&self, position: Position) {
         let scale_factor = self.scale_factor() as f64;
         let position = position.to_logical(scale_factor);
-        let ime_position_request = WindowRequest::IMEPosition(position);
-        self.window_requests
-            .lock()
-            .unwrap()
-            .push(ime_position_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::IMEPosition(position));
     }
 
     #[inline]
@@ -626,31 +488,21 @@ impl Window {
 
     #[inline]
     pub fn raw_window_handle(&self) -> WaylandHandle {
-        let display = self.display.get_display_ptr() as *mut _;
-        let surface = self.surface.as_ref().c_ptr() as *mut _;
-
-        WaylandHandle {
-            display,
-            surface,
-            ..WaylandHandle::empty()
-        }
+        let mut handle = WaylandHandle::empty();
+        handle.display = self.display.get_display_ptr() as *mut _;
+        handle.surface = self.surface.as_ref().c_ptr() as *mut _;
+        handle
     }
-}
 
-impl From<LocalARGBColor> for ARGBColor {
-    fn from(color: LocalARGBColor) -> Self {
-        let a = color.a;
-        let r = color.r;
-        let g = color.g;
-        let b = color.b;
-        Self { a, r, g, b }
+    #[inline]
+    fn send_request(&self, request: WindowRequest) {
+        self.window_requests.lock().unwrap().push(request);
+        self.event_loop_awakener.ping();
     }
 }
 
 impl Drop for Window {
     fn drop(&mut self) {
-        let close_request = WindowRequest::Close;
-        self.window_requests.lock().unwrap().push(close_request);
-        self.event_loop_awakener.ping();
+        self.send_request(WindowRequest::Close);
     }
 }

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

@@ -2,17 +2,23 @@ use std::cell::Cell;
 use std::sync::{Arc, Mutex};
 
 use sctk::reexports::client::protocol::wl_output::WlOutput;
+use sctk::reexports::client::Attached;
+use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_token_v1;
+use sctk::reexports::protocols::staging::xdg_activation::v1::client::xdg_activation_v1::XdgActivationV1;
 
-use sctk::window::{ConceptConfig, ConceptFrame, Decorations, Window};
+use sctk::environment::Environment;
+use sctk::window::{Decorations, FallbackFrame, Window};
 
 use crate::dpi::{LogicalPosition, LogicalSize};
 
 use crate::event::WindowEvent;
+use crate::platform_impl::wayland;
+use crate::platform_impl::wayland::env::WinitEnv;
 use crate::platform_impl::wayland::event_loop::WinitState;
 use crate::platform_impl::wayland::seat::pointer::WinitPointer;
 use crate::platform_impl::wayland::seat::text_input::TextInputHandler;
 use crate::platform_impl::wayland::WindowId;
-use crate::window::CursorIcon;
+use crate::window::{CursorIcon, UserAttentionType};
 
 /// A request to SCTK window from Winit window.
 #[derive(Debug, Clone)]
@@ -34,6 +40,9 @@ pub enum WindowRequest {
     /// Grab cursor.
     GrabCursor(bool),
 
+    /// Drag window.
+    DragWindow,
+
     /// Maximize the window.
     Maximize(bool),
 
@@ -61,12 +70,14 @@ pub enum WindowRequest {
     /// Set IME window position.
     IMEPosition(LogicalPosition<u32>),
 
+    /// Request Attention.
+    ///
+    /// `None` unsets the attention request.
+    Attention(Option<UserAttentionType>),
+
     /// Redraw was requested.
     Redraw,
 
-    /// A new theme for a concept frame was requested.
-    Theme(ConceptConfig),
-
     /// Window should be closed.
     Close,
 }
@@ -128,7 +139,7 @@ impl WindowUpdate {
 /// and react to events.
 pub struct WindowHandle {
     /// An actual window.
-    pub window: Window<ConceptFrame>,
+    pub window: Window<FallbackFrame>,
 
     /// The current size of the window.
     pub size: Arc<Mutex<LogicalSize<u32>>>,
@@ -150,14 +161,23 @@ pub struct WindowHandle {
 
     /// Text inputs on the current surface.
     text_inputs: Vec<TextInputHandler>,
+
+    /// XdgActivation object.
+    xdg_activation: Option<Attached<XdgActivationV1>>,
+
+    /// Indicator whether user attention is requested.
+    attention_requested: Cell<bool>,
 }
 
 impl WindowHandle {
     pub fn new(
-        window: Window<ConceptFrame>,
+        env: &Environment<WinitEnv>,
+        window: Window<FallbackFrame>,
         size: Arc<Mutex<LogicalSize<u32>>>,
         pending_window_requests: Arc<Mutex<Vec<WindowRequest>>>,
     ) -> Self {
+        let xdg_activation = env.get_global::<XdgActivationV1>();
+
         Self {
             window,
             size,
@@ -167,6 +187,8 @@ impl WindowHandle {
             cursor_visible: Cell::new(true),
             pointers: Vec::new(),
             text_inputs: Vec::new(),
+            xdg_activation,
+            attention_requested: Cell::new(false),
         }
     }
 
@@ -181,13 +203,55 @@ impl WindowHandle {
         for pointer in self.pointers.iter() {
             if self.confined.get() {
                 let surface = self.window.surface();
-                pointer.confine(&surface);
+                pointer.confine(surface);
             } else {
                 pointer.unconfine();
             }
         }
     }
 
+    pub fn set_user_attention(&self, request_type: Option<UserAttentionType>) {
+        let xdg_activation = match self.xdg_activation.as_ref() {
+            None => return,
+            Some(xdg_activation) => xdg_activation,
+        };
+
+        //  Urgency is only removed by the compositor and there's no need to raise urgency when it
+        //  was already raised.
+        if request_type.is_none() || self.attention_requested.get() {
+            return;
+        }
+
+        let xdg_activation_token = xdg_activation.get_activation_token();
+        let surface = self.window.surface();
+        let window_id = wayland::make_wid(surface);
+        let xdg_activation = xdg_activation.clone();
+
+        xdg_activation_token.quick_assign(move |xdg_token, event, mut dispatch_data| {
+            let token = match event {
+                xdg_activation_token_v1::Event::Done { token } => token,
+                _ => return,
+            };
+
+            let winit_state = dispatch_data.get::<WinitState>().unwrap();
+            let window_handle = match winit_state.window_map.get_mut(&window_id) {
+                Some(window_handle) => window_handle,
+                None => return,
+            };
+
+            let surface = window_handle.window.surface();
+            xdg_activation.activate(token, surface);
+
+            // Mark that attention request was done and drop the token.
+            window_handle.attention_requested.replace(false);
+            xdg_token.destroy();
+        });
+
+        xdg_activation_token.set_surface(surface);
+        xdg_activation_token.commit();
+        self.attention_requested.replace(true);
+    }
+
     /// Pointer appeared over the window.
     pub fn pointer_entered(&mut self, pointer: WinitPointer) {
         let position = self.pointers.iter().position(|p| *p == pointer);
@@ -195,7 +259,7 @@ impl WindowHandle {
         if position.is_none() {
             if self.confined.get() {
                 let surface = self.window.surface();
-                pointer.confine(&surface);
+                pointer.confine(surface);
             }
             self.pointers.push(pointer);
         }
@@ -219,12 +283,7 @@ impl WindowHandle {
     }
 
     pub fn text_input_entered(&mut self, text_input: TextInputHandler) {
-        if self
-            .text_inputs
-            .iter()
-            .find(|t| *t == &text_input)
-            .is_none()
-        {
+        if !self.text_inputs.iter().any(|t| *t == text_input) {
             self.text_inputs.push(text_input);
         }
     }
@@ -268,6 +327,12 @@ impl WindowHandle {
             pointer.set_cursor(Some(cursor_icon));
         }
     }
+
+    pub fn drag_window(&self) {
+        for pointer in self.pointers.iter() {
+            pointer.drag_window(&self.window);
+        }
+    }
 }
 
 #[inline]
@@ -299,6 +364,9 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
                 WindowRequest::GrabCursor(grab) => {
                     window_handle.set_cursor_grab(grab);
                 }
+                WindowRequest::DragWindow => {
+                    window_handle.drag_window();
+                }
                 WindowRequest::Maximize(maximize) => {
                     if maximize {
                         window_handle.window.set_maximized();
@@ -318,35 +386,35 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
                     window_handle.window.set_decorate(decorations);
 
                     // We should refresh the frame to apply decorations change.
-                    let window_update = window_updates.get_mut(&window_id).unwrap();
+                    let window_update = window_updates.get_mut(window_id).unwrap();
                     window_update.refresh_frame = true;
                 }
                 WindowRequest::Resizeable(resizeable) => {
                     window_handle.window.set_resizable(resizeable);
 
                     // We should refresh the frame to update button state.
-                    let window_update = window_updates.get_mut(&window_id).unwrap();
+                    let window_update = window_updates.get_mut(window_id).unwrap();
                     window_update.refresh_frame = true;
                 }
                 WindowRequest::Title(title) => {
                     window_handle.window.set_title(title);
 
                     // We should refresh the frame to draw new title.
-                    let window_update = window_updates.get_mut(&window_id).unwrap();
+                    let window_update = window_updates.get_mut(window_id).unwrap();
                     window_update.refresh_frame = true;
                 }
                 WindowRequest::MinSize(size) => {
                     let size = size.map(|size| (size.width, size.height));
                     window_handle.window.set_min_size(size);
 
-                    let window_update = window_updates.get_mut(&window_id).unwrap();
+                    let window_update = window_updates.get_mut(window_id).unwrap();
                     window_update.redraw_requested = true;
                 }
                 WindowRequest::MaxSize(size) => {
                     let size = size.map(|size| (size.width, size.height));
                     window_handle.window.set_max_size(size);
 
-                    let window_update = window_updates.get_mut(&window_id).unwrap();
+                    let window_update = window_updates.get_mut(window_id).unwrap();
                     window_update.redraw_requested = true;
                 }
                 WindowRequest::FrameSize(size) => {
@@ -354,20 +422,16 @@ pub fn handle_window_requests(winit_state: &mut WinitState) {
                     window_handle.window.resize(size.width, size.height);
 
                     // We should refresh the frame after resize.
-                    let window_update = window_updates.get_mut(&window_id).unwrap();
+                    let window_update = window_updates.get_mut(window_id).unwrap();
                     window_update.refresh_frame = true;
                 }
+                WindowRequest::Attention(request_type) => {
+                    window_handle.set_user_attention(request_type);
+                }
                 WindowRequest::Redraw => {
-                    let window_update = window_updates.get_mut(&window_id).unwrap();
+                    let window_update = window_updates.get_mut(window_id).unwrap();
                     window_update.redraw_requested = true;
                 }
-                WindowRequest::Theme(concept_config) => {
-                    window_handle.window.set_frame_config(concept_config);
-
-                    // We should refresh the frame to apply new theme.
-                    let window_update = window_updates.get_mut(&window_id).unwrap();
-                    window_update.refresh_frame = true;
-                }
                 WindowRequest::Close => {
                     // The window was requested to be closed.
                     windows_to_close.push(*window_id);

src/platform_impl/linux/x11/event_processor.rs

@@ -709,7 +709,7 @@ impl<T: 'static> EventProcessor<T> {
                                 event: MouseInput {
                                     device_id,
                                     state,
-                                    button: Other(x as u8),
+                                    button: Other(x as u16),
                                     modifiers,
                                 },
                             }),
@@ -1164,57 +1164,56 @@ impl<T: 'static> EventProcessor<T> {
                     if let Some(prev_list) = prev_list {
                         let new_list = wt.xconn.available_monitors();
                         for new_monitor in new_list {
-                            prev_list
+                            // Previous list may be empty, in case of disconnecting and
+                            // reconnecting the only one monitor. We still need to emit events in
+                            // this case.
+                            let maybe_prev_scale_factor = prev_list
                                 .iter()
                                 .find(|prev_monitor| prev_monitor.name == new_monitor.name)
-                                .map(|prev_monitor| {
-                                    if new_monitor.scale_factor != prev_monitor.scale_factor {
-                                        for (window_id, window) in wt.windows.borrow().iter() {
-                                            if let Some(window) = window.upgrade() {
-                                                // Check if the window is on this monitor
-                                                let monitor = window.current_monitor();
-                                                if monitor.name == new_monitor.name {
-                                                    let (width, height) =
-                                                        window.inner_size_physical();
-                                                    let (new_width, new_height) = window
-                                                        .adjust_for_dpi(
-                                                            prev_monitor.scale_factor,
-                                                            new_monitor.scale_factor,
-                                                            width,
-                                                            height,
-                                                            &*window.shared_state.lock(),
-                                                        );
+                                .map(|prev_monitor| prev_monitor.scale_factor);
+                            if Some(new_monitor.scale_factor) != maybe_prev_scale_factor {
+                                for (window_id, window) in wt.windows.borrow().iter() {
+                                    if let Some(window) = window.upgrade() {
+                                        // Check if the window is on this monitor
+                                        let monitor = window.current_monitor();
+                                        if monitor.name == new_monitor.name {
+                                            let (width, height) = window.inner_size_physical();
+                                            let (new_width, new_height) = window.adjust_for_dpi(
+                                                // If there all monitors are closed before, scale
+                                                // factor would be already changed to 1.0.
+                                                maybe_prev_scale_factor.unwrap_or(1.0),
+                                                new_monitor.scale_factor,
+                                                width,
+                                                height,
+                                                &*window.shared_state.lock(),
+                                            );
 
-                                                    let window_id = crate::window::WindowId(
-                                                        crate::platform_impl::platform::WindowId::X(
-                                                            *window_id,
-                                                        ),
-                                                    );
-                                                    let old_inner_size =
-                                                        PhysicalSize::new(width, height);
-                                                    let mut new_inner_size =
-                                                        PhysicalSize::new(new_width, new_height);
+                                            let window_id = crate::window::WindowId(
+                                                crate::platform_impl::platform::WindowId::X(
+                                                    *window_id,
+                                                ),
+                                            );
+                                            let old_inner_size = PhysicalSize::new(width, height);
+                                            let mut new_inner_size =
+                                                PhysicalSize::new(new_width, new_height);
 
-                                                    callback(Event::WindowEvent {
-                                                        window_id,
-                                                        event: WindowEvent::ScaleFactorChanged {
-                                                            scale_factor: new_monitor.scale_factor,
-                                                            new_inner_size: &mut new_inner_size,
-                                                        },
-                                                    });
+                                            callback(Event::WindowEvent {
+                                                window_id,
+                                                event: WindowEvent::ScaleFactorChanged {
+                                                    scale_factor: new_monitor.scale_factor,
+                                                    new_inner_size: &mut new_inner_size,
+                                                },
+                                            });
 
-                                                    if new_inner_size != old_inner_size {
-                                                        let (new_width, new_height) =
-                                                            new_inner_size.into();
-                                                        window.set_inner_size_physical(
-                                                            new_width, new_height,
-                                                        );
-                                                    }
-                                                }
+                                            if new_inner_size != old_inner_size {
+                                                let (new_width, new_height) = new_inner_size.into();
+                                                window
+                                                    .set_inner_size_physical(new_width, new_height);
                                             }
                                         }
                                     }
-                                });
+                                }
+                            }
                         }
                     }
                 }

src/platform_impl/linux/x11/ffi.rs

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

src/platform_impl/linux/x11/mod.rs

@@ -32,15 +32,14 @@ use std::{
     ptr,
     rc::Rc,
     slice,
-    sync::{mpsc, Arc, Mutex, Weak},
+    sync::mpsc::{Receiver, Sender},
+    sync::{mpsc, Arc, Weak},
     time::{Duration, Instant},
 };
 
 use libc::{self, setlocale, LC_CTYPE};
 
-use mio::{unix::EventedFd, Events, Poll, PollOpt, Ready, Token};
-
-use mio_extras::channel::{channel, Receiver, SendError, Sender};
+use mio::{unix::SourceFd, Events, Interest, Poll, Token, Waker};
 
 use self::{
     dnd::{Dnd, DndState},
@@ -57,7 +56,12 @@ use crate::{
 };
 
 const X_TOKEN: Token = Token(0);
-const USER_TOKEN: Token = Token(1);
+const USER_REDRAW_TOKEN: Token = Token(1);
+
+struct WakeSender<T> {
+    sender: Sender<T>,
+    waker: Arc<Waker>,
+}
 
 pub struct EventLoopWindowTarget<T> {
     xconn: Arc<XConnection>,
@@ -67,26 +71,30 @@ pub struct EventLoopWindowTarget<T> {
     root: ffi::Window,
     ime: RefCell<Ime>,
     windows: RefCell<HashMap<WindowId, Weak<UnownedWindow>>>,
-    pending_redraws: Arc<Mutex<HashSet<WindowId>>>,
+    redraw_sender: WakeSender<WindowId>,
     _marker: ::std::marker::PhantomData<T>,
 }
 
 pub struct EventLoop<T: 'static> {
     poll: Poll,
+    waker: Arc<Waker>,
     event_processor: EventProcessor<T>,
-    user_channel: Receiver<T>,
+    redraw_channel: Receiver<WindowId>,
+    user_channel: Receiver<T>, //waker.wake needs to be called whenever something gets sent
     user_sender: Sender<T>,
     target: Rc<RootELW<T>>,
 }
 
 pub struct EventLoopProxy<T: 'static> {
     user_sender: Sender<T>,
+    waker: Arc<Waker>,
 }
 
 impl<T: 'static> Clone for EventLoopProxy<T> {
     fn clone(&self) -> Self {
         EventLoopProxy {
             user_sender: self.user_sender.clone(),
+            waker: self.waker.clone(),
         }
     }
 }
@@ -129,7 +137,7 @@ impl<T: 'static> EventLoop<T> {
         let ime = RefCell::new({
             let result = Ime::new(Arc::clone(&xconn));
             if let Err(ImeCreationError::OpenFailure(ref state)) = result {
-                panic!(format!("Failed to open input method: {:#?}", state));
+                panic!("Failed to open input method: {:#?}", state);
             }
             result.expect("Failed to set input method destruction callback")
         });
@@ -174,11 +182,19 @@ impl<T: 'static> EventLoop<T> {
 
         xconn.update_cached_wm_info(root);
 
-        let pending_redraws: Arc<Mutex<HashSet<WindowId>>> = Default::default();
-
         let mut mod_keymap = ModifierKeymap::new();
         mod_keymap.reset_from_x_connection(&xconn);
 
+        let poll = Poll::new().unwrap();
+        let waker = Arc::new(Waker::new(poll.registry(), USER_REDRAW_TOKEN).unwrap());
+
+        poll.registry()
+            .register(&mut SourceFd(&xconn.x11_fd), X_TOKEN, Interest::READABLE)
+            .unwrap();
+
+        let (user_sender, user_channel) = std::sync::mpsc::channel();
+        let (redraw_sender, redraw_channel) = std::sync::mpsc::channel();
+
         let target = Rc::new(RootELW {
             p: super::EventLoopWindowTarget::X(EventLoopWindowTarget {
                 ime,
@@ -189,31 +205,14 @@ impl<T: 'static> EventLoop<T> {
                 xconn,
                 wm_delete_window,
                 net_wm_ping,
-                pending_redraws: pending_redraws.clone(),
+                redraw_sender: WakeSender {
+                    sender: redraw_sender, // not used again so no clone
+                    waker: waker.clone(),
+                },
             }),
             _marker: ::std::marker::PhantomData,
         });
 
-        let poll = Poll::new().unwrap();
-
-        let (user_sender, user_channel) = channel();
-
-        poll.register(
-            &EventedFd(&get_xtarget(&target).xconn.x11_fd),
-            X_TOKEN,
-            Ready::readable(),
-            PollOpt::level(),
-        )
-        .unwrap();
-
-        poll.register(
-            &user_channel,
-            USER_TOKEN,
-            Ready::readable(),
-            PollOpt::level(),
-        )
-        .unwrap();
-
         let event_processor = EventProcessor {
             target: target.clone(),
             dnd,
@@ -237,20 +236,21 @@ impl<T: 'static> EventLoop<T> {
 
         event_processor.init_device(ffi::XIAllDevices);
 
-        let result = EventLoop {
+        EventLoop {
             poll,
+            waker,
+            event_processor,
+            redraw_channel,
             user_channel,
             user_sender,
-            event_processor,
             target,
-        };
-
-        result
+        }
     }
 
     pub fn create_proxy(&self) -> EventLoopProxy<T> {
         EventLoopProxy {
             user_sender: self.user_sender.clone(),
+            waker: self.waker.clone(),
         }
     }
 
@@ -277,8 +277,6 @@ impl<T: 'static> EventLoop<T> {
             // Process all pending events
             self.drain_events(&mut callback, &mut control_flow);
 
-            let wt = get_xtarget(&self.target);
-
             // Empty the user event buffer
             {
                 while let Ok(event) = self.user_channel.try_recv() {
@@ -301,12 +299,16 @@ impl<T: 'static> EventLoop<T> {
             }
             // Empty the redraw requests
             {
-                // Release the lock to prevent deadlock
-                let windows: Vec<_> = wt.pending_redraws.lock().unwrap().drain().collect();
+                let mut windows = HashSet::new();
 
-                for wid in windows {
+                while let Ok(window_id) = self.redraw_channel.try_recv() {
+                    windows.insert(window_id);
+                }
+
+                for window_id in windows {
+                    let window_id = crate::window::WindowId(super::WindowId::X(window_id));
                     sticky_exit_callback(
-                        Event::RedrawRequested(crate::window::WindowId(super::WindowId::X(wid))),
+                        Event::RedrawRequested(window_id),
                         &self.target,
                         &mut control_flow,
                         &mut callback,
@@ -358,7 +360,11 @@ impl<T: 'static> EventLoop<T> {
             // If the XConnection already contains buffered events, we don't
             // need to wait for data on the socket.
             if !self.event_processor.poll() {
-                self.poll.poll(&mut events, timeout).unwrap();
+                if let Err(e) = self.poll.poll(&mut events, timeout) {
+                    if e.raw_os_error() != Some(libc::EINTR) {
+                        panic!("epoll returned an error: {:?}", e);
+                    }
+                }
                 events.clear();
             }
 
@@ -393,7 +399,6 @@ impl<T: 'static> EventLoop<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()) } {
@@ -408,7 +413,8 @@ impl<T: 'static> EventLoop<T> {
                             super::WindowId::X(wid),
                         )) = event
                         {
-                            wt.pending_redraws.lock().unwrap().insert(wid);
+                            wt.redraw_sender.sender.send(wid).unwrap();
+                            wt.redraw_sender.waker.wake().unwrap();
                         } else {
                             callback(event, window_target, control_flow);
                         }
@@ -437,13 +443,10 @@ impl<T> EventLoopWindowTarget<T> {
 
 impl<T: 'static> EventLoopProxy<T> {
     pub fn send_event(&self, event: T) -> Result<(), EventLoopClosed<T>> {
-        self.user_sender.send(event).map_err(|e| {
-            EventLoopClosed(if let SendError::Disconnected(x) = e {
-                x
-            } else {
-                unreachable!()
-            })
-        })
+        self.user_sender
+            .send(event)
+            .map_err(|e| EventLoopClosed(e.0))
+            .map(|_| self.waker.wake().unwrap())
     }
 }
 
@@ -491,7 +494,7 @@ impl<'a> Deref for DeviceInfo<'a> {
 pub struct WindowId(ffi::Window);
 
 impl WindowId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         WindowId(0)
     }
 }
@@ -500,7 +503,7 @@ impl WindowId {
 pub struct DeviceId(c_int);
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         DeviceId(0)
     }
 }
@@ -521,7 +524,7 @@ impl Window {
         attribs: WindowAttributes,
         pl_attribs: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Self, RootOsError> {
-        let window = Arc::new(UnownedWindow::new(&event_loop, attribs, pl_attribs)?);
+        let window = Arc::new(UnownedWindow::new(event_loop, attribs, pl_attribs)?);
         event_loop
             .windows
             .borrow_mut()

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

@@ -27,12 +27,11 @@ impl XConnection {
                 (self.xlib.XInternAtom)(self.display, name.as_ptr() as *const c_char, ffi::False)
             };
             if atom == 0 {
-                let msg = format!(
+                panic!(
                     "`XInternAtom` failed, which really shouldn't happen. Atom: {:?}, Error: {:#?}",
                     name,
                     self.check_errors(),
                 );
-                panic!(msg);
             }
             /*println!(
                 "XInternAtom name:{:?} atom:{:?}",

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

@@ -104,8 +104,8 @@ impl XConnection {
             CursorIcon::WResize => load(b"left_side\0"),
             CursorIcon::EwResize => load(b"h_double_arrow\0"),
             CursorIcon::NsResize => load(b"v_double_arrow\0"),
-            CursorIcon::NwseResize => loadn(&[b"bd_double_arrow\0", b"size_bdiag\0"]),
-            CursorIcon::NeswResize => loadn(&[b"fd_double_arrow\0", b"size_fdiag\0"]),
+            CursorIcon::NwseResize => loadn(&[b"bd_double_arrow\0", b"size_fdiag\0"]),
+            CursorIcon::NeswResize => loadn(&[b"fd_double_arrow\0", b"size_bdiag\0"]),
             CursorIcon::ColResize => loadn(&[b"split_h\0", b"h_double_arrow\0"]),
             CursorIcon::RowResize => loadn(&[b"split_v\0", b"v_double_arrow\0"]),
 

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

@@ -190,6 +190,24 @@ impl<'a> NormalHints<'a> {
         }
     }
 
+    pub fn get_position(&self) -> Option<(i32, i32)> {
+        if has_flag(self.size_hints.flags, ffi::PPosition) {
+            Some((self.size_hints.x as i32, self.size_hints.y as i32))
+        } else {
+            None
+        }
+    }
+
+    pub fn set_position(&mut self, position: Option<(i32, i32)>) {
+        if let Some((x, y)) = position {
+            self.size_hints.flags |= ffi::PPosition;
+            self.size_hints.x = x as c_int;
+            self.size_hints.y = y as c_int;
+        } else {
+            self.size_hints.flags &= !ffi::PPosition;
+        }
+    }
+
     // WARNING: This hint is obsolete
     pub fn set_size(&mut self, size: Option<(u32, u32)>) {
         if let Some((width, height)) = size {

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

@@ -23,6 +23,7 @@ pub use self::{
 
 use std::{
     mem::{self, MaybeUninit},
+    ops::BitAnd,
     os::raw::*,
     ptr,
 };
@@ -39,6 +40,13 @@ 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
+}
+
 #[must_use = "This request was made asynchronously, and is still in the output buffer. You must explicitly choose to either `.flush()` (empty the output buffer, sending the request now) or `.queue()` (wait to send the request, allowing you to continue to add more requests without additional round-trips). For more information, see the documentation for `util::flush_requests`."]
 pub struct Flusher<'a> {
     xconn: &'a XConnection,

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

@@ -27,7 +27,11 @@ pub fn calc_dpi_factor(
     // Quantize 1/12 step size
     let dpi_factor = ((ppmm * (12.0 * 25.4 / 96.0)).round() / 12.0).max(1.0);
     assert!(validate_scale_factor(dpi_factor));
-    dpi_factor
+    if dpi_factor <= 20. {
+        dpi_factor
+    } else {
+        1.
+    }
 }
 
 impl XConnection {

src/platform_impl/linux/x11/window.rs

@@ -1,8 +1,6 @@
-use raw_window_handle::unix::XlibHandle;
+use raw_window_handle::XlibHandle;
 use std::{
-    cmp,
-    collections::HashSet,
-    env,
+    cmp, env,
     ffi::CString,
     mem::{self, replace, MaybeUninit},
     os::raw::*,
@@ -10,6 +8,7 @@ use std::{
     ptr, slice,
     sync::Arc,
 };
+use x11_dl::xlib::TrueColor;
 
 use libc;
 use parking_lot::Mutex;
@@ -23,10 +22,12 @@ use crate::{
         MonitorHandle as PlatformMonitorHandle, OsError, PlatformSpecificWindowBuilderAttributes,
         VideoMode as PlatformVideoMode,
     },
-    window::{CursorIcon, Fullscreen, Icon, WindowAttributes},
+    window::{CursorIcon, Fullscreen, Icon, UserAttentionType, WindowAttributes},
 };
 
-use super::{ffi, util, EventLoopWindowTarget, ImeSender, WindowId, XConnection, XError};
+use super::{
+    ffi, util, EventLoopWindowTarget, ImeSender, WakeSender, WindowId, XConnection, XError,
+};
 
 #[derive(Debug)]
 pub struct SharedState {
@@ -104,7 +105,7 @@ pub struct UnownedWindow {
     cursor_visible: Mutex<bool>,
     ime_sender: Mutex<ImeSender>,
     pub shared_state: Mutex<SharedState>,
-    pending_redraws: Arc<::std::sync::Mutex<HashSet<WindowId>>>,
+    redraw_sender: WakeSender<WindowId>,
 }
 
 impl UnownedWindow {
@@ -147,6 +148,10 @@ impl UnownedWindow {
             .min_inner_size
             .map(|size| size.to_physical::<u32>(scale_factor).into());
 
+        let position = window_attrs
+            .position
+            .map(|position| position.to_physical::<i32>(scale_factor).into());
+
         let dimensions = {
             // x11 only applies constraints when the window is actively resized
             // by the user, so we have to manually apply the initial constraints
@@ -177,6 +182,39 @@ impl UnownedWindow {
         };
 
         // creating
+        let (visual, depth, require_colormap) = match pl_attribs.visual_infos {
+            Some(vi) => (vi.visual, vi.depth, false),
+            None if window_attrs.transparent == true => {
+                // Find a suitable visual
+                let mut vinfo = MaybeUninit::uninit();
+                let vinfo_initialized = unsafe {
+                    (xconn.xlib.XMatchVisualInfo)(
+                        xconn.display,
+                        screen_id,
+                        32,
+                        TrueColor,
+                        vinfo.as_mut_ptr(),
+                    ) != 0
+                };
+                if vinfo_initialized {
+                    let vinfo = unsafe { vinfo.assume_init() };
+                    (vinfo.visual, vinfo.depth, true)
+                } else {
+                    debug!("Could not set transparency, because XMatchVisualInfo returned zero for the required parameters");
+                    (
+                        ffi::CopyFromParent as *mut ffi::Visual,
+                        ffi::CopyFromParent,
+                        false,
+                    )
+                }
+            }
+            _ => (
+                ffi::CopyFromParent as *mut ffi::Visual,
+                ffi::CopyFromParent,
+                false,
+            ),
+        };
+
         let mut set_win_attr = {
             let mut swa: ffi::XSetWindowAttributes = unsafe { mem::zeroed() };
             swa.colormap = if let Some(vi) = pl_attribs.visual_infos {
@@ -184,6 +222,8 @@ impl UnownedWindow {
                     let visual = vi.visual;
                     (xconn.xlib.XCreateColormap)(xconn.display, root, visual, ffi::AllocNone)
                 }
+            } else if require_colormap {
+                unsafe { (xconn.xlib.XCreateColormap)(xconn.display, root, visual, ffi::AllocNone) }
             } else {
                 0
             };
@@ -212,28 +252,14 @@ impl UnownedWindow {
             (xconn.xlib.XCreateWindow)(
                 xconn.display,
                 root,
-                0,
-                0,
+                position.map_or(0, |p: PhysicalPosition<i32>| p.x as c_int),
+                position.map_or(0, |p: PhysicalPosition<i32>| p.y as c_int),
                 dimensions.0 as c_uint,
                 dimensions.1 as c_uint,
                 0,
-                match pl_attribs.visual_infos {
-                    Some(vi) => vi.depth,
-                    None => ffi::CopyFromParent,
-                },
+                depth,
                 ffi::InputOutput as c_uint,
-                // TODO: If window wants transparency and `visual_infos` is None,
-                // we need to find our own visual which has an `alphaMask` which
-                // is > 0, like we do in glutin.
-                //
-                // It is non obvious which masks, if any, we should pass to
-                // `XGetVisualInfo`. winit doesn't receive any info about what
-                // properties the user wants. Users should consider choosing the
-                // visual themselves as glutin does.
-                match pl_attribs.visual_infos {
-                    Some(vi) => vi.visual,
-                    None => ffi::CopyFromParent as *mut ffi::Visual,
-                },
+                visual,
                 window_attributes,
                 &mut set_win_attr,
             )
@@ -249,7 +275,10 @@ impl UnownedWindow {
             cursor_visible: Mutex::new(true),
             ime_sender: Mutex::new(event_loop.ime_sender.clone()),
             shared_state: SharedState::new(guessed_monitor, window_attrs.visible),
-            pending_redraws: event_loop.pending_redraws.clone(),
+            redraw_sender: WakeSender {
+                waker: event_loop.redraw_sender.waker.clone(),
+                sender: event_loop.redraw_sender.sender.clone(),
+            },
         };
 
         // Title must be set before mapping. Some tiling window managers (i.e. i3) use the window
@@ -345,6 +374,7 @@ impl UnownedWindow {
                 }
 
                 let mut normal_hints = util::NormalHints::new(xconn);
+                normal_hints.set_position(position.map(|PhysicalPosition { x, y }| (x, y)));
                 normal_hints.set_size(Some(dimensions));
                 normal_hints.set_min_size(min_inner_size.map(Into::into));
                 normal_hints.set_max_size(max_inner_size.map(Into::into));
@@ -440,6 +470,12 @@ impl UnownedWindow {
                 window
                     .set_fullscreen_inner(window_attrs.fullscreen.clone())
                     .map(|flusher| flusher.queue());
+
+                if let Some(PhysicalPosition { x, y }) = position {
+                    let shared_state = window.shared_state.get_mut();
+
+                    shared_state.restore_position = Some((x, y));
+                }
             }
             if window_attrs.always_on_top {
                 window
@@ -524,23 +560,6 @@ impl UnownedWindow {
         )
     }
 
-    #[inline]
-    pub fn set_urgent(&self, is_urgent: bool) {
-        let mut wm_hints = self
-            .xconn
-            .get_wm_hints(self.xwindow)
-            .expect("`XGetWMHints` failed");
-        if is_urgent {
-            (*wm_hints).flags |= ffi::XUrgencyHint;
-        } else {
-            (*wm_hints).flags &= !ffi::XUrgencyHint;
-        }
-        self.xconn
-            .set_wm_hints(self.xwindow, wm_hints)
-            .flush()
-            .expect("Failed to set urgency hint");
-    }
-
     fn set_netwm(
         &self,
         operation: util::StateOperation,
@@ -786,6 +805,30 @@ impl UnownedWindow {
             .expect("Failed to change window minimization");
     }
 
+    #[inline]
+    pub fn is_maximized(&self) -> bool {
+        let state_atom = unsafe { self.xconn.get_atom_unchecked(b"_NET_WM_STATE\0") };
+        let state = self
+            .xconn
+            .get_property(self.xwindow, state_atom, ffi::XA_ATOM);
+        let horz_atom = unsafe {
+            self.xconn
+                .get_atom_unchecked(b"_NET_WM_STATE_MAXIMIZED_HORZ\0")
+        };
+        let vert_atom = unsafe {
+            self.xconn
+                .get_atom_unchecked(b"_NET_WM_STATE_MAXIMIZED_VERT\0")
+        };
+        match state {
+            Ok(atoms) => {
+                let horz_maximized = atoms.iter().any(|atom: &ffi::Atom| *atom == horz_atom);
+                let vert_maximized = atoms.iter().any(|atom: &ffi::Atom| *atom == vert_atom);
+                horz_maximized && vert_maximized
+            }
+            _ => false,
+        }
+    }
+
     fn set_maximized_inner(&self, maximized: bool) -> util::Flusher<'_> {
         let horz_atom = unsafe {
             self.xconn
@@ -1063,7 +1106,7 @@ impl UnownedWindow {
 
     fn update_normal_hints<F>(&self, callback: F) -> Result<(), XError>
     where
-        F: FnOnce(&mut util::NormalHints<'_>) -> (),
+        F: FnOnce(&mut util::NormalHints<'_>),
     {
         let mut normal_hints = self.xconn.get_normal_hints(self.xwindow)?;
         callback(&mut normal_hints);
@@ -1144,7 +1187,7 @@ impl UnownedWindow {
             )
         } else {
             let window_size = Some(Size::from(self.inner_size()));
-            (window_size.clone(), window_size)
+            (window_size, window_size)
         };
 
         self.set_maximizable_inner(resizable).queue();
@@ -1294,6 +1337,46 @@ impl UnownedWindow {
         self.set_cursor_position_physical(x, y)
     }
 
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        let pointer = self
+            .xconn
+            .query_pointer(self.xwindow, util::VIRTUAL_CORE_POINTER)
+            .map_err(|err| ExternalError::Os(os_error!(OsError::XError(err))))?;
+
+        let window = self.inner_position().map_err(ExternalError::NotSupported)?;
+
+        let message = unsafe { self.xconn.get_atom_unchecked(b"_NET_WM_MOVERESIZE\0") };
+
+        // we can't use `set_cursor_grab(false)` here because it doesn't run `XUngrabPointer`
+        // if the cursor isn't currently grabbed
+        let mut grabbed_lock = self.cursor_grabbed.lock();
+        unsafe {
+            (self.xconn.xlib.XUngrabPointer)(self.xconn.display, ffi::CurrentTime);
+        }
+        self.xconn
+            .flush_requests()
+            .map_err(|err| ExternalError::Os(os_error!(OsError::XError(err))))?;
+        *grabbed_lock = false;
+
+        // we keep the lock until we are done
+        self.xconn
+            .send_client_msg(
+                self.xwindow,
+                self.root,
+                message,
+                Some(ffi::SubstructureRedirectMask | ffi::SubstructureNotifyMask),
+                [
+                    (window.x as c_long + pointer.win_x as c_long),
+                    (window.y as c_long + pointer.win_y as c_long),
+                    8, // _NET_WM_MOVERESIZE_MOVE
+                    ffi::Button1 as c_long,
+                    1,
+                ],
+            )
+            .flush()
+            .map_err(|err| ExternalError::Os(os_error!(OsError::XError(err))))
+    }
+
     pub(crate) fn set_ime_position_physical(&self, x: i32, y: i32) {
         let _ = self
             .ime_sender
@@ -1307,6 +1390,58 @@ impl UnownedWindow {
         self.set_ime_position_physical(x, y);
     }
 
+    #[inline]
+    pub fn focus_window(&self) {
+        let state_atom = unsafe { self.xconn.get_atom_unchecked(b"WM_STATE\0") };
+        let state_type_atom = unsafe { self.xconn.get_atom_unchecked(b"CARD32\0") };
+        let is_minimized = if let Ok(state) =
+            self.xconn
+                .get_property(self.xwindow, state_atom, state_type_atom)
+        {
+            state.contains(&(ffi::IconicState as c_ulong))
+        } else {
+            false
+        };
+        let is_visible = match self.shared_state.lock().visibility {
+            Visibility::Yes => true,
+            Visibility::YesWait | Visibility::No => false,
+        };
+
+        if is_visible && !is_minimized {
+            let atom = unsafe { self.xconn.get_atom_unchecked(b"_NET_ACTIVE_WINDOW\0") };
+            let flusher = self.xconn.send_client_msg(
+                self.xwindow,
+                self.root,
+                atom,
+                Some(ffi::SubstructureRedirectMask | ffi::SubstructureNotifyMask),
+                [1, ffi::CurrentTime as c_long, 0, 0, 0],
+            );
+            if let Err(e) = flusher.flush() {
+                log::error!(
+                    "`flush` returned an error when focusing the window. Error was: {}",
+                    e
+                );
+            }
+        }
+    }
+
+    #[inline]
+    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        let mut wm_hints = self
+            .xconn
+            .get_wm_hints(self.xwindow)
+            .expect("`XGetWMHints` failed");
+        if request_type.is_some() {
+            (*wm_hints).flags |= ffi::XUrgencyHint;
+        } else {
+            (*wm_hints).flags &= !ffi::XUrgencyHint;
+        }
+        self.xconn
+            .set_wm_hints(self.xwindow, wm_hints)
+            .flush()
+            .expect("Failed to set urgency hint");
+    }
+
     #[inline]
     pub fn id(&self) -> WindowId {
         WindowId(self.xwindow)
@@ -1314,18 +1449,18 @@ impl UnownedWindow {
 
     #[inline]
     pub fn request_redraw(&self) {
-        self.pending_redraws
-            .lock()
-            .unwrap()
-            .insert(WindowId(self.xwindow));
+        self.redraw_sender
+            .sender
+            .send(WindowId(self.xwindow))
+            .unwrap();
+        self.redraw_sender.waker.wake().unwrap();
     }
 
     #[inline]
     pub fn raw_window_handle(&self) -> XlibHandle {
-        XlibHandle {
-            window: self.xwindow,
-            display: self.xconn.display as _,
-            ..XlibHandle::empty()
-        }
+        let mut handle = XlibHandle::empty();
+        handle.window = self.xlib_window();
+        handle.display = self.xlib_display();
+        handle
     }
 }

src/platform_impl/macos/activation_hack.rs

@@ -1,208 +0,0 @@
-// Normally when you run or distribute a macOS app, it's bundled: it's in one
-// of those fun little folders that you have to right click "Show Package
-// Contents" on, and usually contains myriad delights including, but not
-// limited to, plists, icons, and of course, your beloved executable. However,
-// when you use `cargo run`, your app is unbundled - it's just a lonely, bare
-// executable.
-//
-// Apple isn't especially fond of unbundled apps, which is to say, they seem to
-// barely be supported. If you move the mouse while opening a winit window from
-// an unbundled app, the window will fail to activate and be in a grayed-out
-// uninteractable state. Switching to another app and back is the only way to
-// get the winit window into a normal state. None of this happens if the app is
-// bundled, i.e. when running via Xcode.
-//
-// To workaround this, we just switch focus to the Dock and then switch back to
-// our app. We only do this for unbundled apps, and only when they fail to
-// become active on their own.
-//
-// This solution was derived from this Godot PR:
-// https://github.com/godotengine/godot/pull/17187
-// (which appears to be based on https://stackoverflow.com/a/7602677)
-// The curious specialness of mouse motions is touched upon here:
-// https://github.com/godotengine/godot/issues/8653#issuecomment-358130512
-//
-// We omit the 2nd step of the solution used in Godot, since it appears to have
-// no effect - I speculate that it's just technical debt picked up from the SO
-// answer; the API used is fairly exotic, and was historically used for very
-// old versions of macOS that didn't support `activateIgnoringOtherApps`, i.e.
-// in previous versions of SDL:
-// https://hg.libsdl.org/SDL/file/c0bcc39a3491/src/video/cocoa/SDL_cocoaevents.m#l322
-//
-// The `performSelector` delays in the Godot solution are used for sequencing,
-// since refocusing the app will fail if the call is made before it finishes
-// unfocusing. The delays used there are much smaller than the ones in the
-// original SO answer, presumably because they found the fastest delay that
-// works reliably through trial and error. Instead of using delays, we just
-// handle `applicationDidResignActive`; despite the app not activating reliably,
-// that still triggers when we switch focus to the Dock.
-//
-// The Godot solution doesn't appear to skip the hack when an unbundled app
-// activates normally. Checking for this is difficult, since if you call
-// `isActive` too early, it will always be `NO`. Even though we receive
-// `applicationDidResignActive` when switching focus to the Dock, we never
-// receive a preceding `applicationDidBecomeActive` if the app fails to
-// activate normally. I wasn't able to find a proper point in time to perform
-// the `isActive` check, so we instead check for the cause of the quirk: if
-// any mouse motion occurs prior to us receiving `applicationDidResignActive`,
-// we assume the app failed to become active.
-//
-// Fun fact: this issue is still present in GLFW
-// (https://github.com/glfw/glfw/issues/1515)
-//
-// A similar issue was found in SDL, but the resolution doesn't seem to work
-// for us: https://bugzilla.libsdl.org/show_bug.cgi?id=3051
-
-use super::util;
-use cocoa::{
-    appkit::{NSApp, NSApplicationActivateIgnoringOtherApps},
-    base::id,
-    foundation::NSUInteger,
-};
-use objc::runtime::{Object, Sel, BOOL, NO, YES};
-use std::{
-    os::raw::c_void,
-    sync::atomic::{AtomicBool, Ordering},
-};
-
-#[derive(Debug, Default)]
-pub struct State {
-    // Indicates that the hack has either completed or been skipped.
-    activated: AtomicBool,
-    // Indicates that the mouse has moved at some point in time.
-    mouse_moved: AtomicBool,
-    // Indicates that the hack is in progress, and that we should refocus when
-    // the app resigns active.
-    needs_refocus: AtomicBool,
-}
-
-impl State {
-    pub fn name() -> &'static str {
-        "activationHackState"
-    }
-
-    pub fn new() -> *mut c_void {
-        let this = Box::new(Self::default());
-        Box::into_raw(this) as *mut c_void
-    }
-
-    pub unsafe fn free(this: *mut Self) {
-        Box::from_raw(this);
-    }
-
-    pub unsafe fn get_ptr(obj: &Object) -> *mut Self {
-        let this: *mut c_void = *(*obj).get_ivar(Self::name());
-        assert!(!this.is_null(), "`activationHackState` pointer was null");
-        this as *mut Self
-    }
-
-    pub unsafe fn set_activated(obj: &Object, value: bool) {
-        let this = Self::get_ptr(obj);
-        (*this).activated.store(value, Ordering::Release);
-    }
-
-    unsafe fn get_activated(obj: &Object) -> bool {
-        let this = Self::get_ptr(obj);
-        (*this).activated.load(Ordering::Acquire)
-    }
-
-    pub unsafe fn set_mouse_moved(obj: &Object, value: bool) {
-        let this = Self::get_ptr(obj);
-        (*this).mouse_moved.store(value, Ordering::Release);
-    }
-
-    pub unsafe fn get_mouse_moved(obj: &Object) -> bool {
-        let this = Self::get_ptr(obj);
-        (*this).mouse_moved.load(Ordering::Acquire)
-    }
-
-    pub unsafe fn set_needs_refocus(obj: &Object, value: bool) {
-        let this = Self::get_ptr(obj);
-        (*this).needs_refocus.store(value, Ordering::Release);
-    }
-
-    unsafe fn get_needs_refocus(obj: &Object) -> bool {
-        let this = Self::get_ptr(obj);
-        (*this).needs_refocus.load(Ordering::Acquire)
-    }
-}
-
-// This is the entry point for the hack - if the app is unbundled and a mouse
-// movement occurs before the app activates, it will trigger the hack. Because
-// mouse movements prior to activation are the cause of this quirk, they should
-// be a reliable way to determine if the hack needs to be performed.
-pub extern "C" fn mouse_moved(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `activationHackMouseMoved`");
-    unsafe {
-        if !State::get_activated(this) {
-            // We check if `CFBundleName` is undefined to determine if the
-            // app is unbundled.
-            if let None = util::app_name() {
-                info!("App detected as unbundled");
-                unfocus(this);
-            } else {
-                info!("App detected as bundled");
-            }
-        }
-    }
-    trace!("Completed `activationHackMouseMoved`");
-}
-
-// Switch focus to the dock.
-unsafe fn unfocus(this: &Object) {
-    // We only perform the hack if the app failed to activate, since otherwise,
-    // there'd be a gross (but fast) flicker as it unfocused and then refocused.
-    // However, we only enter this function if we detect mouse movement prior
-    // to activation, so this should always be `NO`.
-    //
-    // Note that this check isn't necessarily reliable in detecting a violation
-    // of the invariant above, since it's not guaranteed that activation will
-    // resolve before this point. In other words, it can spuriously return `NO`.
-    // This is also why the mouse motion approach was chosen, since it's not
-    // obvious how to sequence this check - if someone knows how to, then that
-    // would almost surely be a cleaner approach.
-    let active: BOOL = msg_send![NSApp(), isActive];
-    if active == YES {
-        error!("Unbundled app activation hack triggered on an app that's already active; this shouldn't happen!");
-    } else {
-        info!("Performing unbundled app activation hack");
-        let dock_bundle_id = util::ns_string_id_ref("com.apple.dock");
-        let dock_array: id = msg_send![
-            class!(NSRunningApplication),
-            runningApplicationsWithBundleIdentifier: *dock_bundle_id
-        ];
-        let dock_array_len: NSUInteger = msg_send![dock_array, count];
-        if dock_array_len == 0 {
-            error!("The Dock doesn't seem to be running, so switching focus to it is impossible");
-        } else {
-            State::set_needs_refocus(this, true);
-            let dock: id = msg_send![dock_array, objectAtIndex: 0];
-            // This will trigger `applicationDidResignActive`, which will in
-            // turn call `refocus`.
-            let status: BOOL = msg_send![
-                dock,
-                activateWithOptions: NSApplicationActivateIgnoringOtherApps
-            ];
-            if status == NO {
-                error!("Failed to switch focus to Dock");
-            }
-        }
-    }
-}
-
-// Switch focus back to our app, causing the user to rejoice!
-pub unsafe fn refocus(this: &Object) {
-    if State::get_needs_refocus(this) {
-        State::set_needs_refocus(this, false);
-        let app: id = msg_send![class!(NSRunningApplication), currentApplication];
-        // Simply calling `NSApp activateIgnoringOtherApps` doesn't work. The
-        // nuanced difference isn't clear to me, but hey, I tried.
-        let success: BOOL = msg_send![
-            app,
-            activateWithOptions: NSApplicationActivateIgnoringOtherApps
-        ];
-        if success == NO {
-            error!("Failed to refocus app");
-        }
-    }
-}

src/platform_impl/macos/app.rs

@@ -2,14 +2,14 @@ use std::collections::VecDeque;
 
 use cocoa::{
     appkit::{self, NSEvent},
-    base::{id, nil},
+    base::id,
 };
 use objc::{
     declare::ClassDecl,
     runtime::{Class, Object, Sel},
 };
 
-use super::{activation_hack, app_state::AppState, event::EventWrapper, util, DEVICE_ID};
+use super::{app_state::AppState, event::EventWrapper, util, DEVICE_ID};
 use crate::event::{DeviceEvent, ElementState, Event};
 
 pub struct AppClass(pub *const Class);
@@ -49,14 +49,14 @@ extern "C" fn send_event(this: &Object, _sel: Sel, event: id) {
             let key_window: id = msg_send![this, keyWindow];
             let _: () = msg_send![key_window, sendEvent: event];
         } else {
-            maybe_dispatch_device_event(this, event);
+            maybe_dispatch_device_event(event);
             let superclass = util::superclass(this);
             let _: () = msg_send![super(this, superclass), sendEvent: event];
         }
     }
 }
 
-unsafe fn maybe_dispatch_device_event(this: &Object, event: id) {
+unsafe fn maybe_dispatch_device_event(event: id) {
     let event_type = event.eventType();
     match event_type {
         appkit::NSMouseMoved
@@ -98,21 +98,6 @@ unsafe fn maybe_dispatch_device_event(this: &Object, event: id) {
             }
 
             AppState::queue_events(events);
-
-            // Notify the delegate when the first mouse move occurs. This is
-            // used for the unbundled app activation hack, which needs to know
-            // if any mouse motions occurred prior to the app activating.
-            let delegate: id = msg_send![this, delegate];
-            assert_ne!(delegate, nil);
-            if !activation_hack::State::get_mouse_moved(&*delegate) {
-                activation_hack::State::set_mouse_moved(&*delegate, true);
-                let () = msg_send![
-                    delegate,
-                    performSelector: sel!(activationHackMouseMoved:)
-                    withObject: nil
-                    afterDelay: 0.0
-                ];
-            }
         }
         appkit::NSLeftMouseDown | appkit::NSRightMouseDown | appkit::NSOtherMouseDown => {
             let mut events = VecDeque::with_capacity(1);

src/platform_impl/macos/app_delegate.rs

@@ -1,10 +1,25 @@
-use super::{activation_hack, app_state::AppState};
+use crate::{platform::macos::ActivationPolicy, platform_impl::platform::app_state::AppState};
+
 use cocoa::base::id;
 use objc::{
     declare::ClassDecl,
     runtime::{Class, Object, Sel},
 };
-use std::os::raw::c_void;
+use std::{
+    cell::{RefCell, RefMut},
+    os::raw::c_void,
+};
+
+static AUX_DELEGATE_STATE_NAME: &str = "auxState";
+
+pub struct AuxDelegateState {
+    /// We store this value in order to be able to defer setting the activation policy until
+    /// after the app has finished launching. If the activation policy is set earlier, the
+    /// menubar is initially unresponsive on macOS 10.15 for example.
+    pub activation_policy: ActivationPolicy,
+
+    pub create_default_menu: bool,
+}
 
 pub struct AppDelegateClass(pub *const Class);
 unsafe impl Send for AppDelegateClass {}
@@ -17,36 +32,34 @@ lazy_static! {
 
         decl.add_class_method(sel!(new), new as extern "C" fn(&Class, Sel) -> id);
         decl.add_method(sel!(dealloc), dealloc as extern "C" fn(&Object, Sel));
+
         decl.add_method(
             sel!(applicationDidFinishLaunching:),
             did_finish_launching as extern "C" fn(&Object, Sel, id),
         );
-        decl.add_method(
-            sel!(applicationDidBecomeActive:),
-            did_become_active as extern "C" fn(&Object, Sel, id),
-        );
-        decl.add_method(
-            sel!(applicationDidResignActive:),
-            did_resign_active as extern "C" fn(&Object, Sel, id),
-        );
-
-        decl.add_ivar::<*mut c_void>(activation_hack::State::name());
-        decl.add_method(
-            sel!(activationHackMouseMoved:),
-            activation_hack::mouse_moved as extern "C" fn(&Object, Sel, id),
-        );
+        decl.add_ivar::<*mut c_void>(AUX_DELEGATE_STATE_NAME);
 
         AppDelegateClass(decl.register())
     };
 }
 
+/// Safety: Assumes that Object is an instance of APP_DELEGATE_CLASS
+pub unsafe fn get_aux_state_mut(this: &Object) -> RefMut<'_, AuxDelegateState> {
+    let ptr: *mut c_void = *this.get_ivar(AUX_DELEGATE_STATE_NAME);
+    // Watch out that this needs to be the correct type
+    (*(ptr as *mut RefCell<AuxDelegateState>)).borrow_mut()
+}
+
 extern "C" fn new(class: &Class, _: Sel) -> id {
     unsafe {
         let this: id = msg_send![class, alloc];
         let this: id = msg_send![this, init];
         (*this).set_ivar(
-            activation_hack::State::name(),
-            activation_hack::State::new(),
+            AUX_DELEGATE_STATE_NAME,
+            Box::into_raw(Box::new(RefCell::new(AuxDelegateState {
+                activation_policy: ActivationPolicy::Regular,
+                create_default_menu: true,
+            }))) as *mut c_void,
         );
         this
     }
@@ -54,28 +67,15 @@ extern "C" fn new(class: &Class, _: Sel) -> id {
 
 extern "C" fn dealloc(this: &Object, _: Sel) {
     unsafe {
-        activation_hack::State::free(activation_hack::State::get_ptr(this));
+        let state_ptr: *mut c_void = *(this.get_ivar(AUX_DELEGATE_STATE_NAME));
+        // As soon as the box is constructed it is immediately dropped, releasing the underlying
+        // memory
+        Box::from_raw(state_ptr as *mut RefCell<AuxDelegateState>);
     }
 }
 
-extern "C" fn did_finish_launching(_: &Object, _: Sel, _: id) {
+extern "C" fn did_finish_launching(this: &Object, _: Sel, _: id) {
     trace!("Triggered `applicationDidFinishLaunching`");
-    AppState::launched();
+    AppState::launched(this);
     trace!("Completed `applicationDidFinishLaunching`");
 }
-
-extern "C" fn did_become_active(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `applicationDidBecomeActive`");
-    unsafe {
-        activation_hack::State::set_activated(this, true);
-    }
-    trace!("Completed `applicationDidBecomeActive`");
-}
-
-extern "C" fn did_resign_active(this: &Object, _: Sel, _: id) {
-    trace!("Triggered `applicationDidResignActive`");
-    unsafe {
-        activation_hack::refocus(this);
-    }
-    trace!("Completed `applicationDidResignActive`");
-}

src/platform_impl/macos/app_state.rs

@@ -1,9 +1,10 @@
 use std::{
+    cell::{RefCell, RefMut},
     collections::VecDeque,
     fmt::{self, Debug},
     hint::unreachable_unchecked,
     mem,
-    rc::Rc,
+    rc::{Rc, Weak},
     sync::{
         atomic::{AtomicBool, Ordering},
         Mutex, MutexGuard,
@@ -12,22 +13,30 @@ use std::{
 };
 
 use cocoa::{
-    appkit::{NSApp, NSEventType::NSApplicationDefined, NSWindow},
+    appkit::{NSApp, NSApplication, NSWindow},
     base::{id, nil},
-    foundation::{NSAutoreleasePool, NSPoint, NSSize},
+    foundation::NSSize,
+};
+use objc::{
+    rc::autoreleasepool,
+    runtime::{Object, YES},
 };
-
-use objc::runtime::YES;
 
 use crate::{
     dpi::LogicalSize,
     event::{Event, StartCause, WindowEvent},
     event_loop::{ControlFlow, EventLoopWindowTarget as RootWindowTarget},
-    platform_impl::platform::{
-        event::{EventProxy, EventWrapper},
-        observer::EventLoopWaker,
-        util::{IdRef, Never},
-        window::get_window_id,
+    platform::macos::ActivationPolicy,
+    platform_impl::{
+        get_aux_state_mut,
+        platform::{
+            event::{EventProxy, EventWrapper},
+            event_loop::{post_dummy_event, PanicInfo},
+            menu,
+            observer::{CFRunLoopGetMain, CFRunLoopWakeUp, EventLoopWaker},
+            util::{IdRef, Never},
+            window::get_window_id,
+        },
     },
     window::WindowId,
 };
@@ -52,11 +61,31 @@ pub trait EventHandler: Debug {
 }
 
 struct EventLoopHandler<T: 'static> {
-    callback: Box<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>,
+    callback: Weak<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
     will_exit: bool,
     window_target: Rc<RootWindowTarget<T>>,
 }
 
+impl<T> EventLoopHandler<T> {
+    fn with_callback<F>(&mut self, f: F)
+    where
+        F: FnOnce(
+            &mut EventLoopHandler<T>,
+            RefMut<'_, dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>,
+        ),
+    {
+        if let Some(callback) = self.callback.upgrade() {
+            let callback = callback.borrow_mut();
+            (f)(self, callback);
+        } else {
+            panic!(
+                "Tried to dispatch an event, but the event loop that \
+                owned the event handler callback seems to be destroyed"
+            );
+        }
+    }
+}
+
 impl<T> Debug for EventLoopHandler<T> {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         formatter
@@ -68,23 +97,27 @@ impl<T> Debug for EventLoopHandler<T> {
 
 impl<T> EventHandler for EventLoopHandler<T> {
     fn handle_nonuser_event(&mut self, event: Event<'_, Never>, control_flow: &mut ControlFlow) {
-        (self.callback)(event.userify(), &self.window_target, control_flow);
-        self.will_exit |= *control_flow == ControlFlow::Exit;
-        if self.will_exit {
-            *control_flow = ControlFlow::Exit;
-        }
+        self.with_callback(|this, mut callback| {
+            (callback)(event.userify(), &this.window_target, control_flow);
+            this.will_exit |= *control_flow == ControlFlow::Exit;
+            if this.will_exit {
+                *control_flow = ControlFlow::Exit;
+            }
+        });
     }
 
     fn handle_user_events(&mut self, control_flow: &mut ControlFlow) {
-        let mut will_exit = self.will_exit;
-        for event in self.window_target.p.receiver.try_iter() {
-            (self.callback)(Event::UserEvent(event), &self.window_target, control_flow);
-            will_exit |= *control_flow == ControlFlow::Exit;
-            if will_exit {
-                *control_flow = ControlFlow::Exit;
+        self.with_callback(|this, mut callback| {
+            let mut will_exit = this.will_exit;
+            for event in this.window_target.p.receiver.try_iter() {
+                (callback)(Event::UserEvent(event), &this.window_target, control_flow);
+                will_exit |= *control_flow == ControlFlow::Exit;
+                if will_exit {
+                    *control_flow = ControlFlow::Exit;
+                }
             }
-        }
-        self.will_exit = will_exit;
+            this.will_exit = will_exit;
+        });
     }
 }
 
@@ -229,20 +262,12 @@ pub static INTERRUPT_EVENT_LOOP_EXIT: AtomicBool = AtomicBool::new(false);
 pub enum AppState {}
 
 impl AppState {
-    // This function extends lifetime of `callback` to 'static as its side effect
-    pub unsafe fn set_callback<F, T>(callback: F, window_target: Rc<RootWindowTarget<T>>)
-    where
-        F: FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
-    {
+    pub fn set_callback<T>(
+        callback: Weak<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
+        window_target: Rc<RootWindowTarget<T>>,
+    ) {
         *HANDLER.callback.lock().unwrap() = Some(Box::new(EventLoopHandler {
-            // This transmute is always safe, in case it was reached through `run`, since our
-            // lifetime will be already 'static. In other cases caller should ensure that all data
-            // they passed to callback will actually outlive it, some apps just can't move
-            // everything to event loop, so this is something that they should care about.
-            callback: mem::transmute::<
-                Box<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>,
-                Box<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>,
-            >(Box::new(callback)),
+            callback,
             will_exit: false,
             window_target,
         }));
@@ -255,9 +280,22 @@ impl AppState {
         HANDLER.callback.lock().unwrap().take();
     }
 
-    pub fn launched() {
+    pub fn launched(app_delegate: &Object) {
+        apply_activation_policy(app_delegate);
+        unsafe {
+            let ns_app = NSApp();
+            window_activation_hack(ns_app);
+            // TODO: Consider allowing the user to specify they don't want their application activated
+            ns_app.activateIgnoringOtherApps_(YES);
+        };
         HANDLER.set_ready();
         HANDLER.waker().start();
+        let create_default_menu = unsafe { get_aux_state_mut(app_delegate).create_default_menu };
+        if create_default_menu {
+            // The menubar initialization should be before the `NewEvents` event, to allow
+            // overriding of the default menu even if it's created
+            menu::initialize();
+        }
         HANDLER.set_in_callback(true);
         HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::NewEvents(
             StartCause::Init,
@@ -265,8 +303,13 @@ impl AppState {
         HANDLER.set_in_callback(false);
     }
 
-    pub fn wakeup() {
-        if !HANDLER.is_ready() {
+    pub fn wakeup(panic_info: Weak<PanicInfo>) {
+        let panic_info = panic_info
+            .upgrade()
+            .expect("The panic info must exist here. This failure indicates a developer error.");
+
+        // Return when in callback due to https://github.com/rust-windowing/winit/issues/1779
+        if panic_info.is_panicking() || !HANDLER.is_ready() || HANDLER.get_in_callback() {
             return;
         }
         let start = HANDLER.get_start_time().unwrap();
@@ -302,6 +345,14 @@ impl AppState {
         if !pending_redraw.contains(&window_id) {
             pending_redraw.push(window_id);
         }
+        unsafe {
+            let rl = CFRunLoopGetMain();
+            CFRunLoopWakeUp(rl);
+        }
+    }
+
+    pub fn handle_redraw(window_id: WindowId) {
+        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(window_id)));
     }
 
     pub fn queue_event(wrapper: EventWrapper) {
@@ -318,32 +369,34 @@ impl AppState {
         HANDLER.events().append(&mut wrappers);
     }
 
-    pub fn cleared() {
-        if !HANDLER.is_ready() {
+    pub fn cleared(panic_info: Weak<PanicInfo>) {
+        let panic_info = panic_info
+            .upgrade()
+            .expect("The panic info must exist here. This failure indicates a developer error.");
+
+        // Return when in callback due to https://github.com/rust-windowing/winit/issues/1779
+        if panic_info.is_panicking() || !HANDLER.is_ready() || HANDLER.get_in_callback() {
             return;
         }
-        if !HANDLER.get_in_callback() {
-            HANDLER.set_in_callback(true);
-            HANDLER.handle_user_events();
-            for event in HANDLER.take_events() {
-                HANDLER.handle_nonuser_event(event);
-            }
-            HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::MainEventsCleared));
-            for window_id in HANDLER.should_redraw() {
-                HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(
-                    window_id,
-                )));
-            }
-            HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawEventsCleared));
-            HANDLER.set_in_callback(false);
+
+        HANDLER.set_in_callback(true);
+        HANDLER.handle_user_events();
+        for event in HANDLER.take_events() {
+            HANDLER.handle_nonuser_event(event);
         }
+        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::MainEventsCleared));
+        for window_id in HANDLER.should_redraw() {
+            HANDLER
+                .handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawRequested(window_id)));
+        }
+        HANDLER.handle_nonuser_event(EventWrapper::StaticEvent(Event::RedrawEventsCleared));
+        HANDLER.set_in_callback(false);
+
         if HANDLER.should_exit() {
             unsafe {
                 let app: id = NSApp();
                 let windows: id = msg_send![app, windows];
-                let window: id = msg_send![windows, objectAtIndex:0];
                 let window_count: usize = msg_send![windows, count];
-                assert_ne!(window, nil);
 
                 let dialog_open = if window_count > 1 {
                     let dialog: id = msg_send![windows, lastObject];
@@ -354,35 +407,26 @@ impl AppState {
                 };
 
                 let dialog_is_closing = HANDLER.dialog_is_closing.load(Ordering::SeqCst);
-                let pool = NSAutoreleasePool::new(nil);
-                if !INTERRUPT_EVENT_LOOP_EXIT.load(Ordering::SeqCst)
-                    && !dialog_open
-                    && !dialog_is_closing
-                {
-                    let _: () = msg_send![app, stop: nil];
+                autoreleasepool(|| {
+                    if !INTERRUPT_EVENT_LOOP_EXIT.load(Ordering::SeqCst)
+                        && !dialog_open
+                        && !dialog_is_closing
+                    {
+                        let () = msg_send![app, stop: nil];
+                        // To stop event loop immediately, we need to post some event here.
+                        post_dummy_event(app);
+                    }
+                });
 
-                    let dummy_event: id = msg_send![class!(NSEvent),
-                        otherEventWithType: NSApplicationDefined
-                        location: NSPoint::new(0.0, 0.0)
-                        modifierFlags: 0
-                        timestamp: 0
-                        windowNumber: 0
-                        context: nil
-                        subtype: 0
-                        data1: 0
-                        data2: 0
-                    ];
-                    // To stop event loop immediately, we need to post some event here.
-                    let _: () = msg_send![window, postEvent: dummy_event atStart: YES];
-                }
-                pool.drain();
-
-                let window_has_focus = msg_send![window, isKeyWindow];
-                if !dialog_open && window_has_focus && dialog_is_closing {
-                    HANDLER.dialog_is_closing.store(false, Ordering::SeqCst);
-                }
-                if dialog_open {
-                    HANDLER.dialog_is_closing.store(true, Ordering::SeqCst);
+                if window_count > 0 {
+                    let window: id = msg_send![windows, objectAtIndex:0];
+                    let window_has_focus = msg_send![window, isKeyWindow];
+                    if !dialog_open && window_has_focus && dialog_is_closing {
+                        HANDLER.dialog_is_closing.store(false, Ordering::SeqCst);
+                    }
+                    if dialog_open {
+                        HANDLER.dialog_is_closing.store(true, Ordering::SeqCst);
+                    }
                 }
             };
         }
@@ -396,3 +440,49 @@ impl AppState {
         }
     }
 }
+
+/// A hack to make activation of multiple windows work when creating them before
+/// `applicationDidFinishLaunching:` / `Event::Event::NewEvents(StartCause::Init)`.
+///
+/// Alternative to this would be the user calling `window.set_visible(true)` in
+/// `StartCause::Init`.
+///
+/// If this becomes too bothersome to maintain, it can probably be removed
+/// without too much damage.
+unsafe fn window_activation_hack(ns_app: id) {
+    // Get the application's windows
+    // TODO: Proper ordering of the windows
+    let ns_windows: id = msg_send![ns_app, windows];
+    let ns_enumerator: id = msg_send![ns_windows, objectEnumerator];
+    loop {
+        // Enumerate over the windows
+        let ns_window: id = msg_send![ns_enumerator, nextObject];
+        if ns_window == nil {
+            break;
+        }
+        // And call `makeKeyAndOrderFront` if it was called on the window in `UnownedWindow::new`
+        // This way we preserve the user's desired initial visiblity status
+        // TODO: Also filter on the type/"level" of the window, and maybe other things?
+        if ns_window.isVisible() == YES {
+            trace!("Activating visible window");
+            ns_window.makeKeyAndOrderFront_(nil);
+        } else {
+            trace!("Skipping activating invisible window");
+        }
+    }
+}
+fn apply_activation_policy(app_delegate: &Object) {
+    unsafe {
+        use cocoa::appkit::NSApplicationActivationPolicy::*;
+        let ns_app = NSApp();
+        // We need to delay setting the activation policy and activating the app
+        // until `applicationDidFinishLaunching` has been called. Otherwise the
+        // menu bar won't be interactable.
+        let act_pol = get_aux_state_mut(app_delegate).activation_policy;
+        ns_app.setActivationPolicy_(match act_pol {
+            ActivationPolicy::Regular => NSApplicationActivationPolicyRegular,
+            ActivationPolicy::Accessory => NSApplicationActivationPolicyAccessory,
+            ActivationPolicy::Prohibited => NSApplicationActivationPolicyProhibited,
+        });
+    }
+}

src/platform_impl/macos/event_loop.rs

@@ -1,13 +1,22 @@
 use std::{
-    collections::VecDeque, marker::PhantomData, mem, os::raw::c_void, process, ptr, rc::Rc,
+    any::Any,
+    cell::{Cell, RefCell},
+    collections::VecDeque,
+    marker::PhantomData,
+    mem,
+    os::raw::c_void,
+    panic::{catch_unwind, resume_unwind, RefUnwindSafe, UnwindSafe},
+    process, ptr,
+    rc::{Rc, Weak},
     sync::mpsc,
 };
 
 use cocoa::{
-    appkit::NSApp,
-    base::{id, nil},
-    foundation::NSAutoreleasePool,
+    appkit::{NSApp, NSEventType::NSApplicationDefined},
+    base::{id, nil, YES},
+    foundation::NSPoint,
 };
+use objc::rc::autoreleasepool;
 
 use crate::{
     event::Event,
@@ -23,6 +32,34 @@ use crate::{
     },
 };
 
+#[derive(Default)]
+pub struct PanicInfo {
+    inner: Cell<Option<Box<dyn Any + Send + 'static>>>,
+}
+
+// WARNING:
+// As long as this struct is used through its `impl`, it is UnwindSafe.
+// (If `get_mut` is called on `inner`, unwind safety may get broken.)
+impl UnwindSafe for PanicInfo {}
+impl RefUnwindSafe for PanicInfo {}
+impl PanicInfo {
+    pub fn is_panicking(&self) -> bool {
+        let inner = self.inner.take();
+        let result = inner.is_some();
+        self.inner.set(inner);
+        result
+    }
+    /// Overwrites the curret state if the current state is not panicking
+    pub fn set_panic(&self, p: Box<dyn Any + Send + 'static>) {
+        if !self.is_panicking() {
+            self.inner.set(Some(p));
+        }
+    }
+    pub fn take(&self) -> Option<Box<dyn Any + Send + 'static>> {
+        self.inner.take()
+    }
+}
+
 pub struct EventLoopWindowTarget<T: 'static> {
     pub sender: mpsc::Sender<T>, // this is only here to be cloned elsewhere
     pub receiver: mpsc::Receiver<T>,
@@ -48,9 +85,33 @@ impl<T: 'static> EventLoopWindowTarget<T> {
     }
 }
 
+impl<T> EventLoopWindowTarget<T> {
+    pub(crate) fn hide_application(&self) {
+        let cls = objc::runtime::Class::get("NSApplication").unwrap();
+        let app: cocoa::base::id = unsafe { msg_send![cls, sharedApplication] };
+        unsafe { msg_send![app, hide: 0] }
+    }
+
+    pub(crate) fn hide_other_applications(&self) {
+        let cls = objc::runtime::Class::get("NSApplication").unwrap();
+        let app: cocoa::base::id = unsafe { msg_send![cls, sharedApplication] };
+        unsafe { msg_send![app, hideOtherApplications: 0] }
+    }
+}
+
 pub struct EventLoop<T: 'static> {
+    pub(crate) delegate: IdRef,
+
     window_target: Rc<RootWindowTarget<T>>,
-    _delegate: IdRef,
+    panic_info: Rc<PanicInfo>,
+
+    /// We make sure that the callback closure is dropped during a panic
+    /// by making the event loop own it.
+    ///
+    /// Every other reference should be a Weak reference which is only upgraded
+    /// into a strong reference in order to call the callback but then the
+    /// strong reference should be dropped as soon as possible.
+    _callback: Option<Rc<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>>,
 }
 
 impl<T> EventLoop<T> {
@@ -67,18 +128,21 @@ impl<T> EventLoop<T> {
             let app: id = msg_send![APP_CLASS.0, sharedApplication];
 
             let delegate = IdRef::new(msg_send![APP_DELEGATE_CLASS.0, new]);
-            let pool = NSAutoreleasePool::new(nil);
-            let _: () = msg_send![app, setDelegate:*delegate];
-            let _: () = msg_send![pool, drain];
+            autoreleasepool(|| {
+                let _: () = msg_send![app, setDelegate:*delegate];
+            });
             delegate
         };
-        setup_control_flow_observers();
+        let panic_info: Rc<PanicInfo> = Default::default();
+        setup_control_flow_observers(Rc::downgrade(&panic_info));
         EventLoop {
+            delegate,
             window_target: Rc::new(RootWindowTarget {
                 p: Default::default(),
                 _marker: PhantomData,
             }),
-            _delegate: delegate,
+            panic_info,
+            _callback: None,
         }
     }
 
@@ -98,15 +162,38 @@ impl<T> EventLoop<T> {
     where
         F: FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow),
     {
-        unsafe {
-            let pool = NSAutoreleasePool::new(nil);
+        // This transmute is always safe, in case it was reached through `run`, since our
+        // lifetime will be already 'static. In other cases caller should ensure that all data
+        // they passed to callback will actually outlive it, some apps just can't move
+        // everything to event loop, so this is something that they should care about.
+        let callback = unsafe {
+            mem::transmute::<
+                Rc<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
+                Rc<RefCell<dyn FnMut(Event<'_, T>, &RootWindowTarget<T>, &mut ControlFlow)>>,
+            >(Rc::new(RefCell::new(callback)))
+        };
+
+        self._callback = Some(Rc::clone(&callback));
+
+        autoreleasepool(|| unsafe {
             let app = NSApp();
             assert_ne!(app, nil);
-            AppState::set_callback(callback, Rc::clone(&self.window_target));
-            let _: () = msg_send![app, run];
+
+            // A bit of juggling with the callback references to make sure
+            // that `self.callback` is the only owner of the callback.
+            let weak_cb: Weak<_> = Rc::downgrade(&callback);
+            mem::drop(callback);
+
+            AppState::set_callback(weak_cb, Rc::clone(&self.window_target));
+            let () = msg_send![app, run];
+
+            if let Some(panic) = self.panic_info.take() {
+                drop(self._callback.take());
+                resume_unwind(panic);
+            }
             AppState::exit();
-            pool.drain();
-        }
+        });
+        drop(self._callback.take());
     }
 
     pub fn create_proxy(&self) -> Proxy<T> {
@@ -114,6 +201,56 @@ impl<T> EventLoop<T> {
     }
 }
 
+#[inline]
+pub unsafe fn post_dummy_event(target: id) {
+    let event_class = class!(NSEvent);
+    let dummy_event: id = msg_send![
+        event_class,
+        otherEventWithType: NSApplicationDefined
+        location: NSPoint::new(0.0, 0.0)
+        modifierFlags: 0
+        timestamp: 0
+        windowNumber: 0
+        context: nil
+        subtype: 0
+        data1: 0
+        data2: 0
+    ];
+    let () = msg_send![target, postEvent: dummy_event atStart: YES];
+}
+
+/// Catches panics that happen inside `f` and when a panic
+/// happens, stops the `sharedApplication`
+#[inline]
+pub fn stop_app_on_panic<F: FnOnce() -> R + UnwindSafe, R>(
+    panic_info: Weak<PanicInfo>,
+    f: F,
+) -> Option<R> {
+    match catch_unwind(f) {
+        Ok(r) => Some(r),
+        Err(e) => {
+            // It's important that we set the panic before requesting a `stop`
+            // because some callback are still called during the `stop` message
+            // and we need to know in those callbacks if the application is currently
+            // panicking
+            {
+                let panic_info = panic_info.upgrade().unwrap();
+                panic_info.set_panic(e);
+            }
+            unsafe {
+                let app_class = class!(NSApplication);
+                let app: id = msg_send![app_class, sharedApplication];
+                let () = msg_send![app, stop: nil];
+
+                // Posting a dummy event to get `stop` to take effect immediately.
+                // See: https://stackoverflow.com/questions/48041279/stopping-the-nsapplication-main-event-loop/48064752#48064752
+                post_dummy_event(app);
+            }
+            None
+        }
+    }
+}
+
 pub struct Proxy<T> {
     sender: mpsc::Sender<T>,
     source: CFRunLoopSourceRef,

src/platform_impl/macos/ffi.rs

@@ -2,6 +2,8 @@
 
 #![allow(dead_code, non_snake_case, non_upper_case_globals)]
 
+use std::ffi::c_void;
+
 use cocoa::{
     base::id,
     foundation::{NSInteger, NSUInteger},
@@ -116,6 +118,8 @@ pub enum NSWindowLevel {
     NSScreenSaverWindowLevel = kCGScreenSaverWindowLevelKey as _,
 }
 
+pub const NSStringEnumerationByComposedCharacterSequences: NSUInteger = 2;
+
 pub type CGDisplayFadeInterval = f32;
 pub type CGDisplayReservationInterval = f32;
 pub type CGDisplayBlendFraction = f32;
@@ -159,7 +163,19 @@ pub const IOYUV422Pixels: &str = "Y4U2V2";
 pub const IO8BitOverlayPixels: &str = "O8";
 
 pub type CGWindowLevel = i32;
-pub type CGDisplayModeRef = *mut libc::c_void;
+pub type CGDisplayModeRef = *mut c_void;
+
+#[cfg_attr(
+    not(use_colorsync_cgdisplaycreateuuidfromdisplayid),
+    link(name = "CoreGraphics", kind = "framework")
+)]
+#[cfg_attr(
+    use_colorsync_cgdisplaycreateuuidfromdisplayid,
+    link(name = "ColorSync", kind = "framework")
+)]
+extern "C" {
+    pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> CFUUIDRef;
+}
 
 #[link(name = "CoreGraphics", kind = "framework")]
 extern "C" {
@@ -189,7 +205,6 @@ extern "C" {
         synchronous: Boolean,
     ) -> CGError;
     pub fn CGReleaseDisplayFadeReservation(token: CGDisplayFadeReservationToken) -> CGError;
-    pub fn CGDisplayCreateUUIDFromDisplayID(display: CGDirectDisplayID) -> CFUUIDRef;
     pub fn CGShieldingWindowLevel() -> CGWindowLevel;
     pub fn CGDisplaySetDisplayMode(
         display: CGDirectDisplayID,

src/platform_impl/macos/menu.rs

@@ -0,0 +1,115 @@
+use super::util::IdRef;
+use cocoa::appkit::{NSApp, NSApplication, NSEventModifierFlags, NSMenu, NSMenuItem};
+use cocoa::base::{nil, selector};
+use cocoa::foundation::{NSProcessInfo, NSString};
+use objc::{
+    rc::autoreleasepool,
+    runtime::{Object, Sel},
+};
+
+struct KeyEquivalent<'a> {
+    key: &'a str,
+    masks: Option<NSEventModifierFlags>,
+}
+
+pub fn initialize() {
+    autoreleasepool(|| unsafe {
+        let menubar = IdRef::new(NSMenu::new(nil));
+        let app_menu_item = IdRef::new(NSMenuItem::new(nil));
+        menubar.addItem_(*app_menu_item);
+        let app = NSApp();
+        app.setMainMenu_(*menubar);
+
+        let app_menu = NSMenu::new(nil);
+        let process_name = NSProcessInfo::processInfo(nil).processName();
+
+        // About menu item
+        let about_item_prefix = NSString::alloc(nil).init_str("About ");
+        let about_item_title = about_item_prefix.stringByAppendingString_(process_name);
+        let about_item = menu_item(
+            about_item_title,
+            selector("orderFrontStandardAboutPanel:"),
+            None,
+        );
+
+        // Seperator menu item
+        let sep_first = NSMenuItem::separatorItem(nil);
+
+        // Hide application menu item
+        let hide_item_prefix = NSString::alloc(nil).init_str("Hide ");
+        let hide_item_title = hide_item_prefix.stringByAppendingString_(process_name);
+        let hide_item = menu_item(
+            hide_item_title,
+            selector("hide:"),
+            Some(KeyEquivalent {
+                key: "h",
+                masks: None,
+            }),
+        );
+
+        // Hide other applications menu item
+        let hide_others_item_title = NSString::alloc(nil).init_str("Hide Others");
+        let hide_others_item = menu_item(
+            hide_others_item_title,
+            selector("hideOtherApplications:"),
+            Some(KeyEquivalent {
+                key: "h",
+                masks: Some(
+                    NSEventModifierFlags::NSAlternateKeyMask
+                        | NSEventModifierFlags::NSCommandKeyMask,
+                ),
+            }),
+        );
+
+        // Show applications menu item
+        let show_all_item_title = NSString::alloc(nil).init_str("Show All");
+        let show_all_item = menu_item(
+            show_all_item_title,
+            selector("unhideAllApplications:"),
+            None,
+        );
+
+        // Seperator menu item
+        let sep = NSMenuItem::separatorItem(nil);
+
+        // Quit application menu item
+        let quit_item_prefix = NSString::alloc(nil).init_str("Quit ");
+        let quit_item_title = quit_item_prefix.stringByAppendingString_(process_name);
+        let quit_item = menu_item(
+            quit_item_title,
+            selector("terminate:"),
+            Some(KeyEquivalent {
+                key: "q",
+                masks: None,
+            }),
+        );
+
+        app_menu.addItem_(about_item);
+        app_menu.addItem_(sep_first);
+        app_menu.addItem_(hide_item);
+        app_menu.addItem_(hide_others_item);
+        app_menu.addItem_(show_all_item);
+        app_menu.addItem_(sep);
+        app_menu.addItem_(quit_item);
+        app_menu_item.setSubmenu_(app_menu);
+    });
+}
+
+fn menu_item(
+    title: *mut Object,
+    selector: Sel,
+    key_equivalent: Option<KeyEquivalent<'_>>,
+) -> *mut Object {
+    unsafe {
+        let (key, masks) = match key_equivalent {
+            Some(ke) => (NSString::alloc(nil).init_str(ke.key), ke.masks),
+            None => (NSString::alloc(nil).init_str(""), None),
+        };
+        let item = NSMenuItem::alloc(nil).initWithTitle_action_keyEquivalent_(title, selector, key);
+        if let Some(masks) = masks {
+            item.setKeyEquivalentModifierMask_(masks)
+        }
+
+        item
+    }
+}

src/platform_impl/macos/mod.rs

@@ -1,12 +1,12 @@
 #![cfg(target_os = "macos")]
 
-mod activation_hack;
 mod app;
 mod app_delegate;
 mod app_state;
 mod event;
 mod event_loop;
 mod ffi;
+mod menu;
 mod monitor;
 mod observer;
 mod util;
@@ -17,6 +17,7 @@ mod window_delegate;
 use std::{fmt, ops::Deref, sync::Arc};
 
 pub use self::{
+    app_delegate::{get_aux_state_mut, AuxDelegateState},
     event_loop::{EventLoop, EventLoopWindowTarget, Proxy as EventLoopProxy},
     monitor::{MonitorHandle, VideoMode},
     window::{Id as WindowId, PlatformSpecificWindowBuilderAttributes, UnownedWindow},
@@ -24,6 +25,7 @@ pub use self::{
 use crate::{
     error::OsError as RootOsError, event::DeviceId as RootDeviceId, window::WindowAttributes,
 };
+use objc::rc::autoreleasepool;
 
 pub(crate) use crate::icon::NoIcon as PlatformIcon;
 
@@ -31,7 +33,7 @@ pub(crate) use crate::icon::NoIcon as PlatformIcon;
 pub struct DeviceId;
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         DeviceId
     }
 }
@@ -68,7 +70,7 @@ impl Window {
         attributes: WindowAttributes,
         pl_attribs: PlatformSpecificWindowBuilderAttributes,
     ) -> Result<Self, RootOsError> {
-        let (window, _delegate) = UnownedWindow::new(attributes, pl_attribs)?;
+        let (window, _delegate) = autoreleasepool(|| UnownedWindow::new(attributes, pl_attribs))?;
         Ok(Window { window, _delegate })
     }
 }

src/platform_impl/macos/observer.rs

@@ -1,6 +1,17 @@
-use std::{self, os::raw::*, ptr, time::Instant};
+use std::{
+    self,
+    os::raw::*,
+    panic::{AssertUnwindSafe, UnwindSafe},
+    ptr,
+    rc::Weak,
+    time::Instant,
+};
 
-use crate::platform_impl::platform::{app_state::AppState, ffi};
+use crate::platform_impl::platform::{
+    app_state::AppState,
+    event_loop::{stop_app_on_panic, PanicInfo},
+    ffi,
+};
 
 #[link(name = "CoreFoundation", kind = "framework")]
 extern "C" {
@@ -85,9 +96,20 @@ pub type CFRunLoopObserverCallBack =
     extern "C" fn(observer: CFRunLoopObserverRef, activity: CFRunLoopActivity, info: *mut c_void);
 pub type CFRunLoopTimerCallBack = extern "C" fn(timer: CFRunLoopTimerRef, info: *mut c_void);
 
-pub enum CFRunLoopObserverContext {}
 pub enum CFRunLoopTimerContext {}
 
+/// This mirrors the struct with the same name from Core Foundation.
+/// https://developer.apple.com/documentation/corefoundation/cfrunloopobservercontext?language=objc
+#[allow(non_snake_case)]
+#[repr(C)]
+pub struct CFRunLoopObserverContext {
+    pub version: CFIndex,
+    pub info: *mut c_void,
+    pub retain: Option<extern "C" fn(info: *const c_void) -> *const c_void>,
+    pub release: Option<extern "C" fn(info: *const c_void)>,
+    pub copyDescription: Option<extern "C" fn(info: *const c_void) -> CFStringRef>,
+}
+
 #[allow(non_snake_case)]
 #[repr(C)]
 pub struct CFRunLoopSourceContext {
@@ -103,21 +125,42 @@ pub struct CFRunLoopSourceContext {
     pub perform: Option<extern "C" fn(*mut c_void)>,
 }
 
+unsafe fn control_flow_handler<F>(panic_info: *mut c_void, f: F)
+where
+    F: FnOnce(Weak<PanicInfo>) + UnwindSafe,
+{
+    let info_from_raw = Weak::from_raw(panic_info as *mut PanicInfo);
+    // Asserting unwind safety on this type should be fine because `PanicInfo` is
+    // `RefUnwindSafe` and `Rc<T>` is `UnwindSafe` if `T` is `RefUnwindSafe`.
+    let panic_info = AssertUnwindSafe(Weak::clone(&info_from_raw));
+    // `from_raw` takes ownership of the data behind the pointer.
+    // But if this scope takes ownership of the weak pointer, then
+    // the weak pointer will get free'd at the end of the scope.
+    // However we want to keep that weak reference around after the function.
+    std::mem::forget(info_from_raw);
+
+    stop_app_on_panic(Weak::clone(&panic_info), move || f(panic_info.0));
+}
+
 // begin is queued with the highest priority to ensure it is processed before other observers
 extern "C" fn control_flow_begin_handler(
     _: CFRunLoopObserverRef,
     activity: CFRunLoopActivity,
-    _: *mut c_void,
+    panic_info: *mut c_void,
 ) {
-    #[allow(non_upper_case_globals)]
-    match activity {
-        kCFRunLoopAfterWaiting => {
-            //trace!("Triggered `CFRunLoopAfterWaiting`");
-            AppState::wakeup();
-            //trace!("Completed `CFRunLoopAfterWaiting`");
-        }
-        kCFRunLoopEntry => unimplemented!(), // not expected to ever happen
-        _ => unreachable!(),
+    unsafe {
+        control_flow_handler(panic_info, |panic_info| {
+            #[allow(non_upper_case_globals)]
+            match activity {
+                kCFRunLoopAfterWaiting => {
+                    //trace!("Triggered `CFRunLoopAfterWaiting`");
+                    AppState::wakeup(panic_info);
+                    //trace!("Completed `CFRunLoopAfterWaiting`");
+                }
+                kCFRunLoopEntry => unimplemented!(), // not expected to ever happen
+                _ => unreachable!(),
+            }
+        });
     }
 }
 
@@ -126,17 +169,21 @@ extern "C" fn control_flow_begin_handler(
 extern "C" fn control_flow_end_handler(
     _: CFRunLoopObserverRef,
     activity: CFRunLoopActivity,
-    _: *mut c_void,
+    panic_info: *mut c_void,
 ) {
-    #[allow(non_upper_case_globals)]
-    match activity {
-        kCFRunLoopBeforeWaiting => {
-            //trace!("Triggered `CFRunLoopBeforeWaiting`");
-            AppState::cleared();
-            //trace!("Completed `CFRunLoopBeforeWaiting`");
-        }
-        kCFRunLoopExit => (), //unimplemented!(), // not expected to ever happen
-        _ => unreachable!(),
+    unsafe {
+        control_flow_handler(panic_info, |panic_info| {
+            #[allow(non_upper_case_globals)]
+            match activity {
+                kCFRunLoopBeforeWaiting => {
+                    //trace!("Triggered `CFRunLoopBeforeWaiting`");
+                    AppState::cleared(panic_info);
+                    //trace!("Completed `CFRunLoopBeforeWaiting`");
+                }
+                kCFRunLoopExit => (), //unimplemented!(), // not expected to ever happen
+                _ => unreachable!(),
+            }
+        });
     }
 }
 
@@ -152,6 +199,7 @@ impl RunLoop {
         flags: CFOptionFlags,
         priority: CFIndex,
         handler: CFRunLoopObserverCallBack,
+        context: *mut CFRunLoopObserverContext,
     ) {
         let observer = CFRunLoopObserverCreate(
             ptr::null_mut(),
@@ -159,24 +207,33 @@ impl RunLoop {
             ffi::TRUE, // Indicates we want this to run repeatedly
             priority,  // The lower the value, the sooner this will run
             handler,
-            ptr::null_mut(),
+            context,
         );
         CFRunLoopAddObserver(self.0, observer, kCFRunLoopCommonModes);
     }
 }
 
-pub fn setup_control_flow_observers() {
+pub fn setup_control_flow_observers(panic_info: Weak<PanicInfo>) {
     unsafe {
+        let mut context = CFRunLoopObserverContext {
+            info: Weak::into_raw(panic_info) as *mut _,
+            version: 0,
+            retain: None,
+            release: None,
+            copyDescription: None,
+        };
         let run_loop = RunLoop::get();
         run_loop.add_observer(
             kCFRunLoopEntry | kCFRunLoopAfterWaiting,
             CFIndex::min_value(),
             control_flow_begin_handler,
+            &mut context as *mut _,
         );
         run_loop.add_observer(
             kCFRunLoopExit | kCFRunLoopBeforeWaiting,
             CFIndex::max_value(),
             control_flow_end_handler,
+            &mut context as *mut _,
         );
     }
 }

src/platform_impl/macos/util/async.rs

@@ -10,6 +10,7 @@ use cocoa::{
 };
 use dispatch::Queue;
 use objc::rc::autoreleasepool;
+use objc::runtime::NO;
 
 use crate::{
     dpi::LogicalSize,
@@ -167,7 +168,7 @@ pub unsafe fn set_maximized_async(
                 } else {
                     shared_state_lock.saved_standard_frame()
                 };
-                ns_window.setFrame_display_(new_rect, 0);
+                ns_window.setFrame_display_(new_rect, NO);
             }
 
             trace!("Unlocked shared state in `set_maximized`");
@@ -206,7 +207,10 @@ pub unsafe fn set_title_async(ns_window: id, title: String) {
 
 // `close:` is thread-safe, but we want the event to be triggered from the main
 // thread. Though, it's a good idea to look into that more...
-pub unsafe fn close_async(ns_window: id) {
+//
+// ArturKovacs: It's important that this operation keeps the underlying window alive
+// through the `IdRef` because otherwise it would dereference free'd memory
+pub unsafe fn close_async(ns_window: IdRef) {
     let ns_window = MainThreadSafe(ns_window);
     Queue::main().exec_async(move || {
         autoreleasepool(move || {

src/platform_impl/macos/util/mod.rs

@@ -3,17 +3,27 @@ mod cursor;
 
 pub use self::{cursor::*, r#async::*};
 
-use std::ops::{BitAnd, Deref};
+use std::{
+    cell::Cell,
+    ops::{BitAnd, Deref},
+    rc::Rc,
+};
 
+use block::ConcreteBlock;
 use cocoa::{
     appkit::{NSApp, NSWindowStyleMask},
     base::{id, nil},
-    foundation::{NSAutoreleasePool, NSRect, NSString, NSUInteger},
+    foundation::{NSPoint, NSRect, NSString, NSUInteger},
 };
 use core_graphics::display::CGDisplay;
 use objc::runtime::{Class, Object, Sel, BOOL, YES};
 
-use crate::platform_impl::platform::ffi;
+use crate::{
+    dpi::LogicalPosition,
+    platform_impl::platform::ffi::{
+        self, NSRange, NSStringEnumerationByComposedCharacterSequences,
+    },
+};
 
 // Replace with `!` once stable
 #[derive(Debug)]
@@ -60,9 +70,7 @@ impl Drop for IdRef {
     fn drop(&mut self) {
         if self.0 != nil {
             unsafe {
-                let pool = NSAutoreleasePool::new(nil);
                 let () = msg_send![self.0, release];
-                pool.drain();
             };
         }
     }
@@ -91,10 +99,46 @@ pub fn bottom_left_to_top_left(rect: NSRect) -> f64 {
     CGDisplay::main().pixels_high() as f64 - (rect.origin.y + rect.size.height)
 }
 
+/// Converts from winit screen-coordinates to macOS screen-coordinates.
+/// Winit: top-left is (0, 0) and y increasing downwards
+/// macOS: bottom-left is (0, 0) and y increasing upwards
+pub fn window_position(position: LogicalPosition<f64>) -> NSPoint {
+    NSPoint::new(
+        position.x,
+        CGDisplay::main().pixels_high() as f64 - position.y,
+    )
+}
+
 pub unsafe fn ns_string_id_ref(s: &str) -> IdRef {
     IdRef::new(NSString::alloc(nil).init_str(s))
 }
 
+/// Returns the number of characters in a string.
+/// (A single character may consist of multiple UTF-32 code units.
+/// This is possible when long sequences of composing characters are present)
+///
+/// Unsafe because assumes that the `string` is an `NSString` object
+pub unsafe fn ns_string_char_count(string: id) -> usize {
+    let length: NSUInteger = msg_send![string, length];
+    let range = NSRange {
+        location: 0,
+        length,
+    };
+    let char_count = Rc::new(Cell::new(0));
+    let block = {
+        let char_count = char_count.clone();
+        ConcreteBlock::new(move || char_count.set(char_count.get() + 1)).copy()
+    };
+    let block = &*block;
+    let () = msg_send![string,
+        enumerateSubstringsInRange:range
+        options:NSStringEnumerationByComposedCharacterSequences
+        usingBlock:block
+    ];
+    char_count.get()
+}
+
+#[allow(dead_code)] // In case we want to use this function in the future
 pub unsafe fn app_name() -> Option<id> {
     let bundle: id = msg_send![class!(NSBundle), mainBundle];
     let dict: id = msg_send![bundle, infoDictionary];

src/platform_impl/macos/view.rs

@@ -29,7 +29,7 @@ use crate::{
             scancode_to_keycode, EventWrapper,
         },
         ffi::*,
-        util::{self, IdRef},
+        util::{self, ns_string_char_count, IdRef},
         window::get_window_id,
         DEVICE_ID,
     },
@@ -55,9 +55,10 @@ pub(super) struct ViewState {
     pub cursor_state: Arc<Mutex<CursorState>>,
     ime_spot: Option<(f64, f64)>,
     raw_characters: Option<String>,
-    is_key_down: bool,
     pub(super) modifiers: ModifiersState,
     tracking_rect: Option<NSInteger>,
+    is_ime_activated: bool,
+    marked_text: id,
 }
 
 impl ViewState {
@@ -69,14 +70,17 @@ impl ViewState {
 pub fn new_view(ns_window: id) -> (IdRef, Weak<Mutex<CursorState>>) {
     let cursor_state = Default::default();
     let cursor_access = Arc::downgrade(&cursor_state);
+    let marked_text =
+        unsafe { <id as NSMutableAttributedString>::init(NSMutableAttributedString::alloc(nil)) };
     let state = ViewState {
         ns_window,
         cursor_state,
         ime_spot: None,
         raw_characters: None,
-        is_key_down: false,
         modifiers: Default::default(),
         tracking_rect: None,
+        is_ime_activated: false,
+        marked_text,
     };
     unsafe {
         // This is free'd in `dealloc`
@@ -149,7 +153,10 @@ lazy_static! {
             sel!(setMarkedText:selectedRange:replacementRange:),
             set_marked_text as extern "C" fn(&mut Object, Sel, id, NSRange, NSRange),
         );
-        decl.add_method(sel!(unmarkText), unmark_text as extern "C" fn(&Object, Sel));
+        decl.add_method(
+            sel!(unmarkText),
+            unmark_text as extern "C" fn(&mut Object, Sel),
+        );
         decl.add_method(
             sel!(validAttributesForMarkedText),
             valid_attributes_for_marked_text as extern "C" fn(&Object, Sel) -> id,
@@ -161,7 +168,7 @@ lazy_static! {
         );
         decl.add_method(
             sel!(insertText:replacementRange:),
-            insert_text as extern "C" fn(&Object, Sel, id, NSRange),
+            insert_text as extern "C" fn(&mut Object, Sel, id, NSRange),
         );
         decl.add_method(
             sel!(characterIndexForPoint:),
@@ -255,8 +262,11 @@ lazy_static! {
             sel!(frameDidChange:),
             frame_did_change as extern "C" fn(&Object, Sel, id),
         );
+        decl.add_method(
+            sel!(acceptsFirstMouse:),
+            accepts_first_mouse as extern "C" fn(&Object, Sel, id) -> BOOL,
+        );
         decl.add_ivar::<*mut c_void>("winitState");
-        decl.add_ivar::<id>("markedText");
         let protocol = Protocol::get("NSTextInputClient").unwrap();
         decl.add_protocol(&protocol);
         ViewClass(decl.register())
@@ -266,9 +276,9 @@ lazy_static! {
 extern "C" fn dealloc(this: &Object, _sel: Sel) {
     unsafe {
         let state: *mut c_void = *this.get_ivar("winitState");
-        let marked_text: id = *this.get_ivar("markedText");
-        let _: () = msg_send![marked_text, release];
-        Box::from_raw(state as *mut ViewState);
+        let state = state as *mut ViewState;
+        let _: () = msg_send![(*state).marked_text, release];
+        Box::from_raw(state);
     }
 }
 
@@ -277,15 +287,12 @@ extern "C" fn init_with_winit(this: &Object, _sel: Sel, state: *mut c_void) -> i
         let this: id = msg_send![this, init];
         if this != nil {
             (*this).set_ivar("winitState", state);
-            let marked_text =
-                <id as NSMutableAttributedString>::init(NSMutableAttributedString::alloc(nil));
-            (*this).set_ivar("markedText", marked_text);
             let _: () = msg_send![this, setPostsFrameChangedNotifications: YES];
 
             let notification_center: &Object =
                 msg_send![class!(NSNotificationCenter), defaultCenter];
             let notification_name =
-                NSString::alloc(nil).init_str("NSViewFrameDidChangeNotification");
+                IdRef::new(NSString::alloc(nil).init_str("NSViewFrameDidChangeNotification"));
             let _: () = msg_send![
                 notification_center,
                 addObserver: this
@@ -346,7 +353,7 @@ extern "C" fn draw_rect(this: &Object, _sel: Sel, rect: NSRect) {
         let state_ptr: *mut c_void = *this.get_ivar("winitState");
         let state = &mut *(state_ptr as *mut ViewState);
 
-        AppState::queue_redraw(WindowId(get_window_id(state.ns_window)));
+        AppState::handle_redraw(WindowId(get_window_id(state.ns_window)));
 
         let superclass = util::superclass(this);
         let () = msg_send![super(this, superclass), drawRect: rect];
@@ -386,17 +393,20 @@ extern "C" fn reset_cursor_rects(this: &Object, _sel: Sel) {
 extern "C" fn has_marked_text(this: &Object, _sel: Sel) -> BOOL {
     unsafe {
         trace!("Triggered `hasMarkedText`");
-        let marked_text: id = *this.get_ivar("markedText");
+        let state_ptr: *mut c_void = *this.get_ivar("winitState");
+        let state = &mut *(state_ptr as *mut ViewState);
+        let retval = (state.marked_text.length() > 0) as BOOL;
         trace!("Completed `hasMarkedText`");
-        (marked_text.length() > 0) as i8
+        retval
     }
 }
 
 extern "C" fn marked_range(this: &Object, _sel: Sel) -> NSRange {
     unsafe {
         trace!("Triggered `markedRange`");
-        let marked_text: id = *this.get_ivar("markedText");
-        let length = marked_text.length();
+        let state_ptr: *mut c_void = *this.get_ivar("winitState");
+        let state = &mut *(state_ptr as *mut ViewState);
+        let length = state.marked_text.length();
         trace!("Completed `markedRange`");
         if length > 0 {
             NSRange::new(0, length - 1)
@@ -421,32 +431,62 @@ extern "C" fn set_marked_text(
 ) {
     trace!("Triggered `setMarkedText`");
     unsafe {
-        let marked_text_ref: &mut id = this.get_mut_ivar("markedText");
-        let _: () = msg_send![(*marked_text_ref), release];
-        let marked_text = NSMutableAttributedString::alloc(nil);
+        let state_ptr: *mut c_void = *this.get_ivar("winitState");
+        let state = &mut *(state_ptr as *mut ViewState);
+
+        // Delete previous marked text
+        let char_count = ns_string_char_count(state.marked_text.string());
+        delete_marked_text(state, char_count);
+
+        state.is_ime_activated = true;
+
+        let _: () = msg_send![state.marked_text, release];
+        state.marked_text = NSMutableAttributedString::alloc(nil);
         let has_attr = msg_send![string, isKindOfClass: class!(NSAttributedString)];
         if has_attr {
-            marked_text.initWithAttributedString(string);
+            state.marked_text.initWithAttributedString(string);
         } else {
-            marked_text.initWithString(string);
+            state.marked_text.initWithString(string);
         };
-        *marked_text_ref = marked_text;
+
+        let text_ns_str = state.marked_text.string();
+        let slice = slice::from_raw_parts(
+            text_ns_str.UTF8String() as *const c_uchar,
+            text_ns_str.len(),
+        );
+        let text_str = str::from_utf8_unchecked(slice);
+
+        for character in text_str.chars() {
+            AppState::queue_event(EventWrapper::StaticEvent(Event::WindowEvent {
+                window_id: WindowId(get_window_id(state.ns_window)),
+                event: WindowEvent::ReceivedCharacter(character),
+            }));
+        }
     }
     trace!("Completed `setMarkedText`");
 }
 
-extern "C" fn unmark_text(this: &Object, _sel: Sel) {
+extern "C" fn unmark_text(this: &mut Object, _sel: Sel) {
     trace!("Triggered `unmarkText`");
     unsafe {
-        let marked_text: id = *this.get_ivar("markedText");
-        let mutable_string = marked_text.mutableString();
-        let _: () = msg_send![mutable_string, setString:""];
-        let input_context: id = msg_send![this, inputContext];
-        let _: () = msg_send![input_context, discardMarkedText];
+        clear_marked_text(this);
     }
     trace!("Completed `unmarkText`");
 }
 
+/// Unsafe because assumes that `this` is an instance of the `WinitView` class that we declare
+/// programmatically
+unsafe fn clear_marked_text(this: &mut Object) {
+    let state_ptr: *mut c_void = *this.get_ivar("winitState");
+    let state = &mut *(state_ptr as *mut ViewState);
+
+    let _: () = msg_send![state.marked_text, release];
+    state.marked_text = NSMutableAttributedString::alloc(nil);
+
+    let input_context: id = msg_send![this, inputContext];
+    let _: () = msg_send![input_context, discardMarkedText];
+}
+
 extern "C" fn valid_attributes_for_marked_text(_this: &Object, _sel: Sel) -> id {
     trace!("Triggered `validAttributesForMarkedText`");
     trace!("Completed `validAttributesForMarkedText`");
@@ -494,12 +534,19 @@ extern "C" fn first_rect_for_character_range(
     }
 }
 
-extern "C" fn insert_text(this: &Object, _sel: Sel, string: id, _replacement_range: NSRange) {
+extern "C" fn insert_text(this: &mut Object, _sel: Sel, string: id, _replacement_range: NSRange) {
     trace!("Triggered `insertText`");
     unsafe {
         let state_ptr: *mut c_void = *this.get_ivar("winitState");
         let state = &mut *(state_ptr as *mut ViewState);
 
+        let is_ime_activated: bool = state.is_ime_activated;
+        if is_ime_activated {
+            clear_marked_text(this);
+            state.is_ime_activated = false;
+            return;
+        }
+
         let has_attr = msg_send![string, isKindOfClass: class!(NSAttributedString)];
         let characters = if has_attr {
             // This is a *mut NSAttributedString
@@ -512,7 +559,6 @@ extern "C" fn insert_text(this: &Object, _sel: Sel, string: id, _replacement_ran
         let slice =
             slice::from_raw_parts(characters.UTF8String() as *const c_uchar, characters.len());
         let string = str::from_utf8_unchecked(slice);
-        state.is_key_down = true;
 
         // We don't need this now, but it's here if that changes.
         //let event: id = msg_send![NSApp(), currentEvent];
@@ -567,6 +613,15 @@ extern "C" fn do_command_by_selector(this: &Object, _sel: Sel, command: Sel) {
     trace!("Completed `doCommandBySelector`");
 }
 
+fn delete_marked_text(state: &mut ViewState, count: usize) {
+    for _ in 0..count {
+        AppState::queue_event(EventWrapper::StaticEvent(Event::WindowEvent {
+            window_id: WindowId(get_window_id(state.ns_window)),
+            event: WindowEvent::ReceivedCharacter('\u{7f}'), // fire DELETE
+        }));
+    }
+}
+
 fn get_characters(event: id, ignore_modifiers: bool) -> String {
     unsafe {
         let characters: id = if ignore_modifiers {
@@ -671,7 +726,7 @@ extern "C" fn key_down(this: &Object, _sel: Sel, event: id) {
         let pass_along = {
             AppState::queue_event(EventWrapper::StaticEvent(window_event));
             // Emit `ReceivedCharacter` for key repeats
-            if is_repeat && state.is_key_down {
+            if is_repeat {
                 for character in characters.chars().filter(|c| !is_corporate_character(*c)) {
                     AppState::queue_event(EventWrapper::StaticEvent(Event::WindowEvent {
                         window_id,
@@ -701,8 +756,6 @@ extern "C" fn key_up(this: &Object, _sel: Sel, event: id) {
         let state_ptr: *mut c_void = *this.get_ivar("winitState");
         let state = &mut *(state_ptr as *mut ViewState);
 
-        state.is_key_down = false;
-
         let scancode = get_scancode(event) as u32;
         let virtual_keycode = retrieve_keycode(event);
 
@@ -1078,3 +1131,7 @@ extern "C" fn pressure_change_with_event(this: &Object, _sel: Sel, event: id) {
 extern "C" fn wants_key_down_for_event(_this: &Object, _sel: Sel, _event: id) -> BOOL {
     YES
 }
+
+extern "C" fn accepts_first_mouse(_this: &Object, _sel: Sel, _event: id) -> BOOL {
+    YES
+}

src/platform_impl/macos/window.rs

@@ -1,4 +1,4 @@
-use raw_window_handle::{macos::MacOSHandle, RawWindowHandle};
+use raw_window_handle::{AppKitHandle, RawWindowHandle};
 use std::{
     collections::VecDeque,
     f64,
@@ -16,7 +16,7 @@ use crate::{
     error::{ExternalError, NotSupportedError, OsError as RootOsError},
     icon::Icon,
     monitor::{MonitorHandle as RootMonitorHandle, VideoMode as RootVideoMode},
-    platform::macos::{ActivationPolicy, RequestUserAttentionType, WindowExtMacOS},
+    platform::macos::WindowExtMacOS,
     platform_impl::platform::{
         app_state::AppState,
         app_state::INTERRUPT_EVENT_LOOP_EXIT,
@@ -28,20 +28,22 @@ use crate::{
         window_delegate::new_delegate,
         OsError,
     },
-    window::{CursorIcon, Fullscreen, WindowAttributes, WindowId as RootWindowId},
+    window::{
+        CursorIcon, Fullscreen, UserAttentionType, WindowAttributes, WindowId as RootWindowId,
+    },
 };
 use cocoa::{
     appkit::{
-        self, CGFloat, NSApp, NSApplication, NSApplicationActivationPolicy,
-        NSApplicationPresentationOptions, NSColor, NSRequestUserAttentionType, NSScreen, NSView,
-        NSWindow, NSWindowButton, NSWindowStyleMask,
+        self, CGFloat, NSApp, NSApplication, NSApplicationPresentationOptions, NSColor,
+        NSRequestUserAttentionType, NSScreen, NSView, NSWindow, NSWindowButton, NSWindowStyleMask,
     },
     base::{id, nil},
-    foundation::{NSAutoreleasePool, NSDictionary, NSPoint, NSRect, NSSize},
+    foundation::{NSDictionary, NSPoint, NSRect, NSSize},
 };
 use core_graphics::display::{CGDisplay, CGDisplayMode};
 use objc::{
     declare::ClassDecl,
+    rc::autoreleasepool,
     runtime::{Class, Object, Sel, BOOL, NO, YES},
 };
 
@@ -49,7 +51,7 @@ use objc::{
 pub struct Id(pub usize);
 
 impl Id {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         Id(0)
     }
 }
@@ -62,7 +64,6 @@ pub fn get_window_id(window_cocoa_id: id) -> Id {
 
 #[derive(Clone)]
 pub struct PlatformSpecificWindowBuilderAttributes {
-    pub activation_policy: ActivationPolicy,
     pub movable_by_window_background: bool,
     pub titlebar_transparent: bool,
     pub title_hidden: bool,
@@ -78,7 +79,6 @@ impl Default for PlatformSpecificWindowBuilderAttributes {
     #[inline]
     fn default() -> Self {
         Self {
-            activation_policy: Default::default(),
             movable_by_window_background: false,
             titlebar_transparent: false,
             title_hidden: false,
@@ -92,24 +92,6 @@ impl Default for PlatformSpecificWindowBuilderAttributes {
     }
 }
 
-fn create_app(activation_policy: ActivationPolicy) -> Option<id> {
-    unsafe {
-        let ns_app = NSApp();
-        if ns_app == nil {
-            None
-        } else {
-            use self::NSApplicationActivationPolicy::*;
-            ns_app.setActivationPolicy_(match activation_policy {
-                ActivationPolicy::Regular => NSApplicationActivationPolicyRegular,
-                ActivationPolicy::Accessory => NSApplicationActivationPolicyAccessory,
-                ActivationPolicy::Prohibited => NSApplicationActivationPolicyProhibited,
-            });
-            ns_app.finishLaunching();
-            Some(ns_app)
-        }
-    }
-}
-
 unsafe fn create_view(
     ns_window: id,
     pl_attribs: &PlatformSpecificWindowBuilderAttributes,
@@ -129,8 +111,6 @@ unsafe fn create_view(
             ns_view.setWantsLayer(YES);
         }
 
-        ns_window.setContentView_(*ns_view);
-        ns_window.makeFirstResponder_(*ns_view);
         (ns_view, cursor_state)
     })
 }
@@ -139,8 +119,7 @@ fn create_window(
     attrs: &WindowAttributes,
     pl_attrs: &PlatformSpecificWindowBuilderAttributes,
 ) -> Option<IdRef> {
-    unsafe {
-        let pool = NSAutoreleasePool::new(nil);
+    autoreleasepool(|| unsafe {
         let screen = match attrs.fullscreen {
             Some(Fullscreen::Borderless(Some(RootMonitorHandle { inner: ref monitor })))
             | Some(Fullscreen::Exclusive(RootVideoMode {
@@ -164,7 +143,17 @@ fn create_window(
                     }
                     None => (800.0, 600.0),
                 };
-                NSRect::new(NSPoint::new(0.0, 0.0), NSSize::new(width, height))
+                let (left, bottom) = match attrs.position {
+                    Some(position) => {
+                        let logical = util::window_position(position.to_logical(scale_factor));
+                        // macOS wants the position of the bottom left corner,
+                        // but caller is setting the position of top left corner
+                        (logical.x, logical.y - height)
+                    }
+                    // This value is ignored by calling win.center() below
+                    None => (0.0, 0.0),
+                };
+                NSRect::new(NSPoint::new(left, bottom), NSSize::new(width, height))
             }
         };
 
@@ -247,13 +236,13 @@ fn create_window(
             if !pl_attrs.has_shadow {
                 ns_window.setHasShadow_(NO);
             }
-
-            ns_window.center();
+            if attrs.position.is_none() {
+                ns_window.center();
+            }
             ns_window
         });
-        pool.drain();
         res
-    }
+    })
 }
 
 struct WindowClass(*const Class);
@@ -292,7 +281,10 @@ pub struct SharedState {
     is_simple_fullscreen: bool,
     pub saved_style: Option<NSWindowStyleMask>,
     /// Presentation options saved before entering `set_simple_fullscreen`, and
-    /// restored upon exiting it
+    /// restored upon exiting it. Also used when transitioning from Borderless to
+    /// Exclusive fullscreen in `set_fullscreen` because we need to disable the menu
+    /// bar in exclusive fullscreen but want to restore the original options when
+    /// transitioning back to borderless fullscreen.
     save_presentation_opts: Option<NSApplicationPresentationOptions>,
     pub saved_desktop_display_mode: Option<(CGDisplay, CGDisplayMode)>,
 }
@@ -344,24 +336,19 @@ impl UnownedWindow {
                 panic!("Windows can only be created on the main thread on macOS");
             }
         }
+        trace!("Creating new window");
 
-        let pool = unsafe { NSAutoreleasePool::new(nil) };
+        let ns_window = create_window(&win_attribs, &pl_attribs)
+            .ok_or_else(|| os_error!(OsError::CreationError("Couldn't create `NSWindow`")))?;
 
-        let ns_app = create_app(pl_attribs.activation_policy).ok_or_else(|| {
-            unsafe { pool.drain() };
-            os_error!(OsError::CreationError("Couldn't create `NSApplication`"))
-        })?;
+        let (ns_view, cursor_state) = unsafe { create_view(*ns_window, &pl_attribs) }
+            .ok_or_else(|| os_error!(OsError::CreationError("Couldn't create `NSView`")))?;
 
-        let ns_window = create_window(&win_attribs, &pl_attribs).ok_or_else(|| {
-            unsafe { pool.drain() };
-            os_error!(OsError::CreationError("Couldn't create `NSWindow`"))
-        })?;
-
-        let (ns_view, cursor_state) =
-            unsafe { create_view(*ns_window, &pl_attribs) }.ok_or_else(|| {
-                unsafe { pool.drain() };
-                os_error!(OsError::CreationError("Couldn't create `NSView`"))
-            })?;
+        // Configure the new view as the "key view" for the window
+        unsafe {
+            ns_window.setContentView_(*ns_view);
+            ns_window.setInitialFirstResponder_(*ns_view);
+        }
 
         let input_context = unsafe { util::create_input_context(*ns_view) };
 
@@ -373,7 +360,6 @@ impl UnownedWindow {
                 ns_window.setBackgroundColor_(NSColor::clearColor(nil));
             }
 
-            ns_app.activateIgnoringOtherApps_(YES);
             win_attribs.min_inner_size.map(|dim| {
                 let logical_dim = dim.to_logical(scale_factor);
                 set_min_inner_size(*ns_window, logical_dim)
@@ -423,20 +409,15 @@ impl UnownedWindow {
         // Setting the window as key has to happen *after* we set the fullscreen
         // state, since otherwise we'll briefly see the window at normal size
         // before it transitions.
-        unsafe {
-            if visible {
-                window.ns_window.makeKeyAndOrderFront_(nil);
-            } else {
-                window.ns_window.makeKeyWindow();
-            }
+        if visible {
+            // Tightly linked with `app_state::window_activation_hack`
+            unsafe { window.ns_window.makeKeyAndOrderFront_(nil) };
         }
 
         if maximized {
             window.set_maximized(maximized);
         }
 
-        unsafe { pool.drain() };
-
         Ok((window, delegate))
     }
 
@@ -494,17 +475,8 @@ impl UnownedWindow {
     pub fn set_outer_position(&self, position: Position) {
         let scale_factor = self.scale_factor();
         let position = position.to_logical(scale_factor);
-        let dummy = NSRect::new(
-            NSPoint::new(
-                position.x,
-                // While it's true that we're setting the top-left position,
-                // it still needs to be in a bottom-left coordinate system.
-                CGDisplay::main().pixels_high() as f64 - position.y,
-            ),
-            NSSize::new(0f64, 0f64),
-        );
         unsafe {
-            util::set_frame_top_left_point_async(*self.ns_window, dummy.origin);
+            util::set_frame_top_left_point_async(*self.ns_window, util::window_position(position));
         }
     }
 
@@ -634,6 +606,16 @@ impl UnownedWindow {
         Ok(())
     }
 
+    #[inline]
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        unsafe {
+            let event: id = msg_send![NSApp(), currentEvent];
+            let _: () = msg_send![*self.ns_window, performWindowDragWithEvent: event];
+        }
+
+        Ok(())
+    }
+
     pub(crate) fn is_zoomed(&self) -> bool {
         // because `isZoomed` doesn't work if the window's borderless,
         // we make it resizable temporalily.
@@ -653,7 +635,7 @@ impl UnownedWindow {
             self.set_style_mask_async(curr_mask);
         }
 
-        is_zoomed != 0
+        is_zoomed != NO
     }
 
     fn saved_style(&self, shared_state: &mut SharedState) -> NSWindowStyleMask {
@@ -728,6 +710,11 @@ impl UnownedWindow {
         shared_state_lock.fullscreen.clone()
     }
 
+    #[inline]
+    pub fn is_maximized(&self) -> bool {
+        self.is_zoomed()
+    }
+
     #[inline]
     pub fn set_fullscreen(&self, fullscreen: Option<Fullscreen>) {
         trace!("Locked shared state in `set_fullscreen`");
@@ -798,6 +785,15 @@ impl UnownedWindow {
 
             let mut fade_token = ffi::kCGDisplayFadeReservationInvalidToken;
 
+            if matches!(old_fullscreen, Some(Fullscreen::Borderless(_))) {
+                unsafe {
+                    let app = NSApp();
+                    trace!("Locked shared state in `set_fullscreen`");
+                    let mut shared_state_lock = self.shared_state.lock().unwrap();
+                    shared_state_lock.save_presentation_opts = Some(app.presentationOptions_());
+                }
+            }
+
             unsafe {
                 // Fade to black (and wait for the fade to complete) to hide the
                 // flicker from capturing the display and switching display mode
@@ -848,7 +844,6 @@ impl UnownedWindow {
         trace!("Locked shared state in `set_fullscreen`");
         let mut shared_state_lock = self.shared_state.lock().unwrap();
         shared_state_lock.fullscreen = fullscreen.clone();
-        trace!("Unlocked shared state in `set_fullscreen`");
 
         INTERRUPT_EVENT_LOOP_EXIT.store(true, Ordering::SeqCst);
 
@@ -889,16 +884,42 @@ impl UnownedWindow {
                 // of the menu bar, and this looks broken, so we must make sure
                 // that the menu bar is disabled. This is done in the window
                 // delegate in `window:willUseFullScreenPresentationOptions:`.
+                let app = NSApp();
+                trace!("Locked shared state in `set_fullscreen`");
+                shared_state_lock.save_presentation_opts = Some(app.presentationOptions_());
+
+                let presentation_options =
+                    NSApplicationPresentationOptions::NSApplicationPresentationFullScreen
+                        | NSApplicationPresentationOptions::NSApplicationPresentationHideDock
+                        | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar;
+                app.setPresentationOptions_(presentation_options);
+
                 let () = msg_send![*self.ns_window, setLevel: ffi::CGShieldingWindowLevel() + 1];
             },
             (
                 &Some(Fullscreen::Exclusive(RootVideoMode { ref video_mode })),
                 &Some(Fullscreen::Borderless(_)),
             ) => unsafe {
+                let presentation_options =
+                    shared_state_lock.save_presentation_opts.unwrap_or_else(|| {
+                        NSApplicationPresentationOptions::NSApplicationPresentationFullScreen
+                        | NSApplicationPresentationOptions::NSApplicationPresentationAutoHideDock
+                        | NSApplicationPresentationOptions::NSApplicationPresentationAutoHideMenuBar
+                    });
+                NSApp().setPresentationOptions_(presentation_options);
+
                 util::restore_display_mode_async(video_mode.monitor().inner.native_identifier());
+
+                // Restore the normal window level following the Borderless fullscreen
+                // `CGShieldingWindowLevel() + 1` hack.
+                let () = msg_send![
+                    *self.ns_window,
+                    setLevel: ffi::NSWindowLevel::NSNormalWindowLevel
+                ];
             },
             _ => INTERRUPT_EVENT_LOOP_EXIT.store(false, Ordering::SeqCst),
-        }
+        };
+        trace!("Unlocked shared state in `set_fullscreen`");
     }
 
     #[inline]
@@ -977,6 +998,34 @@ impl UnownedWindow {
         }
     }
 
+    #[inline]
+    pub fn focus_window(&self) {
+        let is_minimized: BOOL = unsafe { msg_send![*self.ns_window, isMiniaturized] };
+        let is_minimized = is_minimized == YES;
+        let is_visible: BOOL = unsafe { msg_send![*self.ns_window, isVisible] };
+        let is_visible = is_visible == YES;
+
+        if !is_minimized && is_visible {
+            unsafe {
+                NSApp().activateIgnoringOtherApps_(YES);
+                util::make_key_and_order_front_async(*self.ns_window);
+            }
+        }
+    }
+
+    #[inline]
+    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        let ns_request_type = request_type.map(|ty| match ty {
+            UserAttentionType::Critical => NSRequestUserAttentionType::NSCriticalRequest,
+            UserAttentionType::Informational => NSRequestUserAttentionType::NSInformationalRequest,
+        });
+        unsafe {
+            if let Some(ty) = ns_request_type {
+                NSApp().requestUserAttention_(ty);
+            }
+        }
+    }
+
     #[inline]
     // Allow directly accessing the current monitor internally without unwrapping.
     pub(crate) fn current_monitor_inner(&self) -> RootMonitorHandle {
@@ -1010,12 +1059,10 @@ impl UnownedWindow {
 
     #[inline]
     pub fn raw_window_handle(&self) -> RawWindowHandle {
-        let handle = MacOSHandle {
-            ns_window: *self.ns_window as *mut _,
-            ns_view: *self.ns_view as *mut _,
-            ..MacOSHandle::empty()
-        };
-        RawWindowHandle::MacOS(handle)
+        let mut handle = AppKitHandle::empty();
+        handle.ns_window = *self.ns_window as *mut _;
+        handle.ns_view = *self.ns_view as *mut _;
+        RawWindowHandle::AppKit(handle)
     }
 }
 
@@ -1030,18 +1077,6 @@ impl WindowExtMacOS for UnownedWindow {
         *self.ns_view as *mut _
     }
 
-    #[inline]
-    fn request_user_attention(&self, request_type: RequestUserAttentionType) {
-        unsafe {
-            NSApp().requestUserAttention_(match request_type {
-                RequestUserAttentionType::Critical => NSRequestUserAttentionType::NSCriticalRequest,
-                RequestUserAttentionType::Informational => {
-                    NSRequestUserAttentionType::NSInformationalRequest
-                }
-            });
-        }
-    }
-
     #[inline]
     fn simple_fullscreen(&self) -> bool {
         let shared_state_lock = self.shared_state.lock().unwrap();
@@ -1150,7 +1185,7 @@ impl Drop for UnownedWindow {
         trace!("Dropping `UnownedWindow` ({:?})", self as *mut _);
         // Close the window if it has not yet been closed.
         if *self.ns_window != nil {
-            unsafe { util::close_async(*self.ns_window) };
+            unsafe { util::close_async(self.ns_window.clone()) };
         }
     }
 }
@@ -1168,14 +1203,14 @@ unsafe fn set_min_inner_size<V: NSWindow + Copy>(window: V, mut min_size: Logica
     // If necessary, resize the window to match constraint
     if current_rect.size.width < min_size.width {
         current_rect.size.width = min_size.width;
-        window.setFrame_display_(current_rect, 0)
+        window.setFrame_display_(current_rect, NO)
     }
     if current_rect.size.height < min_size.height {
         // The origin point of a rectangle is at its bottom left in Cocoa.
         // To ensure the window's top-left point remains the same:
         current_rect.origin.y += current_rect.size.height - min_size.height;
         current_rect.size.height = min_size.height;
-        window.setFrame_display_(current_rect, 0)
+        window.setFrame_display_(current_rect, NO)
     }
 }
 
@@ -1192,13 +1227,13 @@ unsafe fn set_max_inner_size<V: NSWindow + Copy>(window: V, mut max_size: Logica
     // If necessary, resize the window to match constraint
     if current_rect.size.width > max_size.width {
         current_rect.size.width = max_size.width;
-        window.setFrame_display_(current_rect, 0)
+        window.setFrame_display_(current_rect, NO)
     }
     if current_rect.size.height > max_size.height {
         // The origin point of a rectangle is at its bottom left in Cocoa.
         // To ensure the window's top-left point remains the same:
         current_rect.origin.y += current_rect.size.height - max_size.height;
         current_rect.size.height = max_size.height;
-        window.setFrame_display_(current_rect, 0)
+        window.setFrame_display_(current_rect, NO)
     }
 }

src/platform_impl/macos/window_delegate.rs

@@ -7,10 +7,11 @@ use std::{
 use cocoa::{
     appkit::{self, NSApplicationPresentationOptions, NSView, NSWindow},
     base::{id, nil},
-    foundation::{NSAutoreleasePool, NSUInteger},
+    foundation::NSUInteger,
 };
 use objc::{
     declare::ClassDecl,
+    rc::autoreleasepool,
     runtime::{Class, Object, Sel, BOOL, NO, YES},
 };
 
@@ -274,11 +275,11 @@ extern "C" fn window_will_close(this: &Object, _: Sel, _: id) {
     trace!("Triggered `windowWillClose:`");
     with_state(this, |state| unsafe {
         // `setDelegate:` retains the previous value and then autoreleases it
-        let pool = NSAutoreleasePool::new(nil);
-        // Since El Capitan, we need to be careful that delegate methods can't
-        // be called after the window closes.
-        let () = msg_send![*state.ns_window, setDelegate: nil];
-        pool.drain();
+        autoreleasepool(|| {
+            // Since El Capitan, we need to be careful that delegate methods can't
+            // be called after the window closes.
+            let () = msg_send![*state.ns_window, setDelegate: nil];
+        });
         state.emit_event(WindowEvent::Destroyed);
     });
     trace!("Completed `windowWillClose:`");
@@ -481,10 +482,10 @@ extern "C" fn window_will_exit_fullscreen(this: &Object, _: Sel, _: id) {
 }
 
 extern "C" fn window_will_use_fullscreen_presentation_options(
-    _this: &Object,
+    this: &Object,
     _: Sel,
     _: id,
-    _proposed_options: NSUInteger,
+    proposed_options: NSUInteger,
 ) -> NSUInteger {
     // Generally, games will want to disable the menu bar and the dock. Ideally,
     // this would be configurable by the user. Unfortunately because of our
@@ -494,10 +495,22 @@ extern "C" fn window_will_use_fullscreen_presentation_options(
     // still want to make this configurable for borderless fullscreen. Right now
     // we don't, for consistency. If we do, it should be documented that the
     // user-provided options are ignored in exclusive fullscreen.
-    (NSApplicationPresentationOptions::NSApplicationPresentationFullScreen
-        | NSApplicationPresentationOptions::NSApplicationPresentationHideDock
-        | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar)
-        .bits()
+    let mut options: NSUInteger = proposed_options;
+    with_state(this, |state| {
+        state.with_window(|window| {
+            trace!("Locked shared state in `window_will_use_fullscreen_presentation_options`");
+            let shared_state = window.shared_state.lock().unwrap();
+            if let Some(Fullscreen::Exclusive(_)) = shared_state.fullscreen {
+                options = (NSApplicationPresentationOptions::NSApplicationPresentationFullScreen
+                    | NSApplicationPresentationOptions::NSApplicationPresentationHideDock
+                    | NSApplicationPresentationOptions::NSApplicationPresentationHideMenuBar)
+                    .bits();
+            }
+            trace!("Unlocked shared state in `window_will_use_fullscreen_presentation_options`");
+        })
+    });
+
+    options
 }
 
 /// Invoked when entered fullscreen

src/platform_impl/web/device.rs

@@ -2,7 +2,7 @@
 pub struct Id(pub i32);
 
 impl Id {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         Id(0)
     }
 }

src/platform_impl/web/event_loop/window_target.rs

@@ -1,6 +1,8 @@
 use super::{super::monitor, backend, device, proxy::Proxy, runner, window};
 use crate::dpi::{PhysicalSize, Size};
-use crate::event::{DeviceId, ElementState, Event, KeyboardInput, TouchPhase, WindowEvent};
+use crate::event::{
+    DeviceEvent, DeviceId, ElementState, Event, KeyboardInput, TouchPhase, WindowEvent,
+};
 use crate::event_loop::ControlFlow;
 use crate::monitor::MonitorHandle as RootMH;
 use crate::window::{Theme, WindowId};
@@ -130,7 +132,7 @@ impl<T> WindowTarget<T> {
         });
 
         let runner = self.runner.clone();
-        canvas.on_cursor_move(move |pointer_id, position, modifiers| {
+        canvas.on_cursor_move(move |pointer_id, position, delta, modifiers| {
             runner.send_event(Event::WindowEvent {
                 window_id: WindowId(id),
                 event: WindowEvent::CursorMoved {
@@ -139,6 +141,12 @@ impl<T> WindowTarget<T> {
                     modifiers,
                 },
             });
+            runner.send_event(Event::DeviceEvent {
+                device_id: DeviceId(device::Id(pointer_id)),
+                event: DeviceEvent::MouseMotion {
+                    delta: (delta.x, delta.y),
+                },
+            });
         });
 
         let runner = self.runner.clone();

src/platform_impl/web/mod.rs

@@ -1,5 +1,5 @@
 // Brief introduction to the internals of the web backend:
-// Currently, the web backend supports both wasm-bindgen and stdweb as methods of binding to the
+// The web backend used to support both wasm-bindgen and stdweb as methods of binding to the
 // environment. Because they are both supporting the same underlying APIs, the actual web bindings
 // are cordoned off into backend abstractions, which present the thinnest unifying layer possible.
 //
@@ -23,17 +23,9 @@ mod event_loop;
 mod monitor;
 mod window;
 
-#[cfg(feature = "web-sys")]
 #[path = "web_sys/mod.rs"]
 mod backend;
 
-#[cfg(feature = "stdweb")]
-#[path = "stdweb/mod.rs"]
-mod backend;
-
-#[cfg(not(any(feature = "web-sys", feature = "stdweb")))]
-compile_error!("Please select a feature to build for web: `web-sys`, `stdweb`");
-
 pub use self::device::Id as DeviceId;
 pub use self::error::OsError;
 pub use self::event_loop::{

src/platform_impl/web/stdweb/canvas.rs

@@ -1,307 +0,0 @@
-use super::event;
-use crate::dpi::{LogicalPosition, PhysicalPosition, PhysicalSize};
-use crate::error::OsError as RootOE;
-use crate::event::{ModifiersState, MouseButton, MouseScrollDelta, ScanCode, VirtualKeyCode};
-use crate::platform_impl::{OsError, PlatformSpecificWindowBuilderAttributes};
-
-use std::cell::RefCell;
-use std::rc::Rc;
-use stdweb::js;
-use stdweb::traits::IPointerEvent;
-use stdweb::unstable::TryInto;
-use stdweb::web::event::{
-    BlurEvent, ConcreteEvent, FocusEvent, FullscreenChangeEvent, IEvent, KeyDownEvent,
-    KeyPressEvent, KeyUpEvent, MouseWheelEvent, PointerDownEvent, PointerMoveEvent,
-    PointerOutEvent, PointerOverEvent, PointerUpEvent,
-};
-use stdweb::web::html_element::CanvasElement;
-use stdweb::web::{
-    document, EventListenerHandle, IChildNode, IElement, IEventTarget, IHtmlElement,
-};
-
-pub struct Canvas {
-    /// Note: resizing the CanvasElement should go through `backend::set_canvas_size` to ensure the DPI factor is maintained.
-    raw: CanvasElement,
-    on_focus: Option<EventListenerHandle>,
-    on_blur: Option<EventListenerHandle>,
-    on_keyboard_release: Option<EventListenerHandle>,
-    on_keyboard_press: Option<EventListenerHandle>,
-    on_received_character: Option<EventListenerHandle>,
-    on_cursor_leave: Option<EventListenerHandle>,
-    on_cursor_enter: Option<EventListenerHandle>,
-    on_cursor_move: Option<EventListenerHandle>,
-    on_mouse_press: Option<EventListenerHandle>,
-    on_mouse_release: Option<EventListenerHandle>,
-    on_mouse_wheel: Option<EventListenerHandle>,
-    on_fullscreen_change: Option<EventListenerHandle>,
-    wants_fullscreen: Rc<RefCell<bool>>,
-}
-
-impl Canvas {
-    pub fn create(attr: PlatformSpecificWindowBuilderAttributes) -> Result<Self, RootOE> {
-        let canvas = match attr.canvas {
-            Some(canvas) => canvas,
-            None => document()
-                .create_element("canvas")
-                .map_err(|_| os_error!(OsError("Failed to create canvas element".to_owned())))?
-                .try_into()
-                .map_err(|_| os_error!(OsError("Failed to create canvas element".to_owned())))?,
-        };
-
-        // A tabindex is needed in order to capture local keyboard events.
-        // A "0" value means that the element should be focusable in
-        // sequential keyboard navigation, but its order is defined by the
-        // document's source order.
-        // https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/tabindex
-        canvas
-            .set_attribute("tabindex", "0")
-            .map_err(|_| os_error!(OsError("Failed to set a tabindex".to_owned())))?;
-
-        Ok(Canvas {
-            raw: canvas,
-            on_blur: None,
-            on_focus: None,
-            on_keyboard_release: None,
-            on_keyboard_press: None,
-            on_received_character: None,
-            on_cursor_leave: None,
-            on_cursor_enter: None,
-            on_cursor_move: None,
-            on_mouse_release: None,
-            on_mouse_press: None,
-            on_mouse_wheel: None,
-            on_fullscreen_change: None,
-            wants_fullscreen: Rc::new(RefCell::new(false)),
-        })
-    }
-
-    pub fn set_attribute(&self, attribute: &str, value: &str) {
-        self.raw
-            .set_attribute(attribute, value)
-            .expect(&format!("Set attribute: {}", attribute));
-    }
-
-    pub fn position(&self) -> LogicalPosition<f64> {
-        let bounds = self.raw.get_bounding_client_rect();
-
-        LogicalPosition {
-            x: bounds.get_x(),
-            y: bounds.get_y(),
-        }
-    }
-
-    pub fn size(&self) -> PhysicalSize<u32> {
-        PhysicalSize {
-            width: self.raw.width() as u32,
-            height: self.raw.height() as u32,
-        }
-    }
-
-    pub fn raw(&self) -> &CanvasElement {
-        &self.raw
-    }
-
-    pub fn on_blur<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(),
-    {
-        self.on_blur = Some(self.add_event(move |_: BlurEvent| {
-            handler();
-        }));
-    }
-
-    pub fn on_focus<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(),
-    {
-        self.on_focus = Some(self.add_event(move |_: FocusEvent| {
-            handler();
-        }));
-    }
-
-    pub fn on_keyboard_release<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(ScanCode, Option<VirtualKeyCode>, ModifiersState),
-    {
-        self.on_keyboard_release = Some(self.add_user_event(move |event: KeyUpEvent| {
-            event.prevent_default();
-            handler(
-                event::scan_code(&event),
-                event::virtual_key_code(&event),
-                event::keyboard_modifiers(&event),
-            );
-        }));
-    }
-
-    pub fn on_keyboard_press<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(ScanCode, Option<VirtualKeyCode>, ModifiersState),
-    {
-        self.on_keyboard_press = Some(self.add_user_event(move |event: KeyDownEvent| {
-            event.prevent_default();
-            handler(
-                event::scan_code(&event),
-                event::virtual_key_code(&event),
-                event::keyboard_modifiers(&event),
-            );
-        }));
-    }
-
-    pub fn on_received_character<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(char),
-    {
-        // TODO: Use `beforeinput`.
-        //
-        // The `keypress` event is deprecated, but there does not seem to be a
-        // viable/compatible alternative as of now. `beforeinput` is still widely
-        // unsupported.
-        self.on_received_character = Some(self.add_user_event(move |event: KeyPressEvent| {
-            handler(event::codepoint(&event));
-        }));
-    }
-
-    pub fn on_cursor_leave<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(i32),
-    {
-        self.on_cursor_leave = Some(self.add_event(move |event: PointerOutEvent| {
-            handler(event.pointer_id());
-        }));
-    }
-
-    pub fn on_cursor_enter<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(i32),
-    {
-        self.on_cursor_enter = Some(self.add_event(move |event: PointerOverEvent| {
-            handler(event.pointer_id());
-        }));
-    }
-
-    pub fn on_mouse_release<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(i32, MouseButton, ModifiersState),
-    {
-        self.on_mouse_release = Some(self.add_user_event(move |event: PointerUpEvent| {
-            handler(
-                event.pointer_id(),
-                event::mouse_button(&event),
-                event::mouse_modifiers(&event),
-            );
-        }));
-    }
-
-    pub fn on_mouse_press<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(i32, PhysicalPosition<f64>, MouseButton, ModifiersState),
-    {
-        let canvas = self.raw.clone();
-        self.on_mouse_press = Some(self.add_user_event(move |event: PointerDownEvent| {
-            handler(
-                event.pointer_id(),
-                event::mouse_position(&event).to_physical(super::scale_factor()),
-                event::mouse_button(&event),
-                event::mouse_modifiers(&event),
-            );
-            canvas
-                .set_pointer_capture(event.pointer_id())
-                .expect("Failed to set pointer capture");
-        }));
-    }
-
-    pub fn on_cursor_move<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(i32, PhysicalPosition<f64>, ModifiersState),
-    {
-        // todo
-        self.on_cursor_move = Some(self.add_event(move |event: PointerMoveEvent| {
-            handler(
-                event.pointer_id(),
-                event::mouse_position(&event).to_physical(super::scale_factor()),
-                event::mouse_modifiers(&event),
-            );
-        }));
-    }
-
-    pub fn on_mouse_wheel<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(i32, MouseScrollDelta, ModifiersState),
-    {
-        self.on_mouse_wheel = Some(self.add_event(move |event: MouseWheelEvent| {
-            event.prevent_default();
-            if let Some(delta) = event::mouse_scroll_delta(&event) {
-                handler(0, delta, event::mouse_modifiers(&event));
-            }
-        }));
-    }
-
-    pub fn on_fullscreen_change<F>(&mut self, mut handler: F)
-    where
-        F: 'static + FnMut(),
-    {
-        self.on_fullscreen_change = Some(self.add_event(move |_: FullscreenChangeEvent| handler()));
-    }
-
-    pub fn on_dark_mode<F>(&mut self, handler: F)
-    where
-        F: 'static + FnMut(bool),
-    {
-        // TODO: upstream to stdweb
-        js! {
-            var handler = @{handler};
-
-            if (window.matchMedia) {
-                window.matchMedia("(prefers-color-scheme: dark)").addListener(function(e) {
-                    handler(event.matches)
-                });
-            }
-        }
-    }
-
-    fn add_event<E, F>(&self, mut handler: F) -> EventListenerHandle
-    where
-        E: ConcreteEvent,
-        F: 'static + FnMut(E),
-    {
-        self.raw.add_event_listener(move |event: E| {
-            event.stop_propagation();
-            event.cancel_bubble();
-
-            handler(event);
-        })
-    }
-
-    // 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.)
-    fn add_user_event<E, F>(&self, mut handler: F) -> EventListenerHandle
-    where
-        E: ConcreteEvent,
-        F: 'static + FnMut(E),
-    {
-        let wants_fullscreen = self.wants_fullscreen.clone();
-        let canvas = self.raw.clone();
-
-        self.add_event(move |event: E| {
-            handler(event);
-
-            if *wants_fullscreen.borrow() {
-                canvas.request_fullscreen();
-                *wants_fullscreen.borrow_mut() = false;
-            }
-        })
-    }
-
-    pub fn request_fullscreen(&self) {
-        *self.wants_fullscreen.borrow_mut() = true;
-    }
-
-    pub fn is_fullscreen(&self) -> bool {
-        super::is_fullscreen(&self.raw)
-    }
-
-    pub fn remove_listeners(&mut self) {
-        // TODO: Stub, unimplemented (see web_sys for reference).
-    }
-}

src/platform_impl/web/stdweb/event.rs

@@ -1,232 +0,0 @@
-use crate::dpi::LogicalPosition;
-use crate::event::{ModifiersState, MouseButton, MouseScrollDelta, ScanCode, VirtualKeyCode};
-
-use stdweb::web::event::{IKeyboardEvent, IMouseEvent, MouseWheelDeltaMode, MouseWheelEvent};
-use stdweb::{js, unstable::TryInto, JsSerialize};
-
-pub fn mouse_button(event: &impl IMouseEvent) -> MouseButton {
-    match event.button() {
-        stdweb::web::event::MouseButton::Left => MouseButton::Left,
-        stdweb::web::event::MouseButton::Right => MouseButton::Right,
-        stdweb::web::event::MouseButton::Wheel => MouseButton::Middle,
-        stdweb::web::event::MouseButton::Button4 => MouseButton::Other(0),
-        stdweb::web::event::MouseButton::Button5 => MouseButton::Other(1),
-    }
-}
-
-pub fn mouse_modifiers(event: &impl IMouseEvent) -> ModifiersState {
-    let mut m = ModifiersState::empty();
-    m.set(ModifiersState::SHIFT, event.shift_key());
-    m.set(ModifiersState::CTRL, event.ctrl_key());
-    m.set(ModifiersState::ALT, event.alt_key());
-    m.set(ModifiersState::LOGO, event.meta_key());
-    m
-}
-
-pub fn mouse_position(event: &impl IMouseEvent) -> LogicalPosition<f64> {
-    LogicalPosition {
-        x: event.offset_x() as f64,
-        y: event.offset_y() as f64,
-    }
-}
-
-pub fn mouse_scroll_delta(event: &MouseWheelEvent) -> Option<MouseScrollDelta> {
-    let x = event.delta_x();
-    let y = -event.delta_y();
-
-    match event.delta_mode() {
-        MouseWheelDeltaMode::Line => Some(MouseScrollDelta::LineDelta(x as f32, y as f32)),
-        MouseWheelDeltaMode::Pixel => {
-            let delta = LogicalPosition::new(x, y).to_physical(super::scale_factor());
-            Some(MouseScrollDelta::PixelDelta(delta))
-        }
-        MouseWheelDeltaMode::Page => None,
-    }
-}
-
-pub fn scan_code<T: JsSerialize>(event: &T) -> ScanCode {
-    let key_code = js! ( return @{event}.keyCode; );
-
-    key_code
-        .try_into()
-        .expect("The which value should be a number")
-}
-
-pub fn virtual_key_code(event: &impl IKeyboardEvent) -> Option<VirtualKeyCode> {
-    Some(match &event.code()[..] {
-        "Digit1" => VirtualKeyCode::Key1,
-        "Digit2" => VirtualKeyCode::Key2,
-        "Digit3" => VirtualKeyCode::Key3,
-        "Digit4" => VirtualKeyCode::Key4,
-        "Digit5" => VirtualKeyCode::Key5,
-        "Digit6" => VirtualKeyCode::Key6,
-        "Digit7" => VirtualKeyCode::Key7,
-        "Digit8" => VirtualKeyCode::Key8,
-        "Digit9" => VirtualKeyCode::Key9,
-        "Digit0" => VirtualKeyCode::Key0,
-        "KeyA" => VirtualKeyCode::A,
-        "KeyB" => VirtualKeyCode::B,
-        "KeyC" => VirtualKeyCode::C,
-        "KeyD" => VirtualKeyCode::D,
-        "KeyE" => VirtualKeyCode::E,
-        "KeyF" => VirtualKeyCode::F,
-        "KeyG" => VirtualKeyCode::G,
-        "KeyH" => VirtualKeyCode::H,
-        "KeyI" => VirtualKeyCode::I,
-        "KeyJ" => VirtualKeyCode::J,
-        "KeyK" => VirtualKeyCode::K,
-        "KeyL" => VirtualKeyCode::L,
-        "KeyM" => VirtualKeyCode::M,
-        "KeyN" => VirtualKeyCode::N,
-        "KeyO" => VirtualKeyCode::O,
-        "KeyP" => VirtualKeyCode::P,
-        "KeyQ" => VirtualKeyCode::Q,
-        "KeyR" => VirtualKeyCode::R,
-        "KeyS" => VirtualKeyCode::S,
-        "KeyT" => VirtualKeyCode::T,
-        "KeyU" => VirtualKeyCode::U,
-        "KeyV" => VirtualKeyCode::V,
-        "KeyW" => VirtualKeyCode::W,
-        "KeyX" => VirtualKeyCode::X,
-        "KeyY" => VirtualKeyCode::Y,
-        "KeyZ" => VirtualKeyCode::Z,
-        "Escape" => VirtualKeyCode::Escape,
-        "F1" => VirtualKeyCode::F1,
-        "F2" => VirtualKeyCode::F2,
-        "F3" => VirtualKeyCode::F3,
-        "F4" => VirtualKeyCode::F4,
-        "F5" => VirtualKeyCode::F5,
-        "F6" => VirtualKeyCode::F6,
-        "F7" => VirtualKeyCode::F7,
-        "F8" => VirtualKeyCode::F8,
-        "F9" => VirtualKeyCode::F9,
-        "F10" => VirtualKeyCode::F10,
-        "F11" => VirtualKeyCode::F11,
-        "F12" => VirtualKeyCode::F12,
-        "F13" => VirtualKeyCode::F13,
-        "F14" => VirtualKeyCode::F14,
-        "F15" => VirtualKeyCode::F15,
-        "F16" => VirtualKeyCode::F16,
-        "F17" => VirtualKeyCode::F17,
-        "F18" => VirtualKeyCode::F18,
-        "F19" => VirtualKeyCode::F19,
-        "F20" => VirtualKeyCode::F20,
-        "F21" => VirtualKeyCode::F21,
-        "F22" => VirtualKeyCode::F22,
-        "F23" => VirtualKeyCode::F23,
-        "F24" => VirtualKeyCode::F24,
-        "PrintScreen" => VirtualKeyCode::Snapshot,
-        "ScrollLock" => VirtualKeyCode::Scroll,
-        "Pause" => VirtualKeyCode::Pause,
-        "Insert" => VirtualKeyCode::Insert,
-        "Home" => VirtualKeyCode::Home,
-        "Delete" => VirtualKeyCode::Delete,
-        "End" => VirtualKeyCode::End,
-        "PageDown" => VirtualKeyCode::PageDown,
-        "PageUp" => VirtualKeyCode::PageUp,
-        "ArrowLeft" => VirtualKeyCode::Left,
-        "ArrowUp" => VirtualKeyCode::Up,
-        "ArrowRight" => VirtualKeyCode::Right,
-        "ArrowDown" => VirtualKeyCode::Down,
-        "Backspace" => VirtualKeyCode::Back,
-        "Enter" => VirtualKeyCode::Return,
-        "Space" => VirtualKeyCode::Space,
-        "Compose" => VirtualKeyCode::Compose,
-        "Caret" => VirtualKeyCode::Caret,
-        "NumLock" => VirtualKeyCode::Numlock,
-        "Numpad0" => VirtualKeyCode::Numpad0,
-        "Numpad1" => VirtualKeyCode::Numpad1,
-        "Numpad2" => VirtualKeyCode::Numpad2,
-        "Numpad3" => VirtualKeyCode::Numpad3,
-        "Numpad4" => VirtualKeyCode::Numpad4,
-        "Numpad5" => VirtualKeyCode::Numpad5,
-        "Numpad6" => VirtualKeyCode::Numpad6,
-        "Numpad7" => VirtualKeyCode::Numpad7,
-        "Numpad8" => VirtualKeyCode::Numpad8,
-        "Numpad9" => VirtualKeyCode::Numpad9,
-        "AbntC1" => VirtualKeyCode::AbntC1,
-        "AbntC2" => VirtualKeyCode::AbntC2,
-        "NumpadAdd" => VirtualKeyCode::NumpadAdd,
-        "Quote" => VirtualKeyCode::Apostrophe,
-        "Apps" => VirtualKeyCode::Apps,
-        "At" => VirtualKeyCode::At,
-        "Ax" => VirtualKeyCode::Ax,
-        "Backslash" => VirtualKeyCode::Backslash,
-        "Calculator" => VirtualKeyCode::Calculator,
-        "Capital" => VirtualKeyCode::Capital,
-        "Semicolon" => VirtualKeyCode::Semicolon,
-        "Comma" => VirtualKeyCode::Comma,
-        "Convert" => VirtualKeyCode::Convert,
-        "NumpadDecimal" => VirtualKeyCode::NumpadDecimal,
-        "NumpadDivide" => VirtualKeyCode::NumpadDivide,
-        "Equal" => VirtualKeyCode::Equals,
-        "Backquote" => VirtualKeyCode::Grave,
-        "Kana" => VirtualKeyCode::Kana,
-        "Kanji" => VirtualKeyCode::Kanji,
-        "AltLeft" => VirtualKeyCode::LAlt,
-        "BracketLeft" => VirtualKeyCode::LBracket,
-        "ControlLeft" => VirtualKeyCode::LControl,
-        "ShiftLeft" => VirtualKeyCode::LShift,
-        "MetaLeft" => VirtualKeyCode::LWin,
-        "Mail" => VirtualKeyCode::Mail,
-        "MediaSelect" => VirtualKeyCode::MediaSelect,
-        "MediaStop" => VirtualKeyCode::MediaStop,
-        "Minus" => VirtualKeyCode::Minus,
-        "NumpadMultiply" => VirtualKeyCode::NumpadMultiply,
-        "Mute" => VirtualKeyCode::Mute,
-        "LaunchMyComputer" => VirtualKeyCode::MyComputer,
-        "NavigateForward" => VirtualKeyCode::NavigateForward,
-        "NavigateBackward" => VirtualKeyCode::NavigateBackward,
-        "NextTrack" => VirtualKeyCode::NextTrack,
-        "NoConvert" => VirtualKeyCode::NoConvert,
-        "NumpadComma" => VirtualKeyCode::NumpadComma,
-        "NumpadEnter" => VirtualKeyCode::NumpadEnter,
-        "NumpadEquals" => VirtualKeyCode::NumpadEquals,
-        "OEM102" => VirtualKeyCode::OEM102,
-        "Period" => VirtualKeyCode::Period,
-        "PlayPause" => VirtualKeyCode::PlayPause,
-        "Power" => VirtualKeyCode::Power,
-        "PrevTrack" => VirtualKeyCode::PrevTrack,
-        "AltRight" => VirtualKeyCode::RAlt,
-        "BracketRight" => VirtualKeyCode::RBracket,
-        "ControlRight" => VirtualKeyCode::RControl,
-        "ShiftRight" => VirtualKeyCode::RShift,
-        "MetaRight" => VirtualKeyCode::RWin,
-        "Slash" => VirtualKeyCode::Slash,
-        "Sleep" => VirtualKeyCode::Sleep,
-        "Stop" => VirtualKeyCode::Stop,
-        "NumpadSubtract" => VirtualKeyCode::NumpadSubtract,
-        "Sysrq" => VirtualKeyCode::Sysrq,
-        "Tab" => VirtualKeyCode::Tab,
-        "Underline" => VirtualKeyCode::Underline,
-        "Unlabeled" => VirtualKeyCode::Unlabeled,
-        "AudioVolumeDown" => VirtualKeyCode::VolumeDown,
-        "AudioVolumeUp" => VirtualKeyCode::VolumeUp,
-        "Wake" => VirtualKeyCode::Wake,
-        "WebBack" => VirtualKeyCode::WebBack,
-        "WebFavorites" => VirtualKeyCode::WebFavorites,
-        "WebForward" => VirtualKeyCode::WebForward,
-        "WebHome" => VirtualKeyCode::WebHome,
-        "WebRefresh" => VirtualKeyCode::WebRefresh,
-        "WebSearch" => VirtualKeyCode::WebSearch,
-        "WebStop" => VirtualKeyCode::WebStop,
-        "Yen" => VirtualKeyCode::Yen,
-        _ => return None,
-    })
-}
-
-pub fn keyboard_modifiers(event: &impl IKeyboardEvent) -> ModifiersState {
-    let mut m = ModifiersState::empty();
-    m.set(ModifiersState::SHIFT, event.shift_key());
-    m.set(ModifiersState::CTRL, event.ctrl_key());
-    m.set(ModifiersState::ALT, event.alt_key());
-    m.set(ModifiersState::LOGO, event.meta_key());
-    m
-}
-
-pub fn codepoint(event: &impl IKeyboardEvent) -> char {
-    // `event.key()` always returns a non-empty `String`. Therefore, this should
-    // never panic.
-    // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key
-    event.key().chars().next().unwrap()
-}

src/platform_impl/web/stdweb/mod.rs

@@ -1,96 +0,0 @@
-#![deprecated(since = "0.23.0", note = "Please migrate to web-sys over stdweb")]
-
-mod canvas;
-mod event;
-mod scaling;
-mod timeout;
-
-pub use self::canvas::Canvas;
-pub use self::scaling::ScaleChangeDetector;
-pub use self::timeout::{AnimationFrameRequest, Timeout};
-
-use crate::dpi::{LogicalSize, Size};
-use crate::platform::web::WindowExtStdweb;
-use crate::window::Window;
-
-use stdweb::js;
-use stdweb::unstable::TryInto;
-use stdweb::web::event::BeforeUnloadEvent;
-use stdweb::web::window;
-use stdweb::web::IEventTarget;
-use stdweb::web::{document, html_element::CanvasElement, Element};
-
-pub fn throw(msg: &str) {
-    js! { throw @{msg} }
-}
-
-pub fn exit_fullscreen() {
-    document().exit_fullscreen();
-}
-
-pub type UnloadEventHandle = ();
-
-pub fn on_unload(mut handler: impl FnMut() + 'static) -> UnloadEventHandle {
-    window().add_event_listener(move |_: BeforeUnloadEvent| handler());
-}
-
-impl WindowExtStdweb for Window {
-    fn canvas(&self) -> CanvasElement {
-        self.window.canvas().raw().clone()
-    }
-
-    fn is_dark_mode(&self) -> bool {
-        // TODO: upstream to stdweb
-        let is_dark_mode = js! {
-            return (window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches)
-        };
-
-        is_dark_mode.try_into().expect("should return a bool")
-    }
-}
-
-pub fn window_size() -> LogicalSize<f64> {
-    let window = window();
-    let width = window.inner_width() as f64;
-    let height = window.inner_height() as f64;
-
-    LogicalSize { width, height }
-}
-
-pub fn scale_factor() -> f64 {
-    let window = window();
-    window.device_pixel_ratio()
-}
-
-pub fn set_canvas_size(raw: &CanvasElement, size: Size) {
-    use stdweb::*;
-
-    let scale_factor = scale_factor();
-
-    let physical_size = size.to_physical::<u32>(scale_factor);
-    let logical_size = size.to_logical::<f64>(scale_factor);
-
-    raw.set_width(physical_size.width);
-    raw.set_height(physical_size.height);
-
-    set_canvas_style_property(raw, "width", &format!("{}px", logical_size.width));
-    set_canvas_style_property(raw, "height", &format!("{}px", logical_size.height));
-}
-
-pub fn set_canvas_style_property(raw: &CanvasElement, style_attribute: &str, value: &str) {
-    js! {
-        @{raw.as_ref()}.style[@{style_attribute}] = @{value};
-    }
-}
-
-pub fn is_fullscreen(canvas: &CanvasElement) -> bool {
-    match document().fullscreen_element() {
-        Some(elem) => {
-            let raw: Element = canvas.clone().into();
-            raw == elem
-        }
-        None => false,
-    }
-}
-
-pub type RawCanvasType = CanvasElement;

src/platform_impl/web/stdweb/scaling.rs

@@ -1,13 +0,0 @@
-use super::super::ScaleChangeArgs;
-
-pub struct ScaleChangeDetector(());
-
-impl ScaleChangeDetector {
-    pub(crate) fn new<F>(_handler: F) -> Self
-    where
-        F: 'static + FnMut(ScaleChangeArgs),
-    {
-        // TODO: Stub, unimplemented (see web_sys for reference).
-        Self(())
-    }
-}

src/platform_impl/web/stdweb/timeout.rs

@@ -1,63 +0,0 @@
-use std::cell::Cell;
-use std::rc::Rc;
-use std::time::Duration;
-use stdweb::web::{window, IWindowOrWorker, RequestAnimationFrameHandle, TimeoutHandle};
-
-#[derive(Debug)]
-pub struct Timeout {
-    handle: Option<TimeoutHandle>,
-}
-
-impl Timeout {
-    pub fn new<F>(f: F, duration: Duration) -> Timeout
-    where
-        F: 'static + FnMut(),
-    {
-        Timeout {
-            handle: Some(window().set_clearable_timeout(f, duration.as_millis() as u32)),
-        }
-    }
-}
-
-impl Drop for Timeout {
-    fn drop(&mut self) {
-        let handle = self.handle.take().unwrap();
-        handle.clear();
-    }
-}
-
-#[derive(Debug)]
-pub struct AnimationFrameRequest {
-    handle: Option<RequestAnimationFrameHandle>,
-    // track callback state, because `cancelAnimationFrame` is slow
-    fired: Rc<Cell<bool>>,
-}
-
-impl AnimationFrameRequest {
-    pub fn new<F>(mut f: F) -> AnimationFrameRequest
-    where
-        F: 'static + FnMut(),
-    {
-        let fired = Rc::new(Cell::new(false));
-        let c_fired = fired.clone();
-        let handle = window().request_animation_frame(move |_| {
-            (*c_fired).set(true);
-            f();
-        });
-
-        AnimationFrameRequest {
-            handle: Some(handle),
-            fired,
-        }
-    }
-}
-
-impl Drop for AnimationFrameRequest {
-    fn drop(&mut self) {
-        if !(*self.fired).get() {
-            if let Some(handle) = self.handle.take() {
-                handle.cancel();
-            }
-        }
-    }
-}

src/platform_impl/web/web_sys/canvas.rs

@@ -18,6 +18,7 @@ use web_sys::{
 mod mouse_handler;
 mod pointer_handler;
 
+#[allow(dead_code)]
 pub struct Canvas {
     common: Common,
     on_focus: Option<EventListenerHandle<dyn FnMut(FocusEvent)>>,
@@ -157,7 +158,17 @@ impl Canvas {
         self.on_keyboard_press = Some(self.common.add_user_event(
             "keydown",
             move |event: KeyboardEvent| {
-                event.prevent_default();
+                // event.prevent_default() would suppress subsequent on_received_character() calls. That
+                // supression is correct for key sequences like Tab/Shift-Tab, Ctrl+R, PgUp/Down to
+                // scroll, etc. We should not do it for key sequences that result in meaningful character
+                // input though.
+                let event_key = &event.key();
+                let is_key_string = event_key.len() == 1 || !event_key.is_ascii();
+                let is_shortcut_modifiers =
+                    (event.ctrl_key() || event.alt_key()) && !event.get_modifier_state("AltGr");
+                if !is_key_string || is_shortcut_modifiers {
+                    event.prevent_default();
+                }
                 handler(
                     event::scan_code(&event),
                     event::virtual_key_code(&event),
@@ -179,6 +190,8 @@ impl Canvas {
         self.on_received_character = Some(self.common.add_user_event(
             "keypress",
             move |event: KeyboardEvent| {
+                // Supress further handling to stop keys like the space key from scrolling the page.
+                event.prevent_default();
                 handler(event::codepoint(&event));
             },
         ));
@@ -226,7 +239,7 @@ impl Canvas {
 
     pub fn on_cursor_move<F>(&mut self, handler: F)
     where
-        F: 'static + FnMut(i32, PhysicalPosition<f64>, ModifiersState),
+        F: 'static + FnMut(i32, PhysicalPosition<f64>, PhysicalPosition<f64>, ModifiersState),
     {
         match &mut self.mouse_state {
             MouseState::HasPointerEvent(h) => h.on_cursor_move(&self.common, handler),

src/platform_impl/web/web_sys/canvas/mouse_handler.rs

@@ -8,6 +8,7 @@ use std::rc::Rc;
 
 use web_sys::{EventTarget, MouseEvent};
 
+#[allow(dead_code)]
 pub(super) struct MouseHandler {
     on_mouse_leave: Option<EventListenerHandle<dyn FnMut(MouseEvent)>>,
     on_mouse_enter: Option<EventListenerHandle<dyn FnMut(MouseEvent)>>,
@@ -160,7 +161,7 @@ impl MouseHandler {
 
     pub fn on_cursor_move<F>(&mut self, canvas_common: &super::Common, mut handler: F)
     where
-        F: 'static + FnMut(i32, PhysicalPosition<f64>, ModifiersState),
+        F: 'static + FnMut(i32, PhysicalPosition<f64>, PhysicalPosition<f64>, ModifiersState),
     {
         let mouse_capture_state = self.mouse_capture_state.clone();
         let canvas = canvas_common.raw.clone();
@@ -190,9 +191,11 @@ impl MouseHandler {
                             // use `offsetX`/`offsetY`.
                             event::mouse_position_by_client(&event, &canvas)
                         };
+                        let mouse_delta = event::mouse_delta(&event);
                         handler(
                             0,
                             mouse_pos.to_physical(super::super::scale_factor()),
+                            mouse_delta.to_physical(super::super::scale_factor()),
                             event::mouse_modifiers(&event),
                         );
                     }

src/platform_impl/web/web_sys/canvas/pointer_handler.rs

@@ -5,6 +5,7 @@ use crate::event::{ModifiersState, MouseButton};
 
 use web_sys::PointerEvent;
 
+#[allow(dead_code)]
 pub(super) struct PointerHandler {
     on_cursor_leave: Option<EventListenerHandle<dyn FnMut(PointerEvent)>>,
     on_cursor_enter: Option<EventListenerHandle<dyn FnMut(PointerEvent)>>,
@@ -87,7 +88,7 @@ impl PointerHandler {
 
     pub fn on_cursor_move<F>(&mut self, canvas_common: &super::Common, mut handler: F)
     where
-        F: 'static + FnMut(i32, PhysicalPosition<f64>, ModifiersState),
+        F: 'static + FnMut(i32, PhysicalPosition<f64>, PhysicalPosition<f64>, ModifiersState),
     {
         self.on_cursor_move = Some(canvas_common.add_event(
             "pointermove",
@@ -95,6 +96,7 @@ impl PointerHandler {
                 handler(
                     event.pointer_id(),
                     event::mouse_position(&event).to_physical(super::super::scale_factor()),
+                    event::mouse_delta(&event).to_physical(super::super::scale_factor()),
                     event::mouse_modifiers(&event),
                 );
             },

src/platform_impl/web/web_sys/event.rs

@@ -29,6 +29,13 @@ pub fn mouse_position(event: &MouseEvent) -> LogicalPosition<f64> {
     }
 }
 
+pub fn mouse_delta(event: &MouseEvent) -> LogicalPosition<f64> {
+    LogicalPosition {
+        x: event.movement_x() as f64,
+        y: event.movement_y() as f64,
+    }
+}
+
 pub fn mouse_position_by_client(
     event: &MouseEvent,
     canvas: &HtmlCanvasElement,

src/platform_impl/web/web_sys/scaling.rs

@@ -59,9 +59,9 @@ impl ScaleChangeDetectorInternal {
         // We add 0.0001 to the lower and upper bounds such that it won't fail
         // due to floating point precision limitations.
         let media_query = format!(
-            "(min-resolution: {:.4}dppx) and (max-resolution: {:.4}dppx)",
-            current_scale - 0.0001,
-            current_scale + 0.0001,
+            "(min-resolution: {min_scale:.4}dppx) and (max-resolution: {max_scale:.4}dppx),
+             (-webkit-min-device-pixel-ratio: {min_scale:.4}) and (-webkit-max-device-pixel-ratio: {max_scale:.4})",
+            min_scale = current_scale - 0.0001, max_scale= current_scale + 0.0001,
         );
         let mql = MediaQueryListHandle::new(&media_query, closure);
         if let Some(mql) = &mql {

src/platform_impl/web/window.rs

@@ -3,9 +3,11 @@ use crate::error::{ExternalError, NotSupportedError, OsError as RootOE};
 use crate::event;
 use crate::icon::Icon;
 use crate::monitor::MonitorHandle as RootMH;
-use crate::window::{CursorIcon, Fullscreen, WindowAttributes, WindowId as RootWI};
+use crate::window::{
+    CursorIcon, Fullscreen, UserAttentionType, WindowAttributes, WindowId as RootWI,
+};
 
-use raw_window_handle::web::WebHandle;
+use raw_window_handle::{RawWindowHandle, WebHandle};
 
 use super::{backend, monitor, EventLoopWindowTarget};
 
@@ -220,6 +222,11 @@ impl Window {
         }
     }
 
+    #[inline]
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        Err(ExternalError::NotSupported(NotSupportedError::new()))
+    }
+
     #[inline]
     pub fn set_minimized(&self, _minimized: bool) {
         // Intentionally a no-op, as canvases cannot be 'minimized'
@@ -230,6 +237,12 @@ impl Window {
         // Intentionally a no-op, as canvases cannot be 'maximized'
     }
 
+    #[inline]
+    pub fn is_maximized(&self) -> bool {
+        // Canvas cannot be 'maximized'
+        false
+    }
+
     #[inline]
     pub fn fullscreen(&self) -> Option<Fullscreen> {
         if self.canvas.borrow().is_fullscreen() {
@@ -268,6 +281,16 @@ impl Window {
         // Currently a no-op as it does not seem there is good support for this on web
     }
 
+    #[inline]
+    pub fn focus_window(&self) {
+        // Currently a no-op as it does not seem there is good support for this on web
+    }
+
+    #[inline]
+    pub fn request_user_attention(&self, _request_type: Option<UserAttentionType>) {
+        // Currently an intentional no-op
+    }
+
     #[inline]
     // Allow directly accessing the current monitor internally without unwrapping.
     fn current_monitor_inner(&self) -> RootMH {
@@ -299,13 +322,10 @@ impl Window {
     }
 
     #[inline]
-    pub fn raw_window_handle(&self) -> raw_window_handle::RawWindowHandle {
-        let handle = WebHandle {
-            id: self.id.0,
-            ..WebHandle::empty()
-        };
-
-        raw_window_handle::RawWindowHandle::Web(handle)
+    pub fn raw_window_handle(&self) -> RawWindowHandle {
+        let mut handle = WebHandle::empty();
+        handle.id = self.id.0;
+        RawWindowHandle::Web(handle)
     }
 }
 
@@ -321,7 +341,7 @@ impl Drop for Window {
 pub struct Id(pub(crate) u32);
 
 impl Id {
-    pub unsafe fn dummy() -> Id {
+    pub const unsafe fn dummy() -> Id {
         Id(0)
     }
 }

src/platform_impl/windows/dark_mode.rs

@@ -6,36 +6,24 @@ use std::os::windows::ffi::OsStrExt;
 use winapi::{
     shared::{
         basetsd::SIZE_T,
-        minwindef::{BOOL, DWORD, FALSE, UINT, ULONG, WORD},
-        ntdef::{LPSTR, NTSTATUS, NT_SUCCESS, PVOID, WCHAR},
+        minwindef::{BOOL, DWORD, FALSE, WORD},
+        ntdef::{NTSTATUS, NT_SUCCESS, PVOID},
         windef::HWND,
         winerror::S_OK,
     },
-    um::{libloaderapi, uxtheme, winuser},
+    um::{libloaderapi, uxtheme, winnt, winuser},
 };
 
+use crate::window::Theme;
+
 lazy_static! {
     static ref WIN10_BUILD_VERSION: Option<DWORD> = {
-        // FIXME: RtlGetVersion is a documented windows API,
-        // should be part of winapi!
-
-        #[allow(non_snake_case)]
-        #[repr(C)]
-        struct OSVERSIONINFOW {
-            dwOSVersionInfoSize: ULONG,
-            dwMajorVersion: ULONG,
-            dwMinorVersion: ULONG,
-            dwBuildNumber: ULONG,
-            dwPlatformId: ULONG,
-            szCSDVersion: [WCHAR; 128],
-        }
-
-        type RtlGetVersion = unsafe extern "system" fn (*mut OSVERSIONINFOW) -> NTSTATUS;
+        type RtlGetVersion = unsafe extern "system" fn (*mut winnt::OSVERSIONINFOW) -> NTSTATUS;
         let handle = get_function!("ntdll.dll", RtlGetVersion);
 
         if let Some(rtl_get_version) = handle {
             unsafe {
-                let mut vi = OSVERSIONINFOW {
+                let mut vi = winnt::OSVERSIONINFOW {
                     dwOSVersionInfoSize: 0,
                     dwMajorVersion: 0,
                     dwMinorVersion: 0,
@@ -70,24 +58,33 @@ lazy_static! {
     static ref LIGHT_THEME_NAME: Vec<u16> = widestring("");
 }
 
-/// Attempt to set dark mode on a window, if necessary.
-/// Returns true if dark mode was set, false if not.
-pub fn try_dark_mode(hwnd: HWND) -> bool {
+/// Attempt to set a theme on a window, if necessary.
+/// Returns the theme that was picked
+pub fn try_theme(hwnd: HWND, preferred_theme: Option<Theme>) -> Theme {
     if *DARK_MODE_SUPPORTED {
-        let is_dark_mode = should_use_dark_mode();
+        let is_dark_mode = match preferred_theme {
+            Some(theme) => theme == Theme::Dark,
+            None => should_use_dark_mode(),
+        };
 
-        let theme_name = if is_dark_mode {
-            DARK_THEME_NAME.as_ptr()
+        let theme = if is_dark_mode {
+            Theme::Dark
         } else {
-            LIGHT_THEME_NAME.as_ptr()
+            Theme::Light
+        };
+        let theme_name = match theme {
+            Theme::Dark => DARK_THEME_NAME.as_ptr(),
+            Theme::Light => LIGHT_THEME_NAME.as_ptr(),
         };
 
         let status = unsafe { uxtheme::SetWindowTheme(hwnd, theme_name as _, std::ptr::null()) };
 
-        status == S_OK && set_dark_mode_for_window(hwnd, is_dark_mode)
-    } else {
-        false
+        if status == S_OK && set_dark_mode_for_window(hwnd, is_dark_mode) {
+            return theme;
+        }
     }
+
+    Theme::Light
 }
 
 fn set_dark_mode_for_window(hwnd: HWND, is_dark_mode: bool) -> bool {
@@ -97,11 +94,12 @@ fn set_dark_mode_for_window(hwnd: HWND, is_dark_mode: bool) -> bool {
     type SetWindowCompositionAttribute =
         unsafe extern "system" fn(HWND, *mut WINDOWCOMPOSITIONATTRIBDATA) -> BOOL;
 
-    #[allow(non_snake_case)]
+    #[allow(clippy::upper_case_acronyms)]
     type WINDOWCOMPOSITIONATTRIB = u32;
     const WCA_USEDARKMODECOLORS: WINDOWCOMPOSITIONATTRIB = 26;
 
     #[allow(non_snake_case)]
+    #[allow(clippy::upper_case_acronyms)]
     #[repr(C)]
     struct WINDOWCOMPOSITIONATTRIBDATA {
         Attrib: WINDOWCOMPOSITIONATTRIB,
@@ -170,21 +168,8 @@ fn should_apps_use_dark_mode() -> bool {
         .unwrap_or(false)
 }
 
-// FIXME: This definition was missing from winapi. Can remove from
-// here and use winapi once the following PR is released:
-// https://github.com/retep998/winapi-rs/pull/815
-#[repr(C)]
-#[allow(non_snake_case)]
-struct HIGHCONTRASTA {
-    cbSize: UINT,
-    dwFlags: DWORD,
-    lpszDefaultScheme: LPSTR,
-}
-
-const HCF_HIGHCONTRASTON: DWORD = 1;
-
 fn is_high_contrast() -> bool {
-    let mut hc = HIGHCONTRASTA {
+    let mut hc = winuser::HIGHCONTRASTA {
         cbSize: 0,
         dwFlags: 0,
         lpszDefaultScheme: std::ptr::null_mut(),
@@ -199,7 +184,7 @@ fn is_high_contrast() -> bool {
         )
     };
 
-    ok != FALSE && (HCF_HIGHCONTRASTON & hc.dwFlags) == 1
+    ok != FALSE && (winuser::HCF_HIGHCONTRASTON & hc.dwFlags) == 1
 }
 
 fn widestring(src: &'static str) -> Vec<u16> {

src/platform_impl/windows/drop_handler.rs

@@ -181,7 +181,7 @@ impl FileDropHandler {
             },
         };
 
-        let mut drop_format = FORMATETC {
+        let drop_format = FORMATETC {
             cfFormat: CF_HDROP as CLIPFORMAT,
             ptd: ptr::null(),
             dwAspect: DVASPECT_CONTENT,
@@ -190,7 +190,7 @@ impl FileDropHandler {
         };
 
         let mut medium = std::mem::zeroed();
-        let get_data_result = (*data_obj).GetData(&mut drop_format, &mut medium);
+        let get_data_result = (*data_obj).GetData(&drop_format, &mut medium);
         if SUCCEEDED(get_data_result) {
             let hglobal = (*medium.u).hGlobal();
             let hdrop = (*hglobal) as shellapi::HDROP;
@@ -213,15 +213,15 @@ impl FileDropHandler {
                 callback(OsString::from_wide(&path_buf[0..character_count]).into());
             }
 
-            return Some(hdrop);
+            Some(hdrop)
         } else if get_data_result == DV_E_FORMATETC {
             // If the dropped item is not a file this error will occur.
             // In this case it is OK to return without taking further action.
             debug!("Error occured while processing dropped/hovered item: item is not a file.");
-            return None;
+            None
         } else {
             debug!("Unexpected error occured while processing dropped/hovered item.");
-            return None;
+            None
         }
     }
 }

src/platform_impl/windows/event.rs

@@ -39,8 +39,8 @@ pub fn get_key_mods() -> ModifiersState {
 bitflags! {
     #[derive(Default)]
     pub struct ModifiersStateSide: u32 {
-        const LSHIFT = 0b010 << 0;
-        const RSHIFT = 0b001 << 0;
+        const LSHIFT = 0b010;
+        const RSHIFT = 0b001;
 
         const LCTRL = 0b010 << 3;
         const RCTRL = 0b001 << 3;
@@ -343,6 +343,7 @@ pub fn handle_extended_keys(
     extended: bool,
 ) -> Option<(c_int, UINT)> {
     // Welcome to hell https://blog.molecular-matters.com/2011/09/05/properly-handling-keyboard-input/
+    scancode |= if extended { 0xE000 } else { 0x0000 };
     let vkey = match vkey {
         winuser::VK_SHIFT => unsafe {
             winuser::MapVirtualKeyA(scancode, winuser::MAPVK_VSC_TO_VK_EX) as _
@@ -363,20 +364,23 @@ pub fn handle_extended_keys(
         }
         _ => {
             match scancode {
-                // This is only triggered when using raw input. Without this check, we get two events whenever VK_PAUSE is
-                // pressed, the first one having scancode 0x1D but vkey VK_PAUSE...
-                0x1D if vkey == winuser::VK_PAUSE => return None,
-                // ...and the second having scancode 0x45 but an unmatched vkey!
-                0x45 => winuser::VK_PAUSE,
-                // VK_PAUSE and VK_SCROLL have the same scancode when using modifiers, alongside incorrect vkey values.
-                0x46 => {
-                    if extended {
-                        scancode = 0x45;
-                        winuser::VK_PAUSE
-                    } else {
-                        winuser::VK_SCROLL
-                    }
+                // When VK_PAUSE is pressed it emits a LeftControl + NumLock scancode event sequence, but reports VK_PAUSE
+                // as the virtual key on both events, or VK_PAUSE on the first event or 0xFF when using raw input.
+                // Don't emit anything for the LeftControl event in the pair...
+                0xE01D if vkey == winuser::VK_PAUSE => return None,
+                // ...and emit the Pause event for the second event in the pair.
+                0x45 if vkey == winuser::VK_PAUSE || vkey == 0xFF => {
+                    scancode = 0xE059;
+                    winuser::VK_PAUSE
                 }
+                // VK_PAUSE has an incorrect vkey value when used with modifiers. VK_PAUSE also reports a different
+                // scancode when used with modifiers than when used without
+                0xE046 => {
+                    scancode = 0xE059;
+                    winuser::VK_PAUSE
+                }
+                // VK_SCROLL has an incorrect vkey value when used with modifiers.
+                0x46 => winuser::VK_SCROLL,
                 _ => vkey,
             }
         }

src/platform_impl/windows/event_loop/runner.rs

@@ -23,7 +23,7 @@ use crate::{
 pub(crate) type EventLoopRunnerShared<T> = Rc<EventLoopRunner<T>>;
 pub(crate) struct EventLoopRunner<T: 'static> {
     // The event loop's win32 handles
-    thread_msg_target: HWND,
+    pub(super) thread_msg_target: HWND,
     wait_thread_id: DWORD,
 
     control_flow: Cell<ControlFlow>,

src/platform_impl/windows/mod.rs

@@ -1,6 +1,6 @@
 #![cfg(target_os = "windows")]
 
-use winapi::{self, shared::windef::HWND};
+use winapi::{self, shared::windef::HMENU, shared::windef::HWND};
 
 pub use self::{
     event_loop::{EventLoop, EventLoopProxy, EventLoopWindowTarget},
@@ -13,22 +13,34 @@ pub use self::icon::WinIcon as PlatformIcon;
 
 use crate::event::DeviceId as RootDeviceId;
 use crate::icon::Icon;
+use crate::window::Theme;
+
+#[derive(Clone)]
+pub enum Parent {
+    None,
+    ChildOf(HWND),
+    OwnedBy(HWND),
+}
 
 #[derive(Clone)]
 pub struct PlatformSpecificWindowBuilderAttributes {
-    pub parent: Option<HWND>,
+    pub parent: Parent,
+    pub menu: Option<HMENU>,
     pub taskbar_icon: Option<Icon>,
     pub no_redirection_bitmap: bool,
     pub drag_and_drop: bool,
+    pub preferred_theme: Option<Theme>,
 }
 
 impl Default for PlatformSpecificWindowBuilderAttributes {
     fn default() -> Self {
         Self {
-            parent: None,
+            parent: Parent::None,
+            menu: None,
             taskbar_icon: None,
             no_redirection_bitmap: false,
             drag_and_drop: true,
+            preferred_theme: None,
         }
     }
 }
@@ -46,7 +58,7 @@ unsafe impl Sync for Cursor {}
 pub struct DeviceId(u32);
 
 impl DeviceId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         DeviceId(0)
     }
 }
@@ -76,7 +88,7 @@ unsafe impl Send for WindowId {}
 unsafe impl Sync for WindowId {}
 
 impl WindowId {
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         use std::ptr::null_mut;
 
         WindowId(null_mut())

src/platform_impl/windows/util.rs

@@ -30,7 +30,7 @@ where
 }
 
 pub fn wchar_to_string(wchar: &[wchar_t]) -> String {
-    String::from_utf16_lossy(wchar).to_string()
+    String::from_utf16_lossy(wchar)
 }
 
 pub fn wchar_ptr_to_string(wchar: *const wchar_t) -> String {

src/platform_impl/windows/window.rs

@@ -1,30 +1,32 @@
 #![cfg(target_os = "windows")]
 
 use parking_lot::Mutex;
-use raw_window_handle::{windows::WindowsHandle, RawWindowHandle};
+use raw_window_handle::{RawWindowHandle, Win32Handle};
 use std::{
     cell::Cell,
     ffi::OsStr,
     io, mem,
     os::windows::ffi::OsStrExt,
-    ptr,
+    panic, ptr,
     sync::{mpsc::channel, Arc},
 };
 
 use winapi::{
     ctypes::c_int,
     shared::{
-        minwindef::{HINSTANCE, UINT},
-        windef::{HWND, POINT, RECT},
+        minwindef::{HINSTANCE, LPARAM, UINT, WPARAM},
+        windef::{HWND, POINT, POINTS, RECT},
     },
     um::{
-        combaseapi, dwmapi, libloaderapi,
+        combaseapi, dwmapi,
+        imm::{CFS_POINT, COMPOSITIONFORM},
+        libloaderapi,
         objbase::COINIT_APARTMENTTHREADED,
         ole2,
         oleidl::LPDROPTARGET,
         shobjidl_core::{CLSID_TaskbarList, ITaskbarList2},
         wingdi::{CreateRectRgn, DeleteObject},
-        winnt::LPCWSTR,
+        winnt::{LPCWSTR, SHORT},
         winuser,
     },
 };
@@ -35,16 +37,16 @@ use crate::{
     icon::Icon,
     monitor::MonitorHandle as RootMonitorHandle,
     platform_impl::platform::{
-        dark_mode::try_dark_mode,
-        dpi::{dpi_to_scale_factor, hwnd_dpi},
+        dark_mode::try_theme,
+        dpi::{dpi_to_scale_factor, enable_non_client_dpi_scaling, hwnd_dpi},
         drop_handler::FileDropHandler,
-        event_loop::{self, EventLoopWindowTarget, DESTROY_MSG_ID},
+        event_loop::{self, EventLoopWindowTarget, WindowLongPtr, DESTROY_MSG_ID},
         icon::{self, IconType},
         monitor, util,
         window_state::{CursorFlags, SavedWindow, WindowFlags, WindowState},
-        PlatformSpecificWindowBuilderAttributes, WindowId,
+        Parent, PlatformSpecificWindowBuilderAttributes, WindowId,
     },
-    window::{CursorIcon, Fullscreen, WindowAttributes},
+    window::{CursorIcon, Fullscreen, Theme, UserAttentionType, WindowAttributes},
 };
 
 /// The Win32 implementation of the main `Window` object.
@@ -69,56 +71,7 @@ impl Window {
         // First person to remove the need for cloning here gets a cookie!
         //
         // done. you owe me -- ossi
-        unsafe {
-            let drag_and_drop = pl_attr.drag_and_drop;
-            init(w_attr, pl_attr, event_loop).map(|win| {
-                let file_drop_handler = if drag_and_drop {
-                    use winapi::shared::winerror::{OLE_E_WRONGCOMPOBJ, RPC_E_CHANGED_MODE, S_OK};
-
-                    let ole_init_result = ole2::OleInitialize(ptr::null_mut());
-                    // It is ok if the initialize result is `S_FALSE` because it might happen that
-                    // multiple windows are created on the same thread.
-                    if ole_init_result == OLE_E_WRONGCOMPOBJ {
-                        panic!("OleInitialize failed! Result was: `OLE_E_WRONGCOMPOBJ`");
-                    } else if ole_init_result == RPC_E_CHANGED_MODE {
-                        panic!(
-                            "OleInitialize failed! Result was: `RPC_E_CHANGED_MODE`. \
-                            Make sure other crates are not using multithreaded COM library \
-                            on the same thread or disable drag and drop support."
-                        );
-                    }
-
-                    let file_drop_runner = event_loop.runner_shared.clone();
-                    let file_drop_handler = FileDropHandler::new(
-                        win.window.0,
-                        Box::new(move |event| {
-                            if let Ok(e) = event.map_nonuser_event() {
-                                file_drop_runner.send_event(e)
-                            }
-                        }),
-                    );
-                    let handler_interface_ptr =
-                        &mut (*file_drop_handler.data).interface as LPDROPTARGET;
-
-                    assert_eq!(
-                        ole2::RegisterDragDrop(win.window.0, handler_interface_ptr),
-                        S_OK
-                    );
-                    Some(file_drop_handler)
-                } else {
-                    None
-                };
-
-                let subclass_input = event_loop::SubclassInput {
-                    window_state: win.window_state.clone(),
-                    event_loop_runner: event_loop.runner_shared.clone(),
-                    file_drop_handler,
-                };
-
-                event_loop::subclass_window(win.window.0, subclass_input);
-                win
-            })
-        }
+        unsafe { init(w_attr, pl_attr, event_loop) }
     }
 
     pub fn set_title(&self, text: &str) {
@@ -275,17 +228,15 @@ impl Window {
 
     #[inline]
     pub fn hinstance(&self) -> HINSTANCE {
-        unsafe { winuser::GetWindowLongW(self.hwnd(), winuser::GWL_HINSTANCE) as *mut _ }
+        unsafe { winuser::GetWindowLongPtrW(self.hwnd(), winuser::GWLP_HINSTANCE) as *mut _ }
     }
 
     #[inline]
     pub fn raw_window_handle(&self) -> RawWindowHandle {
-        let handle = WindowsHandle {
-            hwnd: self.window.0 as *mut _,
-            hinstance: self.hinstance() as *mut _,
-            ..WindowsHandle::empty()
-        };
-        RawWindowHandle::Windows(handle)
+        let mut handle = Win32Handle::empty();
+        handle.hwnd = self.window.0 as *mut _;
+        handle.hinstance = self.hinstance() as *mut _;
+        RawWindowHandle::Win32(handle)
     }
 
     #[inline]
@@ -353,6 +304,30 @@ impl Window {
         Ok(())
     }
 
+    #[inline]
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        unsafe {
+            let points = {
+                let mut pos = mem::zeroed();
+                winuser::GetCursorPos(&mut pos);
+                pos
+            };
+            let points = POINTS {
+                x: points.x as SHORT,
+                y: points.y as SHORT,
+            };
+            winuser::ReleaseCapture();
+            winuser::PostMessageW(
+                self.window.0,
+                winuser::WM_NCLBUTTONDOWN,
+                winuser::HTCAPTION as WPARAM,
+                &points as *const _ as LPARAM,
+            );
+        }
+
+        Ok(())
+    }
+
     #[inline]
     pub fn id(&self) -> WindowId {
         WindowId(self.window.0)
@@ -382,6 +357,12 @@ impl Window {
         });
     }
 
+    #[inline]
+    pub fn is_maximized(&self) -> bool {
+        let window_state = self.window_state.lock();
+        window_state.window_flags.contains(WindowFlags::MAXIMIZED)
+    }
+
     #[inline]
     pub fn fullscreen(&self) -> Option<Fullscreen> {
         let window_state = self.window_state.lock();
@@ -402,20 +383,6 @@ impl Window {
         drop(window_state_lock);
 
         self.thread_executor.execute_in_thread(move || {
-            let mut window_state_lock = window_state.lock();
-
-            // Save window bounds before entering fullscreen
-            match (&old_fullscreen, &fullscreen) {
-                (&None, &Some(_)) => {
-                    let client_rect = util::get_client_rect(window.0).unwrap();
-                    window_state_lock.saved_window = Some(SavedWindow {
-                        client_rect,
-                        scale_factor: window_state_lock.scale_factor,
-                    });
-                }
-                _ => (),
-            }
-
             // Change video mode if we're transitioning to or from exclusive
             // fullscreen
             match (&old_fullscreen, &fullscreen) {
@@ -436,7 +403,7 @@ impl Window {
                     // string, so add it
                     display_name.push(0);
 
-                    let mut native_video_mode = video_mode.video_mode.native_video_mode.clone();
+                    let mut native_video_mode = video_mode.video_mode.native_video_mode;
 
                     let res = unsafe {
                         winuser::ChangeDisplaySettingsExW(
@@ -489,13 +456,29 @@ impl Window {
             }
 
             // Update window style
-            WindowState::set_window_flags(window_state_lock, window.0, |f| {
-                f.set(WindowFlags::MARKER_FULLSCREEN, fullscreen.is_some())
+            WindowState::set_window_flags(window_state.lock(), window.0, |f| {
+                f.set(
+                    WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN,
+                    matches!(fullscreen, Some(Fullscreen::Exclusive(_))),
+                );
+                f.set(
+                    WindowFlags::MARKER_BORDERLESS_FULLSCREEN,
+                    matches!(fullscreen, Some(Fullscreen::Borderless(_))),
+                );
             });
 
             // Update window bounds
             match &fullscreen {
                 Some(fullscreen) => {
+                    // Save window bounds before entering fullscreen
+                    let placement = unsafe {
+                        let mut placement = mem::zeroed();
+                        winuser::GetWindowPlacement(window.0, &mut placement);
+                        placement
+                    };
+
+                    window_state.lock().saved_window = Some(SavedWindow { placement });
+
                     let monitor = match &fullscreen {
                         Fullscreen::Exclusive(video_mode) => video_mode.monitor(),
                         Fullscreen::Borderless(Some(monitor)) => monitor.clone(),
@@ -522,27 +505,10 @@ impl Window {
                 }
                 None => {
                     let mut window_state_lock = window_state.lock();
-                    if let Some(SavedWindow {
-                        client_rect,
-                        scale_factor,
-                    }) = window_state_lock.saved_window.take()
-                    {
-                        window_state_lock.scale_factor = scale_factor;
+                    if let Some(SavedWindow { placement }) = window_state_lock.saved_window.take() {
                         drop(window_state_lock);
-                        let client_rect = util::adjust_window_rect(window.0, client_rect).unwrap();
-
                         unsafe {
-                            winuser::SetWindowPos(
-                                window.0,
-                                ptr::null_mut(),
-                                client_rect.left,
-                                client_rect.top,
-                                client_rect.right - client_rect.left,
-                                client_rect.bottom - client_rect.top,
-                                winuser::SWP_ASYNCWINDOWPOS
-                                    | winuser::SWP_NOZORDER
-                                    | winuser::SWP_NOACTIVATE,
-                            );
+                            winuser::SetWindowPlacement(window.0, &placement);
                             winuser::InvalidateRgn(window.0, ptr::null_mut(), 0);
                         }
                     }
@@ -598,6 +564,11 @@ impl Window {
         self.window_state.lock().window_icon = window_icon;
     }
 
+    #[inline]
+    pub fn set_enable(&self, enabled: bool) {
+        unsafe { winuser::EnableWindow(self.hwnd() as _, enabled as _) };
+    }
+
     #[inline]
     pub fn set_taskbar_icon(&self, taskbar_icon: Option<Icon>) {
         if let Some(ref taskbar_icon) = taskbar_icon {
@@ -610,14 +581,75 @@ impl Window {
         self.window_state.lock().taskbar_icon = taskbar_icon;
     }
 
-    #[inline]
-    pub fn set_ime_position(&self, _position: Position) {
-        warn!("`Window::set_ime_position` is ignored on Windows")
+    pub(crate) fn set_ime_position_physical(&self, x: i32, y: i32) {
+        if unsafe { winuser::GetSystemMetrics(winuser::SM_IMMENABLED) } != 0 {
+            let mut composition_form = COMPOSITIONFORM {
+                dwStyle: CFS_POINT,
+                ptCurrentPos: POINT { x, y },
+                rcArea: unsafe { mem::zeroed() },
+            };
+            unsafe {
+                let himc = winapi::um::imm::ImmGetContext(self.window.0);
+                winapi::um::imm::ImmSetCompositionWindow(himc, &mut composition_form);
+                winapi::um::imm::ImmReleaseContext(self.window.0, himc);
+            }
+        }
     }
 
     #[inline]
-    pub fn is_dark_mode(&self) -> bool {
-        self.window_state.lock().is_dark_mode
+    pub fn set_ime_position(&self, spot: Position) {
+        let (x, y) = spot.to_physical::<i32>(self.scale_factor()).into();
+        self.set_ime_position_physical(x, y);
+    }
+
+    #[inline]
+    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        let window = self.window.clone();
+        let active_window_handle = unsafe { winuser::GetActiveWindow() };
+        if window.0 == active_window_handle {
+            return;
+        }
+
+        self.thread_executor.execute_in_thread(move || unsafe {
+            let (flags, count) = request_type
+                .map(|ty| match ty {
+                    UserAttentionType::Critical => {
+                        (winuser::FLASHW_ALL | winuser::FLASHW_TIMERNOFG, u32::MAX)
+                    }
+                    UserAttentionType::Informational => {
+                        (winuser::FLASHW_TRAY | winuser::FLASHW_TIMERNOFG, 0)
+                    }
+                })
+                .unwrap_or((winuser::FLASHW_STOP, 0));
+
+            let mut flash_info = winuser::FLASHWINFO {
+                cbSize: mem::size_of::<winuser::FLASHWINFO>() as UINT,
+                hwnd: window.0,
+                dwFlags: flags,
+                uCount: count,
+                dwTimeout: 0,
+            };
+            winuser::FlashWindowEx(&mut flash_info);
+        });
+    }
+
+    #[inline]
+    pub fn theme(&self) -> Theme {
+        self.window_state.lock().current_theme
+    }
+
+    #[inline]
+    pub fn focus_window(&self) {
+        let window = self.window.clone();
+        let window_flags = self.window_state.lock().window_flags();
+
+        let is_visible = window_flags.contains(WindowFlags::VISIBLE);
+        let is_minimized = window_flags.contains(WindowFlags::MINIMIZED);
+        let is_foreground = window.0 == unsafe { winuser::GetForegroundWindow() };
+
+        if is_visible && !is_minimized && !is_foreground {
+            unsafe { force_window_active(window.0) };
+        }
     }
 }
 
@@ -644,18 +676,180 @@ pub struct WindowWrapper(HWND);
 unsafe impl Sync for WindowWrapper {}
 unsafe impl Send for WindowWrapper {}
 
-unsafe fn init<T: 'static>(
+pub(super) struct InitData<'a, T: 'static> {
+    // inputs
+    pub event_loop: &'a EventLoopWindowTarget<T>,
+    pub attributes: WindowAttributes,
+    pub pl_attribs: PlatformSpecificWindowBuilderAttributes,
+    pub window_flags: WindowFlags,
+    // outputs
+    pub window: Option<Window>,
+}
+
+impl<'a, T: 'static> InitData<'a, T> {
+    unsafe fn create_window(&self, window: HWND) -> Window {
+        // Register for touch events if applicable
+        {
+            let digitizer = winuser::GetSystemMetrics(winuser::SM_DIGITIZER) as u32;
+            if digitizer & winuser::NID_READY != 0 {
+                winuser::RegisterTouchWindow(window, winuser::TWF_WANTPALM);
+            }
+        }
+
+        let dpi = hwnd_dpi(window);
+        let scale_factor = dpi_to_scale_factor(dpi);
+
+        // making the window transparent
+        if self.attributes.transparent && !self.pl_attribs.no_redirection_bitmap {
+            // Empty region for the blur effect, so the window is fully transparent
+            let region = CreateRectRgn(0, 0, -1, -1);
+
+            let bb = dwmapi::DWM_BLURBEHIND {
+                dwFlags: dwmapi::DWM_BB_ENABLE | dwmapi::DWM_BB_BLURREGION,
+                fEnable: 1,
+                hRgnBlur: region,
+                fTransitionOnMaximized: 0,
+            };
+
+            dwmapi::DwmEnableBlurBehindWindow(window, &bb);
+            DeleteObject(region as _);
+        }
+
+        // If the system theme is dark, we need to set the window theme now
+        // before we update the window flags (and possibly show the
+        // window for the first time).
+        let current_theme = try_theme(window, self.pl_attribs.preferred_theme);
+
+        let window_state = {
+            let window_state = WindowState::new(
+                &self.attributes,
+                self.pl_attribs.taskbar_icon.clone(),
+                scale_factor,
+                current_theme,
+                self.pl_attribs.preferred_theme,
+            );
+            let window_state = Arc::new(Mutex::new(window_state));
+            WindowState::set_window_flags(window_state.lock(), window, |f| *f = self.window_flags);
+            window_state
+        };
+
+        enable_non_client_dpi_scaling(window);
+
+        Window {
+            window: WindowWrapper(window),
+            window_state,
+            thread_executor: self.event_loop.create_thread_executor(),
+        }
+    }
+
+    unsafe fn create_window_data(&self, win: &Window) -> event_loop::WindowData<T> {
+        let file_drop_handler = if self.pl_attribs.drag_and_drop {
+            use winapi::shared::winerror::{OLE_E_WRONGCOMPOBJ, RPC_E_CHANGED_MODE, S_OK};
+
+            let ole_init_result = ole2::OleInitialize(ptr::null_mut());
+            // It is ok if the initialize result is `S_FALSE` because it might happen that
+            // multiple windows are created on the same thread.
+            if ole_init_result == OLE_E_WRONGCOMPOBJ {
+                panic!("OleInitialize failed! Result was: `OLE_E_WRONGCOMPOBJ`");
+            } else if ole_init_result == RPC_E_CHANGED_MODE {
+                panic!(
+                    "OleInitialize failed! Result was: `RPC_E_CHANGED_MODE`. \
+                    Make sure other crates are not using multithreaded COM library \
+                    on the same thread or disable drag and drop support."
+                );
+            }
+
+            let file_drop_runner = self.event_loop.runner_shared.clone();
+            let file_drop_handler = FileDropHandler::new(
+                win.window.0,
+                Box::new(move |event| {
+                    if let Ok(e) = event.map_nonuser_event() {
+                        file_drop_runner.send_event(e)
+                    }
+                }),
+            );
+            let handler_interface_ptr = &mut (*file_drop_handler.data).interface as LPDROPTARGET;
+
+            assert_eq!(
+                ole2::RegisterDragDrop(win.window.0, handler_interface_ptr),
+                S_OK
+            );
+            Some(file_drop_handler)
+        } else {
+            None
+        };
+
+        self.event_loop.runner_shared.register_window(win.window.0);
+
+        event_loop::WindowData {
+            window_state: win.window_state.clone(),
+            event_loop_runner: self.event_loop.runner_shared.clone(),
+            _file_drop_handler: file_drop_handler,
+            userdata_removed: Cell::new(false),
+            recurse_depth: Cell::new(0),
+        }
+    }
+
+    // Returns a pointer to window user data on success.
+    // The user data will be registered for the window and can be accessed within the window event callback.
+    pub unsafe fn on_nccreate(&mut self, window: HWND) -> Option<WindowLongPtr> {
+        let runner = self.event_loop.runner_shared.clone();
+        let result = runner.catch_unwind(|| unsafe {
+            let mut window = self.create_window(window);
+            let window_data = self.create_window_data(&mut window);
+            (window, window_data)
+        });
+
+        result.map(|(win, userdata)| {
+            self.window = Some(win);
+            let userdata = Box::into_raw(Box::new(userdata));
+            userdata as _
+        })
+    }
+
+    pub unsafe fn on_create(&mut self) {
+        let win = self.window.as_mut().expect("failed window creation");
+        let attributes = self.attributes.clone();
+
+        // Set visible before setting the size to ensure the
+        // attribute is correctly applied.
+        win.set_visible(attributes.visible);
+
+        let dimensions = attributes
+            .inner_size
+            .unwrap_or_else(|| PhysicalSize::new(800, 600).into());
+        win.set_inner_size(dimensions);
+        if attributes.maximized {
+            // Need to set MAXIMIZED after setting `inner_size` as
+            // `Window::set_inner_size` changes MAXIMIZED to false.
+            win.set_maximized(true);
+        }
+
+        if attributes.fullscreen.is_some() {
+            win.set_fullscreen(attributes.fullscreen);
+            force_window_active(win.window.0);
+        }
+
+        if let Some(position) = attributes.position {
+            win.set_outer_position(position);
+        }
+    }
+}
+unsafe fn init<T>(
     attributes: WindowAttributes,
     pl_attribs: PlatformSpecificWindowBuilderAttributes,
     event_loop: &EventLoopWindowTarget<T>,
-) -> Result<Window, RootOsError> {
+) -> Result<Window, RootOsError>
+where
+    T: 'static,
+{
     let title = OsStr::new(&attributes.title)
         .encode_wide()
         .chain(Some(0).into_iter())
         .collect::<Vec<_>>();
 
     // registering the window class
-    let class_name = register_window_class(&attributes.window_icon, &pl_attribs.taskbar_icon);
+    let class_name = register_window_class::<T>(&attributes.window_icon, &pl_attribs.taskbar_icon);
 
     let mut window_flags = WindowFlags::empty();
     window_flags.set(WindowFlags::DECORATIONS, attributes.decorations);
@@ -667,120 +861,64 @@ unsafe fn init<T: 'static>(
     window_flags.set(WindowFlags::TRANSPARENT, attributes.transparent);
     // WindowFlags::VISIBLE and MAXIMIZED are set down below after the window has been configured.
     window_flags.set(WindowFlags::RESIZABLE, attributes.resizable);
-    window_flags.set(WindowFlags::CHILD, pl_attribs.parent.is_some());
-    window_flags.set(WindowFlags::ON_TASKBAR, true);
 
-    // creating the real window this time, by using the functions in `extra_functions`
-    let real_window = {
-        let (style, ex_style) = window_flags.to_window_styles();
-        let handle = winuser::CreateWindowExW(
-            ex_style,
-            class_name.as_ptr(),
-            title.as_ptr() as LPCWSTR,
-            style,
-            winuser::CW_USEDEFAULT,
-            winuser::CW_USEDEFAULT,
-            winuser::CW_USEDEFAULT,
-            winuser::CW_USEDEFAULT,
-            pl_attribs.parent.unwrap_or(ptr::null_mut()),
-            ptr::null_mut(),
-            libloaderapi::GetModuleHandleW(ptr::null()),
-            ptr::null_mut(),
-        );
-
-        if handle.is_null() {
-            return Err(os_error!(io::Error::last_os_error()));
+    let parent = match pl_attribs.parent {
+        Parent::ChildOf(parent) => {
+            window_flags.set(WindowFlags::CHILD, true);
+            if pl_attribs.menu.is_some() {
+                warn!("Setting a menu on a child window is unsupported");
+            }
+            Some(parent)
+        }
+        Parent::OwnedBy(parent) => {
+            window_flags.set(WindowFlags::POPUP, true);
+            Some(parent)
+        }
+        Parent::None => {
+            window_flags.set(WindowFlags::ON_TASKBAR, true);
+            None
         }
-
-        WindowWrapper(handle)
     };
 
-    // Register for touch events if applicable
-    {
-        let digitizer = winuser::GetSystemMetrics(winuser::SM_DIGITIZER) as u32;
-        if digitizer & winuser::NID_READY != 0 {
-            winuser::RegisterTouchWindow(real_window.0, winuser::TWF_WANTPALM);
-        }
-    }
-
-    let dpi = hwnd_dpi(real_window.0);
-    let scale_factor = dpi_to_scale_factor(dpi);
-
-    // making the window transparent
-    if attributes.transparent && !pl_attribs.no_redirection_bitmap {
-        let region = CreateRectRgn(0, 0, -1, -1); // makes the window transparent
-
-        let bb = dwmapi::DWM_BLURBEHIND {
-            dwFlags: dwmapi::DWM_BB_ENABLE | dwmapi::DWM_BB_BLURREGION,
-            fEnable: 1,
-            hRgnBlur: region,
-            fTransitionOnMaximized: 0,
-        };
-
-        dwmapi::DwmEnableBlurBehindWindow(real_window.0, &bb);
-        DeleteObject(region as _);
-
-        if attributes.decorations {
-            // HACK: When opaque (opacity 255), there is a trail whenever
-            // the transparent window is moved. By reducing it to 254,
-            // the window is rendered properly.
-            let opacity = 254;
-
-            // The color key can be any value except for black (0x0).
-            let color_key = 0x0030c100;
-
-            winuser::SetLayeredWindowAttributes(
-                real_window.0,
-                color_key,
-                opacity,
-                winuser::LWA_ALPHA,
-            );
-        }
-    }
-
-    // If the system theme is dark, we need to set the window theme now
-    // before we update the window flags (and possibly show the
-    // window for the first time).
-    let dark_mode = try_dark_mode(real_window.0);
-
-    let window_state = {
-        let window_state = WindowState::new(
-            &attributes,
-            pl_attribs.taskbar_icon,
-            scale_factor,
-            dark_mode,
-        );
-        let window_state = Arc::new(Mutex::new(window_state));
-        WindowState::set_window_flags(window_state.lock(), real_window.0, |f| *f = window_flags);
-        window_state
+    let mut initdata = InitData {
+        event_loop,
+        attributes,
+        pl_attribs: pl_attribs.clone(),
+        window_flags,
+        window: None,
     };
 
-    let win = Window {
-        window: real_window,
-        window_state,
-        thread_executor: event_loop.create_thread_executor(),
-    };
+    let (style, ex_style) = window_flags.to_window_styles();
+    let handle = winuser::CreateWindowExW(
+        ex_style,
+        class_name.as_ptr(),
+        title.as_ptr() as LPCWSTR,
+        style,
+        winuser::CW_USEDEFAULT,
+        winuser::CW_USEDEFAULT,
+        winuser::CW_USEDEFAULT,
+        winuser::CW_USEDEFAULT,
+        parent.unwrap_or(ptr::null_mut()),
+        pl_attribs.menu.unwrap_or(ptr::null_mut()),
+        libloaderapi::GetModuleHandleW(ptr::null()),
+        &mut initdata as *mut _ as *mut _,
+    );
 
-    let dimensions = attributes
-        .inner_size
-        .unwrap_or_else(|| PhysicalSize::new(1024, 768).into());
-    win.set_inner_size(dimensions);
-    if attributes.maximized {
-        // Need to set MAXIMIZED after setting `inner_size` as
-        // `Window::set_inner_size` changes MAXIMIZED to false.
-        win.set_maximized(true);
-    }
-    win.set_visible(attributes.visible);
-
-    if let Some(_) = attributes.fullscreen {
-        win.set_fullscreen(attributes.fullscreen);
-        force_window_active(win.window.0);
+    // If the window creation in `InitData` panicked, then should resume panicking here
+    if let Err(panic_error) = event_loop.runner_shared.take_panic_error() {
+        panic::resume_unwind(panic_error)
     }
 
-    Ok(win)
+    if handle.is_null() {
+        return Err(os_error!(io::Error::last_os_error()));
+    }
+
+    // If the handle is non-null, then window creation must have succeeded, which means
+    // that we *must* have populated the `InitData.window` field.
+    Ok(initdata.window.unwrap())
 }
 
-unsafe fn register_window_class(
+unsafe fn register_window_class<T: 'static>(
     window_icon: &Option<Icon>,
     taskbar_icon: &Option<Icon>,
 ) -> Vec<u16> {
@@ -801,7 +939,7 @@ unsafe fn register_window_class(
     let class = winuser::WNDCLASSEXW {
         cbSize: mem::size_of::<winuser::WNDCLASSEXW>() as UINT,
         style: winuser::CS_HREDRAW | winuser::CS_VREDRAW | winuser::CS_OWNDC,
-        lpfnWndProc: Some(winuser::DefWindowProcW),
+        lpfnWndProc: Some(super::event_loop::public_window_callback::<T>),
         cbClsExtra: 0,
         cbWndExtra: 0,
         hInstance: libloaderapi::GetModuleHandleW(ptr::null()),
@@ -858,7 +996,7 @@ unsafe fn taskbar_mark_fullscreen(handle: HWND, fullscreen: bool) {
     TASKBAR_LIST.with(|task_bar_list_ptr| {
         let mut task_bar_list = task_bar_list_ptr.get();
 
-        if task_bar_list == ptr::null_mut() {
+        if task_bar_list.is_null() {
             use winapi::{shared::winerror::S_OK, Interface};
 
             let hr = combaseapi::CoCreateInstance(

src/platform_impl/windows/window_state.rs

@@ -3,7 +3,7 @@ use crate::{
     event::ModifiersState,
     icon::Icon,
     platform_impl::platform::{event_loop, util},
-    window::{CursorIcon, Fullscreen, WindowAttributes},
+    window::{CursorIcon, Fullscreen, Theme, WindowAttributes},
 };
 use parking_lot::MutexGuard;
 use std::{io, ptr};
@@ -31,21 +31,21 @@ pub struct WindowState {
 
     pub modifiers_state: ModifiersState,
     pub fullscreen: Option<Fullscreen>,
-    pub is_dark_mode: bool,
+    pub current_theme: Theme,
+    pub preferred_theme: Option<Theme>,
     pub high_surrogate: Option<u16>,
-    window_flags: WindowFlags,
+    pub window_flags: WindowFlags,
 }
 
 #[derive(Clone)]
 pub struct SavedWindow {
-    pub client_rect: RECT,
-    pub scale_factor: f64,
+    pub placement: winuser::WINDOWPLACEMENT,
 }
 
 #[derive(Clone)]
 pub struct MouseProperties {
     pub cursor: CursorIcon,
-    pub buttons_down: u32,
+    pub capture_count: u32,
     cursor_flags: CursorFlags,
     pub last_position: Option<PhysicalPosition<f64>>,
 }
@@ -68,10 +68,12 @@ bitflags! {
         const TRANSPARENT    = 1 << 6;
         const CHILD          = 1 << 7;
         const MAXIMIZED      = 1 << 8;
+        const POPUP          = 1 << 14;
 
         /// Marker flag for fullscreen. Should always match `WindowState::fullscreen`, but is
         /// included here to make masking easier.
-        const MARKER_FULLSCREEN = 1 << 9;
+        const MARKER_EXCLUSIVE_FULLSCREEN = 1 << 9;
+        const MARKER_BORDERLESS_FULLSCREEN = 1 << 13;
 
         /// The `WM_SIZE` event contains some parameters that can effect the state of `WindowFlags`.
         /// In most cases, it's okay to let those parameters change the state. However, when we're
@@ -84,12 +86,7 @@ bitflags! {
 
         const MINIMIZED = 1 << 12;
 
-        const FULLSCREEN_AND_MASK = !(
-            WindowFlags::DECORATIONS.bits |
-            WindowFlags::RESIZABLE.bits |
-            WindowFlags::MAXIMIZED.bits
-        );
-        const FULLSCREEN_OR_MASK = WindowFlags::ALWAYS_ON_TOP.bits;
+        const EXCLUSIVE_FULLSCREEN_OR_MASK = WindowFlags::ALWAYS_ON_TOP.bits;
         const NO_DECORATIONS_AND_MASK = !WindowFlags::RESIZABLE.bits;
         const INVISIBLE_AND_MASK = !WindowFlags::MAXIMIZED.bits;
     }
@@ -100,12 +97,13 @@ impl WindowState {
         attributes: &WindowAttributes,
         taskbar_icon: Option<Icon>,
         scale_factor: f64,
-        is_dark_mode: bool,
+        current_theme: Theme,
+        preferred_theme: Option<Theme>,
     ) -> WindowState {
         WindowState {
             mouse: MouseProperties {
                 cursor: CursorIcon::default(),
-                buttons_down: 0,
+                capture_count: 0,
                 cursor_flags: CursorFlags::empty(),
                 last_position: None,
             },
@@ -121,7 +119,8 @@ impl WindowState {
 
             modifiers_state: ModifiersState::default(),
             fullscreen: None,
-            is_dark_mode,
+            current_theme,
+            preferred_theme,
             high_surrogate: None,
             window_flags: WindowFlags::empty(),
         }
@@ -176,9 +175,8 @@ impl MouseProperties {
 
 impl WindowFlags {
     fn mask(mut self) -> WindowFlags {
-        if self.contains(WindowFlags::MARKER_FULLSCREEN) {
-            self &= WindowFlags::FULLSCREEN_AND_MASK;
-            self |= WindowFlags::FULLSCREEN_OR_MASK;
+        if self.contains(WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN) {
+            self |= WindowFlags::EXCLUSIVE_FULLSCREEN_OR_MASK;
         }
         if !self.contains(WindowFlags::VISIBLE) {
             self &= WindowFlags::INVISIBLE_AND_MASK;
@@ -213,12 +211,12 @@ impl WindowFlags {
         if self.contains(WindowFlags::NO_BACK_BUFFER) {
             style_ex |= WS_EX_NOREDIRECTIONBITMAP;
         }
-        if self.contains(WindowFlags::TRANSPARENT) && self.contains(WindowFlags::DECORATIONS) {
-            style_ex |= WS_EX_LAYERED;
-        }
         if self.contains(WindowFlags::CHILD) {
             style |= WS_CHILD; // This is incompatible with WS_POPUP if that gets added eventually.
         }
+        if self.contains(WindowFlags::POPUP) {
+            style |= WS_POPUP;
+        }
         if self.contains(WindowFlags::MINIMIZED) {
             style |= WS_MINIMIZE;
         }
@@ -229,6 +227,12 @@ impl WindowFlags {
         style |= WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_SYSMENU;
         style_ex |= WS_EX_ACCEPTFILES;
 
+        if self.intersects(
+            WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN | WindowFlags::MARKER_BORDERLESS_FULLSCREEN,
+        ) {
+            style &= !WS_OVERLAPPEDWINDOW;
+        }
+
         (style, style_ex)
     }
 
@@ -319,7 +323,9 @@ impl WindowFlags {
                 // We generally don't want style changes here to affect window
                 // focus, but for fullscreen windows they must be activated
                 // (i.e. focused) so that they appear on top of the taskbar
-                if !new.contains(WindowFlags::MARKER_FULLSCREEN) {
+                if !new.contains(WindowFlags::MARKER_EXCLUSIVE_FULLSCREEN)
+                    && !new.contains(WindowFlags::MARKER_BORDERLESS_FULLSCREEN)
+                {
                     flags |= winuser::SWP_NOACTIVATE;
                 }
 

src/window.rs

@@ -69,12 +69,16 @@ impl Drop for Window {
 pub struct WindowId(pub(crate) platform_impl::WindowId);
 
 impl WindowId {
-    /// Returns a dummy `WindowId`, useful for unit testing. The only guarantee made about the return
-    /// value of this function is that it will always be equal to itself and to future values returned
-    /// by this function.  No other guarantees are made. This may be equal to a real `WindowId`.
+    /// Returns a dummy `WindowId`, useful for unit testing.
+    ///
+    /// # Safety
+    ///
+    /// The only guarantee made about the return value of this function is that
+    /// it will always be equal to itself and to future values returned by this function.
+    /// No other guarantees are made. This may be equal to a real `WindowId`.
     ///
     /// **Passing this into a winit function will result in undefined behavior.**
-    pub unsafe fn dummy() -> Self {
+    pub const unsafe fn dummy() -> Self {
         WindowId(platform_impl::WindowId::dummy())
     }
 }
@@ -116,6 +120,31 @@ pub struct WindowAttributes {
     /// The default is `None`.
     pub max_inner_size: Option<Size>,
 
+    /// The desired position of the window. If this is `None`, some platform-specific position
+    /// will be chosen.
+    ///
+    /// The default is `None`.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **macOS**: The top left corner position of the window content, the window's "inner"
+    /// position. The window title bar will be placed above it.
+    /// The window will be positioned such that it fits on screen, maintaining
+    /// set `inner_size` if any.
+    /// If you need to precisely position the top left corner of the whole window you have to
+    /// use [`Window::set_outer_position`] after creating the window.
+    /// - **Windows**: The top left corner position of the window title bar, the window's "outer"
+    /// position.
+    /// There may be a small gap between this position and the window due to the specifics of the
+    /// Window Manager.
+    /// - **X11**: The top left corner of the window, the window's "outer" position.
+    /// - **Others**: Ignored.
+    ///
+    /// See [`Window::set_outer_position`].
+    ///
+    /// [`Window::set_outer_position`]: crate::window::Window::set_outer_position
+    pub position: Option<Position>,
+
     /// Whether the window is resizable or not.
     ///
     /// The default is `true`.
@@ -170,6 +199,7 @@ impl Default for WindowAttributes {
             inner_size: None,
             min_inner_size: None,
             max_inner_size: None,
+            position: None,
             resizable: true,
             title: "winit window".to_owned(),
             maximized: false,
@@ -223,6 +253,17 @@ impl WindowBuilder {
         self
     }
 
+    /// Sets a desired initial position for the window.
+    ///
+    /// See [`WindowAttributes::position`] for details.
+    ///
+    /// [`WindowAttributes::position`]: crate::window::WindowAttributes::position
+    #[inline]
+    pub fn with_position<P: Into<Position>>(mut self, position: P) -> Self {
+        self.window.position = Some(position.into());
+        self
+    }
+
     /// Sets whether the window is resizable or not.
     ///
     /// See [`Window::set_resizable`] for details.
@@ -401,7 +442,7 @@ impl Window {
     /// ## Platform-specific
     ///
     /// - **iOS:** Can only be called on the main thread.
-    /// - **Android:** Unsupported.
+    /// - **Android:** Subsequent calls after `MainEventsCleared` are not handled.
     #[inline]
     pub fn request_redraw(&self) {
         self.window.request_redraw()
@@ -526,7 +567,7 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Andraid / Web:** Unsupported.
+    /// - **iOS / Android / Web:** Unsupported.
     #[inline]
     pub fn set_max_inner_size<S: Into<Size>>(&self, max_size: Option<S>) {
         self.window.set_max_inner_size(max_size.map(|s| s.into()))
@@ -597,6 +638,17 @@ impl Window {
         self.window.set_maximized(maximized)
     }
 
+    /// Gets the window's current maximized state.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Wayland / X11:** Not implemented.
+    /// - **iOS / Android / Web:** Unsupported.
+    #[inline]
+    pub fn is_maximized(&self) -> bool {
+        self.window.is_maximized()
+    }
+
     /// Sets the window to fullscreen or back.
     ///
     /// ## Platform-specific
@@ -677,11 +729,44 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// - **iOS / Android / Web / Windows:** Unsupported.
+    /// - **iOS / Android / Web:** Unsupported.
     #[inline]
     pub fn set_ime_position<P: Into<Position>>(&self, position: P) {
         self.window.set_ime_position(position.into())
     }
+
+    /// Brings the window to the front and sets input focus. Has no effect if the window is
+    /// already in focus, minimized, or not visible.
+    ///
+    /// This method steals input focus from other applications. Do not use this method unless
+    /// you are certain that's what the user wants. Focus stealing can cause an extremely disruptive
+    /// user experience.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Web / Wayland:** Unsupported.
+    #[inline]
+    pub fn focus_window(&self) {
+        self.window.focus_window()
+    }
+
+    /// Requests user attention to the window, this has no effect if the application
+    /// is already focused. How requesting for user attention manifests is platform dependent,
+    /// see `UserAttentionType` for details.
+    ///
+    /// Providing `None` will unset the request for user attention. Unsetting the request for
+    /// user attention might not be done automatically by the WM when the window receives input.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **iOS / Android / Web :** Unsupported.
+    /// - **macOS:** `None` has no effect.
+    /// - **X11:** Requests for user attention must be manually cleared.
+    /// - **Wayland:** Requires `xdg_activation_v1` protocol, `None` has no effect.
+    #[inline]
+    pub fn request_user_attention(&self, request_type: Option<UserAttentionType>) {
+        self.window.request_user_attention(request_type)
+    }
 }
 
 /// Cursor functions.
@@ -736,6 +821,22 @@ impl Window {
     pub fn set_cursor_visible(&self, visible: bool) {
         self.window.set_cursor_visible(visible)
     }
+
+    /// Moves the window with the left mouse button until the button is released.
+    ///
+    /// There's no guarantee that this will work unless the left mouse button was pressed
+    /// immediately before this function is called.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **X11:** Un-grabs the cursor.
+    /// - **Wayland:** Requires the cursor to be inside the window to be dragged.
+    /// - **macOS:** May prevent the button release event to be triggered.
+    /// - **iOS / Android / Web:** Always returns an [`ExternalError::NotSupported`].
+    #[inline]
+    pub fn drag_window(&self) -> Result<(), ExternalError> {
+        self.window.drag_window()
+    }
 }
 
 /// Monitor info functions.
@@ -784,6 +885,12 @@ impl Window {
 }
 
 unsafe impl raw_window_handle::HasRawWindowHandle for Window {
+    /// Returns a `raw_window_handle::RawWindowHandle` for the Window
+    ///
+    /// ## Platform-specific
+    ///
+    /// - **Android:** Only available after receiving the Resumed event and before Suspended. *If you*
+    /// *try to get the handle outside of that period, this function will panic*!
     fn raw_window_handle(&self) -> raw_window_handle::RawWindowHandle {
         self.window.raw_window_handle()
     }
@@ -863,8 +970,29 @@ pub enum Fullscreen {
     Borderless(Option<MonitorHandle>),
 }
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq)]
 pub enum Theme {
     Light,
     Dark,
 }
+
+/// ## Platform-specific
+///
+/// - **X11:** Sets the WM's `XUrgencyHint`. No distinction between `Critical` and `Informational`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum UserAttentionType {
+    /// ## Platform-specific
+    /// - **macOS:** Bounces the dock icon until the application is in focus.
+    /// - **Windows:** Flashes both the window and the taskbar button until the application is in focus.
+    Critical,
+    /// ## Platform-specific
+    /// - **macOS:** Bounces the dock icon once.
+    /// - **Windows:** Flashes the taskbar button until the application is in focus.
+    Informational,
+}
+
+impl Default for UserAttentionType {
+    fn default() -> Self {
+        UserAttentionType::Informational
+    }
+}