Safe surface lifetime via Arc<Window>

crates/kas-core/src/app/common.rs

@@ -9,7 +9,7 @@ use crate::draw::DrawSharedImpl;
 use crate::draw::{color::Rgba, DrawIface, WindowCommon};
 use crate::geom::Size;
 use crate::theme::Theme;
-use raw_window_handle as raw;
+use raw_window_handle as rwh;
 use std::time::Instant;
 use thiserror::Error;
 
@@ -22,7 +22,7 @@ use thiserror::Error;
 pub enum Error {
     /// Window-handle error
     #[error(transparent)]
-    Handle(#[from] raw::HandleError),
+    Handle(#[from] rwh::HandleError),
 
     /// Failure from the graphics sub-system
     #[error("error from graphics sub-system")]
@@ -189,6 +189,17 @@ pub trait AppGraphicsBuilder {
 
     /// Construct shared state
     fn build(self) -> Result<Self::Shared>;
+
+    /// Construct a window surface
+    ///
+    /// It is required to call [`WindowSurface::do_resize`] after this.
+    fn new_surface<'window, W>(
+        shared: &mut Self::Shared,
+        window: W,
+    ) -> Result<Self::Surface<'window>>
+    where
+        W: rwh::HasWindowHandle + rwh::HasDisplayHandle + Send + Sync + 'window,
+        Self: Sized;
 }
 
 /// Window graphical surface requirements
@@ -198,14 +209,6 @@ pub trait WindowSurface {
     /// Shared draw state
     type Shared: kas::draw::DrawSharedImpl;
 
-    /// Construct an instance from a window handle
-    ///
-    /// It is required to call [`WindowSurface::do_resize`] after this.
-    fn new<W>(shared: &mut Self::Shared, window: W) -> Result<Self>
-    where
-        W: raw::HasWindowHandle + raw::HasDisplayHandle + Send + Sync,
-        Self: Sized;
-
     /// Get current surface size
     fn size(&self) -> Size;
 

crates/kas-core/src/app/mod.rs

@@ -71,7 +71,7 @@ enum ProxyAction {
 #[cfg(test)]
 mod test {
     use super::*;
-    use raw_window_handle as raw;
+    use raw_window_handle as rwh;
     use std::time::Instant;
 
     struct Draw;
@@ -250,7 +250,7 @@ mod test {
 
         fn new<W>(_: &mut Self::Shared, _: W) -> Result<Self>
         where
-            W: raw::HasRawWindowHandle + raw::HasRawDisplayHandle,
+            W: rwh::HasRawWindowHandle + rwh::HasRawDisplayHandle,
             Self: Sized,
         {
             todo!()

crates/kas-core/src/app/window.rs

@@ -17,6 +17,7 @@ use kas::theme::{DrawCx, SizeCx, ThemeSize};
 use kas::theme::{Theme, Window as _};
 use kas::{autoimpl, messages::MessageStack, Action, Id, Layout, LayoutExt, Widget, WindowId};
 use std::mem::take;
+use std::sync::Arc;
 use std::time::{Duration, Instant};
 use winit::event::WindowEvent;
 use winit::event_loop::EventLoopWindowTarget;
@@ -25,7 +26,7 @@ use winit::window::WindowBuilder;
 /// Window fields requiring a frame or surface
 #[crate::autoimpl(Deref, DerefMut using self.window)]
 struct WindowData<G: AppGraphicsBuilder, T: Theme<G::Shared>> {
-    window: winit::window::Window,
+    window: Arc<winit::window::Window>,
     #[cfg(all(wayland_platform, feature = "clipboard"))]
     wayland_clipboard: Option<smithay_clipboard::Clipboard>,
     surface: G::Surface<'static>,
@@ -170,7 +171,9 @@ impl<A: AppData, G: AppGraphicsBuilder, T: Theme<G::Shared>> Window<A, G, T> {
             _ => None,
         };
 
-        let mut surface = G::Surface::new(&mut state.shared.draw.draw, &window)?;
+        // NOTE: usage of Arc is inelegant, but avoids lots of unsafe code
+        let window = Arc::new(window);
+        let mut surface = G::new_surface(&mut state.shared.draw.draw, window.clone())?;
         if apply_size {
             surface.do_resize(&mut state.shared.draw.draw, size);
         }

crates/kas-wgpu/src/lib.rs

@@ -29,6 +29,7 @@ mod surface;
 use crate::draw::{CustomPipeBuilder, DrawPipe};
 use kas::app::{AppBuilder, AppGraphicsBuilder, Result};
 use kas::theme::{FlatTheme, Theme};
+use wgpu::rwh;
 
 pub use draw_shaded::{DrawShaded, DrawShadedImpl};
 pub use options::Options;
@@ -56,6 +57,17 @@ impl<CB: CustomPipeBuilder> AppGraphicsBuilder for WgpuBuilder<CB> {
         }
         DrawPipe::new(self.custom, &options)
     }
+
+    fn new_surface<'window, W>(
+        shared: &mut Self::Shared,
+        window: W,
+    ) -> Result<Self::Surface<'window>>
+    where
+        W: rwh::HasWindowHandle + rwh::HasDisplayHandle + Send + Sync + 'window,
+        Self: Sized,
+    {
+        surface::Surface::new(shared, window)
+    }
 }
 
 impl Default for WgpuBuilder<()> {

crates/kas-wgpu/src/surface.rs

@@ -6,7 +6,7 @@
 //! WGPU window surface
 
 use crate::draw::{CustomPipe, DrawPipe, DrawWindow};
-use kas::app::{raw_window_handle as raw, Error, WindowSurface};
+use kas::app::{raw_window_handle as rwh, Error, WindowSurface};
 use kas::cast::Cast;
 use kas::draw::color::Rgba;
 use kas::draw::{DrawIface, DrawSharedImpl, WindowCommon};
@@ -20,20 +20,16 @@ pub struct Surface<'a, C: CustomPipe> {
     draw: DrawWindow<C::Window>,
 }
 
-impl<'a, C: CustomPipe> WindowSurface for Surface<'a, C> {
-    type Shared = DrawPipe<C>;
-
-    fn new<W>(shared: &mut Self::Shared, window: W) -> Result<Self, Error>
+impl<'a, C: CustomPipe> Surface<'a, C> {
+    pub fn new<W>(shared: &mut <Self as WindowSurface>::Shared, window: W) -> Result<Self, Error>
     where
-        W: raw::HasWindowHandle + raw::HasDisplayHandle + Send + Sync,
+        W: rwh::HasWindowHandle + rwh::HasDisplayHandle + Send + Sync + 'a,
         Self: Sized,
     {
-        let surface = unsafe {
-            // TODO: handle window lifetime safely
-            let target = wgpu::SurfaceTargetUnsafe::from_window(&window)?;
-            shared.instance.create_surface_unsafe(target)
-        }
-        .map_err(|e| Error::Graphics(Box::new(e)))?;
+        let surface = shared
+            .instance
+            .create_surface(window)
+            .map_err(|e| Error::Graphics(Box::new(e)))?;
         let sc_desc = wgpu::SurfaceConfiguration {
             usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
             format: crate::draw::RENDER_TEX_FORMAT,
@@ -55,6 +51,10 @@ impl<'a, C: CustomPipe> WindowSurface for Surface<'a, C> {
             draw: shared.new_window(),
         })
     }
+}
+
+impl<'a, C: CustomPipe> WindowSurface for Surface<'a, C> {
+    type Shared = DrawPipe<C>;
 
     fn size(&self) -> Size {
         Size::new(self.sc_desc.width.cast(), self.sc_desc.height.cast())