pub fn step_size(&self) -> Option<f64> {
        let result = self.step_sizes()?;
        use GetParameterStepSizesResult::*;
        match result {
            Normal {
                normal_step,
                small_step,
                ..
            } => {
                // The reported step sizes relate to the reported value range, which is not always
                // the unit interval! Easy to test with JS FX.
                let range = self.value_range();
                // We are primarily interested in the smallest step size that makes sense. We can
                // always create multiples of it.
                let span = (range.max_val - range.min_val).abs();
                if span == 0.0 {
                    return None;
                }
                let pref_step_size = small_step.unwrap_or(normal_step);
                Some(pref_step_size / span)
            }
            Toggle => Some(1.0),
        }
    }
// Returns a normalized value
// Returns None if no step size (continuous character)
// TODO-low This is a too opinionated function in that it already interprets and processes some
// of REAPER's return  values.
Returns a normalized value
Returns None if no step size (continuous character)
TODO-low This is a too opinionated function in that it already interprets and processes some
of REAPER's return  values.
Returns a normalized value Returns None if no step size ( continuous character ) TODO - low This is a too opinionated function in that it already interprets and processes some of REAPER ' s return values .
pub fn step_size(&self) -> Option<f64> {
        let result = self.step_sizes()?;
        use GetParameterStepSizesResult::*;
        match result {
            Normal {
                normal_step,
                small_step,
                ..
            } => {
                // The reported step sizes relate to the reported value range, which is not always
                // the unit interval! Easy to test with JS FX.
                let range = self.value_range();
                // We are primarily interested in the smallest step size that makes sense. We can
                // always create multiples of it.
                let span = (range.max_val - range.min_val).abs();
                if span == 0.0 {
                    return None;
                }
                let pref_step_size = small_step.unwrap_or(normal_step);
                Some(pref_step_size / span)
            }
            Toggle => Some(1.0),
        }
    }
pub fn step_size ( & self ) -> Option < f64 > { let result = self . step_sizes ( ) ? ; use GetParameterStepSizesResult :: * ; match result { Normal { normal_step , small_step , .. } => { // The reported step sizes relate to the reported value range, which is not always // the unit interval! Easy to test with JS FX. let range = self . value_range ( ) ; // We are primarily interested in the smallest step size that makes sense. We can // always create multiples of it. let span = ( range . max_val - range . min_val ) . abs ( ) ; if span == 0.0 { return None ; } let pref_step_size = small_step . unwrap_or ( normal_step ) ; Some ( pref_step_size / span ) } Toggle => Some ( 1.0 ) , } }
Returns a normalized value
Returns None if no step size (continuous character)
TODO-low This is a too opinionated function in that it already interprets and processes some
of REAPER's return  values.
Returns a normalized value Returns None if no step size ( continuous character ) TODO - low This is a too opinionated function in that it already interprets and processes some of REAPER ' s return values .
&self
&self