Struct EnumParamInner 

pub struct EnumParamInner { /* private fields */ }

The type-erased internals for EnumParam so that the wrapper can interact with it. Acts like an IntParam but with different conversions from strings to values.

Implementations

impl EnumParamInner

pub fn len(&self) -> usize

Get the number of variants for this enum.

pub fn unmodulated_plain_id(&self) -> Option<&'static str>

Get the stable ID for the parameter’s current value according to unmodulated_plain_value(). Returns None if this enum parameter doesn’t have any stable IDs.

pub fn set_from_id(&self, id: &str) -> bool

Set the parameter based on a serialized stable string identifier. Return whether the ID was known and the parameter was set.

Trait Implementations

impl Debug for EnumParamInner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for EnumParamInner

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl InternalParamMut for EnumParamInner

unsafe fn _internal_set_plain_value(&self, plain: Self::Plain) -> bool

Set this parameter based on a plain, unnormalized value. This does not snap to step sizes for continuous parameters (i.e. FloatParam). If modulate_value() has previously been called with a non zero value then this offset is taken into account to form the effective value.

unsafe fn _internal_set_normalized_value(&self, normalized: f32) -> bool

Set this parameter based on a normalized value. The normalized value will be snapped to the step size for continuous parameters (i.e. FloatParam). If modulate_value() has previously been called with a non zero value then this offset is taken into account to form the effective value.

unsafe fn _internal_modulate_value(&self, modulation_offset: f32) -> bool

Add a modulation offset to the value’s unmodulated value. This value sticks until this function is called again with a 0.0 value. Out of bound values will be clamped to the parameter’s range. The normalized value will be snapped to the step size for continuous parameters (i.e. FloatParam).

unsafe fn _internal_update_smoother(&self, sample_rate: f32, reset: bool)

Update the smoother state to point to the current value. Also used when initializing and restoring a plugin so everything is in sync. In that case the smoother should completely reset to the current value.

impl Param for EnumParamInner

type Plain = i32

The plain parameter type.

fn name(&self) -> &str

Get the human readable name for this parameter.

fn unit(&self) -> &'static str

Get the unit label for this parameter, if any.

fn poly_modulation_id(&self) -> Option<u32>

Get this parameter’s polyphonic modulation ID. If this is set for a parameter in a CLAP plugin, then polyphonic modulation will be enabled for that parameter. Polyphonic modulation is communicated to the plugin through NoteEvent::PolyModulation and NoteEvent::MonoAutomation events. See the documentation on those events for more information.

fn modulated_plain_value(&self) -> Self::Plain

Get the unnormalized value for this parameter.

fn modulated_normalized_value(&self) -> f32

Get the normalized [0, 1] value for this parameter.

fn default_plain_value(&self) -> Self::Plain

Get the unnormalized default value for this parameter.

fn unmodulated_plain_value(&self) -> Self::Plain

Get the unnormalized value for this parameter before any (monophonic) modulation coming from the host has been applied. If the host is not currently modulating this parameter than this will be the same as modulated_plain_value(). This may be useful for displaying modulation differently in plugin GUIs. Right now only CLAP plugins in Bitwig Studio use modulation.

fn unmodulated_normalized_value(&self) -> f32

Get the normalized [0, 1] value for this parameter before any (monophonic) modulation coming from the host has been applied. If the host is not currently modulating this parameter than this will be the same as modulated_normalized_value(). This may be useful for displaying modulation differently in plugin GUIs. Right now only CLAP plugins in Bitwig Studio use modulation.

fn step_count(&self) -> Option<usize>

Get the number of steps for this parameter, if it is discrete. Used for the host’s generic UI.

fn previous_step(&self, from: Self::Plain, finer: bool) -> Self::Plain

Returns the previous step from a specific value for this parameter. This can be the same as from if the value is at the start of its range. This is mainly used for scroll wheel interaction in plugin GUIs. When the parameter is not discrete then a step should cover one hundredth of the normalized range instead.

fn next_step(&self, from: Self::Plain, finer: bool) -> Self::Plain

Returns the next step from a specific value for this parameter. This can be the same as from if the value is at the end of its range. This is mainly used for scroll wheel interaction in plugin GUIs. When the parameter is not discrete then a step should cover one hundredth of the normalized range instead.

fn normalized_value_to_string( &self, normalized: f32, _include_unit: bool, ) -> String

Get the string representation for a normalized value. Used as part of the wrappers. Most plugin formats already have support for units, in which case it shouldn’t be part of this string or some DAWs may show duplicate units.

fn string_to_normalized_value(&self, string: &str) -> Option<f32>

Get the string representation for a normalized value. Used as part of the wrappers.

fn preview_normalized(&self, plain: Self::Plain) -> f32

Get the normalized value for a plain, unnormalized value, as a float. Used as part of the wrappers.

fn preview_plain(&self, normalized: f32) -> Self::Plain

Get the plain, unnormalized value for a normalized value, as a float. Used as part of the wrappers. This does snap to step sizes for continuous parameters (i.e. FloatParam).

fn flags(&self) -> ParamFlags

Flags to control the parameter’s behavior. See ParamFlags.

fn as_ptr(&self) -> ParamPtr

Internal implementation detail for implementing Params. This should not be used directly.

fn default_normalized_value(&self) -> f32

Get the normalized [0, 1] default value for this parameter.

fn previous_normalized_step(&self, from: f32, finer: bool) -> f32

The same as previous_step(), but for normalized values. This is mostly useful for GUI widgets.

fn next_normalized_step(&self, from: f32, finer: bool) -> f32

The same as next_step(), but for normalized values. This is mostly useful for GUI widgets.

fn preview_modulated(&self, normalized_offset: f32) -> Self::Plain

Get the plain, unnormalized value for this parameter after polyphonic modulation has been applied. This is a convenience method for calling preview_plain() with unmodulated_normalized_value() + normalized_offset.