Separate Compositor::new from Compositor::create_renderer

graphics/src/compositor.rs

@@ -22,10 +22,10 @@ pub trait Compositor: Sized {
     fn new<W: HasRawWindowHandle + HasRawDisplayHandle>(
         settings: Self::Settings,
         compatible_window: Option<&W>,
-    ) -> Result<(Self, Self::Renderer), Error>;
+    ) -> Result<Self, Error>;
 
     /// Creates a [`Self::Renderer`] for the [`Compositor`].
-    fn renderer(&self) -> Self::Renderer;
+    fn create_renderer(&self) -> Self::Renderer;
 
     /// Crates a new [`Surface`] for the given window.
     ///

renderer/src/compositor.rs

@@ -26,7 +26,7 @@ impl<Theme> crate::graphics::Compositor for Compositor<Theme> {
     fn new<W: HasRawWindowHandle + HasRawDisplayHandle>(
         settings: Self::Settings,
         compatible_window: Option<&W>,
-    ) -> Result<(Self, Self::Renderer), Error> {
+    ) -> Result<Self, Error> {
         let candidates =
             Candidate::list_from_env().unwrap_or(Candidate::default_list());
 
@@ -34,9 +34,7 @@ impl<Theme> crate::graphics::Compositor for Compositor<Theme> {
 
         for candidate in candidates {
             match candidate.build(settings, compatible_window) {
-                Ok((compositor, renderer)) => {
+                Ok(compositor) => return Ok(compositor),
-                    return Ok((compositor, renderer))
-                }
                 Err(new_error) => {
                     error = new_error;
                 }
@@ -46,14 +44,14 @@ impl<Theme> crate::graphics::Compositor for Compositor<Theme> {
         Err(error)
     }
 
-    fn renderer(&self) -> Self::Renderer {
+    fn create_renderer(&self) -> Self::Renderer {
         match self {
             Compositor::TinySkia(compositor) => {
-                Renderer::TinySkia(compositor.renderer())
+                Renderer::TinySkia(compositor.create_renderer())
             }
             #[cfg(feature = "wgpu")]
             Compositor::Wgpu(compositor) => {
-                Renderer::Wgpu(compositor.renderer())
+                Renderer::Wgpu(compositor.create_renderer())
             }
         }
     }
@@ -232,29 +230,21 @@ impl Candidate {
         self,
         settings: Settings,
         _compatible_window: Option<&W>,
-    ) -> Result<(Compositor<Theme>, Renderer<Theme>), Error> {
+    ) -> Result<Compositor<Theme>, Error> {
         match self {
             Self::TinySkia => {
-                let (compositor, backend) =
+                let compositor = iced_tiny_skia::window::compositor::new(
-                    iced_tiny_skia::window::compositor::new(
+                    iced_tiny_skia::Settings {
-                        iced_tiny_skia::Settings {
+                        default_font: settings.default_font,
-                            default_font: settings.default_font,
+                        default_text_size: settings.default_text_size,
-                            default_text_size: settings.default_text_size,
+                    },
-                        },
+                );
-                    );
 
-                Ok((
+                Ok(Compositor::TinySkia(compositor))
-                    Compositor::TinySkia(compositor),
-                    Renderer::TinySkia(iced_tiny_skia::Renderer::new(
-                        backend,
-                        settings.default_font,
-                        settings.default_text_size,
-                    )),
-                ))
             }
             #[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,
@@ -264,14 +254,7 @@ impl Candidate {
                     _compatible_window,
                 )?;
 
-                Ok((
+                Ok(Compositor::Wgpu(compositor))
-                    Compositor::Wgpu(compositor),
-                    Renderer::Wgpu(iced_wgpu::Renderer::new(
-                        backend,
-                        settings.default_font,
-                        settings.default_text_size,
-                    )),
-                ))
             }
             #[cfg(not(feature = "wgpu"))]
             Self::Wgpu => {

tiny_skia/src/window/compositor.rs

@@ -28,20 +28,11 @@ impl<Theme> crate::graphics::Compositor for Compositor<Theme> {
     fn new<W: HasRawWindowHandle + HasRawDisplayHandle>(
         settings: Self::Settings,
         _compatible_window: Option<&W>,
-    ) -> Result<(Self, Self::Renderer), Error> {
+    ) -> Result<Self, Error> {
-        let (compositor, backend) = new(settings);
+        Ok(new(settings))
-
-        Ok((
-            compositor,
-            Renderer::new(
-                backend,
-                settings.default_font,
-                settings.default_text_size,
-            ),
-        ))
     }
 
-    fn renderer(&self) -> Self::Renderer {
+    fn create_renderer(&self) -> Self::Renderer {
         Renderer::new(
             Backend::new(),
             self.settings.default_font,
@@ -130,14 +121,11 @@ impl<Theme> crate::graphics::Compositor for Compositor<Theme> {
     }
 }
 
-pub fn new<Theme>(settings: Settings) -> (Compositor<Theme>, Backend) {
+pub fn new<Theme>(settings: Settings) -> Compositor<Theme> {
-    (
+    Compositor {
-        Compositor {
+        settings,
-            settings,
+        _theme: PhantomData,
-            _theme: PhantomData,
+    }
-        },
-        Backend::new(),
-    )
 }
 
 pub fn present<T: AsRef<str>>(

wgpu/src/window/compositor.rs

@@ -139,16 +139,14 @@ impl<Theme> Compositor<Theme> {
 pub fn new<Theme, W: HasRawWindowHandle + HasRawDisplayHandle>(
     settings: Settings,
     compatible_window: Option<&W>,
-) -> Result<(Compositor<Theme>, Backend), Error> {
+) -> Result<Compositor<Theme>, Error> {
     let compositor = futures::executor::block_on(Compositor::request(
         settings,
         compatible_window,
     ))
     .ok_or(Error::GraphicsAdapterNotFound)?;
 
-    let backend = compositor.create_backend();
+    Ok(compositor)
-
-    Ok((compositor, backend))
 }
 
 /// Presents the given primitives with the given [`Compositor`] and [`Backend`].
@@ -214,20 +212,11 @@ impl<Theme> graphics::Compositor for Compositor<Theme> {
     fn new<W: HasRawWindowHandle + HasRawDisplayHandle>(
         settings: Self::Settings,
         compatible_window: Option<&W>,
-    ) -> Result<(Self, Self::Renderer), Error> {
+    ) -> Result<Self, Error> {
-        let (compositor, backend) = new(settings, compatible_window)?;
+        new(settings, compatible_window)
-
-        Ok((
-            compositor,
-            Renderer::new(
-                backend,
-                settings.default_font,
-                settings.default_text_size,
-            ),
-        ))
     }
 
-    fn renderer(&self) -> Self::Renderer {
+    fn create_renderer(&self) -> Self::Renderer {
         Renderer::new(
             self.create_backend(),
             self.settings.default_font,

winit/src/application.rs

@@ -181,8 +181,8 @@ where
         };
     }
 
-    let (compositor, mut renderer) =
+    let compositor = C::new(compositor_settings, Some(&window))?;
-        C::new(compositor_settings, Some(&window))?;
+    let mut renderer = compositor.create_renderer();
 
     for font in settings.fonts {
         use crate::core::text::Renderer;

winit/src/multi_window.rs

@@ -181,8 +181,8 @@ where
         };
     }
 
-    let (mut compositor, renderer) =
+    let mut compositor = C::new(compositor_settings, Some(&main_window))?;
-        C::new(compositor_settings, Some(&main_window))?;
+    let renderer = compositor.create_renderer();
 
     let windows = Windows::new(
         &application,

winit/src/multi_window/windows.rs

@@ -97,7 +97,7 @@ where
             physical_size.width,
             physical_size.height,
         );
-        let renderer = compositor.renderer();
+        let renderer = compositor.create_renderer();
 
         self.ids.push(id);
         self.raw.push(window);