feat: Add a safe method for cross-crate interop to winit

CHANGELOG.md

@@ -9,6 +9,7 @@ And please only add new entries to the top of this list, right below the `# Unre
 # Unreleased
 
 - Bump MSRV from `1.60` to `1.64`.
+- Implement the borrowed handle traits from the `raw-window-handle` crate.
 
 # 0.28.3
 

Cargo.toml

@@ -42,8 +42,8 @@ wayland-dlopen = ["sctk/dlopen", "wayland-client/dlopen"]
 wayland-csd-adwaita = ["sctk-adwaita", "sctk-adwaita/ab_glyph"]
 wayland-csd-adwaita-crossfont = ["sctk-adwaita", "sctk-adwaita/crossfont"]
 wayland-csd-adwaita-notitle = ["sctk-adwaita"]
-android-native-activity = [ "android-activity/native-activity" ]
-android-game-activity = [ "android-activity/game-activity" ]
+android-native-activity = ["android-activity/native-activity"]
+android-game-activity = ["android-activity/game-activity"]
 
 [build-dependencies]
 cfg_aliases = "0.1.1"
@@ -54,7 +54,7 @@ instant = { version = "0.1", features = ["wasm-bindgen"] }
 log = "0.4"
 mint = { version = "0.5.6", optional = true }
 once_cell = "1.12"
-raw_window_handle = { package = "raw-window-handle", version = "0.5" }
+raw_window_handle = { package = "raw-window-handle", version = "0.5.2", features = ["std"] }
 serde = { version = "1", optional = true, features = ["serde_derive"] }
 
 [dev-dependencies]

examples/borrowed_window.rs

@@ -0,0 +1,47 @@
+//! Use borrowed window handles in `winit`.
+
+#![allow(clippy::single_match)]
+
+use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
+use simple_logger::SimpleLogger;
+use winit::{
+    event::{Event, WindowEvent},
+    event_loop::EventLoop,
+    window::WindowBuilder,
+};
+
+fn main() {
+    SimpleLogger::new().init().unwrap();
+    let event_loop = EventLoop::new();
+
+    let window = WindowBuilder::new()
+        .with_title("A borrowed window!")
+        .with_inner_size(winit::dpi::LogicalSize::new(128.0, 128.0))
+        .build(&event_loop)
+        .unwrap();
+
+    event_loop.run(move |event, elwt, control_flow| {
+        control_flow.set_wait();
+        println!("{event:?}");
+
+        // Print the display handle.
+        println!("Display handle: {:?}", elwt.display_handle());
+
+        // Print the window handle.
+        match window.window_handle() {
+            Ok(handle) => println!("Window handle: {:?}", handle),
+            Err(_) => println!("Window handle: None"),
+        }
+
+        match event {
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                window_id,
+            } if window_id == window.id() => control_flow.set_exit(),
+            Event::MainEventsCleared => {
+                window.request_redraw();
+            }
+            _ => (),
+        }
+    });
+}

src/event_loop.rs

@@ -13,7 +13,9 @@ use std::{error, fmt};
 
 use instant::{Duration, Instant};
 use once_cell::sync::OnceCell;
-use raw_window_handle::{HasRawDisplayHandle, RawDisplayHandle};
+use raw_window_handle::{
+    DisplayHandle, HandleError, HasDisplayHandle, HasRawDisplayHandle, RawDisplayHandle,
+};
 
 use crate::{event::Event, monitor::MonitorHandle, platform_impl};
 
@@ -48,6 +50,17 @@ pub struct EventLoopWindowTarget<T: 'static> {
     pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
 }
 
+/// Target that provides a handle to the display powering the event loop.
+///
+/// This type allows one to take advantage of the display's capabilities, such as
+/// querying the display's resolution or DPI, without having to create a window. It
+/// implements `HasDisplayHandle`.
+#[derive(Clone)]
+pub struct OwnedDisplayHandle {
+    pub(crate) p: platform_impl::OwnedDisplayHandle,
+    pub(crate) _marker: PhantomData<*mut ()>, // Not Send nor Sync
+}
+
 /// Object that allows building the event loop.
 ///
 /// This is used to make specifying options that affect the whole application
@@ -320,6 +333,12 @@ unsafe impl<T> HasRawDisplayHandle for EventLoop<T> {
     }
 }
 
+impl<T> HasDisplayHandle for EventLoop<T> {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+        self.event_loop.window_target().display_handle()
+    }
+}
+
 impl<T> Deref for EventLoop<T> {
     type Target = EventLoopWindowTarget<T>;
     fn deref(&self) -> &EventLoopWindowTarget<T> {
@@ -367,6 +386,14 @@ impl<T> EventLoopWindowTarget<T> {
         #[cfg(any(x11_platform, wayland_platform, windows))]
         self.p.set_device_event_filter(_filter);
     }
+
+    /// Get an owned handle to the current display.
+    ///
+    /// This handle can be cheaply cloned and used, allowing one to fulfill the `HasDisplayHandle`
+    /// trait bound.
+    pub fn owned_display_handle(&self) -> &OwnedDisplayHandle {
+        self.p.owned_display_handle()
+    }
 }
 
 unsafe impl<T> HasRawDisplayHandle for EventLoopWindowTarget<T> {
@@ -376,6 +403,27 @@ unsafe impl<T> HasRawDisplayHandle for EventLoopWindowTarget<T> {
     }
 }
 
+impl<T> HasDisplayHandle for EventLoopWindowTarget<T> {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+        // SAFETY: The display handle is valid for as long as the window target is.
+        Ok(unsafe { DisplayHandle::borrow_raw(self.raw_display_handle()) })
+    }
+}
+
+unsafe impl HasRawDisplayHandle for OwnedDisplayHandle {
+    /// Returns a [`raw_window_handle::RawDisplayHandle`] for the event loop.
+    fn raw_display_handle(&self) -> RawDisplayHandle {
+        self.p.raw_display_handle()
+    }
+}
+
+impl HasDisplayHandle for OwnedDisplayHandle {
+    fn display_handle(&self) -> Result<DisplayHandle<'_>, HandleError> {
+        // SAFETY: The display handle is valid for as long as the window target is.
+        Ok(unsafe { DisplayHandle::borrow_raw(self.raw_display_handle()) })
+    }
+}
+
 /// Used to send custom events to [`EventLoop`].
 pub struct EventLoopProxy<T: 'static> {
     event_loop_proxy: platform_impl::EventLoopProxy<T>,

src/platform_impl/android/mod.rs

@@ -16,7 +16,7 @@ use android_activity::{
 };
 use once_cell::sync::Lazy;
 use raw_window_handle::{
-    AndroidDisplayHandle, HasRawWindowHandle, RawDisplayHandle, RawWindowHandle,
+    Active, AndroidDisplayHandle, HasRawWindowHandle, RawDisplayHandle, RawWindowHandle,
 };
 
 use crate::platform_impl::Fullscreen;
@@ -340,6 +340,7 @@ impl<T: 'static> EventLoop<T> {
                         &redraw_flag,
                         android_app.create_waker(),
                     ),
+                    active: Arc::new(Active::new()),
                     _marker: std::marker::PhantomData,
                 },
                 _marker: std::marker::PhantomData,
@@ -378,6 +379,11 @@ impl<T: 'static> EventLoop<T> {
 
             match event {
                 MainEvent::InitWindow { .. } => {
+                    // SAFETY: The window is now active.
+                    unsafe {
+                        self.window_target.p.active.set_active();
+                    }
+
                     sticky_exit_callback(
                         event::Event::Resumed,
                         self.window_target(),
@@ -392,6 +398,8 @@ impl<T: 'static> EventLoop<T> {
                         control_flow,
                         callback,
                     );
+
+                    self.window_target.p.active.set_inactive();
                 }
                 MainEvent::WindowResized { .. } => resized = true,
                 MainEvent::RedrawNeeded { .. } => *pending_redraw = true,
@@ -821,6 +829,7 @@ impl<T> EventLoopProxy<T> {
 pub struct EventLoopWindowTarget<T: 'static> {
     app: AndroidApp,
     redraw_requester: RedrawRequester,
+    active: Arc<Active>,
     _marker: std::marker::PhantomData<T>,
 }
 
@@ -838,6 +847,22 @@ impl<T: 'static> EventLoopWindowTarget<T> {
     pub fn raw_display_handle(&self) -> RawDisplayHandle {
         RawDisplayHandle::Android(AndroidDisplayHandle::empty())
     }
+
+    pub fn owned_display_handle(&self) -> &event_loop::OwnedDisplayHandle {
+        &event_loop::OwnedDisplayHandle {
+            p: OwnedDisplayHandle,
+            _marker: std::marker::PhantomData,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct OwnedDisplayHandle;
+
+impl OwnedDisplayHandle {
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        RawDisplayHandle::Android(AndroidDisplayHandle::empty())
+    }
 }
 
 #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
@@ -876,6 +901,7 @@ pub struct PlatformSpecificWindowBuilderAttributes;
 pub(crate) struct Window {
     app: AndroidApp,
     redraw_requester: RedrawRequester,
+    active: Arc<Active>,
 }
 
 impl Window {
@@ -889,6 +915,7 @@ impl Window {
         Ok(Self {
             app: el.app.clone(),
             redraw_requester: el.redraw_requester.clone(),
+            active: el.active.clone(),
         })
     }
 
@@ -1084,6 +1111,10 @@ impl Window {
     pub fn title(&self) -> String {
         String::new()
     }
+
+    pub(crate) fn active(&self) -> &Active {
+        &self.active
+    }
 }
 
 #[derive(Default, Clone, Debug)]

src/platform_impl/ios/event_loop.rs

@@ -65,6 +65,22 @@ impl<T: 'static> EventLoopWindowTarget<T> {
     pub fn raw_display_handle(&self) -> RawDisplayHandle {
         RawDisplayHandle::UiKit(UiKitDisplayHandle::empty())
     }
+
+    pub fn owned_display_handle(&self) -> &crate::event_loop::OwnedDisplayHandle {
+        &crate::event_loop::OwnedDisplayHandle {
+            p: OwnedDisplayHandle,
+            _marker: PhantomData,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct OwnedDisplayHandle;
+
+impl OwnedDisplayHandle {
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        RawDisplayHandle::UiKit(UiKitDisplayHandle::empty())
+    }
 }
 
 pub struct EventLoop<T: 'static> {

src/platform_impl/ios/mod.rs

@@ -81,7 +81,8 @@ use std::fmt;
 
 pub(crate) use self::{
     event_loop::{
-        EventLoop, EventLoopProxy, EventLoopWindowTarget, PlatformSpecificEventLoopAttributes,
+        EventLoop, EventLoopProxy, EventLoopWindowTarget, OwnedDisplayHandle,
+        PlatformSpecificEventLoopAttributes,
     },
     monitor::{MonitorHandle, VideoMode},
     window::{PlatformSpecificWindowBuilderAttributes, Window, WindowId},

src/platform_impl/linux/mod.rs

@@ -685,6 +685,14 @@ pub enum EventLoopProxy<T: 'static> {
     Wayland(wayland::EventLoopProxy<T>),
 }
 
+#[derive(Clone)]
+pub enum OwnedDisplayHandle {
+    #[cfg(x11_platform)]
+    X(x11::OwnedDisplayHandle),
+    #[cfg(wayland_platform)]
+    Wayland(wayland::OwnedDisplayHandle),
+}
+
 impl<T: 'static> Clone for EventLoopProxy<T> {
     fn clone(&self) -> Self {
         x11_or_wayland!(match self; EventLoopProxy(proxy) => proxy.clone(); as EventLoopProxy)
@@ -866,6 +874,21 @@ impl<T> EventLoopWindowTarget<T> {
     pub fn raw_display_handle(&self) -> raw_window_handle::RawDisplayHandle {
         x11_or_wayland!(match self; Self(evlp) => evlp.raw_display_handle())
     }
+
+    pub fn owned_display_handle(&self) -> &crate::event_loop::OwnedDisplayHandle {
+        match self {
+            #[cfg(wayland_platform)]
+            EventLoopWindowTarget::Wayland(evlp) => evlp.owned_display_handle(),
+            #[cfg(x11_platform)]
+            EventLoopWindowTarget::X(evlp) => evlp.owned_display_handle(),
+        }
+    }
+}
+
+impl OwnedDisplayHandle {
+    pub fn raw_display_handle(&self) -> raw_window_handle::RawDisplayHandle {
+        x11_or_wayland!(match self; Self(evlp) => evlp.raw_display_handle())
+    }
 }
 
 fn sticky_exit_callback<T, F>(

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

@@ -21,7 +21,10 @@ use sctk::WaylandSource;
 
 use crate::dpi::{LogicalSize, PhysicalSize};
 use crate::event::{Event, StartCause, WindowEvent};
-use crate::event_loop::{ControlFlow, EventLoopWindowTarget as RootEventLoopWindowTarget};
+use crate::event_loop::{
+    ControlFlow, EventLoopWindowTarget as RootEventLoopWindowTarget,
+    OwnedDisplayHandle as RootOwnedDisplayHandle,
+};
 use crate::platform_impl::platform::sticky_exit_callback;
 use crate::platform_impl::EventLoopWindowTarget as PlatformEventLoopWindowTarget;
 
@@ -45,6 +48,9 @@ pub struct EventLoopWindowTarget<T> {
     /// Wayland display.
     pub display: Display,
 
+    /// Display handle.
+    pub display_handle: RootOwnedDisplayHandle,
+
     /// Environment to handle object creation, etc.
     pub env: Environment<WinitEnv>,
 
@@ -81,6 +87,10 @@ impl<T> EventLoopWindowTarget<T> {
         display_handle.display = self.display.get_display_ptr() as *mut _;
         RawDisplayHandle::Wayland(display_handle)
     }
+
+    pub fn owned_display_handle(&self) -> &RootOwnedDisplayHandle {
+        &self.display_handle
+    }
 }
 
 pub struct EventLoop<T: 'static> {
@@ -183,6 +193,12 @@ impl<T: 'static> EventLoop<T> {
         // Create event loop window target.
         let event_loop_window_target = EventLoopWindowTarget {
             display: display.clone(),
+            display_handle: RootOwnedDisplayHandle {
+                p: super::super::OwnedDisplayHandle::Wayland(OwnedDisplayHandle {
+                    display: display.clone(),
+                }),
+                _marker: std::marker::PhantomData,
+            },
             env,
             state: RefCell::new(WinitState {
                 window_map,
@@ -601,6 +617,19 @@ impl<T: 'static> EventLoop<T> {
     }
 }
 
+#[derive(Clone)]
+pub struct OwnedDisplayHandle {
+    display: Display,
+}
+
+impl OwnedDisplayHandle {
+    pub fn raw_display_handle(&self) -> RawDisplayHandle {
+        let mut display_handle = WaylandDisplayHandle::empty();
+        display_handle.display = self.display.get_display_ptr() as *mut _;
+        RawDisplayHandle::Wayland(display_handle)
+    }
+}
+
 // The default routine does floor, but we need round on Wayland.
 fn logical_to_physical_rounded(size: LogicalSize<u32>, scale_factor: f64) -> PhysicalSize<u32> {
     let width = size.width as f64 * scale_factor;