linuxsampler 2.3.1
LinuxSampler::InstrumentEditor Class Referenceabstract

Instrument Editor Interface (external plugin) More...

#include <InstrumentEditor.h>

Inheritance diagram for LinuxSampler::InstrumentEditor:
LinuxSampler::VirtualMidiDevice LinuxSampler::Thread

Public Types

enum  event_type_t {
  EVENT_TYPE_NOTEON = 1 , EVENT_TYPE_NOTEOFF = 2 , EVENT_TYPE_CC = 3 , EVENT_TYPE_PITCHBEND ,
  EVENT_TYPE_PROGRAM , EVENT_TYPE_CHPRESSURE
}
 

Public Member Functions

virtual int Main (void *pInstrument, String sTypeName, String sTypeVersion, void *pUserData=NULL)=0
 Entry point for the instrument editor's thread.
 
virtual bool IsTypeSupported (String sTypeName, String sTypeVersion)=0
 The instrument editor has to return true in case it supports the given instrument data structure type and version, it has to return false otherwise.
 
virtual String Name ()=0
 The instrument editor's name (i.e.
 
virtual String Version ()=0
 The instrument editor's version (i.e.
 
virtual String Description ()=0
 Arbitrary textual description of the instrument editor (i.e.
 
void NotifySamplesToBeRemoved (std::set< void * > Samples)
 Dispatch pending sample removal event.
 
void NotifySamplesRemoved ()
 Dispatch completed sample removal event.
 
void NotifyDataStructureToBeChanged (void *pStruct, String sStructType)
 Dispatch pending data structure modification event.
 
void NotifyDataStructureChanged (void *pStruct, String sStructType)
 Dispatch completed data structure modification event.
 
void NotifySampleReferenceChanged (void *pOldSample, void *pNewSample)
 Dispatch sample reference changed event.
 
void Launch (EngineChannel *pEngineChannel, void *pInstrument, String sTypeName, String sTypeVersion, void *pUserData=NULL)
 Launch the instrument editor for the given instrument.
 
EngineChannelGetEngineChannel ()
 Returns the EngineChannel for which this instrument editor was spawned for, for editing the respective instrument loaded on that EngineChannel.
 
void AddListener (InstrumentEditorListener *pListener)
 Registers object that wants to be notified on events.
 
void RemoveListener (InstrumentEditorListener *pListener)
 Unregisters object that doesn't want to be notified anymore.
 
 InstrumentEditor ()
 Constructor.
 
virtual ~InstrumentEditor ()
 Destructor.
 
bool SendNoteOnToSampler (uint8_t Key, uint8_t Velocity)
 Sends a MIDI note on event to the sampler.
 
bool SendNoteOffToSampler (uint8_t Key, uint8_t Velocity)
 Sends a MIDI note off event to the sampler.
 
bool SendCCToSampler (uint8_t Controller, uint8_t Value)
 Sends a MIDI Control Change event to the sampler.
 
bool SendChannelPressureToSampler (uint8_t Pressure)
 Sends a MIDI Channel Pressure (aftertouch) event to the sampler.
 
bool SendPitchBendToSampler (int Pitch)
 Sends a MIDI Pitch Bend event to the sampler.
 
bool SendProgramChangeToSampler (uint8_t Program)
 Sends a MIDI Program Change event to the sampler.
 
bool NotesChanged ()
 Can be called by the virtual MIDI device to check whether a new note on or note off MIDI event arrived to the sampler during the last call to this method.
 
bool NoteChanged (uint8_t Key)
 Can be called by the virtual MIDI device to check whether a new note on or note off MIDI event arrived to the sampler for Key during the last call to this method.
 
bool NoteIsActive (uint8_t Key)
 Can be called by the virtual MIDI device to check which key / note is currently active by the sampler, e.g.
 
uint8_t NoteOnVelocity (uint8_t Key)
 Returns the velocity of the last note on event.
 
uint8_t NoteOffVelocity (uint8_t Key)
 Returns the velocity of the last note off event.
 
bool ControllersChanged ()
 Can be called by the virtual MIDI device to check whether a Control Change MIDI event arrived to the sampler during the last call to this method.
 
bool ControllerChanged (uint8_t Controller)
 Can be called by the virtual MIDI device to check whether a Control Change MIDI event arrived to the sampler for Controller during the last call to this method.
 
uint8_t ControllerValue (uint8_t Controller)
 Returns the value of the last Control Change event.
 
void SendNoteOnToDevice (uint8_t Key, uint8_t Velocity)
 Informs the virtual MIDI device that a note on event occured (e.g.
 
void SendNoteOffToDevice (uint8_t Key, uint8_t Velocity)
 Informs the virtual MIDI device that a note off event occured (e.g.
 
void SendCCToDevice (uint8_t Controller, uint8_t Value)
 Informs the virtual MIDI device that a Control Change event occured (e.g.
 
bool GetMidiEventFromDevice (event_t &Event)
 Gets the next pending MIDI event from the virtual MIDI device by using a lockfree FIFO.
 
void SetMaxEvents (int n)
 Adjusts the internal event buffer to cover at least the given amount of MIDI events.
 
void Reset ()
 Intended to be called on "panic" / all notes off situations.
 

Protected Member Functions

virtual int Main ()
 This method needs to be implemented by the descending class and is the entry point for the new thread.
 
virtual int StartThread ()
 
virtual int StopThread ()
 
virtual int SignalStopThread ()
 
virtual bool IsRunning ()
 
std::string name ()
 
void TestCancel ()
 Synchronization point for potentially terminating the thread.
 
virtual int SignalStartThread ()
 
virtual int SetSchedulingPriority ()
 
virtual int LockMemory ()
 
virtual void EnableDestructor ()
 
virtual int onThreadEnd ()
 

Static Protected Member Functions

static voidallocAlignedMem (size_t boundary, size_t size)
 Allocates an aligned block of memory.
 
static void freeAlignedMem (void *ptr)
 Frees an aligned block of memory allocated with allocAlignedMem()
 
static bool lockMemory (void *addr, size_t size)
 Locks a region of memory in physical RAM.
 
static bool unlockMemory (void *addr, size_t size)
 Unlocks a region of memory in physical RAM.
 
static void pushCancelable (bool cancel)
 
static void popCancelable ()
 
static std::string nameOfCaller ()
 
static void setNameOfCaller (std::string name)
 

Protected Attributes

std::set< InstrumentEditorListener * > listeners
 

Detailed Description

Instrument Editor Interface (external plugin)

LinuxSampler allows to spawn arbitrary instrument editor applications within the sampler's own process. That way instrument editors are able to modify already loaded instruments live or on-the-fly, that is without having to load it again neither on sampler nor on editor side, which is essential for editing large instruments.

Instrument editors have to implement this abstract base class, embedded into a DLL and placed into the respective sampler's library path. The sampler will load these external DLLs as plugins on startup. Whenever there's a request for editing an instrument, the sampler will try to launch a matching registered editor, by calling the respective plugin's Main() method.

Definition at line 51 of file InstrumentEditor.h.

Member Enumeration Documentation

◆ event_type_t

Enumerator
EVENT_TYPE_NOTEON 
EVENT_TYPE_NOTEOFF 
EVENT_TYPE_CC 
EVENT_TYPE_PITCHBEND 
EVENT_TYPE_PROGRAM 
EVENT_TYPE_CHPRESSURE 

Definition at line 22 of file VirtualMidiDevice.h.

Constructor & Destructor Documentation

◆ InstrumentEditor()

LinuxSampler::InstrumentEditor::InstrumentEditor ( )

Constructor.

◆ ~InstrumentEditor()

virtual LinuxSampler::InstrumentEditor::~InstrumentEditor ( )
virtual

Destructor.

Member Function Documentation

◆ AddListener()

void LinuxSampler::InstrumentEditor::AddListener ( InstrumentEditorListener pListener)

Registers object that wants to be notified on events.

◆ allocAlignedMem()

static void * LinuxSampler::Thread::allocAlignedMem ( size_t  boundary,
size_t  size 
)
inlinestaticinherited

Allocates an aligned block of memory.

Allocated memory blocks need to be freed using freeAlignedMem().

Parameters
boundary- the alignement boundary, usually a power of 2 e.g. 4 but it can be an arbitrary number between 1 and 128
size- size in bytes to be allocated
Returns
pointer to the allocated memory block

Definition at line 83 of file Thread.h.

Referenced by LinuxSampler::AudioChannel::AudioChannel().

◆ ControllerChanged()

bool LinuxSampler::VirtualMidiDevice::ControllerChanged ( uint8_t  Controller)
inherited

Can be called by the virtual MIDI device to check whether a Control Change MIDI event arrived to the sampler for Controller during the last call to this method.

So this is a asynchronously, "polling" based communication mechanism, which works in conjunction with the ControllerValue() method call.

◆ ControllersChanged()

bool LinuxSampler::VirtualMidiDevice::ControllersChanged ( )
inherited

Can be called by the virtual MIDI device to check whether a Control Change MIDI event arrived to the sampler during the last call to this method.

So this is a asynchronously, "polling" based communication mechanism, which works in conjunction with the ControllerValue() method call.

◆ ControllerValue()

uint8_t LinuxSampler::VirtualMidiDevice::ControllerValue ( uint8_t  Controller)
inherited

Returns the value of the last Control Change event.

No FIFO is used!

◆ Description()

virtual String LinuxSampler::InstrumentEditor::Description ( )
pure virtual

Arbitrary textual description of the instrument editor (i.e.

"Gigasampler and DLS format editor, GTK based").

◆ EnableDestructor()

virtual void LinuxSampler::Thread::EnableDestructor ( )
protectedvirtualinherited

◆ freeAlignedMem()

static void LinuxSampler::Thread::freeAlignedMem ( void ptr)
inlinestaticinherited

Frees an aligned block of memory allocated with allocAlignedMem()

Parameters
ptr- pointer to the memory block

Definition at line 95 of file Thread.h.

Referenced by LinuxSampler::AudioChannel::~AudioChannel().

◆ GetEngineChannel()

EngineChannel * LinuxSampler::InstrumentEditor::GetEngineChannel ( )

Returns the EngineChannel for which this instrument editor was spawned for, for editing the respective instrument loaded on that EngineChannel.

◆ GetMidiEventFromDevice()

bool LinuxSampler::VirtualMidiDevice::GetMidiEventFromDevice ( event_t Event)
inherited

Gets the next pending MIDI event from the virtual MIDI device by using a lockfree FIFO.

Note: this method is usually only called by the sampler.

Parameters
Event- destination for writing the next event to
Returns
true on success, false if no event pending

◆ IsRunning()

virtual bool LinuxSampler::Thread::IsRunning ( )
virtualinherited

◆ IsTypeSupported()

virtual bool LinuxSampler::InstrumentEditor::IsTypeSupported ( String  sTypeName,
String  sTypeVersion 
)
pure virtual

The instrument editor has to return true in case it supports the given instrument data structure type and version, it has to return false otherwise.

This method will be called by the sampler to determine which editor is capable to work with a certain instrument.

Parameters
sTypeName- i.e. "libgig"
sTypeVersion- i.e. "3.0.1"

◆ Launch()

void LinuxSampler::InstrumentEditor::Launch ( EngineChannel pEngineChannel,
void pInstrument,
String  sTypeName,
String  sTypeVersion,
void pUserData = NULL 
)

Launch the instrument editor for the given instrument.

The editor will be spawned in its own thread and this method will return as soon as the editor's thread actually started.

Parameters
pEngineChannel- the engine channel on which pInstrument is currently used on and for which the instrument editor shall be spawned for editing
pInstrument- pointer to the respective instrument object
sTypeName- format of the instrument data structure (i.e. "libgig" )
sTypeVersion- version of the instrument data structure (i.e. "3.0.1" ).
pUserData- (optional) arbitrary 3rd party data that might e.g. been passed by InstrumentManager::LaunchInstrumentEditor()

◆ LockMemory()

virtual int LinuxSampler::Thread::LockMemory ( )
protectedvirtualinherited

◆ lockMemory()

static bool LinuxSampler::Thread::lockMemory ( void addr,
size_t  size 
)
inlinestaticinherited

Locks a region of memory in physical RAM.

Parameters
addr- address of the memory block
size- size of the memory block
Returns
true if the locking succeded, otherwise false

Definition at line 108 of file Thread.h.

◆ Main() [1/2]

virtual int LinuxSampler::InstrumentEditor::Main ( )
protectedvirtual

This method needs to be implemented by the descending class and is the entry point for the new thread.

NOTE: If your thread runs for a longer time, i.e. if it is running a loop, then you should explicitly call TestCancel() once in a while in your Main() implementation, especially if your implementation does not use any system calls.

Implements LinuxSampler::Thread.

◆ Main() [2/2]

virtual int LinuxSampler::InstrumentEditor::Main ( void pInstrument,
String  sTypeName,
String  sTypeVersion,
void pUserData = NULL 
)
pure virtual

Entry point for the instrument editor's thread.

As the instrument data structure is passed as typeless (void*) pointer, this is not type safe! The implementing instrument editor has to interpret the sTypeName and sTypeVersion arguments to determine if it's able to cast the instrument pointer to a known type and actually be able to work with it.

Parameters
pInstrument- pointer to the respective instrument object
sTypeName- format of the instrument data structure (i.e. "libgig" )
sTypeVersion- version of the instrument data structure (i.e. "3.0.1" ).
pUserData- (optional) arbitrary 3rd party data that might been passed by Launch()

◆ name()

std::string LinuxSampler::Thread::name ( )
inherited

◆ Name()

virtual String LinuxSampler::InstrumentEditor::Name ( )
pure virtual

The instrument editor's name (i.e.

"gigedit" ).

◆ nameOfCaller()

static std::string LinuxSampler::Thread::nameOfCaller ( )
staticinherited

◆ NoteChanged()

bool LinuxSampler::VirtualMidiDevice::NoteChanged ( uint8_t  Key)
inherited

Can be called by the virtual MIDI device to check whether a new note on or note off MIDI event arrived to the sampler for Key during the last call to this method.

So this is a asynchronously, "polling" based communication mechanism, which works in conjunction with the NoteIsActive() method call.

◆ NoteIsActive()

bool LinuxSampler::VirtualMidiDevice::NoteIsActive ( uint8_t  Key)
inherited

Can be called by the virtual MIDI device to check which key / note is currently active by the sampler, e.g.

to highlight the respective keys on a graphical virtual keyboard.

See also
NotesChanged(), NoteChanged()

◆ NoteOffVelocity()

uint8_t LinuxSampler::VirtualMidiDevice::NoteOffVelocity ( uint8_t  Key)
inherited

Returns the velocity of the last note off event.

No FIFO is used!

◆ NoteOnVelocity()

uint8_t LinuxSampler::VirtualMidiDevice::NoteOnVelocity ( uint8_t  Key)
inherited

Returns the velocity of the last note on event.

No FIFO is used!

◆ NotesChanged()

bool LinuxSampler::VirtualMidiDevice::NotesChanged ( )
inherited

Can be called by the virtual MIDI device to check whether a new note on or note off MIDI event arrived to the sampler during the last call to this method.

So this is a asynchronously, "polling" based communication mechanism, which works in conjunction with the NoteIsActive() method call.

◆ NotifyDataStructureChanged()

void LinuxSampler::InstrumentEditor::NotifyDataStructureChanged ( void pStruct,
String  sStructType 
)

Dispatch completed data structure modification event.

Inform the sampler that the by NotifyDataStructureToBeChanged() previously announced data structure has been completely modified.

Parameters
pStruct- data structure that has been modified
sStructType- name of the data structure (i.e. its C++ struct or class name)

◆ NotifyDataStructureToBeChanged()

void LinuxSampler::InstrumentEditor::NotifyDataStructureToBeChanged ( void pStruct,
String  sStructType 
)

Dispatch pending data structure modification event.

SHOULD be called by the instrument editor before modifying data structures (except samples, which have their own dispatch methods) which could otherwise lead to undesired synchronisation issues and a crash. The respective data structure is passed as a typeless pointer pStruct , so the instrument editor additionally has to pass the name of the data structure (i.e. "gig::Region" ), so the sampler can cast the pointer to an appropriate type. The sampler will react by stopping usage of the respective data structure.

After calling this method, the instrument editor MUST call NotifyDataStructureChanged() , so the sampler can react by resuming usage of the respective data structure for playback.

Parameters
pStruct- data structure going to be modified
sStructType- name of the data structure (i.e. its C++ struct or class name)

◆ NotifySampleReferenceChanged()

void LinuxSampler::InstrumentEditor::NotifySampleReferenceChanged ( void pOldSample,
void pNewSample 
)

Dispatch sample reference changed event.

SHOULD be called by the instrument editor after a certain data structure changed its reference / pointer to a sample, so the sampler can react by:

  • Caching the newly referenced sample if necessary.
  • Un-caching the old referenced sample if necessary.

Note: the instrument editor additionally MUST embed this call into the respective NotifyDataStructureToBeChanged() and NotifyDataStructureChanged() calls for announcing the data structure whose sample reference is actually to be changed, so the sampler can react by suspending usage. For example:

NotifyDataStructureToBeChanged(pDimReg, "gig::DimensionRegion");
gig::Sample* pOldSample = pDimReg->pSample;
pDimReg->pSample = pNewSample;
NotifyDataStructureChanged(pDimReg, "gig::DimensionRegion");
void NotifySampleReferenceChanged(void *pOldSample, void *pNewSample)
Dispatch sample reference changed event.
void NotifyDataStructureChanged(void *pStruct, String sStructType)
Dispatch completed data structure modification event.
void NotifyDataStructureToBeChanged(void *pStruct, String sStructType)
Dispatch pending data structure modification event.
Wraps as a kind of pointer class some data object shared with other threads, to protect / synchronize...

So calling this method alone is not safe!

Parameters
pOldSample- previous sample reference
pNewSample- current sample reference

◆ NotifySamplesRemoved()

void LinuxSampler::InstrumentEditor::NotifySamplesRemoved ( )

Dispatch completed sample removal event.

Inform the sampler that the by NotifySamplesToBeRemoved() previously announced samples have been deleted.

◆ NotifySamplesToBeRemoved()

void LinuxSampler::InstrumentEditor::NotifySamplesToBeRemoved ( std::set< void * >  Samples)

Dispatch pending sample removal event.

SHOULD be called by the instrument editor before deleting samples, so the sampler can react by stopping usage of these samples to avoid a crash.

After calling this method, the instrument editor MUST call NotifySamplesRemoved() after it actually deleted the samples, so the sampler can react by i.e. resuming playback of sampler engines.

Parameters
Samples- list of samples that will be deleted by the instrument editor

◆ onThreadEnd()

virtual int LinuxSampler::Thread::onThreadEnd ( )
protectedvirtualinherited

◆ popCancelable()

static void LinuxSampler::Thread::popCancelable ( )
staticinherited

◆ pushCancelable()

static void LinuxSampler::Thread::pushCancelable ( bool  cancel)
staticinherited

◆ RemoveListener()

void LinuxSampler::InstrumentEditor::RemoveListener ( InstrumentEditorListener pListener)

Unregisters object that doesn't want to be notified anymore.

◆ Reset()

void LinuxSampler::VirtualMidiDevice::Reset ( )
inherited

Intended to be called on "panic" / all notes off situations.

Calling this method will reset all internal atomic flags, such that the state reflects that no note is currently active (its key pressed down).

Only exception: this method currently does not reset the internal ring buffer which is used to transmit MIDI events to the sampler.

Also note that this method is not fully concurrency safe. That means since only flags are reset, calling this method means no harm, but it might conflict with MIDI events etc and thus still cause hanging notes durcing such a specific concurrency conflict. Or in other words: the user might need to trigger the "panic" button multiple times.

◆ SendCCToDevice()

void LinuxSampler::VirtualMidiDevice::SendCCToDevice ( uint8_t  Controller,
uint8_t  Value 
)
inherited

Informs the virtual MIDI device that a Control Change event occured (e.g.

caused by a MIDI keyboard connected to the sampler). Communication acts asynchronously, that is this method call doesn't lock in any way and returns immediately. It is thus realtime safe.

Note: this method is usually only called by the sampler.

See also
ControllersChanged(), ControllerValue()

◆ SendCCToSampler()

bool LinuxSampler::VirtualMidiDevice::SendCCToSampler ( uint8_t  Controller,
uint8_t  Value 
)
inherited

Sends a MIDI Control Change event to the sampler.

Returns
true on success, false if internal FIFO full (or provided values invalid)

◆ SendChannelPressureToSampler()

bool LinuxSampler::VirtualMidiDevice::SendChannelPressureToSampler ( uint8_t  Pressure)
inherited

Sends a MIDI Channel Pressure (aftertouch) event to the sampler.

Returns
true on success, false if internal FIFO full (or provided value invalid)

◆ SendNoteOffToDevice()

void LinuxSampler::VirtualMidiDevice::SendNoteOffToDevice ( uint8_t  Key,
uint8_t  Velocity 
)
inherited

Informs the virtual MIDI device that a note off event occured (e.g.

caused by a MIDI keyboard connected to the sampler). Communication acts asynchronously, that is this method call doesn't lock in any way and returns immediately. It is thus realtime safe.

Note: this method is usually only called by the sampler.

See also
ActiveNotesChanged(), NoteIsActive()

◆ SendNoteOffToSampler()

bool LinuxSampler::VirtualMidiDevice::SendNoteOffToSampler ( uint8_t  Key,
uint8_t  Velocity 
)
inherited

Sends a MIDI note off event to the sampler.

Returns
true on success, false if internal FIFO full (or provided values invalid)

◆ SendNoteOnToDevice()

void LinuxSampler::VirtualMidiDevice::SendNoteOnToDevice ( uint8_t  Key,
uint8_t  Velocity 
)
inherited

Informs the virtual MIDI device that a note on event occured (e.g.

caused by a MIDI keyboard connected to the sampler). Communication acts asynchronously, that is this method call doesn't lock in any way and returns immediately. It is thus realtime safe.

Note: this method is usually only called by the sampler.

See also
ActiveNotesChanged(), NoteIsActive()

◆ SendNoteOnToSampler()

bool LinuxSampler::VirtualMidiDevice::SendNoteOnToSampler ( uint8_t  Key,
uint8_t  Velocity 
)
inherited

Sends a MIDI note on event to the sampler.

Returns
true on success, false if internal FIFO full (or provided values invalid)

◆ SendPitchBendToSampler()

bool LinuxSampler::VirtualMidiDevice::SendPitchBendToSampler ( int  Pitch)
inherited

Sends a MIDI Pitch Bend event to the sampler.

Parameters
Pitch- MIDI pitch value (-8192 ... +8191)
Returns
true on success, false if internal FIFO full (or provided pitch value out of valid range)

◆ SendProgramChangeToSampler()

bool LinuxSampler::VirtualMidiDevice::SendProgramChangeToSampler ( uint8_t  Program)
inherited

Sends a MIDI Program Change event to the sampler.

If you want to change the sound bank, call SendCCToSampler() (with controller = 0 for bank select MSB and/or controller = 32 for bank select LSB) before calling this method.

Parameters
Program- MIDI program number
Returns
true on success, false if internal FIFO full (or provided value invalid)

◆ SetMaxEvents()

void LinuxSampler::VirtualMidiDevice::SetMaxEvents ( int  n)
inherited

Adjusts the internal event buffer to cover at least the given amount of MIDI events.

This might be useful, since the internal event buffer is by default quite small (i.e. just 12 events).

This method is not thread safe! Any operations upon this device have to be stopped before calling this method!

◆ setNameOfCaller()

static void LinuxSampler::Thread::setNameOfCaller ( std::string  name)
staticinherited

◆ SetSchedulingPriority()

virtual int LinuxSampler::Thread::SetSchedulingPriority ( )
protectedvirtualinherited

◆ SignalStartThread()

virtual int LinuxSampler::Thread::SignalStartThread ( )
protectedvirtualinherited

◆ SignalStopThread()

virtual int LinuxSampler::Thread::SignalStopThread ( )
virtualinherited

◆ StartThread()

virtual int LinuxSampler::Thread::StartThread ( )
virtualinherited

◆ StopThread()

virtual int LinuxSampler::Thread::StopThread ( )
virtualinherited

◆ TestCancel()

void LinuxSampler::Thread::TestCancel ( )
protectedinherited

Synchronization point for potentially terminating the thread.

Like already described in Main() you should call TestCancel() in your Main() implementation once in a while to provide the system a chance to perform a clean termination of your thread. Depending on the underlying OS, and also depending on whether your are using any system call in your Main() implementation, it might otherwise be possible that the thread cannot be terminated at all! And even if the underlying OS supports terminating busy threads which do not call TestCancel(), this might still cause undefined behavior on such OSes!

◆ unlockMemory()

static bool LinuxSampler::Thread::unlockMemory ( void addr,
size_t  size 
)
inlinestaticinherited

Unlocks a region of memory in physical RAM.

Parameters
addr- address of the memory block
size- size of the memory block
Returns
true if the unlocking succeded, otherwise false

Definition at line 123 of file Thread.h.

◆ Version()

virtual String LinuxSampler::InstrumentEditor::Version ( )
pure virtual

The instrument editor's version (i.e.

"0.0.1" ).

Member Data Documentation

◆ listeners

std::set<InstrumentEditorListener*> LinuxSampler::InstrumentEditor::listeners
protected

Definition at line 240 of file InstrumentEditor.h.


The documentation for this class was generated from the following file: