Struct NoteExpressionEvent 

pub struct NoteExpressionEvent { /* private fields */ }

A note expression event.

Note Expressions are well named modifications of a voice targeted to voices using Pckns. Note Expressions are delivered as sample accurate events and should be applied at the sample when received.

Note expressions are a statement of value, not cumulative. A Pan event of 0 followed by 1 followed by 0.5 would pan hard left, hard right, and center. They are intended as an offset from the non-note-expression voice default. A voice which had a volume of -20dB absent note expressions which received a +4dB note expression would move the voice to -16dB.

A plugin which receives a note expression at the same sample as a NoteOnEvent should apply that expression to all generated samples. A plugin which receives a note expression after a NoteOnEvent event should initiate the voice with default values and then apply the note expression when received. A plugin may make a choice to smooth note expression streams.

Implementations

impl NoteExpressionEvent

pub const fn new( time: u32, pckn: Pckn, expression_type: NoteExpressionType, value: f64, ) -> NoteExpressionEvent

Creates a new NoteExpressionEvent from a time stamp, a Pckn target, an NoteExpressionType and a raw value.

pub const fn expression_type(&self) -> Option<NoteExpressionType>

Returns the NoteExpressionType of this event.

This returns None if the expression type is not supported.

pub const fn set_expression_type(&mut self, expression_type: NoteExpressionType)

Sets the NoteExpressionType of this event.

pub const fn with_expression_type( self, expression_type: NoteExpressionType, ) -> NoteExpressionEvent

Builds a NoteExpressionEvent with the given NoteExpressionType, and returns it.

This is useful to use in a builder-style pattern.

pub const fn value(&self) -> f64

Returns the raw expression value of this event.

pub const fn set_value(&mut self, value: f64)

Sets the raw expression value of this event.

pub const fn with_value(self, value: f64) -> NoteExpressionEvent

Builds a NoteExpressionEvent with the given raw expression value, and returns it.

This is useful to use in a builder-style pattern.

pub const fn as_raw(&self) -> &clap_event_note_expression

Returns a shared reference to the underlying raw, C-FFI compatible event struct.

pub const unsafe fn as_raw_mut(&mut self) -> &mut clap_event_note_expression

Returns an exclusive, mutable reference to the raw, C-FFI compatible event struct.

Safety

This method allows mutating the event header’s fields, most notably type_, size and space_id.

Modifying those fields may trigger Undefined Behavior, as it can make other readers of this event treat it as a type or size that it is actually not.

pub const fn from_raw(raw: &clap_event_note_expression) -> NoteExpressionEvent

Creates a new event of this type from a reference to a raw, C-FFI compatible event struct.

Panics

This method will panic if the given event struct’s header doesn’t actually match the expected event type.

pub const fn from_raw_ref( raw: &clap_event_note_expression, ) -> &NoteExpressionEvent

Creates a reference to an event of this type from a reference to a raw, C-FFI compatible event struct.

Panics

This method will panic if the given event struct’s header doesn’t actually match the expected event type.

pub const fn from_raw_mut( raw: &mut clap_event_note_expression, ) -> &mut NoteExpressionEvent

Creates a mutable reference to a note event of this type from a reference to a raw, C-FFI compatible event struct.

Panics

This method will panic if the given event struct’s header doesn’t actually match the expected note event type.

pub const fn pckn(&self) -> Pckn

The Pckn tuple indicating which note(s) this note event targets.

pub const fn set_pckn(&mut self, pckn: Pckn)

Sets the Pckn tuple for this event.

pub const fn with_pckn(self, pckn: Pckn) -> NoteExpressionEvent

Sets the Pckn tuple for this event.

This method takes and returns ownership of the event, allowing it to be used in a builder-style pattern.

pub const fn port_index(&self) -> Match<u16>

The index of the note port this event targets.

This returns Match::All if this event targets all possible note ports.

pub const fn set_port_index(&mut self, port_index: Match<u16>)

Sets the index of the note port this event targets.

Use Match::All to target all possible note ports.

pub const fn with_port_index( self, port_index: Match<u16>, ) -> NoteExpressionEvent

Sets the index of the note port this event targets.

Use Match::All to target all possible note ports.

This method takes and returns ownership of the event, allowing it to be used in a builder-style pattern.

pub const fn channel(&self) -> Match<u16>

The note channel this event targets (0-15).

This returns Match::All if this event targets all possible note channels.

pub const fn set_channel(&mut self, channel: Match<u16>)

Sets the note channel this event targets (0-15).

Use Match::All to target all possible channels.

pub const fn with_channel(self, channel: Match<u16>) -> NoteExpressionEvent

Sets the note channel this event targets (0-15).

Use Match::All to target all possible channels.

This method takes and returns ownership of the event, allowing it to be used in a builder-style pattern.

pub const fn key(&self) -> Match<u16>

The key of the note(s) this event targets (0-127).

This returns Match::All if this event targets all possible note keys.

pub const fn set_key(&mut self, key: Match<u16>)

Sets the key of the note(s) this event targets (0-127).

Use Match::All to target all possible note keys.

pub const fn with_key(self, key: Match<u16>) -> NoteExpressionEvent

Sets the key of the note(s) this event targets (0-127).

Use Match::All to target all possible note keys.

This method takes and returns ownership of the event, allowing it to be used in a builder-style pattern.

pub const fn note_id(&self) -> Match<u32>

The specific ID of the Note this event targets.

This returns Match::All if this event doesn’t target a specific note, or doesn’t provide a Note ID.

pub const fn set_note_id(&mut self, note_id: Match<u32>)

Sets the specific ID of the Note this event targets.

Use Match::All to not target a single specific note in particular.

pub const fn with_note_id(self, note_id: Match<u32>) -> NoteExpressionEvent

Sets the specific ID of the Note this event targets.

Use Match::All to not target a single specific note in particular.

This method takes and returns ownership of the event, allowing it to be used in a builder-style pattern.

Trait Implementations

impl AsRef<UnknownEvent> for NoteExpressionEvent

fn as_ref(&self) -> &UnknownEvent

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for NoteExpressionEvent

fn clone(&self) -> NoteExpressionEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for NoteExpressionEvent

impl Debug for NoteExpressionEvent

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

Formats the value using the given formatter.

impl Event for NoteExpressionEvent

const TYPE_ID: u16 = CLAP_EVENT_NOTE_EXPRESSION

The raw event type identifier for this event type.

type EventSpace<'a> = CoreEventSpace<'a>

The event space this event type is a part of.

fn flags(&self) -> EventFlags

Returns the EventFlags of this event.

fn set_flags(&mut self, flags: EventFlags)

Sets the EventFlags of this event.

fn with_flags(self, flags: EventFlags) -> Self

Builds an event with the given EventFlags, and returns it.

fn time(&self) -> u32

Returns the time stamp of this event, in samples.

fn set_time(&mut self, time: u32)

Sets the time stamp of this event, in samples.

fn with_time(self, time: u32) -> Self

Builds an event with the given time stamp, and returns it.

fn header(&self) -> &EventHeader<Self>

Returns a shared, immutable reference to this event’s header.

fn header_mut(&mut self) -> &mut EventHeader<Self>

Returns an exclusive, mutable reference to this event’s header.

fn as_unknown(&self) -> &UnknownEvent

Returns this event as a type-erased UnknownEvent.

fn raw_header(&self) -> &clap_event_header

Returns a shared, immutable reference to the raw, C-FFI compatible representation of this header’s event.

unsafe fn raw_header_mut(&mut self) -> &mut clap_event_header

Returns an exclusive, mutable reference to the raw, C-FFI compatible representation of this header’s event.

impl PartialEq for NoteExpressionEvent

fn eq(&self, other: &NoteExpressionEvent) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.