chore: bump the github-actions group across 1 directory with 3 updates

Bumps the github-actions group with 3 updates in the / directory: [actions/cache](https://github.com/actions/cache), [actions/checkout](https://github.com/actions/checkout) and [actions/upload-pages-artifact](https://github.com/actions/upload-pages-artifact).


Updates `actions/cache` from 5 to 6
- [Release notes](https://github.com/actions/cache/releases)
- [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md)
- [Commits](https://github.com/actions/cache/compare/v5...v6)

Updates `actions/checkout` from 6 to 7
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/v6...v7)

Updates `actions/upload-pages-artifact` from 4 to 5
- [Release notes](https://github.com/actions/upload-pages-artifact/releases)
- [Commits](https://github.com/actions/upload-pages-artifact/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/cache
  dependency-version: '6'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
- dependency-name: actions/checkout
  dependency-version: '7'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
- dependency-name: actions/upload-pages-artifact
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/ci.yml

@@ -124,7 +124,7 @@ jobs:
       # the cache has been downloaded.
       #
       # This could be avoided if we added Cargo.lock to the repository.
-      uses: actions/cache/restore@v5
+      uses: actions/cache/restore@v6
       with:
         # https://doc.rust-lang.org/cargo/guide/cargo-home.html#caching-the-cargo-home-in-ci
         path: |
@@ -136,7 +136,7 @@ jobs:
 
     - name: Generate lockfile
       # Also updates the crates.io index
-      run: cargo generate-lockfile && cargo update -p smol_str --precise 0.3.2
+      run: cargo generate-lockfile && cargo update -p smol_str --precise 0.3.2 && cargo update -p unicode-segmentation --precise 1.12.0 && cargo update -p wayland-protocols --precise 0.32.12
 
     - name: Install GCC Multilib
       if: (matrix.platform.os == 'ubuntu-latest') && contains(matrix.platform.target, 'i686')
@@ -145,7 +145,7 @@ jobs:
     - name: Cache cargo-apk
       if: contains(matrix.platform.target, 'android')
       id: cargo-apk-cache
-      uses: actions/cache@v5
+      uses: actions/cache@v6
       with:
         path: ~/.cargo/bin/cargo-apk
         # Change this key if we update the required cargo-apk version
@@ -281,7 +281,7 @@ jobs:
 
     # See restore step above
     - name: Save cache of cargo folder
-      uses: actions/cache/save@v5
+      uses: actions/cache/save@v6
       with:
         path: |
           ~/.cargo/registry/index/
@@ -290,31 +290,14 @@ jobs:
         key: cargo-${{ matrix.toolchain }}-${{ matrix.platform.name }}-${{ hashFiles('Cargo.lock') }}
 
   cargo-deny:
-    name: Run cargo-deny on ${{ matrix.platform.name }}
+    name: Run cargo-deny
     runs-on: ubuntu-latest
 
-    # TODO: remove this matrix when https://github.com/EmbarkStudios/cargo-deny/issues/324 is resolved
-    strategy:
-      fail-fast: false
-      matrix:
-        platform:
-          - { name: 'Android', target: aarch64-linux-android }
-          - { name: 'iOS', target: aarch64-apple-ios }
-          - { name: 'Linux', target: x86_64-unknown-linux-gnu }
-          - { name: 'macOS', target: aarch64-apple-darwin }
-          - { name: 'Redox OS', target: x86_64-unknown-redox }
-          - { name: 'Web', target: wasm32-unknown-unknown }
-          - { name: 'Windows GNU', target: x86_64-pc-windows-gnu }
-          - { name: 'Windows MSVC', target: x86_64-pc-windows-msvc }
-
     steps:
     - uses: taiki-e/checkout-action@v1
     - uses: EmbarkStudios/cargo-deny-action@v2
       with:
-        command: check
         log-level: error
-        manifest-path: winit/Cargo.toml
-        arguments: --all-features --target ${{ matrix.platform.target }}
 
   eslint:
     name: ESLint

.github/workflows/docs.yml

@@ -19,7 +19,7 @@ jobs:
       id-token: write
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - uses: dtolnay/rust-toolchain@master
         with:
@@ -32,7 +32,7 @@ jobs:
           cargo doc --no-deps -Z rustdoc-map -Z rustdoc-scrape-examples --features=serde,mint,android-native-activity
 
       - name: Setup Pages
-        uses: actions/configure-pages@v5
+        uses: actions/configure-pages@v6
 
       - name: Fix permissions
         run: |
@@ -41,10 +41,10 @@ jobs:
           done
 
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v4
+        uses: actions/upload-pages-artifact@v5
         with:
           path: target/doc
 
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v5

deny.toml

@@ -1,27 +1,25 @@
 # https://embarkstudios.github.io/cargo-deny
 # cargo install cargo-deny
-# cargo update && cargo deny --target aarch64-apple-ios check
-# Note: running just `cargo deny check` without a `--target` will result in
-# false positives due to https://github.com/EmbarkStudios/cargo-deny/issues/324
+# cargo update && cargo deny check
 [graph]
 all-features = true
 exclude-dev = true
 targets = [
-    { triple = "aarch64-apple-darwin" },
-    { triple = "aarch64-apple-ios" },
-    { triple = "aarch64-linux-android" },
-    { triple = "i686-pc-windows-gnu" },
-    { triple = "i686-pc-windows-msvc" },
-    { triple = "i686-unknown-linux-gnu" },
+    "aarch64-apple-darwin",
+    "aarch64-apple-ios",
+    "aarch64-linux-android",
+    "i686-pc-windows-gnu",
+    "i686-pc-windows-msvc",
+    "i686-unknown-linux-gnu",
     { triple = "wasm32-unknown-unknown", features = [
         "atomics",
     ] },
-    { triple = "x86_64-apple-darwin" },
-    { triple = "x86_64-apple-ios" },
-    { triple = "x86_64-pc-windows-gnu" },
-    { triple = "x86_64-pc-windows-msvc" },
-    { triple = "x86_64-unknown-linux-gnu" },
-    { triple = "x86_64-unknown-redox" },
+    "x86_64-apple-darwin",
+    "x86_64-apple-ios",
+    "x86_64-pc-windows-gnu",
+    "x86_64-pc-windows-msvc",
+    "x86_64-unknown-linux-gnu",
+    "x86_64-unknown-redox",
 ]
 
 [licenses]
@@ -33,6 +31,7 @@ allow = [
     "MIT",          # https://tldrlegal.com/license/mit-license
     "Unicode-3.0",  # https://spdx.org/licenses/Unicode-3.0.html
     "Zlib",         # https://spdx.org/licenses/Zlib.html
+    "MPL-2.0",      # https://www.mozilla.org/en-US/MPL/2.0/
 ]
 confidence-threshold = 1.0
 private = { ignore = true }
@@ -40,46 +39,23 @@ private = { ignore = true }
 [bans]
 multiple-versions = "deny"
 skip = [
-    { crate = "bitflags@1", reason = "the ecosystem is in the process of migrating" },
-    { crate = "rustix@0.38", reason = "the ecosystem is in the process of migrating" },
-    { crate = "linux-raw-sys@0.4", reason = "the ecosystem is in the process of migrating" },
+    { crate = "jni-sys@0.3", reason = "uses the semver trick to depend on v0.4, but `ndk` hasn't been updated to v0.4 yet" },
+    { crate = "thiserror@1.0", reason = "dep of `ndk` crate, yet to be updated" },
+    { crate = "thiserror-impl@1.0", reason = "dep of `thiserror`" },
+    { crate = "objc2@0.5", reason = "used by crossfont" },
+    { crate = "objc2-foundation@0.2", reason = "used by crossfont" },
+]
+skip-tree = [
+    { crate = "windows-sys", reason = "foundational but bumps fairly often, nothing we can do about it not having a shared version" },
 ]
-wildcards = "allow" # at least until https://github.com/EmbarkStudios/cargo-deny/issues/241 is fixed
 
 [bans.build]
+bypass = [
+    { crate = "android-activity", allow-globs = ["android-games-sdk/import-games-sdk.sh"] },
+    { crate = "freetype-sys", allow-globs = ["freetype2/*"] },
+    # `crossfont` still depends (partially transitively) on `winapi`.
+    { crate = "winapi-i686-pc-windows-gnu", allow-globs = ["lib/lib*.a"] },
+    { crate = "winapi-x86_64-pc-windows-gnu", allow-globs = ["lib/lib*.a"] },
+]
 include-archives = true
 interpreted = "deny"
-
-[[bans.build.bypass]]
-allow = [
-    { path = "generate-bindings.sh", checksum = "268ec23248218d779e33853cdc60e2985e70214ff004716cd734270de1f6b561" },
-]
-crate = "android-activity"
-
-[[bans.build.bypass]]
-allow-globs = ["ci/*", "githooks/*"]
-crate = "zerocopy"
-
-[[bans.build.bypass]]
-allow-globs = ["cherry-pick-stable.sh"]
-crate = "libc"
-
-[[bans.build.bypass]]
-allow-globs = ["freetype2/*"]
-crate = "freetype-sys"
-
-[[bans.build.bypass]]
-allow-globs = ["lib/*.a"]
-crate = "windows_i686_gnu"
-
-[[bans.build.bypass]]
-allow-globs = ["lib/*.lib"]
-crate = "windows_i686_msvc"
-
-[[bans.build.bypass]]
-allow-globs = ["lib/*.a"]
-crate = "windows_x86_64_gnu"
-
-[[bans.build.bypass]]
-allow-globs = ["lib/*.lib"]
-crate = "windows_x86_64_msvc"

winit-android/src/keycodes.rs

@@ -109,6 +109,7 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         Keycode::MediaStop => KeyCode::MediaStop,
         Keycode::MediaNext => KeyCode::MediaTrackNext,
         Keycode::MediaPrevious => KeyCode::MediaTrackPrevious,
+        Keycode::MediaEject => KeyCode::Eject,
 
         Keycode::Plus => KeyCode::Equal,
         Keycode::Minus => KeyCode::Minus,
@@ -131,7 +132,11 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         // These are exactly the same
         Keycode::ScrollLock => KeyCode::ScrollLock,
 
+        Keycode::Eisu => KeyCode::Lang2,
+        Keycode::Muhenkan => KeyCode::NonConvert,
+        Keycode::Henkan => KeyCode::Convert,
         Keycode::Yen => KeyCode::IntlYen,
+        Keycode::Ro => KeyCode::IntlRo,
         Keycode::Kana => KeyCode::Lang1,
         Keycode::KatakanaHiragana => KeyCode::KanaMode,
 
@@ -154,6 +159,14 @@ pub fn to_physical_key(keycode: Keycode) -> PhysicalKey {
         Keycode::Sleep => KeyCode::Sleep, // what about SoftSleep?
         Keycode::Wakeup => KeyCode::WakeUp,
 
+        Keycode::CapsLock => KeyCode::CapsLock,
+        Keycode::Help => KeyCode::Help,
+
+        Keycode::Back => KeyCode::BrowserBack,
+        Keycode::Forward => KeyCode::BrowserForward,
+        Keycode::Refresh => KeyCode::BrowserRefresh,
+        Keycode::Search => KeyCode::BrowserSearch,
+
         keycode => return PhysicalKey::Unidentified(NativeKeyCode::Android(keycode.into())),
     })
 }

winit-appkit/Cargo.toml

@@ -107,7 +107,7 @@ objc2-foundation = { workspace = true, features = [
     "NSThread",
     "NSValue",
 ] }
-winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }
+winit-common = { workspace = true, features = ["core-foundation", "event-handler", "foundation"] }
 
 [dev-dependencies]
 winit.workspace = true

winit-appkit/src/app.rs

@@ -1,8 +1,8 @@
 #![allow(clippy::unnecessary_cast)]
 
 use std::cell::Cell;
-use std::mem;
 use std::rc::Rc;
+use std::{mem, ptr};
 
 use dispatch2::MainThreadBound;
 use objc2::runtime::{Imp, Sel};
@@ -80,9 +80,7 @@ pub(crate) fn override_send_event(global_app: &NSApplication) {
     let overridden = unsafe { mem::transmute::<SendEvent, Imp>(send_event) };
 
     // If we've already overridden the method, don't do anything.
-    // FIXME(madsmtm): Use `std::ptr::fn_addr_eq` (Rust 1.85) once available in MSRV.
-    #[allow(unknown_lints, unpredictable_function_pointer_comparisons)]
-    if overridden == method.implementation() {
+    if ptr::fn_addr_eq(overridden, method.implementation()) {
         return;
     }
 

winit-appkit/src/app_state.rs

@@ -6,7 +6,8 @@ use std::time::Instant;
 
 use dispatch2::MainThreadBound;
 use objc2::MainThreadMarker;
-use objc2_app_kit::NSApplication;
+use objc2_app_kit::{NSApplication, NSApplicationActivationPolicy, NSRunningApplication};
+use objc2_foundation::NSNotification;
 use winit_common::core_foundation::{EventLoopProxy, MainRunLoop};
 use winit_common::event_handler::EventHandler;
 use winit_core::application::ApplicationHandler;
@@ -15,17 +16,24 @@ use winit_core::event_loop::ControlFlow;
 use winit_core::window::WindowId;
 
 use super::event_loop::{ActiveEventLoop, notify_windows_of_exit, stop_app_immediately};
+use super::menu;
 use super::observer::EventLoopWaker;
 
 #[derive(Debug)]
 pub(super) struct AppState {
     mtm: MainThreadMarker,
+    activation_policy: Option<NSApplicationActivationPolicy>,
+    default_menu: bool,
+    activate_ignoring_other_apps: bool,
     run_loop: MainRunLoop,
     event_loop_proxy: Arc<EventLoopProxy>,
     event_handler: EventHandler,
+    stop_on_launch: Cell<bool>,
     stop_before_wait: Cell<bool>,
     stop_after_wait: Cell<bool>,
     stop_on_redraw: Cell<bool>,
+    /// Whether `applicationDidFinishLaunching:` has been run or not.
+    is_launched: Cell<bool>,
     /// Whether an `EventLoop` is currently running.
     is_running: Cell<bool>,
     /// Whether the user has requested the event loop to exit.
@@ -45,19 +53,29 @@ static GLOBAL: MainThreadBound<OnceCell<Rc<AppState>>> =
     MainThreadBound::new(OnceCell::new(), unsafe { MainThreadMarker::new_unchecked() });
 
 impl AppState {
-    pub(super) fn setup_global(mtm: MainThreadMarker) -> Option<Rc<Self>> {
+    pub(super) fn setup_global(
+        mtm: MainThreadMarker,
+        activation_policy: Option<NSApplicationActivationPolicy>,
+        default_menu: bool,
+        activate_ignoring_other_apps: bool,
+    ) -> Option<Rc<Self>> {
         let event_loop_proxy = Arc::new(EventLoopProxy::new(mtm, move || {
             Self::get(mtm).with_handler(|app, event_loop| app.proxy_wake_up(event_loop));
         }));
 
         let this = Rc::new(Self {
             mtm,
+            activation_policy,
+            default_menu,
+            activate_ignoring_other_apps,
             run_loop: MainRunLoop::get(mtm),
             event_loop_proxy,
             event_handler: EventHandler::new(),
+            stop_on_launch: Cell::new(false),
             stop_before_wait: Cell::new(false),
             stop_after_wait: Cell::new(false),
             stop_on_redraw: Cell::new(false),
+            is_launched: Cell::new(false),
             is_running: Cell::new(false),
             exit: Cell::new(false),
             control_flow: Cell::new(ControlFlow::default()),
@@ -78,6 +96,69 @@ impl AppState {
             .clone()
     }
 
+    // NOTE: This notification will, globally, only be emitted once,
+    // no matter how many `EventLoop`s the user creates.
+    pub fn did_finish_launching(self: &Rc<Self>, _notification: &NSNotification) {
+        self.is_launched.set(true);
+
+        let app = NSApplication::sharedApplication(self.mtm);
+        // We need to delay setting the activation policy and activating the app
+        // until `applicationDidFinishLaunching` has been called. Otherwise the
+        // menu bar is initially unresponsive on macOS 10.15.
+        if let Some(activation_policy) = self.activation_policy {
+            app.setActivationPolicy(activation_policy);
+        } else {
+            // If no activation policy is explicitly provided, and the application
+            // is bundled, do not set the activation policy at all, to allow the
+            // package manifest to define the behavior via LSUIElement.
+            //
+            // See:
+            // - https://github.com/rust-windowing/winit/issues/261
+            // - https://github.com/rust-windowing/winit/issues/3958
+            let is_bundled =
+                NSRunningApplication::currentApplication().bundleIdentifier().is_some();
+            if !is_bundled {
+                app.setActivationPolicy(NSApplicationActivationPolicy::Regular);
+            }
+        }
+
+        #[allow(deprecated)]
+        app.activateIgnoringOtherApps(self.activate_ignoring_other_apps);
+
+        if self.default_menu {
+            // The menubar initialization should be before the `NewEvents` event, to allow
+            // overriding of the default menu even if it's created
+            menu::initialize(&app);
+        }
+
+        self.waker.borrow_mut().start();
+
+        self.set_is_running(true);
+        self.dispatch_init_events();
+
+        // If the application is being launched via `EventLoop::pump_app_events()` then we'll
+        // want to stop the app once it is launched (and return to the external loop)
+        //
+        // In this case we still want to consider Winit's `EventLoop` to be "running",
+        // so we call `start_running()` above.
+        if self.stop_on_launch.get() {
+            // NOTE: the original idea had been to only stop the underlying `RunLoop`
+            // for the app but that didn't work as expected (`-[NSApplication run]`
+            // effectively ignored the attempt to stop the RunLoop and re-started it).
+            //
+            // So we return from `pump_events` by stopping the application.
+            let app = NSApplication::sharedApplication(self.mtm);
+            stop_app_immediately(&app);
+        }
+    }
+
+    pub fn will_terminate(self: &Rc<Self>, _notification: &NSNotification) {
+        let app = NSApplication::sharedApplication(self.mtm);
+        notify_windows_of_exit(&app);
+        self.event_handler.terminate();
+        self.internal_exit();
+    }
+
     /// Place the event handler in the application state for the duration
     /// of the given closure.
     pub fn set_event_handler<R>(
@@ -88,14 +169,17 @@ impl AppState {
         self.event_handler.set(Box::new(handler), closure)
     }
 
-    pub fn terminate_event_handler(&self) {
-        self.event_handler.terminate();
-    }
-
     pub fn event_loop_proxy(&self) -> &Arc<EventLoopProxy> {
         &self.event_loop_proxy
     }
 
+    /// If `pump_events` is called to progress the event loop then we
+    /// bootstrap the event loop via `-[NSApplication run]` but will use
+    /// `CFRunLoopRunInMode` for subsequent calls to `pump_events`.
+    pub fn set_stop_on_launch(&self) {
+        self.stop_on_launch.set(true);
+    }
+
     pub fn set_stop_before_wait(&self, value: bool) {
         self.stop_before_wait.set(value)
     }
@@ -124,6 +208,10 @@ impl AppState {
         self.set_wait_timeout(None);
     }
 
+    pub fn is_launched(&self) -> bool {
+        self.is_launched.get()
+    }
+
     pub fn set_is_running(&self, value: bool) {
         self.is_running.set(value)
     }

winit-appkit/src/event_loop.rs

@@ -7,13 +7,14 @@ use objc2::runtime::ProtocolObject;
 use objc2::{MainThreadMarker, available};
 use objc2_app_kit::{
     NSApplication, NSApplicationActivationPolicy, NSApplicationDidFinishLaunchingNotification,
-    NSApplicationWillTerminateNotification, NSRunningApplication, NSWindow,
+    NSApplicationWillTerminateNotification, NSWindow,
 };
 use objc2_core_foundation::{CFIndex, CFRunLoopActivity, kCFRunLoopCommonModes};
 use objc2_foundation::{NSNotificationCenter, NSObjectProtocol};
 use rwh_06::HasDisplayHandle;
 use tracing::debug_span;
 use winit_common::core_foundation::{MainRunLoop, MainRunLoopObserver, tracing_observers};
+use winit_common::foundation::create_observer;
 use winit_core::application::ApplicationHandler;
 use winit_core::cursor::{CustomCursor as CoreCustomCursor, CustomCursorSource};
 use winit_core::error::{EventLoopError, RequestError};
@@ -30,9 +31,8 @@ use super::app_state::AppState;
 use super::cursor::CustomCursor;
 use super::event::dummy_event;
 use super::monitor;
-use super::notification_center::create_observer;
+use crate::ActivationPolicy;
 use crate::window::Window;
-use crate::{ActivationPolicy, menu};
 
 #[derive(Debug)]
 pub struct ActiveEventLoop {
@@ -150,6 +150,7 @@ pub struct EventLoop {
     // the system instead cleans it up next time it would have posted a notification to it.
     //
     // Though we do still need to keep the observers around to prevent them from being deallocated.
+    _did_finish_launching_observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,
     _will_terminate_observer: Retained<ProtocolObject<dyn NSObjectProtocol>>,
 
     _tracing_observers: Option<(MainRunLoopObserver, MainRunLoopObserver)>,
@@ -175,8 +176,20 @@ impl EventLoop {
         let mtm = MainThreadMarker::new()
             .expect("on macOS, `EventLoop` must be created on the main thread!");
 
-        let app_state =
-            AppState::setup_global(mtm).ok_or_else(|| EventLoopError::RecreationAttempt)?;
+        let activation_policy = match attributes.activation_policy {
+            None => None,
+            Some(ActivationPolicy::Regular) => Some(NSApplicationActivationPolicy::Regular),
+            Some(ActivationPolicy::Accessory) => Some(NSApplicationActivationPolicy::Accessory),
+            Some(ActivationPolicy::Prohibited) => Some(NSApplicationActivationPolicy::Prohibited),
+        };
+
+        let app_state = AppState::setup_global(
+            mtm,
+            activation_policy,
+            attributes.default_menu,
+            attributes.activate_ignoring_other_apps,
+        )
+        .ok_or_else(|| EventLoopError::RecreationAttempt)?;
 
         // Initialize the application (if it has not already been).
         let app = NSApplication::sharedApplication(mtm);
@@ -186,33 +199,32 @@ impl EventLoop {
 
         let center = NSNotificationCenter::defaultCenter();
 
-        // Handle `terminate:`. This may happen if:
-        // - The user uses the context menu in the Dock icon.
-        // - Or the `Quit` menu item we install with the default menu (including via. the keyboard
-        //   shortcut).
-        // - Maybe other cases?
-        //
-        // In these cases, AppKit is going to call `std::process::exit`, so we won't get the chance
-        // to return to the user from `EventLoop::run_app`. So we have to clean up and drop their
-        // windows and application here too.
         let weak_app_state = Rc::downgrade(&app_state);
-        let _will_terminate_observer = create_observer(
+        let _did_finish_launching_observer = create_observer(
             &center,
-            unsafe { NSApplicationWillTerminateNotification },
+            // `applicationDidFinishLaunching:`
+            unsafe { NSApplicationDidFinishLaunchingNotification },
             move |notification| {
-                let _entered = debug_span!("applicationWillTerminate").entered();
-
-                let app = notification.object().unwrap().downcast::<NSApplication>().unwrap();
-                notify_windows_of_exit(&app);
-
+                let _entered = debug_span!("NSApplicationDidFinishLaunchingNotification").entered();
                 if let Some(app_state) = weak_app_state.upgrade() {
-                    app_state.terminate_event_handler();
-                    app_state.internal_exit();
+                    app_state.did_finish_launching(notification);
+                }
+            },
+        );
+
+        let weak_app_state = Rc::downgrade(&app_state);
+        let _will_terminate_observer = create_observer(
+            &center,
+            // `applicationWillTerminate:`
+            unsafe { NSApplicationWillTerminateNotification },
+            move |notification| {
+                let _entered = debug_span!("NSApplicationWillTerminateNotification").entered();
+                if let Some(app_state) = weak_app_state.upgrade() {
+                    app_state.will_terminate(notification);
                 }
             },
         );
 
-        // Set up run loop observers for calling `new_events` and `about_to_wait`.
         let main_loop = MainRunLoop::get(mtm);
         let mode = unsafe { kCFRunLoopCommonModes }.unwrap();
 
@@ -246,100 +258,11 @@ impl EventLoop {
         );
         main_loop.add_observer(&_after_waiting_observer, mode);
 
-        // Run `finishLaunching` just in case it works.
-        app.finishLaunching();
-        // Now _ideally_, calling `finishLaunching` should be enough for the application to, you
-        // know, launch (create the a dock icon etc.), but unfortunately, this doesn't happen for
-        // various godforsaken reasons... The only way to make the application properly launch is by
-        // calling `NSApplication::run`.
-        //
-        // So we check if the application hasn't finished launching, and if it hasn't, we run it
-        // once to finish it.
-        //
-        // This is _very_ important, there's a _lot_ of weird and subtle state that requires that
-        // the application is launched properly, including window creation, the menu bar,
-        // activation, see:
-        // - https://github.com/rust-windowing/winit/pull/1903
-        // - https://github.com/rust-windowing/winit/pull/1922
-        // - https://github.com/rust-windowing/winit/issues/2238
-        // - https://github.com/rust-windowing/winit/issues/2051
-        // - https://github.com/rust-windowing/winit/issues/2087
-        // - https://developer.apple.com/forums/thread/772169
-        //
-        // This approach is similar to what other cross-platform windowing libraries do (except that
-        // we do it without a delegate to allow users to override that):
-        // - GLFW delegate: https://github.com/glfw/glfw/blob/3.4/src/cocoa_init.m#L439-L443
-        // - GLFW launch: https://github.com/glfw/glfw/blob/3.4/src/cocoa_init.m#L634-L635
-        // - FLTK delegate: https://github.com/fltk/fltk/blob/release-1.4.4/src/Fl_cocoa.mm#L1604-L1607
-        // - FLTK launch: https://github.com/fltk/fltk/blob/release-1.4.4/src/Fl_cocoa.mm#L1903-L1919
-        // - Stackoverflow issue: https://stackoverflow.com/questions/48020222/how-to-make-nsapp-run-not-block/67626393#67626393
-        if !NSRunningApplication::currentApplication().isFinishedLaunching() {
-            // Register an observer to stop the application immediately after launching.
-            //
-            // NOTE: This notification will, globally, only be emitted once, no matter how many
-            // `EventLoop`s the user creates. We detect it with `isFinishedLaunching` above.
-            let did_finish_launching_observer = create_observer(
-                &center,
-                unsafe { NSApplicationDidFinishLaunchingNotification },
-                move |notification| {
-                    let _entered = debug_span!("applicationDidFinishLaunching").entered();
-
-                    let app = notification.object().unwrap().downcast::<NSApplication>().unwrap();
-
-                    // Stop the application, to make the `app.run()` call below return.
-                    stop_app_immediately(&app);
-                },
-            );
-
-            // We call `stop_app_immediately` above, so this should return after launching.
-            app.run();
-
-            // The observer should've been called at this point.
-            drop(did_finish_launching_observer);
-
-            // We _could_ keep trying if we failed to initialize, but that would potentially lead
-            // to an infinite loop, it's probably better to just continue.
-            debug_assert!(NSRunningApplication::currentApplication().isFinishedLaunching());
-        }
-
-        // We need to delay setting the activation policy and activating the app until
-        // `applicationDidFinishLaunching:` has been called, otherwise the menu bar is initially
-        // unresponsive on macOS 10.15.
-        if let Some(activation_policy) = attributes.activation_policy {
-            app.setActivationPolicy(match activation_policy {
-                ActivationPolicy::Regular => NSApplicationActivationPolicy::Regular,
-                ActivationPolicy::Accessory => NSApplicationActivationPolicy::Accessory,
-                ActivationPolicy::Prohibited => NSApplicationActivationPolicy::Prohibited,
-            });
-        } else {
-            // If no activation policy is explicitly provided, and the application
-            // is bundled, do not set the activation policy at all, to allow the
-            // package manifest to define the behavior via LSUIElement.
-            //
-            // See:
-            // - https://github.com/rust-windowing/winit/issues/261
-            // - https://github.com/rust-windowing/winit/issues/3958
-            let is_bundled =
-                NSRunningApplication::currentApplication().bundleIdentifier().is_some();
-            if !is_bundled {
-                app.setActivationPolicy(NSApplicationActivationPolicy::Regular);
-            }
-        }
-
-        // TODO: Use `app.activate()` instead on newer OS versions?
-        #[expect(deprecated)]
-        app.activateIgnoringOtherApps(attributes.activate_ignoring_other_apps);
-
-        if attributes.default_menu {
-            // The default menubar initialization should be before everything else, to allow
-            // overriding it even if it's created.
-            menu::initialize(&app);
-        }
-
         Ok(EventLoop {
             app,
             app_state: app_state.clone(),
             window_target: ActiveEventLoop { app_state, mtm },
+            _did_finish_launching_observer,
             _will_terminate_observer,
             _tracing_observers,
             _before_waiting_observer,
@@ -359,7 +282,6 @@ impl EventLoop {
         &mut self,
         app: A,
     ) -> Result<(), EventLoopError> {
-        let _entered = debug_span!("run_app_on_demand").entered();
         self.app_state.clear_exit();
         self.app_state.set_event_handler(app, || {
             autoreleasepool(|_| {
@@ -369,9 +291,11 @@ impl EventLoop {
                 self.app_state.set_stop_after_wait(false);
                 self.app_state.set_stop_on_redraw(false);
 
-                debug_assert!(!self.app_state.is_running());
-                self.app_state.set_is_running(true);
-                self.app_state.dispatch_init_events();
+                if self.app_state.is_launched() {
+                    debug_assert!(!self.app_state.is_running());
+                    self.app_state.set_is_running(true);
+                    self.app_state.dispatch_init_events();
+                }
 
                 // NOTE: Make sure to not run the application re-entrantly, as that'd be confusing.
                 self.app.run();
@@ -388,10 +312,19 @@ impl EventLoop {
         timeout: Option<Duration>,
         app: A,
     ) -> PumpStatus {
-        let _entered = debug_span!("pump_app_events").entered();
         self.app_state.set_event_handler(app, || {
             autoreleasepool(|_| {
-                if !self.app_state.is_running() {
+                // As a special case, if the application hasn't been launched yet then we at least
+                // run the loop until it has fully launched.
+                if !self.app_state.is_launched() {
+                    debug_assert!(!self.app_state.is_running());
+
+                    self.app_state.set_stop_on_launch();
+                    self.app.run();
+
+                    // Note: we dispatch `NewEvents(Init)` + `Resumed` events after the application
+                    // has launched
+                } else if !self.app_state.is_running() {
                     // Even though the application may have been launched, it's possible we aren't
                     // running if the `EventLoop` was run before and has since
                     // exited. This indicates that we just starting to re-run

winit-appkit/src/lib.rs

@@ -50,13 +50,15 @@
 //! }
 //!
 //! fn main() -> Result<(), Box<dyn std::error::Error>> {
-//!     // Register the delegate before Winit gets a chance to touch things.
+//!     let event_loop = EventLoop::new()?;
+//!
 //!     let mtm = MainThreadMarker::new().unwrap();
 //!     let delegate = AppDelegate::new(mtm);
+//!     // Important: Call `sharedApplication` after `EventLoop::new`,
+//!     // doing it before is not yet supported.
 //!     let app = NSApplication::sharedApplication(mtm);
 //!     app.setDelegate(Some(ProtocolObject::from_ref(&*delegate)));
 //!
-//!     let event_loop = EventLoop::new()?;
 //!     // event_loop.run_app(&mut my_app);
 //!     Ok(())
 //! }
@@ -74,7 +76,6 @@ mod event_loop;
 mod ffi;
 mod menu;
 mod monitor;
-mod notification_center;
 mod observer;
 mod view;
 mod window;

winit-appkit/src/view.rs

@@ -3,13 +3,13 @@ use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, VecDeque};
 use std::rc::Rc;
 
-use dpi::{LogicalPosition, LogicalSize};
+use dpi::{LogicalPosition, PhysicalSize};
 use objc2::rc::Retained;
 use objc2::runtime::{AnyObject, Sel};
 use objc2::{AnyThread, DefinedClass, MainThreadMarker, define_class, msg_send};
 use objc2_app_kit::{
     NSApplication, NSCursor, NSEvent, NSEventPhase, NSResponder, NSTextInputClient, NSTrackingArea,
-    NSTrackingAreaOptions, NSView, NSWindow,
+    NSTrackingAreaOptions, NSView, NSViewLayerContentsRedrawPolicy, NSWindow,
 };
 use objc2_core_foundation::CGRect;
 use objc2_foundation::{
@@ -161,10 +161,20 @@ define_class!(
             //    resize occurring.
             // 2. Even when a window resize does occur on a new tabbed window, it contains the wrong
             //    size (includes tab height).
-            let rect = self.frame();
-            let logical_size = LogicalSize::new(rect.size.width as f64, rect.size.height as f64);
-            let size = logical_size.to_physical::<u32>(self.scale_factor());
-            self.queue_event(WindowEvent::SurfaceResized(size));
+            self.surface_resized();
+            // During live resize, AppKit may not let the normal event loop reach its next redraw
+            // point before stretching the current layer contents. Redraw immediately after the
+            // app has observed the new surface size.
+            self.redraw_during_live_resize();
+        }
+
+        #[unsafe(method(viewDidChangeBackingProperties))]
+        fn view_did_change_backing_properties(&self) {
+            let _entered = debug_span!("viewDidChangeBackingProperties").entered();
+            // Moving between displays or changing scale can alter the drawable backing size
+            // without a matching frame-size change.
+            self.surface_resized();
+            self.redraw_during_live_resize();
         }
 
         #[unsafe(method(drawRect:))]
@@ -273,27 +283,26 @@ define_class!(
                 self.ivars().ime_state.set(ImeState::Ground);
             }
 
+            let string = string.to_string();
             let cursor_range = if string.is_empty() {
                 // An empty string basically means that there's no preedit, so indicate that by
                 // sending a `None` cursor range.
                 None
             } else {
-                // Clamp to string length to avoid NSRangeException from out-of-bounds
-                // indices sent by macOS IME (e.g. native Pinyin, see
-                // https://github.com/alacritty/alacritty/issues/8791).
-                let len = string.length();
-                let location = selected_range.location.min(len);
-                let end = selected_range.end().min(len);
-                // Convert the selected range from UTF-16 indices to UTF-8 indices.
-                let sub_string_a = string.substringToIndex(location);
-                let sub_string_b = string.substringToIndex(end);
-                let lowerbound_utf8 = sub_string_a.len();
-                let upperbound_utf8 = sub_string_b.len();
+                // Convert the selected range from UTF-16 code unit indices to UTF-8 byte
+                // offsets. `utf16_to_utf8_offset` is defensive: it snaps an offset that would
+                // split a surrogate pair down to the character boundary and clamps an
+                // out-of-bounds offset to the string length, so no `NSRangeException` is
+                // possible and the resulting range can never be inverted (`lower <= upper`).
+                // IMEs are known to send both mid-surrogate and out-of-bounds offsets (e.g.
+                // native Pinyin, see https://github.com/alacritty/alacritty/issues/8791).
+                let lowerbound_utf8 = utf16_to_utf8_offset(&string, selected_range.location);
+                let upperbound_utf8 = utf16_to_utf8_offset(&string, selected_range.end());
                 Some((lowerbound_utf8, upperbound_utf8))
             };
 
             // Send WindowEvent for updating marked text
-            self.queue_event(WindowEvent::Ime(Ime::Preedit(string.to_string(), cursor_range)));
+            self.queue_event(WindowEvent::Ime(Ime::Preedit(string, cursor_range)));
         }
 
         #[unsafe(method(unmarkText))]
@@ -796,6 +805,10 @@ impl WinitView {
         let this: Retained<Self> = unsafe { msg_send![super(this), init] };
         *this.ivars().input_source.borrow_mut() = this.current_input_source();
 
+        // Ask AppKit to redisplay the layer while the view is being resized so layer-backed
+        // surfaces keep painting.
+        this.setLayerContentsRedrawPolicy(NSViewLayerContentsRedrawPolicy::DuringViewResize);
+
         // `MouseEnteredAndExited` enables receiving events through `mouseEntered:` and
         // `mouseExited:`.
         //
@@ -854,6 +867,37 @@ impl WinitView {
         });
     }
 
+    fn surface_resized(&self) {
+        let Some(window) = (**self).window() else {
+            return;
+        };
+        let size = self.surface_size();
+        let window_id = window_id(&window);
+        self.ivars().app_state.maybe_queue_with_handler(move |app, event_loop| {
+            app.window_event(event_loop, window_id, WindowEvent::SurfaceResized(size));
+        });
+    }
+
+    /// Returns the drawable size from the view's backing-coordinate bounds.
+    pub(super) fn surface_size(&self) -> PhysicalSize<u32> {
+        // The view bounds are authoritative for full-size content views and during live resize.
+        // Deriving this from the window frame can exclude custom titlebar content or be stale.
+        let backing_bounds = self.convertRectToBacking(self.bounds());
+        PhysicalSize::new(
+            backing_bounds.size.width.round().max(0.0) as u32,
+            backing_bounds.size.height.round().max(0.0) as u32,
+        )
+    }
+
+    fn redraw_during_live_resize(&self) {
+        let Some(window) = (**self).window() else {
+            return;
+        };
+        if window.inLiveResize() {
+            self.ivars().app_state.handle_redraw(window_id(&window));
+        }
+    }
+
     fn scale_factor(&self) -> f64 {
         self.window().backingScaleFactor() as f64
     }
@@ -1170,3 +1214,92 @@ fn replace_event(event: &NSEvent, option_as_alt: OptionAsAlt) -> Retained<NSEven
         event.copy()
     }
 }
+
+/// Convert a UTF-16 code unit offset into the corresponding UTF-8 byte offset within `s`.
+///
+/// IMEs are not required to send well-formed offsets, so this is defensive: an offset that
+/// would split a surrogate pair is snapped down to the start of that character, and an
+/// out-of-bounds offset is clamped to the end of the string (e.g. native Pinyin sends
+/// out-of-bounds indices, see <https://github.com/alacritty/alacritty/issues/8791>).
+///
+/// The mapping is monotone non-decreasing, so applying it to the location and end of an
+/// `NSRange` (where `location <= end`) can never produce an inverted byte range.
+fn utf16_to_utf8_offset(s: &str, utf16_offset: usize) -> usize {
+    let mut utf16_pos = 0;
+    for (utf8_pos, ch) in s.char_indices() {
+        if utf16_pos >= utf16_offset {
+            return utf8_pos;
+        }
+        utf16_pos += ch.len_utf16();
+        // The target offset lands strictly inside this character's UTF-16 representation,
+        // i.e. it splits a surrogate pair: snap down to the character boundary.
+        if utf16_pos > utf16_offset {
+            return utf8_pos;
+        }
+    }
+    s.len()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Apply the UTF-16 -> UTF-8 conversion to both ends of a `selectedRange {loc, len}`,
+    /// mirroring what `set_marked_text` does for the emitted `Ime::Preedit` cursor range.
+    fn convert(s: &str, loc: usize, len: usize) -> (usize, usize) {
+        (utf16_to_utf8_offset(s, loc), utf16_to_utf8_offset(s, loc + len))
+    }
+
+    #[test]
+    fn mid_surrogate_offset_snaps_down() {
+        // "😀a": 😀 is one char = 2 UTF-16 units = 4 UTF-8 bytes; offset 1 is mid-pair.
+        assert_eq!(utf16_to_utf8_offset("\u{1F600}a", 1), 0);
+        // Offset 2 is the boundary just after the pair.
+        assert_eq!(utf16_to_utf8_offset("\u{1F600}a", 2), 4);
+    }
+
+    #[test]
+    fn no_longer_inverted() {
+        // "a😀b" with selectedRange {1,1}: previously emitted (1, 0) -- lower > upper, a
+        // slice-panic vector. The boundary-snapping conversion keeps lower <= upper.
+        assert_eq!(convert("a\u{1F600}b", 1, 1), (1, 1));
+    }
+
+    #[test]
+    fn prefix_preserved_on_mid_pair_collapse() {
+        // "a😀b" with selectedRange {2,0}: previously collapsed to (0, 0), discarding the
+        // valid "a" prefix; now snaps to the char boundary after "a".
+        assert_eq!(convert("a\u{1F600}b", 2, 0), (1, 1));
+    }
+
+    #[test]
+    fn out_of_bounds_clamps_to_len() {
+        // Subsumes the #4494 `.min(len)` clamp: an out-of-bounds offset maps to the string
+        // length instead of triggering an NSRangeException.
+        assert_eq!(convert("\u{1F600}a", 99, 0), (5, 5));
+    }
+
+    #[test]
+    fn well_formed_inputs_are_identity() {
+        // The common case (well-formed boundary indices) must be byte-for-byte unchanged.
+        assert_eq!(convert("a\u{1F600}b", 3, 0), (5, 5));
+        assert_eq!(convert("a\u{1F600}b", 4, 0), (6, 6));
+        // BMP multi-byte (Japanese): each char is 1 UTF-16 unit and 3 UTF-8 bytes.
+        assert_eq!(convert("\u{3053}\u{3093}", 1, 1), (3, 6));
+    }
+
+    #[test]
+    fn monotone_non_decreasing() {
+        // Sweep every UTF-16 offset (including out-of-bounds) over a string mixing BMP and
+        // non-BMP characters and assert the conversion never goes backwards, which is what
+        // guarantees `lower <= upper` for any `NSRange`.
+        let s = "a\u{1F600}b\u{3053}\u{1F4A9}c";
+        let mut prev = 0;
+        for off in 0..=20 {
+            let cur = utf16_to_utf8_offset(s, off);
+            assert!(cur >= prev, "non-monotone at offset {off}: {cur} < {prev}");
+            assert!(cur <= s.len(), "offset {off} mapped past end: {cur} > {}", s.len());
+            prev = cur;
+        }
+    }
+}

winit-appkit/src/window_delegate.rs

@@ -912,10 +912,7 @@ impl WindowDelegate {
     fn handle_scale_factor_changed(&self, scale_factor: CGFloat) {
         let window = self.window();
 
-        let content_size = window.contentRectForFrameRect(window.frame()).size;
-        let content_size = LogicalSize::new(content_size.width, content_size.height);
-
-        let suggested_size = content_size.to_physical(scale_factor);
+        let suggested_size = self.view().surface_size();
         let new_surface_size = Arc::new(Mutex::new(suggested_size));
         self.queue_event(WindowEvent::ScaleFactorChanged {
             scale_factor,
@@ -1040,9 +1037,7 @@ impl WindowDelegate {
 
     #[inline]
     pub fn surface_size(&self) -> PhysicalSize<u32> {
-        let content_rect = self.window().contentRectForFrameRect(self.window().frame());
-        let logical = LogicalSize::new(content_rect.size.width, content_rect.size.height);
-        logical.to_physical(self.scale_factor())
+        self.view().surface_size()
     }
 
     #[inline]

winit-common/Cargo.toml

@@ -20,6 +20,9 @@ xkb = ["dep:xkbcommon-dl", "dep:smol_str"]
 # CoreFoundation
 core-foundation = ["dep:block2", "dep:objc2", "dep:objc2-core-foundation"]
 
+# Foundation
+foundation = ["dep:block2", "dep:objc2", "dep:objc2-foundation"]
+
 [dependencies]
 smol_str = { workspace = true, optional = true }
 tracing.workspace = true
@@ -30,7 +33,7 @@ memmap2 = { workspace = true, optional = true }
 x11-dl = { workspace = true, optional = true }
 xkbcommon-dl = { workspace = true, optional = true }
 
-# CoreFoundation
+# Foundation / CoreFoundation
 block2 = { workspace = true, optional = true }
 objc2 = { workspace = true, optional = true }
 objc2-core-foundation = { workspace = true, optional = true, features = [
@@ -40,6 +43,13 @@ objc2-core-foundation = { workspace = true, optional = true, features = [
     "CFRunLoop",
     "CFString",
 ] }
+objc2-foundation = { workspace = true, optional = true, features = [
+    "std",
+    "block2",
+    "NSNotification",
+    "NSString",
+    "NSOperation",
+] }
 
 [package.metadata.docs.rs]
 all-features = true

winit-common/src/foundation/mod.rs

@@ -0,0 +1,3 @@
+mod notification_center;
+
+pub use self::notification_center::*;

winit-common/src/foundation/notification_center.rs

@@ -1,4 +1,3 @@
-// NOTE: This is symlinked to be contained in both the AppKit and UIKit implementations.
 use std::ptr::NonNull;
 
 use block2::RcBlock;
@@ -12,7 +11,7 @@ use objc2_foundation::{
 ///
 /// This is used in Winit as an alternative to declaring an application delegate, as we want to
 /// give the user full control over those.
-pub(crate) fn create_observer(
+pub fn create_observer(
     center: &NSNotificationCenter,
     name: &NSNotificationName,
     handler: impl Fn(&NSNotification) + 'static,

winit-common/src/lib.rs

@@ -4,5 +4,7 @@
 pub mod core_foundation;
 #[cfg(feature = "event-handler")]
 pub mod event_handler;
+#[cfg(feature = "foundation")]
+pub mod foundation;
 #[cfg(feature = "xkb")]
 pub mod xkb;

winit-core/src/event.rs

@@ -269,6 +269,20 @@ pub enum WindowEvent {
         button: ButtonSource,
     },
 
+    /// Multi-finger hold gesture on the touchpad or touchscreen without movement.
+    ///
+    /// The `phase` field indicates the lifecycle of the hold gesture:
+    /// - `Started`: One or more fingers are in contact with the touchpad/touchscreen.
+    /// - `Ended`: All fingers have been lifted from the touchpad/touchscreen.
+    /// - `Cancelled`: The hold gesture was interrupted, for example when another finger touches the
+    ///   touchpad (causing a new `Started` event with more fingers), or when movement begins and
+    ///   transitions to other gestures like pinch, pan, or rotation.
+    ///
+    /// ## Platform-specific
+    ///
+    /// - Only available on **Wayland**.
+    HoldGesture { device_id: Option<DeviceId>, phase: TouchPhase },
+
     /// Two-finger pinch gesture, often used for magnification.
     ///
     /// ## Platform-specific
@@ -1006,9 +1020,17 @@ pub enum Ime {
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum TouchPhase {
+    /// Initial touch contact or gesture start, for example when one or more fingers touch the
+    /// screen or touchpad.
     Started,
+    /// The touch contact point changed, for example without lifting the finger.
     Moved,
+    /// All touch contact points have been lifted from the touchscreen or touchpad.
+    ///
+    /// This event is important as it should clear any state or event in flight that was
+    /// generated by the preceding `Started` and `Moved` events.
     Ended,
+    /// The event was cancelled and should cancel any event in flight and clear state.
     Cancelled,
 }
 

winit-core/src/window.rs

@@ -880,7 +880,8 @@ pub trait Window: AsAny + Send + Sync + fmt::Debug {
     /// ## Platform-specific
     ///
     /// - **Android / iOS / X11 / Web / Windows:** Unsupported.
-    /// - **Wayland:** Only works with org_kde_kwin_blur_manager protocol.
+    /// - **Wayland:** Only works with `org_kde_kwin_blur_manager` or
+    ///   `ext_background_effect_manager_v1` protocol.
     fn set_blur(&self, blur: bool);
 
     /// Modifies the window's visibility.

winit-uikit/Cargo.toml

@@ -69,7 +69,7 @@ objc2-ui-kit = { workspace = true, features = [
     "UIViewController",
     "UIWindow",
 ] }
-winit-common = { workspace = true, features = ["core-foundation", "event-handler"] }
+winit-common = { workspace = true, features = ["core-foundation", "event-handler", "foundation"] }
 
 [package.metadata.docs.rs]
 all-features = true

winit-uikit/src/event_loop.rs

@@ -14,6 +14,7 @@ use objc2_ui_kit::{
 use rwh_06::HasDisplayHandle;
 use tracing::debug_span;
 use winit_common::core_foundation::{MainRunLoop, MainRunLoopObserver, tracing_observers};
+use winit_common::foundation::create_observer;
 use winit_core::application::ApplicationHandler;
 use winit_core::cursor::{CustomCursor, CustomCursorSource};
 use winit_core::error::{EventLoopError, NotSupportedError, RequestError};
@@ -25,7 +26,6 @@ use winit_core::monitor::MonitorHandle as CoreMonitorHandle;
 use winit_core::window::{Theme, Window as CoreWindow};
 
 use super::app_state::{AppState, send_occluded_event_for_all_windows};
-use super::notification_center::create_observer;
 use crate::monitor::MonitorHandle;
 use crate::window::Window;
 use crate::{app_state, monitor};

winit-uikit/src/lib.rs

@@ -103,7 +103,6 @@
 mod app_state;
 mod event_loop;
 mod monitor;
-mod notification_center;
 mod view;
 mod view_controller;
 mod window;

winit-uikit/src/notification_center.rs

@@ -1 +0,0 @@
-../../winit-appkit/src/notification_center.rs

winit-wayland/Cargo.toml

@@ -40,7 +40,7 @@ sctk = { package = "smithay-client-toolkit", version = "0.20.0", default-feature
 sctk-adwaita = { version = "0.11.0", default-features = false, optional = true }
 wayland-backend = { version = "0.3.10", default-features = false, features = ["client_system"] }
 wayland-client = "0.31.10"
-wayland-protocols = { version = "0.32.8", features = ["staging"] }
+wayland-protocols = { version = "0.32.11", features = ["staging", "unstable"] }
 wayland-protocols-plasma = { version = "0.3.8", features = ["client"] }
 winit-common = { workspace = true, features = ["xkb", "wayland"] }
 

winit-wayland/src/seat/mod.rs

@@ -12,6 +12,7 @@ use sctk::reexports::protocols::wp::text_input::zv3::client::zwp_text_input_v3::
 use sctk::seat::pointer::{ThemeSpec, ThemedPointer};
 use sctk::seat::{Capability as SeatCapability, SeatHandler, SeatState};
 use tracing::warn;
+use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_hold_v1::ZwpPointerGestureHoldV1;
 use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_pinch_v1::ZwpPointerGesturePinchV1;
 use wayland_protocols::wp::tablet::zv2::client::zwp_tablet_seat_v2::ZwpTabletSeatV2;
 use winit_core::event::WindowEvent;
@@ -60,6 +61,9 @@ pub struct WinitSeatState {
     /// The pinch pointer gesture bound on the seat.
     pointer_gesture_pinch: Option<ZwpPointerGesturePinchV1>,
 
+    /// The hold pointer gesture bound on the seat.
+    pointer_gesture_hold: Option<ZwpPointerGestureHoldV1>,
+
     /// The keyboard bound on the seat.
     keyboard_state: Option<KeyboardState>,
 
@@ -141,6 +145,14 @@ impl SeatHandler for WinitState {
                     )
                 });
 
+                seat_state.pointer_gesture_hold = self.pointer_gestures.as_ref().map(|manager| {
+                    manager.get_hold_gesture(
+                        themed_pointer.pointer(),
+                        queue_handle,
+                        PointerGestureData::default(),
+                    )
+                });
+
                 let themed_pointer = Arc::new(themed_pointer);
 
                 // Register cursor surface.
@@ -209,6 +221,10 @@ impl SeatHandler for WinitState {
                     pointer_gesture_pinch.destroy();
                 }
 
+                if let Some(pointer_gesture_hold) = seat_state.pointer_gesture_hold.take() {
+                    pointer_gesture_hold.destroy();
+                }
+
                 if let Some(pointer) = seat_state.pointer.take() {
                     let pointer_data = pointer.pointer().winit_data();
 

winit-wayland/src/seat/pointer/pointer_gesture.rs

@@ -7,9 +7,12 @@ use sctk::globals::GlobalData;
 use sctk::reexports::client::globals::{BindError, GlobalList};
 use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
 use sctk::reexports::protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_pinch_v1::{
-    Event, ZwpPointerGesturePinchV1,
+    Event as PinchEvent, ZwpPointerGesturePinchV1,
 };
 use sctk::reexports::protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gestures_v1::ZwpPointerGesturesV1;
+use wayland_protocols::wp::pointer_gestures::zv1::client::zwp_pointer_gesture_hold_v1::{
+    Event as HoldEvent, ZwpPointerGestureHoldV1,
+};
 use winit_core::event::{TouchPhase, WindowEvent};
 use winit_core::window::WindowId;
 
@@ -27,7 +30,7 @@ impl PointerGesturesState {
         globals: &GlobalList,
         queue_handle: &QueueHandle<WinitState>,
     ) -> Result<Self, BindError> {
-        let pointer_gestures = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        let pointer_gestures = globals.bind(queue_handle, 3..=3, GlobalData)?;
         Ok(Self { pointer_gestures })
     }
 }
@@ -70,6 +73,49 @@ impl Dispatch<ZwpPointerGesturesV1, GlobalData, WinitState> for PointerGesturesS
     }
 }
 
+impl Dispatch<ZwpPointerGestureHoldV1, PointerGestureData, WinitState> for PointerGesturesState {
+    fn event(
+        state: &mut WinitState,
+        _proxy: &ZwpPointerGestureHoldV1,
+        event: <ZwpPointerGestureHoldV1 as wayland_client::Proxy>::Event,
+        data: &PointerGestureData,
+        _conn: &Connection,
+        _qhandle: &QueueHandle<WinitState>,
+    ) {
+        let mut pointer_gesture_data = data.inner.lock().unwrap();
+        let (window_id, phase) = match event {
+            HoldEvent::Begin { surface, fingers, .. } => {
+                if fingers < 2 {
+                    return;
+                }
+
+                let window_id = crate::make_wid(&surface);
+                pointer_gesture_data.window_id = Some(window_id);
+
+                (window_id, TouchPhase::Started)
+            },
+            HoldEvent::End { cancelled, .. } => {
+                let window_id = match pointer_gesture_data.window_id {
+                    Some(window_id) => window_id,
+                    _ => return,
+                };
+
+                // Reset the state.
+                *pointer_gesture_data = Default::default();
+
+                let phase = if cancelled == 0 { TouchPhase::Ended } else { TouchPhase::Cancelled };
+
+                (window_id, phase)
+            },
+            _ => return,
+        };
+
+        state
+            .events_sink
+            .push_window_event(WindowEvent::HoldGesture { device_id: None, phase }, window_id);
+    }
+}
+
 impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for PointerGesturesState {
     fn event(
         state: &mut WinitState,
@@ -81,7 +127,7 @@ impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for Poin
     ) {
         let mut pointer_gesture_data = data.inner.lock().unwrap();
         let (window_id, phase, pan_delta, pinch_delta, rotation_delta) = match event {
-            Event::Begin { surface, fingers, .. } => {
+            PinchEvent::Begin { surface, fingers, .. } => {
                 // We only support two fingers for now.
                 if fingers != 2 {
                     return;
@@ -100,7 +146,7 @@ impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for Poin
 
                 (window_id, TouchPhase::Started, PhysicalPosition::new(0., 0.), 0., 0.)
             },
-            Event::Update { dx, dy, scale: pinch, rotation, .. } => {
+            PinchEvent::Update { dx, dy, scale: pinch, rotation, .. } => {
                 let window_id = match pointer_gesture_data.window_id {
                     Some(window_id) => window_id,
                     _ => return,
@@ -121,7 +167,7 @@ impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for Poin
                 let rotation_delta = -rotation as f32;
                 (window_id, TouchPhase::Moved, pan_delta, pinch_delta, rotation_delta)
             },
-            Event::End { cancelled, .. } => {
+            PinchEvent::End { cancelled, .. } => {
                 let window_id = match pointer_gesture_data.window_id {
                     Some(window_id) => window_id,
                     _ => return,
@@ -155,3 +201,4 @@ impl Dispatch<ZwpPointerGesturePinchV1, PointerGestureData, WinitState> for Poin
 
 delegate_dispatch!(WinitState: [ZwpPointerGesturesV1: GlobalData] => PointerGesturesState);
 delegate_dispatch!(WinitState: [ZwpPointerGesturePinchV1: PointerGestureData] => PointerGesturesState);
+delegate_dispatch!(WinitState: [ZwpPointerGestureHoldV1: PointerGestureData] => PointerGesturesState);

winit-wayland/src/state.rs

@@ -29,7 +29,7 @@ use crate::seat::{
     PointerConstraintsState, PointerGesturesState, RelativePointerState, TextInputState,
     WinitPointerData, WinitPointerDataExt, WinitSeatState,
 };
-use crate::types::kwin_blur::KWinBlurManager;
+use crate::types::bgr_effects::BgrEffectManager;
 use crate::types::wp_fractional_scaling::FractionalScalingManager;
 use crate::types::wp_tablet_input_v2::TabletManager;
 use crate::types::wp_viewporter::ViewporterState;
@@ -116,8 +116,8 @@ pub struct WinitState {
     /// Fractional scaling manager.
     pub fractional_scaling_manager: Option<FractionalScalingManager>,
 
-    /// KWin blur manager.
-    pub kwin_blur_manager: Option<KWinBlurManager>,
+    /// Blur manager.
+    pub blur_manager: Option<BgrEffectManager>,
 
     /// Loop handle to re-register event sources, such as keyboard repeat.
     pub loop_handle: LoopHandle<'static, Self>,
@@ -192,7 +192,7 @@ impl WinitState {
             window_events_sink: Default::default(),
             viewporter_state,
             fractional_scaling_manager,
-            kwin_blur_manager: KWinBlurManager::new(globals, queue_handle).ok(),
+            blur_manager: BgrEffectManager::new(globals, queue_handle).ok(),
 
             seats,
             text_input_state: TextInputState::new(globals, queue_handle).ok(),

winit-wayland/src/types/bgr_effects.rs

@@ -0,0 +1,85 @@
+use sctk::compositor::Region;
+use sctk::reexports::client::QueueHandle;
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::protocols::ext::background_effect::v1::client::ext_background_effect_surface_v1::ExtBackgroundEffectSurfaceV1;
+use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
+
+use crate::state::WinitState;
+use crate::types::ext_background_effect::ExtBackgroundEffectManager;
+use crate::types::kwin_blur::KWinBlurManager;
+
+/// Wrapper around various background effects for [`WlSurface`].
+#[derive(Debug, Clone)]
+pub enum BgrEffectManager {
+    Ext(ExtBackgroundEffectManager),
+    KWin(KWinBlurManager),
+}
+
+impl BgrEffectManager {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        ExtBackgroundEffectManager::new(globals, queue_handle)
+            .map(Self::Ext)
+            .or_else(|_| KWinBlurManager::new(globals, queue_handle).map(Self::KWin))
+    }
+
+    /// Creates a new blur effect for the surface.
+    pub fn new_blur_effect(
+        &mut self,
+        surface: &WlSurface,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> SurfaceBlurEffect {
+        match self {
+            BgrEffectManager::Ext(mgr) => SurfaceBlurEffect::Ext(mgr.blur(surface, queue_handle)),
+            BgrEffectManager::KWin(mgr) => SurfaceBlurEffect::Kwin(
+                mgr.blur(surface, queue_handle),
+                mgr.clone(),
+                surface.clone(),
+            ),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum SurfaceBlurEffect {
+    Ext(ExtBackgroundEffectSurfaceV1),
+    Kwin(OrgKdeKwinBlur, KWinBlurManager, WlSurface),
+}
+
+impl SurfaceBlurEffect {
+    /// Returns `true` if the main surface commit is required.
+    ///
+    /// `None` clears the blur.
+    #[must_use]
+    pub fn set_blur(&self, region: Option<&Region>) -> bool {
+        let region = region.map(|region| region.wl_region());
+        match self {
+            SurfaceBlurEffect::Ext(surface) => {
+                surface.set_blur_region(region);
+                true
+            },
+            SurfaceBlurEffect::Kwin(blur, ..) => {
+                blur.set_region(region);
+                blur.commit();
+                true
+            },
+        }
+    }
+}
+
+impl Drop for SurfaceBlurEffect {
+    fn drop(&mut self) {
+        match self {
+            SurfaceBlurEffect::Ext(surface) => surface.destroy(),
+            SurfaceBlurEffect::Kwin(blur, mgr, wl_surface) => {
+                blur.set_region(None);
+                blur.commit();
+                blur.release();
+                mgr.unset(wl_surface);
+            },
+        }
+    }
+}

winit-wayland/src/types/ext_background_effect.rs

@@ -0,0 +1,59 @@
+use sctk::globals::GlobalData;
+use sctk::reexports::client::globals::{BindError, GlobalList};
+use sctk::reexports::client::protocol::wl_surface::WlSurface;
+use sctk::reexports::client::{Connection, Dispatch, Proxy, QueueHandle, delegate_dispatch};
+use wayland_protocols::ext::background_effect::v1::client::ext_background_effect_manager_v1::ExtBackgroundEffectManagerV1;
+use wayland_protocols::ext::background_effect::v1::client::ext_background_effect_surface_v1::ExtBackgroundEffectSurfaceV1;
+
+use crate::state::WinitState;
+
+#[derive(Debug, Clone)]
+pub struct ExtBackgroundEffectManager {
+    manager: ExtBackgroundEffectManagerV1,
+}
+
+impl ExtBackgroundEffectManager {
+    pub fn new(
+        globals: &GlobalList,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> Result<Self, BindError> {
+        let manager = globals.bind(queue_handle, 1..=1, GlobalData)?;
+        Ok(Self { manager })
+    }
+
+    pub fn blur(
+        &mut self,
+        surface: &WlSurface,
+        queue_handle: &QueueHandle<WinitState>,
+    ) -> ExtBackgroundEffectSurfaceV1 {
+        self.manager.get_background_effect(surface, queue_handle, ())
+    }
+}
+
+impl Dispatch<ExtBackgroundEffectManagerV1, GlobalData, WinitState> for ExtBackgroundEffectManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ExtBackgroundEffectManagerV1,
+        _: <ExtBackgroundEffectManagerV1 as Proxy>::Event,
+        _: &GlobalData,
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+    }
+}
+
+impl Dispatch<ExtBackgroundEffectSurfaceV1, (), WinitState> for ExtBackgroundEffectManager {
+    fn event(
+        _: &mut WinitState,
+        _: &ExtBackgroundEffectSurfaceV1,
+        _: <ExtBackgroundEffectSurfaceV1 as Proxy>::Event,
+        _: &(),
+        _: &Connection,
+        _: &QueueHandle<WinitState>,
+    ) {
+        // There is no event
+    }
+}
+
+delegate_dispatch!(WinitState: [ExtBackgroundEffectManagerV1: GlobalData] => ExtBackgroundEffectManager);
+delegate_dispatch!(WinitState: [ExtBackgroundEffectSurfaceV1: ()] => ExtBackgroundEffectManager);

winit-wayland/src/types/mod.rs

@@ -1,6 +1,8 @@
 //! Wayland protocol implementation boilerplate.
 
+pub mod bgr_effects;
 pub mod cursor;
+pub mod ext_background_effect;
 pub mod kwin_blur;
 pub mod wp_fractional_scaling;
 pub mod wp_tablet_input_v2;

winit-wayland/src/window/mod.rs

@@ -127,7 +127,8 @@ impl Window {
         // Set transparency hint.
         window_state.set_transparent(attributes.transparent);
 
-        window_state.set_blur(attributes.blur);
+        // Set blur.
+        let _ = window_state.set_blur(attributes.blur);
 
         // Set the decorations hint.
         window_state.set_decorate(attributes.decorations);
@@ -498,7 +499,9 @@ impl CoreWindow for Window {
 
     #[inline]
     fn set_blur(&self, blur: bool) {
-        self.window_state.lock().unwrap().set_blur(blur);
+        if self.window_state.lock().unwrap().set_blur(blur) {
+            self.request_redraw();
+        }
     }
 
     #[inline]

winit-wayland/src/window/state.rs

@@ -29,7 +29,6 @@ use sctk::shm::slot::SlotPool;
 use sctk::subcompositor::SubcompositorState;
 use tracing::{info, warn};
 use wayland_protocols::xdg::toplevel_icon::v1::client::xdg_toplevel_icon_manager_v1::XdgToplevelIconManagerV1;
-use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 use winit_core::cursor::{CursorIcon, CustomCursor as CoreCustomCursor};
 use winit_core::error::{NotSupportedError, RequestError};
 use winit_core::window::{
@@ -43,8 +42,8 @@ use crate::seat::{
     ZwpTextInputV3Ext,
 };
 use crate::state::{WindowCompositorUpdate, WinitState};
+use crate::types::bgr_effects::{BgrEffectManager, SurfaceBlurEffect};
 use crate::types::cursor::{CustomCursor, SelectedCursor, WaylandCustomCursor};
-use crate::types::kwin_blur::KWinBlurManager;
 use crate::types::xdg_toplevel_icon_manager::ToplevelIcon;
 
 #[cfg(feature = "sctk-adwaita")]
@@ -156,8 +155,8 @@ pub struct WindowState {
 
     viewport: Option<WpViewport>,
     fractional_scale: Option<WpFractionalScaleV1>,
-    blur: Option<OrgKdeKwinBlur>,
-    blur_manager: Option<KWinBlurManager>,
+    blur: Option<SurfaceBlurEffect>,
+    blur_manager: Option<BgrEffectManager>,
 
     /// Whether the client side decorations have pending move operations.
     ///
@@ -206,7 +205,7 @@ impl WindowState {
             toplevel_icon: None,
             xdg_toplevel_icon_manager,
             blur: None,
-            blur_manager: winit_state.kwin_blur_manager.clone(),
+            blur_manager: winit_state.blur_manager.clone(),
             compositor,
             handle,
             csd_fails: false,
@@ -742,6 +741,13 @@ impl WindowState {
             // Set surface size without the borders.
             viewport.set_destination(self.size.width as _, self.size.height as _);
         }
+
+        // Update blur region with new size.
+        if self.blur.is_some() {
+            // NOTE: either user resized or configure, in both cases
+            // the redraw scheduling is done on the caller side.
+            let _ = self.set_blur(true);
+        }
     }
 
     /// Get the scale factor of the window.
@@ -1113,20 +1119,37 @@ impl WindowState {
         }
     }
 
-    /// Make window background blurred
-    #[inline]
-    pub fn set_blur(&mut self, blurred: bool) {
-        if blurred && self.blur.is_none() {
-            if let Some(blur_manager) = self.blur_manager.as_ref() {
-                let blur = blur_manager.blur(self.window.wl_surface(), &self.queue_handle);
-                blur.commit();
-                self.blur = Some(blur);
-            } else {
-                info!("Blur manager unavailable, unable to change blur")
-            }
-        } else if !blurred && self.blur.is_some() {
-            self.blur_manager.as_ref().unwrap().unset(self.window.wl_surface());
-            self.blur.take().unwrap().release();
+    /// Make window background blurred.
+    ///
+    /// Returns `true` if redraw is required.
+    #[must_use]
+    pub fn set_blur(&mut self, blurred: bool) -> bool {
+        if !blurred {
+            self.blur = None;
+            return true;
+        }
+
+        let mgr = match self.blur_manager.as_mut() {
+            Some(mgr) => mgr,
+            None => {
+                info!("Blur manager unavailable, unable to change blur");
+                return false;
+            },
+        };
+
+        let blur = match self.blur.as_ref() {
+            Some(blur) => blur,
+            None => {
+                self.blur = Some(mgr.new_blur_effect(self.window.wl_surface(), &self.queue_handle));
+                self.blur.as_ref().unwrap()
+            },
+        };
+
+        if let Ok(region) = Region::new(&*self.compositor) {
+            region.add(0, 0, i32::MAX, i32::MAX);
+            blur.set_blur(Some(&region))
+        } else {
+            false
         }
     }
 
@@ -1224,10 +1247,6 @@ impl WindowState {
 
 impl Drop for WindowState {
     fn drop(&mut self) {
-        if let Some(blur) = self.blur.take() {
-            blur.release();
-        }
-
         if let Some(fs) = self.fractional_scale.take() {
             fs.destroy();
         }

winit-web/src/monitor.rs

@@ -526,7 +526,7 @@ impl MonitorHandler {
                     },
                 };
 
-                // Notifying `Future`s is not dependant on the lifetime of the runner,
+                // Notifying `Future`s is not dependent on the lifetime of the runner,
                 // because they can outlive it.
                 if let Some(runner) = runner.upgrade() {
                     if let Some(details) = details {
@@ -761,7 +761,7 @@ impl MonitorPermissionFuture {
         wasm_bindgen_futures::spawn_local(async move {
             match future.await {
                 Ok(details) => {
-                    // Notifying `Future`s is not dependant on the lifetime of the runner, because
+                    // Notifying `Future`s is not dependent on the lifetime of the runner, because
                     // they can outlive it.
                     notifier.notify(Ok(()));
 

winit-win32/src/event_loop.rs

@@ -51,12 +51,12 @@ use windows_sys::Win32::UI::WindowsAndMessaging::{
     SystemParametersInfoW, TranslateMessage, WHEEL_DELTA, WINDOWPOS, WM_CAPTURECHANGED, WM_CLOSE,
     WM_CREATE, WM_DESTROY, WM_DPICHANGED, WM_ENTERSIZEMOVE, WM_EXITSIZEMOVE, WM_GETMINMAXINFO,
     WM_IME_COMPOSITION, WM_IME_ENDCOMPOSITION, WM_IME_SETCONTEXT, WM_IME_STARTCOMPOSITION,
-    WM_INPUT, WM_KEYDOWN, WM_KEYUP, WM_KILLFOCUS, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MBUTTONDOWN,
-    WM_MBUTTONUP, WM_MENUCHAR, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL, WM_NCACTIVATE,
-    WM_NCCALCSIZE, WM_NCCREATE, WM_NCDESTROY, WM_NCLBUTTONDOWN, WM_PAINT, WM_POINTERDOWN,
-    WM_POINTERUP, WM_POINTERUPDATE, WM_RBUTTONDOWN, WM_RBUTTONUP, WM_SETCURSOR, WM_SETFOCUS,
-    WM_SETTINGCHANGE, WM_SIZE, WM_SIZING, WM_SYSCOMMAND, WM_SYSKEYDOWN, WM_SYSKEYUP, WM_TOUCH,
-    WM_WINDOWPOSCHANGED, WM_WINDOWPOSCHANGING, WM_XBUTTONDOWN, WM_XBUTTONUP, WMSZ_BOTTOM,
+    WM_INPUT, WM_INPUTLANGCHANGE, WM_KEYDOWN, WM_KEYUP, WM_KILLFOCUS, WM_LBUTTONDOWN, WM_LBUTTONUP,
+    WM_MBUTTONDOWN, WM_MBUTTONUP, WM_MENUCHAR, WM_MOUSEHWHEEL, WM_MOUSEMOVE, WM_MOUSEWHEEL,
+    WM_NCACTIVATE, WM_NCCALCSIZE, WM_NCCREATE, WM_NCDESTROY, WM_NCLBUTTONDOWN, WM_PAINT,
+    WM_POINTERDOWN, WM_POINTERUP, WM_POINTERUPDATE, WM_RBUTTONDOWN, WM_RBUTTONUP, WM_SETCURSOR,
+    WM_SETFOCUS, WM_SETTINGCHANGE, WM_SIZE, WM_SIZING, WM_SYSCOMMAND, WM_SYSKEYDOWN, WM_SYSKEYUP,
+    WM_TOUCH, WM_WINDOWPOSCHANGED, WM_WINDOWPOSCHANGING, WM_XBUTTONDOWN, WM_XBUTTONUP, WMSZ_BOTTOM,
     WMSZ_BOTTOMLEFT, WMSZ_BOTTOMRIGHT, WMSZ_LEFT, WMSZ_RIGHT, WMSZ_TOP, WMSZ_TOPLEFT,
     WMSZ_TOPRIGHT, WNDCLASSEXW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW,
     WS_EX_TRANSPARENT, WS_OVERLAPPED, WS_POPUP, WS_VISIBLE,
@@ -1508,6 +1508,21 @@ unsafe fn public_window_callback_inner(
             result = ProcResult::Value(unsafe { DefWindowProcW(window, msg, wparam, lparam) });
         },
 
+        WM_INPUTLANGCHANGE => {
+            // Refresh the cached keyboard layout for the newly activated input
+            // language. This message is sent (by Windows or by layout switchers
+            // such as Punto Switcher) after the layout changes. Refreshing the
+            // cache here prevents a freeze that otherwise occurs when switching
+            // layout via such tools. We still defer to `DefWindowProc` so the
+            // message keeps propagating to first-level child windows, as the
+            // Win32 documentation requires.
+            {
+                let mut layouts = LAYOUT_CACHE.lock().unwrap();
+                layouts.get_current_layout();
+            }
+            result = ProcResult::DefWindowProc(wparam);
+        },
+
         // this is necessary for us to maintain minimize/restore state
         WM_SYSCOMMAND => {
             if wparam == SC_RESTORE as usize {

winit-x11/src/event_processor.rs

@@ -1757,7 +1757,7 @@ impl EventProcessor {
                 .find(|prev_monitor| prev_monitor.name == new_monitor.name)
                 .map(|prev_monitor| prev_monitor.scale_factor);
             if Some(new_monitor.scale_factor) != maybe_prev_scale_factor {
-                for window in self.target.windows.borrow().iter().filter_map(|(_, w)| w.upgrade()) {
+                for window in self.target.windows.borrow().values().filter_map(|w| w.upgrade()) {
                     window.refresh_dpi_for_monitor(
                         &new_monitor,
                         maybe_prev_scale_factor,

winit/Cargo.toml

@@ -76,9 +76,13 @@ winit-core.workspace = true
 
 [dev-dependencies]
 image = { workspace = true, features = ["png"] }
-softbuffer.workspace = true
 tracing = { workspace = true, features = ["log"] }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
+# Launching a window without drawing to it has unpredictable results varying from platform to
+# platform. We use the `softbuffer` crate in our examples because of its ease of use to avoid
+# confusion around this. `glutin` or `wgpu` could also be used to fill the window buffer, but they
+# are more complicated to set up.
+softbuffer.workspace = true
 
 [target.'cfg(target_os = "android")'.dependencies]
 winit-android.workspace = true

winit/examples/application.rs

@@ -15,7 +15,6 @@ use std::time::Instant;
 use std::{fmt, mem};
 
 use cursor_icon::CursorIcon;
-use rwh_06::{DisplayHandle, HasDisplayHandle};
 use softbuffer::{Context, Surface};
 use tracing::{error, info};
 #[cfg(web_platform)]
@@ -25,7 +24,7 @@ use winit::cursor::{Cursor, CustomCursor, CustomCursorSource};
 use winit::dpi::{LogicalSize, PhysicalPosition, PhysicalSize};
 use winit::error::RequestError;
 use winit::event::{DeviceEvent, DeviceId, MouseButton, MouseScrollDelta, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
 use winit::icon::{Icon, RgbaIcon};
 use winit::keyboard::{Key, ModifiersState};
 use winit::monitor::Fullscreen;
@@ -45,9 +44,6 @@ use winit_core::application::macos::ApplicationHandlerExtMacOS;
 #[path = "util/tracing.rs"]
 mod tracing_init;
 
-#[path = "util/fill.rs"]
-mod fill;
-
 /// The amount of points to around the window for drag resize direction calculations.
 const BORDER_SIZE: f64 = 20.;
 
@@ -94,20 +90,12 @@ struct Application {
     /// Drawing context.
     ///
     /// With OpenGL it could be EGLDisplay.
-    context: Option<Context<DisplayHandle<'static>>>,
+    context: Context<OwnedDisplayHandle>,
 }
 
 impl Application {
     fn new(event_loop: &EventLoop, receiver: Receiver<Action>, sender: Sender<Action>) -> Self {
-        // SAFETY: we drop the context right before the event loop is stopped, thus making it safe.
-        let context = Some(
-            Context::new(unsafe {
-                std::mem::transmute::<DisplayHandle<'_>, DisplayHandle<'static>>(
-                    event_loop.display_handle().unwrap(),
-                )
-            })
-            .unwrap(),
-        );
+        let context = Context::new(event_loop.owned_display_handle()).unwrap();
 
         // You'll have to choose an icon size at your own discretion. On X11, the desired size
         // varies by WM, and on Windows, you still have to account for screen scaling. Here
@@ -541,16 +529,7 @@ impl ApplicationHandler for Application {
             WindowEvent::DoubleTapGesture { .. } => {
                 info!("Smart zoom");
             },
-            WindowEvent::TouchpadPressure { .. }
-            | WindowEvent::DragLeft { .. }
-            | WindowEvent::KeyboardInput { .. }
-            | WindowEvent::PointerEntered { .. }
-            | WindowEvent::DragEntered { .. }
-            | WindowEvent::DragMoved { .. }
-            | WindowEvent::DragDropped { .. }
-            | WindowEvent::Destroyed
-            | WindowEvent::Ime(_)
-            | WindowEvent::Moved(_) => (),
+            _ => (),
         }
     }
 
@@ -605,9 +584,7 @@ impl ApplicationHandlerExtMacOS for Application {
 /// State of the window.
 struct WindowState {
     /// Render surface.
-    ///
-    /// NOTE: This surface must be dropped before the `Window`.
-    surface: Surface<DisplayHandle<'static>, Arc<dyn Window>>,
+    surface: Surface<OwnedDisplayHandle, Arc<dyn Window>>,
     /// The actual winit Window.
     window: Arc<dyn Window>,
     /// The window theme we're drawing with.
@@ -648,9 +625,7 @@ impl WindowState {
     fn new(app: &Application, window: Box<dyn Window>) -> Result<Self, Box<dyn Error>> {
         let window: Arc<dyn Window> = Arc::from(window);
 
-        // SAFETY: the surface is dropped before the `window` which provided it with handle, thus
-        // it doesn't outlive it.
-        let surface = Surface::new(app.context.as_ref().unwrap(), Arc::clone(&window))?;
+        let surface = Surface::new(&app.context, Arc::clone(&window))?;
 
         let theme = window.theme().unwrap_or(Theme::Dark);
         info!("Theme: {theme:?}");
@@ -937,35 +912,40 @@ impl WindowState {
             return Ok(());
         }
 
-        if self.animated_fill_color {
-            fill::fill_window_with_animated_color(&*self.window, self.start_time);
-            return Ok(());
-        }
-
         let mut buffer = self.surface.buffer_mut()?;
 
-        // Draw a different color inside the safe area
-        let surface_size = self.window.surface_size();
-        let insets = self.window.safe_area();
-        for y in 0..surface_size.height {
-            for x in 0..surface_size.width {
-                let index = y as usize * surface_size.width as usize + x as usize;
-                if insets.left <= x
-                    && x <= (surface_size.width - insets.right)
-                    && insets.top <= y
-                    && y <= (surface_size.height - insets.bottom)
-                {
-                    // In safe area
-                    buffer[index] = match self.theme {
-                        Theme::Light => 0xffe8e8e8, // Light gray
-                        Theme::Dark => 0xff525252,  // Medium gray
-                    };
-                } else {
-                    // Outside safe area
-                    buffer[index] = match self.theme {
-                        Theme::Light => 0xffffffff, // White
-                        Theme::Dark => 0xff181818,  // Dark gray
-                    };
+        if self.animated_fill_color {
+            // Fill the entire buffer with a single color.
+            let time = self.start_time.elapsed().as_secs_f32() * 1.5;
+            let blue = (time.sin() * 255.0) as u32;
+            let green = ((time.cos() * 255.0) as u32) << 8;
+            let red = ((1.0 - time.sin() * 255.0) as u32) << 16;
+            let color = red | green | blue;
+            buffer.fill(color);
+        } else {
+            // Draw a different color inside the safe area
+            let surface_size = self.window.surface_size();
+            let insets = self.window.safe_area();
+            for y in 0..surface_size.height {
+                for x in 0..surface_size.width {
+                    let index = y as usize * surface_size.width as usize + x as usize;
+                    if insets.left <= x
+                        && x <= (surface_size.width - insets.right)
+                        && insets.top <= y
+                        && y <= (surface_size.height - insets.bottom)
+                    {
+                        // In safe area
+                        buffer[index] = match self.theme {
+                            Theme::Light => 0xffe8e8e8, // Light gray
+                            Theme::Dark => 0xff525252,  // Medium gray
+                        };
+                    } else {
+                        // Outside safe area
+                        buffer[index] = match self.theme {
+                            Theme::Light => 0xffffffff, // White
+                            Theme::Dark => 0xff181818,  // Dark gray
+                        };
+                    }
                 }
             }
         }

winit/examples/child_window.rs

@@ -3,11 +3,12 @@
 fn main() -> Result<(), impl std::error::Error> {
     use std::collections::HashMap;
 
+    use softbuffer::{Context, Surface};
     use tracing::info;
     use winit::application::ApplicationHandler;
     use winit::dpi::{LogicalPosition, LogicalSize, Position};
     use winit::event::{ElementState, KeyEvent, WindowEvent};
-    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
     use winit::raw_window_handle::HasRawWindowHandle;
     use winit::window::{Window, WindowAttributes, WindowId};
 
@@ -16,18 +17,20 @@ fn main() -> Result<(), impl std::error::Error> {
 
     #[derive(Debug)]
     struct WindowData {
-        window: Box<dyn Window>,
+        surface: Surface<OwnedDisplayHandle, Box<dyn Window>>,
         color: u32,
     }
 
     impl WindowData {
-        fn new(window: Box<dyn Window>, color: u32) -> Self {
-            Self { window, color }
+        fn new(context: &Context<OwnedDisplayHandle>, window: Box<dyn Window>, color: u32) -> Self {
+            let surface = Surface::new(context, window).unwrap();
+            Self { surface, color }
         }
     }
 
-    #[derive(Default, Debug)]
+    #[derive(Debug)]
     struct Application {
+        context: Context<OwnedDisplayHandle>,
         parent_window_id: Option<WindowId>,
         windows: HashMap<WindowId, WindowData>,
     }
@@ -42,7 +45,7 @@ fn main() -> Result<(), impl std::error::Error> {
             info!("Parent window id: {:?})", window.id());
             self.parent_window_id = Some(window.id());
 
-            self.windows.insert(window.id(), WindowData::new(window, 0xffbbbbbb));
+            self.windows.insert(window.id(), WindowData::new(&self.context, window, 0xffbbbbbb));
         }
 
         fn window_event(
@@ -73,18 +76,24 @@ fn main() -> Result<(), impl std::error::Error> {
                         0xff000000 + 3_u32.pow((child_index + 2).rem_euclid(16) as u32);
 
                     let parent_window = self.windows.get(&self.parent_window_id.unwrap()).unwrap();
-                    let child_window =
-                        spawn_child_window(parent_window.window.as_ref(), event_loop, child_index);
+                    let child_window = spawn_child_window(
+                        parent_window.surface.window().as_ref(),
+                        event_loop,
+                        child_index,
+                    );
                     let child_id = child_window.id();
                     info!("Child window created with id: {child_id:?}");
-                    self.windows.insert(child_id, WindowData::new(child_window, child_color));
+                    self.windows.insert(
+                        child_id,
+                        WindowData::new(&self.context, child_window, child_color),
+                    );
                 },
                 WindowEvent::RedrawRequested => {
-                    if let Some(window) = self.windows.get(&window_id) {
+                    if let Some(window) = self.windows.get_mut(&window_id) {
                         if window_id == self.parent_window_id.unwrap() {
-                            fill::fill_window(window.window.as_ref());
+                            fill::fill(&mut window.surface);
                         } else {
-                            fill::fill_window_with_color(window.window.as_ref(), window.color);
+                            fill::fill_with_color(&mut window.surface, window.color);
                         }
                     }
                 },
@@ -118,7 +127,8 @@ fn main() -> Result<(), impl std::error::Error> {
     }
 
     let event_loop = EventLoop::new().unwrap();
-    event_loop.run_app(Application::default())
+    let context = Context::new(event_loop.owned_display_handle()).unwrap();
+    event_loop.run_app(Application { context, parent_window_id: None, windows: HashMap::new() })
 }
 
 #[cfg(not(any(x11_platform, macos_platform, windows_platform)))]

winit/examples/control_flow.rs

@@ -4,12 +4,13 @@ use std::thread;
 #[cfg(not(web_platform))]
 use std::time;
 
+use softbuffer::{Context, Surface};
 use tracing::{info, warn};
 #[cfg(web_platform)]
 use web_time as time;
 use winit::application::ApplicationHandler;
 use winit::event::{ElementState, KeyEvent, StartCause, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop, OwnedDisplayHandle};
 use winit::keyboard::{Key, NamedKey};
 use winit::window::{Window, WindowAttributes, WindowId};
 
@@ -52,7 +53,7 @@ struct ControlFlowDemo {
     request_redraw: bool,
     wait_cancelled: bool,
     close_requested: bool,
-    window: Option<Box<dyn Window>>,
+    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
 }
 
 impl ApplicationHandler for ControlFlowDemo {
@@ -69,7 +70,10 @@ impl ApplicationHandler for ControlFlowDemo {
         let window_attributes = WindowAttributes::default().with_title(
             "Press 1, 2, 3 to change control flow mode. Press R to toggle redraw requests.",
         );
-        self.window = Some(event_loop.create_window(window_attributes).unwrap());
+        let window = event_loop.create_window(window_attributes).unwrap();
+        let context = Context::new(event_loop.owned_display_handle()).unwrap();
+        let surface = Surface::new(&context, window).unwrap();
+        self.surface = Some(surface);
     }
 
     fn window_event(
@@ -112,9 +116,9 @@ impl ApplicationHandler for ControlFlowDemo {
                 _ => (),
             },
             WindowEvent::RedrawRequested => {
-                let window = self.window.as_ref().unwrap();
-                window.pre_present_notify();
-                fill::fill_window(window.as_ref());
+                let surface = self.surface.as_mut().unwrap();
+                surface.window().pre_present_notify();
+                fill::fill(surface);
             },
             _ => (),
         }
@@ -122,7 +126,7 @@ impl ApplicationHandler for ControlFlowDemo {
 
     fn about_to_wait(&mut self, event_loop: &dyn ActiveEventLoop) {
         if self.request_redraw && !self.wait_cancelled && !self.close_requested {
-            self.window.as_ref().unwrap().request_redraw();
+            self.surface.as_ref().unwrap().window().request_redraw();
         }
 
         match self.mode {

winit/examples/dnd.rs

@@ -1,9 +1,10 @@
 use std::error::Error;
 
+use softbuffer::{Context, Surface};
 use tracing::info;
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
 use winit::window::{Window, WindowAttributes, WindowId};
 
 #[path = "util/fill.rs"]
@@ -16,27 +17,24 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     let event_loop = EventLoop::new()?;
 
-    let app = Application::new();
+    let app = Application::default();
     Ok(event_loop.run_app(app)?)
 }
 
 /// Application state and event handling.
-#[derive(Debug)]
+#[derive(Default, Debug)]
 struct Application {
-    window: Option<Box<dyn Window>>,
-}
-
-impl Application {
-    fn new() -> Self {
-        Self { window: None }
-    }
+    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
 }
 
 impl ApplicationHandler for Application {
     fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
         let window_attributes =
             WindowAttributes::default().with_title("Drag and drop files on me!");
-        self.window = Some(event_loop.create_window(window_attributes).unwrap());
+        let window = event_loop.create_window(window_attributes).unwrap();
+        let context = Context::new(event_loop.owned_display_handle()).unwrap();
+        let surface = Surface::new(&context, window).unwrap();
+        self.surface = Some(surface);
     }
 
     fn window_event(
@@ -53,9 +51,9 @@ impl ApplicationHandler for Application {
                 info!("{event:?}");
             },
             WindowEvent::RedrawRequested => {
-                let window = self.window.as_ref().unwrap();
-                window.pre_present_notify();
-                fill::fill_window(window.as_ref());
+                let surface = self.surface.as_mut().unwrap();
+                surface.window().pre_present_notify();
+                fill::fill(surface);
             },
             WindowEvent::CloseRequested => {
                 event_loop.exit();

winit/examples/ime.rs

@@ -9,10 +9,11 @@ use std::cmp;
 use std::error::Error;
 
 use dpi::{LogicalPosition, PhysicalSize};
+use softbuffer::{Context, Surface};
 use tracing::{error, info};
 use winit::application::ApplicationHandler;
 use winit::event::{Ime, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
 use winit::keyboard::{Key, ModifiersState, NamedKey};
 #[cfg(web_platform)]
 use winit::platform::web::WindowAttributesWeb;
@@ -30,7 +31,7 @@ const IME_CURSOR_SIZE: PhysicalSize<u32> = PhysicalSize::new(20, 20);
 
 #[derive(Debug)]
 struct App {
-    window: Option<Box<dyn Window>>,
+    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
     input_state: TextInputState,
     modifiers: ModifiersState,
 }
@@ -73,14 +74,12 @@ impl ApplicationHandler for App {
         #[cfg(web_platform)]
         let window_attributes = WindowAttributes::default()
             .with_platform_attributes(Box::new(WindowAttributesWeb::default().with_append(true)));
-        self.window = match event_loop.create_window(window_attributes) {
-            Ok(window) => Some(window),
-            Err(err) => {
-                error!("error creating window: {err}");
-                event_loop.exit();
-                return;
-            },
-        };
+        let window = event_loop.create_window(window_attributes).expect("failed creating window");
+
+        let context =
+            Context::new(event_loop.owned_display_handle()).expect("failed creating context");
+        let surface = Surface::new(&context, window).expect("failed creating surface");
+        self.surface = Some(surface);
 
         // Allow IME out of the box.
         let enable_request = ImeEnableRequest::new(
@@ -101,11 +100,13 @@ impl ApplicationHandler for App {
         match event {
             WindowEvent::CloseRequested => {
                 info!("Close was requested; stopping");
-                self.window = None;
+                self.surface = None;
                 event_loop.exit();
             },
-            WindowEvent::SurfaceResized(_) => {
-                self.window.as_ref().expect("resize event without a window").request_redraw();
+            WindowEvent::SurfaceResized(surface_size) => {
+                let surface = self.surface.as_mut().expect("resize event without a surface");
+                fill::resize(surface, surface_size);
+                surface.window().request_redraw();
             },
             WindowEvent::RedrawRequested => {
                 // Redraw the application.
@@ -114,13 +115,13 @@ impl ApplicationHandler for App {
                 // this event rather than in AboutToWait, since rendering in here allows
                 // the program to gracefully handle redraws requested by the OS.
 
-                let window = self.window.as_ref().expect("redraw request without a window");
+                let surface = self.surface.as_mut().expect("redraw event without a surface");
 
                 // Notify that you're about to draw.
-                window.pre_present_notify();
+                surface.window().pre_present_notify();
 
                 // Draw.
-                fill::fill_window(window.as_ref());
+                fill::fill(surface);
 
                 // For contiguous redraw loop you can request a redraw from here.
                 // window.request_redraw();
@@ -214,14 +215,14 @@ impl App {
     }
 
     fn handle_ime_event(&mut self, event: Ime) {
-        let window = self.window.as_ref().expect("IME request without a window");
+        let surface = self.surface.as_ref().expect("IME request without a window");
         match event {
-            Ime::Enabled => info!("IME enabled for Window={:?}", window.id()),
+            Ime::Enabled => info!("IME enabled for Window={:?}", surface.window().id()),
             Ime::Preedit(text, caret_pos) => info!("Preedit: {text}, with caret at {caret_pos:?}"),
             Ime::Commit(text) => {
                 self.input_state.append_text(&text);
                 let request_data = self.get_ime_update();
-                window.request_ime_update(ImeRequest::Update(request_data)).unwrap();
+                surface.window().request_ime_update(ImeRequest::Update(request_data)).unwrap();
                 self.print_input_state();
             },
             Ime::DeleteSurrounding { before_bytes, after_bytes } => {
@@ -246,7 +247,7 @@ impl App {
                     error!("Buggy IME tried to delete with indices not on char boundary.");
                 }
             },
-            Ime::Disabled => info!("IME disabled for Window={:?}", window.id()),
+            Ime::Disabled => info!("IME disabled for Window={:?}", surface.window().id()),
         }
     }
 
@@ -312,7 +313,7 @@ impl App {
     }
 
     fn window(&self) -> &dyn Window {
-        self.window.as_ref().unwrap().as_ref()
+        self.surface.as_ref().unwrap().window().as_ref()
     }
 }
 
@@ -355,7 +356,7 @@ Use CTRL+h to cycle content hint permutations.
     );
 
     let app = App {
-        window: None,
+        surface: None,
         input_state: TextInputState {
             ime_enabled: true,
             contents: String::new(),

winit/examples/pump_events.rs

@@ -7,11 +7,12 @@ fn main() -> std::process::ExitCode {
     use std::thread::sleep;
     use std::time::Duration;
 
+    use softbuffer::{Context, Surface};
     use tracing::info;
     use winit::application::ApplicationHandler;
     use winit::event::WindowEvent;
     use winit::event_loop::pump_events::{EventLoopExtPumpEvents, PumpStatus};
-    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
     use winit::window::{Window, WindowAttributes, WindowId};
 
     #[path = "util/fill.rs"]
@@ -21,13 +22,16 @@ fn main() -> std::process::ExitCode {
 
     #[derive(Default, Debug)]
     struct PumpDemo {
-        window: Option<Box<dyn Window>>,
+        surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
     }
 
     impl ApplicationHandler for PumpDemo {
         fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
             let window_attributes = WindowAttributes::default().with_title("A fantastic window!");
-            self.window = Some(event_loop.create_window(window_attributes).unwrap());
+            let window = event_loop.create_window(window_attributes).unwrap();
+
+            let context = Context::new(event_loop.owned_display_handle()).unwrap();
+            self.surface = Some(Surface::new(&context, window).unwrap());
         }
 
         fn window_event(
@@ -38,16 +42,16 @@ fn main() -> std::process::ExitCode {
         ) {
             info!("{event:?}");
 
-            let window = match self.window.as_ref() {
-                Some(window) => window,
+            let surface = match self.surface.as_mut() {
+                Some(surface) => surface,
                 None => return,
             };
 
             match event {
                 WindowEvent::CloseRequested => event_loop.exit(),
                 WindowEvent::RedrawRequested => {
-                    fill::fill_window(window.as_ref());
-                    window.request_redraw();
+                    fill::fill(surface);
+                    surface.window().request_redraw();
                 },
                 _ => (),
             }

winit/examples/run_on_demand.rs

@@ -5,11 +5,12 @@
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     use std::time::Duration;
 
+    use softbuffer::{Context, Surface};
     use tracing::info;
     use winit::application::ApplicationHandler;
     use winit::event::WindowEvent;
     use winit::event_loop::run_on_demand::EventLoopExtRunOnDemand;
-    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
     use winit::window::{Window, WindowAttributes, WindowId};
 
     #[path = "util/fill.rs"]
@@ -17,27 +18,30 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     #[path = "util/tracing.rs"]
     mod tracing;
 
-    #[derive(Default, Debug)]
+    #[derive(Debug)]
     struct App {
+        context: Context<OwnedDisplayHandle>,
         idx: usize,
+        surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
         window_id: Option<WindowId>,
-        window: Option<Box<dyn Window>>,
     }
 
     impl ApplicationHandler for App {
         fn about_to_wait(&mut self, _event_loop: &dyn ActiveEventLoop) {
-            if let Some(window) = self.window.as_ref() {
-                window.request_redraw();
+            if let Some(surface) = self.surface.as_ref() {
+                surface.window().request_redraw();
             }
         }
 
         fn can_create_surfaces(&mut self, event_loop: &dyn ActiveEventLoop) {
             let window_attributes = WindowAttributes::default()
-                .with_title("Fantastic window number one!")
+                .with_title(format!("Fantastic window number {}!", self.idx))
                 .with_surface_size(winit::dpi::LogicalSize::new(128.0, 128.0));
             let window = event_loop.create_window(window_attributes).unwrap();
             self.window_id = Some(window.id());
-            self.window = Some(window);
+
+            let surface = Surface::new(&self.context, window).unwrap();
+            self.surface = Some(surface);
         }
 
         fn window_event(
@@ -53,19 +57,17 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 return;
             }
 
-            let window = match self.window.as_mut() {
-                Some(window) => window,
-                None => return,
+            let Some(surface) = self.surface.as_mut() else {
+                return;
             };
 
             match event {
                 WindowEvent::CloseRequested => {
                     info!("Window {} CloseRequested", self.idx);
-                    fill::cleanup_window(window.as_ref());
-                    self.window = None;
+                    self.surface = None;
                 },
                 WindowEvent::RedrawRequested => {
-                    fill::fill_window(window.as_ref());
+                    fill::fill(surface);
                 },
                 _ => (),
             }
@@ -76,7 +78,8 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let mut event_loop = EventLoop::new().unwrap();
 
-    let mut app = App { idx: 1, ..Default::default() };
+    let context = Context::new(event_loop.owned_display_handle()).unwrap();
+    let mut app = App { context, idx: 1, surface: None, window_id: None };
     event_loop.run_app_on_demand(&mut app)?;
 
     info!("Finished first loop");

winit/examples/util/fill.rs

@@ -1,115 +1,43 @@
-//! Fill the window buffer with a solid color.
-//!
-//! Launching a window without drawing to it has unpredictable results varying from platform to
-//! platform. In order to have well-defined examples, this module provides an easy way to
-//! fill the window buffer with a solid color.
-//!
-//! The `softbuffer` crate is used, largely because of its ease of use. `glutin` or `wgpu` could
-//! also be used to fill the window buffer, but they are more complicated to use.
-
-use std::cell::RefCell;
-use std::collections::HashMap;
-use std::mem;
-use std::mem::ManuallyDrop;
 use std::num::NonZeroU32;
-#[cfg(not(web_platform))]
-use std::time::Instant;
 
-use softbuffer::{Context, Surface};
-#[cfg(web_platform)]
-use web_time::Instant;
-use winit::window::{Window, WindowId};
+use rwh_06::{HasDisplayHandle, HasWindowHandle};
+use softbuffer::Surface;
+use winit::window::Window;
 
-thread_local! {
-    // NOTE: You should never do things like that, create context and drop it before
-    // you drop the event loop. We do this for brevity to not blow up examples. We use
-    // ManuallyDrop to prevent destructors from running.
+/// Resize the surface.
+pub fn resize(
+    surface: &mut Surface<impl HasDisplayHandle, impl HasWindowHandle>,
+    surface_size: dpi::PhysicalSize<u32>,
+) {
+    // Handle zero-sized buffers.
     //
-    // A static, thread-local map of graphics contexts to open windows.
-    static GC: ManuallyDrop<RefCell<Option<GraphicsContext>>> = const { ManuallyDrop::new(RefCell::new(None)) };
+    // FIXME(madsmtm): This should be done by softbuffer internally in the future:
+    // https://github.com/rust-windowing/softbuffer/issues/238
+    let (Some(width), Some(height)) =
+        (NonZeroU32::new(surface_size.width), NonZeroU32::new(surface_size.height))
+    else {
+        return;
+    };
+
+    surface.resize(width, height).expect("Failed to resize the softbuffer surface");
 }
 
-/// The graphics context used to draw to a window.
-struct GraphicsContext {
-    /// The global softbuffer context.
-    context: RefCell<Context<&'static dyn Window>>,
+/// Fill the window buffer with a solid color.
+pub fn fill_with_color(
+    surface: &mut Surface<impl HasDisplayHandle, impl HasWindowHandle + AsRef<dyn Window>>,
+    color: u32,
+) {
+    let surface_size = surface.window().as_ref().surface_size();
+    resize(surface, surface_size);
 
-    /// The hash map of window IDs to surfaces.
-    surfaces: HashMap<WindowId, Surface<&'static dyn Window, &'static dyn Window>>,
-}
-
-impl GraphicsContext {
-    fn new(w: &dyn Window) -> Self {
-        Self {
-            context: RefCell::new(
-                Context::new(unsafe { mem::transmute::<&'_ dyn Window, &'static dyn Window>(w) })
-                    .expect("Failed to create a softbuffer context"),
-            ),
-            surfaces: HashMap::new(),
-        }
-    }
-
-    fn create_surface(
-        &mut self,
-        window: &dyn Window,
-    ) -> &mut Surface<&'static dyn Window, &'static dyn Window> {
-        self.surfaces.entry(window.id()).or_insert_with(|| {
-            Surface::new(&self.context.borrow(), unsafe {
-                mem::transmute::<&'_ dyn Window, &'static dyn Window>(window)
-            })
-            .expect("Failed to create a softbuffer surface")
-        })
-    }
-
-    fn destroy_surface(&mut self, window: &dyn Window) {
-        self.surfaces.remove(&window.id());
-    }
-}
-
-pub fn fill_window_with_color(window: &dyn Window, color: u32) {
-    GC.with(|gc| {
-        let size = window.surface_size();
-        let (Some(width), Some(height)) =
-            (NonZeroU32::new(size.width), NonZeroU32::new(size.height))
-        else {
-            return;
-        };
-
-        // Either get the last context used or create a new one.
-        let mut gc = gc.borrow_mut();
-        let surface = gc.get_or_insert_with(|| GraphicsContext::new(window)).create_surface(window);
-
-        // Fill a buffer with a solid color
-
-        surface.resize(width, height).expect("Failed to resize the softbuffer surface");
-
-        let mut buffer = surface.buffer_mut().expect("Failed to get the softbuffer buffer");
-        buffer.fill(color);
-        buffer.present().expect("Failed to present the softbuffer buffer");
-    })
+    let mut buffer = surface.buffer_mut().expect("Failed to get the softbuffer buffer");
+    buffer.fill(color);
+    buffer.present().expect("Failed to present the softbuffer buffer");
 }
 
 #[allow(dead_code)]
-pub fn fill_window(window: &dyn Window) {
-    fill_window_with_color(window, 0xff181818);
-}
-
-#[allow(dead_code)]
-pub fn fill_window_with_animated_color(window: &dyn Window, start: Instant) {
-    let time = start.elapsed().as_secs_f32() * 1.5;
-    let blue = (time.sin() * 255.0) as u32;
-    let green = ((time.cos() * 255.0) as u32) << 8;
-    let red = ((1.0 - time.sin() * 255.0) as u32) << 16;
-    let color = red | green | blue;
-    fill_window_with_color(window, color);
-}
-
-#[allow(dead_code)]
-pub fn cleanup_window(window: &dyn Window) {
-    GC.with(|gc| {
-        let mut gc = gc.borrow_mut();
-        if let Some(context) = gc.as_mut() {
-            context.destroy_surface(window);
-        }
-    });
+pub fn fill(
+    surface: &mut Surface<impl HasDisplayHandle, impl HasWindowHandle + AsRef<dyn Window>>,
+) {
+    fill_with_color(surface, 0xff181818);
 }

winit/examples/window.rs

@@ -2,10 +2,11 @@
 
 use std::error::Error;
 
-use tracing::{error, info};
+use softbuffer::{Context, Surface};
+use tracing::info;
 use winit::application::ApplicationHandler;
 use winit::event::WindowEvent;
-use winit::event_loop::{ActiveEventLoop, EventLoop};
+use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
 #[cfg(web_platform)]
 use winit::platform::web::WindowAttributesWeb;
 use winit::window::{Window, WindowAttributes, WindowId};
@@ -17,7 +18,7 @@ mod tracing;
 
 #[derive(Default, Debug)]
 struct App {
-    window: Option<Box<dyn Window>>,
+    surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
 }
 
 impl ApplicationHandler for App {
@@ -27,14 +28,12 @@ impl ApplicationHandler for App {
         #[cfg(web_platform)]
         let window_attributes = WindowAttributes::default()
             .with_platform_attributes(Box::new(WindowAttributesWeb::default().with_append(true)));
-        self.window = match event_loop.create_window(window_attributes) {
-            Ok(window) => Some(window),
-            Err(err) => {
-                error!("error creating window: {err}");
-                event_loop.exit();
-                return;
-            },
-        }
+        let window = event_loop.create_window(window_attributes).expect("failed creating window");
+
+        let context =
+            Context::new(event_loop.owned_display_handle()).expect("failed creating context");
+        let surface = Surface::new(&context, window).expect("failed creating surface");
+        self.surface = Some(surface);
     }
 
     fn window_event(&mut self, event_loop: &dyn ActiveEventLoop, _: WindowId, event: WindowEvent) {
@@ -44,8 +43,10 @@ impl ApplicationHandler for App {
                 info!("Close was requested; stopping");
                 event_loop.exit();
             },
-            WindowEvent::SurfaceResized(_) => {
-                self.window.as_ref().expect("resize event without a window").request_redraw();
+            WindowEvent::SurfaceResized(surface_size) => {
+                let surface = self.surface.as_mut().expect("resize event without a surface");
+                fill::resize(surface, surface_size);
+                surface.window().request_redraw();
             },
             WindowEvent::RedrawRequested => {
                 // Redraw the application.
@@ -54,13 +55,15 @@ impl ApplicationHandler for App {
                 // this event rather than in AboutToWait, since rendering in here allows
                 // the program to gracefully handle redraws requested by the OS.
 
-                let window = self.window.as_ref().expect("redraw request without a window");
+                let surface = self.surface.as_mut().expect("redraw event without a surface");
 
                 // Notify that you're about to draw.
-                window.pre_present_notify();
+                surface.window().pre_present_notify();
 
                 // Draw.
-                fill::fill_window(window.as_ref());
+                let mut buffer = surface.buffer_mut().expect("Failed to get the softbuffer buffer");
+                buffer.fill(0xff181818);
+                buffer.present().expect("Failed to present the softbuffer buffer");
 
                 // For contiguous redraw loop you can request a redraw from here.
                 // window.request_redraw();

winit/examples/x11_embed.rs

@@ -3,9 +3,10 @@ use std::error::Error;
 
 #[cfg(x11_platform)]
 fn main() -> Result<(), Box<dyn Error>> {
+    use softbuffer::{Context, Surface};
     use winit::application::ApplicationHandler;
     use winit::event::WindowEvent;
-    use winit::event_loop::{ActiveEventLoop, EventLoop};
+    use winit::event_loop::{ActiveEventLoop, EventLoop, OwnedDisplayHandle};
     use winit::platform::x11::WindowAttributesX11;
     use winit::window::{Window, WindowAttributes, WindowId};
 
@@ -17,7 +18,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     #[derive(Debug)]
     pub struct XEmbedDemo {
         parent_window_id: u32,
-        window: Option<Box<dyn Window>>,
+        surface: Option<Surface<OwnedDisplayHandle, Box<dyn Window>>>,
     }
 
     impl ApplicationHandler for XEmbedDemo {
@@ -29,7 +30,10 @@ fn main() -> Result<(), Box<dyn Error>> {
                 WindowAttributesX11::default().with_embed_parent_window(self.parent_window_id);
             window_attributes = window_attributes.with_platform_attributes(Box::new(x11_attrs));
 
-            self.window = Some(event_loop.create_window(window_attributes).unwrap());
+            let window = event_loop.create_window(window_attributes).unwrap();
+            let context = Context::new(event_loop.owned_display_handle()).unwrap();
+            let surface = Surface::new(&context, window).unwrap();
+            self.surface = Some(surface);
         }
 
         fn window_event(
@@ -38,19 +42,19 @@ fn main() -> Result<(), Box<dyn Error>> {
             _window_id: WindowId,
             event: WindowEvent,
         ) {
-            let window = self.window.as_ref().unwrap();
             match event {
                 WindowEvent::CloseRequested => event_loop.exit(),
                 WindowEvent::RedrawRequested => {
-                    window.pre_present_notify();
-                    fill::fill_window(window.as_ref());
+                    let surface = self.surface.as_mut().unwrap();
+                    surface.window().pre_present_notify();
+                    fill::fill(surface);
                 },
                 _ => (),
             }
         }
 
         fn about_to_wait(&mut self, _event_loop: &dyn ActiveEventLoop) {
-            self.window.as_ref().unwrap().request_redraw();
+            self.surface.as_ref().unwrap().window().request_redraw();
         }
     }
 
@@ -63,7 +67,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     tracing::init();
     let event_loop = EventLoop::new()?;
 
-    Ok(event_loop.run_app(XEmbedDemo { parent_window_id, window: None })?)
+    Ok(event_loop.run_app(XEmbedDemo { parent_window_id, surface: None })?)
 }
 
 #[cfg(not(x11_platform))]

winit/src/changelog/unreleased.md

@@ -47,16 +47,23 @@ changelog entry.
 - On Redox, add support for missing keyboard scancodes.
 - Implement `Send` and `Sync` for `OwnedDisplayHandle`.
 - Use new macOS 15 cursors for resize icons.
+- On Android, added scancode conversions for more obscure key codes.
+- On Wayland, added `HoldGesture` event for multi-finger hold gestures
+- On Wayland, added ext-background-effect-v1 support.
 
 ### Changed
 
 - Updated `windows-sys` to `v0.61`.
 - On older macOS versions (tested up to 12.7.6), applications now receive mouse movement events for unfocused windows, matching the behavior on other platforms.
-- On macOS, the application is now launched in `EventLoop::new` instead of `EventLoop::run_app`. If you're registering a custom delegate, you should now register it before `EventLoop::new`.
 
 ### Fixed
 
+- On Windows, fix a freeze that occurs when the keyboard layout is switched by
+  tools such as Punto Switcher. The `WM_INPUTLANGCHANGE` message is now handled
+  to refresh the cached keyboard layout, while still deferring to
+  `DefWindowProc` for normal propagation.
 - On Redox, handle `EINTR` when reading from `event_socket` instead of panicking.
 - On Wayland, switch from using the `ahash` hashing algorithm to `foldhash`.
 - On macOS, fix borderless game presentation options not sticking after switching spaces.
 - On macOS, fix IME being locked on (regardless of requests to disable) after being enabled once.
+- On macOS, fix a panic and incorrect cursor position in Ime::Preedit when the preedit string contains special characters (ie. emojis) caused by incorrect UTF-16 to UTF-8 offset conversion.

winit/src/event_loop.rs

@@ -29,7 +29,7 @@ use crate::platform_impl;
 ///
 /// To wake up an `EventLoop` from a another thread, see the [`EventLoopProxy`] docs.
 ///
-/// Note that this cannot be shared across threads (due to platform-dependant logic
+/// Note that this cannot be shared across threads (due to platform-dependent logic
 /// forbidding it), as such it is neither [`Send`] nor [`Sync`]. If you need cross-thread access,
 /// the [`Window`] created from this _can_ be sent to an other thread, and the
 /// [`EventLoopProxy`] allows you to wake up an `EventLoop` from another thread.
@@ -75,9 +75,6 @@ impl EventLoopBuilder {
     ///   `DISPLAY` respectively when building the event loop.
     /// - **Android:** must be configured with an `AndroidApp` from `android_main()` by calling
     ///   [`.with_android_app(app)`] before calling `.build()`, otherwise it'll panic.
-    /// - **macOS:** this will launch the application, so if you want to register a custom delegate,
-    ///   or otherwise do stuff before `applicationDidFinishLaunching:`, you should do it before
-    ///   this function is called.
     ///
     /// [`platform`]: crate::platform
     #[cfg_attr(