Merge branch 'master' into feature/pane-grid-titlebar

13 files changed, 212 insertions, 104 deletions

diff --git a/native/Cargo.toml b/native/Cargo.toml
index 75b4a56b..13052a93 100644
--- a/native/Cargo.toml
+++ b/native/Cargo.toml
@@ -13,6 +13,7 @@ debug = []
 [dependencies]
 twox-hash = "1.5"
 unicode-segmentation = "1.6"
+num-traits = "0.2"
 
 [dependencies.iced_core]
 version = "0.2"
diff --git a/native/src/debug/basic.rs b/native/src/debug/basic.rs
index 5338d0d9..8a712038 100644
--- a/native/src/debug/basic.rs
+++ b/native/src/debug/basic.rs
@@ -174,9 +174,13 @@ impl Debug {
         lines.push(key_value("Render:", self.render_durations.average()));
         lines.push(key_value("Message count:", self.message_count));
         lines.push(String::from("Last messages:"));
-        lines.extend(
-            self.last_messages.iter().map(|msg| format!("    {}", msg)),
-        );
+        lines.extend(self.last_messages.iter().map(|msg| {
+            if msg.len() <= 100 {
+                format!("    {}", msg)
+            } else {
+                format!("    {:.100}...", msg)
+            }
+        }));
 
         lines
     }
diff --git a/native/src/program/state.rs b/native/src/program/state.rs
index 8716d8b9..fdc42e8b 100644
--- a/native/src/program/state.rs
+++ b/native/src/program/state.rs
@@ -1,5 +1,5 @@
 use crate::{
-    Cache, Clipboard, Command, Debug, Event, Program, Renderer, Size,
+    Cache, Clipboard, Command, Debug, Event, Point, Program, Renderer, Size,
     UserInterface,
 };
 
@@ -31,6 +31,7 @@ where
     pub fn new(
         mut program: P,
         bounds: Size,
+        cursor_position: Point,
         renderer: &mut P::Renderer,
         debug: &mut Debug,
     ) -> Self {
@@ -43,7 +44,7 @@ where
         );
 
         debug.draw_started();
-        let primitive = user_interface.draw(renderer);
+        let primitive = user_interface.draw(renderer, cursor_position);
         debug.draw_finished();
 
         let cache = Some(user_interface.into_cache());
@@ -88,6 +89,13 @@ where
         self.queued_messages.push(message);
     }
 
+    /// Returns whether the event queue of the [`State`] is empty or not.
+    ///
+    /// [`State`]: struct.State.html
+    pub fn is_queue_empty(&self) -> bool {
+        self.queued_events.is_empty() && self.queued_messages.is_empty()
+    }
+
     /// Processes all the queued events and messages, rebuilding and redrawing
     /// the widgets of the linked [`Program`] if necessary.
     ///
@@ -97,15 +105,12 @@ where
     /// [`Program`]: trait.Program.html
     pub fn update(
         &mut self,
-        clipboard: Option<&dyn Clipboard>,
         bounds: Size,
+        cursor_position: Point,
+        clipboard: Option<&dyn Clipboard>,
         renderer: &mut P::Renderer,
         debug: &mut Debug,
     ) -> Option<Command<P::Message>> {
-        if self.queued_events.is_empty() && self.queued_messages.is_empty() {
-            return None;
-        }
-
         let mut user_interface = build_user_interface(
             &mut self.program,
             self.cache.take().unwrap(),
@@ -117,6 +122,7 @@ where
         debug.event_processing_started();
         let mut messages = user_interface.update(
             self.queued_events.drain(..),
+            cursor_position,
             clipboard,
             renderer,
         );
@@ -125,7 +131,7 @@ where
 
         if messages.is_empty() {
             debug.draw_started();
-            self.primitive = user_interface.draw(renderer);
+            self.primitive = user_interface.draw(renderer, cursor_position);
             debug.draw_finished();
 
             self.cache = Some(user_interface.into_cache());
@@ -156,7 +162,7 @@ where
             );
 
             debug.draw_started();
-            self.primitive = user_interface.draw(renderer);
+            self.primitive = user_interface.draw(renderer, cursor_position);
             debug.draw_finished();
 
             self.cache = Some(user_interface.into_cache());
diff --git a/native/src/renderer/null.rs b/native/src/renderer/null.rs
index d6a8e18f..580f58f8 100644
--- a/native/src/renderer/null.rs
+++ b/native/src/renderer/null.rs
@@ -50,7 +50,9 @@ impl row::Renderer for Null {
 impl text::Renderer for Null {
     type Font = Font;
 
-    const DEFAULT_SIZE: u16 = 20;
+    fn default_size(&self) -> u16 {
+        20
+    }
 
     fn measure(
         &self,
@@ -104,13 +106,8 @@ impl scrollable::Renderer for Null {
 }
 
 impl text_input::Renderer for Null {
-    type Font = Font;
     type Style = ();
 
-    fn default_size(&self) -> u16 {
-        20
-    }
-
     fn measure_value(&self, _value: &str, _size: u16, _font: Font) -> f32 {
         0.0
     }
diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs
index e963b601..b9646043 100644
--- a/native/src/user_interface.rs
+++ b/native/src/user_interface.rs
@@ -1,4 +1,4 @@
-use crate::{layout, mouse, Clipboard, Element, Event, Layout, Point, Size};
+use crate::{layout, Clipboard, Element, Event, Layout, Point, Size};
 
 use std::hash::Hasher;
 
@@ -23,7 +23,6 @@ pub struct UserInterface<'a, Message, Renderer> {
     root: Element<'a, Message, Renderer>,
     layout: layout::Node,
     bounds: Size,
-    cursor_position: Point,
 }
 
 impl<'a, Message, Renderer> UserInterface<'a, Message, Renderer>
@@ -115,7 +114,6 @@ where
             root,
             layout,
             bounds,
-            cursor_position: cache.cursor_position,
         }
     }
 
@@ -132,7 +130,7 @@ where
     /// completing [the previous example](#example):
     ///
     /// ```no_run
-    /// use iced_native::{UserInterface, Cache, Size};
+    /// use iced_native::{UserInterface, Cache, Size, Point};
     /// use iced_wgpu::Renderer;
     ///
     /// # mod iced_wgpu {
@@ -154,6 +152,7 @@ where
     /// let mut cache = Cache::new();
     /// let mut renderer = Renderer::new();
     /// let mut window_size = Size::new(1024.0, 768.0);
+    /// let mut cursor_position = Point::default();
     ///
     /// // Initialize our event storage
     /// let mut events = Vec::new();
@@ -169,7 +168,12 @@ where
     ///     );
     ///
     ///     // Update the user interface
-    ///     let messages = user_interface.update(events.drain(..), None, &renderer);
+    ///     let messages = user_interface.update(
+    ///         events.drain(..),
+    ///         cursor_position,
+    ///         None,
+    ///         &renderer,
+    ///     );
     ///
     ///     cache = user_interface.into_cache();
     ///
@@ -182,20 +186,17 @@ where
     pub fn update(
         &mut self,
         events: impl IntoIterator<Item = Event>,
+        cursor_position: Point,
         clipboard: Option<&dyn Clipboard>,
         renderer: &Renderer,
     ) -> Vec<Message> {
         let mut messages = Vec::new();
 
         for event in events {
-            if let Event::Mouse(mouse::Event::CursorMoved { x, y }) = event {
-                self.cursor_position = Point::new(x, y);
-            }
-
             self.root.widget.on_event(
                 event,
                 Layout::new(&self.layout),
-                self.cursor_position,
+                cursor_position,
                 &mut messages,
                 renderer,
                 clipboard,
@@ -219,7 +220,7 @@ where
     /// [completing the last example](#example-1):
     ///
     /// ```no_run
-    /// use iced_native::{UserInterface, Cache, Size};
+    /// use iced_native::{UserInterface, Cache, Size, Point};
     /// use iced_wgpu::Renderer;
     ///
     /// # mod iced_wgpu {
@@ -241,6 +242,7 @@ where
     /// let mut cache = Cache::new();
     /// let mut renderer = Renderer::new();
     /// let mut window_size = Size::new(1024.0, 768.0);
+    /// let mut cursor_position = Point::default();
     /// let mut events = Vec::new();
     ///
     /// loop {
@@ -253,10 +255,15 @@ where
     ///         &mut renderer,
     ///     );
     ///
-    ///     let messages = user_interface.update(events.drain(..), None, &renderer);
+    ///     let messages = user_interface.update(
+    ///         events.drain(..),
+    ///         cursor_position,
+    ///         None,
+    ///         &renderer,
+    ///     );
     ///
     ///     // Draw the user interface
-    ///     let mouse_cursor = user_interface.draw(&mut renderer);
+    ///     let mouse_cursor = user_interface.draw(&mut renderer, cursor_position);
     ///
     ///     cache = user_interface.into_cache();
     ///
@@ -268,12 +275,16 @@ where
     ///     // Flush rendering operations...
     /// }
     /// ```
-    pub fn draw(&self, renderer: &mut Renderer) -> Renderer::Output {
+    pub fn draw(
+        &self,
+        renderer: &mut Renderer,
+        cursor_position: Point,
+    ) -> Renderer::Output {
         self.root.widget.draw(
             renderer,
             &Renderer::Defaults::default(),
             Layout::new(&self.layout),
-            self.cursor_position,
+            cursor_position,
         )
     }
 
@@ -287,7 +298,6 @@ where
             hash: self.hash,
             layout: self.layout,
             bounds: self.bounds,
-            cursor_position: self.cursor_position,
         }
     }
 }
@@ -300,7 +310,6 @@ pub struct Cache {
     hash: u64,
     layout: layout::Node,
     bounds: Size,
-    cursor_position: Point,
 }
 
 impl Cache {
@@ -316,7 +325,6 @@ impl Cache {
             hash: 0,
             layout: layout::Node::new(Size::new(0.0, 0.0)),
             bounds: Size::ZERO,
-            cursor_position: Point::new(-1.0, -1.0),
         }
     }
 }
@@ -329,7 +337,7 @@ impl Default for Cache {
 
 impl PartialEq for Cache {
     fn eq(&self, other: &Cache) -> bool {
-        self.hash == other.hash && self.cursor_position == other.cursor_position
+        self.hash == other.hash
     }
 }
 
diff --git a/native/src/widget/checkbox.rs b/native/src/widget/checkbox.rs
index 5fb13290..44962288 100644
--- a/native/src/widget/checkbox.rs
+++ b/native/src/widget/checkbox.rs
@@ -32,7 +32,7 @@ pub struct Checkbox<Message, Renderer: self::Renderer + text::Renderer> {
     width: Length,
     size: u16,
     spacing: u16,
-    text_size: u16,
+    text_size: Option<u16>,
     style: Renderer::Style,
 }
 
@@ -60,7 +60,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
             width: Length::Shrink,
             size: <Renderer as self::Renderer>::DEFAULT_SIZE,
             spacing: Renderer::DEFAULT_SPACING,
-            text_size: <Renderer as text::Renderer>::DEFAULT_SIZE,
+            text_size: None,
             style: Renderer::Style::default(),
         }
     }
@@ -93,7 +93,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
     ///
     /// [`Checkbox`]: struct.Checkbox.html
     pub fn text_size(mut self, text_size: u16) -> Self {
-        self.text_size = text_size;
+        self.text_size = Some(text_size);
         self
     }
 
@@ -136,7 +136,7 @@ where
             .push(
                 Text::new(&self.label)
                     .width(self.width)
-                    .size(self.text_size),
+                    .size(self.text_size.unwrap_or(renderer.default_size())),
             )
             .layout(renderer, limits)
     }
@@ -181,7 +181,7 @@ where
             defaults,
             label_layout.bounds(),
             &self.label,
-            self.text_size,
+            self.text_size.unwrap_or(renderer.default_size()),
             Default::default(),
             None,
             HorizontalAlignment::Left,
diff --git a/native/src/widget/pane_grid.rs b/native/src/widget/pane_grid.rs
index a3282ed7..21788e6a 100644
--- a/native/src/widget/pane_grid.rs
+++ b/native/src/widget/pane_grid.rs
@@ -216,6 +216,10 @@ where
     /// The `leeway` describes the amount of space around a split that can be
     /// used to grab it.
     ///
+    /// The grabbable area of a split will have a length of `spacing + leeway`,
+    /// properly centered. In other words, a length of
+    /// `(spacing + leeway) / 2.0` on either side of the split line.
+    ///
     /// [`PaneGrid`]: struct.PaneGrid.html
     pub fn on_resize<F>(mut self, leeway: u16, f: F) -> Self
     where
@@ -284,8 +288,6 @@ where
                     self.state.focus(pane);
                 }
             }
-        } else {
-            self.state.unfocus();
         }
     }
 
@@ -299,7 +301,7 @@ where
             if let Some((split, _)) = self.state.picked_split() {
                 let bounds = layout.bounds();
 
-                let splits = self.state.splits(
+                let splits = self.state.split_regions(
                     f32::from(self.spacing),
                     Size::new(bounds.width, bounds.height),
                 );
@@ -421,7 +423,7 @@ where
         let limits = limits.width(self.width).height(self.height);
         let size = limits.resolve(Size::ZERO);
 
-        let regions = self.state.regions(f32::from(self.spacing), size);
+        let regions = self.state.pane_regions(f32::from(self.spacing), size);
 
         let children = self
             .elements
@@ -464,7 +466,7 @@ where
                                     cursor_position.y - bounds.y,
                                 );
 
-                                let splits = self.state.splits(
+                                let splits = self.state.split_regions(
                                     f32::from(self.spacing),
                                     Size::new(bounds.width, bounds.height),
                                 );
@@ -493,6 +495,8 @@ where
                                 );
                             }
                         }
+                    } else {
+                        self.state.unfocus();
                     }
                 }
                 mouse::Event::ButtonReleased(mouse::Button::Left) => {
@@ -550,10 +554,8 @@ where
                                 }
                             }
                         }
-
-                        *self.pressed_modifiers = modifiers;
                     }
-                    keyboard::Event::KeyReleased { modifiers, .. } => {
+                    keyboard::Event::ModifiersChanged(modifiers) => {
                         *self.pressed_modifiers = modifiers;
                     }
                     _ => {}
@@ -601,7 +603,7 @@ where
 
                     let splits = self
                         .state
-                        .splits(f32::from(self.spacing), bounds.size());
+                        .split_regions(f32::from(self.spacing), bounds.size());
 
                     hovered_split(
                         splits.iter(),
diff --git a/native/src/widget/pane_grid/node.rs b/native/src/widget/pane_grid/node.rs
index b13c5e26..cbfd8a43 100644
--- a/native/src/widget/pane_grid/node.rs
+++ b/native/src/widget/pane_grid/node.rs
@@ -43,12 +43,36 @@ pub enum Node {
 }
 
 impl Node {
+    /// Returns an iterator over each [`Split`] in this [`Node`].
+    ///
+    /// [`Split`]: struct.Split.html
+    /// [`Node`]: enum.Node.html
+    pub fn splits(&self) -> impl Iterator<Item = &Split> {
+        let mut unvisited_nodes = vec![self];
+
+        std::iter::from_fn(move || {
+            while let Some(node) = unvisited_nodes.pop() {
+                match node {
+                    Node::Split { id, a, b, .. } => {
+                        unvisited_nodes.push(a);
+                        unvisited_nodes.push(b);
+
+                        return Some(id);
+                    }
+                    _ => {}
+                }
+            }
+
+            None
+        })
+    }
+
     /// Returns the rectangular region for each [`Pane`] in the [`Node`] given
     /// the spacing between panes and the total available space.
     ///
     /// [`Pane`]: struct.Pane.html
     /// [`Node`]: enum.Node.html
-    pub fn regions(
+    pub fn pane_regions(
         &self,
         spacing: f32,
         size: Size,
@@ -75,7 +99,7 @@ impl Node {
     ///
     /// [`Split`]: struct.Split.html
     /// [`Node`]: enum.Node.html
-    pub fn splits(
+    pub fn split_regions(
         &self,
         spacing: f32,
         size: Size,
diff --git a/native/src/widget/pane_grid/state.rs b/native/src/widget/pane_grid/state.rs
index a8431dec..3f0accc1 100644
--- a/native/src/widget/pane_grid/state.rs
+++ b/native/src/widget/pane_grid/state.rs
@@ -157,8 +157,10 @@ impl<T> State<T> {
     /// [`Pane`]: struct.Pane.html
     /// [`State::active`]: struct.State.html#method.active
     pub fn adjacent(&self, pane: &Pane, direction: Direction) -> Option<Pane> {
-        let regions =
-            self.internal.layout.regions(0.0, Size::new(4096.0, 4096.0));
+        let regions = self
+            .internal
+            .layout
+            .pane_regions(0.0, Size::new(4096.0, 4096.0));
 
         let current_region = regions.get(pane)?;
 
@@ -194,6 +196,13 @@ impl<T> State<T> {
         self.internal.focus(pane);
     }
 
+    /// Unfocuses the current focused [`Pane`].
+    ///
+    /// [`Pane`]: struct.Pane.html
+    pub fn unfocus(&mut self) {
+        self.internal.unfocus();
+    }
+
     /// Splits the given [`Pane`] into two in the given [`Axis`] and
     /// initializing the new [`Pane`] with the provided internal state.
     ///
@@ -366,20 +375,20 @@ impl Internal {
         }
     }
 
-    pub fn regions(
+    pub fn pane_regions(
         &self,
         spacing: f32,
         size: Size,
     ) -> HashMap<Pane, Rectangle> {
-        self.layout.regions(spacing, size)
+        self.layout.pane_regions(spacing, size)
     }
 
-    pub fn splits(
+    pub fn split_regions(
         &self,
         spacing: f32,
         size: Size,
     ) -> HashMap<Split, (Axis, Rectangle, f32)> {
-        self.layout.splits(spacing, size)
+        self.layout.split_regions(spacing, size)
     }
 
     pub fn focus(&mut self, pane: &Pane) {
diff --git a/native/src/widget/radio.rs b/native/src/widget/radio.rs
index d07a9012..5b8d00e9 100644
--- a/native/src/widget/radio.rs
+++ b/native/src/widget/radio.rs
@@ -41,7 +41,7 @@ pub struct Radio<Message, Renderer: self::Renderer + text::Renderer> {
     width: Length,
     size: u16,
     spacing: u16,
-    text_size: u16,
+    text_size: Option<u16>,
     style: Renderer::Style,
 }
 
@@ -75,7 +75,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
             width: Length::Shrink,
             size: <Renderer as self::Renderer>::DEFAULT_SIZE,
             spacing: Renderer::DEFAULT_SPACING, //15
-            text_size: <Renderer as text::Renderer>::DEFAULT_SIZE,
+            text_size: None,
             style: Renderer::Style::default(),
         }
     }
@@ -108,7 +108,7 @@ impl<Message, Renderer: self::Renderer + text::Renderer>
     ///
     /// [`Radio`]: struct.Radio.html
     pub fn text_size(mut self, text_size: u16) -> Self {
-        self.text_size = text_size;
+        self.text_size = Some(text_size);
         self
     }
 
@@ -151,7 +151,7 @@ where
             .push(
                 Text::new(&self.label)
                     .width(self.width)
-                    .size(self.text_size),
+                    .size(self.text_size.unwrap_or(renderer.default_size())),
             )
             .layout(renderer, limits)
     }
@@ -194,7 +194,7 @@ where
             defaults,
             label_layout.bounds(),
             &self.label,
-            self.text_size,
+            self.text_size.unwrap_or(renderer.default_size()),
             Default::default(),
             None,
             HorizontalAlignment::Left,
diff --git a/native/src/widget/slider.rs b/native/src/widget/slider.rs
index 753a49fe..70f2b6ac 100644
--- a/native/src/widget/slider.rs
+++ b/native/src/widget/slider.rs
@@ -16,13 +16,16 @@ use std::{hash::Hash, ops::RangeInclusive};
 ///
 /// A [`Slider`] will try to fill the horizontal space of its container.
 ///
+/// The [`Slider`] range of numeric values is generic and its step size defaults
+/// to 1 unit.
+///
 /// [`Slider`]: struct.Slider.html
 ///
 /// # Example
 /// ```
 /// # use iced_native::{slider, renderer::Null};
 /// #
-/// # pub type Slider<'a, Message> = iced_native::Slider<'a, Message, Null>;
+/// # pub type Slider<'a, T, Message> = iced_native::Slider<'a, T, Message, Null>;
 /// pub enum Message {
 ///     SliderChanged(f32),
 /// }
@@ -35,17 +38,22 @@ use std::{hash::Hash, ops::RangeInclusive};
 ///
 /// ![Slider drawn by Coffee's renderer](https://github.com/hecrj/coffee/blob/bda9818f823dfcb8a7ad0ff4940b4d4b387b5208/images/ui/slider.png?raw=true)
 #[allow(missing_debug_implementations)]
-pub struct Slider<'a, Message, Renderer: self::Renderer> {
+pub struct Slider<'a, T, Message, Renderer: self::Renderer> {
     state: &'a mut State,
-    range: RangeInclusive<f32>,
-    value: f32,
-    on_change: Box<dyn Fn(f32) -> Message>,
+    range: RangeInclusive<T>,
+    step: T,
+    value: T,
+    on_change: Box<dyn Fn(T) -> Message>,
     on_release: Option<Message>,
     width: Length,
     style: Renderer::Style,
 }
 
-impl<'a, Message, Renderer: self::Renderer> Slider<'a, Message, Renderer> {
+impl<'a, T, Message, Renderer> Slider<'a, T, Message, Renderer>
+where
+    T: Copy + From<u8> + std::cmp::PartialOrd,
+    Renderer: self::Renderer,
+{
     /// Creates a new [`Slider`].
     ///
     /// It expects:
@@ -60,17 +68,30 @@ impl<'a, Message, Renderer: self::Renderer> Slider<'a, Message, Renderer> {
     /// [`State`]: struct.State.html
     pub fn new<F>(
         state: &'a mut State,
-        range: RangeInclusive<f32>,
-        value: f32,
+        range: RangeInclusive<T>,
+        value: T,
         on_change: F,
     ) -> Self
     where
-        F: 'static + Fn(f32) -> Message,
+        F: 'static + Fn(T) -> Message,
     {
+        let value = if value >= *range.start() {
+            value
+        } else {
+            *range.start()
+        };
+
+        let value = if value <= *range.end() {
+            value
+        } else {
+            *range.end()
+        };
+
         Slider {
             state,
-            value: value.max(*range.start()).min(*range.end()),
+            value,
             range,
+            step: T::from(1),
             on_change: Box::new(on_change),
             on_release: None,
             width: Length::Fill,
@@ -106,6 +127,14 @@ impl<'a, Message, Renderer: self::Renderer> Slider<'a, Message, Renderer> {
         self.style = style.into();
         self
     }
+
+    /// Sets the step size of the [`Slider`].
+    ///
+    /// [`Slider`]: struct.Slider.html
+    pub fn step(mut self, step: T) -> Self {
+        self.step = step;
+        self
+    }
 }
 
 /// The local state of a [`Slider`].
@@ -125,9 +154,10 @@ impl State {
     }
 }
 
-impl<'a, Message, Renderer> Widget<Message, Renderer>
-    for Slider<'a, Message, Renderer>
+impl<'a, T, Message, Renderer> Widget<Message, Renderer>
+    for Slider<'a, T, Message, Renderer>
 where
+    T: Copy + Into<f64> + num_traits::FromPrimitive,
     Renderer: self::Renderer,
     Message: Clone,
 {
@@ -164,17 +194,24 @@ where
     ) {
         let mut change = || {
             let bounds = layout.bounds();
-
             if cursor_position.x <= bounds.x {
                 messages.push((self.on_change)(*self.range.start()));
             } else if cursor_position.x >= bounds.x + bounds.width {
                 messages.push((self.on_change)(*self.range.end()));
             } else {
-                let percent = (cursor_position.x - bounds.x) / bounds.width;
-                let value = (self.range.end() - self.range.start()) * percent
-                    + self.range.start();
+                let step = self.step.into();
+                let start = (*self.range.start()).into();
+                let end = (*self.range.end()).into();
+
+                let percent = f64::from(cursor_position.x - bounds.x)
+                    / f64::from(bounds.width);
+
+                let steps = (percent * (end - start) / step).round();
+                let value = steps * step + start;
 
-                messages.push((self.on_change)(value));
+                if let Some(value) = T::from_f64(value) {
+                    messages.push((self.on_change)(value));
+                }
             }
         };
 
@@ -212,11 +249,14 @@ where
         layout: Layout<'_>,
         cursor_position: Point,
     ) -> Renderer::Output {
+        let start = *self.range.start();
+        let end = *self.range.end();
+
         renderer.draw(
             layout.bounds(),
             cursor_position,
-            self.range.clone(),
-            self.value,
+            start.into() as f32..=end.into() as f32,
+            self.value.into() as f32,
             self.state.is_dragging,
             &self.style,
         )
@@ -269,14 +309,15 @@ pub trait Renderer: crate::Renderer {
     ) -> Self::Output;
 }
 
-impl<'a, Message, Renderer> From<Slider<'a, Message, Renderer>>
+impl<'a, T, Message, Renderer> From<Slider<'a, T, Message, Renderer>>
     for Element<'a, Message, Renderer>
 where
+    T: 'a + Copy + Into<f64> + num_traits::FromPrimitive,
     Renderer: 'a + self::Renderer,
     Message: 'a + Clone,
 {
     fn from(
-        slider: Slider<'a, Message, Renderer>,
+        slider: Slider<'a, T, Message, Renderer>,
     ) -> Element<'a, Message, Renderer> {
         Element::new(slider)
     }
diff --git a/native/src/widget/text.rs b/native/src/widget/text.rs
index 0b05b67d..48a69e34 100644
--- a/native/src/widget/text.rs
+++ b/native/src/widget/text.rs
@@ -131,7 +131,7 @@ where
     ) -> layout::Node {
         let limits = limits.width(self.width).height(self.height);
 
-        let size = self.size.unwrap_or(Renderer::DEFAULT_SIZE);
+        let size = self.size.unwrap_or(renderer.default_size());
 
         let bounds = limits.max();
 
@@ -154,7 +154,7 @@ where
             defaults,
             layout.bounds(),
             &self.content,
-            self.size.unwrap_or(Renderer::DEFAULT_SIZE),
+            self.size.unwrap_or(renderer.default_size()),
             self.font,
             self.color,
             self.horizontal_alignment,
@@ -187,10 +187,10 @@ pub trait Renderer: crate::Renderer {
     /// [`Text`]: struct.Text.html
     type Font: Default + Copy;
 
-    /// The default size of [`Text`].
+    /// Returns the default size of [`Text`].
     ///
     /// [`Text`]: struct.Text.html
-    const DEFAULT_SIZE: u16;
+    fn default_size(&self) -> u16;
 
     /// Measures the [`Text`] in the given bounds and returns the minimum
     /// boundaries that can fit the contents.
diff --git a/native/src/widget/text_input.rs b/native/src/widget/text_input.rs
index e3a5355b..3f415101 100644
--- a/native/src/widget/text_input.rs
+++ b/native/src/widget/text_input.rs
@@ -17,8 +17,8 @@ use editor::Editor;
 use crate::{
     keyboard, layout,
     mouse::{self, click},
-    Clipboard, Element, Event, Hasher, Layout, Length, Point, Rectangle, Size,
-    Widget,
+    text, Clipboard, Element, Event, Hasher, Layout, Length, Point, Rectangle,
+    Size, Widget,
 };
 
 use std::u32;
@@ -486,7 +486,8 @@ where
         let text_bounds = layout.children().next().unwrap().bounds();
 
         if self.is_secure {
-            renderer.draw(
+            self::Renderer::draw(
+                renderer,
                 bounds,
                 text_bounds,
                 cursor_position,
@@ -498,7 +499,8 @@ where
                 &self.style,
             )
         } else {
-            renderer.draw(
+            self::Renderer::draw(
+                renderer,
                 bounds,
                 text_bounds,
                 cursor_position,
@@ -531,20 +533,10 @@ where
 ///
 /// [`TextInput`]: struct.TextInput.html
 /// [renderer]: ../../renderer/index.html
-pub trait Renderer: crate::Renderer + Sized {
-    /// The font type used for [`TextInput`].
-    ///
-    /// [`TextInput`]: struct.TextInput.html
-    type Font: Default + Copy;
-
+pub trait Renderer: text::Renderer + Sized {
     /// The style supported by this renderer.
     type Style: Default;
 
-    /// Returns the default size of the text of the [`TextInput`].
-    ///
-    /// [`TextInput`]: struct.TextInput.html
-    fn default_size(&self) -> u16;
-
     /// Returns the width of the value of the [`TextInput`].
     ///
     /// [`TextInput`]: struct.TextInput.html
@@ -683,6 +675,30 @@ impl State {
     pub fn cursor(&self) -> Cursor {
         self.cursor
     }
+
+    /// Moves the [`Cursor`] of the [`TextInput`] to the front of the input text.
+    ///
+    /// [`Cursor`]: struct.Cursor.html
+    /// [`TextInput`]: struct.TextInput.html
+    pub fn move_cursor_to_front(&mut self) {
+        self.cursor.move_to(0);
+    }
+
+    /// Moves the [`Cursor`] of the [`TextInput`] to the end of the input text.
+    ///
+    /// [`Cursor`]: struct.Cursor.html
+    /// [`TextInput`]: struct.TextInput.html
+    pub fn move_cursor_to_end(&mut self) {
+        self.cursor.move_to(usize::MAX);
+    }
+
+    /// Moves the [`Cursor`] of the [`TextInput`] to an arbitrary location.
+    ///
+    /// [`Cursor`]: struct.Cursor.html
+    /// [`TextInput`]: struct.TextInput.html
+    pub fn move_cursor_to(&mut self, position: usize) {
+        self.cursor.move_to(position);
+    }
 }
 
 // TODO: Reduce allocations