namespace Arts

 A pool object of the type T keeps a pool of T* pointers, that are numbered. More...
List of all Methods
Annotated List
Files
Globals
Hierarchy
Index

Public Types

Public Methods

Public Members

Detailed Description

A pool object of the type T keeps a pool of T* pointers, that are numbered.

You allocate and release slots, and store T*'s in there. It should take about no time to find a new free slot to store the T object into and to release a slot to be reused.

The pool object internally keeps track which slots are used.

typedef unsigned char mcopbyte

Buffer (class)

template<class T> void  readTypeSeq (Buffer& stream, std::vector<T>& sequence)

template<class T> void  writeTypeSeq (Buffer& stream, const std::vector<T>& sequence)

template<class T> void  writeObject (Buffer& stream, T* object)

template<class T> void  readObject (Buffer& stream, T*& result)

template<class T> void  readObjectSeq (Buffer& stream, std::vector<T>& sequence)

template<class T> void  writeObjectSeq (Buffer& stream, const std::vector<T>& sequence)

typedef unsigned char mcopbyte

Connection (class)

enum HeaderMagic {MCOP_MAGIC = 1296256848}; }

enum MessageType {mcopMessageInvalid = 0, mcopServerHello = 1, mcopClientHello = 2, mcopAuthAccept = 3, mcopInvocation = 4, mcopReturn = 5, mcopOnewayInvocation = 6}; }

enum MethodType {methodOneway = 1, methodTwoway = 2}; }

enum AttributeType {streamIn = 1, streamOut = 2, streamMulti = 4, attributeStream = 8, attributeAttribute = 16, streamAsync = 32, streamDefault = 64}; }

enum TypeIdentification {tiUnknown = 0, tiVoid = 1, tiLong = 2, tiByte = 3, tiString = 4, tiBoolean = 5, tiFloat = 6, tiEnum = 128, tiType = 129, tiInterface = 130}; }

Header (class)

Invocation (class)

OnewayInvocation (class)

ServerHello (class)

ClientHello (class)

AuthAccept (class)

ObjectReference (class)

ParamDef (class)

MethodDef (class)

AttributeDef (class)

InterfaceDef (class)

TypeComponent (class)

TypeDef (class)

EnumComponent (class)

EnumDef (class)

ModuleDef (class)

Any (class)

InterfaceRepo (class)

InterfaceRepoV2 (class)

FlowSystemSender (class)

FlowSystemReceiver (class)

FlowSystem (class)

GlobalComm (class)

TmpGlobalComm (class)

TraderOffer (class)

TraderQuery (class)

InterfaceRepo_base (class)

InterfaceRepo_stub (class)

InterfaceRepo_skel (class)

InterfaceRepoV2_base (class)

InterfaceRepoV2_stub (class)

InterfaceRepoV2_skel (class)

inline operator  InterfaceRepo ()

[const]

FlowSystemSender_base (class)

FlowSystemSender_stub (class)

FlowSystemSender_skel (class)

FlowSystemReceiver_base (class)

FlowSystemReceiver_stub (class)

FlowSystemReceiver_skel (class)

FlowSystem_base (class)

FlowSystem_stub (class)

FlowSystem_skel (class)

GlobalComm_base (class)

GlobalComm_stub (class)

GlobalComm_skel (class)

TmpGlobalComm_base (class)

TmpGlobalComm_stub (class)

TmpGlobalComm_skel (class)

inline operator  GlobalComm ()

[const]

TraderOffer_base (class)

TraderOffer_stub (class)

TraderOffer_skel (class)

TraderQuery_base (class)

TraderQuery_stub (class)

TraderQuery_skel (class)

inline long  InterfaceRepo::insertModule (const Arts::ModuleDef& newModule)

inline void  InterfaceRepo::removeModule (long moduleID)

inline Arts::InterfaceDef  InterfaceRepo::queryInterface (const std::string& name)

inline Arts::TypeDef  InterfaceRepo::queryType (const std::string& name)

inline Arts::EnumDef  InterfaceRepo::queryEnum (const std::string& name)

inline std::vector<std::string> *  InterfaceRepo::queryChildren (const std::string& name)

inline std::vector<std::string> *  InterfaceRepo::queryInterfaces ()

inline std::vector<std::string> *  InterfaceRepo::queryTypes ()

inline std::vector<std::string> *  InterfaceRepo::queryEnums ()

inline long  InterfaceRepoV2::insertModule (const Arts::ModuleDef& newModule)

inline void  InterfaceRepoV2::removeModule (long moduleID)

inline Arts::InterfaceDef  InterfaceRepoV2::queryInterface (const std::string& name)

inline Arts::TypeDef  InterfaceRepoV2::queryType (const std::string& name)

inline Arts::EnumDef  InterfaceRepoV2::queryEnum (const std::string& name)

inline std::vector<std::string> *  InterfaceRepoV2::queryChildren (const std::string& name)

inline std::vector<std::string> *  InterfaceRepoV2::queryInterfaces ()

inline std::vector<std::string> *  InterfaceRepoV2::queryTypes ()

inline std::vector<std::string> *  InterfaceRepoV2::queryEnums ()

inline Arts::TypeIdentification  InterfaceRepoV2::identifyType (const std::string& name)

inline void  FlowSystemSender::processed ()

inline void  FlowSystemSender::disconnect ()

inline long  FlowSystemReceiver::receiveHandlerID ()

inline void  FlowSystemReceiver::disconnect ()

inline void  FlowSystem::startObject (Arts::Object node)

inline void  FlowSystem::stopObject (Arts::Object node)

inline void  FlowSystem::connectObject (Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort)

inline void  FlowSystem::disconnectObject (Arts::Object sourceObject, const std::string& sourcePort, Arts::Object destObject, const std::string& destPort)

inline Arts::AttributeType  FlowSystem::queryFlags (Arts::Object node, const std::string& port)

inline void  FlowSystem::setFloatValue (Arts::Object node, const std::string& port, float value)

inline Arts::FlowSystemReceiver  FlowSystem::createReceiver (Arts::Object destObject, const std::string& destPort, Arts::FlowSystemSender sender)

inline bool  GlobalComm::put (const std::string& variable, const std::string& value)

inline std::string  GlobalComm::get (const std::string& variable)

inline void  GlobalComm::erase (const std::string& variable)

inline bool  TmpGlobalComm::put (const std::string& variable, const std::string& value)

inline std::string  TmpGlobalComm::get (const std::string& variable)

inline void  TmpGlobalComm::erase (const std::string& variable)

inline std::string  TraderOffer::interfaceName ()

inline std::vector<std::string> *  TraderOffer::getProperty (const std::string& name)

inline void  TraderQuery::supports (const std::string& property, const std::string& value)

inline std::vector<Arts::TraderOffer> *  TraderQuery::query ()

FlowSystem_impl (class)

ObjectManager (class)

Object_skel (class)

ReferenceClean (class)

DelayedReturn (class)

The "DelayedReturn" class implements delayed returning from functions.

For instance, suppose you would like to return from a wait() operation only after a certain time has passed, without blocking other clients from using your interface during this time.

Your implementation (in the skel file) of wait should look like this 


 static DelayedReturn *delayedReturn = 0;

 bool TimeServer::waitUntil(long time)
 {
     if(time(0) < time)
     {
     	   // ... initialize timer here ...
         delayedReturn = Dispatcher::the()->delayReturn();
     }
     return false; 
 }

 void timerEvent()
 {
 	   delayedReturn->doReturn(true);
 }

NOTE: this class breaks for local use (i.e. you can only use it if the call was a remote call), so it is strongly recommended not to use it unless there is no alternative (and you should really know what you are doing, too).

typedef void  (*mcop_sighandler) (int)

Dispatcher (class)

Factory (class)

Object_stub (class)

RemoteScheduleNode (class)

ScheduleNode (class)

IDLFileReg (class)

InterfaceRepo_impl (class)

IOType (struct)

What does the reentrant flag do?

The IOManager offers a processOneEvent call. This means, that you can ask that I/O is handled, even while in a routine that handles I/O. As a practical example: you may have got a remote invocation for the function foo. Now you are in function foo() and call function bar() on a remote server. When you wait for the result, you obviously will again require the IOManager to wait for it. Thus this is a case where you need reentrant I/O handling.

That way, you get a multiple level stack:

[...] | [ Hander for I/O ] | [ IOManager ] level 2 | [ Some other function ] | [ Hander for I/O ] | [ IOManager ] level 1 | [ main() ]

What reentrant does, is to allow that IO Watch to be activated at levels higher than one.

Timers and notifications, on the other hand will only be carried out at level 1.

IONotify (class)

IONotify is the base class you can derive from to receive callbacks about IO activity. You will need to call the watchFD function of the IOManager to start watching a filedescriptor.

IOWatchFD (class)

TimeNotify (class)

TimeWatcher (class)

IOManager (class)

Provides services like timers and notifications when filedescriptors get ready to read/write.

StdIOManager (class)

MCOPUtils (class)

typedef void  (*DispatchFunction) (void *object, Buffer *request, Buffer *result)

typedef void  (*OnewayDispatchFunction) (void *object, Buffer *request)

WeakReferenceBase (class)

Object (class)

Object_base (class)

AnyConstRef (class)

Pool (class)

SocketConnection (class)

StartupClass (class)

StartupManager (class)

TCPConnection (class)

TCPServer (class)

Type (class)

Base class for the IDL mapping of struct-like types

UnixConnection (class)

UnixServer (class)

GenericDataChannel (class)

GenericDataPacket (class)

DataPacket (class)

The DataPacket<T> interface is what C++ implementations of MCOP interfaces will need to use.

RawDataPacket (class)

The RawDataPacket<T> interface handles raw class T arrays of data

FloatDataPacket (class)

FloatDataPacket finally is one concrete DataPacket (which contains the information how to marshal a datapacket of type float)

ByteDataPacket (class)

GenericAsyncStream (class)

AsyncStream (class)

FloatAsyncStream (class)

ByteAsyncStream (class)

Notification (struct)

NotificationClient (class)

NotificationManager (class)

ExtensionLoader (class)

MCOPConfig (class)

void  connect (const Object& src, const std::string& output, const Object& dest, const std::string& input)

void  connect (const Object& src, const std::string& output, const Object& dest)

void  connect (const Object& src, const Object& dest, const std::string& input)

void  connect (const Object& src, const Object& dest)

void  disconnect (const Object& src, const std::string& output, const Object& dest, const std::string& input)

void  disconnect (const Object& src, const std::string& output, const Object& dest)

void  disconnect (const Object& src, const Object& dest, const std::string& input)

void  disconnect (const Object& src, const Object& dest)

void  setValue (const Object& c, const std::string& port, const float fvalue)

void  setValue (const Object& c, const float fvalue)

Reference (class)

SubClass (class)

DynamicCast (class)

WeakReference (class)

The WeakReference class can be used to savely store an object, without disallowing that it gets destroyed. A typical situation where you may want to use this is when you implement a datastructure, where A refers B, and B refers A. Using "normal" references, this structure would never get freed.

Usage example:

Synth_WAVE_SIN sin; WeakReference<Synth_PLAY_WAV> weak_sin;

{ Synth_WAVE_SIN test = weak_sin; if(test.isNull()) printf("#1 missing object\n"); else test.start(); }

// now, the strong reference leaves sin = Synth_WAVE_SIN::null();

{ Synth_WAVE_SIN test = weak_sin; if(test.isNull()) printf("#2 missing object\n"); else test.stop();

This would output "#2 missing object".

DynamicRequest (class)

The DynamicRequest class can be used to invoke requests on objects, without using IDL generated code to do so (i.e. you can talk to objects without having to know their interfaces at compile time)

Suppose you have the interface

interface SimpleSoundServer { [...] long play(string file); // plays a file and returns an id [...] };

And server is of type SimpleSoundServer, you can write in your C++ code:

long id; if(DynamicRequest(server).method("play").param("/tmp/bong.wav").invoke(id)) { cout << "playing file now, id is " << id << endl; } else { cout << "something went wrong with the dynamic request" << endl; }

You can of course also add parameters and other information one-by-one:

DynamicRequest request(server); request.method("play"); request.param("/tmp/bong.wav");

long id; if(request.invoke(id)) cout << "success" << endl;

AnyRefBase (class)

AnyRef (class)

Debug (class)

enum AutoSuspendState {asNoSuspend = 0, asSuspend = 1, asSuspendStop = 2}; }

enum AudioManagerDirection {amPlay = 0, amRecord = 1}; }

AudioManagerInfo (class)

SynthModule (class)

Synth_PLAY (class)

Synth_RECORD (class)

Synth_FREQUENCY (class)

Synth_WAVE_SIN (class)

Synth_MULTI_ADD (class)

Synth_ADD (class)

Synth_MUL (class)

Synth_PLAY_WAV (class)

Synth_BUS_UPLINK (class)

Synth_BUS_DOWNLINK (class)

ByteStreamToAudio (class)

StereoEffect (class)

StereoVolumeControl (class)

StereoFFTScope (class)

StereoEffectStack (class)

AudioManagerClient (class)

AudioManager (class)

Synth_AMAN_PLAY (class)

Synth_AMAN_RECORD (class)

SynthModule_base (class)

SynthModule_stub (class)

SynthModule_skel (class)

Synth_PLAY_base (class)

Synth_PLAY_stub (class)

Synth_PLAY_skel (class)

inline operator  SynthModule ()

[const]

Synth_RECORD_base (class)

Synth_RECORD_stub (class)

Synth_RECORD_skel (class)

inline operator  SynthModule ()

[const]

Synth_FREQUENCY_base (class)

Synth_FREQUENCY_stub (class)

Synth_FREQUENCY_skel (class)

inline operator  SynthModule ()

[const]

Synth_WAVE_SIN_base (class)

Synth_WAVE_SIN_stub (class)

Synth_WAVE_SIN_skel (class)

inline operator  SynthModule ()

[const]

Synth_MULTI_ADD_base (class)

Synth_MULTI_ADD_stub (class)

Synth_MULTI_ADD_skel (class)

inline operator  SynthModule ()

[const]

Synth_ADD_base (class)

Synth_ADD_stub (class)

Synth_ADD_skel (class)

inline operator  SynthModule ()

[const]

Synth_MUL_base (class)

Synth_MUL_stub (class)

Synth_MUL_skel (class)

inline operator  SynthModule ()

[const]

Synth_PLAY_WAV_base (class)

Synth_PLAY_WAV_stub (class)

Synth_PLAY_WAV_skel (class)

inline operator  SynthModule ()

[const]

Synth_BUS_UPLINK_base (class)

Synth_BUS_UPLINK_stub (class)

Synth_BUS_UPLINK_skel (class)

inline operator  SynthModule ()

[const]

Synth_BUS_DOWNLINK_base (class)

Synth_BUS_DOWNLINK_stub (class)

Synth_BUS_DOWNLINK_skel (class)

inline operator  SynthModule ()

[const]

ByteStreamToAudio_base (class)

ByteStreamToAudio_stub (class)

ByteStreamToAudio_skel (class)

inline operator  SynthModule ()

[const]

StereoEffect_base (class)

StereoEffect_stub (class)

StereoEffect_skel (class)

inline operator  SynthModule ()

[const]

StereoVolumeControl_base (class)

StereoVolumeControl_stub (class)

StereoVolumeControl_skel (class)

inline operator  StereoEffect ()

[const]

inline operator  SynthModule ()

[const]

StereoFFTScope_base (class)

StereoFFTScope_stub (class)

StereoFFTScope_skel (class)

inline operator  StereoEffect ()

[const]

inline operator  SynthModule ()

[const]

StereoEffectStack_base (class)

StereoEffectStack_stub (class)

StereoEffectStack_skel (class)

inline operator  StereoEffect ()

[const]

inline operator  SynthModule ()

[const]

AudioManagerClient_base (class)

AudioManagerClient_stub (class)

AudioManagerClient_skel (class)

AudioManager_base (class)

AudioManager_stub (class)

AudioManager_skel (class)

Synth_AMAN_PLAY_base (class)

Synth_AMAN_PLAY_stub (class)

Synth_AMAN_PLAY_skel (class)

inline operator  SynthModule ()

[const]

Synth_AMAN_RECORD_base (class)

Synth_AMAN_RECORD_stub (class)

Synth_AMAN_RECORD_skel (class)

inline operator  SynthModule ()

[const]

inline Arts::AutoSuspendState  SynthModule::autoSuspend ()

inline void  SynthModule::start ()

inline void  SynthModule::stop ()

inline void  SynthModule::streamInit ()

inline void  SynthModule::streamStart ()

inline void  SynthModule::streamEnd ()

inline Arts::AutoSuspendState  Synth_PLAY::autoSuspend ()

inline void  Synth_PLAY::start ()

inline void  Synth_PLAY::stop ()

inline void  Synth_PLAY::streamInit ()

inline void  Synth_PLAY::streamStart ()

inline void  Synth_PLAY::streamEnd ()

inline Arts::AutoSuspendState  Synth_RECORD::autoSuspend ()

inline void  Synth_RECORD::start ()

inline void  Synth_RECORD::stop ()

inline void  Synth_RECORD::streamInit ()

inline void  Synth_RECORD::streamStart ()

inline void  Synth_RECORD::streamEnd ()

inline Arts::AutoSuspendState  Synth_FREQUENCY::autoSuspend ()

inline void  Synth_FREQUENCY::start ()

inline void  Synth_FREQUENCY::stop ()

inline void  Synth_FREQUENCY::streamInit ()

inline void  Synth_FREQUENCY::streamStart ()

inline void  Synth_FREQUENCY::streamEnd ()

inline Arts::AutoSuspendState  Synth_WAVE_SIN::autoSuspend ()

inline void  Synth_WAVE_SIN::start ()

inline void  Synth_WAVE_SIN::stop ()

inline void  Synth_WAVE_SIN::streamInit ()

inline void  Synth_WAVE_SIN::streamStart ()

inline void  Synth_WAVE_SIN::streamEnd ()

inline Arts::AutoSuspendState  Synth_MULTI_ADD::autoSuspend ()

inline void  Synth_MULTI_ADD::start ()

inline void  Synth_MULTI_ADD::stop ()

inline void  Synth_MULTI_ADD::streamInit ()

inline void  Synth_MULTI_ADD::streamStart ()

inline void  Synth_MULTI_ADD::streamEnd ()

inline Arts::AutoSuspendState  Synth_ADD::autoSuspend ()

inline void  Synth_ADD::start ()

inline void  Synth_ADD::stop ()

inline void  Synth_ADD::streamInit ()

inline void  Synth_ADD::streamStart ()

inline void  Synth_ADD::streamEnd ()

inline Arts::AutoSuspendState  Synth_MUL::autoSuspend ()

inline void  Synth_MUL::start ()

inline void  Synth_MUL::stop ()

inline void  Synth_MUL::streamInit ()

inline void  Synth_MUL::streamStart ()

inline void  Synth_MUL::streamEnd ()

inline Arts::AutoSuspendState  Synth_PLAY_WAV::autoSuspend ()

inline void  Synth_PLAY_WAV::start ()

inline void  Synth_PLAY_WAV::stop ()

inline void  Synth_PLAY_WAV::streamInit ()

inline void  Synth_PLAY_WAV::streamStart ()

inline void  Synth_PLAY_WAV::streamEnd ()

inline float  Synth_PLAY_WAV::speed ()

inline void  Synth_PLAY_WAV::speed (float _newValue)

inline std::string  Synth_PLAY_WAV::filename ()

inline void  Synth_PLAY_WAV::filename (const std::string& _newValue)

inline bool  Synth_PLAY_WAV::finished ()

inline Arts::AutoSuspendState  Synth_BUS_UPLINK::autoSuspend ()

inline void  Synth_BUS_UPLINK::start ()

inline void  Synth_BUS_UPLINK::stop ()

inline void  Synth_BUS_UPLINK::streamInit ()

inline void  Synth_BUS_UPLINK::streamStart ()

inline void  Synth_BUS_UPLINK::streamEnd ()

inline std::string  Synth_BUS_UPLINK::busname ()

inline void  Synth_BUS_UPLINK::busname (const std::string& _newValue)

inline Arts::AutoSuspendState  Synth_BUS_DOWNLINK::autoSuspend ()

inline void  Synth_BUS_DOWNLINK::start ()

inline void  Synth_BUS_DOWNLINK::stop ()

inline void  Synth_BUS_DOWNLINK::streamInit ()

inline void  Synth_BUS_DOWNLINK::streamStart ()

inline void  Synth_BUS_DOWNLINK::streamEnd ()

inline std::string  Synth_BUS_DOWNLINK::busname ()

inline void  Synth_BUS_DOWNLINK::busname (const std::string& _newValue)

inline Arts::AutoSuspendState  ByteStreamToAudio::autoSuspend ()

inline void  ByteStreamToAudio::start ()

inline void  ByteStreamToAudio::stop ()

inline void  ByteStreamToAudio::streamInit ()

inline void  ByteStreamToAudio::streamStart ()

inline void  ByteStreamToAudio::streamEnd ()

inline long  ByteStreamToAudio::samplingRate ()

inline void  ByteStreamToAudio::samplingRate (long _newValue)

inline long  ByteStreamToAudio::channels ()

inline void  ByteStreamToAudio::channels (long _newValue)

inline long  ByteStreamToAudio::bits ()

inline void  ByteStreamToAudio::bits (long _newValue)

inline bool  ByteStreamToAudio::running ()

inline Arts::AutoSuspendState  StereoEffect::autoSuspend ()

inline void  StereoEffect::start ()

inline void  StereoEffect::stop ()

inline void  StereoEffect::streamInit ()

inline void  StereoEffect::streamStart ()

inline void  StereoEffect::streamEnd ()

inline Arts::AutoSuspendState  StereoVolumeControl::autoSuspend ()

inline void  StereoVolumeControl::start ()

inline void  StereoVolumeControl::stop ()

inline void  StereoVolumeControl::streamInit ()

inline void  StereoVolumeControl::streamStart ()

inline void  StereoVolumeControl::streamEnd ()

inline float  StereoVolumeControl::scaleFactor ()

inline void  StereoVolumeControl::scaleFactor (float _newValue)

inline float  StereoVolumeControl::currentVolumeLeft ()

inline float  StereoVolumeControl::currentVolumeRight ()

inline Arts::AutoSuspendState  StereoFFTScope::autoSuspend ()

inline void  StereoFFTScope::start ()

inline void  StereoFFTScope::stop ()

inline void  StereoFFTScope::streamInit ()

inline void  StereoFFTScope::streamStart ()

inline void  StereoFFTScope::streamEnd ()

inline std::vector<float> *  StereoFFTScope::scope ()

inline Arts::AutoSuspendState  StereoEffectStack::autoSuspend ()

inline void  StereoEffectStack::start ()

inline void  StereoEffectStack::stop ()

inline void  StereoEffectStack::streamInit ()

inline void  StereoEffectStack::streamStart ()

inline void  StereoEffectStack::streamEnd ()

inline long  StereoEffectStack::insertTop (Arts::StereoEffect effect, const std::string& name)

inline long  StereoEffectStack::insertBottom (Arts::StereoEffect effect, const std::string& name)

inline void  StereoEffectStack::remove (long ID)

inline long  AudioManagerClient::ID ()

inline Arts::AudioManagerDirection  AudioManagerClient::direction ()

inline void  AudioManagerClient::direction (Arts::AudioManagerDirection _newValue)

inline std::string  AudioManagerClient::title ()

inline void  AudioManagerClient::title (const std::string& _newValue)

inline std::string  AudioManagerClient::autoRestoreID ()

inline void  AudioManagerClient::autoRestoreID (const std::string& _newValue)

inline  AudioManagerClient::AudioManagerClient (Arts::AudioManagerDirection direction, const std::string& title, const std::string& autoRestoreID)

inline std::vector<std::string> *  AudioManager::destinations ()

inline std::vector<Arts::AudioManagerInfo> *  AudioManager::clients ()

inline long  AudioManager::changes ()

inline void  AudioManager::setDestination (long ID, const std::string& destination)

inline Arts::AutoSuspendState  Synth_AMAN_PLAY::autoSuspend ()

inline void  Synth_AMAN_PLAY::start ()

inline void  Synth_AMAN_PLAY::stop ()

inline void  Synth_AMAN_PLAY::streamInit ()

inline void  Synth_AMAN_PLAY::streamStart ()

inline void  Synth_AMAN_PLAY::streamEnd ()

inline std::string  Synth_AMAN_PLAY::title ()

inline void  Synth_AMAN_PLAY::title (const std::string& _newValue)

inline std::string  Synth_AMAN_PLAY::autoRestoreID ()

inline void  Synth_AMAN_PLAY::autoRestoreID (const std::string& _newValue)

inline  Synth_AMAN_PLAY::Synth_AMAN_PLAY (Arts::AudioManagerClient client)

inline Arts::AutoSuspendState  Synth_AMAN_RECORD::autoSuspend ()

inline void  Synth_AMAN_RECORD::start ()

inline void  Synth_AMAN_RECORD::stop ()

inline void  Synth_AMAN_RECORD::streamInit ()

inline void  Synth_AMAN_RECORD::streamStart ()

inline void  Synth_AMAN_RECORD::streamEnd ()

inline std::string  Synth_AMAN_RECORD::title ()

inline void  Synth_AMAN_RECORD::title (const std::string& _newValue)

inline std::string  Synth_AMAN_RECORD::autoRestoreID ()

inline void  Synth_AMAN_RECORD::autoRestoreID (const std::string& _newValue)

inline  Synth_AMAN_RECORD::Synth_AMAN_RECORD (Arts::AudioManagerClient client)

ASProducer (class)

ASConsumer (class)

AudioSubSystemStart (class)

AudioSubSystem (class)

Cache (class)

CachedObject (class)

CachedWav (class)

void  convert_mono_8_float (unsigned long samples, unsigned char *from, float *to)

void  interpolate_mono_8_float (unsigned long samples, double startpos, double speed, unsigned char *from, float *to)

void  convert_mono_16le_float (unsigned long samples, unsigned char *from, float *to)

void  interpolate_mono_16le_float (unsigned long samples, double startpos, double speed, unsigned char *from, float *to)

void  convert_mono_16be_float (unsigned long samples, unsigned char *from, float *to)

void  interpolate_mono_16be_float (unsigned long samples, double startpos, double speed, unsigned char *from, float *to)

void  convert_stereo_i8_2float (unsigned long samples, unsigned char *from, float *left, float *right)

void  interpolate_stereo_i8_2float (unsigned long samples, double startpos, double speed, unsigned char *from, float *left, float *right)

void  convert_stereo_i16le_2float (unsigned long samples, unsigned char *from, float *left, float *right)

void  interpolate_stereo_i16le_2float (unsigned long samples, double startpos, double speed, unsigned char *from, float *left, float *right)

void  convert_stereo_i16be_2float (unsigned long samples, unsigned char *from, float *left, float *right)

void  interpolate_stereo_i16be_2float (unsigned long samples, double startpos, double speed, unsigned char *from, float *left, float *right)

void  convert_mono_float_float (unsigned long samples, float *from, float *to)

void  interpolate_mono_float_float (unsigned long samples, double startpos, double speed, float *from, float *to)

void  convert_stereo_ifloat_2float (unsigned long samples, float *from, float *left, float *right)

void  interpolate_stereo_ifloat_2float (unsigned long samples, double startpos, double speed, float *from, float *left, float *right)

void  convert_mono_float_16le (unsigned long samples, float *from, unsigned char *to)

void  convert_stereo_2float_i16le (unsigned long samples, float *left, float *right, unsigned char *to)

void  convert_mono_float_16be (unsigned long samples, float *from, unsigned char *to)

void  convert_stereo_2float_i16be (unsigned long samples, float *left, float *right, unsigned char *to)

void  convert_mono_float_8 (unsigned long samples, float *from, unsigned char *to)

void  convert_stereo_2float_i8 (unsigned long samples, float *left, float *right, unsigned char *to)

enum {uni_convert_u8 = 8, uni_convert_s16_le = 16, uni_convert_s16_be = 17, uni_convert_float_ne = 0x100 }

unsigned long  uni_convert_stereo_2float ( unsigned long samples, unsigned char *from, unsigned long fromLen, unsigned int fromChannels, unsigned int fromBits, float *left, float *right, double speed, double startposition )

PipeSegment (class)

PipeBuffer (class)

StdSynthModule (class)

SynthBuffer (class)

StdScheduleNode (class)

Port (class)

AudioPort (class)

MultiPort (class)

StdFlowSystem (class)

enum RealtimeStatus {rtRealtime = 0, rtNoSupport = 1, rtNoWrapper = 2, rtNoRealtime = 3}; }

ByteSoundProducer (class)

SimpleSoundServer (class)

SoundServer (class)

WavPlayObject (class)

ByteSoundProducer_base (class)

ByteSoundProducer_stub (class)

ByteSoundProducer_skel (class)

inline operator  SynthModule ()

[const]

SimpleSoundServer_base (class)

SimpleSoundServer_stub (class)

SimpleSoundServer_skel (class)

inline operator  PlayObjectFactory ()

[const]

SoundServer_base (class)

SoundServer_stub (class)

SoundServer_skel (class)

inline operator  SimpleSoundServer ()

[const]

PlayObjectFactory (class)

WavPlayObject_base (class)

WavPlayObject_stub (class)

WavPlayObject_skel (class)

PlayObject (class)

PlayObject_private (class)

inline operator  SynthModule ()

[const]

inline Arts::AutoSuspendState  ByteSoundProducer::autoSuspend ()

inline void  ByteSoundProducer::start ()

inline void  ByteSoundProducer::stop ()

inline void  ByteSoundProducer::streamInit ()

inline void  ByteSoundProducer::streamStart ()

inline void  ByteSoundProducer::streamEnd ()

inline long  ByteSoundProducer::samplingRate ()

inline long  ByteSoundProducer::channels ()

inline long  ByteSoundProducer::bits ()

inline Arts::PlayObject  SimpleSoundServer::createPlayObject (const std::string& filename)

inline Arts::StereoEffectStack  SimpleSoundServer::outstack ()

inline float  SimpleSoundServer::minStreamBufferTime ()

inline float  SimpleSoundServer::serverBufferTime ()

inline long  SimpleSoundServer::play (const std::string& filename)

inline void  SimpleSoundServer::attach (Arts::ByteSoundProducer producer)

inline void  SimpleSoundServer::detach (Arts::ByteSoundProducer producer)

inline Arts::Object  SimpleSoundServer::createObject (const std::string& name)

inline Arts::StereoEffectStack  SoundServer::outstack ()

inline float  SoundServer::minStreamBufferTime ()

inline float  SoundServer::serverBufferTime ()

inline long  SoundServer::play (const std::string& filename)

inline void  SoundServer::attach (Arts::ByteSoundProducer producer)

inline void  SoundServer::detach (Arts::ByteSoundProducer producer)

inline Arts::Object  SoundServer::createObject (const std::string& name)

inline Arts::PlayObject  SoundServer::createPlayObject (const std::string& filename)

inline Arts::RealtimeStatus  SoundServer::realtimeStatus ()

inline long  SoundServer::secondsUntilSuspend ()

inline bool  SoundServer::suspend ()

inline bool  SoundServer::terminate ()

inline std::string  WavPlayObject::description ()

inline Arts::poTime  WavPlayObject::currentTime ()

inline Arts::poTime  WavPlayObject::overallTime ()

inline Arts::poCapabilities  WavPlayObject::capabilities ()

inline std::string  WavPlayObject::mediaName ()

inline Arts::poState  WavPlayObject::state ()

inline void  WavPlayObject::play ()

inline void  WavPlayObject::seek (const Arts::poTime& newTime)

inline void  WavPlayObject::pause ()

inline void  WavPlayObject::halt ()

inline bool  WavPlayObject::loadMedia (const std::string& filename)

inline Arts::AutoSuspendState  WavPlayObject::autoSuspend ()

inline void  WavPlayObject::start ()

inline void  WavPlayObject::stop ()

inline void  WavPlayObject::streamInit ()

inline void  WavPlayObject::streamStart ()

inline void  WavPlayObject::streamEnd ()

enum poState {posIdle = 0, posPlaying = 1, posPaused = 2}; }

enum poCapabilities {capSeek = 1, capPause = 2}; }

poTime (class)

PlayObject_private_base (class)

PlayObject_private_stub (class)

PlayObject_private_skel (class)

PlayObject_base (class)

PlayObject_stub (class)

PlayObject_skel (class)

inline operator  PlayObject_private ()

[const]

PlayObjectFactory_base (class)

PlayObjectFactory_stub (class)

PlayObjectFactory_skel (class)

inline bool  PlayObject_private::loadMedia (const std::string& filename)

inline bool  PlayObject::loadMedia (const std::string& filename)

inline std::string  PlayObject::description ()

inline Arts::poTime  PlayObject::currentTime ()

inline Arts::poTime  PlayObject::overallTime ()

inline Arts::poCapabilities  PlayObject::capabilities ()

inline std::string  PlayObject::mediaName ()

inline Arts::poState  PlayObject::state ()

inline void  PlayObject::play ()

inline void  PlayObject::seek (const Arts::poTime& newTime)

inline void  PlayObject::pause ()

inline void  PlayObject::halt ()

inline Arts::PlayObject  PlayObjectFactory::createPlayObject (const std::string& filename)

QIOManager (class)

QIOManager performs MCOP I/O inside the Qt event loop. This way, you will be able to receive requests and notifications inside Qt application. The usual way to set it up is: 


 KApplication app(argc, argv);    // as usual

 Arts::QIOManager qiomanager;
 Arts::Dispatcher dispatcher(&qiomanager);
 ...
 return app.exec();               // as usual

AudioIOFactory (class)

AudioIO (class)

enum PortDirection {input = 0, output = 1}; }

enum PortConnType {conn_stream = 0, conn_event = 1, conn_property = 2}; }

PortType (class)

ModuleInfo (class)

PortDesc (class)

ModuleDesc (class)

StructureDesc (class)

StructurePortDesc (class)

ObjectFactory (class)

LocalFactory (class)

StructureBuilder (class)

Structure (class)

PortDesc_base (class)

PortDesc_stub (class)

PortDesc_skel (class)

ModuleDesc_base (class)

ModuleDesc_stub (class)

ModuleDesc_skel (class)

StructureDesc_base (class)

StructureDesc_stub (class)

StructureDesc_skel (class)

StructurePortDesc_base (class)

StructurePortDesc_stub (class)

StructurePortDesc_skel (class)

inline operator  PortDesc ()

[const]

ObjectFactory_base (class)

ObjectFactory_stub (class)

ObjectFactory_skel (class)

LocalFactory_base (class)

LocalFactory_stub (class)

LocalFactory_skel (class)

inline operator  ObjectFactory ()

[const]

StructureBuilder_base (class)

StructureBuilder_stub (class)

StructureBuilder_skel (class)

Structure_base (class)

Structure_stub (class)

Structure_skel (class)

inline operator  SynthModule ()

[const]

inline long  PortDesc::ID ()

inline Arts::ModuleDesc  PortDesc::parent ()

inline std::string  PortDesc::name ()

inline Arts::PortType  PortDesc::type ()

inline bool  PortDesc::isConnected ()

inline bool  PortDesc::hasValue ()

inline void  PortDesc::hasValue (bool _newValue)

inline std::vector<Arts::PortDesc> *  PortDesc::connections ()

inline float  PortDesc::floatValue ()

inline void  PortDesc::floatValue (float _newValue)

inline std::string  PortDesc::stringValue ()

inline void  PortDesc::stringValue (const std::string& _newValue)

inline Arts::Any  PortDesc::value ()

inline void  PortDesc::value (const Arts::Any& _newValue)

inline long  PortDesc::internalOldID ()

inline  PortDesc::PortDesc (Arts::ModuleDesc parent, const std::string& name, const Arts::PortType& type)

inline bool  PortDesc::connectTo (Arts::PortDesc port)

inline void  PortDesc::disconnectFrom (Arts::PortDesc port)

inline void  PortDesc::disconnectAll ()

inline std::vector<std::string> *  PortDesc::saveToList ()

inline void  PortDesc::loadFromList (const std::vector<std::string>& list)

inline void  PortDesc::internalConnectInput (Arts::PortDesc port)

inline void  PortDesc::internalReConnect (const std::vector<Arts::PortDesc>& allports)

inline long  ModuleDesc::ID ()

inline Arts::StructureDesc  ModuleDesc::parent ()

inline std::string  ModuleDesc::name ()

inline std::vector<Arts::PortDesc> *  ModuleDesc::ports ()

inline long  ModuleDesc::x ()

inline long  ModuleDesc::y ()

inline long  ModuleDesc::width ()

inline long  ModuleDesc::height ()

inline bool  ModuleDesc::isInterface ()

inline bool  ModuleDesc::isStructure ()

inline  ModuleDesc::ModuleDesc (Arts::StructureDesc parent, const Arts::ModuleInfo& info)

inline bool  ModuleDesc::moveTo (long x, long y)

inline Arts::PortDesc  ModuleDesc::findPort (const std::string& name)

inline std::vector<std::string> *  ModuleDesc::saveToList ()

inline void  ModuleDesc::loadFromList (const std::vector<std::string>& list)

inline bool  StructureDesc::valid ()

inline std::string  StructureDesc::name ()

inline void  StructureDesc::name (const std::string& _newValue)

inline std::vector<Arts::ModuleDesc> *  StructureDesc::modules ()

inline std::vector<Arts::StructurePortDesc> *  StructureDesc::ports ()

inline Arts::ModuleInfo  StructureDesc::externalInterface ()

inline long  StructureDesc::obtainID ()

inline std::vector<std::string> *  StructureDesc::saveToList ()

inline void  StructureDesc::loadFromList (const std::vector<std::string>& list)

inline void  StructureDesc::clear ()

inline Arts::ModuleDesc  StructureDesc::createModuleDesc (const Arts::ModuleInfo& info)

inline void  StructureDesc::freeModuleDesc (Arts::ModuleDesc moduledesc)

inline Arts::StructurePortDesc  StructureDesc::createStructurePortDesc (const Arts::PortType& type, const std::string& name)

inline void  StructureDesc::freeStructurePortDesc (Arts::StructurePortDesc portdesc)

inline void  StructureDesc::moveStructurePortDesc (Arts::StructurePortDesc portdesc, long newposition)

inline long  StructurePortDesc::ID ()

inline Arts::ModuleDesc  StructurePortDesc::parent ()

inline std::string  StructurePortDesc::name ()

inline Arts::PortType  StructurePortDesc::type ()

inline bool  StructurePortDesc::isConnected ()

inline bool  StructurePortDesc::hasValue ()

inline void  StructurePortDesc::hasValue (bool _newValue)

inline std::vector<Arts::PortDesc> *  StructurePortDesc::connections ()

inline float  StructurePortDesc::floatValue ()

inline void  StructurePortDesc::floatValue (float _newValue)

inline std::string  StructurePortDesc::stringValue ()

inline void  StructurePortDesc::stringValue (const std::string& _newValue)

inline Arts::Any  StructurePortDesc::value ()

inline void  StructurePortDesc::value (const Arts::Any& _newValue)

inline long  StructurePortDesc::internalOldID ()

inline  StructurePortDesc::StructurePortDesc (Arts::ModuleDesc parent, const std::string& name, const Arts::PortType& type)

inline bool  StructurePortDesc::connectTo (Arts::PortDesc port)

inline void  StructurePortDesc::disconnectFrom (Arts::PortDesc port)

inline void  StructurePortDesc::disconnectAll ()

inline std::vector<std::string> *  StructurePortDesc::saveToList ()

inline void  StructurePortDesc::loadFromList (const std::vector<std::string>& list)

inline void  StructurePortDesc::internalConnectInput (Arts::PortDesc port)

inline void  StructurePortDesc::internalReConnect (const std::vector<Arts::PortDesc>& allports)

inline long  StructurePortDesc::x ()

inline long  StructurePortDesc::y ()

inline long  StructurePortDesc::position ()

inline Arts::StructureDesc  StructurePortDesc::parentStructure ()

inline  StructurePortDesc::StructurePortDesc (Arts::StructureDesc parent, const std::string& name, const Arts::PortType& type)

inline bool  StructurePortDesc::moveTo (long x, long y)

inline void  StructurePortDesc::lowerPosition ()

inline void  StructurePortDesc::raisePosition ()

inline void  StructurePortDesc::rename (const std::string& newname)

inline void  StructurePortDesc::internalSetPosition (long position)

inline Arts::Object  ObjectFactory::createObject (const std::string& name)

inline Arts::Object  LocalFactory::createObject (const std::string& name)

inline void  StructureBuilder::addFactory (Arts::ObjectFactory factory)

inline Arts::Object  StructureBuilder::createObject (Arts::StructureDesc structure)

inline Arts::AutoSuspendState  Structure::autoSuspend ()

inline void  Structure::start ()

inline void  Structure::stop ()

inline void  Structure::streamInit ()

inline void  Structure::streamStart ()

inline void  Structure::streamEnd ()

inline void  Structure::run ()

inline void  Structure::halt ()

enum MidiCommandStatus {mcsCommandMask = 240, mcsChannelMask = 15, mcsNoteOff = 128, mcsNoteOn = 144, mcsKeyPressure = 160, mcsParameter = 176, mcsProgram = 192, mcsChannelPressure = 208, mcsPitchWheel = 224}; }

enum MidiCommandParameter {mcpSustain = 64, mcpAllNotesOff = 123}; }

enum MidiClientDirection {mcdPlay = 0, mcdRecord = 1}; }

enum MidiClientType {mctDestination = 0, mctApplication = 1}; }

TimeStamp (class)

MidiCommand (class)

MidiEvent (class)

MidiClientInfo (class)

MidiPort (class)

MidiClient (class)

MidiManager (class)

MidiTest (class)

RawMidiPort (class)

MidiPort_base (class)

MidiPort_stub (class)

MidiPort_skel (class)

MidiClient_base (class)

MidiClient_stub (class)

MidiClient_skel (class)

MidiManager_base (class)

MidiManager_stub (class)

MidiManager_skel (class)

MidiTest_base (class)

MidiTest_stub (class)

MidiTest_skel (class)

inline operator  MidiPort ()

[const]

RawMidiPort_base (class)

RawMidiPort_stub (class)

RawMidiPort_skel (class)

inline operator  MidiPort ()

[const]

inline Arts::TimeStamp  MidiPort::time ()

inline void  MidiPort::processCommand (const Arts::MidiCommand& command)

inline void  MidiPort::processEvent (const Arts::MidiEvent& event)

inline Arts::MidiClientInfo  MidiClient::info ()

inline std::string  MidiClient::title ()

inline void  MidiClient::title (const std::string& _newValue)

inline void  MidiClient::addInputPort (Arts::MidiPort port)

inline Arts::MidiPort  MidiClient::addOutputPort ()

inline void  MidiClient::removePort (Arts::MidiPort port)

inline std::vector<Arts::MidiClientInfo> *  MidiManager::clients ()

inline Arts::MidiClient  MidiManager::addClient (Arts::MidiClientDirection direction, Arts::MidiClientType type, const std::string& title, const std::string& autoRestoreID)

inline void  MidiManager::connect (long clientID, long destinationID)

inline void  MidiManager::disconnect (long clientID, long destinationID)

inline Arts::TimeStamp  MidiTest::time ()

inline void  MidiTest::processCommand (const Arts::MidiCommand& command)

inline void  MidiTest::processEvent (const Arts::MidiEvent& event)

inline Arts::TimeStamp  RawMidiPort::time ()

inline void  RawMidiPort::processCommand (const Arts::MidiCommand& command)

inline void  RawMidiPort::processEvent (const Arts::MidiEvent& event)

inline std::string  RawMidiPort::device ()

inline void  RawMidiPort::device (const std::string& _newValue)

inline bool  RawMidiPort::input ()

inline void  RawMidiPort::input (bool _newValue)

inline bool  RawMidiPort::output ()

inline void  RawMidiPort::output (bool _newValue)

inline bool  RawMidiPort::running ()

inline void  RawMidiPort::running (bool _newValue)

inline bool  RawMidiPort::open ()

MidiChannel (class)

ObjectCache (class)

MidiReleaseHelper (class)

Synth_CAPTURE_WAV (class)

Synth_NIL (class)

Synth_DEBUG (class)

Synth_DATA (class)

Synth_ATAN_SATURATE (class)

Synth_BRICKWALL_LIMITER (class)

Synth_AUTOPANNER (class)

Synth_DELAY (class)

Synth_CDELAY (class)

Synth_FM_SOURCE (class)

Synth_TREMOLO (class)

Synth_FX_CFLANGER (class)

Synth_NOISE (class)

Synth_WAVE_TRI (class)

Synth_WAVE_SQUARE (class)

Synth_WAVE_PULSE (class)

Synth_WAVE_SOFTSAW (class)

Synth_ENVELOPE_ADSR (class)

Synth_SHELVE_CUTOFF (class)

Synth_XFADE (class)

Synth_MIDI_TEST (class)

Synth_MIDI_DEBUG (class)

Synth_FREEVERB (class)

Synth_STD_EQUALIZER (class)

Synth_RC (class)

Synth_MOOG_VCF (class)

Synth_PSCALE (class)

Synth_SEQUENCE (class)

Synth_PITCH_SHIFT (class)

Interface_MIDI_NOTE (class)

Synth_STRUCT_KILL (class)

MidiChannel_base (class)

MidiChannel_stub (class)

MidiChannel_skel (class)

ObjectCache_base (class)

ObjectCache_stub (class)

ObjectCache_skel (class)

MidiReleaseHelper_base (class)

MidiReleaseHelper_stub (class)

MidiReleaseHelper_skel (class)

inline operator  SynthModule ()

[const]

Synth_CAPTURE_WAV_base (class)

Synth_CAPTURE_WAV_stub (class)

Synth_CAPTURE_WAV_skel (class)

inline operator  SynthModule ()

[const]

Synth_NIL_base (class)

Synth_NIL_stub (class)

Synth_NIL_skel (class)

inline operator  SynthModule ()

[const]

Synth_DEBUG_base (class)

Synth_DEBUG_stub (class)

Synth_DEBUG_skel (class)

inline operator  SynthModule ()

[const]

Synth_DATA_base (class)

Synth_DATA_stub (class)

Synth_DATA_skel (class)

inline operator  SynthModule ()

[const]

Synth_ATAN_SATURATE_base (class)

Synth_ATAN_SATURATE_stub (class)

Synth_ATAN_SATURATE_skel (class)

inline operator  SynthModule ()

[const]

Synth_BRICKWALL_LIMITER_base (class)

Synth_BRICKWALL_LIMITER_stub (class)

Synth_BRICKWALL_LIMITER_skel (class)

inline operator  SynthModule ()

[const]

Synth_AUTOPANNER_base (class)

Synth_AUTOPANNER_stub (class)

Synth_AUTOPANNER_skel (class)

inline operator  SynthModule ()

[const]

Synth_DELAY_base (class)

Synth_DELAY_stub (class)

Synth_DELAY_skel (class)

inline operator  SynthModule ()

[const]

Synth_CDELAY_base (class)

Synth_CDELAY_stub (class)

Synth_CDELAY_skel (class)

inline operator  SynthModule ()

[const]

Synth_FM_SOURCE_base (class)

Synth_FM_SOURCE_stub (class)

Synth_FM_SOURCE_skel (class)

inline operator  SynthModule ()

[const]

Synth_TREMOLO_base (class)

Synth_TREMOLO_stub (class)

Synth_TREMOLO_skel (class)

inline operator  SynthModule ()

[const]

Synth_FX_CFLANGER_base (class)

Synth_FX_CFLANGER_stub (class)

Synth_FX_CFLANGER_skel (class)

inline operator  SynthModule ()

[const]

Synth_NOISE_base (class)

Synth_NOISE_stub (class)

Synth_NOISE_skel (class)

inline operator  SynthModule ()

[const]

Synth_WAVE_TRI_base (class)

Synth_WAVE_TRI_stub (class)

Synth_WAVE_TRI_skel (class)

inline operator  SynthModule ()

[const]

Synth_WAVE_SQUARE_base (class)

Synth_WAVE_SQUARE_stub (class)

Synth_WAVE_SQUARE_skel (class)

inline operator  SynthModule ()

[const]

Synth_WAVE_PULSE_base (class)

Synth_WAVE_PULSE_stub (class)

Synth_WAVE_PULSE_skel (class)

inline operator  SynthModule ()

[const]

Synth_WAVE_SOFTSAW_base (class)

Synth_WAVE_SOFTSAW_stub (class)

Synth_WAVE_SOFTSAW_skel (class)

inline operator  SynthModule ()

[const]

Synth_ENVELOPE_ADSR_base (class)

Synth_ENVELOPE_ADSR_stub (class)

Synth_ENVELOPE_ADSR_skel (class)

inline operator  SynthModule ()

[const]

Synth_SHELVE_CUTOFF_base (class)

Synth_SHELVE_CUTOFF_stub (class)

Synth_SHELVE_CUTOFF_skel (class)

inline operator  SynthModule ()

[const]

Synth_XFADE_base (class)

Synth_XFADE_stub (class)

Synth_XFADE_skel (class)

inline operator  SynthModule ()

[const]

Synth_MIDI_TEST_base (class)

Synth_MIDI_TEST_stub (class)

Synth_MIDI_TEST_skel (class)

inline operator  SynthModule ()

[const]

inline operator  MidiPort ()

[const]

Synth_MIDI_DEBUG_base (class)

Synth_MIDI_DEBUG_stub (class)

Synth_MIDI_DEBUG_skel (class)

inline operator  SynthModule ()

[const]

inline operator  MidiChannel ()

[const]

Synth_FREEVERB_base (class)

Synth_FREEVERB_stub (class)

Synth_FREEVERB_skel (class)

inline operator  StereoEffect ()

[const]

inline operator  SynthModule ()

[const]

Synth_STD_EQUALIZER_base (class)

Synth_STD_EQUALIZER_stub (class)

Synth_STD_EQUALIZER_skel (class)

inline operator  SynthModule ()

[const]

Synth_RC_base (class)

Synth_RC_stub (class)

Synth_RC_skel (class)

inline operator  SynthModule ()

[const]

Synth_MOOG_VCF_base (class)

Synth_MOOG_VCF_stub (class)

Synth_MOOG_VCF_skel (class)

inline operator  SynthModule ()

[const]

Synth_PSCALE_base (class)

Synth_PSCALE_stub (class)

Synth_PSCALE_skel (class)

inline operator  SynthModule ()

[const]

Synth_SEQUENCE_base (class)

Synth_SEQUENCE_stub (class)

Synth_SEQUENCE_skel (class)

inline operator  SynthModule ()

[const]

Synth_PITCH_SHIFT_base (class)

Synth_PITCH_SHIFT_stub (class)

Synth_PITCH_SHIFT_skel (class)

inline operator  SynthModule ()

[const]

Interface_MIDI_NOTE_base (class)

Interface_MIDI_NOTE_stub (class)

Interface_MIDI_NOTE_skel (class)

inline operator  SynthModule ()

[const]

Synth_STRUCT_KILL_base (class)

Synth_STRUCT_KILL_stub (class)

Synth_STRUCT_KILL_skel (class)

inline operator  SynthModule ()

[const]

inline Arts::TimeStamp  MidiChannel::time ()

inline void  MidiChannel::noteOnAt (const Arts::TimeStamp& time, Arts::mcopbyte channel, Arts::mcopbyte note, Arts::mcopbyte volume)

inline void  MidiChannel::noteOffAt (const Arts::TimeStamp& time, Arts::mcopbyte channel, Arts::mcopbyte note)

inline void  MidiChannel::noteOn (Arts::mcopbyte channel, Arts::mcopbyte note, Arts::mcopbyte volume)

inline void  MidiChannel::noteOff (Arts::mcopbyte channel, Arts::mcopbyte note)

inline void  ObjectCache::put (Arts::Object obj, const std::string& name)

inline Arts::Object  ObjectCache::get (const std::string& name)

inline Arts::AutoSuspendState  MidiReleaseHelper::autoSuspend ()

inline void  MidiReleaseHelper::start ()

inline void  MidiReleaseHelper::stop ()

inline void  MidiReleaseHelper::streamInit ()

inline void  MidiReleaseHelper::streamStart ()

inline void  MidiReleaseHelper::streamEnd ()

inline Arts::SynthModule  MidiReleaseHelper::voice ()

inline void  MidiReleaseHelper::voice (Arts::SynthModule _newValue)

inline std::string  MidiReleaseHelper::name ()

inline void  MidiReleaseHelper::name (const std::string& _newValue)

inline Arts::ObjectCache  MidiReleaseHelper::cache ()

inline void  MidiReleaseHelper::cache (Arts::ObjectCache _newValue)

inline bool  MidiReleaseHelper::terminate ()

inline Arts::AutoSuspendState  Synth_CAPTURE_WAV::autoSuspend ()

inline void  Synth_CAPTURE_WAV::start ()

inline void  Synth_CAPTURE_WAV::stop ()

inline void  Synth_CAPTURE_WAV::streamInit ()

inline void  Synth_CAPTURE_WAV::streamStart ()

inline void  Synth_CAPTURE_WAV::streamEnd ()

inline Arts::AutoSuspendState  Synth_NIL::autoSuspend ()

inline void  Synth_NIL::start ()

inline void  Synth_NIL::stop ()

inline void  Synth_NIL::streamInit ()

inline void  Synth_NIL::streamStart ()

inline void  Synth_NIL::streamEnd ()

inline Arts::AutoSuspendState  Synth_DEBUG::autoSuspend ()

inline void  Synth_DEBUG::start ()

inline void  Synth_DEBUG::stop ()

inline void  Synth_DEBUG::streamInit ()

inline void  Synth_DEBUG::streamStart ()

inline void  Synth_DEBUG::streamEnd ()

inline std::string  Synth_DEBUG::comment ()

inline void  Synth_DEBUG::comment (const std::string& _newValue)

inline Arts::AutoSuspendState  Synth_DATA::autoSuspend ()

inline void  Synth_DATA::start ()

inline void  Synth_DATA::stop ()

inline void  Synth_DATA::streamInit ()

inline void  Synth_DATA::streamStart ()

inline void  Synth_DATA::streamEnd ()

inline float  Synth_DATA::value ()

inline void  Synth_DATA::value (float _newValue)

inline Arts::AutoSuspendState  Synth_ATAN_SATURATE::autoSuspend ()

inline void  Synth_ATAN_SATURATE::start ()

inline void  Synth_ATAN_SATURATE::stop ()

inline void  Synth_ATAN_SATURATE::streamInit ()

inline void  Synth_ATAN_SATURATE::streamStart ()

inline void  Synth_ATAN_SATURATE::streamEnd ()

inline float  Synth_ATAN_SATURATE::inscale ()

inline void  Synth_ATAN_SATURATE::inscale (float _newValue)

inline Arts::AutoSuspendState  Synth_BRICKWALL_LIMITER::autoSuspend ()

inline void  Synth_BRICKWALL_LIMITER::start ()

inline void  Synth_BRICKWALL_LIMITER::stop ()

inline void  Synth_BRICKWALL_LIMITER::streamInit ()

inline void  Synth_BRICKWALL_LIMITER::streamStart ()

inline void  Synth_BRICKWALL_LIMITER::streamEnd ()

inline Arts::AutoSuspendState  Synth_AUTOPANNER::autoSuspend ()

inline void  Synth_AUTOPANNER::start ()

inline void  Synth_AUTOPANNER::stop ()

inline void  Synth_AUTOPANNER::streamInit ()

inline void  Synth_AUTOPANNER::streamStart ()

inline void  Synth_AUTOPANNER::streamEnd ()

inline Arts::AutoSuspendState  Synth_DELAY::autoSuspend ()

inline void  Synth_DELAY::start ()

inline void  Synth_DELAY::stop ()

inline void  Synth_DELAY::streamInit ()

inline void  Synth_DELAY::streamStart ()

inline void  Synth_DELAY::streamEnd ()

inline Arts::AutoSuspendState  Synth_CDELAY::autoSuspend ()

inline void  Synth_CDELAY::start ()

inline void  Synth_CDELAY::stop ()

inline void  Synth_CDELAY::streamInit ()

inline void  Synth_CDELAY::streamStart ()

inline void  Synth_CDELAY::streamEnd ()

inline float  Synth_CDELAY::time ()

inline void  Synth_CDELAY::time (float _newValue)

inline Arts::AutoSuspendState  Synth_FM_SOURCE::autoSuspend ()

inline void  Synth_FM_SOURCE::start ()

inline void  Synth_FM_SOURCE::stop ()

inline void  Synth_FM_SOURCE::streamInit ()

inline void  Synth_FM_SOURCE::streamStart ()

inline void  Synth_FM_SOURCE::streamEnd ()

inline Arts::AutoSuspendState  Synth_TREMOLO::autoSuspend ()

inline void  Synth_TREMOLO::start ()

inline void  Synth_TREMOLO::stop ()

inline void  Synth_TREMOLO::streamInit ()

inline void  Synth_TREMOLO::streamStart ()

inline void  Synth_TREMOLO::streamEnd ()

inline Arts::AutoSuspendState  Synth_FX_CFLANGER::autoSuspend ()

inline void  Synth_FX_CFLANGER::start ()

inline void  Synth_FX_CFLANGER::stop ()

inline void  Synth_FX_CFLANGER::streamInit ()

inline void  Synth_FX_CFLANGER::streamStart ()

inline void  Synth_FX_CFLANGER::streamEnd ()

inline float  Synth_FX_CFLANGER::mintime ()

inline void  Synth_FX_CFLANGER::mintime (float _newValue)

inline float  Synth_FX_CFLANGER::maxtime ()

inline void  Synth_FX_CFLANGER::maxtime (float _newValue)

inline Arts::AutoSuspendState  Synth_NOISE::autoSuspend ()

inline void  Synth_NOISE::start ()

inline void  Synth_NOISE::stop ()

inline void  Synth_NOISE::streamInit ()

inline void  Synth_NOISE::streamStart ()

inline void  Synth_NOISE::streamEnd ()

inline Arts::AutoSuspendState  Synth_WAVE_TRI::autoSuspend ()

inline void  Synth_WAVE_TRI::start ()

inline void  Synth_WAVE_TRI::stop ()

inline void  Synth_WAVE_TRI::streamInit ()

inline void  Synth_WAVE_TRI::streamStart ()

inline void  Synth_WAVE_TRI::streamEnd ()

inline Arts::AutoSuspendState  Synth_WAVE_SQUARE::autoSuspend ()

inline void  Synth_WAVE_SQUARE::start ()

inline void  Synth_WAVE_SQUARE::stop ()

inline void  Synth_WAVE_SQUARE::streamInit ()

inline void  Synth_WAVE_SQUARE::streamStart ()

inline void  Synth_WAVE_SQUARE::streamEnd ()

inline Arts::AutoSuspendState  Synth_WAVE_PULSE::autoSuspend ()

inline void  Synth_WAVE_PULSE::start ()

inline void  Synth_WAVE_PULSE::stop ()

inline void  Synth_WAVE_PULSE::streamInit ()

inline void  Synth_WAVE_PULSE::streamStart ()

inline void  Synth_WAVE_PULSE::streamEnd ()

inline float  Synth_WAVE_PULSE::dutycycle ()

inline void  Synth_WAVE_PULSE::dutycycle (float _newValue)

inline Arts::AutoSuspendState  Synth_WAVE_SOFTSAW::autoSuspend ()

inline void  Synth_WAVE_SOFTSAW::start ()

inline void  Synth_WAVE_SOFTSAW::stop ()

inline void  Synth_WAVE_SOFTSAW::streamInit ()

inline void  Synth_WAVE_SOFTSAW::streamStart ()

inline void  Synth_WAVE_SOFTSAW::streamEnd ()

inline Arts::AutoSuspendState  Synth_ENVELOPE_ADSR::autoSuspend ()

inline void  Synth_ENVELOPE_ADSR::start ()

inline void  Synth_ENVELOPE_ADSR::stop ()

inline void  Synth_ENVELOPE_ADSR::streamInit ()

inline void  Synth_ENVELOPE_ADSR::streamStart ()

inline void  Synth_ENVELOPE_ADSR::streamEnd ()

inline Arts::AutoSuspendState  Synth_SHELVE_CUTOFF::autoSuspend ()

inline void  Synth_SHELVE_CUTOFF::start ()

inline void  Synth_SHELVE_CUTOFF::stop ()

inline void  Synth_SHELVE_CUTOFF::streamInit ()

inline void  Synth_SHELVE_CUTOFF::streamStart ()

inline void  Synth_SHELVE_CUTOFF::streamEnd ()

inline Arts::AutoSuspendState  Synth_XFADE::autoSuspend ()

inline void  Synth_XFADE::start ()

inline void  Synth_XFADE::stop ()

inline void  Synth_XFADE::streamInit ()

inline void  Synth_XFADE::streamStart ()

inline void  Synth_XFADE::streamEnd ()

inline Arts::AutoSuspendState  Synth_MIDI_TEST::autoSuspend ()

inline void  Synth_MIDI_TEST::start ()

inline void  Synth_MIDI_TEST::stop ()

inline void  Synth_MIDI_TEST::streamInit ()

inline void  Synth_MIDI_TEST::streamStart ()

inline void  Synth_MIDI_TEST::streamEnd ()

inline Arts::TimeStamp  Synth_MIDI_TEST::time ()

inline void  Synth_MIDI_TEST::processCommand (const Arts::MidiCommand& command)

inline void  Synth_MIDI_TEST::processEvent (const Arts::MidiEvent& event)

inline std::string  Synth_MIDI_TEST::filename ()

inline void  Synth_MIDI_TEST::filename (const std::string& _newValue)

inline Arts::AutoSuspendState  Synth_MIDI_DEBUG::autoSuspend ()

inline void  Synth_MIDI_DEBUG::start ()

inline void  Synth_MIDI_DEBUG::stop ()

inline void  Synth_MIDI_DEBUG::streamInit ()

inline void  Synth_MIDI_DEBUG::streamStart ()

inline void  Synth_MIDI_DEBUG::streamEnd ()

inline Arts::TimeStamp  Synth_MIDI_DEBUG::time ()

inline void  Synth_MIDI_DEBUG::noteOnAt (const Arts::TimeStamp& time, Arts::mcopbyte channel, Arts::mcopbyte note, Arts::mcopbyte volume)

inline void  Synth_MIDI_DEBUG::noteOffAt (const Arts::TimeStamp& time, Arts::mcopbyte channel, Arts::mcopbyte note)

inline void  Synth_MIDI_DEBUG::noteOn (Arts::mcopbyte channel, Arts::mcopbyte note, Arts::mcopbyte volume)

inline void  Synth_MIDI_DEBUG::noteOff (Arts::mcopbyte channel, Arts::mcopbyte note)

inline Arts::AutoSuspendState  Synth_FREEVERB::autoSuspend ()

inline void  Synth_FREEVERB::start ()

inline void  Synth_FREEVERB::stop ()

inline void  Synth_FREEVERB::streamInit ()

inline void  Synth_FREEVERB::streamStart ()

inline void  Synth_FREEVERB::streamEnd ()

inline float  Synth_FREEVERB::roomsize ()

inline void  Synth_FREEVERB::roomsize (float _newValue)

inline float  Synth_FREEVERB::damp ()

inline void  Synth_FREEVERB::damp (float _newValue)

inline float  Synth_FREEVERB::wet ()

inline void  Synth_FREEVERB::wet (float _newValue)

inline float  Synth_FREEVERB::dry ()

inline void  Synth_FREEVERB::dry (float _newValue)

inline float  Synth_FREEVERB::width ()

inline void  Synth_FREEVERB::width (float _newValue)

inline float  Synth_FREEVERB::mode ()

inline void  Synth_FREEVERB::mode (float _newValue)

inline Arts::AutoSuspendState  Synth_STD_EQUALIZER::autoSuspend ()

inline void  Synth_STD_EQUALIZER::start ()

inline void  Synth_STD_EQUALIZER::stop ()

inline void  Synth_STD_EQUALIZER::streamInit ()

inline void  Synth_STD_EQUALIZER::streamStart ()

inline void  Synth_STD_EQUALIZER::streamEnd ()

inline float  Synth_STD_EQUALIZER::low ()

inline void  Synth_STD_EQUALIZER::low (float _newValue)

inline float  Synth_STD_EQUALIZER::mid ()

inline void  Synth_STD_EQUALIZER::mid (float _newValue)

inline float  Synth_STD_EQUALIZER::high ()

inline void  Synth_STD_EQUALIZER::high (float _newValue)

inline float  Synth_STD_EQUALIZER::frequency ()

inline void  Synth_STD_EQUALIZER::frequency (float _newValue)

inline float  Synth_STD_EQUALIZER::q ()

inline void  Synth_STD_EQUALIZER::q (float _newValue)

inline Arts::AutoSuspendState  Synth_RC::autoSuspend ()

inline void  Synth_RC::start ()

inline void  Synth_RC::stop ()

inline void  Synth_RC::streamInit ()

inline void  Synth_RC::streamStart ()

inline void  Synth_RC::streamEnd ()

inline float  Synth_RC::b ()

inline void  Synth_RC::b (float _newValue)

inline float  Synth_RC::f ()

inline void  Synth_RC::f (float _newValue)

inline Arts::AutoSuspendState  Synth_MOOG_VCF::autoSuspend ()

inline void  Synth_MOOG_VCF::start ()

inline void  Synth_MOOG_VCF::stop ()

inline void  Synth_MOOG_VCF::streamInit ()

inline void  Synth_MOOG_VCF::streamStart ()

inline void  Synth_MOOG_VCF::streamEnd ()

inline float  Synth_MOOG_VCF::frequency ()

inline void  Synth_MOOG_VCF::frequency (float _newValue)

inline float  Synth_MOOG_VCF::resonance ()

inline void  Synth_MOOG_VCF::resonance (float _newValue)

inline Arts::AutoSuspendState  Synth_PSCALE::autoSuspend ()

inline void  Synth_PSCALE::start ()

inline void  Synth_PSCALE::stop ()

inline void  Synth_PSCALE::streamInit ()

inline void  Synth_PSCALE::streamStart ()

inline void  Synth_PSCALE::streamEnd ()

inline float  Synth_PSCALE::top ()

inline void  Synth_PSCALE::top (float _newValue)

inline Arts::AutoSuspendState  Synth_SEQUENCE::autoSuspend ()

inline void  Synth_SEQUENCE::start ()

inline void  Synth_SEQUENCE::stop ()

inline void  Synth_SEQUENCE::streamInit ()

inline void  Synth_SEQUENCE::streamStart ()

inline void  Synth_SEQUENCE::streamEnd ()

inline float  Synth_SEQUENCE::speed ()

inline void  Synth_SEQUENCE::speed (float _newValue)

inline std::string  Synth_SEQUENCE::seq ()

inline void  Synth_SEQUENCE::seq (const std::string& _newValue)

inline Arts::AutoSuspendState  Synth_PITCH_SHIFT::autoSuspend ()

inline void  Synth_PITCH_SHIFT::start ()

inline void  Synth_PITCH_SHIFT::stop ()

inline void  Synth_PITCH_SHIFT::streamInit ()

inline void  Synth_PITCH_SHIFT::streamStart ()

inline void  Synth_PITCH_SHIFT::streamEnd ()

inline float  Synth_PITCH_SHIFT::speed ()

inline void  Synth_PITCH_SHIFT::speed (float _newValue)

inline float  Synth_PITCH_SHIFT::frequency ()

inline void  Synth_PITCH_SHIFT::frequency (float _newValue)

inline Arts::AutoSuspendState  Interface_MIDI_NOTE::autoSuspend ()

inline void  Interface_MIDI_NOTE::start ()

inline void  Interface_MIDI_NOTE::stop ()

inline void  Interface_MIDI_NOTE::streamInit ()

inline void  Interface_MIDI_NOTE::streamStart ()

inline void  Interface_MIDI_NOTE::streamEnd ()

inline Arts::AutoSuspendState  Synth_STRUCT_KILL::autoSuspend ()

inline void  Synth_STRUCT_KILL::start ()

inline void  Synth_STRUCT_KILL::stop ()

inline void  Synth_STRUCT_KILL::streamInit ()

inline void  Synth_STRUCT_KILL::streamStart ()

inline void  Synth_STRUCT_KILL::streamEnd ()

Widget (class)

Button (class)

Poti (class)

Widget_base (class)

Widget_stub (class)

Widget_skel (class)

Button_base (class)

Button_stub (class)

Button_skel (class)

inline operator  Widget ()

[const]

Poti_base (class)

Poti_stub (class)

Poti_skel (class)

inline operator  Widget ()

[const]

inline long  Widget::widgetID ()

inline Arts::Widget  Widget::parent ()

inline void  Widget::parent (Arts::Widget _newValue)

inline long  Widget::x ()

inline void  Widget::x (long _newValue)

inline long  Widget::y ()

inline void  Widget::y (long _newValue)

inline long  Widget::width ()

inline void  Widget::width (long _newValue)

inline long  Widget::height ()

inline void  Widget::height (long _newValue)

inline bool  Widget::visible ()

inline void  Widget::visible (bool _newValue)

inline void  Widget::show ()

inline void  Widget::hide ()

inline long  Button::widgetID ()

inline Arts::Widget  Button::parent ()

inline void  Button::parent (Arts::Widget _newValue)

inline long  Button::x ()

inline void  Button::x (long _newValue)

inline long  Button::y ()

inline void  Button::y (long _newValue)

inline long  Button::width ()

inline void  Button::width (long _newValue)

inline long  Button::height ()

inline void  Button::height (long _newValue)

inline bool  Button::visible ()

inline void  Button::visible (bool _newValue)

inline void  Button::show ()

inline void  Button::hide ()

inline std::string  Button::text ()

inline void  Button::text (const std::string& _newValue)

inline long  Poti::widgetID ()

inline Arts::Widget  Poti::parent ()

inline void  Poti::parent (Arts::Widget _newValue)

inline long  Poti::x ()

inline void  Poti::x (long _newValue)

inline long  Poti::y ()

inline void  Poti::y (long _newValue)

inline long  Poti::width ()

inline void  Poti::width (long _newValue)

inline long  Poti::height ()

inline void  Poti::height (long _newValue)

inline bool  Poti::visible ()

inline void  Poti::visible (bool _newValue)

inline void  Poti::show ()

inline void  Poti::hide ()

inline std::string  Poti::text ()

inline void  Poti::text (const std::string& _newValue)

inline std::string  Poti::color ()

inline void  Poti::color (const std::string& _newValue)

inline float  Poti::min ()

inline void  Poti::min (float _newValue)

inline float  Poti::max ()

inline void  Poti::max (float _newValue)

inline float  Poti::value ()

inline void  Poti::value (float _newValue)

Refiller (class)

Resampler (class)

GIOManager (class)

GIOManager performs MCOP I/O inside the Glib event loop. This way, you will be able to receive requests and notifications inside Glib application. The usual way to set it up is: 


 GMainLoop *main_loop = g_main_new(FALSE);  // as usual

 Arts::GIOManager iomanager;
 Arts::Dispatcher dispatcher(&iomanager);

 g_main_run(main_loop);                     // as usual

Thread_impl (class)

Base class for platform specific thread code

Mutex_impl (class)

Base class for platform specific mutex code

Thread (class)

A thread of execution

Example for implementing a thread: 


 class Counter : public Arts::Thread 
 {
 public:
   void run() {
     for(int i = 0;i < 10;i++)
     {
       printf("%d\n",i+1);
       sleep(1);
     }
   }
 };            // start the thread with Counter c; c.start();

SystemThreads (class)

Encapsulates the operating system threading facilities

Mutex (class)

A mutex

To protect a critical section, you can use a mutex, which will ensure that only one thread at a time can lock it. Here is an example for a thread-safe random number generator: 


 class RandomGenerator {
   Arts::Mutex mutex;
   long seed;
 public:
   long get() {
     mutex.lock();
     // do complicated calculation with seed here
     mutex.unlock();
     return seed;
   }
 };

inline operator  PlayObject ()

[const]

inline operator  PlayObject_private ()

[const]

Generated by: stefan@stefan on Sat Feb 24 19:11:23 2001, using kdoc 2.0a47.