Add ability to get underlying window handle

src/cg.rs

@@ -30,7 +30,7 @@ pub struct CGImpl<D, W> {
     window: id,
     color_space: CGColorSpace,
     size: Option<(NonZeroU32, NonZeroU32)>,
-    _window_source: W,
+    window_handle: W,
     _display: PhantomData<D>,
 }
 
@@ -62,10 +62,22 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> CGImpl<D, W> {
             color_space,
             size: None,
             _display: PhantomData,
-            _window_source: window_src,
+            window_handle: window_src,
         })
     }
 
+    /// Get the inner window handle.
+    #[inline]
+    pub fn get_ref(&self) -> &W {
+        &self.window_handle
+    }
+
+    /// Get a mutable reference to the inner window handle.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.window_handle
+    }
+
     pub fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError> {
         self.size = Some((width, height));
         Ok(())

src/kms.rs

@@ -73,7 +73,7 @@ pub(crate) struct KmsImpl<D: ?Sized, W: ?Sized> {
     buffer: Option<Buffers>,
 
     /// Window handle that we are keeping around.
-    _window: W,
+    window_handle: W,
 }
 
 #[derive(Debug)]
@@ -200,10 +200,22 @@ impl<D: ?Sized, W: HasWindowHandle> KmsImpl<D, W> {
             connectors,
             display,
             buffer: None,
-            _window: window,
+            window_handle: window,
         })
     }
 
+    /// Get the inner window handle.
+    #[inline]
+    pub fn get_ref(&self) -> &W {
+        &self.window_handle
+    }
+
+    /// Get a mutable reference to the inner window handle.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.window_handle
+    }
+
     /// Resize the internal buffer to the given size.
     pub(crate) fn resize(
         &mut self,

src/lib.rs

@@ -86,6 +86,24 @@ macro_rules! make_dispatch {
         }
 
         impl<D: HasDisplayHandle, W: HasWindowHandle> SurfaceDispatch<D, W> {
+            fn get_ref(&self) -> &W {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.get_ref(),
+                    )*
+                }
+            }
+
+            fn get_mut(&mut self) -> &mut W {
+                match self {
+                    $(
+                        $(#[$attr])*
+                        Self::$name(inner) => inner.get_mut(),
+                    )*
+                }
+            }
+
             pub fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError> {
                 match self {
                     $(
@@ -311,6 +329,16 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> Surface<D, W> {
         })
     }
 
+    /// Get a reference to the underlying window handle.
+    pub fn get_ref(&self) -> &W {
+        self.surface_impl.get_ref()
+    }
+
+    /// Get a mutable reference to the underlying window handle.
+    pub fn get_mut(&mut self) -> &mut W {
+        self.surface_impl.get_mut()
+    }
+
     /// Set the size of the buffer that will be returned by [`Surface::buffer_mut`].
     ///
     /// If the size of the buffer does not match the size of the window, the buffer is drawn
@@ -350,6 +378,29 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> Surface<D, W> {
     }
 }
 
+impl<D: HasDisplayHandle, W: HasWindowHandle> AsRef<W> for Surface<D, W> {
+    #[inline]
+    fn as_ref(&self) -> &W {
+        self.get_ref()
+    }
+}
+
+impl<D: HasDisplayHandle, W: HasWindowHandle> AsMut<W> for Surface<D, W> {
+    #[inline]
+    fn as_mut(&mut self) -> &mut W {
+        self.get_mut()
+    }
+}
+
+impl<D: HasDisplayHandle, W: HasWindowHandle> HasWindowHandle for Surface<D, W> {
+    #[inline]
+    fn window_handle(
+        &self,
+    ) -> Result<raw_window_handle::WindowHandle<'_>, raw_window_handle::HandleError> {
+        self.get_ref().window_handle()
+    }
+}
+
 /// A buffer that can be written to by the CPU and presented to the window.
 ///
 /// This derefs to a `[u32]`, which depending on the backend may be a mapping into shared memory

src/orbital.rs

@@ -59,7 +59,7 @@ pub struct OrbitalImpl<D, W> {
     width: u32,
     height: u32,
     presented: bool,
-    _window_source: W,
+    window_handle: W,
     _display: PhantomData<D>,
 }
 
@@ -76,11 +76,23 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> OrbitalImpl<D, W> {
             width: 0,
             height: 0,
             presented: false,
-            _window_source: window,
+            window_handle: window,
             _display: PhantomData,
         })
     }
 
+    /// Get the inner window handle.
+    #[inline]
+    pub fn get_ref(&self) -> &W {
+        &self.window_handle
+    }
+
+    /// Get a mutable reference to the inner window handle.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.window_handle
+    }
+
     pub fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError> {
         let width = width.get();
         let height = height.get();

src/wayland/mod.rs

@@ -83,7 +83,7 @@ pub struct WaylandImpl<D: ?Sized, W: ?Sized> {
     ///
     /// This has to be dropped *after* the `surface` field, because the `surface` field implicitly
     /// borrows this.
-    _window: W,
+    window_handle: W,
 }
 
 impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> WaylandImpl<D, W> {
@@ -109,10 +109,22 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> WaylandImpl<D, W> {
             surface: Some(surface),
             buffers: Default::default(),
             size: None,
-            _window: window,
+            window_handle: window,
         })
     }
 
+    /// Get the inner window handle.
+    #[inline]
+    pub fn get_ref(&self) -> &W {
+        &self.window_handle
+    }
+
+    /// Get a mutable reference to the inner window handle.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.window_handle
+    }
+
     pub fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError> {
         self.size = Some(
             (|| {

src/web.rs

@@ -57,7 +57,7 @@ pub struct WebImpl<D, W> {
     size: Option<(NonZeroU32, NonZeroU32)>,
 
     /// The underlying window handle.
-    _window: W,
+    window_handle: W,
 
     /// The underlying display handle.
     _display: PhantomData<D>,
@@ -114,7 +114,7 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> WebImpl<D, W> {
             buffer: Vec::new(),
             buffer_presented: false,
             size: None,
-            _window: window,
+            window_handle: window,
             _display: PhantomData,
         })
     }
@@ -130,11 +130,23 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> WebImpl<D, W> {
             buffer: Vec::new(),
             buffer_presented: false,
             size: None,
-            _window: window,
+            window_handle: window,
             _display: PhantomData,
         })
     }
 
+    /// Get the inner window handle.
+    #[inline]
+    pub fn get_ref(&self) -> &W {
+        &self.window_handle
+    }
+
+    /// Get a mutable reference to the inner window handle.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.window_handle
+    }
+
     /// De-duplicates the error handling between `HtmlCanvasElement` and `OffscreenCanvas`.
     fn resolve_ctx<T: JsCast>(
         result: Option<Option<Object>>,

src/win32.rs

@@ -142,7 +142,7 @@ pub struct Win32Impl<D: ?Sized, W> {
     /// The handle for the window.
     ///
     /// This should be kept alive in order to keep `window` valid.
-    _window: W,
+    handle: W,
 
     /// The display handle.
     ///
@@ -184,11 +184,23 @@ impl<D: HasDisplayHandle, W: HasWindowHandle> Win32Impl<D, W> {
             dc,
             window: hwnd,
             buffer: None,
-            _window: window,
+            handle: window,
             _display: PhantomData,
         })
     }
 
+    /// Get the inner window handle.
+    #[inline]
+    pub fn get_ref(&self) -> &W {
+        &self.handle
+    }
+
+    /// Get a mutable reference to the inner window handle.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.handle
+    }
+
     pub fn resize(&mut self, width: NonZeroU32, height: NonZeroU32) -> Result<(), SoftBufferError> {
         let (width, height) = (|| {
             let width = NonZeroI32::new(i32::try_from(width.get()).ok()?)?;

src/x11.rs

@@ -150,7 +150,7 @@ pub struct X11Impl<D: ?Sized, W: ?Sized> {
     size: Option<(NonZeroU16, NonZeroU16)>,
 
     /// Keep the window alive.
-    _window_handle: W,
+    window_handle: W,
 }
 
 /// The buffer that is being drawn to.
@@ -292,10 +292,22 @@ impl<D: HasDisplayHandle + ?Sized, W: HasWindowHandle> X11Impl<D, W> {
             buffer,
             buffer_presented: false,
             size: None,
-            _window_handle: window_src,
+            window_handle: window_src,
         })
     }
 
+    /// Get the inner window handle.
+    #[inline]
+    pub fn get_ref(&self) -> &W {
+        &self.window_handle
+    }
+
+    /// Get a mutable reference to the inner window handle.
+    #[inline]
+    pub fn get_mut(&mut self) -> &mut W {
+        &mut self.window_handle
+    }
+
     /// Resize the internal buffer to the given width and height.
     pub(crate) fn resize(
         &mut self,