widget: slider: Add stepping functionality

A new builder method `with_step(f64)` is added to set the stepping value.

Signed-off-by: Christopher N. Hesse <[email protected]>

AUTHORS

@@ -16,3 +16,4 @@ Robert Wittams
 Jaap Aarts
 Maximilian Köstler
 Bruno Dupuis
+Christopher Noel Hesse

CHANGELOG.md

@@ -51,6 +51,7 @@ You can find its changes [documented below](#070---2021-01-01).
 - Linux extension: primary_clipboard ([#1843] by [@Maan2003])
 - x11: Implement primary_clipboard ([#1867] by [@psychon])
 - x11: Set WM_CLASS property ([#1868] by [@psychon])
+- Widget/Slider: Add stepping functionality ([#1875] by [@raymanfx])
 
 ### Changed
 

druid/src/widget/slider.rs

@@ -31,6 +31,7 @@ const KNOB_STROKE_WIDTH: f64 = 2.0;
 pub struct Slider {
     min: f64,
     max: f64,
+    step: Option<f64>,
     knob_pos: Point,
     knob_hovered: bool,
     x_offset: f64,
@@ -42,6 +43,7 @@ impl Slider {
         Slider {
             min: 0.,
             max: 1.,
+            step: None,
             knob_pos: Default::default(),
             knob_hovered: Default::default(),
             x_offset: Default::default(),
@@ -56,6 +58,24 @@ impl Slider {
         self.max = max;
         self
     }
+
+    /// Builder-style method to set the stepping.
+    ///
+    /// The default step size is `0.0` (smooth).
+    pub fn with_step(mut self, step: f64) -> Self {
+        if step < 0.0 {
+            tracing::warn!("Bad slider step: {}", step);
+            return self;
+        }
+        self.step = if step == 0.0 {
+            // A stepping value of 0.0 would yield an infinite amount of steps.
+            // Enforce a single step instead.
+            Some(self.max)
+        } else {
+            Some(step)
+        };
+        self
+    }
 }
 
 impl Slider {
@@ -68,7 +88,13 @@ impl Slider {
         let scalar = ((mouse_x + self.x_offset - knob_width / 2.) / (slider_width - knob_width))
             .max(0.0)
             .min(1.0);
-        self.min + scalar * (self.max - self.min)
+        let mut value = self.min + scalar * (self.max - self.min);
+        if let Some(stepping) = self.step {
+            let steps = (self.max / stepping).round();
+            let step = (value * steps).round();
+            value = step / steps;
+        }
+        value
     }
 
     fn normalize(&self, data: f64) -> f64 {