Remove trait-specific draw logic in `iced_native`

27 files changed, 121 insertions, 1823 deletions

diff --git a/graphics/src/lib.rs b/graphics/src/lib.rs
index 54cdcb77..9c113da6 100644
--- a/graphics/src/lib.rs
+++ b/graphics/src/lib.rs
@@ -4,7 +4,7 @@
 //! ![The native path of the Iced ecosystem](https://github.com/hecrj/iced/blob/0525d76ff94e828b7b21634fa94a747022001c83/docs/graphs/native.png?raw=true)
 //!
 //! [`iced`]: https://github.com/hecrj/iced
-#![deny(missing_docs)]
+//#![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
 #![deny(unused_results)]
 #![deny(unsafe_code)]
diff --git a/graphics/src/overlay/menu.rs b/graphics/src/overlay/menu.rs
index 53f47984..7dfb48b9 100644
--- a/graphics/src/overlay/menu.rs
+++ b/graphics/src/overlay/menu.rs
@@ -1,9 +1,8 @@
 //! Build and show dropdown menus.
-use crate::alignment;
 use crate::backend::{self, Backend};
-use crate::{Primitive, Renderer};
+use crate::Renderer;
 
-use iced_native::{mouse, overlay, Color, Font, Padding, Point, Rectangle};
+use iced_native::overlay;
 
 pub use iced_style::menu::Style;
 
@@ -12,105 +11,4 @@ where
     B: Backend + backend::Text,
 {
     type Style = Style;
-
-    fn decorate(
-        &mut self,
-        bounds: Rectangle,
-        _cursor_position: Point,
-        style: &Style,
-        (primitives, mouse_cursor): Self::Output,
-    ) -> Self::Output {
-        (
-            Primitive::Group {
-                primitives: vec![
-                    Primitive::Quad {
-                        bounds,
-                        background: style.background,
-                        border_color: style.border_color,
-                        border_width: style.border_width,
-                        border_radius: 0.0,
-                    },
-                    primitives,
-                ],
-            },
-            mouse_cursor,
-        )
-    }
-
-    fn draw<T: ToString>(
-        &mut self,
-        bounds: Rectangle,
-        cursor_position: Point,
-        viewport: &Rectangle,
-        options: &[T],
-        hovered_option: Option<usize>,
-        padding: Padding,
-        text_size: u16,
-        font: Font,
-        style: &Style,
-    ) -> Self::Output {
-        use std::f32;
-
-        let is_mouse_over = bounds.contains(cursor_position);
-        let option_height = (text_size + padding.vertical()) as usize;
-
-        let mut primitives = Vec::new();
-
-        let offset = viewport.y - bounds.y;
-        let start = (offset / option_height as f32) as usize;
-        let end =
-            ((offset + viewport.height) / option_height as f32).ceil() as usize;
-
-        let visible_options = &options[start..end.min(options.len())];
-
-        for (i, option) in visible_options.iter().enumerate() {
-            let i = start + i;
-            let is_selected = hovered_option == Some(i);
-
-            let bounds = Rectangle {
-                x: bounds.x,
-                y: bounds.y + (option_height * i) as f32,
-                width: bounds.width,
-                height: f32::from(text_size + padding.vertical()),
-            };
-
-            if is_selected {
-                primitives.push(Primitive::Quad {
-                    bounds,
-                    background: style.selected_background,
-                    border_color: Color::TRANSPARENT,
-                    border_width: 0.0,
-                    border_radius: 0.0,
-                });
-            }
-
-            primitives.push(Primitive::Text {
-                content: option.to_string(),
-                bounds: Rectangle {
-                    x: bounds.x + padding.left as f32,
-                    y: bounds.center_y(),
-                    width: f32::INFINITY,
-                    ..bounds
-                },
-                size: f32::from(text_size),
-                font,
-                color: if is_selected {
-                    style.selected_text_color
-                } else {
-                    style.text_color
-                },
-                horizontal_alignment: alignment::Horizontal::Left,
-                vertical_alignment: alignment::Vertical::Center,
-            });
-        }
-
-        (
-            Primitive::Group { primitives },
-            if is_mouse_over {
-                mouse::Interaction::Pointer
-            } else {
-                mouse::Interaction::default()
-            },
-        )
-    }
 }
diff --git a/graphics/src/renderer.rs b/graphics/src/renderer.rs
index fa63991b..cedffe7e 100644
--- a/graphics/src/renderer.rs
+++ b/graphics/src/renderer.rs
@@ -1,30 +1,29 @@
 use crate::{Backend, Defaults, Primitive};
-use iced_native::layout::{self, Layout};
-use iced_native::mouse;
-use iced_native::{
-    Background, Color, Element, Point, Rectangle, Vector, Widget,
-};
+use iced_native::layout;
+use iced_native::{Element, Rectangle};
 
 /// A backend-agnostic renderer that supports all the built-in widgets.
 #[derive(Debug)]
 pub struct Renderer<B: Backend> {
     backend: B,
+    primitive: Primitive,
 }
 
 impl<B: Backend> Renderer<B> {
     /// Creates a new [`Renderer`] from the given [`Backend`].
     pub fn new(backend: B) -> Self {
-        Self { backend }
+        Self {
+            backend,
+            primitive: Primitive::None,
+        }
     }
 
-    /// Returns a reference to the [`Backend`] of the [`Renderer`].
     pub fn backend(&self) -> &B {
         &self.backend
     }
 
-    /// Returns a mutable reference to the [`Backend`] of the [`Renderer`].
-    pub fn backend_mut(&mut self) -> &mut B {
-        &mut self.backend
+    pub fn present(&mut self, f: impl FnOnce(&mut B, &Primitive)) {
+        f(&mut self.backend, &self.primitive);
     }
 }
 
@@ -32,7 +31,6 @@ impl<B> iced_native::Renderer for Renderer<B>
 where
     B: Backend,
 {
-    type Output = (Primitive, mouse::Interaction);
     type Defaults = Defaults;
 
     fn layout<'a, Message>(
@@ -47,75 +45,5 @@ where
         layout
     }
 
-    fn overlay(
-        &mut self,
-        (base_primitive, base_cursor): (Primitive, mouse::Interaction),
-        (overlay_primitives, overlay_cursor): (Primitive, mouse::Interaction),
-        overlay_bounds: Rectangle,
-    ) -> (Primitive, mouse::Interaction) {
-        (
-            Primitive::Group {
-                primitives: vec![
-                    base_primitive,
-                    Primitive::Clip {
-                        bounds: Rectangle {
-                            width: overlay_bounds.width + 0.5,
-                            height: overlay_bounds.height + 0.5,
-                            ..overlay_bounds
-                        },
-                        offset: Vector::new(0, 0),
-                        content: Box::new(overlay_primitives),
-                    },
-                ],
-            },
-            if base_cursor > overlay_cursor {
-                base_cursor
-            } else {
-                overlay_cursor
-            },
-        )
-    }
-}
-
-impl<B> layout::Debugger for Renderer<B>
-where
-    B: Backend,
-{
-    fn explain<Message>(
-        &mut self,
-        defaults: &Defaults,
-        widget: &dyn Widget<Message, Self>,
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-        color: Color,
-    ) -> Self::Output {
-        let (primitive, cursor) =
-            widget.draw(self, defaults, layout, cursor_position, viewport);
-
-        let mut primitives = Vec::new();
-
-        explain_layout(layout, color, &mut primitives);
-        primitives.push(primitive);
-
-        (Primitive::Group { primitives }, cursor)
-    }
-}
-
-fn explain_layout(
-    layout: Layout<'_>,
-    color: Color,
-    primitives: &mut Vec<Primitive>,
-) {
-    primitives.push(Primitive::Quad {
-        bounds: layout.bounds(),
-        background: Background::Color(Color::TRANSPARENT),
-        border_radius: 0.0,
-        border_width: 1.0,
-        border_color: [0.6, 0.6, 0.6, 0.5].into(),
-    });
-
-    for child in layout.children() {
-        explain_layout(child, color, primitives);
-    }
+    fn with_layer(&mut self, _bounds: Rectangle, _f: impl FnOnce(&mut Self)) {}
 }
diff --git a/graphics/src/widget/button.rs b/graphics/src/widget/button.rs
index 60400ed8..990aac9f 100644
--- a/graphics/src/widget/button.rs
+++ b/graphics/src/widget/button.rs
@@ -1,12 +1,8 @@
 //! Allow your users to perform actions by pressing a button.
 //!
 //! A [`Button`] has some local [`State`].
-use crate::defaults::{self, Defaults};
-use crate::{Backend, Primitive, Renderer};
-use iced_native::mouse;
-use iced_native::{
-    Background, Color, Element, Layout, Padding, Point, Rectangle, Vector,
-};
+use crate::{Backend, Renderer};
+use iced_native::Padding;
 
 pub use iced_native::button::State;
 pub use iced_style::button::{Style, StyleSheet};
@@ -24,88 +20,4 @@ where
     const DEFAULT_PADDING: Padding = Padding::new(5);
 
     type Style = Box<dyn StyleSheet>;
-
-    fn draw<Message>(
-        &mut self,
-        _defaults: &Defaults,
-        bounds: Rectangle,
-        cursor_position: Point,
-        is_disabled: bool,
-        is_pressed: bool,
-        style: &Box<dyn StyleSheet>,
-        content: &Element<'_, Message, Self>,
-        content_layout: Layout<'_>,
-    ) -> Self::Output {
-        let is_mouse_over = bounds.contains(cursor_position);
-
-        let styling = if is_disabled {
-            style.disabled()
-        } else if is_mouse_over {
-            if is_pressed {
-                style.pressed()
-            } else {
-                style.hovered()
-            }
-        } else {
-            style.active()
-        };
-
-        let (content, _) = content.draw(
-            self,
-            &Defaults {
-                text: defaults::Text {
-                    color: styling.text_color,
-                },
-            },
-            content_layout,
-            cursor_position,
-            &bounds,
-        );
-
-        (
-            if styling.background.is_some() || styling.border_width > 0.0 {
-                let background = Primitive::Quad {
-                    bounds,
-                    background: styling
-                        .background
-                        .unwrap_or(Background::Color(Color::TRANSPARENT)),
-                    border_radius: styling.border_radius,
-                    border_width: styling.border_width,
-                    border_color: styling.border_color,
-                };
-
-                if styling.shadow_offset == Vector::default() {
-                    Primitive::Group {
-                        primitives: vec![background, content],
-                    }
-                } else {
-                    // TODO: Implement proper shadow support
-                    let shadow = Primitive::Quad {
-                        bounds: Rectangle {
-                            x: bounds.x + styling.shadow_offset.x,
-                            y: bounds.y + styling.shadow_offset.y,
-                            ..bounds
-                        },
-                        background: Background::Color(
-                            [0.0, 0.0, 0.0, 0.5].into(),
-                        ),
-                        border_radius: styling.border_radius,
-                        border_width: 0.0,
-                        border_color: Color::TRANSPARENT,
-                    };
-
-                    Primitive::Group {
-                        primitives: vec![shadow, background, content],
-                    }
-                }
-            } else {
-                content
-            },
-            if is_mouse_over && !is_disabled {
-                mouse::Interaction::Pointer
-            } else {
-                mouse::Interaction::default()
-            },
-        )
-    }
 }
diff --git a/graphics/src/widget/canvas.rs b/graphics/src/widget/canvas.rs
index 7897c8ec..7bf00ca5 100644
--- a/graphics/src/widget/canvas.rs
+++ b/graphics/src/widget/canvas.rs
@@ -3,12 +3,10 @@
 //! A [`Canvas`] widget can be used to draw different kinds of 2D shapes in a
 //! [`Frame`]. It can be used for animation, data visualization, game graphics,
 //! and more!
-use crate::{Backend, Defaults, Primitive, Renderer};
+use crate::{Backend, Defaults, Renderer};
 use iced_native::layout;
-use iced_native::mouse;
 use iced_native::{
-    Clipboard, Element, Hasher, Layout, Length, Point, Rectangle, Size, Vector,
-    Widget,
+    Clipboard, Element, Hasher, Layout, Length, Point, Rectangle, Size, Widget,
 };
 use std::hash::Hash;
 use std::marker::PhantomData;
@@ -190,28 +188,29 @@ where
         &self,
         _renderer: &mut Renderer<B>,
         _defaults: &Defaults,
-        layout: Layout<'_>,
-        cursor_position: Point,
+        _layout: Layout<'_>,
+        _cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> (Primitive, mouse::Interaction) {
-        let bounds = layout.bounds();
-        let translation = Vector::new(bounds.x, bounds.y);
-        let cursor = Cursor::from_window_position(cursor_position);
-
-        (
-            Primitive::Translate {
-                translation,
-                content: Box::new(Primitive::Group {
-                    primitives: self
-                        .program
-                        .draw(bounds, cursor)
-                        .into_iter()
-                        .map(Geometry::into_primitive)
-                        .collect(),
-                }),
-            },
-            self.program.mouse_interaction(bounds, cursor),
-        )
+    ) {
+        // let bounds = layout.bounds();
+        // let translation = Vector::new(bounds.x, bounds.y);
+        // let cursor = Cursor::from_window_position(cursor_position);
+
+        // (
+        //     Primitive::Translate {
+        //         translation,
+        //         content: Box::new(Primitive::Group {
+        //             primitives: self
+        //                 .program
+        //                 .draw(bounds, cursor)
+        //                 .into_iter()
+        //                 .map(Geometry::into_primitive)
+        //                 .collect(),
+        //         }),
+        //     },
+        //     self.program.mouse_interaction(bounds, cursor),
+        // )
+        // TODO
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
diff --git a/graphics/src/widget/checkbox.rs b/graphics/src/widget/checkbox.rs
index 620bfc9e..3b756525 100644
--- a/graphics/src/widget/checkbox.rs
+++ b/graphics/src/widget/checkbox.rs
@@ -1,10 +1,8 @@
 //! Show toggle controls using checkboxes.
-use crate::alignment;
 use crate::backend::{self, Backend};
-use crate::{Primitive, Rectangle, Renderer};
+use crate::Renderer;
 
 use iced_native::checkbox;
-use iced_native::mouse;
 
 pub use iced_style::checkbox::{Style, StyleSheet};
 
@@ -22,56 +20,4 @@ where
 
     const DEFAULT_SIZE: u16 = 20;
     const DEFAULT_SPACING: u16 = 15;
-
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        is_checked: bool,
-        is_mouse_over: bool,
-        (label, _): Self::Output,
-        style_sheet: &Self::Style,
-    ) -> Self::Output {
-        let style = if is_mouse_over {
-            style_sheet.hovered(is_checked)
-        } else {
-            style_sheet.active(is_checked)
-        };
-
-        let checkbox = Primitive::Quad {
-            bounds,
-            background: style.background,
-            border_radius: style.border_radius,
-            border_width: style.border_width,
-            border_color: style.border_color,
-        };
-
-        (
-            Primitive::Group {
-                primitives: if is_checked {
-                    let check = Primitive::Text {
-                        content: B::CHECKMARK_ICON.to_string(),
-                        font: B::ICON_FONT,
-                        size: bounds.height * 0.7,
-                        bounds: Rectangle {
-                            x: bounds.center_x(),
-                            y: bounds.center_y(),
-                            ..bounds
-                        },
-                        color: style.checkmark_color,
-                        horizontal_alignment: alignment::Horizontal::Center,
-                        vertical_alignment: alignment::Vertical::Center,
-                    };
-
-                    vec![checkbox, check, label]
-                } else {
-                    vec![checkbox, label]
-                },
-            },
-            if is_mouse_over {
-                mouse::Interaction::Pointer
-            } else {
-                mouse::Interaction::default()
-            },
-        )
-    }
 }
diff --git a/graphics/src/widget/column.rs b/graphics/src/widget/column.rs
index 0cf56842..567529e5 100644
--- a/graphics/src/widget/column.rs
+++ b/graphics/src/widget/column.rs
@@ -1,49 +1,5 @@
-use crate::{Backend, Primitive, Renderer};
-use iced_native::column;
-use iced_native::mouse;
-use iced_native::{Element, Layout, Point, Rectangle};
+use crate::Renderer;
 
 /// A container that distributes its contents vertically.
 pub type Column<'a, Message, Backend> =
     iced_native::Column<'a, Message, Renderer<Backend>>;
-
-impl<B> column::Renderer for Renderer<B>
-where
-    B: Backend,
-{
-    fn draw<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        content: &[Element<'_, Message, Self>],
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output {
-        let mut mouse_interaction = mouse::Interaction::default();
-
-        (
-            Primitive::Group {
-                primitives: content
-                    .iter()
-                    .zip(layout.children())
-                    .map(|(child, layout)| {
-                        let (primitive, new_mouse_interaction) = child.draw(
-                            self,
-                            defaults,
-                            layout,
-                            cursor_position,
-                            viewport,
-                        );
-
-                        if new_mouse_interaction > mouse_interaction {
-                            mouse_interaction = new_mouse_interaction;
-                        }
-
-                        primitive
-                    })
-                    .collect(),
-            },
-            mouse_interaction,
-        )
-    }
-}
diff --git a/graphics/src/widget/container.rs b/graphics/src/widget/container.rs
index aae3e1d8..811a0c7f 100644
--- a/graphics/src/widget/container.rs
+++ b/graphics/src/widget/container.rs
@@ -1,8 +1,6 @@
 //! Decorate content and apply alignment.
 use crate::container;
-use crate::defaults::{self, Defaults};
-use crate::{Backend, Primitive, Renderer};
-use iced_native::{Background, Color, Element, Layout, Point, Rectangle};
+use crate::{Backend, Renderer};
 
 pub use iced_style::container::{Style, StyleSheet};
 
@@ -18,61 +16,4 @@ where
     B: Backend,
 {
     type Style = Box<dyn container::StyleSheet>;
-
-    fn draw<Message>(
-        &mut self,
-        defaults: &Defaults,
-        bounds: Rectangle,
-        cursor_position: Point,
-        viewport: &Rectangle,
-        style_sheet: &Self::Style,
-        content: &Element<'_, Message, Self>,
-        content_layout: Layout<'_>,
-    ) -> Self::Output {
-        let style = style_sheet.style();
-
-        let defaults = Defaults {
-            text: defaults::Text {
-                color: style.text_color.unwrap_or(defaults.text.color),
-            },
-        };
-
-        let (content, mouse_interaction) = content.draw(
-            self,
-            &defaults,
-            content_layout,
-            cursor_position,
-            viewport,
-        );
-
-        if let Some(background) = background(bounds, &style) {
-            (
-                Primitive::Group {
-                    primitives: vec![background, content],
-                },
-                mouse_interaction,
-            )
-        } else {
-            (content, mouse_interaction)
-        }
-    }
-}
-
-pub(crate) fn background(
-    bounds: Rectangle,
-    style: &container::Style,
-) -> Option<Primitive> {
-    if style.background.is_some() || style.border_width > 0.0 {
-        Some(Primitive::Quad {
-            bounds,
-            background: style
-                .background
-                .unwrap_or(Background::Color(Color::TRANSPARENT)),
-            border_radius: style.border_radius,
-            border_width: style.border_width,
-            border_color: style.border_color,
-        })
-    } else {
-        None
-    }
 }
diff --git a/graphics/src/widget/image.rs b/graphics/src/widget/image.rs
index bdf03de3..b55ba32f 100644
--- a/graphics/src/widget/image.rs
+++ b/graphics/src/widget/image.rs
@@ -3,10 +3,8 @@ pub mod viewer;
 
 use crate::backend::{self, Backend};
 
-use crate::{Primitive, Renderer};
+use crate::Renderer;
 use iced_native::image;
-use iced_native::mouse;
-use iced_native::Layout;
 
 pub use iced_native::image::{Handle, Image, Viewer};
 
@@ -17,18 +15,4 @@ where
     fn dimensions(&self, handle: &image::Handle) -> (u32, u32) {
         self.backend().dimensions(handle)
     }
-
-    fn draw(
-        &mut self,
-        handle: image::Handle,
-        layout: Layout<'_>,
-    ) -> Self::Output {
-        (
-            Primitive::Image {
-                handle,
-                bounds: layout.bounds(),
-            },
-            mouse::Interaction::default(),
-        )
-    }
 }
diff --git a/graphics/src/widget/image/viewer.rs b/graphics/src/widget/image/viewer.rs
index 28dffc4f..ea7d8591 100644
--- a/graphics/src/widget/image/viewer.rs
+++ b/graphics/src/widget/image/viewer.rs
@@ -1,55 +1,2 @@
 //! Zoom and pan on an image.
-use crate::backend::{self, Backend};
-use crate::{Primitive, Renderer};
-
-use iced_native::image;
-use iced_native::image::viewer;
-use iced_native::mouse;
-use iced_native::{Rectangle, Size, Vector};
-
-impl<B> viewer::Renderer for Renderer<B>
-where
-    B: Backend + backend::Image,
-{
-    fn draw(
-        &mut self,
-        state: &viewer::State,
-        bounds: Rectangle,
-        image_size: Size,
-        translation: Vector,
-        handle: image::Handle,
-        is_mouse_over: bool,
-    ) -> Self::Output {
-        (
-            {
-                Primitive::Clip {
-                    bounds,
-                    content: Box::new(Primitive::Translate {
-                        translation,
-                        content: Box::new(Primitive::Image {
-                            handle,
-                            bounds: Rectangle {
-                                x: bounds.x,
-                                y: bounds.y,
-                                ..Rectangle::with_size(image_size)
-                            },
-                        }),
-                    }),
-                    offset: Vector::new(0, 0),
-                }
-            },
-            {
-                if state.is_cursor_grabbed() {
-                    mouse::Interaction::Grabbing
-                } else if is_mouse_over
-                    && (image_size.width > bounds.width
-                        || image_size.height > bounds.height)
-                {
-                    mouse::Interaction::Grab
-                } else {
-                    mouse::Interaction::Idle
-                }
-            },
-        )
-    }
-}
+pub use iced_native::image::Viewer;
diff --git a/graphics/src/widget/pane_grid.rs b/graphics/src/widget/pane_grid.rs
index 92cdbb77..8c6b0f82 100644
--- a/graphics/src/widget/pane_grid.rs
+++ b/graphics/src/widget/pane_grid.rs
@@ -7,12 +7,8 @@
 //! drag and drop, and hotkey support.
 //!
 //! [`pane_grid` example]: https://github.com/hecrj/iced/tree/0.3/examples/pane_grid
-use crate::defaults;
-use crate::{Backend, Color, Primitive, Renderer};
-use iced_native::container;
-use iced_native::mouse;
+use crate::{Backend, Renderer};
 use iced_native::pane_grid;
-use iced_native::{Element, Layout, Point, Rectangle, Vector};
 
 pub use iced_native::pane_grid::{
     Axis, Configuration, Content, Direction, DragEvent, Node, Pane,
@@ -35,270 +31,4 @@ where
     B: Backend,
 {
     type Style = Box<dyn StyleSheet>;
-
-    fn draw<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        content: &[(Pane, Content<'_, Message, Self>)],
-        dragging: Option<(Pane, Point)>,
-        resizing: Option<(Axis, Rectangle, bool)>,
-        layout: Layout<'_>,
-        style_sheet: &<Self as pane_grid::Renderer>::Style,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output {
-        let pane_cursor_position = if dragging.is_some() {
-            // TODO: Remove once cursor availability is encoded in the type
-            // system
-            Point::new(-1.0, -1.0)
-        } else {
-            cursor_position
-        };
-
-        let mut mouse_interaction = mouse::Interaction::default();
-        let mut dragged_pane = None;
-
-        let mut panes: Vec<_> = content
-            .iter()
-            .zip(layout.children())
-            .enumerate()
-            .map(|(i, ((id, pane), layout))| {
-                let (primitive, new_mouse_interaction) = pane.draw(
-                    self,
-                    defaults,
-                    layout,
-                    pane_cursor_position,
-                    viewport,
-                );
-
-                if new_mouse_interaction > mouse_interaction {
-                    mouse_interaction = new_mouse_interaction;
-                }
-
-                if let Some((dragging, origin)) = dragging {
-                    if *id == dragging {
-                        dragged_pane = Some((i, layout, origin));
-                    }
-                }
-
-                primitive
-            })
-            .collect();
-
-        let mut primitives = if let Some((index, layout, origin)) = dragged_pane
-        {
-            let pane = panes.remove(index);
-            let bounds = layout.bounds();
-
-            // TODO: Fix once proper layering is implemented.
-            // This is a pretty hacky way to achieve layering.
-            let clip = Primitive::Clip {
-                bounds: Rectangle {
-                    x: cursor_position.x - origin.x,
-                    y: cursor_position.y - origin.y,
-                    width: bounds.width + 0.5,
-                    height: bounds.height + 0.5,
-                },
-                offset: Vector::new(0, 0),
-                content: Box::new(Primitive::Translate {
-                    translation: Vector::new(
-                        cursor_position.x - bounds.x - origin.x,
-                        cursor_position.y - bounds.y - origin.y,
-                    ),
-                    content: Box::new(pane),
-                }),
-            };
-
-            panes.push(clip);
-
-            panes
-        } else {
-            panes
-        };
-
-        let (primitives, mouse_interaction) =
-            if let Some((axis, split_region, is_picked)) = resizing {
-                let highlight = if is_picked {
-                    style_sheet.picked_split()
-                } else {
-                    style_sheet.hovered_split()
-                };
-
-                if let Some(highlight) = highlight {
-                    primitives.push(Primitive::Quad {
-                        bounds: match axis {
-                            Axis::Horizontal => Rectangle {
-                                x: split_region.x,
-                                y: (split_region.y
-                                    + (split_region.height - highlight.width)
-                                        / 2.0)
-                                    .round(),
-                                width: split_region.width,
-                                height: highlight.width,
-                            },
-                            Axis::Vertical => Rectangle {
-                                x: (split_region.x
-                                    + (split_region.width - highlight.width)
-                                        / 2.0)
-                                    .round(),
-                                y: split_region.y,
-                                width: highlight.width,
-                                height: split_region.height,
-                            },
-                        },
-                        background: highlight.color.into(),
-                        border_radius: 0.0,
-                        border_width: 0.0,
-                        border_color: Color::TRANSPARENT,
-                    });
-                }
-
-                (
-                    primitives,
-                    match axis {
-                        Axis::Horizontal => {
-                            mouse::Interaction::ResizingVertically
-                        }
-                        Axis::Vertical => {
-                            mouse::Interaction::ResizingHorizontally
-                        }
-                    },
-                )
-            } else {
-                (primitives, mouse_interaction)
-            };
-
-        (
-            Primitive::Group { primitives },
-            if dragging.is_some() {
-                mouse::Interaction::Grabbing
-            } else {
-                mouse_interaction
-            },
-        )
-    }
-
-    fn draw_pane<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        bounds: Rectangle,
-        style_sheet: &<Self as container::Renderer>::Style,
-        title_bar: Option<(&TitleBar<'_, Message, Self>, Layout<'_>)>,
-        body: (&Element<'_, Message, Self>, Layout<'_>),
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output {
-        let style = style_sheet.style();
-        let (body, body_layout) = body;
-
-        let (body_primitive, body_interaction) =
-            body.draw(self, defaults, body_layout, cursor_position, viewport);
-
-        let background = crate::widget::container::background(bounds, &style);
-
-        if let Some((title_bar, title_bar_layout)) = title_bar {
-            let show_controls = bounds.contains(cursor_position);
-            let is_over_pick_area =
-                title_bar.is_over_pick_area(title_bar_layout, cursor_position);
-
-            let (title_bar_primitive, title_bar_interaction) = title_bar.draw(
-                self,
-                defaults,
-                title_bar_layout,
-                cursor_position,
-                viewport,
-                show_controls,
-            );
-
-            (
-                Primitive::Group {
-                    primitives: vec![
-                        background.unwrap_or(Primitive::None),
-                        title_bar_primitive,
-                        body_primitive,
-                    ],
-                },
-                if title_bar_interaction > body_interaction {
-                    title_bar_interaction
-                } else if is_over_pick_area {
-                    mouse::Interaction::Grab
-                } else {
-                    body_interaction
-                },
-            )
-        } else {
-            (
-                if let Some(background) = background {
-                    Primitive::Group {
-                        primitives: vec![background, body_primitive],
-                    }
-                } else {
-                    body_primitive
-                },
-                body_interaction,
-            )
-        }
-    }
-
-    fn draw_title_bar<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        bounds: Rectangle,
-        style_sheet: &<Self as container::Renderer>::Style,
-        content: (&Element<'_, Message, Self>, Layout<'_>),
-        controls: Option<(&Element<'_, Message, Self>, Layout<'_>)>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output {
-        let style = style_sheet.style();
-        let (title_content, title_layout) = content;
-
-        let defaults = Self::Defaults {
-            text: defaults::Text {
-                color: style.text_color.unwrap_or(defaults.text.color),
-            },
-        };
-
-        let background = crate::widget::container::background(bounds, &style);
-
-        let (title_primitive, title_interaction) = title_content.draw(
-            self,
-            &defaults,
-            title_layout,
-            cursor_position,
-            viewport,
-        );
-
-        if let Some((controls, controls_layout)) = controls {
-            let (controls_primitive, controls_interaction) = controls.draw(
-                self,
-                &defaults,
-                controls_layout,
-                cursor_position,
-                viewport,
-            );
-
-            (
-                Primitive::Group {
-                    primitives: vec![
-                        background.unwrap_or(Primitive::None),
-                        title_primitive,
-                        controls_primitive,
-                    ],
-                },
-                controls_interaction.max(title_interaction),
-            )
-        } else {
-            (
-                if let Some(background) = background {
-                    Primitive::Group {
-                        primitives: vec![background, title_primitive],
-                    }
-                } else {
-                    title_primitive
-                },
-                title_interaction,
-            )
-        }
-    }
 }
diff --git a/graphics/src/widget/pick_list.rs b/graphics/src/widget/pick_list.rs
index 532840b8..54f42cde 100644
--- a/graphics/src/widget/pick_list.rs
+++ b/graphics/src/widget/pick_list.rs
@@ -1,9 +1,8 @@
 //! Display a dropdown list of selectable values.
-use crate::alignment;
 use crate::backend::{self, Backend};
-use crate::{Primitive, Renderer};
+use crate::Renderer;
 
-use iced_native::{mouse, Font, Padding, Point, Rectangle};
+use iced_native::Padding;
 use iced_style::menu;
 
 pub use iced_native::pick_list::State;
@@ -24,80 +23,4 @@ where
     fn menu_style(style: &Box<dyn StyleSheet>) -> menu::Style {
         style.menu()
     }
-
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        cursor_position: Point,
-        selected: Option<String>,
-        placeholder: Option<&str>,
-        padding: Padding,
-        text_size: u16,
-        font: Font,
-        style: &Box<dyn StyleSheet>,
-    ) -> Self::Output {
-        let is_mouse_over = bounds.contains(cursor_position);
-        let is_selected = selected.is_some();
-
-        let style = if is_mouse_over {
-            style.hovered()
-        } else {
-            style.active()
-        };
-
-        let background = Primitive::Quad {
-            bounds,
-            background: style.background,
-            border_color: style.border_color,
-            border_width: style.border_width,
-            border_radius: style.border_radius,
-        };
-
-        let arrow_down = Primitive::Text {
-            content: B::ARROW_DOWN_ICON.to_string(),
-            font: B::ICON_FONT,
-            size: bounds.height * style.icon_size,
-            bounds: Rectangle {
-                x: bounds.x + bounds.width - f32::from(padding.horizontal()),
-                y: bounds.center_y(),
-                ..bounds
-            },
-            color: style.text_color,
-            horizontal_alignment: alignment::Horizontal::Right,
-            vertical_alignment: alignment::Vertical::Center,
-        };
-
-        (
-            Primitive::Group {
-                primitives: if let Some(label) =
-                    selected.or_else(|| placeholder.map(str::to_string))
-                {
-                    let label = Primitive::Text {
-                        content: label,
-                        size: f32::from(text_size),
-                        font,
-                        color: is_selected
-                            .then(|| style.text_color)
-                            .unwrap_or(style.placeholder_color),
-                        bounds: Rectangle {
-                            x: bounds.x + f32::from(padding.left),
-                            y: bounds.center_y(),
-                            ..bounds
-                        },
-                        horizontal_alignment: alignment::Horizontal::Left,
-                        vertical_alignment: alignment::Vertical::Center,
-                    };
-
-                    vec![background, label, arrow_down]
-                } else {
-                    vec![background, arrow_down]
-                },
-            },
-            if is_mouse_over {
-                mouse::Interaction::Pointer
-            } else {
-                mouse::Interaction::default()
-            },
-        )
-    }
 }
diff --git a/graphics/src/widget/progress_bar.rs b/graphics/src/widget/progress_bar.rs
index 32ee42c6..3d21b7b9 100644
--- a/graphics/src/widget/progress_bar.rs
+++ b/graphics/src/widget/progress_bar.rs
@@ -2,10 +2,8 @@
 //!
 //! A [`ProgressBar`] has a range of possible values and a current value,
 //! as well as a length, height and style.
-use crate::{Backend, Primitive, Renderer};
-use iced_native::mouse;
+use crate::{Backend, Renderer};
 use iced_native::progress_bar;
-use iced_native::{Color, Rectangle};
 
 pub use iced_style::progress_bar::{Style, StyleSheet};
 
@@ -22,53 +20,4 @@ where
     type Style = Box<dyn StyleSheet>;
 
     const DEFAULT_HEIGHT: u16 = 30;
-
-    fn draw(
-        &self,
-        bounds: Rectangle,
-        range: std::ops::RangeInclusive<f32>,
-        value: f32,
-        style_sheet: &Self::Style,
-    ) -> Self::Output {
-        let style = style_sheet.style();
-        let (range_start, range_end) = range.into_inner();
-
-        let active_progress_width = if range_start >= range_end {
-            0.0
-        } else {
-            bounds.width * (value - range_start) / (range_end - range_start)
-        };
-
-        let background = Primitive::Group {
-            primitives: vec![Primitive::Quad {
-                bounds: Rectangle { ..bounds },
-                background: style.background,
-                border_radius: style.border_radius,
-                border_width: 0.0,
-                border_color: Color::TRANSPARENT,
-            }],
-        };
-
-        (
-            if active_progress_width > 0.0 {
-                let bar = Primitive::Quad {
-                    bounds: Rectangle {
-                        width: active_progress_width,
-                        ..bounds
-                    },
-                    background: style.bar,
-                    border_radius: style.border_radius,
-                    border_width: 0.0,
-                    border_color: Color::TRANSPARENT,
-                };
-
-                Primitive::Group {
-                    primitives: vec![background, bar],
-                }
-            } else {
-                background
-            },
-            mouse::Interaction::default(),
-        )
-    }
 }
diff --git a/graphics/src/widget/qr_code.rs b/graphics/src/widget/qr_code.rs
index b3a01dd7..a809d99f 100644
--- a/graphics/src/widget/qr_code.rs
+++ b/graphics/src/widget/qr_code.rs
@@ -1,10 +1,10 @@
 //! Encode and display information in a QR code.
 use crate::canvas;
-use crate::{Backend, Defaults, Primitive, Renderer, Vector};
+use crate::{Backend, Defaults, Renderer};
 
 use iced_native::{
-    layout, mouse, Color, Element, Hasher, Layout, Length, Point, Rectangle,
-    Size, Widget,
+    layout, Color, Element, Hasher, Layout, Length, Point, Rectangle, Size,
+    Widget,
 };
 use thiserror::Error;
 
@@ -82,53 +82,54 @@ where
         &self,
         _renderer: &mut Renderer<B>,
         _defaults: &Defaults,
-        layout: Layout<'_>,
+        _layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> (Primitive, mouse::Interaction) {
-        let bounds = layout.bounds();
-        let side_length = self.state.width + 2 * QUIET_ZONE;
-
-        // Reuse cache if possible
-        let geometry = self.state.cache.draw(bounds.size(), |frame| {
-            // Scale units to cell size
-            frame.scale(f32::from(self.cell_size));
-
-            // Draw background
-            frame.fill_rectangle(
-                Point::ORIGIN,
-                Size::new(side_length as f32, side_length as f32),
-                self.light,
-            );
-
-            // Avoid drawing on the quiet zone
-            frame.translate(Vector::new(QUIET_ZONE as f32, QUIET_ZONE as f32));
-
-            // Draw contents
-            self.state
-                .contents
-                .iter()
-                .enumerate()
-                .filter(|(_, value)| **value == qrcode::Color::Dark)
-                .for_each(|(index, _)| {
-                    let row = index / self.state.width;
-                    let column = index % self.state.width;
-
-                    frame.fill_rectangle(
-                        Point::new(column as f32, row as f32),
-                        Size::UNIT,
-                        self.dark,
-                    );
-                });
-        });
-
-        (
-            Primitive::Translate {
-                translation: Vector::new(bounds.x, bounds.y),
-                content: Box::new(geometry.into_primitive()),
-            },
-            mouse::Interaction::default(),
-        )
+    ) {
+        // let bounds = layout.bounds();
+        // let side_length = self.state.width + 2 * QUIET_ZONE;
+
+        // // Reuse cache if possible
+        // let geometry = self.state.cache.draw(bounds.size(), |frame| {
+        //     // Scale units to cell size
+        //     frame.scale(f32::from(self.cell_size));
+
+        //     // Draw background
+        //     frame.fill_rectangle(
+        //         Point::ORIGIN,
+        //         Size::new(side_length as f32, side_length as f32),
+        //         self.light,
+        //     );
+
+        //     // Avoid drawing on the quiet zone
+        //     frame.translate(Vector::new(QUIET_ZONE as f32, QUIET_ZONE as f32));
+
+        //     // Draw contents
+        //     self.state
+        //         .contents
+        //         .iter()
+        //         .enumerate()
+        //         .filter(|(_, value)| **value == qrcode::Color::Dark)
+        //         .for_each(|(index, _)| {
+        //             let row = index / self.state.width;
+        //             let column = index % self.state.width;
+
+        //             frame.fill_rectangle(
+        //                 Point::new(column as f32, row as f32),
+        //                 Size::UNIT,
+        //                 self.dark,
+        //             );
+        //         });
+        // });
+
+        // (
+        //     Primitive::Translate {
+        //         translation: Vector::new(bounds.x, bounds.y),
+        //         content: Box::new(geometry.into_primitive()),
+        //     },
+        //     mouse::Interaction::default(),
+        // )
+        // TODO
     }
 }
 
diff --git a/graphics/src/widget/radio.rs b/graphics/src/widget/radio.rs
index fd3d8145..cd83f2ff 100644
--- a/graphics/src/widget/radio.rs
+++ b/graphics/src/widget/radio.rs
@@ -1,8 +1,6 @@
 //! Create choices using radio buttons.
-use crate::{Backend, Primitive, Renderer};
-use iced_native::mouse;
+use crate::{Backend, Renderer};
 use iced_native::radio;
-use iced_native::{Background, Color, Rectangle};
 
 pub use iced_style::radio::{Style, StyleSheet};
 
@@ -21,58 +19,4 @@ where
 
     const DEFAULT_SIZE: u16 = 28;
     const DEFAULT_SPACING: u16 = 15;
-
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        is_selected: bool,
-        is_mouse_over: bool,
-        (label, _): Self::Output,
-        style_sheet: &Self::Style,
-    ) -> Self::Output {
-        let style = if is_mouse_over {
-            style_sheet.hovered()
-        } else {
-            style_sheet.active()
-        };
-
-        let size = bounds.width;
-        let dot_size = size / 2.0;
-
-        let radio = Primitive::Quad {
-            bounds,
-            background: style.background,
-            border_radius: size / 2.0,
-            border_width: style.border_width,
-            border_color: style.border_color,
-        };
-
-        (
-            Primitive::Group {
-                primitives: if is_selected {
-                    let radio_circle = Primitive::Quad {
-                        bounds: Rectangle {
-                            x: bounds.x + dot_size / 2.0,
-                            y: bounds.y + dot_size / 2.0,
-                            width: bounds.width - dot_size,
-                            height: bounds.height - dot_size,
-                        },
-                        background: Background::Color(style.dot_color),
-                        border_radius: dot_size / 2.0,
-                        border_width: 0.0,
-                        border_color: Color::TRANSPARENT,
-                    };
-
-                    vec![radio, radio_circle, label]
-                } else {
-                    vec![radio, label]
-                },
-            },
-            if is_mouse_over {
-                mouse::Interaction::Pointer
-            } else {
-                mouse::Interaction::default()
-            },
-        )
-    }
 }
diff --git a/graphics/src/widget/row.rs b/graphics/src/widget/row.rs
index 397d80bf..55960c04 100644
--- a/graphics/src/widget/row.rs
+++ b/graphics/src/widget/row.rs
@@ -1,49 +1,5 @@
-use crate::{Backend, Primitive, Renderer};
-use iced_native::mouse;
-use iced_native::row;
-use iced_native::{Element, Layout, Point, Rectangle};
+use crate::Renderer;
 
 /// A container that distributes its contents horizontally.
 pub type Row<'a, Message, Backend> =
     iced_native::Row<'a, Message, Renderer<Backend>>;
-
-impl<B> row::Renderer for Renderer<B>
-where
-    B: Backend,
-{
-    fn draw<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        content: &[Element<'_, Message, Self>],
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output {
-        let mut mouse_interaction = mouse::Interaction::default();
-
-        (
-            Primitive::Group {
-                primitives: content
-                    .iter()
-                    .zip(layout.children())
-                    .map(|(child, layout)| {
-                        let (primitive, new_mouse_interaction) = child.draw(
-                            self,
-                            defaults,
-                            layout,
-                            cursor_position,
-                            viewport,
-                        );
-
-                        if new_mouse_interaction > mouse_interaction {
-                            mouse_interaction = new_mouse_interaction;
-                        }
-
-                        primitive
-                    })
-                    .collect(),
-            },
-            mouse_interaction,
-        )
-    }
-}
diff --git a/graphics/src/widget/rule.rs b/graphics/src/widget/rule.rs
index 835ebed8..62766f82 100644
--- a/graphics/src/widget/rule.rs
+++ b/graphics/src/widget/rule.rs
@@ -1,9 +1,7 @@
 //! Display a horizontal or vertical rule for dividing content.
 
-use crate::{Backend, Primitive, Renderer};
-use iced_native::mouse;
+use crate::{Backend, Renderer};
 use iced_native::rule;
-use iced_native::{Background, Color, Rectangle};
 
 pub use iced_style::rule::{FillMode, Style, StyleSheet};
 
@@ -17,57 +15,4 @@ where
     B: Backend,
 {
     type Style = Box<dyn StyleSheet>;
-
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        style_sheet: &Self::Style,
-        is_horizontal: bool,
-    ) -> Self::Output {
-        let style = style_sheet.style();
-
-        let line = if is_horizontal {
-            let line_y = (bounds.y + (bounds.height / 2.0)
-                - (style.width as f32 / 2.0))
-                .round();
-
-            let (offset, line_width) = style.fill_mode.fill(bounds.width);
-            let line_x = bounds.x + offset;
-
-            Primitive::Quad {
-                bounds: Rectangle {
-                    x: line_x,
-                    y: line_y,
-                    width: line_width,
-                    height: style.width as f32,
-                },
-                background: Background::Color(style.color),
-                border_radius: style.radius,
-                border_width: 0.0,
-                border_color: Color::TRANSPARENT,
-            }
-        } else {
-            let line_x = (bounds.x + (bounds.width / 2.0)
-                - (style.width as f32 / 2.0))
-                .round();
-
-            let (offset, line_height) = style.fill_mode.fill(bounds.height);
-            let line_y = bounds.y + offset;
-
-            Primitive::Quad {
-                bounds: Rectangle {
-                    x: line_x,
-                    y: line_y,
-                    width: style.width as f32,
-                    height: line_height,
-                },
-                background: Background::Color(style.color),
-                border_radius: style.radius,
-                border_width: 0.0,
-                border_color: Color::TRANSPARENT,
-            }
-        };
-
-        (line, mouse::Interaction::default())
-    }
 }
diff --git a/graphics/src/widget/scrollable.rs b/graphics/src/widget/scrollable.rs
index 2220e4b8..f1fe0d2d 100644
--- a/graphics/src/widget/scrollable.rs
+++ b/graphics/src/widget/scrollable.rs
@@ -1,8 +1,7 @@
 //! Navigate an endless amount of content with a scrollbar.
-use crate::{Backend, Primitive, Renderer};
-use iced_native::mouse;
+use crate::{Backend, Renderer};
 use iced_native::scrollable;
-use iced_native::{Background, Color, Rectangle, Vector};
+use iced_native::Rectangle;
 
 pub use iced_native::scrollable::State;
 pub use iced_style::scrollable::{Scrollbar, Scroller, StyleSheet};
@@ -73,86 +72,4 @@ where
             None
         }
     }
-
-    fn draw(
-        &mut self,
-        state: &scrollable::State,
-        bounds: Rectangle,
-        _content_bounds: Rectangle,
-        is_mouse_over: bool,
-        is_mouse_over_scrollbar: bool,
-        scrollbar: Option<scrollable::Scrollbar>,
-        offset: u32,
-        style_sheet: &Self::Style,
-        (content, mouse_interaction): Self::Output,
-    ) -> Self::Output {
-        (
-            if let Some(scrollbar) = scrollbar {
-                let clip = Primitive::Clip {
-                    bounds,
-                    offset: Vector::new(0, offset),
-                    content: Box::new(content),
-                };
-
-                let style = if state.is_scroller_grabbed() {
-                    style_sheet.dragging()
-                } else if is_mouse_over_scrollbar {
-                    style_sheet.hovered()
-                } else {
-                    style_sheet.active()
-                };
-
-                let is_scrollbar_visible =
-                    style.background.is_some() || style.border_width > 0.0;
-
-                let scroller = if is_mouse_over
-                    || state.is_scroller_grabbed()
-                    || is_scrollbar_visible
-                {
-                    Primitive::Quad {
-                        bounds: scrollbar.scroller.bounds,
-                        background: Background::Color(style.scroller.color),
-                        border_radius: style.scroller.border_radius,
-                        border_width: style.scroller.border_width,
-                        border_color: style.scroller.border_color,
-                    }
-                } else {
-                    Primitive::None
-                };
-
-                let scrollbar = if is_scrollbar_visible {
-                    Primitive::Quad {
-                        bounds: scrollbar.bounds,
-                        background: style
-                            .background
-                            .unwrap_or(Background::Color(Color::TRANSPARENT)),
-                        border_radius: style.border_radius,
-                        border_width: style.border_width,
-                        border_color: style.border_color,
-                    }
-                } else {
-                    Primitive::None
-                };
-
-                let scroll = Primitive::Clip {
-                    bounds,
-                    offset: Vector::new(0, 0),
-                    content: Box::new(Primitive::Group {
-                        primitives: vec![scrollbar, scroller],
-                    }),
-                };
-
-                Primitive::Group {
-                    primitives: vec![clip, scroll],
-                }
-            } else {
-                content
-            },
-            if is_mouse_over_scrollbar || state.is_scroller_grabbed() {
-                mouse::Interaction::Idle
-            } else {
-                mouse_interaction
-            },
-        )
-    }
 }
diff --git a/graphics/src/widget/slider.rs b/graphics/src/widget/slider.rs
index aeceec3f..5125d66c 100644
--- a/graphics/src/widget/slider.rs
+++ b/graphics/src/widget/slider.rs
@@ -1,10 +1,8 @@
 //! Display an interactive selector of a single value from a range of values.
 //!
 //! A [`Slider`] has some local [`State`].
-use crate::{Backend, Primitive, Renderer};
-use iced_native::mouse;
+use crate::{Backend, Renderer};
 use iced_native::slider;
-use iced_native::{Background, Color, Point, Rectangle};
 
 pub use iced_native::slider::State;
 pub use iced_style::slider::{Handle, HandleShape, Style, StyleSheet};
@@ -23,101 +21,4 @@ where
     type Style = Box<dyn StyleSheet>;
 
     const DEFAULT_HEIGHT: u16 = 22;
-
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        cursor_position: Point,
-        range: std::ops::RangeInclusive<f32>,
-        value: f32,
-        is_dragging: bool,
-        style_sheet: &Self::Style,
-    ) -> Self::Output {
-        let is_mouse_over = bounds.contains(cursor_position);
-
-        let style = if is_dragging {
-            style_sheet.dragging()
-        } else if is_mouse_over {
-            style_sheet.hovered()
-        } else {
-            style_sheet.active()
-        };
-
-        let rail_y = bounds.y + (bounds.height / 2.0).round();
-
-        let (rail_top, rail_bottom) = (
-            Primitive::Quad {
-                bounds: Rectangle {
-                    x: bounds.x,
-                    y: rail_y,
-                    width: bounds.width,
-                    height: 2.0,
-                },
-                background: Background::Color(style.rail_colors.0),
-                border_radius: 0.0,
-                border_width: 0.0,
-                border_color: Color::TRANSPARENT,
-            },
-            Primitive::Quad {
-                bounds: Rectangle {
-                    x: bounds.x,
-                    y: rail_y + 2.0,
-                    width: bounds.width,
-                    height: 2.0,
-                },
-                background: Background::Color(style.rail_colors.1),
-                border_radius: 0.0,
-                border_width: 0.0,
-                border_color: Color::TRANSPARENT,
-            },
-        );
-
-        let (handle_width, handle_height, handle_border_radius) = match style
-            .handle
-            .shape
-        {
-            HandleShape::Circle { radius } => {
-                (radius * 2.0, radius * 2.0, radius)
-            }
-            HandleShape::Rectangle {
-                width,
-                border_radius,
-            } => (f32::from(width), f32::from(bounds.height), border_radius),
-        };
-
-        let (range_start, range_end) = range.into_inner();
-
-        let handle_offset = if range_start >= range_end {
-            0.0
-        } else {
-            (bounds.width - handle_width) * (value - range_start)
-                / (range_end - range_start)
-        };
-
-        let handle = Primitive::Quad {
-            bounds: Rectangle {
-                x: bounds.x + handle_offset.round(),
-                y: rail_y - handle_height / 2.0,
-                width: handle_width,
-                height: handle_height,
-            },
-            background: Background::Color(style.handle.color),
-            border_radius: handle_border_radius,
-            border_width: style.handle.border_width,
-            border_color: style.handle.border_color,
-        };
-
-        (
-            Primitive::Group {
-                primitives: vec![rail_top, rail_bottom, handle],
-            },
-            if is_dragging {
-                mouse::Interaction::Grabbing
-            } else if is_mouse_over {
-                mouse::Interaction::Grab
-            } else {
-                mouse::Interaction::default()
-            },
-        )
-    }
 }
diff --git a/graphics/src/widget/space.rs b/graphics/src/widget/space.rs
index 1f31eabe..a4d60d4b 100644
--- a/graphics/src/widget/space.rs
+++ b/graphics/src/widget/space.rs
@@ -1,15 +1 @@
-use crate::{Backend, Primitive, Renderer};
-use iced_native::mouse;
-use iced_native::space;
-use iced_native::Rectangle;
-
 pub use iced_native::Space;
-
-impl<B> space::Renderer for Renderer<B>
-where
-    B: Backend,
-{
-    fn draw(&mut self, _bounds: Rectangle) -> Self::Output {
-        (Primitive::None, mouse::Interaction::default())
-    }
-}
diff --git a/graphics/src/widget/svg.rs b/graphics/src/widget/svg.rs
index 8b5ed66a..b74a0abb 100644
--- a/graphics/src/widget/svg.rs
+++ b/graphics/src/widget/svg.rs
@@ -1,7 +1,7 @@
 //! Display vector graphics in your application.
 use crate::backend::{self, Backend};
-use crate::{Primitive, Renderer};
-use iced_native::{mouse, svg, Layout};
+use crate::Renderer;
+use iced_native::svg;
 
 pub use iced_native::svg::{Handle, Svg};
 
@@ -12,18 +12,4 @@ where
     fn dimensions(&self, handle: &svg::Handle) -> (u32, u32) {
         self.backend().viewport_dimensions(handle)
     }
-
-    fn draw(
-        &mut self,
-        handle: svg::Handle,
-        layout: Layout<'_>,
-    ) -> Self::Output {
-        (
-            Primitive::Svg {
-                handle,
-                bounds: layout.bounds(),
-            },
-            mouse::Interaction::default(),
-        )
-    }
 }
diff --git a/graphics/src/widget/text.rs b/graphics/src/widget/text.rs
index d6d446d3..2ccd18a1 100644
--- a/graphics/src/widget/text.rs
+++ b/graphics/src/widget/text.rs
@@ -1,10 +1,8 @@
 //! Write some text for your users to read.
 use crate::backend::{self, Backend};
-use crate::{Primitive, Renderer};
-use iced_native::alignment;
-use iced_native::mouse;
+use crate::Renderer;
 use iced_native::text;
-use iced_native::{Color, Font, Point, Rectangle, Size};
+use iced_native::{Font, Point, Size};
 
 /// A paragraph of text.
 ///
@@ -52,41 +50,4 @@ where
             nearest_only,
         )
     }
-
-    fn draw(
-        &mut self,
-        defaults: &Self::Defaults,
-        bounds: Rectangle,
-        content: &str,
-        size: u16,
-        font: Font,
-        color: Option<Color>,
-        horizontal_alignment: alignment::Horizontal,
-        vertical_alignment: alignment::Vertical,
-    ) -> Self::Output {
-        let x = match horizontal_alignment {
-            alignment::Horizontal::Left => bounds.x,
-            alignment::Horizontal::Center => bounds.center_x(),
-            alignment::Horizontal::Right => bounds.x + bounds.width,
-        };
-
-        let y = match vertical_alignment {
-            alignment::Vertical::Top => bounds.y,
-            alignment::Vertical::Center => bounds.center_y(),
-            alignment::Vertical::Bottom => bounds.y + bounds.height,
-        };
-
-        (
-            Primitive::Text {
-                content: content.to_string(),
-                size: f32::from(size),
-                bounds: Rectangle { x, y, ..bounds },
-                color: color.unwrap_or(defaults.text.color),
-                font,
-                horizontal_alignment,
-                vertical_alignment,
-            },
-            mouse::Interaction::default(),
-        )
-    }
 }
diff --git a/graphics/src/widget/text_input.rs b/graphics/src/widget/text_input.rs
index 1516b007..e9dbf056 100644
--- a/graphics/src/widget/text_input.rs
+++ b/graphics/src/widget/text_input.rs
@@ -1,14 +1,9 @@
 //! Display fields that can be filled with text.
 //!
 //! A [`TextInput`] has some local [`State`].
-use crate::alignment;
 use crate::backend::{self, Backend};
-use crate::{
-    Background, Color, Font, Point, Primitive, Rectangle, Renderer, Size,
-    Vector,
-};
+use crate::{Font, Rectangle, Renderer, Size};
 
-use iced_native::mouse;
 use iced_native::text_input::{self, cursor};
 use std::f32;
 
@@ -66,181 +61,6 @@ where
             0.0
         }
     }
-
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        text_bounds: Rectangle,
-        cursor_position: Point,
-        font: Font,
-        size: u16,
-        placeholder: &str,
-        value: &text_input::Value,
-        state: &text_input::State,
-        style_sheet: &Self::Style,
-    ) -> Self::Output {
-        let is_mouse_over = bounds.contains(cursor_position);
-
-        let style = if state.is_focused() {
-            style_sheet.focused()
-        } else if is_mouse_over {
-            style_sheet.hovered()
-        } else {
-            style_sheet.active()
-        };
-
-        let input = Primitive::Quad {
-            bounds,
-            background: style.background,
-            border_radius: style.border_radius,
-            border_width: style.border_width,
-            border_color: style.border_color,
-        };
-
-        let text = value.to_string();
-
-        let text_value = Primitive::Text {
-            content: if text.is_empty() {
-                placeholder.to_string()
-            } else {
-                text.clone()
-            },
-            color: if text.is_empty() {
-                style_sheet.placeholder_color()
-            } else {
-                style_sheet.value_color()
-            },
-            font,
-            bounds: Rectangle {
-                y: text_bounds.center_y(),
-                width: f32::INFINITY,
-                ..text_bounds
-            },
-            size: f32::from(size),
-            horizontal_alignment: alignment::Horizontal::Left,
-            vertical_alignment: alignment::Vertical::Center,
-        };
-
-        let (contents_primitive, offset) = if state.is_focused() {
-            let cursor = state.cursor();
-
-            let (cursor_primitive, offset) = match cursor.state(value) {
-                cursor::State::Index(position) => {
-                    let (text_value_width, offset) =
-                        measure_cursor_and_scroll_offset(
-                            self,
-                            text_bounds,
-                            value,
-                            size,
-                            position,
-                            font,
-                        );
-
-                    (
-                        Primitive::Quad {
-                            bounds: Rectangle {
-                                x: text_bounds.x + text_value_width,
-                                y: text_bounds.y,
-                                width: 1.0,
-                                height: text_bounds.height,
-                            },
-                            background: Background::Color(
-                                style_sheet.value_color(),
-                            ),
-                            border_radius: 0.0,
-                            border_width: 0.0,
-                            border_color: Color::TRANSPARENT,
-                        },
-                        offset,
-                    )
-                }
-                cursor::State::Selection { start, end } => {
-                    let left = start.min(end);
-                    let right = end.max(start);
-
-                    let (left_position, left_offset) =
-                        measure_cursor_and_scroll_offset(
-                            self,
-                            text_bounds,
-                            value,
-                            size,
-                            left,
-                            font,
-                        );
-
-                    let (right_position, right_offset) =
-                        measure_cursor_and_scroll_offset(
-                            self,
-                            text_bounds,
-                            value,
-                            size,
-                            right,
-                            font,
-                        );
-
-                    let width = right_position - left_position;
-
-                    (
-                        Primitive::Quad {
-                            bounds: Rectangle {
-                                x: text_bounds.x + left_position,
-                                y: text_bounds.y,
-                                width,
-                                height: text_bounds.height,
-                            },
-                            background: Background::Color(
-                                style_sheet.selection_color(),
-                            ),
-                            border_radius: 0.0,
-                            border_width: 0.0,
-                            border_color: Color::TRANSPARENT,
-                        },
-                        if end == right {
-                            right_offset
-                        } else {
-                            left_offset
-                        },
-                    )
-                }
-            };
-
-            (
-                Primitive::Group {
-                    primitives: vec![cursor_primitive, text_value],
-                },
-                Vector::new(offset as u32, 0),
-            )
-        } else {
-            (text_value, Vector::new(0, 0))
-        };
-
-        let text_width = self.measure_value(
-            if text.is_empty() { placeholder } else { &text },
-            size,
-            font,
-        );
-
-        let contents = if text_width > text_bounds.width {
-            Primitive::Clip {
-                bounds: text_bounds,
-                offset,
-                content: Box::new(contents_primitive),
-            }
-        } else {
-            contents_primitive
-        };
-
-        (
-            Primitive::Group {
-                primitives: vec![input, contents],
-            },
-            if is_mouse_over {
-                mouse::Interaction::Text
-            } else {
-                mouse::Interaction::default()
-            },
-        )
-    }
 }
 
 fn measure_cursor_and_scroll_offset<B>(
diff --git a/graphics/src/widget/toggler.rs b/graphics/src/widget/toggler.rs
index 852d18ee..cd072f7c 100644
--- a/graphics/src/widget/toggler.rs
+++ b/graphics/src/widget/toggler.rs
@@ -1,19 +1,10 @@
 //! Show toggle controls using togglers.
 use crate::backend::{self, Backend};
-use crate::{Primitive, Renderer};
-use iced_native::mouse;
+use crate::Renderer;
 use iced_native::toggler;
-use iced_native::Rectangle;
 
 pub use iced_style::toggler::{Style, StyleSheet};
 
-/// Makes sure that the border radius of the toggler looks good at every size.
-const BORDER_RADIUS_RATIO: f32 = 32.0 / 13.0;
-
-/// The space ratio between the background Quad and the Toggler bounds, and
-/// between the background Quad and foreground Quad.
-const SPACE_RATIO: f32 = 0.05;
-
 /// A toggler that can be toggled.
 ///
 /// This is an alias of an `iced_native` toggler with an `iced_wgpu::Renderer`.
@@ -27,73 +18,4 @@ where
     type Style = Box<dyn StyleSheet>;
 
     const DEFAULT_SIZE: u16 = 20;
-
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        is_active: bool,
-        is_mouse_over: bool,
-        label: Option<Self::Output>,
-        style_sheet: &Self::Style,
-    ) -> Self::Output {
-        let style = if is_mouse_over {
-            style_sheet.hovered(is_active)
-        } else {
-            style_sheet.active(is_active)
-        };
-
-        let border_radius = bounds.height as f32 / BORDER_RADIUS_RATIO;
-        let space = SPACE_RATIO * bounds.height as f32;
-
-        let toggler_background_bounds = Rectangle {
-            x: bounds.x + space,
-            y: bounds.y + space,
-            width: bounds.width - (2.0 * space),
-            height: bounds.height - (2.0 * space),
-        };
-
-        let toggler_background = Primitive::Quad {
-            bounds: toggler_background_bounds,
-            background: style.background.into(),
-            border_radius,
-            border_width: 1.0,
-            border_color: style.background_border.unwrap_or(style.background),
-        };
-
-        let toggler_foreground_bounds = Rectangle {
-            x: bounds.x
-                + if is_active {
-                    bounds.width - 2.0 * space - (bounds.height - (4.0 * space))
-                } else {
-                    2.0 * space
-                },
-            y: bounds.y + (2.0 * space),
-            width: bounds.height - (4.0 * space),
-            height: bounds.height - (4.0 * space),
-        };
-
-        let toggler_foreground = Primitive::Quad {
-            bounds: toggler_foreground_bounds,
-            background: style.foreground.into(),
-            border_radius,
-            border_width: 1.0,
-            border_color: style.foreground_border.unwrap_or(style.foreground),
-        };
-
-        (
-            Primitive::Group {
-                primitives: match label {
-                    Some((l, _)) => {
-                        vec![l, toggler_background, toggler_foreground]
-                    }
-                    None => vec![toggler_background, toggler_foreground],
-                },
-            },
-            if is_mouse_over {
-                mouse::Interaction::Pointer
-            } else {
-                mouse::Interaction::default()
-            },
-        )
-    }
 }
diff --git a/graphics/src/widget/tooltip.rs b/graphics/src/widget/tooltip.rs
index 493a6389..d55d61b2 100644
--- a/graphics/src/widget/tooltip.rs
+++ b/graphics/src/widget/tooltip.rs
@@ -1,11 +1,6 @@
 //! Decorate content and apply alignment.
 use crate::backend::{self, Backend};
-use crate::defaults::{self, Defaults};
-use crate::{Primitive, Renderer, Vector};
-
-use iced_native::container;
-use iced_native::layout::{self, Layout};
-use iced_native::{Element, Padding, Point, Rectangle, Size, Text};
+use crate::Renderer;
 
 /// An element decorating some content.
 ///
@@ -21,148 +16,4 @@ where
     B: Backend + backend::Text,
 {
     const DEFAULT_PADDING: u16 = 5;
-
-    fn draw<Message>(
-        &mut self,
-        defaults: &Defaults,
-        cursor_position: Point,
-        content_layout: Layout<'_>,
-        viewport: &Rectangle,
-        content: &Element<'_, Message, Self>,
-        tooltip: &Text<Self>,
-        position: Position,
-        style_sheet: &<Self as container::Renderer>::Style,
-        gap: u16,
-        padding: u16,
-    ) -> Self::Output {
-        let (content, mouse_interaction) = content.draw(
-            self,
-            &defaults,
-            content_layout,
-            cursor_position,
-            viewport,
-        );
-
-        let bounds = content_layout.bounds();
-
-        if bounds.contains(cursor_position) {
-            use iced_native::Widget;
-
-            let gap = f32::from(gap);
-            let style = style_sheet.style();
-
-            let defaults = Defaults {
-                text: defaults::Text {
-                    color: style.text_color.unwrap_or(defaults.text.color),
-                },
-            };
-
-            let text_layout = Widget::<(), Self>::layout(
-                tooltip,
-                self,
-                &layout::Limits::new(Size::ZERO, viewport.size())
-                    .pad(Padding::new(padding)),
-            );
-
-            let padding = f32::from(padding);
-            let text_bounds = text_layout.bounds();
-            let x_center = bounds.x + (bounds.width - text_bounds.width) / 2.0;
-            let y_center =
-                bounds.y + (bounds.height - text_bounds.height) / 2.0;
-
-            let mut tooltip_bounds = {
-                let offset = match position {
-                    Position::Top => Vector::new(
-                        x_center,
-                        bounds.y - text_bounds.height - gap - padding,
-                    ),
-                    Position::Bottom => Vector::new(
-                        x_center,
-                        bounds.y + bounds.height + gap + padding,
-                    ),
-                    Position::Left => Vector::new(
-                        bounds.x - text_bounds.width - gap - padding,
-                        y_center,
-                    ),
-                    Position::Right => Vector::new(
-                        bounds.x + bounds.width + gap + padding,
-                        y_center,
-                    ),
-                    Position::FollowCursor => Vector::new(
-                        cursor_position.x,
-                        cursor_position.y - text_bounds.height,
-                    ),
-                };
-
-                Rectangle {
-                    x: offset.x - padding,
-                    y: offset.y - padding,
-                    width: text_bounds.width + padding * 2.0,
-                    height: text_bounds.height + padding * 2.0,
-                }
-            };
-
-            if tooltip_bounds.x < viewport.x {
-                tooltip_bounds.x = viewport.x;
-            } else if viewport.x + viewport.width
-                < tooltip_bounds.x + tooltip_bounds.width
-            {
-                tooltip_bounds.x =
-                    viewport.x + viewport.width - tooltip_bounds.width;
-            }
-
-            if tooltip_bounds.y < viewport.y {
-                tooltip_bounds.y = viewport.y;
-            } else if viewport.y + viewport.height
-                < tooltip_bounds.y + tooltip_bounds.height
-            {
-                tooltip_bounds.y =
-                    viewport.y + viewport.height - tooltip_bounds.height;
-            }
-
-            let (tooltip, _) = Widget::<(), Self>::draw(
-                tooltip,
-                self,
-                &defaults,
-                Layout::with_offset(
-                    Vector::new(
-                        tooltip_bounds.x + padding,
-                        tooltip_bounds.y + padding,
-                    ),
-                    &text_layout,
-                ),
-                cursor_position,
-                viewport,
-            );
-
-            (
-                Primitive::Group {
-                    primitives: vec![
-                        content,
-                        Primitive::Clip {
-                            bounds: *viewport,
-                            offset: Vector::new(0, 0),
-                            content: Box::new(
-                                if let Some(background) =
-                                    crate::container::background(
-                                        tooltip_bounds,
-                                        &style,
-                                    )
-                                {
-                                    Primitive::Group {
-                                        primitives: vec![background, tooltip],
-                                    }
-                                } else {
-                                    tooltip
-                                },
-                            ),
-                        },
-                    ],
-                },
-                mouse_interaction,
-            )
-        } else {
-            (content, mouse_interaction)
-        }
-    }
 }
diff --git a/graphics/src/window/compositor.rs b/graphics/src/window/compositor.rs
index 37edef1d..9ea040cd 100644
--- a/graphics/src/window/compositor.rs
+++ b/graphics/src/window/compositor.rs
@@ -1,7 +1,5 @@
 use crate::{Color, Error, Viewport};
 
-use iced_native::mouse;
-
 use raw_window_handle::HasRawWindowHandle;
 use thiserror::Error;
 
@@ -30,9 +28,8 @@ pub trait Compositor: Sized {
         window: &W,
     ) -> Self::Surface;
 
-    /// Crates a new [`SwapChain`] for the given [`Surface`].
+    /// Configures a new [`Surface`] with the given dimensions.
     ///
-    /// [`SwapChain`]: Self::SwapChain
     /// [`Surface`]: Self::Surface
     fn configure_surface(
         &mut self,
@@ -41,18 +38,17 @@ pub trait Compositor: Sized {
         height: u32,
     );
 
-    /// Draws the output primitives to the next frame of the given [`SwapChain`].
+    /// Presents the [`Renderer`] primitives to the next frame of the given [`Surface`].
     ///
     /// [`SwapChain`]: Self::SwapChain
-    fn draw<T: AsRef<str>>(
+    fn present<T: AsRef<str>>(
         &mut self,
         renderer: &mut Self::Renderer,
         surface: &mut Self::Surface,
         viewport: &Viewport,
         background_color: Color,
-        output: &<Self::Renderer as iced_native::Renderer>::Output,
         overlay: &[T],
-    ) -> Result<mouse::Interaction, SurfaceError>;
+    ) -> Result<(), SurfaceError>;
 }
 
 /// Result of an unsuccessful call to [`Compositor::draw`].
@@ -63,13 +59,13 @@ pub enum SurfaceError {
         "A timeout was encountered while trying to acquire the next frame"
     )]
     Timeout,
-    /// The underlying surface has changed, and therefore the swap chain must be updated.
+    /// The underlying surface has changed, and therefore the surface must be updated.
     #[error(
-        "The underlying surface has changed, and therefore the swap chain must be updated."
+        "The underlying surface has changed, and therefore the surface must be updated."
     )]
     Outdated,
     /// The swap chain has been lost and needs to be recreated.
-    #[error("The swap chain has been lost and needs to be recreated")]
+    #[error("The surface has been lost and needs to be recreated")]
     Lost,
     /// There is no more memory left to allocate a new frame.
     #[error("There is no more memory left to allocate a new frame")]
diff --git a/graphics/src/window/gl_compositor.rs b/graphics/src/window/gl_compositor.rs
index 34d70be3..b1b995f1 100644
--- a/graphics/src/window/gl_compositor.rs
+++ b/graphics/src/window/gl_compositor.rs
@@ -1,5 +1,4 @@
 use crate::{Color, Error, Size, Viewport};
-use iced_native::mouse;
 
 use core::ffi::c_void;
 
@@ -49,15 +48,15 @@ pub trait GLCompositor: Sized {
     /// Resizes the viewport of the [`GLCompositor`].
     fn resize_viewport(&mut self, physical_size: Size<u32>);
 
-    /// Draws the provided output with the given [`Renderer`].
+    /// Presents the primitives of the [`Renderer`] to the next frame of the
+    /// [`GLCompositor`].
     ///
     /// [`Renderer`]: crate::Renderer
-    fn draw<T: AsRef<str>>(
+    fn present<T: AsRef<str>>(
         &mut self,
         renderer: &mut Self::Renderer,
         viewport: &Viewport,
         background_color: Color,
-        output: &<Self::Renderer as iced_native::Renderer>::Output,
         overlay: &[T],
-    ) -> mouse::Interaction;
+    );
 }