Winit version 0.29.3

Wayland scales each window individually, thus make it clear. Also
recommend against using the `MonitorHandle::scale_factor`.

Fixes #3183.

CHANGELOG.md

@@ -11,6 +11,17 @@ Unreleased` header.
 
 # Unreleased
 
+# 0.29.3
+
+- On Wayland, apply correct scale to `PhysicalSize` passed in `WindowBuilder::with_inner_size` when possible.
+- On Wayland, fix `RedrawRequsted` being always sent without decorations and `sctk-adwaita` feature.
+- On Wayland, ignore resize requests when the window is fully tiled.
+- On Wayland, use `configure_bounds` to constrain `with_inner_size` when compositor wants users to pick size.
+- On Windows, fix deadlock when accessing the state during `Cursor{Enter,Leave}`.
+- On Windows, add support for `Window::set_transparent`.
+- On macOS, fix deadlock when entering a nested event loop from an event handler.
+- On macOS, add support for `Window::set_blur`.
+
 # 0.29.2
 
 - **Breaking:** Bump MSRV from `1.60` to `1.65`.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "winit"
-version = "0.29.2"
+version = "0.29.3"
 authors = ["The winit contributors", "Pierre Krieger <pierre.krieger1708@gmail.com>"]
 description = "Cross-platform window creation library."
 edition = "2021"

README.md

@@ -6,7 +6,7 @@
 
 ```toml
 [dependencies]
-winit = "0.29.2"
+winit = "0.29.3"
 ```
 
 ## [Documentation](https://docs.rs/winit)
@@ -116,7 +116,7 @@ clash.
 
 | winit |       ndk-glue               |
 | :---: | :--------------------------: |
-| 0.29.2| `android-activity = "0.5"`   |
+| 0.29  | `android-activity = "0.5"`   |
 | 0.28  | `android-activity = "0.4"`   |
 | 0.27  | `ndk-glue = "0.7"`           |
 | 0.26  | `ndk-glue = "0.5"`           |
@@ -157,7 +157,7 @@ For more details, refer to these `android-activity` [example applications](https
 
 If your application is currently based on `NativeActivity` via the `ndk-glue` crate and building with `cargo apk` then the minimal changes would be:
 1. Remove `ndk-glue` from your `Cargo.toml`
-2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.2", features = [ "android-native-activity" ] }`
+2. Enable the `"android-native-activity"` feature for Winit: `winit = { version = "0.29.3", features = [ "android-native-activity" ] }`
 3. Add an `android_main` entrypoint (as above), instead of using the '`[ndk_glue::main]` proc macro from `ndk-macros` (optionally add a dependency on `android_logger` and initialize logging as above).
 4. Pass a clone of the `AndroidApp` that your application receives to Winit when building your event loop (as shown above).
 

src/dpi.rs

@@ -82,7 +82,8 @@
 //!   If `WINIT_X11_SCALE_FACTOR` is set to `randr`, it'll ignore the `Xft.dpi` field and use the
 //!   XRandR scaling method. Generally speaking, you should try to configure the standard system
 //!   variables to do what you want before resorting to `WINIT_X11_SCALE_FACTOR`.
-//! - **Wayland:** Scale factor is suggested by the the compositor.
+//! - **Wayland:** Scale factor is suggested by the compositor for each window individually. The
+//!   monitor scale factor may differ from the window scale factor.
 //! - **iOS:** Scale factors are set by Apple to the value that best suits the device, and range
 //!   from `1.0` to `3.0`. See [this article][apple_1] and [this article][apple_2] for more
 //!   information.

src/event_loop.rs

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

src/lib.rs

@@ -26,16 +26,36 @@
 //! window or a key getting pressed while the window is focused. Devices can generate
 //! [`DeviceEvent`]s, which contain unfiltered event data that isn't specific to a certain window.
 //! Some user activity, like mouse movement, can generate both a [`WindowEvent`] *and* a
-//! [`DeviceEvent`]. You can also create and handle your own custom [`UserEvent`]s, if desired.
+//! [`DeviceEvent`]. You can also create and handle your own custom [`Event::UserEvent`]s, if desired.
 //!
-//! You can retrieve events by calling [`EventLoop::run`][event_loop_run]. This function will
+//! You can retrieve events by calling [`EventLoop::run()`]. This function will
 //! dispatch events for every [`Window`] that was created with that particular [`EventLoop`], and
-//! will run until [`exit()`] is used, at which point [`Event`]`::`[`LoopExiting`].
+//! will run until [`exit()`] is used, at which point [`Event::LoopExiting`].
 //!
 //! Winit no longer uses a `EventLoop::poll_events() -> impl Iterator<Event>`-based event loop
 //! model, since that can't be implemented properly on some platforms (e.g web, iOS) and works poorly on
 //! most other platforms. However, this model can be re-implemented to an extent with
-//! [`EventLoopExtPumpEvents::pump_events`]. See that method's documentation for more reasons about why
+#![cfg_attr(
+    any(
+        windows_platform,
+        macos_platform,
+        android_platform,
+        x11_platform,
+        wayland_platform
+    ),
+    doc = "[`EventLoopExtPumpEvents::pump_events()`][platform::pump_events::EventLoopExtPumpEvents::pump_events()]"
+)]
+#![cfg_attr(
+    not(any(
+        windows_platform,
+        macos_platform,
+        android_platform,
+        x11_platform,
+        wayland_platform
+    )),
+    doc = "`EventLoopExtPumpEvents::pump_events()`"
+)]
+//! [^1]. See that method's documentation for more reasons about why
 //! it's discouraged, beyond compatibility reasons.
 //!
 //!
@@ -92,8 +112,8 @@
 //! });
 //! ```
 //!
-//! [`Event`]`::`[`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
-//! compared to the value returned by [`Window::id()`][window_id_fn] to determine which [`Window`]
+//! [`WindowEvent`] has a [`WindowId`] member. In multi-window environments, it should be
+//! compared to the value returned by [`Window::id()`] to determine which [`Window`]
 //! dispatched the event.
 //!
 //! # Drawing on the window
@@ -101,7 +121,7 @@
 //! Winit doesn't directly provide any methods for drawing on a [`Window`]. However it allows you to
 //! retrieve the raw handle of the window and display (see the [`platform`] module and/or the
 //! [`raw_window_handle`] and [`raw_display_handle`] methods), which in turn allows
-//!  you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
+//! you to create an OpenGL/Vulkan/DirectX/Metal/etc. context that can be used to render graphics.
 //!
 //! Note that many platforms will display garbage data in the window's client area if the
 //! application doesn't render anything to the window by the time the desktop compositor is ready to
@@ -110,9 +130,8 @@
 //! window visible only once you're ready to render into it.
 //!
 //! [`EventLoop`]: event_loop::EventLoop
-//! [`EventLoopExtPumpEvents::pump_events`]: ./platform/pump_events/trait.EventLoopExtPumpEvents.html#tymethod.pump_events
 //! [`EventLoop::new()`]: event_loop::EventLoop::new
-//! [event_loop_run]: event_loop::EventLoop::run
+//! [`EventLoop::run()`]: event_loop::EventLoop::run
 //! [`exit()`]: event_loop::EventLoopWindowTarget::exit
 //! [`Window`]: window::Window
 //! [`WindowId`]: window::WindowId
@@ -120,15 +139,14 @@
 //! [window_new]: window::Window::new
 //! [window_builder_new]: window::WindowBuilder::new
 //! [window_builder_build]: window::WindowBuilder::build
-//! [window_id_fn]: window::Window::id
-//! [`Event`]: event::Event
+//! [`Window::id()`]: window::Window::id
 //! [`WindowEvent`]: event::WindowEvent
 //! [`DeviceEvent`]: event::DeviceEvent
-//! [`UserEvent`]: event::Event::UserEvent
-//! [`LoopExiting`]: event::Event::LoopExiting
-//! [`platform`]: platform
+//! [`Event::UserEvent`]: event::Event::UserEvent
+//! [`Event::LoopExiting`]: event::Event::LoopExiting
 //! [`raw_window_handle`]: ./window/struct.Window.html#method.raw_window_handle
 //! [`raw_display_handle`]: ./window/struct.Window.html#method.raw_display_handle
+//! [^1]: `EventLoopExtPumpEvents::pump_events()` is only available on Windows, macOS, Android, X11 and Wayland.
 
 #![deny(rust_2018_idioms)]
 #![deny(rustdoc::broken_intra_doc_links)]

src/monitor.rs

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

src/platform/run_on_demand.rs

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

src/platform/web.rs

@@ -109,13 +109,28 @@ pub trait EventLoopExtWebSys {
 
     /// Initializes the winit event loop.
     ///
-    /// Unlike `run`, this returns immediately, and doesn't throw an exception in order to
-    /// satisfy its `!` return type.
+    /// Unlike
+    #[cfg_attr(
+        all(wasm_platform, target_feature = "exception-handling"),
+        doc = "`run()`"
+    )]
+    #[cfg_attr(
+        not(all(wasm_platform, target_feature = "exception-handling")),
+        doc = "[`run()`]"
+    )]
+    /// [^1], this returns immediately, and doesn't throw an exception in order to
+    /// satisfy its [`!`] return type.
     ///
     /// Once the event loop has been destroyed, it's possible to reinitialize another event loop
     /// by calling this function again. This can be useful if you want to recreate the event loop
     /// while the WebAssembly module is still loaded. For example, this can be used to recreate the
     /// event loop when switching between tabs on a single page application.
+    ///
+    #[cfg_attr(
+        not(all(wasm_platform, target_feature = "exception-handling")),
+        doc = "[`run()`]: EventLoop::run()"
+    )]
+    /// [^1]: `run()` is _not_ available on WASM when the target supports `exception-handling`.
     fn spawn<F>(self, event_handler: F)
     where
         F: 'static + FnMut(Event<Self::UserEvent>, &EventLoopWindowTarget<Self::UserEvent>);

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

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

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

@@ -97,11 +97,9 @@ impl Window {
             .map(|activation_state| activation_state.global().clone());
         let display = event_loop_window_target.connection.display();
 
-        // XXX The initial scale factor must be 1, but it might cause sizing issues on HiDPI.
-        let size: LogicalSize<u32> = attributes
+        let size: Size = attributes
             .inner_size
-            .map(|size| size.to_logical::<u32>(1.))
-            .unwrap_or((800, 600).into());
+            .unwrap_or(LogicalSize::new(800., 600.).into());
 
         // We prefer server side decorations, however to not have decorations we ask for client
         // side decorations instead.
@@ -141,7 +139,8 @@ impl Window {
         // Set the window title.
         window_state.set_title(attributes.title);
 
-        // Set the min and max sizes.
+        // Set the min and max sizes. We must set the hints upon creating a window, so
+        // we use the default `1.` scaling...
         let min_size = attributes.min_inner_size.map(|size| size.to_logical(1.));
         let max_size = attributes.max_inner_size.map(|size| size.to_logical(1.));
         window_state.set_min_inner_size(min_size);
@@ -315,12 +314,9 @@ impl Window {
     #[inline]
     pub fn request_inner_size(&self, size: Size) -> Option<PhysicalSize<u32>> {
         let mut window_state = self.window_state.lock().unwrap();
-        let scale_factor = window_state.scale_factor();
-        window_state.resize(size.to_logical::<u32>(scale_factor));
-
+        let new_size = window_state.request_inner_size(size);
         self.request_redraw();
-
-        Some(window_state.inner_size().to_physical(scale_factor))
+        Some(new_size)
     }
 
     /// Set the minimum inner size for the window.

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

@@ -28,7 +28,7 @@ use sctk::shm::Shm;
 use sctk::subcompositor::SubcompositorState;
 use wayland_protocols_plasma::blur::client::org_kde_kwin_blur::OrgKdeKwinBlur;
 
-use crate::dpi::{LogicalPosition, LogicalSize};
+use crate::dpi::{LogicalPosition, LogicalSize, PhysicalSize, Size};
 use crate::error::{ExternalError, NotSupportedError};
 use crate::event::WindowEvent;
 use crate::platform_impl::wayland::event_loop::sink::EventSink;
@@ -133,6 +133,10 @@ pub struct WindowState {
     /// sends `None` for the new size in the configure.
     stateless_size: LogicalSize<u32>,
 
+    /// Initial window size provided by the user. Removed on the first
+    /// configure.
+    initial_size: Option<Size>,
+
     /// The state of the frame callback.
     frame_callback_state: FrameCallbackState,
 
@@ -153,7 +157,7 @@ impl WindowState {
         connection: Connection,
         queue_handle: &QueueHandle<WinitState>,
         winit_state: &WinitState,
-        size: LogicalSize<u32>,
+        initial_size: Size,
         window: Window,
         theme: Option<Theme>,
     ) -> Self {
@@ -194,8 +198,9 @@ impl WindowState {
             resizable: true,
             scale_factor: 1.,
             shm: winit_state.shm.wl_shm().clone(),
-            size,
-            stateless_size: size,
+            size: initial_size.to_logical(1.),
+            stateless_size: initial_size.to_logical(1.),
+            initial_size: Some(initial_size),
             text_inputs: Vec::new(),
             theme,
             title: String::default(),
@@ -253,6 +258,14 @@ impl WindowState {
         subcompositor: &Arc<SubcompositorState>,
         event_sink: &mut EventSink,
     ) -> LogicalSize<u32> {
+        // NOTE: when using fractional scaling or wl_compositor@v6 the scaling
+        // should be delivered before the first configure, thus apply it to
+        // properly scale the physical sizes provided by the users.
+        if let Some(initial_size) = self.initial_size.take() {
+            self.size = initial_size.to_logical(self.scale_factor());
+            self.stateless_size = self.size;
+        }
+
         if configure.decoration_mode == DecorationMode::Client
             && self.frame.is_none()
             && !self.csd_fails
@@ -297,7 +310,7 @@ impl WindowState {
             event_sink.push_window_event(WindowEvent::Occluded(occluded), window_id);
         }
 
-        let new_size = if let Some(frame) = self.frame.as_mut() {
+        let (mut new_size, constrain) = if let Some(frame) = self.frame.as_mut() {
             // Configure the window states.
             frame.update_state(configure.state);
 
@@ -305,22 +318,38 @@ impl WindowState {
                 (Some(width), Some(height)) => {
                     let (width, height) = frame.subtract_borders(width, height);
                     (
-                        width.map(|w| w.get()).unwrap_or(1),
-                        height.map(|h| h.get()).unwrap_or(1),
+                        (
+                            width.map(|w| w.get()).unwrap_or(1),
+                            height.map(|h| h.get()).unwrap_or(1),
+                        )
+                            .into(),
+                        false,
                     )
-                        .into()
                 }
-                (_, _) if stateless => self.stateless_size,
-                _ => self.size,
+                (_, _) if stateless => (self.stateless_size, true),
+                _ => (self.size, true),
             }
         } else {
             match configure.new_size {
-                (Some(width), Some(height)) => (width.get(), height.get()).into(),
-                _ if stateless => self.stateless_size,
-                _ => self.size,
+                (Some(width), Some(height)) => ((width.get(), height.get()).into(), false),
+                _ if stateless => (self.stateless_size, true),
+                _ => (self.size, true),
             }
         };
 
+        // Apply configure bounds only when compositor let the user decide what size to pick.
+        if constrain {
+            let bounds = self.inner_size_bounds(&configure);
+            new_size.width = bounds
+                .0
+                .map(|bound_w| new_size.width.min(bound_w.get()))
+                .unwrap_or(new_size.width);
+            new_size.height = bounds
+                .1
+                .map(|bound_h| new_size.height.min(bound_h.get()))
+                .unwrap_or(new_size.height);
+        }
+
         // XXX Set the configure before doing a resize.
         self.last_configure = Some(configure);
 
@@ -330,6 +359,30 @@ impl WindowState {
         new_size
     }
 
+    /// Compute the bounds for the inner size of the surface.
+    fn inner_size_bounds(
+        &self,
+        configure: &WindowConfigure,
+    ) -> (Option<NonZeroU32>, Option<NonZeroU32>) {
+        let configure_bounds = match configure.suggested_bounds {
+            Some((width, height)) => (NonZeroU32::new(width), NonZeroU32::new(height)),
+            None => (None, None),
+        };
+
+        if let Some(frame) = self.frame.as_ref() {
+            let (width, height) = frame.subtract_borders(
+                configure_bounds.0.unwrap_or(NonZeroU32::new(1).unwrap()),
+                configure_bounds.1.unwrap_or(NonZeroU32::new(1).unwrap()),
+            );
+            (
+                configure_bounds.0.and(width),
+                configure_bounds.1.and(height),
+            )
+        } else {
+            configure_bounds
+        }
+    }
+
     #[inline]
     fn is_stateless(configure: &WindowConfigure) -> bool {
         !(configure.is_maximized() || configure.is_fullscreen() || configure.is_tiled())
@@ -537,7 +590,7 @@ impl WindowState {
     /// Refresh the decorations frame if it's present returning whether the client should redraw.
     pub fn refresh_frame(&mut self) -> bool {
         if let Some(frame) = self.frame.as_mut() {
-            if frame.is_dirty() {
+            if !frame.is_hidden() && frame.is_dirty() {
                 return frame.draw();
             }
         }
@@ -568,8 +621,22 @@ impl WindowState {
         }
     }
 
+    /// Try to resize the window when the user can do so.
+    pub fn request_inner_size(&mut self, inner_size: Size) -> PhysicalSize<u32> {
+        if self
+            .last_configure
+            .as_ref()
+            .map(Self::is_stateless)
+            .unwrap_or(true)
+        {
+            self.resize(inner_size.to_logical(self.scale_factor()))
+        }
+
+        self.inner_size().to_physical(self.scale_factor())
+    }
+
     /// Resize the window to the new inner size.
-    pub fn resize(&mut self, inner_size: LogicalSize<u32>) {
+    fn resize(&mut self, inner_size: LogicalSize<u32>) {
         self.size = inner_size;
 
         // Update the stateless size.

src/platform_impl/linux/x11/ffi.rs

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

src/platform_impl/linux/x11/monitor.rs

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

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

@@ -13,9 +13,7 @@ mod randr;
 mod window_property;
 mod wm;
 
-pub use self::{
-    client_msg::*, geometry::*, hint::*, icon::*, input::*, randr::*, window_property::*, wm::*,
-};
+pub use self::{geometry::*, hint::*, input::*, window_property::*, wm::*};
 
 use std::{
     mem::{self, MaybeUninit},

src/platform_impl/macos/app_state.rs

@@ -494,9 +494,9 @@ impl AppState {
 
         // Return when in callback due to https://github.com/rust-windowing/winit/issues/1779
         if panic_info.is_panicking()
+            || HANDLER.get_in_callback()
             || !HANDLER.have_callback()
             || !HANDLER.is_running()
-            || HANDLER.get_in_callback()
         {
             return;
         }
@@ -601,9 +601,9 @@ impl AppState {
         // XXX: how does it make sense that `get_in_callback()` can ever return `true` here if we're
         // about to return to the `CFRunLoop` to poll for new events?
         if panic_info.is_panicking()
+            || HANDLER.get_in_callback()
             || !HANDLER.have_callback()
             || !HANDLER.is_running()
-            || HANDLER.get_in_callback()
         {
             return;
         }

src/platform_impl/macos/appkit/window.rs

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

src/platform_impl/macos/ffi.rs

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

src/platform_impl/macos/window.rs

@@ -46,6 +46,8 @@ use super::appkit::{
     NSView, NSWindow, NSWindowButton, NSWindowLevel, NSWindowSharingType, NSWindowStyleMask,
     NSWindowTabbingMode, NSWindowTitleVisibility,
 };
+use super::ffi::CGSMainConnectionID;
+use super::ffi::CGSSetWindowBackgroundBlurRadius;
 
 pub(crate) struct Window {
     window: MainThreadBound<Id<WinitWindow>>,
@@ -494,6 +496,10 @@ impl WinitWindow {
             this.setBackgroundColor(&NSColor::clear());
         }
 
+        if attrs.blur {
+            this.set_blur(attrs.blur);
+        }
+
         if let Some(dim) = attrs.min_inner_size {
             this.set_min_inner_size(Some(dim));
         }
@@ -582,7 +588,15 @@ impl WinitWindow {
         self.setOpaque(!transparent)
     }
 
-    pub fn set_blur(&self, _blur: bool) {}
+    pub fn set_blur(&self, blur: bool) {
+        // NOTE: in general we want to specify the blur radius, but the choice of 80
+        // should be a reasonable default.
+        let radius = if blur { 80 } else { 0 };
+        let window_number = self.windowNumber();
+        unsafe {
+            CGSSetWindowBackgroundBlurRadius(CGSMainConnectionID(), window_number, radius);
+        }
+    }
 
     pub fn set_visible(&self, visible: bool) {
         match visible {

src/platform_impl/windows/event_loop.rs

@@ -1465,6 +1465,7 @@ unsafe fn public_window_callback_inner<T: 'static>(
                             .set_cursor_flags(window, |f| f.set(CursorFlags::IN_WINDOW, true))
                             .ok();
 
+                        drop(w);
                         userdata.send_event(Event::WindowEvent {
                             window_id: RootWindowId(WindowId(window)),
                             event: CursorEntered {
@@ -1487,6 +1488,7 @@ unsafe fn public_window_callback_inner<T: 'static>(
                             .set_cursor_flags(window, |f| f.set(CursorFlags::IN_WINDOW, false))
                             .ok();
 
+                        drop(w);
                         userdata.send_event(Event::WindowEvent {
                             window_id: RootWindowId(WindowId(window)),
                             event: CursorLeft {
@@ -1494,12 +1496,13 @@ unsafe fn public_window_callback_inner<T: 'static>(
                             },
                         });
                     }
-                    PointerMoveKind::None => (),
+                    PointerMoveKind::None => drop(w),
                 }
 
                 // handle spurious WM_MOUSEMOVE messages
                 // see https://devblogs.microsoft.com/oldnewthing/20031001-00/?p=42343
                 // and http://debugandconquer.blogspot.com/2015/08/the-cause-of-spurious-mouse-move.html
+                let mut w = userdata.window_state_lock();
                 cursor_moved = w.mouse.last_position != Some(position);
                 w.mouse.last_position = Some(position);
             }

src/platform_impl/windows/window.rs

@@ -126,7 +126,16 @@ impl Window {
         }
     }
 
-    pub fn set_transparent(&self, _transparent: bool) {}
+    pub fn set_transparent(&self, transparent: bool) {
+        let window = self.window.clone();
+        let window_state = Arc::clone(&self.window_state);
+        self.thread_executor.execute_in_thread(move || {
+            let _ = &window;
+            WindowState::set_window_flags(window_state.lock().unwrap(), window.0, |f| {
+                f.set(WindowFlags::TRANSPARENT, transparent)
+            });
+        });
+    }
 
     pub fn set_blur(&self, _blur: bool) {}
 

src/window.rs

@@ -543,14 +543,17 @@ impl Window {
         self.window.maybe_wait_on_main(|w| WindowId(w.id()))
     }
 
-    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and vice versa.
-    ///
-    /// See the [`dpi`](crate::dpi) module for more information.
+    /// Returns the scale factor that can be used to map logical pixels to physical pixels, and
+    /// vice versa.
     ///
     /// Note that this value can change depending on user action (for example if the window is
     /// moved to another screen); as such, tracking [`WindowEvent::ScaleFactorChanged`] events is
     /// the most robust way to track the DPI you need to use to draw.
     ///
+    /// This value may differ from [`MonitorHandle::scale_factor`].
+    ///
+    /// See the [`dpi`](crate::dpi) module for more information.
+    ///
     /// ## Platform-specific
     ///
     /// - **X11:** This respects Xft.dpi, and can be overridden using the `WINIT_X11_SCALE_FACTOR` environment variable.
@@ -904,7 +907,7 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// - **Windows / Web / iOS / Android / Orbital:** Unsupported.
+    /// - **Web / iOS / Android / Orbital:** Unsupported.
     /// - **X11:** Can only be set while building the window, with [`WindowBuilder::with_transparent`].
     #[inline]
     pub fn set_transparent(&self, transparent: bool) {
@@ -918,7 +921,7 @@ impl Window {
     ///
     /// ## Platform-specific
     ///
-    /// - **Android / iOS / macOS / X11 / Web / Windows:** Unsupported.
+    /// - **Android / iOS / X11 / Web / Windows:** Unsupported.
     /// - **Wayland:** Only works with org_kde_kwin_blur_manager protocol.
     #[inline]
     pub fn set_blur(&self, blur: bool) {