Merge pull request #22 from hecrj/basic-renderer

Basic `wgpu` renderer

20 files changed, 277 insertions, 404 deletions

diff --git a/native/src/element.rs b/native/src/element.rs
index dd5ce621..bbedd942 100644
--- a/native/src/element.rs
+++ b/native/src/element.rs
@@ -1,8 +1,6 @@
 use stretch::{geometry, result};
 
-use crate::{
-    renderer, Color, Event, Hasher, Layout, MouseCursor, Node, Point, Widget,
-};
+use crate::{renderer, Color, Event, Hasher, Layout, Node, Point, Widget};
 
 /// A generic [`Widget`].
 ///
@@ -27,7 +25,10 @@ impl<'a, Message, Renderer> std::fmt::Debug for Element<'a, Message, Renderer> {
     }
 }
 
-impl<'a, Message, Renderer> Element<'a, Message, Renderer> {
+impl<'a, Message, Renderer> Element<'a, Message, Renderer>
+where
+    Renderer: crate::Renderer,
+{
     /// Create a new [`Element`] containing the given [`Widget`].
     ///
     /// [`Element`]: struct.Element.html
@@ -40,6 +41,19 @@ impl<'a, Message, Renderer> Element<'a, Message, Renderer> {
         }
     }
 
+    pub fn node(&self, renderer: &Renderer) -> Node {
+        self.widget.node(renderer)
+    }
+
+    pub fn draw(
+        &self,
+        renderer: &mut Renderer,
+        layout: Layout<'_>,
+        cursor_position: Point,
+    ) -> Renderer::Output {
+        self.widget.draw(renderer, layout, cursor_position)
+    }
+
     /// Applies a transformation to the produced message of the [`Element`].
     ///
     /// This method is useful when you want to decouple different parts of your
@@ -87,38 +101,46 @@ impl<'a, Message, Renderer> Element<'a, Message, Renderer> {
     ///
     /// ```
     /// # mod counter {
-    /// #     use iced_native::{button, Button};
+    /// #     use iced_native::{text, Text};
     /// #
     /// #     #[derive(Debug, Clone, Copy)]
     /// #     pub enum Message {}
-    /// #     pub struct Counter(button::State);
+    /// #     pub struct Counter;
     /// #
     /// #     impl Counter {
-    /// #         pub fn view(&mut self) -> Button<Message> {
-    /// #             Button::new(&mut self.0, "_")
+    /// #         pub fn view(&mut self) -> Text {
+    /// #             Text::new("")
     /// #         }
     /// #     }
     /// # }
     /// #
     /// # mod iced_wgpu {
     /// #     use iced_native::{
-    /// #         button, Button, MouseCursor, Node, Point, Rectangle, Style, Layout
+    /// #         text, row, Text, Node, Point, Rectangle, Style, Layout, Row
     /// #     };
     /// #     pub struct Renderer;
     /// #
-    /// #     impl button::Renderer for Renderer {
-    /// #         fn node<Message>(&self, _button: &Button<'_, Message>) -> Node {
-    /// #             Node::new(Style::default())
-    /// #         }
+    /// #     impl iced_native::Renderer for Renderer { type Output = (); }
     /// #
+    /// #     impl iced_native::row::Renderer for Renderer {
     /// #         fn draw<Message>(
     /// #             &mut self,
-    /// #             _button: &Button<'_, Message>,
+    /// #             _column: &Row<'_, Message, Self>,
     /// #             _layout: Layout<'_>,
     /// #             _cursor_position: Point,
-    /// #         ) -> MouseCursor {
-    /// #             MouseCursor::OutOfBounds
+    /// #         ) {}
+    /// #     }
+    /// #
+    /// #     impl text::Renderer for Renderer {
+    /// #         fn node(&self, _text: &Text) -> Node {
+    /// #             Node::new(Style::default())
     /// #         }
+    /// #
+    /// #         fn draw(
+    /// #             &mut self,
+    /// #             _text: &Text,
+    /// #             _layout: Layout<'_>,
+    /// #         ) {}
     /// #     }
     /// # }
     /// #
@@ -225,10 +247,7 @@ impl<'a, Message, Renderer> Element<'a, Message, Renderer> {
         }
     }
 
-    pub(crate) fn compute_layout(
-        &self,
-        renderer: &mut Renderer,
-    ) -> result::Layout {
+    pub(crate) fn compute_layout(&self, renderer: &Renderer) -> result::Layout {
         let node = self.widget.node(renderer);
 
         node.0.compute_layout(geometry::Size::undefined()).unwrap()
@@ -268,8 +287,9 @@ impl<'a, A, B, Renderer> Map<'a, A, B, Renderer> {
 impl<'a, A, B, Renderer> Widget<B, Renderer> for Map<'a, A, B, Renderer>
 where
     A: Copy,
+    Renderer: crate::Renderer,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         self.widget.node(renderer)
     }
 
@@ -300,7 +320,7 @@ where
         renderer: &mut Renderer,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor {
+    ) -> Renderer::Output {
         self.widget.draw(renderer, layout, cursor_position)
     }
 
@@ -309,14 +329,14 @@ where
     }
 }
 
-struct Explain<'a, Message, Renderer: renderer::Debugger> {
+struct Explain<'a, Message, Renderer: crate::Renderer> {
     element: Element<'a, Message, Renderer>,
     color: Color,
 }
 
 impl<'a, Message, Renderer> std::fmt::Debug for Explain<'a, Message, Renderer>
 where
-    Renderer: renderer::Debugger,
+    Renderer: crate::Renderer,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Explain")
@@ -327,7 +347,7 @@ where
 
 impl<'a, Message, Renderer> Explain<'a, Message, Renderer>
 where
-    Renderer: renderer::Debugger,
+    Renderer: crate::Renderer,
 {
     fn new(element: Element<'a, Message, Renderer>, color: Color) -> Self {
         Explain { element, color }
@@ -337,9 +357,9 @@ where
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Explain<'a, Message, Renderer>
 where
-    Renderer: renderer::Debugger,
+    Renderer: crate::Renderer + renderer::Debugger,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         self.element.widget.node(renderer)
     }
 
@@ -360,10 +380,13 @@ where
         renderer: &mut Renderer,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor {
-        renderer.explain(&layout, self.color);
-
-        self.element.widget.draw(renderer, layout, cursor_position)
+    ) -> Renderer::Output {
+        renderer.explain(
+            self.element.widget.as_ref(),
+            layout,
+            cursor_position,
+            self.color,
+        )
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
diff --git a/native/src/input/button_state.rs b/native/src/input/button_state.rs
index e9dc05d7..988043ba 100644
--- a/native/src/input/button_state.rs
+++ b/native/src/input/button_state.rs
@@ -1,9 +1,4 @@
 /// The state of a button.
-///
-/// If you are using [`winit`], consider enabling the `winit` feature to get
-/// conversion implementations for free!
-///
-/// [`winit`]: https://docs.rs/winit/0.20.0-alpha3/winit/
 #[derive(Debug, Hash, Ord, PartialOrd, PartialEq, Eq, Clone, Copy)]
 pub enum ButtonState {
     /// The button is pressed.
@@ -12,13 +7,3 @@ pub enum ButtonState {
     /// The button is __not__ pressed.
     Released,
 }
-
-#[cfg(feature = "winit")]
-impl From<winit::event::ElementState> for ButtonState {
-    fn from(element_state: winit::event::ElementState) -> Self {
-        match element_state {
-            winit::event::ElementState::Pressed => ButtonState::Pressed,
-            winit::event::ElementState::Released => ButtonState::Released,
-        }
-    }
-}
diff --git a/native/src/input/keyboard/key_code.rs b/native/src/input/keyboard/key_code.rs
index 207ddeac..26020a57 100644
--- a/native/src/input/keyboard/key_code.rs
+++ b/native/src/input/keyboard/key_code.rs
@@ -2,9 +2,6 @@
 ///
 /// This is mostly the `KeyCode` type found in [`winit`].
 ///
-/// If you are using [`winit`], consider enabling the `winit` feature to get
-/// conversion implementations for free!
-///
 /// [`winit`]: https://docs.rs/winit/0.20.0-alpha3/winit/
 #[derive(Debug, Hash, Ord, PartialOrd, PartialEq, Eq, Clone, Copy)]
 #[repr(u32)]
@@ -199,176 +196,3 @@ pub enum KeyCode {
     Paste,
     Cut,
 }
-
-#[cfg(feature = "winit")]
-impl From<winit::event::VirtualKeyCode> for KeyCode {
-    fn from(virtual_keycode: winit::event::VirtualKeyCode) -> Self {
-        match virtual_keycode {
-            winit::event::VirtualKeyCode::Key1 => KeyCode::Key1,
-            winit::event::VirtualKeyCode::Key2 => KeyCode::Key2,
-            winit::event::VirtualKeyCode::Key3 => KeyCode::Key3,
-            winit::event::VirtualKeyCode::Key4 => KeyCode::Key4,
-            winit::event::VirtualKeyCode::Key5 => KeyCode::Key5,
-            winit::event::VirtualKeyCode::Key6 => KeyCode::Key6,
-            winit::event::VirtualKeyCode::Key7 => KeyCode::Key7,
-            winit::event::VirtualKeyCode::Key8 => KeyCode::Key8,
-            winit::event::VirtualKeyCode::Key9 => KeyCode::Key9,
-            winit::event::VirtualKeyCode::Key0 => KeyCode::Key0,
-            winit::event::VirtualKeyCode::A => KeyCode::A,
-            winit::event::VirtualKeyCode::B => KeyCode::B,
-            winit::event::VirtualKeyCode::C => KeyCode::C,
-            winit::event::VirtualKeyCode::D => KeyCode::D,
-            winit::event::VirtualKeyCode::E => KeyCode::E,
-            winit::event::VirtualKeyCode::F => KeyCode::F,
-            winit::event::VirtualKeyCode::G => KeyCode::G,
-            winit::event::VirtualKeyCode::H => KeyCode::H,
-            winit::event::VirtualKeyCode::I => KeyCode::I,
-            winit::event::VirtualKeyCode::J => KeyCode::J,
-            winit::event::VirtualKeyCode::K => KeyCode::K,
-            winit::event::VirtualKeyCode::L => KeyCode::L,
-            winit::event::VirtualKeyCode::M => KeyCode::M,
-            winit::event::VirtualKeyCode::N => KeyCode::N,
-            winit::event::VirtualKeyCode::O => KeyCode::O,
-            winit::event::VirtualKeyCode::P => KeyCode::P,
-            winit::event::VirtualKeyCode::Q => KeyCode::Q,
-            winit::event::VirtualKeyCode::R => KeyCode::R,
-            winit::event::VirtualKeyCode::S => KeyCode::S,
-            winit::event::VirtualKeyCode::T => KeyCode::T,
-            winit::event::VirtualKeyCode::U => KeyCode::U,
-            winit::event::VirtualKeyCode::V => KeyCode::V,
-            winit::event::VirtualKeyCode::W => KeyCode::W,
-            winit::event::VirtualKeyCode::X => KeyCode::X,
-            winit::event::VirtualKeyCode::Y => KeyCode::Y,
-            winit::event::VirtualKeyCode::Z => KeyCode::Z,
-            winit::event::VirtualKeyCode::Escape => KeyCode::Escape,
-            winit::event::VirtualKeyCode::F1 => KeyCode::F1,
-            winit::event::VirtualKeyCode::F2 => KeyCode::F2,
-            winit::event::VirtualKeyCode::F3 => KeyCode::F3,
-            winit::event::VirtualKeyCode::F4 => KeyCode::F4,
-            winit::event::VirtualKeyCode::F5 => KeyCode::F5,
-            winit::event::VirtualKeyCode::F6 => KeyCode::F6,
-            winit::event::VirtualKeyCode::F7 => KeyCode::F7,
-            winit::event::VirtualKeyCode::F8 => KeyCode::F8,
-            winit::event::VirtualKeyCode::F9 => KeyCode::F9,
-            winit::event::VirtualKeyCode::F10 => KeyCode::F10,
-            winit::event::VirtualKeyCode::F11 => KeyCode::F11,
-            winit::event::VirtualKeyCode::F12 => KeyCode::F12,
-            winit::event::VirtualKeyCode::F13 => KeyCode::F13,
-            winit::event::VirtualKeyCode::F14 => KeyCode::F14,
-            winit::event::VirtualKeyCode::F15 => KeyCode::F15,
-            winit::event::VirtualKeyCode::F16 => KeyCode::F16,
-            winit::event::VirtualKeyCode::F17 => KeyCode::F17,
-            winit::event::VirtualKeyCode::F18 => KeyCode::F18,
-            winit::event::VirtualKeyCode::F19 => KeyCode::F19,
-            winit::event::VirtualKeyCode::F20 => KeyCode::F20,
-            winit::event::VirtualKeyCode::F21 => KeyCode::F21,
-            winit::event::VirtualKeyCode::F22 => KeyCode::F22,
-            winit::event::VirtualKeyCode::F23 => KeyCode::F23,
-            winit::event::VirtualKeyCode::F24 => KeyCode::F24,
-            winit::event::VirtualKeyCode::Snapshot => KeyCode::Snapshot,
-            winit::event::VirtualKeyCode::Scroll => KeyCode::Scroll,
-            winit::event::VirtualKeyCode::Pause => KeyCode::Pause,
-            winit::event::VirtualKeyCode::Insert => KeyCode::Insert,
-            winit::event::VirtualKeyCode::Home => KeyCode::Home,
-            winit::event::VirtualKeyCode::Delete => KeyCode::Delete,
-            winit::event::VirtualKeyCode::End => KeyCode::End,
-            winit::event::VirtualKeyCode::PageDown => KeyCode::PageDown,
-            winit::event::VirtualKeyCode::PageUp => KeyCode::PageUp,
-            winit::event::VirtualKeyCode::Left => KeyCode::Left,
-            winit::event::VirtualKeyCode::Up => KeyCode::Up,
-            winit::event::VirtualKeyCode::Right => KeyCode::Right,
-            winit::event::VirtualKeyCode::Down => KeyCode::Down,
-            winit::event::VirtualKeyCode::Back => KeyCode::Backspace,
-            winit::event::VirtualKeyCode::Return => KeyCode::Enter,
-            winit::event::VirtualKeyCode::Space => KeyCode::Space,
-            winit::event::VirtualKeyCode::Compose => KeyCode::Compose,
-            winit::event::VirtualKeyCode::Caret => KeyCode::Caret,
-            winit::event::VirtualKeyCode::Numlock => KeyCode::Numlock,
-            winit::event::VirtualKeyCode::Numpad0 => KeyCode::Numpad0,
-            winit::event::VirtualKeyCode::Numpad1 => KeyCode::Numpad1,
-            winit::event::VirtualKeyCode::Numpad2 => KeyCode::Numpad2,
-            winit::event::VirtualKeyCode::Numpad3 => KeyCode::Numpad3,
-            winit::event::VirtualKeyCode::Numpad4 => KeyCode::Numpad4,
-            winit::event::VirtualKeyCode::Numpad5 => KeyCode::Numpad5,
-            winit::event::VirtualKeyCode::Numpad6 => KeyCode::Numpad6,
-            winit::event::VirtualKeyCode::Numpad7 => KeyCode::Numpad7,
-            winit::event::VirtualKeyCode::Numpad8 => KeyCode::Numpad8,
-            winit::event::VirtualKeyCode::Numpad9 => KeyCode::Numpad9,
-            winit::event::VirtualKeyCode::AbntC1 => KeyCode::AbntC1,
-            winit::event::VirtualKeyCode::AbntC2 => KeyCode::AbntC2,
-            winit::event::VirtualKeyCode::Add => KeyCode::Add,
-            winit::event::VirtualKeyCode::Apostrophe => KeyCode::Apostrophe,
-            winit::event::VirtualKeyCode::Apps => KeyCode::Apps,
-            winit::event::VirtualKeyCode::At => KeyCode::At,
-            winit::event::VirtualKeyCode::Ax => KeyCode::Ax,
-            winit::event::VirtualKeyCode::Backslash => KeyCode::Backslash,
-            winit::event::VirtualKeyCode::Calculator => KeyCode::Calculator,
-            winit::event::VirtualKeyCode::Capital => KeyCode::Capital,
-            winit::event::VirtualKeyCode::Colon => KeyCode::Colon,
-            winit::event::VirtualKeyCode::Comma => KeyCode::Comma,
-            winit::event::VirtualKeyCode::Convert => KeyCode::Convert,
-            winit::event::VirtualKeyCode::Decimal => KeyCode::Decimal,
-            winit::event::VirtualKeyCode::Divide => KeyCode::Divide,
-            winit::event::VirtualKeyCode::Equals => KeyCode::Equals,
-            winit::event::VirtualKeyCode::Grave => KeyCode::Grave,
-            winit::event::VirtualKeyCode::Kana => KeyCode::Kana,
-            winit::event::VirtualKeyCode::Kanji => KeyCode::Kanji,
-            winit::event::VirtualKeyCode::LAlt => KeyCode::LAlt,
-            winit::event::VirtualKeyCode::LBracket => KeyCode::LBracket,
-            winit::event::VirtualKeyCode::LControl => KeyCode::LControl,
-            winit::event::VirtualKeyCode::LShift => KeyCode::LShift,
-            winit::event::VirtualKeyCode::LWin => KeyCode::LWin,
-            winit::event::VirtualKeyCode::Mail => KeyCode::Mail,
-            winit::event::VirtualKeyCode::MediaSelect => KeyCode::MediaSelect,
-            winit::event::VirtualKeyCode::MediaStop => KeyCode::MediaStop,
-            winit::event::VirtualKeyCode::Minus => KeyCode::Minus,
-            winit::event::VirtualKeyCode::Multiply => KeyCode::Multiply,
-            winit::event::VirtualKeyCode::Mute => KeyCode::Mute,
-            winit::event::VirtualKeyCode::MyComputer => KeyCode::MyComputer,
-            winit::event::VirtualKeyCode::NavigateForward => {
-                KeyCode::NavigateForward
-            }
-            winit::event::VirtualKeyCode::NavigateBackward => {
-                KeyCode::NavigateBackward
-            }
-            winit::event::VirtualKeyCode::NextTrack => KeyCode::NextTrack,
-            winit::event::VirtualKeyCode::NoConvert => KeyCode::NoConvert,
-            winit::event::VirtualKeyCode::NumpadComma => KeyCode::NumpadComma,
-            winit::event::VirtualKeyCode::NumpadEnter => KeyCode::NumpadEnter,
-            winit::event::VirtualKeyCode::NumpadEquals => KeyCode::NumpadEquals,
-            winit::event::VirtualKeyCode::OEM102 => KeyCode::OEM102,
-            winit::event::VirtualKeyCode::Period => KeyCode::Period,
-            winit::event::VirtualKeyCode::PlayPause => KeyCode::PlayPause,
-            winit::event::VirtualKeyCode::Power => KeyCode::Power,
-            winit::event::VirtualKeyCode::PrevTrack => KeyCode::PrevTrack,
-            winit::event::VirtualKeyCode::RAlt => KeyCode::RAlt,
-            winit::event::VirtualKeyCode::RBracket => KeyCode::RBracket,
-            winit::event::VirtualKeyCode::RControl => KeyCode::RControl,
-            winit::event::VirtualKeyCode::RShift => KeyCode::RShift,
-            winit::event::VirtualKeyCode::RWin => KeyCode::RWin,
-            winit::event::VirtualKeyCode::Semicolon => KeyCode::Semicolon,
-            winit::event::VirtualKeyCode::Slash => KeyCode::Slash,
-            winit::event::VirtualKeyCode::Sleep => KeyCode::Sleep,
-            winit::event::VirtualKeyCode::Stop => KeyCode::Stop,
-            winit::event::VirtualKeyCode::Subtract => KeyCode::Subtract,
-            winit::event::VirtualKeyCode::Sysrq => KeyCode::Sysrq,
-            winit::event::VirtualKeyCode::Tab => KeyCode::Tab,
-            winit::event::VirtualKeyCode::Underline => KeyCode::Underline,
-            winit::event::VirtualKeyCode::Unlabeled => KeyCode::Unlabeled,
-            winit::event::VirtualKeyCode::VolumeDown => KeyCode::VolumeDown,
-            winit::event::VirtualKeyCode::VolumeUp => KeyCode::VolumeUp,
-            winit::event::VirtualKeyCode::Wake => KeyCode::Wake,
-            winit::event::VirtualKeyCode::WebBack => KeyCode::WebBack,
-            winit::event::VirtualKeyCode::WebFavorites => KeyCode::WebFavorites,
-            winit::event::VirtualKeyCode::WebForward => KeyCode::WebForward,
-            winit::event::VirtualKeyCode::WebHome => KeyCode::WebHome,
-            winit::event::VirtualKeyCode::WebRefresh => KeyCode::WebRefresh,
-            winit::event::VirtualKeyCode::WebSearch => KeyCode::WebSearch,
-            winit::event::VirtualKeyCode::WebStop => KeyCode::WebStop,
-            winit::event::VirtualKeyCode::Yen => KeyCode::Yen,
-            winit::event::VirtualKeyCode::Copy => KeyCode::Copy,
-            winit::event::VirtualKeyCode::Paste => KeyCode::Paste,
-            winit::event::VirtualKeyCode::Cut => KeyCode::Cut,
-        }
-    }
-}
diff --git a/native/src/input/mouse/button.rs b/native/src/input/mouse/button.rs
index 6320d701..aeb8a55d 100644
--- a/native/src/input/mouse/button.rs
+++ b/native/src/input/mouse/button.rs
@@ -1,9 +1,4 @@
 /// The button of a mouse.
-///
-/// If you are using [`winit`], consider enabling the `winit` feature to get
-/// conversion implementations for free!
-///
-/// [`winit`]: https://docs.rs/winit/0.20.0-alpha3/winit/
 #[derive(Debug, Hash, PartialEq, Eq, Clone, Copy)]
 pub enum Button {
     /// The left mouse button.
@@ -18,15 +13,3 @@ pub enum Button {
     /// Some other button.
     Other(u8),
 }
-
-#[cfg(feature = "winit")]
-impl From<winit::event::MouseButton> for super::Button {
-    fn from(mouse_button: winit::event::MouseButton) -> Self {
-        match mouse_button {
-            winit::event::MouseButton::Left => Button::Left,
-            winit::event::MouseButton::Right => Button::Right,
-            winit::event::MouseButton::Middle => Button::Middle,
-            winit::event::MouseButton::Other(other) => Button::Other(other),
-        }
-    }
-}
diff --git a/native/src/lib.rs b/native/src/lib.rs
index 39da4943..fa72a553 100644
--- a/native/src/lib.rs
+++ b/native/src/lib.rs
@@ -77,28 +77,29 @@
 //! #
 //! # mod iced_wgpu {
 //! #     use iced_native::{
-//! #         button, text, Button, Text,
-//! #         MouseCursor, Node, Point, Rectangle, Style, Color, Layout
+//! #         button, text, Button, Text, Node, Point, Rectangle, Style, Color, Layout
 //! #     };
 //! #
 //! #     pub struct Renderer {}
 //! #
+//! #     impl iced_native::Renderer for Renderer {
+//! #         type Output = ();
+//! #     }
+//! #
 //! #     impl button::Renderer for Renderer {
 //! #         fn node<Message>(
 //! #             &self,
-//! #             _button: &Button<'_, Message>
+//! #             _button: &Button<'_, Message, Self>
 //! #         ) -> Node {
 //! #             Node::new(Style::default())
 //! #         }
 //! #
 //! #         fn draw<Message>(
 //! #             &mut self,
-//! #             _button: &Button<'_, Message>,
+//! #             _button: &Button<'_, Message, Self>,
 //! #             _layout: Layout<'_>,
 //! #             _cursor_position: Point,
-//! #         ) -> MouseCursor {
-//! #             MouseCursor::OutOfBounds
-//! #         }
+//! #         ) {}
 //! #     }
 //! #
 //! #     impl text::Renderer for Renderer {
@@ -124,7 +125,7 @@
 //!             .push(
 //!                 // The increment button. We tell it to produce an
 //!                 // `IncrementPressed` message when pressed
-//!                 Button::new(&mut self.increment_button, "+")
+//!                 Button::new(&mut self.increment_button, Text::new("+"))
 //!                     .on_press(Message::IncrementPressed),
 //!             )
 //!             .push(
@@ -134,7 +135,7 @@
 //!             .push(
 //!                 // The decrement button. We tell it to produce a
 //!                 // `DecrementPressed` message when pressed
-//!                 Button::new(&mut self.decrement_button, "-")
+//!                 Button::new(&mut self.decrement_button, Text::new("-"))
 //!                     .on_press(Message::DecrementPressed),
 //!             )
 //!     }
@@ -192,7 +193,7 @@
 //! [documentation]: https://docs.rs/iced
 //! [examples]: https://github.com/hecrj/iced/tree/master/examples
 //! [`UserInterface`]: struct.UserInterface.html
-#![deny(missing_docs)]
+//#![deny(missing_docs)]
 #![deny(missing_debug_implementations)]
 #![deny(unused_results)]
 #![deny(unsafe_code)]
@@ -212,7 +213,9 @@ mod user_interface;
 
 pub(crate) use iced_core::Vector;
 
-pub use iced_core::{Align, Color, Justify, Length, Point, Rectangle};
+pub use iced_core::{
+    Align, Background, Color, Justify, Length, Point, Rectangle,
+};
 
 #[doc(no_inline)]
 pub use stretch::{geometry::Size, number::Number};
@@ -223,6 +226,7 @@ pub use hasher::Hasher;
 pub use layout::Layout;
 pub use mouse_cursor::MouseCursor;
 pub use node::Node;
+pub use renderer::Renderer;
 pub use style::Style;
 pub use user_interface::{Cache, UserInterface};
 pub use widget::*;
diff --git a/native/src/mouse_cursor.rs b/native/src/mouse_cursor.rs
index 4ef6361a..291e57a6 100644
--- a/native/src/mouse_cursor.rs
+++ b/native/src/mouse_cursor.rs
@@ -1,5 +1,5 @@
 /// The state of the mouse cursor.
-#[derive(Debug, Eq, PartialEq, Clone, Copy)]
+#[derive(Debug, Eq, PartialEq, Clone, Copy, PartialOrd, Ord)]
 pub enum MouseCursor {
     /// The cursor is out of the bounds of the user interface.
     OutOfBounds,
@@ -19,17 +19,3 @@ pub enum MouseCursor {
     /// The cursor is grabbing a widget.
     Grabbing,
 }
-
-#[cfg(feature = "winit")]
-impl From<MouseCursor> for winit::window::CursorIcon {
-    fn from(mouse_cursor: MouseCursor) -> winit::window::CursorIcon {
-        match mouse_cursor {
-            MouseCursor::OutOfBounds => winit::window::CursorIcon::Default,
-            MouseCursor::Idle => winit::window::CursorIcon::Default,
-            MouseCursor::Pointer => winit::window::CursorIcon::Hand,
-            MouseCursor::Working => winit::window::CursorIcon::Progress,
-            MouseCursor::Grab => winit::window::CursorIcon::Grab,
-            MouseCursor::Grabbing => winit::window::CursorIcon::Grabbing,
-        }
-    }
-}
diff --git a/native/src/renderer.rs b/native/src/renderer.rs
index 2244f00b..afe1b09a 100644
--- a/native/src/renderer.rs
+++ b/native/src/renderer.rs
@@ -1,8 +1,10 @@
 //! Write your own renderer.
 //!
-//! There is not a common entrypoint or trait for a __renderer__ in Iced.
-//! Instead, every [`Widget`] constrains its generic `Renderer` type as
-//! necessary.
+//! You will need to implement the `Renderer` trait first. It simply contains
+//! an `Output` associated type.
+//!
+//! There is no common trait to draw all the widgets. Instead, every [`Widget`]
+//! constrains its generic `Renderer` type as necessary.
 //!
 //! This approach is flexible and composable. For instance, the
 //! [`Text`] widget only needs a [`text::Renderer`] while a [`Checkbox`] widget
@@ -17,22 +19,13 @@
 //! [`text::Renderer`]: ../widget/text/trait.Renderer.html
 //! [`Checkbox`]: ../widget/checkbox/struct.Checkbox.html
 //! [`checkbox::Renderer`]: ../widget/checkbox/trait.Renderer.html
-use crate::{Color, Layout};
 
-/// A renderer able to graphically explain a [`Layout`].
-///
-/// [`Layout`]: ../struct.Layout.html
-pub trait Debugger {
-    /// Explains the [`Layout`] of an [`Element`] for debugging purposes.
-    ///
-    /// This will be called when [`Element::explain`] has been used. It should
-    /// _explain_ the given [`Layout`] graphically.
-    ///
-    /// A common approach consists in recursively rendering the bounds of the
-    /// [`Layout`] and its children.
-    ///
-    /// [`Layout`]: struct.Layout.html
-    /// [`Element`]: struct.Element.html
-    /// [`Element::explain`]: struct.Element.html#method.explain
-    fn explain(&mut self, layout: &Layout<'_>, color: Color);
+mod debugger;
+mod windowed;
+
+pub use debugger::Debugger;
+pub use windowed::Windowed;
+
+pub trait Renderer {
+    type Output;
 }
diff --git a/native/src/renderer/debugger.rs b/native/src/renderer/debugger.rs
new file mode 100644
index 00000000..4cc50661
--- /dev/null
+++ b/native/src/renderer/debugger.rs
@@ -0,0 +1,25 @@
+use crate::{Color, Layout, Point, Widget};
+
+/// A renderer able to graphically explain a [`Layout`].
+///
+/// [`Layout`]: ../struct.Layout.html
+pub trait Debugger: super::Renderer {
+    /// Explains the [`Layout`] of an [`Element`] for debugging purposes.
+    ///
+    /// This will be called when [`Element::explain`] has been used. It should
+    /// _explain_ the given [`Layout`] graphically.
+    ///
+    /// A common approach consists in recursively rendering the bounds of the
+    /// [`Layout`] and its children.
+    ///
+    /// [`Layout`]: struct.Layout.html
+    /// [`Element`]: struct.Element.html
+    /// [`Element::explain`]: struct.Element.html#method.explain
+    fn explain<Message>(
+        &mut self,
+        widget: &dyn Widget<Message, Self>,
+        layout: Layout<'_>,
+        cursor_position: Point,
+        color: Color,
+    ) -> Self::Output;
+}
diff --git a/native/src/renderer/windowed.rs b/native/src/renderer/windowed.rs
new file mode 100644
index 00000000..bcf37964
--- /dev/null
+++ b/native/src/renderer/windowed.rs
@@ -0,0 +1,17 @@
+use crate::MouseCursor;
+
+use raw_window_handle::HasRawWindowHandle;
+
+pub trait Windowed: super::Renderer {
+    type Target;
+
+    fn new<W: HasRawWindowHandle>(window: &W) -> Self;
+
+    fn target(&self, width: u16, height: u16) -> Self::Target;
+
+    fn draw(
+        &mut self,
+        output: &Self::Output,
+        target: &mut Self::Target,
+    ) -> MouseCursor;
+}
diff --git a/native/src/style.rs b/native/src/style.rs
index b1c49fd4..70a7ff74 100644
--- a/native/src/style.rs
+++ b/native/src/style.rs
@@ -74,12 +74,12 @@ impl Style {
         self
     }
 
-    pub(crate) fn align_items(mut self, align: Align) -> Self {
+    pub fn align_items(mut self, align: Align) -> Self {
         self.0.align_items = into_align_items(align);
         self
     }
 
-    pub(crate) fn justify_content(mut self, justify: Justify) -> Self {
+    pub fn justify_content(mut self, justify: Justify) -> Self {
         self.0.justify_content = into_justify_content(justify);
         self
     }
diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs
index 4bfacb2e..5675076d 100644
--- a/native/src/user_interface.rs
+++ b/native/src/user_interface.rs
@@ -1,7 +1,7 @@
-use crate::{input::mouse, Column, Element, Event, Layout, MouseCursor, Point};
+use crate::{input::mouse, Element, Event, Layout, Point};
 
 use std::hash::Hasher;
-use stretch::result;
+use stretch::{geometry, result};
 
 /// A set of interactive graphical elements with a specific [`Layout`].
 ///
@@ -19,7 +19,10 @@ pub struct UserInterface<'a, Message, Renderer> {
     cursor_position: Point,
 }
 
-impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> {
+impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer>
+where
+    Renderer: crate::Renderer,
+{
     /// Builds a user interface for an [`Element`].
     ///
     /// It is able to avoid expensive computations when using a [`Cache`]
@@ -44,6 +47,19 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> {
     /// #     impl Renderer {
     /// #         pub fn new() -> Self { Renderer }
     /// #     }
+    /// #
+    /// #     impl iced_native::Renderer for Renderer { type Output = (); }
+    /// #
+    /// #     impl iced_native::column::Renderer for Renderer {
+    /// #         fn draw<Message>(
+    /// #             &mut self,
+    /// #             _column: &iced_native::Column<'_, Message, Self>,
+    /// #             _layout: iced_native::Layout<'_>,
+    /// #             _cursor_position: iced_native::Point,
+    /// #         ) -> Self::Output {
+    /// #             ()
+    /// #         }
+    /// #     }
     /// # }
     /// #
     /// # use iced_native::Column;
@@ -82,7 +98,7 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> {
     pub fn build<E: Into<Element<'a, Message, Renderer>>>(
         root: E,
         cache: Cache,
-        renderer: &mut Renderer,
+        renderer: &Renderer,
     ) -> Self {
         let root = root.into();
 
@@ -127,6 +143,19 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> {
     /// #     impl Renderer {
     /// #         pub fn new() -> Self { Renderer }
     /// #     }
+    /// #
+    /// #     impl iced_native::Renderer for Renderer { type Output = (); }
+    /// #
+    /// #     impl iced_native::column::Renderer for Renderer {
+    /// #         fn draw<Message>(
+    /// #             &mut self,
+    /// #             _column: &iced_native::Column<'_, Message, Self>,
+    /// #             _layout: iced_native::Layout<'_>,
+    /// #             _cursor_position: iced_native::Point,
+    /// #         ) -> Self::Output {
+    /// #             ()
+    /// #         }
+    /// #     }
     /// # }
     /// #
     /// # use iced_native::Column;
@@ -212,6 +241,19 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> {
     /// #     impl Renderer {
     /// #         pub fn new() -> Self { Renderer }
     /// #     }
+    /// #
+    /// #     impl iced_native::Renderer for Renderer { type Output = (); }
+    /// #
+    /// #     impl iced_native::column::Renderer for Renderer {
+    /// #         fn draw<Message>(
+    /// #             &mut self,
+    /// #             _column: &iced_native::Column<'_, Message, Self>,
+    /// #             _layout: iced_native::Layout<'_>,
+    /// #             _cursor_position: iced_native::Point,
+    /// #         ) -> Self::Output {
+    /// #             ()
+    /// #         }
+    /// #     }
     /// # }
     /// #
     /// # use iced_native::Column;
@@ -254,7 +296,7 @@ impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer> {
     ///     // Flush rendering operations...
     /// }
     /// ```
-    pub fn draw(&self, renderer: &mut Renderer) -> MouseCursor {
+    pub fn draw(&self, renderer: &mut Renderer) -> Renderer::Output {
         self.root.widget.draw(
             renderer,
             Layout::new(&self.layout),
@@ -295,14 +337,16 @@ impl Cache {
     /// [`Cache`]: struct.Cache.html
     /// [`UserInterface`]: struct.UserInterface.html
     pub fn new() -> Cache {
-        let root: Element<'_, (), ()> = Column::new().into();
+        use crate::{Node, Style};
 
-        let hasher = &mut crate::Hasher::default();
-        root.hash_layout(hasher);
+        let empty_node = Node::new(Style::default());
 
         Cache {
-            hash: hasher.finish(),
-            layout: root.compute_layout(&mut ()),
+            hash: 0,
+            layout: empty_node
+                .0
+                .compute_layout(geometry::Size::undefined())
+                .unwrap(),
             cursor_position: Point::new(0.0, 0.0),
         }
     }
diff --git a/native/src/widget.rs b/native/src/widget.rs
index 9b770454..bcef2665 100644
--- a/native/src/widget.rs
+++ b/native/src/widget.rs
@@ -20,13 +20,12 @@
 //!
 //! [`Widget`]: trait.Widget.html
 //! [renderer]: ../renderer/index.html
-mod column;
-mod row;
-
 pub mod button;
 pub mod checkbox;
+pub mod column;
 pub mod image;
 pub mod radio;
+pub mod row;
 pub mod slider;
 pub mod text;
 
@@ -47,7 +46,7 @@ pub use slider::Slider;
 #[doc(no_inline)]
 pub use text::Text;
 
-use crate::{Event, Hasher, Layout, MouseCursor, Node, Point};
+use crate::{Event, Hasher, Layout, Node, Point};
 
 /// A component that displays information and allows interaction.
 ///
@@ -56,7 +55,10 @@ use crate::{Event, Hasher, Layout, MouseCursor, Node, Point};
 ///
 /// [`Widget`]: trait.Widget.html
 /// [`Element`]: ../struct.Element.html
-pub trait Widget<Message, Renderer>: std::fmt::Debug {
+pub trait Widget<Message, Renderer>: std::fmt::Debug
+where
+    Renderer: crate::Renderer,
+{
     /// Returns the [`Node`] of the [`Widget`].
     ///
     /// This [`Node`] is used by the runtime to compute the [`Layout`] of the
@@ -65,20 +67,17 @@ pub trait Widget<Message, Renderer>: std::fmt::Debug {
     /// [`Node`]: ../struct.Node.html
     /// [`Widget`]: trait.Widget.html
     /// [`Layout`]: ../struct.Layout.html
-    fn node(&self, renderer: &mut Renderer) -> Node;
+    fn node(&self, renderer: &Renderer) -> Node;
 
     /// Draws the [`Widget`] using the associated `Renderer`.
     ///
-    /// It must return the [`MouseCursor`] state for the [`Widget`].
-    ///
     /// [`Widget`]: trait.Widget.html
-    /// [`MouseCursor`]: ../enum.MouseCursor.html
     fn draw(
         &self,
         renderer: &mut Renderer,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor;
+    ) -> Renderer::Output;
 
     /// Computes the _layout_ hash of the [`Widget`].
     ///
diff --git a/native/src/widget/button.rs b/native/src/widget/button.rs
index 7b5c4a86..4ab59f7f 100644
--- a/native/src/widget/button.rs
+++ b/native/src/widget/button.rs
@@ -7,17 +7,21 @@
 //! [`Class`]: enum.Class.html
 
 use crate::input::{mouse, ButtonState};
-use crate::{Element, Event, Hasher, Layout, MouseCursor, Node, Point, Widget};
+use crate::{Element, Event, Hasher, Layout, Node, Point, Widget};
 use std::hash::Hash;
 
-pub use iced_core::button::*;
+pub use iced_core::button::State;
 
-impl<'a, Message, Renderer> Widget<Message, Renderer> for Button<'a, Message>
+pub type Button<'a, Message, Renderer> =
+    iced_core::Button<'a, Message, Element<'a, Message, Renderer>>;
+
+impl<'a, Message, Renderer> Widget<Message, Renderer>
+    for Button<'a, Message, Renderer>
 where
     Renderer: self::Renderer,
     Message: Copy + std::fmt::Debug,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         renderer.node(&self)
     }
 
@@ -63,14 +67,14 @@ where
         renderer: &mut Renderer,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor {
+    ) -> Renderer::Output {
         renderer.draw(&self, layout, cursor_position)
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
-        self.label.hash(state);
         self.width.hash(state);
         self.align_self.hash(state);
+        self.content.hash_layout(state);
     }
 }
 
@@ -81,31 +85,33 @@ where
 ///
 /// [`Button`]: struct.Button.html
 /// [renderer]: ../../renderer/index.html
-pub trait Renderer {
+pub trait Renderer: crate::Renderer + Sized {
     /// Creates a [`Node`] for the provided [`Button`].
     ///
     /// [`Node`]: ../../struct.Node.html
     /// [`Button`]: struct.Button.html
-    fn node<Message>(&self, button: &Button<'_, Message>) -> Node;
+    fn node<Message>(&self, button: &Button<'_, Message, Self>) -> Node;
 
     /// Draws a [`Button`].
     ///
     /// [`Button`]: struct.Button.html
     fn draw<Message>(
         &mut self,
-        button: &Button<'_, Message>,
+        button: &Button<'_, Message, Self>,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor;
+    ) -> Self::Output;
 }
 
-impl<'a, Message, Renderer> From<Button<'a, Message>>
+impl<'a, Message, Renderer> From<Button<'a, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
-    Renderer: self::Renderer,
+    Renderer: 'static + self::Renderer,
     Message: 'static + Copy + std::fmt::Debug,
 {
-    fn from(button: Button<'a, Message>) -> Element<'a, Message, Renderer> {
+    fn from(
+        button: Button<'a, Message, Renderer>,
+    ) -> Element<'a, Message, Renderer> {
         Element::new(button)
     }
 }
diff --git a/native/src/widget/checkbox.rs b/native/src/widget/checkbox.rs
index 3e307f64..5393417e 100644
--- a/native/src/widget/checkbox.rs
+++ b/native/src/widget/checkbox.rs
@@ -2,7 +2,7 @@
 use std::hash::Hash;
 
 use crate::input::{mouse, ButtonState};
-use crate::{Element, Event, Hasher, Layout, MouseCursor, Node, Point, Widget};
+use crate::{Element, Event, Hasher, Layout, Node, Point, Widget};
 
 pub use iced_core::Checkbox;
 
@@ -10,7 +10,7 @@ impl<Message, Renderer> Widget<Message, Renderer> for Checkbox<Message>
 where
     Renderer: self::Renderer,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         renderer.node(&self)
     }
 
@@ -26,9 +26,7 @@ where
                 button: mouse::Button::Left,
                 state: ButtonState::Pressed,
             }) => {
-                let mouse_over = layout
-                    .children()
-                    .any(|child| child.bounds().contains(cursor_position));
+                let mouse_over = layout.bounds().contains(cursor_position);
 
                 if mouse_over {
                     messages.push((self.on_toggle)(!self.is_checked));
@@ -43,7 +41,7 @@ where
         renderer: &mut Renderer,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor {
+    ) -> Renderer::Output {
         renderer.draw(&self, layout, cursor_position)
     }
 
@@ -59,12 +57,12 @@ where
 ///
 /// [`Checkbox`]: struct.Checkbox.html
 /// [renderer]: ../../renderer/index.html
-pub trait Renderer {
+pub trait Renderer: crate::Renderer {
     /// Creates a [`Node`] for the provided [`Checkbox`].
     ///
     /// [`Node`]: ../../struct.Node.html
     /// [`Checkbox`]: struct.Checkbox.html
-    fn node<Message>(&mut self, checkbox: &Checkbox<Message>) -> Node;
+    fn node<Message>(&self, checkbox: &Checkbox<Message>) -> Node;
 
     /// Draws a [`Checkbox`].
     ///
@@ -80,7 +78,7 @@ pub trait Renderer {
         checkbox: &Checkbox<Message>,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor;
+    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Checkbox<Message>>
diff --git a/native/src/widget/column.rs b/native/src/widget/column.rs
index 9da2e161..7995cf5d 100644
--- a/native/src/widget/column.rs
+++ b/native/src/widget/column.rs
@@ -1,8 +1,6 @@
 use std::hash::Hash;
 
-use crate::{
-    Element, Event, Hasher, Layout, MouseCursor, Node, Point, Style, Widget,
-};
+use crate::{Element, Event, Hasher, Layout, Node, Point, Style, Widget};
 
 /// A container that distributes its contents vertically.
 pub type Column<'a, Message, Renderer> =
@@ -10,8 +8,10 @@ pub type Column<'a, Message, Renderer> =
 
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Column<'a, Message, Renderer>
+where
+    Renderer: self::Renderer,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         let mut children: Vec<Node> = self
             .children
             .iter()
@@ -70,21 +70,8 @@ impl<'a, Message, Renderer> Widget<Message, Renderer>
         renderer: &mut Renderer,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor {
-        let mut cursor = MouseCursor::OutOfBounds;
-
-        self.children.iter().zip(layout.children()).for_each(
-            |(child, layout)| {
-                let new_cursor =
-                    child.widget.draw(renderer, layout, cursor_position);
-
-                if new_cursor != MouseCursor::OutOfBounds {
-                    cursor = new_cursor;
-                }
-            },
-        );
-
-        cursor
+    ) -> Renderer::Output {
+        renderer.draw(&self, layout, cursor_position)
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -104,10 +91,19 @@ impl<'a, Message, Renderer> Widget<Message, Renderer>
     }
 }
 
+pub trait Renderer: crate::Renderer + Sized {
+    fn draw<Message>(
+        &mut self,
+        row: &Column<'_, Message, Self>,
+        layout: Layout<'_>,
+        cursor_position: Point,
+    ) -> Self::Output;
+}
+
 impl<'a, Message, Renderer> From<Column<'a, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
-    Renderer: 'a,
+    Renderer: 'a + self::Renderer,
     Message: 'static,
 {
     fn from(
diff --git a/native/src/widget/image.rs b/native/src/widget/image.rs
index 81f99acb..6255a7b5 100644
--- a/native/src/widget/image.rs
+++ b/native/src/widget/image.rs
@@ -1,17 +1,16 @@
 //! Display images in your user interface.
 
-use crate::{Element, Hasher, Layout, MouseCursor, Node, Point, Widget};
+use crate::{Element, Hasher, Layout, Node, Point, Widget};
 
 use std::hash::Hash;
 
 pub use iced_core::Image;
 
-impl<I, Message, Renderer> Widget<Message, Renderer> for Image<I>
+impl<Message, Renderer> Widget<Message, Renderer> for Image
 where
-    Renderer: self::Renderer<I>,
-    I: Clone,
+    Renderer: self::Renderer,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         renderer.node(&self)
     }
 
@@ -20,10 +19,8 @@ where
         renderer: &mut Renderer,
         layout: Layout<'_>,
         _cursor_position: Point,
-    ) -> MouseCursor {
-        renderer.draw(&self, layout);
-
-        MouseCursor::OutOfBounds
+    ) -> Renderer::Output {
+        renderer.draw(&self, layout)
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -40,27 +37,26 @@ where
 ///
 /// [`Image`]: struct.Image.html
 /// [renderer]: ../../renderer/index.html
-pub trait Renderer<I> {
+pub trait Renderer: crate::Renderer {
     /// Creates a [`Node`] for the provided [`Image`].
     ///
     /// You should probably keep the original aspect ratio, if possible.
     ///
     /// [`Node`]: ../../struct.Node.html
     /// [`Image`]: struct.Image.html
-    fn node(&mut self, image: &Image<I>) -> Node;
+    fn node(&self, image: &Image) -> Node;
 
     /// Draws an [`Image`].
     ///
     /// [`Image`]: struct.Image.html
-    fn draw(&mut self, image: &Image<I>, layout: Layout<'_>);
+    fn draw(&mut self, image: &Image, layout: Layout<'_>) -> Self::Output;
 }
 
-impl<'a, I, Message, Renderer> From<Image<I>> for Element<'a, Message, Renderer>
+impl<'a, Message, Renderer> From<Image> for Element<'a, Message, Renderer>
 where
-    Renderer: self::Renderer<I>,
-    I: Clone + 'a,
+    Renderer: self::Renderer,
 {
-    fn from(image: Image<I>) -> Element<'a, Message, Renderer> {
+    fn from(image: Image) -> Element<'a, Message, Renderer> {
         Element::new(image)
     }
 }
diff --git a/native/src/widget/radio.rs b/native/src/widget/radio.rs
index 33d42e61..27b8f8a8 100644
--- a/native/src/widget/radio.rs
+++ b/native/src/widget/radio.rs
@@ -1,6 +1,6 @@
 //! Create choices using radio buttons.
 use crate::input::{mouse, ButtonState};
-use crate::{Element, Event, Hasher, Layout, MouseCursor, Node, Point, Widget};
+use crate::{Element, Event, Hasher, Layout, Node, Point, Widget};
 
 use std::hash::Hash;
 
@@ -11,7 +11,7 @@ where
     Renderer: self::Renderer,
     Message: Copy + std::fmt::Debug,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         renderer.node(&self)
     }
 
@@ -40,7 +40,7 @@ where
         renderer: &mut Renderer,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor {
+    ) -> Renderer::Output {
         renderer.draw(&self, layout, cursor_position)
     }
 
@@ -56,12 +56,12 @@ where
 ///
 /// [`Radio`]: struct.Radio.html
 /// [renderer]: ../../renderer/index.html
-pub trait Renderer {
+pub trait Renderer: crate::Renderer {
     /// Creates a [`Node`] for the provided [`Radio`].
     ///
     /// [`Node`]: ../../struct.Node.html
     /// [`Radio`]: struct.Radio.html
-    fn node<Message>(&mut self, radio: &Radio<Message>) -> Node;
+    fn node<Message>(&self, radio: &Radio<Message>) -> Node;
 
     /// Draws a [`Radio`] button.
     ///
@@ -77,7 +77,7 @@ pub trait Renderer {
         radio: &Radio<Message>,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor;
+    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Radio<Message>>
diff --git a/native/src/widget/row.rs b/native/src/widget/row.rs
index 3cd451b7..5ec27159 100644
--- a/native/src/widget/row.rs
+++ b/native/src/widget/row.rs
@@ -1,8 +1,6 @@
 use std::hash::Hash;
 
-use crate::{
-    Element, Event, Hasher, Layout, MouseCursor, Node, Point, Style, Widget,
-};
+use crate::{Element, Event, Hasher, Layout, Node, Point, Style, Widget};
 
 /// A container that distributes its contents horizontally.
 pub type Row<'a, Message, Renderer> =
@@ -10,8 +8,10 @@ pub type Row<'a, Message, Renderer> =
 
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Row<'a, Message, Renderer>
+where
+    Renderer: self::Renderer,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         let mut children: Vec<Node> = self
             .children
             .iter()
@@ -70,21 +70,8 @@ impl<'a, Message, Renderer> Widget<Message, Renderer>
         renderer: &mut Renderer,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor {
-        let mut cursor = MouseCursor::OutOfBounds;
-
-        self.children.iter().zip(layout.children()).for_each(
-            |(child, layout)| {
-                let new_cursor =
-                    child.widget.draw(renderer, layout, cursor_position);
-
-                if new_cursor != MouseCursor::OutOfBounds {
-                    cursor = new_cursor;
-                }
-            },
-        );
-
-        cursor
+    ) -> Renderer::Output {
+        renderer.draw(&self, layout, cursor_position)
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -105,10 +92,19 @@ impl<'a, Message, Renderer> Widget<Message, Renderer>
     }
 }
 
+pub trait Renderer: crate::Renderer + Sized {
+    fn draw<Message>(
+        &mut self,
+        row: &Row<'_, Message, Self>,
+        layout: Layout<'_>,
+        cursor_position: Point,
+    ) -> Self::Output;
+}
+
 impl<'a, Message, Renderer> From<Row<'a, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
-    Renderer: 'a,
+    Renderer: 'a + self::Renderer,
     Message: 'static,
 {
     fn from(row: Row<'a, Message, Renderer>) -> Element<'a, Message, Renderer> {
diff --git a/native/src/widget/slider.rs b/native/src/widget/slider.rs
index 481296bd..d643d902 100644
--- a/native/src/widget/slider.rs
+++ b/native/src/widget/slider.rs
@@ -7,7 +7,7 @@
 use std::hash::Hash;
 
 use crate::input::{mouse, ButtonState};
-use crate::{Element, Event, Hasher, Layout, MouseCursor, Node, Point, Widget};
+use crate::{Element, Event, Hasher, Layout, Node, Point, Widget};
 
 pub use iced_core::slider::*;
 
@@ -15,7 +15,7 @@ impl<'a, Message, Renderer> Widget<Message, Renderer> for Slider<'a, Message>
 where
     Renderer: self::Renderer,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         renderer.node(&self)
     }
 
@@ -71,7 +71,7 @@ where
         renderer: &mut Renderer,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor {
+    ) -> Renderer::Output {
         renderer.draw(&self, layout, cursor_position)
     }
 
@@ -87,7 +87,7 @@ where
 ///
 /// [`Slider`]: struct.Slider.html
 /// [renderer]: ../../renderer/index.html
-pub trait Renderer {
+pub trait Renderer: crate::Renderer {
     /// Creates a [`Node`] for the provided [`Radio`].
     ///
     /// [`Node`]: ../../struct.Node.html
@@ -111,7 +111,7 @@ pub trait Renderer {
         slider: &Slider<'_, Message>,
         layout: Layout<'_>,
         cursor_position: Point,
-    ) -> MouseCursor;
+    ) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Slider<'a, Message>>
diff --git a/native/src/widget/text.rs b/native/src/widget/text.rs
index 5ca6ebf3..e389e1d9 100644
--- a/native/src/widget/text.rs
+++ b/native/src/widget/text.rs
@@ -1,5 +1,5 @@
 //! Write some text for your users to read.
-use crate::{Element, Hasher, Layout, MouseCursor, Node, Point, Widget};
+use crate::{Element, Hasher, Layout, Node, Point, Widget};
 
 use std::hash::Hash;
 
@@ -9,7 +9,7 @@ impl<Message, Renderer> Widget<Message, Renderer> for Text
 where
     Renderer: self::Renderer,
 {
-    fn node(&self, renderer: &mut Renderer) -> Node {
+    fn node(&self, renderer: &Renderer) -> Node {
         renderer.node(&self)
     }
 
@@ -18,10 +18,8 @@ where
         renderer: &mut Renderer,
         layout: Layout<'_>,
         _cursor_position: Point,
-    ) -> MouseCursor {
-        renderer.draw(&self, layout);
-
-        MouseCursor::OutOfBounds
+    ) -> Renderer::Output {
+        renderer.draw(&self, layout)
     }
 
     fn hash_layout(&self, state: &mut Hasher) {
@@ -40,7 +38,7 @@ where
 /// [`Text`]: struct.Text.html
 /// [renderer]: ../../renderer/index.html
 /// [`UserInterface`]: ../../struct.UserInterface.html
-pub trait Renderer {
+pub trait Renderer: crate::Renderer {
     /// Creates a [`Node`] with the given [`Style`] for the provided [`Text`]
     /// contents and size.
     ///
@@ -66,7 +64,7 @@ pub trait Renderer {
     /// [`Text`]: struct.Text.html
     /// [`HorizontalAlignment`]: enum.HorizontalAlignment.html
     /// [`VerticalAlignment`]: enum.VerticalAlignment.html
-    fn draw(&mut self, text: &Text, layout: Layout<'_>);
+    fn draw(&mut self, text: &Text, layout: Layout<'_>) -> Self::Output;
 }
 
 impl<'a, Message, Renderer> From<Text> for Element<'a, Message, Renderer>