1 files changed, 34 insertions, 34 deletions

diff --git a/renderer/src/compositor.rs b/renderer/src/compositor.rs
index d1500089..f10ed048 100644
--- a/renderer/src/compositor.rs
+++ b/renderer/src/compositor.rs
@@ -1,9 +1,8 @@
 use crate::core::Color;
-use crate::graphics::compositor::{Information, SurfaceError};
+use crate::graphics::compositor::{Information, SurfaceError, Window};
 use crate::graphics::{Error, Viewport};
 use crate::{Renderer, Settings};
 
-use raw_window_handle::{HasRawDisplayHandle, HasRawWindowHandle};
 use std::env;
 
 pub enum Compositor<Theme> {
@@ -15,7 +14,7 @@ pub enum Compositor<Theme> {
 pub enum Surface {
     TinySkia(iced_tiny_skia::window::Surface),
     #[cfg(feature = "wgpu")]
-    Wgpu(iced_wgpu::window::Surface),
+    Wgpu(iced_wgpu::window::Surface<'static>),
 }
 
 impl<Theme> crate::graphics::Compositor for Compositor<Theme> {
@@ -23,20 +22,18 @@ impl<Theme> crate::graphics::Compositor for Compositor<Theme> {
     type Renderer = Renderer<Theme>;
     type Surface = Surface;
 
-    fn new<W: HasRawWindowHandle + HasRawDisplayHandle>(
+    fn new<W: Window + Clone>(
         settings: Self::Settings,
-        compatible_window: Option<&W>,
-    ) -> Result<(Self, Self::Renderer), Error> {
+        compatible_window: W,
+    ) -> Result<Self, Error> {
         let candidates =
             Candidate::list_from_env().unwrap_or(Candidate::default_list());
 
         let mut error = Error::GraphicsAdapterNotFound;
 
         for candidate in candidates {
-            match candidate.build(settings, compatible_window) {
-                Ok((compositor, renderer)) => {
-                    return Ok((compositor, renderer))
-                }
+            match candidate.build(settings, compatible_window.clone()) {
+                Ok(compositor) => return Ok(compositor),
                 Err(new_error) => {
                     error = new_error;
                 }
@@ -46,9 +43,21 @@ impl<Theme> crate::graphics::Compositor for Compositor<Theme> {
         Err(error)
     }
 
-    fn create_surface<W: HasRawWindowHandle + HasRawDisplayHandle>(
+    fn create_renderer(&self) -> Self::Renderer {
+        match self {
+            Compositor::TinySkia(compositor) => {
+                Renderer::TinySkia(compositor.create_renderer())
+            }
+            #[cfg(feature = "wgpu")]
+            Compositor::Wgpu(compositor) => {
+                Renderer::Wgpu(compositor.create_renderer())
+            }
+        }
+    }
+
+    fn create_surface<W: Window + Clone>(
         &mut self,
-        window: &W,
+        window: W,
         width: u32,
         height: u32,
     ) -> Surface {
@@ -216,28 +225,26 @@ impl Candidate {
         )
     }
 
-    fn build<Theme, W: HasRawWindowHandle + HasRawDisplayHandle>(
+    fn build<Theme, W: Window>(
         self,
         settings: Settings,
-        _compatible_window: Option<&W>,
-    ) -> Result<(Compositor<Theme>, Renderer<Theme>), Error> {
+        _compatible_window: W,
+    ) -> Result<Compositor<Theme>, Error> {
         match self {
             Self::TinySkia => {
-                let (compositor, backend) =
-                    iced_tiny_skia::window::compositor::new();
+                let compositor = iced_tiny_skia::window::compositor::new(
+                    iced_tiny_skia::Settings {
+                        default_font: settings.default_font,
+                        default_text_size: settings.default_text_size,
+                    },
+                    _compatible_window,
+                );
 
-                Ok((
-                    Compositor::TinySkia(compositor),
-                    Renderer::TinySkia(iced_tiny_skia::Renderer::new(
-                        backend,
-                        settings.default_font,
-                        settings.default_text_size,
-                    )),
-                ))
+                Ok(Compositor::TinySkia(compositor))
             }
             #[cfg(feature = "wgpu")]
             Self::Wgpu => {
-                let (compositor, backend) = iced_wgpu::window::compositor::new(
+                let compositor = iced_wgpu::window::compositor::new(
                     iced_wgpu::Settings {
                         default_font: settings.default_font,
                         default_text_size: settings.default_text_size,
@@ -247,14 +254,7 @@ impl Candidate {
                     _compatible_window,
                 )?;
 
-                Ok((
-                    Compositor::Wgpu(compositor),
-                    Renderer::Wgpu(iced_wgpu::Renderer::new(
-                        backend,
-                        settings.default_font,
-                        settings.default_text_size,
-                    )),
-                ))
+                Ok(Compositor::Wgpu(compositor))
             }
             #[cfg(not(feature = "wgpu"))]
             Self::Wgpu => {