Rename window::Backend to Compositor

examples/tour/src/main.rs

@@ -26,7 +26,7 @@ pub struct Tour {
 }
 
 impl Application for Tour {
-    type Backend = window::Backend;
+    type Compositor = window::Compositor;
     type Executor = executor::Null;
     type Message = Message;
     type Flags = ();

glow/src/window.rs

@@ -1,4 +1,4 @@
 //! Display rendering results on windows.
-mod backend;
+mod compositor;
 
-pub use backend::Backend;
+pub use compositor::Compositor;

glow/src/window/compositor.rs

@@ -6,20 +6,20 @@ use raw_window_handle::HasRawWindowHandle;
 
 /// A window graphics backend for iced powered by `glow`.
 #[allow(missing_debug_implementations)]
-pub struct Backend {
+pub struct Compositor {
     connection: surfman::Connection,
     device: surfman::Device,
     gl_context: surfman::Context,
     gl: Option<glow::Context>,
 }
 
-impl iced_native::window::Backend for Backend {
+impl iced_native::window::Compositor for Compositor {
     type Settings = Settings;
     type Renderer = Renderer;
     type Surface = ();
     type SwapChain = Viewport;
 
-    fn new(settings: Self::Settings) -> Backend {
+    fn new(_settings: Self::Settings) -> Self {
         let connection = surfman::Connection::new().expect("Create connection");
 
         let adapter = connection
@@ -40,7 +40,7 @@ impl iced_native::window::Backend for Backend {
             .create_context(&context_descriptor)
             .expect("Create context");
 
-        Backend {
+        Self {
             connection,
             device,
             gl_context,
@@ -179,7 +179,7 @@ impl iced_native::window::Backend for Backend {
     }
 }
 
-impl Drop for Backend {
+impl Drop for Compositor {
     fn drop(&mut self) {
         self.device
             .destroy_context(&mut self.gl_context)

native/src/window.rs

@@ -1,6 +1,6 @@
 //! Build window-based GUI applications.
-mod backend;
+mod compositor;
 mod event;
 
-pub use backend::Backend;
+pub use compositor::Compositor;
 pub use event::Event;

native/src/window/compositor.rs

@@ -2,8 +2,8 @@ use crate::mouse;
 
 use raw_window_handle::HasRawWindowHandle;
 
-/// A graphics backend that can render to windows.
+/// A graphics compositor that can draw to windows.
-pub trait Backend: Sized {
+pub trait Compositor: Sized {
     /// The settings of the backend.
     type Settings: Default + Clone;
 

src/application.rs

@@ -216,7 +216,7 @@ impl<A> iced_winit::Application for Instance<A>
 where
     A: Application,
 {
-    type Backend = iced_wgpu::window::Backend;
+    type Compositor = iced_wgpu::window::Compositor;
     type Executor = A::Executor;
     type Flags = A::Flags;
     type Message = A::Message;

wgpu/src/window.rs

@@ -1,6 +1,6 @@
 //! Display rendering results on windows.
-mod backend;
+mod compositor;
 mod swap_chain;
 
-pub use backend::Backend;
+pub use compositor::Compositor;
 pub use swap_chain::SwapChain;

wgpu/src/window/compositor.rs

@@ -5,19 +5,19 @@ use raw_window_handle::HasRawWindowHandle;
 
 /// A window graphics backend for iced powered by `wgpu`.
 #[derive(Debug)]
-pub struct Backend {
+pub struct Compositor {
     device: wgpu::Device,
     queue: wgpu::Queue,
     format: wgpu::TextureFormat,
 }
 
-impl iced_native::window::Backend for Backend {
+impl iced_native::window::Compositor for Compositor {
     type Settings = Settings;
     type Renderer = Renderer;
     type Surface = wgpu::Surface;
     type SwapChain = SwapChain;
 
-    fn new(settings: Self::Settings) -> Backend {
+    fn new(settings: Self::Settings) -> Self {
         let (device, queue) = futures::executor::block_on(async {
             let adapter = wgpu::Adapter::request(
                 &wgpu::RequestAdapterOptions {
@@ -43,7 +43,7 @@ impl iced_native::window::Backend for Backend {
                 .await
         });
 
-        Backend {
+        Self {
             device,
             queue,
             format: settings.format,

winit/src/application.rs

@@ -19,7 +19,7 @@ pub trait Application: Sized {
     /// The graphics backend to use to draw the [`Application`].
     ///
     /// [`Application`]: trait.Application.html
-    type Backend: window::Backend;
+    type Compositor: window::Compositor;
 
     /// The [`Executor`] that will run commands and subscriptions.
     ///
@@ -91,7 +91,11 @@ pub trait Application: Sized {
     /// [`Application`]: trait.Application.html
     fn view(
         &mut self,
-    ) -> Element<'_, Self::Message, <Self::Backend as window::Backend>::Renderer>;
+    ) -> Element<
+        '_,
+        Self::Message,
+        <Self::Compositor as window::Compositor>::Renderer,
+    >;
 
     /// Returns the current [`Application`] mode.
     ///
@@ -116,11 +120,11 @@ pub trait Application: Sized {
     /// [`Settings`]: struct.Settings.html
     fn run(
         settings: Settings<Self::Flags>,
-        backend_settings: <Self::Backend as window::Backend>::Settings,
+        backend_settings: <Self::Compositor as window::Compositor>::Settings,
     ) where
         Self: 'static,
     {
-        use window::Backend as _;
+        use window::Compositor as _;
         use winit::{
             event::{self, WindowEvent},
             event_loop::{ControlFlow, EventLoop},
@@ -181,15 +185,15 @@ pub trait Application: Sized {
         let mut resized = false;
 
         let clipboard = Clipboard::new(&window);
-        let mut backend = Self::Backend::new(backend_settings.clone());
+        let mut compositor = Self::Compositor::new(backend_settings.clone());
 
-        let surface = backend.create_surface(&window);
+        let surface = compositor.create_surface(&window);
-        let mut renderer = backend.create_renderer(backend_settings);
+        let mut renderer = compositor.create_renderer(backend_settings);
 
         let mut swap_chain = {
             let physical_size = size.physical();
 
-            backend.create_swap_chain(
+            compositor.create_swap_chain(
                 &surface,
                 physical_size.width,
                 physical_size.height,
@@ -324,7 +328,7 @@ pub trait Application: Sized {
                 if resized {
                     let physical_size = size.physical();
 
-                    swap_chain = backend.create_swap_chain(
+                    swap_chain = compositor.create_swap_chain(
                         &surface,
                         physical_size.width,
                         physical_size.height,
@@ -333,7 +337,7 @@ pub trait Application: Sized {
                     resized = false;
                 }
 
-                let new_mouse_interaction = backend.draw(
+                let new_mouse_interaction = compositor.draw(
                     &mut renderer,
                     &mut swap_chain,
                     &primitive,
@@ -414,10 +418,14 @@ pub trait Application: Sized {
 fn build_user_interface<'a, A: Application>(
     application: &'a mut A,
     cache: Cache,
-    renderer: &mut <A::Backend as window::Backend>::Renderer,
+    renderer: &mut <A::Compositor as window::Compositor>::Renderer,
     size: winit::dpi::LogicalSize<f64>,
     debug: &mut Debug,
-) -> UserInterface<'a, A::Message, <A::Backend as window::Backend>::Renderer> {
+) -> UserInterface<
+    'a,
+    A::Message,
+    <A::Compositor as window::Compositor>::Renderer,
+> {
     debug.view_started();
     let view = application.view();
     debug.view_finished();