Rearrange the Param methods

src/param.rs

@@ -30,6 +30,12 @@ pub trait Param: Display {
     /// Get the unit label for this parameter, if any.
     fn unit(&self) -> &'static str;
 
+    /// Get the unnormalized value for this parameter.
+    fn plain_value(&self) -> Self::Plain;
+
+    /// Get the normalized `[0, 1]` value for this parameter.
+    fn normalized_value(&self) -> f32;
+
     /// Get the number of steps for this paramter, if it is discrete. Used for the host's generic
     /// UI.
     fn step_count(&self) -> Option<usize>;
@@ -46,18 +52,12 @@ pub trait Param: Display {
     /// hundredth of the normalized range instead.
     fn next_step(&self, from: Self::Plain) -> Self::Plain;
 
-    /// Get the unnormalized value for this parameter.
-    fn plain_value(&self) -> Self::Plain;
-
     /// Set this parameter based on a plain, unnormalized value. This does **not** snap to step
     /// sizes for continuous parameters (i.e. [`FloatParam`]).
     ///
     /// This does **not** update the smoother.
     fn set_plain_value(&mut self, plain: Self::Plain);
 
-    /// Get the normalized `[0, 1]` value for this parameter.
-    fn normalized_value(&self) -> f32;
-
     /// Set this parameter based on a normalized value. This **does** snap to step sizes for
     /// continuous parameters (i.e. [`FloatParam`]).
     ///

src/param/boolean.rs

@@ -62,6 +62,14 @@ impl Param for BoolParam {
         ""
     }
 
+    fn plain_value(&self) -> Self::Plain {
+        self.value
+    }
+
+    fn normalized_value(&self) -> f32 {
+        self.preview_normalized(self.value)
+    }
+
     fn step_count(&self) -> Option<usize> {
         Some(1)
     }
@@ -74,10 +82,6 @@ impl Param for BoolParam {
         true
     }
 
-    fn plain_value(&self) -> Self::Plain {
-        self.value
-    }
-
     fn set_plain_value(&mut self, plain: Self::Plain) {
         self.value = plain;
         if let Some(f) = &self.value_changed {
@@ -85,10 +89,6 @@ impl Param for BoolParam {
         }
     }
 
-    fn normalized_value(&self) -> f32 {
-        self.preview_normalized(self.value)
-    }
-
     fn set_normalized_value(&mut self, normalized: f32) {
         self.set_plain_value(self.preview_plain(normalized));
     }

src/param/enums.rs

@@ -109,6 +109,14 @@ impl<T: Enum + PartialEq> Param for EnumParam<T> {
         self.inner.unit()
     }
 
+    fn plain_value(&self) -> Self::Plain {
+        T::from_index(self.inner.plain_value() as usize)
+    }
+
+    fn normalized_value(&self) -> f32 {
+        self.inner.normalized_value()
+    }
+
     fn step_count(&self) -> Option<usize> {
         self.inner.step_count()
     }
@@ -121,18 +129,10 @@ impl<T: Enum + PartialEq> Param for EnumParam<T> {
         T::from_index(self.inner.next_step(T::to_index(from) as i32) as usize)
     }
 
-    fn plain_value(&self) -> Self::Plain {
-        T::from_index(self.inner.plain_value() as usize)
-    }
-
     fn set_plain_value(&mut self, plain: Self::Plain) {
         self.inner.set_plain_value(T::to_index(plain) as i32)
     }
 
-    fn normalized_value(&self) -> f32 {
-        self.inner.normalized_value()
-    }
-
     fn set_normalized_value(&mut self, normalized: f32) {
         self.inner.set_normalized_value(normalized)
     }
@@ -178,6 +178,14 @@ impl Param for EnumParamInner {
         ""
     }
 
+    fn plain_value(&self) -> Self::Plain {
+        self.inner.plain_value()
+    }
+
+    fn normalized_value(&self) -> f32 {
+        self.inner.normalized_value()
+    }
+
     fn step_count(&self) -> Option<usize> {
         Some(self.len() - 1)
     }
@@ -190,18 +198,10 @@ impl Param for EnumParamInner {
         self.inner.next_step(from)
     }
 
-    fn plain_value(&self) -> Self::Plain {
-        self.inner.plain_value()
-    }
-
     fn set_plain_value(&mut self, plain: Self::Plain) {
         self.inner.set_plain_value(plain)
     }
 
-    fn normalized_value(&self) -> f32 {
-        self.inner.normalized_value()
-    }
-
     fn set_normalized_value(&mut self, normalized: f32) {
         self.inner.set_normalized_value(normalized)
     }

src/param/float.rs

@@ -103,6 +103,14 @@ impl Param for FloatParam {
         self.unit
     }
 
+    fn plain_value(&self) -> Self::Plain {
+        self.value
+    }
+
+    fn normalized_value(&self) -> f32 {
+        self.preview_normalized(self.value)
+    }
+
     fn step_count(&self) -> Option<usize> {
         None
     }
@@ -130,10 +138,6 @@ impl Param for FloatParam {
         .clamp(self.range.min(), self.range.max())
     }
 
-    fn plain_value(&self) -> Self::Plain {
-        self.value
-    }
-
     fn set_plain_value(&mut self, plain: Self::Plain) {
         self.value = plain;
         if let Some(f) = &self.value_changed {
@@ -141,10 +145,6 @@ impl Param for FloatParam {
         }
     }
 
-    fn normalized_value(&self) -> f32 {
-        self.preview_normalized(self.value)
-    }
-
     fn set_normalized_value(&mut self, normalized: f32) {
         self.set_plain_value(self.preview_plain(normalized));
     }

src/param/integer.rs

@@ -94,6 +94,14 @@ impl Param for IntParam {
         self.unit
     }
 
+    fn plain_value(&self) -> Self::Plain {
+        self.value
+    }
+
+    fn normalized_value(&self) -> f32 {
+        self.preview_normalized(self.value)
+    }
+
     fn step_count(&self) -> Option<usize> {
         Some(self.range.step_count())
     }
@@ -106,10 +114,6 @@ impl Param for IntParam {
         (from + 1).clamp(self.range.min(), self.range.max())
     }
 
-    fn plain_value(&self) -> Self::Plain {
-        self.value
-    }
-
     fn set_plain_value(&mut self, plain: Self::Plain) {
         self.value = plain;
         if let Some(f) = &self.value_changed {
@@ -117,10 +121,6 @@ impl Param for IntParam {
         }
     }
 
-    fn normalized_value(&self) -> f32 {
-        self.preview_normalized(self.value)
-    }
-
     fn set_normalized_value(&mut self, normalized: f32) {
         self.set_plain_value(self.preview_plain(normalized));
     }

src/param/internals.rs

@@ -146,12 +146,12 @@ macro_rules! param_ptr_forward(
 
 impl ParamPtr {
     param_ptr_forward!(pub unsafe fn name(&self) -> &'static str);
-    param_ptr_forward!(pub unsafe fn step_count(&self) -> Option<usize>);
     param_ptr_forward!(pub unsafe fn unit(&self) -> &'static str);
+    param_ptr_forward!(pub unsafe fn normalized_value(&self) -> f32);
+    param_ptr_forward!(pub unsafe fn step_count(&self) -> Option<usize>);
+    param_ptr_forward!(pub unsafe fn set_normalized_value(&self, normalized: f32));
     param_ptr_forward!(pub unsafe fn update_smoother(&self, sample_rate: f32, reset: bool));
     param_ptr_forward!(pub unsafe fn initialize_block_smoother(&mut self, max_block_size: usize));
-    param_ptr_forward!(pub unsafe fn normalized_value(&self) -> f32);
-    param_ptr_forward!(pub unsafe fn set_normalized_value(&self, normalized: f32));
     param_ptr_forward!(pub unsafe fn normalized_value_to_string(&self, normalized: f32, include_unit: bool) -> String);
     param_ptr_forward!(pub unsafe fn string_to_normalized_value(&self, string: &str) -> Option<f32>);