Make `Slider` value type generic

2 files changed, 54 insertions, 25 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/widget/slider.rs b/native/src/widget/slider.rs
index 8670628c..94f743e8 100644
--- a/native/src/widget/slider.rs
+++ b/native/src/widget/slider.rs
@@ -24,7 +24,7 @@ use std::{hash::Hash, ops::RangeInclusive};
 /// ```
 /// # 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),
 /// }
@@ -37,18 +37,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>,
-    step: 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:
@@ -63,18 +67,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: 1.0,
+            step: T::from(1),
             on_change: Box::new(on_change),
             on_release: None,
             width: Length::Fill,
@@ -114,7 +130,7 @@ impl<'a, Message, Renderer: self::Renderer> Slider<'a, Message, Renderer> {
     /// Sets the step size of the [`Slider`].
     ///
     /// [`Slider`]: struct.Slider.html
-    pub fn step(mut self, step: f32) -> Self {
+    pub fn step(mut self, step: T) -> Self {
         self.step = step;
         self
     }
@@ -137,9 +153,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,
 {
@@ -181,12 +198,19 @@ where
             } 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 steps = (percent * (self.range.end() - self.range.start())
-                    / self.step)
-                    .round();
-                let value = steps * self.step + self.range.start();
-                messages.push((self.on_change)(value));
+                let step: f64 = self.step.into();
+                let start: f64 = (*self.range.start()).into();
+                let end: f64 = (*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;
+
+                if let Some(value) = T::from_f64(value) {
+                    messages.push((self.on_change)(value));
+                }
             }
         };
 
@@ -224,11 +248,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,
         )
@@ -281,14 +308,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)
     }