Remove trait-specific draw logic in `iced_native`

22 files changed, 327 insertions, 797 deletions

diff --git a/native/src/widget/button.rs b/native/src/widget/button.rs
index c469a0e5..1c7f80ef 100644
--- a/native/src/widget/button.rs
+++ b/native/src/widget/button.rs
@@ -248,17 +248,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(
-            defaults,
-            layout.bounds(),
-            cursor_position,
-            self.on_press.is_none(),
-            self.state.is_pressed,
-            &self.style,
-            &self.content,
-            layout.children().next().unwrap(),
-        )
+    ) {
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -289,19 +279,6 @@ pub trait Renderer: crate::Renderer + Sized {
 
     /// The style supported by this renderer.
     type Style: Default;
-
-    /// Draws a [`Button`].
-    fn draw<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        bounds: Rectangle,
-        cursor_position: Point,
-        is_disabled: bool,
-        is_pressed: bool,
-        style: &Self::Style,
-        content: &Element<'_, Message, Self>,
-        content_layout: Layout<'_>,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Button<'a, Message, Renderer>>
diff --git a/native/src/widget/checkbox.rs b/native/src/widget/checkbox.rs
index 8bdb6b78..579e4ee3 100644
--- a/native/src/widget/checkbox.rs
+++ b/native/src/widget/checkbox.rs
@@ -5,7 +5,6 @@ use crate::alignment::{self, Alignment};
 use crate::event::{self, Event};
 use crate::layout;
 use crate::mouse;
-use crate::row;
 use crate::text;
 use crate::touch;
 use crate::{
@@ -121,7 +120,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
 impl<Message, Renderer> Widget<Message, Renderer>
     for Checkbox<Message, Renderer>
 where
-    Renderer: self::Renderer + text::Renderer + row::Renderer,
+    Renderer: self::Renderer + text::Renderer,
 {
     fn width(&self) -> Length {
         self.width
@@ -187,36 +186,29 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        let bounds = layout.bounds();
-        let mut children = layout.children();
-
-        let checkbox_layout = children.next().unwrap();
-        let label_layout = children.next().unwrap();
-        let checkbox_bounds = checkbox_layout.bounds();
-
-        let label = text::Renderer::draw(
-            renderer,
-            defaults,
-            label_layout.bounds(),
-            &self.label,
-            self.text_size.unwrap_or(renderer.default_size()),
-            self.font,
-            self.text_color,
-            alignment::Horizontal::Left,
-            alignment::Vertical::Center,
-        );
-
-        let is_mouse_over = bounds.contains(cursor_position);
-
-        self::Renderer::draw(
-            renderer,
-            checkbox_bounds,
-            self.is_checked,
-            is_mouse_over,
-            label,
-            &self.style,
-        )
+    ) {
+        // let bounds = layout.bounds();
+        // let mut children = layout.children();
+
+        // let checkbox_layout = children.next().unwrap();
+        // let label_layout = children.next().unwrap();
+        // let checkbox_bounds = checkbox_layout.bounds();
+
+        // let label = text::Renderer::draw(
+        //     renderer,
+        //     defaults,
+        //     label_layout.bounds(),
+        //     &self.label,
+        //     self.text_size.unwrap_or(renderer.default_size()),
+        //     self.font,
+        //     self.text_color,
+        //     alignment::Horizontal::Left,
+        //     alignment::Vertical::Center,
+        // );
+
+        // let is_mouse_over = bounds.contains(cursor_position);
+
+        // TODO
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -242,28 +234,12 @@ pub trait Renderer: crate::Renderer {
 
     /// The default spacing of a [`Checkbox`].
     const DEFAULT_SPACING: u16;
-
-    /// Draws a [`Checkbox`].
-    ///
-    /// It receives:
-    ///   * the bounds of the [`Checkbox`]
-    ///   * whether the [`Checkbox`] is selected or not
-    ///   * whether the mouse is over the [`Checkbox`] or not
-    ///   * the drawn label of the [`Checkbox`]
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        is_checked: bool,
-        is_mouse_over: bool,
-        label: Self::Output,
-        style: &Self::Style,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Checkbox<Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
-    Renderer: 'a + self::Renderer + text::Renderer + row::Renderer,
+    Renderer: 'a + self::Renderer + text::Renderer,
     Message: 'a,
 {
     fn from(
diff --git a/native/src/widget/column.rs b/native/src/widget/column.rs
index 30cf0781..61b2361f 100644
--- a/native/src/widget/column.rs
+++ b/native/src/widget/column.rs
@@ -105,7 +105,7 @@ impl<'a, Message, Renderer> Column<'a, Message, Renderer> {
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Column<'a, Message, Renderer>
 where
-    Renderer: self::Renderer,
+    Renderer: crate::Renderer,
 {
     fn width(&self) -> Length {
         self.width
@@ -169,14 +169,8 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(
-            defaults,
-            &self.children,
-            layout,
-            cursor_position,
-            viewport,
-        )
+    ) {
+        // TODO
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -208,33 +202,10 @@ where
     }
 }
 
-/// The renderer of a [`Column`].
-///
-/// Your [renderer] will need to implement this trait before being
-/// able to use a [`Column`] in your user interface.
-///
-/// [renderer]: crate::renderer
-pub trait Renderer: crate::Renderer + Sized {
-    /// Draws a [`Column`].
-    ///
-    /// It receives:
-    /// - the children of the [`Column`]
-    /// - the [`Layout`] of the [`Column`] and its children
-    /// - the cursor position
-    fn draw<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        content: &[Element<'_, Message, Self>],
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output;
-}
-
 impl<'a, Message, Renderer> From<Column<'a, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
-    Renderer: 'a + self::Renderer,
+    Renderer: 'a + crate::Renderer,
     Message: 'a,
 {
     fn from(
diff --git a/native/src/widget/container.rs b/native/src/widget/container.rs
index 0e86ab62..f43de2a5 100644
--- a/native/src/widget/container.rs
+++ b/native/src/widget/container.rs
@@ -179,16 +179,8 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(
-            defaults,
-            layout.bounds(),
-            cursor_position,
-            viewport,
-            &self.style,
-            &self.content,
-            layout.children().next().unwrap(),
-        )
+    ) {
+        // TODO
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -221,18 +213,6 @@ where
 pub trait Renderer: crate::Renderer {
     /// The style supported by this renderer.
     type Style: Default;
-
-    /// Draws a [`Container`].
-    fn draw<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        bounds: Rectangle,
-        cursor_position: Point,
-        viewport: &Rectangle,
-        style: &Self::Style,
-        content: &Element<'_, Message, Self>,
-        content_layout: Layout<'_>,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Container<'a, Message, Renderer>>
diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs
index 4d8e0a3f..1607a596 100644
--- a/native/src/widget/image.rs
+++ b/native/src/widget/image.rs
@@ -96,8 +96,8 @@ where
         layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(self.handle.clone(), layout)
+    ) {
+        // TODO
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -225,9 +225,6 @@ impl std::fmt::Debug for Data {
 pub trait Renderer: crate::Renderer {
     /// Returns the dimensions of an [`Image`] located on the given path.
     fn dimensions(&self, handle: &Handle) -> (u32, u32);
-
-    /// Draws an [`Image`].
-    fn draw(&mut self, handle: Handle, layout: Layout<'_>) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Image> for Element<'a, Message, Renderer>
diff --git a/native/src/widget/image/viewer.rs b/native/src/widget/image/viewer.rs
index 405daf00..d483ed61 100644
--- a/native/src/widget/image/viewer.rs
+++ b/native/src/widget/image/viewer.rs
@@ -88,7 +88,7 @@ impl<'a> Viewer<'a> {
     /// will be respected.
     fn image_size<Renderer>(&self, renderer: &Renderer, bounds: Size) -> Size
     where
-        Renderer: self::Renderer + image::Renderer,
+        Renderer: image::Renderer,
     {
         let (width, height) = renderer.dimensions(&self.handle);
 
@@ -115,7 +115,7 @@ impl<'a> Viewer<'a> {
 
 impl<'a, Message, Renderer> Widget<Message, Renderer> for Viewer<'a>
 where
-    Renderer: self::Renderer + image::Renderer,
+    Renderer: image::Renderer,
 {
     fn width(&self) -> Length {
         self.width
@@ -287,7 +287,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
+    ) {
         let bounds = layout.bounds();
 
         let image_size = self.image_size(renderer, bounds.size());
@@ -302,16 +302,6 @@ where
         };
 
         let is_mouse_over = bounds.contains(cursor_position);
-
-        self::Renderer::draw(
-            renderer,
-            &self.state,
-            bounds,
-            image_size,
-            translation,
-            self.handle.clone(),
-            is_mouse_over,
-        )
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -373,38 +363,9 @@ impl State {
     }
 }
 
-/// The renderer of an [`Viewer`].
-///
-/// Your [renderer] will need to implement this trait before being
-/// able to use a [`Viewer`] in your user interface.
-///
-/// [renderer]: crate::renderer
-pub trait Renderer: crate::Renderer + Sized {
-    /// Draws the [`Viewer`].
-    ///
-    /// It receives:
-    /// - the [`State`] of the [`Viewer`]
-    /// - the bounds of the [`Viewer`] widget
-    /// - the [`Size`] of the scaled [`Viewer`] image
-    /// - the translation of the clipped image
-    /// - the [`Handle`] to the underlying image
-    /// - whether the mouse is over the [`Viewer`] or not
-    ///
-    /// [`Handle`]: image::Handle
-    fn draw(
-        &mut self,
-        state: &State,
-        bounds: Rectangle,
-        image_size: Size,
-        translation: Vector,
-        handle: image::Handle,
-        is_mouse_over: bool,
-    ) -> Self::Output;
-}
-
 impl<'a, Message, Renderer> From<Viewer<'a>> for Element<'a, Message, Renderer>
 where
-    Renderer: 'a + self::Renderer + image::Renderer,
+    Renderer: 'a + image::Renderer,
     Message: 'a,
 {
     fn from(viewer: Viewer<'a>) -> Element<'a, Message, Renderer> {
diff --git a/native/src/widget/pane_grid.rs b/native/src/widget/pane_grid.rs
index 26a72409..b4a8cdb1 100644
--- a/native/src/widget/pane_grid.rs
+++ b/native/src/widget/pane_grid.rs
@@ -32,7 +32,6 @@ use crate::event::{self, Event};
 use crate::layout;
 use crate::mouse;
 use crate::overlay;
-use crate::row;
 use crate::touch;
 use crate::{
     Clipboard, Element, Hasher, Layout, Length, Point, Rectangle, Size, Vector,
@@ -480,66 +479,56 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
-    ) -> Renderer::Output {
-        let picked_split = self
-            .state
-            .picked_split()
-            .and_then(|(split, axis)| {
-                let bounds = layout.bounds();
-
-                let splits = self
-                    .state
-                    .split_regions(f32::from(self.spacing), bounds.size());
-
-                let (_axis, region, ratio) = splits.get(&split)?;
-
-                let region = axis.split_line_bounds(
-                    *region,
-                    *ratio,
-                    f32::from(self.spacing),
-                );
-
-                Some((axis, region + Vector::new(bounds.x, bounds.y), true))
-            })
-            .or_else(|| match self.on_resize {
-                Some((leeway, _)) => {
-                    let bounds = layout.bounds();
-
-                    let relative_cursor = Point::new(
-                        cursor_position.x - bounds.x,
-                        cursor_position.y - bounds.y,
-                    );
-
-                    let splits = self
-                        .state
-                        .split_regions(f32::from(self.spacing), bounds.size());
-
-                    let (_split, axis, region) = hovered_split(
-                        splits.iter(),
-                        f32::from(self.spacing + leeway),
-                        relative_cursor,
-                    )?;
-
-                    Some((
-                        axis,
-                        region + Vector::new(bounds.x, bounds.y),
-                        false,
-                    ))
-                }
-                None => None,
-            });
-
-        self::Renderer::draw(
-            renderer,
-            defaults,
-            &self.elements,
-            self.state.picked_pane(),
-            picked_split,
-            layout,
-            &self.style,
-            cursor_position,
-            viewport,
-        )
+    ) {
+        // let picked_split = self
+        //     .state
+        //     .picked_split()
+        //     .and_then(|(split, axis)| {
+        //         let bounds = layout.bounds();
+
+        //         let splits = self
+        //             .state
+        //             .split_regions(f32::from(self.spacing), bounds.size());
+
+        //         let (_axis, region, ratio) = splits.get(&split)?;
+
+        //         let region = axis.split_line_bounds(
+        //             *region,
+        //             *ratio,
+        //             f32::from(self.spacing),
+        //         );
+
+        //         Some((axis, region + Vector::new(bounds.x, bounds.y), true))
+        //     })
+        //     .or_else(|| match self.on_resize {
+        //         Some((leeway, _)) => {
+        //             let bounds = layout.bounds();
+
+        //             let relative_cursor = Point::new(
+        //                 cursor_position.x - bounds.x,
+        //                 cursor_position.y - bounds.y,
+        //             );
+
+        //             let splits = self
+        //                 .state
+        //                 .split_regions(f32::from(self.spacing), bounds.size());
+
+        //             let (_split, axis, region) = hovered_split(
+        //                 splits.iter(),
+        //                 f32::from(self.spacing + leeway),
+        //                 relative_cursor,
+        //             )?;
+
+        //             Some((
+        //                 axis,
+        //                 region + Vector::new(bounds.x, bounds.y),
+        //                 false,
+        //             ))
+        //         }
+        //         None => None,
+        //     });
+
+        // TODO
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -578,69 +567,12 @@ where
 pub trait Renderer: crate::Renderer + container::Renderer + Sized {
     /// The style supported by this renderer.
     type Style: Default;
-
-    /// Draws a [`PaneGrid`].
-    ///
-    /// It receives:
-    /// - the elements of the [`PaneGrid`]
-    /// - the [`Pane`] that is currently being dragged
-    /// - the [`Axis`] that is currently being resized
-    /// - the [`Layout`] of the [`PaneGrid`] and its elements
-    /// - the cursor position
-    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: &<Self as self::Renderer>::Style,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output;
-
-    /// Draws a [`Pane`].
-    ///
-    /// It receives:
-    /// - the [`TitleBar`] of the [`Pane`], if any
-    /// - the [`Content`] of the [`Pane`]
-    /// - the [`Layout`] of the [`Pane`] and its elements
-    /// - the cursor position
-    fn draw_pane<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        bounds: Rectangle,
-        style: &<Self as container::Renderer>::Style,
-        title_bar: Option<(&TitleBar<'_, Message, Self>, Layout<'_>)>,
-        body: (&Element<'_, Message, Self>, Layout<'_>),
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output;
-
-    /// Draws a [`TitleBar`].
-    ///
-    /// It receives:
-    /// - the bounds, style of the [`TitleBar`]
-    /// - the style of the [`TitleBar`]
-    /// - the content of the [`TitleBar`] with its layout
-    /// - the controls of the [`TitleBar`] with their [`Layout`], if any
-    /// - the cursor position
-    fn draw_title_bar<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        bounds: Rectangle,
-        style: &<Self as container::Renderer>::Style,
-        content: (&Element<'_, Message, Self>, Layout<'_>),
-        controls: Option<(&Element<'_, Message, Self>, Layout<'_>)>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<PaneGrid<'a, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
-    Renderer: 'a + self::Renderer + row::Renderer,
+    Renderer: 'a + self::Renderer,
     Message: 'a,
 {
     fn from(
diff --git a/native/src/widget/pane_grid/content.rs b/native/src/widget/pane_grid/content.rs
index bac9fdd4..e94955f7 100644
--- a/native/src/widget/pane_grid/content.rs
+++ b/native/src/widget/pane_grid/content.rs
@@ -61,32 +61,33 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
-    ) -> Renderer::Output {
-        if let Some(title_bar) = &self.title_bar {
-            let mut children = layout.children();
-            let title_bar_layout = children.next().unwrap();
-            let body_layout = children.next().unwrap();
-
-            renderer.draw_pane(
-                defaults,
-                layout.bounds(),
-                &self.style,
-                Some((title_bar, title_bar_layout)),
-                (&self.body, body_layout),
-                cursor_position,
-                viewport,
-            )
-        } else {
-            renderer.draw_pane(
-                defaults,
-                layout.bounds(),
-                &self.style,
-                None,
-                (&self.body, layout),
-                cursor_position,
-                viewport,
-            )
-        }
+    ) {
+        // TODO
+        // if let Some(title_bar) = &self.title_bar {
+        //     let mut children = layout.children();
+        //     let title_bar_layout = children.next().unwrap();
+        //     let body_layout = children.next().unwrap();
+
+        //     renderer.draw_pane(
+        //         defaults,
+        //         layout.bounds(),
+        //         &self.style,
+        //         Some((title_bar, title_bar_layout)),
+        //         (&self.body, body_layout),
+        //         cursor_position,
+        //         viewport,
+        //     )
+        // } else {
+        //     renderer.draw_pane(
+        //         defaults,
+        //         layout.bounds(),
+        //         &self.style,
+        //         None,
+        //         (&self.body, layout),
+        //         cursor_position,
+        //         viewport,
+        //     )
+        // }
     }
 
     /// Returns whether the [`Content`] with the given [`Layout`] can be picked
diff --git a/native/src/widget/pane_grid/title_bar.rs b/native/src/widget/pane_grid/title_bar.rs
index 070010f8..9b0b7c78 100644
--- a/native/src/widget/pane_grid/title_bar.rs
+++ b/native/src/widget/pane_grid/title_bar.rs
@@ -90,34 +90,34 @@ where
         cursor_position: Point,
         viewport: &Rectangle,
         show_controls: bool,
-    ) -> Renderer::Output {
-        let mut children = layout.children();
-        let padded = children.next().unwrap();
-
-        let mut children = padded.children();
-        let title_layout = children.next().unwrap();
-
-        let controls = if let Some(controls) = &self.controls {
-            let controls_layout = children.next().unwrap();
-
-            if show_controls || self.always_show_controls {
-                Some((controls, controls_layout))
-            } else {
-                None
-            }
-        } else {
-            None
-        };
-
-        renderer.draw_title_bar(
-            defaults,
-            layout.bounds(),
-            &self.style,
-            (&self.content, title_layout),
-            controls,
-            cursor_position,
-            viewport,
-        )
+    ) {
+        // let mut children = layout.children();
+        // let padded = children.next().unwrap();
+
+        // let mut children = padded.children();
+        // let title_layout = children.next().unwrap();
+
+        // let controls = if let Some(controls) = &self.controls {
+        //     let controls_layout = children.next().unwrap();
+
+        //     if show_controls || self.always_show_controls {
+        //         Some((controls, controls_layout))
+        //     } else {
+        //         None
+        //     }
+        // } else {
+        //     None
+        // };
+
+        // renderer.draw_title_bar(
+        //     defaults,
+        //     layout.bounds(),
+        //     &self.style,
+        //     (&self.content, title_layout),
+        //     controls,
+        //     cursor_position,
+        //     viewport,
+        // )
     }
 
     /// Returns whether the mouse cursor is over the pick area of the
diff --git a/native/src/widget/pick_list.rs b/native/src/widget/pick_list.rs
index d7792000..7154a572 100644
--- a/native/src/widget/pick_list.rs
+++ b/native/src/widget/pick_list.rs
@@ -327,18 +327,8 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        self::Renderer::draw(
-            renderer,
-            layout.bounds(),
-            cursor_position,
-            self.selected.as_ref().map(ToString::to_string),
-            self.placeholder.as_ref().map(String::as_str),
-            self.padding,
-            self.text_size.unwrap_or(renderer.default_size()),
-            self.font,
-            &self.style,
-        )
+    ) {
+        // TODO
     }
 
     fn overlay(
@@ -387,19 +377,6 @@ pub trait Renderer: text::Renderer + menu::Renderer {
     fn menu_style(
         style: &<Self as Renderer>::Style,
     ) -> <Self as menu::Renderer>::Style;
-
-    /// Draws a [`PickList`].
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        cursor_position: Point,
-        selected: Option<String>,
-        placeholder: Option<&str>,
-        padding: Padding,
-        text_size: u16,
-        font: Self::Font,
-        style: &<Self as Renderer>::Style,
-    ) -> Self::Output;
 }
 
 impl<'a, T: 'a, Message, Renderer> Into<Element<'a, Message, Renderer>>
diff --git a/native/src/widget/progress_bar.rs b/native/src/widget/progress_bar.rs
index d294f198..d8cf5376 100644
--- a/native/src/widget/progress_bar.rs
+++ b/native/src/widget/progress_bar.rs
@@ -97,13 +97,8 @@ where
         layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(
-            layout.bounds(),
-            self.range.clone(),
-            self.value,
-            &self.style,
-        )
+    ) {
+        // TODO
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -127,22 +122,6 @@ pub trait Renderer: crate::Renderer {
 
     /// The default height of a [`ProgressBar`].
     const DEFAULT_HEIGHT: u16;
-
-    /// Draws a [`ProgressBar`].
-    ///
-    /// It receives:
-    ///   * the bounds of the [`ProgressBar`]
-    ///   * the range of values of the [`ProgressBar`]
-    ///   * the current value of the [`ProgressBar`]
-    ///   * maybe a specific background of the [`ProgressBar`]
-    ///   * maybe a specific active color of the [`ProgressBar`]
-    fn draw(
-        &self,
-        bounds: Rectangle,
-        range: RangeInclusive<f32>,
-        value: f32,
-        style: &Self::Style,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<ProgressBar<Renderer>>
diff --git a/native/src/widget/radio.rs b/native/src/widget/radio.rs
index 513b2fce..c6955079 100644
--- a/native/src/widget/radio.rs
+++ b/native/src/widget/radio.rs
@@ -5,7 +5,6 @@ use crate::alignment::{self, Alignment};
 use crate::event::{self, Event};
 use crate::layout;
 use crate::mouse;
-use crate::row;
 use crate::text;
 use crate::touch;
 use crate::{
@@ -136,7 +135,7 @@ where
 impl<Message, Renderer> Widget<Message, Renderer> for Radio<Message, Renderer>
 where
     Message: Clone,
-    Renderer: self::Renderer + text::Renderer + row::Renderer,
+    Renderer: self::Renderer + text::Renderer,
 {
     fn width(&self) -> Length {
         self.width
@@ -199,36 +198,37 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        let bounds = layout.bounds();
-        let mut children = layout.children();
+    ) {
+        // TODO
+        // let bounds = layout.bounds();
+        // let mut children = layout.children();
 
-        let radio_layout = children.next().unwrap();
-        let label_layout = children.next().unwrap();
-        let radio_bounds = radio_layout.bounds();
+        // let radio_layout = children.next().unwrap();
+        // let label_layout = children.next().unwrap();
+        // let radio_bounds = radio_layout.bounds();
 
-        let label = text::Renderer::draw(
-            renderer,
-            defaults,
-            label_layout.bounds(),
-            &self.label,
-            self.text_size.unwrap_or(renderer.default_size()),
-            self.font,
-            self.text_color,
-            alignment::Horizontal::Left,
-            alignment::Vertical::Center,
-        );
+        // let label = text::Renderer::draw(
+        //     renderer,
+        //     defaults,
+        //     label_layout.bounds(),
+        //     &self.label,
+        //     self.text_size.unwrap_or(renderer.default_size()),
+        //     self.font,
+        //     self.text_color,
+        //     alignment::Horizontal::Left,
+        //     alignment::Vertical::Center,
+        // );
 
-        let is_mouse_over = bounds.contains(cursor_position);
+        // let is_mouse_over = bounds.contains(cursor_position);
 
-        self::Renderer::draw(
-            renderer,
-            radio_bounds,
-            self.is_selected,
-            is_mouse_over,
-            label,
-            &self.style,
-        )
+        // self::Renderer::draw(
+        //     renderer,
+        //     radio_bounds,
+        //     self.is_selected,
+        //     is_mouse_over,
+        //     label,
+        //     &self.style,
+        // )
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -254,29 +254,13 @@ pub trait Renderer: crate::Renderer {
 
     /// The default spacing of a [`Radio`] button.
     const DEFAULT_SPACING: u16;
-
-    /// Draws a [`Radio`] button.
-    ///
-    /// It receives:
-    ///   * the bounds of the [`Radio`]
-    ///   * whether the [`Radio`] is selected or not
-    ///   * whether the mouse is over the [`Radio`] or not
-    ///   * the drawn label of the [`Radio`]
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        is_selected: bool,
-        is_mouse_over: bool,
-        label: Self::Output,
-        style: &Self::Style,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Radio<Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
     Message: 'a + Clone,
-    Renderer: 'a + self::Renderer + row::Renderer + text::Renderer,
+    Renderer: 'a + self::Renderer + text::Renderer,
 {
     fn from(radio: Radio<Message, Renderer>) -> Element<'a, Message, Renderer> {
         Element::new(radio)
diff --git a/native/src/widget/row.rs b/native/src/widget/row.rs
index 1923f213..04a1f864 100644
--- a/native/src/widget/row.rs
+++ b/native/src/widget/row.rs
@@ -104,7 +104,7 @@ impl<'a, Message, Renderer> Row<'a, Message, Renderer> {
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Row<'a, Message, Renderer>
 where
-    Renderer: self::Renderer,
+    Renderer: crate::Renderer,
 {
     fn width(&self) -> Length {
         self.width
@@ -168,14 +168,15 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(
-            defaults,
-            &self.children,
-            layout,
-            cursor_position,
-            viewport,
-        )
+    ) {
+        // TODO
+        // renderer.draw(
+        //     defaults,
+        //     &self.children,
+        //     layout,
+        //     cursor_position,
+        //     viewport,
+        // )
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -207,33 +208,10 @@ where
     }
 }
 
-/// The renderer of a [`Row`].
-///
-/// Your [renderer] will need to implement this trait before being
-/// able to use a [`Row`] in your user interface.
-///
-/// [renderer]: crate::renderer
-pub trait Renderer: crate::Renderer + Sized {
-    /// Draws a [`Row`].
-    ///
-    /// It receives:
-    /// - the children of the [`Row`]
-    /// - the [`Layout`] of the [`Row`] and its children
-    /// - the cursor position
-    fn draw<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        children: &[Element<'_, Message, Self>],
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Self::Output;
-}
-
 impl<'a, Message, Renderer> From<Row<'a, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
-    Renderer: 'a + self::Renderer,
+    Renderer: 'a + crate::Renderer,
     Message: 'a,
 {
     fn from(row: Row<'a, Message, Renderer>) -> Element<'a, Message, Renderer> {
diff --git a/native/src/widget/rule.rs b/native/src/widget/rule.rs
index 18c88658..1fab77bc 100644
--- a/native/src/widget/rule.rs
+++ b/native/src/widget/rule.rs
@@ -72,8 +72,9 @@ where
         layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(layout.bounds(), &self.style, self.is_horizontal)
+    ) {
+        // TODO
+        // renderer.draw(layout.bounds(), &self.style, self.is_horizontal)
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -89,19 +90,6 @@ where
 pub trait Renderer: crate::Renderer {
     /// The style supported by this renderer.
     type Style: Default;
-
-    /// Draws a [`Rule`].
-    ///
-    /// It receives:
-    ///   * the bounds of the [`Rule`]
-    ///   * the style of the [`Rule`]
-    ///   * whether the [`Rule`] is horizontal (true) or vertical (false)
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        style: &Self::Style,
-        is_horizontal: bool,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Rule<Renderer>>
diff --git a/native/src/widget/scrollable.rs b/native/src/widget/scrollable.rs
index a8e467d3..1c897dc5 100644
--- a/native/src/widget/scrollable.rs
+++ b/native/src/widget/scrollable.rs
@@ -1,5 +1,4 @@
 //! Navigate an endless amount of content with a scrollbar.
-use crate::column;
 use crate::event::{self, Event};
 use crate::layout;
 use crate::mouse;
@@ -381,57 +380,45 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        let bounds = layout.bounds();
-        let content_layout = layout.children().next().unwrap();
-        let content_bounds = content_layout.bounds();
-        let offset = self.state.offset(bounds, content_bounds);
-        let scrollbar = renderer.scrollbar(
-            bounds,
-            content_bounds,
-            offset,
-            self.scrollbar_width,
-            self.scrollbar_margin,
-            self.scroller_width,
-        );
-
-        let is_mouse_over = bounds.contains(cursor_position);
-        let is_mouse_over_scrollbar = scrollbar
-            .as_ref()
-            .map(|scrollbar| scrollbar.is_mouse_over(cursor_position))
-            .unwrap_or(false);
-
-        let content = {
-            let cursor_position = if is_mouse_over && !is_mouse_over_scrollbar {
-                Point::new(cursor_position.x, cursor_position.y + offset as f32)
-            } else {
-                Point::new(cursor_position.x, -1.0)
-            };
-
-            self.content.draw(
-                renderer,
-                defaults,
-                content_layout,
-                cursor_position,
-                &Rectangle {
-                    y: bounds.y + offset as f32,
-                    ..bounds
-                },
-            )
-        };
-
-        self::Renderer::draw(
-            renderer,
-            &self.state,
-            bounds,
-            content_layout.bounds(),
-            is_mouse_over,
-            is_mouse_over_scrollbar,
-            scrollbar,
-            offset,
-            &self.style,
-            content,
-        )
+    ) {
+        // TODO
+        // let bounds = layout.bounds();
+        // let content_layout = layout.children().next().unwrap();
+        // let content_bounds = content_layout.bounds();
+        // let offset = self.state.offset(bounds, content_bounds);
+        // let scrollbar = renderer.scrollbar(
+        //     bounds,
+        //     content_bounds,
+        //     offset,
+        //     self.scrollbar_width,
+        //     self.scrollbar_margin,
+        //     self.scroller_width,
+        // );
+
+        // let is_mouse_over = bounds.contains(cursor_position);
+        // let is_mouse_over_scrollbar = scrollbar
+        //     .as_ref()
+        //     .map(|scrollbar| scrollbar.is_mouse_over(cursor_position))
+        //     .unwrap_or(false);
+
+        // let content = {
+        //     let cursor_position = if is_mouse_over && !is_mouse_over_scrollbar {
+        //         Point::new(cursor_position.x, cursor_position.y + offset as f32)
+        //     } else {
+        //         Point::new(cursor_position.x, -1.0)
+        //     };
+
+        //     self.content.draw(
+        //         renderer,
+        //         defaults,
+        //         content_layout,
+        //         cursor_position,
+        //         &Rectangle {
+        //             y: bounds.y + offset as f32,
+        //             ..bounds
+        //         },
+        //     )
+        // };
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -635,7 +622,7 @@ pub struct Scroller {
 /// able to use a [`Scrollable`] in your user interface.
 ///
 /// [renderer]: crate::renderer
-pub trait Renderer: column::Renderer + Sized {
+pub trait Renderer: crate::Renderer + Sized {
     /// The style supported by this renderer.
     type Style: Default;
 
@@ -650,30 +637,6 @@ pub trait Renderer: column::Renderer + Sized {
         scrollbar_margin: u16,
         scroller_width: u16,
     ) -> Option<Scrollbar>;
-
-    /// Draws the [`Scrollable`].
-    ///
-    /// It receives:
-    /// - the [`State`] of the [`Scrollable`]
-    /// - the bounds of the [`Scrollable`] widget
-    /// - the bounds of the [`Scrollable`] content
-    /// - whether the mouse is over the [`Scrollable`] or not
-    /// - whether the mouse is over the [`Scrollbar`] or not
-    /// - a optional [`Scrollbar`] to be rendered
-    /// - the scrolling offset
-    /// - the drawn content
-    fn draw(
-        &mut self,
-        scrollable: &State,
-        bounds: Rectangle,
-        content_bounds: Rectangle,
-        is_mouse_over: bool,
-        is_mouse_over_scrollbar: bool,
-        scrollbar: Option<Scrollbar>,
-        offset: u32,
-        style: &Self::Style,
-        content: Self::Output,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Scrollable<'a, Message, Renderer>>
diff --git a/native/src/widget/slider.rs b/native/src/widget/slider.rs
index 2a74d5a3..bcf811fe 100644
--- a/native/src/widget/slider.rs
+++ b/native/src/widget/slider.rs
@@ -250,18 +250,19 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        let start = *self.range.start();
-        let end = *self.range.end();
-
-        renderer.draw(
-            layout.bounds(),
-            cursor_position,
-            start.into() as f32..=end.into() as f32,
-            self.value.into() as f32,
-            self.state.is_dragging,
-            &self.style,
-        )
+    ) {
+        // TODO
+        // let start = *self.range.start();
+        // let end = *self.range.end();
+
+        // renderer.draw(
+        //     layout.bounds(),
+        //     cursor_position,
+        //     start.into() as f32..=end.into() as f32,
+        //     self.value.into() as f32,
+        //     self.state.is_dragging,
+        //     &self.style,
+        // )
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -284,24 +285,6 @@ pub trait Renderer: crate::Renderer {
 
     /// The default height of a [`Slider`].
     const DEFAULT_HEIGHT: u16;
-
-    /// Draws a [`Slider`].
-    ///
-    /// It receives:
-    ///   * the current cursor position
-    ///   * the bounds of the [`Slider`]
-    ///   * the local state of the [`Slider`]
-    ///   * the range of values of the [`Slider`]
-    ///   * the current value of the [`Slider`]
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        cursor_position: Point,
-        range: RangeInclusive<f32>,
-        value: f32,
-        is_dragging: bool,
-        style: &Self::Style,
-    ) -> Self::Output;
 }
 
 impl<'a, T, Message, Renderer> From<Slider<'a, T, Message, Renderer>>
diff --git a/native/src/widget/space.rs b/native/src/widget/space.rs
index 6b34ece8..9a70dab1 100644
--- a/native/src/widget/space.rs
+++ b/native/src/widget/space.rs
@@ -39,7 +39,7 @@ impl Space {
 
 impl<Message, Renderer> Widget<Message, Renderer> for Space
 where
-    Renderer: self::Renderer,
+    Renderer: crate::Renderer,
 {
     fn width(&self) -> Length {
         self.width
@@ -66,8 +66,7 @@ where
         layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(layout.bounds())
+    ) {
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -78,17 +77,9 @@ where
     }
 }
 
-/// The renderer of an amount of [`Space`].
-pub trait Renderer: crate::Renderer {
-    /// Draws an amount of empty [`Space`].
-    ///
-    /// You should most likely return an empty primitive here.
-    fn draw(&mut self, bounds: Rectangle) -> Self::Output;
-}
-
 impl<'a, Message, Renderer> From<Space> for Element<'a, Message, Renderer>
 where
-    Renderer: self::Renderer,
+    Renderer: crate::Renderer,
     Message: 'a,
 {
     fn from(space: Space) -> Element<'a, Message, Renderer> {
diff --git a/native/src/widget/svg.rs b/native/src/widget/svg.rs
index 9cd61918..737dd8d4 100644
--- a/native/src/widget/svg.rs
+++ b/native/src/widget/svg.rs
@@ -94,8 +94,9 @@ where
         layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(self.handle.clone(), layout)
+    ) {
+        // TODO
+        // renderer.draw(self.handle.clone(), layout)
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -187,9 +188,6 @@ impl std::fmt::Debug for Data {
 pub trait Renderer: crate::Renderer {
     /// Returns the default dimensions of an [`Svg`] for the given [`Handle`].
     fn dimensions(&self, handle: &Handle) -> (u32, u32);
-
-    /// Draws an [`Svg`].
-    fn draw(&mut self, handle: Handle, layout: Layout<'_>) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Svg> for Element<'a, Message, Renderer>
diff --git a/native/src/widget/text.rs b/native/src/widget/text.rs
index 168d49c2..9915a6e9 100644
--- a/native/src/widget/text.rs
+++ b/native/src/widget/text.rs
@@ -133,22 +133,13 @@ where
 
     fn draw(
         &self,
-        renderer: &mut Renderer,
-        defaults: &Renderer::Defaults,
-        layout: Layout<'_>,
+        _renderer: &mut Renderer,
+        _defaults: &Renderer::Defaults,
+        _layout: Layout<'_>,
         _cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        renderer.draw(
-            defaults,
-            layout.bounds(),
-            &self.content,
-            self.size.unwrap_or(renderer.default_size()),
-            self.font,
-            self.color,
-            self.horizontal_alignment,
-            self.vertical_alignment,
-        )
+    ) {
+        // TODO
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -201,27 +192,6 @@ pub trait Renderer: crate::Renderer {
         point: Point,
         nearest_only: bool,
     ) -> Option<Hit>;
-
-    /// Draws a [`Text`] fragment.
-    ///
-    /// It receives:
-    ///   * the bounds of the [`Text`]
-    ///   * the contents of the [`Text`]
-    ///   * the size of the [`Text`]
-    ///   * the color of the [`Text`]
-    ///   * the [`HorizontalAlignment`] of the [`Text`]
-    ///   * the [`VerticalAlignment`] of the [`Text`]
-    fn draw(
-        &mut self,
-        defaults: &Self::Defaults,
-        bounds: Rectangle,
-        content: &str,
-        size: u16,
-        font: Self::Font,
-        color: Option<Color>,
-        horizontal_alignment: alignment::Horizontal,
-        vertical_alignment: alignment::Vertical,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Text<Renderer>>
diff --git a/native/src/widget/text_input.rs b/native/src/widget/text_input.rs
index 84d171be..fe95eb95 100644
--- a/native/src/widget/text_input.rs
+++ b/native/src/widget/text_input.rs
@@ -170,38 +170,39 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         value: Option<&Value>,
-    ) -> Renderer::Output {
-        let value = value.unwrap_or(&self.value);
-        let bounds = layout.bounds();
-        let text_bounds = layout.children().next().unwrap().bounds();
-
-        if self.is_secure {
-            self::Renderer::draw(
-                renderer,
-                bounds,
-                text_bounds,
-                cursor_position,
-                self.font,
-                self.size.unwrap_or(renderer.default_size()),
-                &self.placeholder,
-                &value.secure(),
-                &self.state,
-                &self.style,
-            )
-        } else {
-            self::Renderer::draw(
-                renderer,
-                bounds,
-                text_bounds,
-                cursor_position,
-                self.font,
-                self.size.unwrap_or(renderer.default_size()),
-                &self.placeholder,
-                value,
-                &self.state,
-                &self.style,
-            )
-        }
+    ) {
+        // TODO
+        // let value = value.unwrap_or(&self.value);
+        // let bounds = layout.bounds();
+        // let text_bounds = layout.children().next().unwrap().bounds();
+
+        // if self.is_secure {
+        //     self::Renderer::draw(
+        //         renderer,
+        //         bounds,
+        //         text_bounds,
+        //         cursor_position,
+        //         self.font,
+        //         self.size.unwrap_or(renderer.default_size()),
+        //         &self.placeholder,
+        //         &value.secure(),
+        //         &self.state,
+        //         &self.style,
+        //     )
+        // } else {
+        //     self::Renderer::draw(
+        //         renderer,
+        //         bounds,
+        //         text_bounds,
+        //         cursor_position,
+        //         self.font,
+        //         self.size.unwrap_or(renderer.default_size()),
+        //         &self.placeholder,
+        //         value,
+        //         &self.state,
+        //         &self.style,
+        //     )
+        // }
     }
 }
 
@@ -630,7 +631,7 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
+    ) {
         self.draw(renderer, layout, cursor_position, None)
     }
 
@@ -673,28 +674,6 @@ pub trait Renderer: text::Renderer + Sized {
         state: &State,
     ) -> f32;
 
-    /// Draws a [`TextInput`].
-    ///
-    /// It receives:
-    /// - the bounds of the [`TextInput`]
-    /// - the bounds of the text (i.e. the current value)
-    /// - the cursor position
-    /// - the placeholder to show when the value is empty
-    /// - the current [`Value`]
-    /// - the current [`State`]
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        text_bounds: Rectangle,
-        cursor_position: Point,
-        font: Self::Font,
-        size: u16,
-        placeholder: &str,
-        value: &Value,
-        state: &State,
-        style: &Self::Style,
-    ) -> Self::Output;
-
     /// Computes the position of the text cursor at the given X coordinate of
     /// a [`TextInput`].
     fn find_cursor_position(
diff --git a/native/src/widget/toggler.rs b/native/src/widget/toggler.rs
index c624be4c..4a1f1f5d 100644
--- a/native/src/widget/toggler.rs
+++ b/native/src/widget/toggler.rs
@@ -5,7 +5,6 @@ use crate::alignment;
 use crate::event;
 use crate::layout;
 use crate::mouse;
-use crate::row;
 use crate::text;
 use crate::{
     Alignment, Clipboard, Element, Event, Hasher, Layout, Length, Point,
@@ -119,7 +118,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
 
 impl<Message, Renderer> Widget<Message, Renderer> for Toggler<Message, Renderer>
 where
-    Renderer: self::Renderer + text::Renderer + row::Renderer,
+    Renderer: self::Renderer + text::Renderer,
 {
     fn width(&self) -> Length {
         self.width
@@ -190,43 +189,35 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
         _viewport: &Rectangle,
-    ) -> Renderer::Output {
-        let bounds = layout.bounds();
-        let mut children = layout.children();
-
-        let label = match &self.label {
-            Some(label) => {
-                let label_layout = children.next().unwrap();
-
-                Some(text::Renderer::draw(
-                    renderer,
-                    defaults,
-                    label_layout.bounds(),
-                    &label,
-                    self.text_size.unwrap_or(renderer.default_size()),
-                    self.font,
-                    None,
-                    self.text_alignment,
-                    alignment::Vertical::Center,
-                ))
-            }
-
-            None => None,
-        };
-
-        let toggler_layout = children.next().unwrap();
-        let toggler_bounds = toggler_layout.bounds();
-
-        let is_mouse_over = bounds.contains(cursor_position);
-
-        self::Renderer::draw(
-            renderer,
-            toggler_bounds,
-            self.is_active,
-            is_mouse_over,
-            label,
-            &self.style,
-        )
+    ) {
+        // TODO
+        // let bounds = layout.bounds();
+        // let mut children = layout.children();
+
+        // let label = match &self.label {
+        //     Some(label) => {
+        //         let label_layout = children.next().unwrap();
+
+        //         Some(text::Renderer::draw(
+        //             renderer,
+        //             defaults,
+        //             label_layout.bounds(),
+        //             &label,
+        //             self.text_size.unwrap_or(renderer.default_size()),
+        //             self.font,
+        //             None,
+        //             self.text_alignment,
+        //             alignment::Vertical::Center,
+        //         ))
+        //     }
+
+        //     None => None,
+        // };
+
+        // let toggler_layout = children.next().unwrap();
+        // let toggler_bounds = toggler_layout.bounds();
+
+        // let is_mouse_over = bounds.contains(cursor_position);
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -249,29 +240,12 @@ pub trait Renderer: crate::Renderer {
 
     /// The default size of a [`Toggler`].
     const DEFAULT_SIZE: u16;
-
-    /// Draws a [`Toggler`].
-    ///
-    /// It receives:
-    ///   * the bounds of the [`Toggler`]
-    ///   * whether the [`Toggler`] is activated or not
-    ///   * whether the mouse is over the [`Toggler`] or not
-    ///   * the drawn label of the [`Toggler`]
-    ///   * the style of the [`Toggler`]
-    fn draw(
-        &mut self,
-        bounds: Rectangle,
-        is_active: bool,
-        is_mouse_over: bool,
-        label: Option<Self::Output>,
-        style: &Self::Style,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Toggler<Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
-    Renderer: 'a + self::Renderer + text::Renderer + row::Renderer,
+    Renderer: 'a + self::Renderer + text::Renderer,
     Message: 'a,
 {
     fn from(
diff --git a/native/src/widget/tooltip.rs b/native/src/widget/tooltip.rs
index 276afd41..83d04675 100644
--- a/native/src/widget/tooltip.rs
+++ b/native/src/widget/tooltip.rs
@@ -136,25 +136,13 @@ where
 
     fn draw(
         &self,
-        renderer: &mut Renderer,
-        defaults: &Renderer::Defaults,
-        layout: Layout<'_>,
-        cursor_position: Point,
-        viewport: &Rectangle,
-    ) -> Renderer::Output {
-        self::Renderer::draw(
-            renderer,
-            defaults,
-            cursor_position,
-            layout,
-            viewport,
-            &self.content,
-            &self.tooltip,
-            self.position,
-            &self.style,
-            self.gap,
-            self.padding,
-        )
+        _renderer: &mut Renderer,
+        _defaults: &Renderer::Defaults,
+        _layout: Layout<'_>,
+        _cursor_position: Point,
+        _viewport: &Rectangle,
+    ) {
+        // TODO
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -177,23 +165,6 @@ pub trait Renderer:
 {
     /// The default padding of a [`Tooltip`] drawn by this renderer.
     const DEFAULT_PADDING: u16;
-
-    /// Draws a [`Tooltip`].
-    ///
-    /// [`Tooltip`]: struct.Tooltip.html
-    fn draw<Message>(
-        &mut self,
-        defaults: &Self::Defaults,
-        cursor_position: Point,
-        content_layout: Layout<'_>,
-        viewport: &Rectangle,
-        content: &Element<'_, Message, Self>,
-        tooltip: &Text<Self>,
-        position: Position,
-        style: &<Self as container::Renderer>::Style,
-        gap: u16,
-        padding: u16,
-    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Tooltip<'a, Message, Renderer>>