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

8 files changed, 159 insertions, 67 deletions

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