Use Radians as a number directly in gradient example

core/Cargo.toml

@@ -15,6 +15,7 @@ bitflags.workspace = true
 log.workspace = true
 thiserror.workspace = true
 twox-hash.workspace = true
+num-traits.workspace = true
 
 palette.workspace = true
 palette.optional = true

core/src/angle.rs

@@ -1,17 +1,56 @@
 use crate::{Point, Rectangle, Vector};
-use std::f32::consts::PI;
 
-#[derive(Debug, Copy, Clone, PartialEq)]
+use std::f32::consts::PI;
+use std::ops::RangeInclusive;
+
 /// Degrees
+#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
 pub struct Degrees(pub f32);
 
-#[derive(Debug, Copy, Clone, PartialEq)]
 /// Radians
+#[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
 pub struct Radians(pub f32);
 
+impl Radians {
+    /// The range of radians of a circle.
+    pub const RANGE: RangeInclusive<Radians> = Radians(0.0)..=Radians(2.0 * PI);
+}
+
 impl From<Degrees> for Radians {
     fn from(degrees: Degrees) -> Self {
-        Radians(degrees.0 * PI / 180.0)
+        Self(degrees.0 * PI / 180.0)
+    }
+}
+
+impl From<f32> for Radians {
+    fn from(radians: f32) -> Self {
+        Self(radians)
+    }
+}
+
+impl From<u8> for Radians {
+    fn from(radians: u8) -> Self {
+        Self(f32::from(radians))
+    }
+}
+
+impl From<Radians> for f64 {
+    fn from(radians: Radians) -> Self {
+        Self::from(radians.0)
+    }
+}
+
+impl num_traits::FromPrimitive for Radians {
+    fn from_i64(n: i64) -> Option<Self> {
+        Some(Self(n as f32))
+    }
+
+    fn from_u64(n: u64) -> Option<Self> {
+        Some(Self(n as f32))
+    }
+
+    fn from_f64(n: f64) -> Option<Self> {
+        Some(Self(n as f32))
     }
 }
 

examples/gradient/src/main.rs

@@ -12,14 +12,14 @@ pub fn main() -> iced::Result {
 struct Gradient {
     start: Color,
     end: Color,
-    angle: f32,
+    angle: Radians,
 }
 
 #[derive(Debug, Clone, Copy)]
 enum Message {
     StartChanged(Color),
     EndChanged(Color),
-    AngleChanged(f32),
+    AngleChanged(Radians),
 }
 
 impl Sandbox for Gradient {
@@ -29,7 +29,7 @@ impl Sandbox for Gradient {
         Self {
             start: Color::WHITE,
             end: Color::new(0.0, 0.0, 1.0, 1.0),
-            angle: 0.0,
+            angle: Radians(0.0),
         }
     }
 
@@ -52,12 +52,10 @@ impl Sandbox for Gradient {
             .width(Length::Fill)
             .height(Length::Fill)
             .style(move |_: &_| {
-                let gradient = gradient::Linear::new(Radians(
+                let gradient = gradient::Linear::new(angle)
-                    angle + std::f32::consts::PI,
+                    .add_stop(0.0, start)
-                ))
+                    .add_stop(1.0, end)
-                .add_stop(0.0, start)
+                    .into();
-                .add_stop(1.0, end)
-                .into();
 
                 container::Appearance {
                     background: Some(Background::Gradient(gradient)),
@@ -67,10 +65,8 @@ impl Sandbox for Gradient {
 
         let angle_picker = row![
             text("Angle").width(64),
-            slider(0.0..=std::f32::consts::PI * 2.0, self.angle, move |v| {
+            slider(Radians::RANGE, self.angle, Message::AngleChanged)
-                Message::AngleChanged(v)
+                .step(0.01)
-            })
-            .step(0.01)
         ]
         .spacing(8)
         .padding(8)

widget/src/slider.rs

@@ -137,8 +137,8 @@ where
     }
 
     /// Sets the step size of the [`Slider`].
-    pub fn step(mut self, step: T) -> Self {
+    pub fn step(mut self, step: impl Into<T>) -> Self {
-        self.step = step;
+        self.step = step.into();
         self
     }
 }