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

mcopbyte

Buffer (class)

Buffer

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

readTypeSeq

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

writeTypeSeq

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

writeObject

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

readObject

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

readObjectSeq

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

writeObjectSeq

typedef unsigned char mcopbyte

mcopbyte

Connection (class)

Connection

enum HeaderMagic {MCOP_MAGIC = 1296256848}

HeaderMagic

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

MessageType

enum MethodType {methodOneway = 1, methodTwoway = 2}

MethodType

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

AttributeType

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

TypeIdentification

Header (class)

Header

Invocation (class)

Invocation

OnewayInvocation (class)

OnewayInvocation

ServerHello (class)

ServerHello

ClientHello (class)

ClientHello

AuthAccept (class)

AuthAccept

ObjectReference (class)

ObjectReference

ParamDef (class)

ParamDef

MethodDef (class)

MethodDef

AttributeDef (class)

AttributeDef

InterfaceDef (class)

InterfaceDef

TypeComponent (class)

TypeComponent

TypeDef (class)

TypeDef

EnumComponent (class)

EnumComponent

EnumDef (class)

EnumDef

ModuleDef (class)

ModuleDef

Any (class)

Any

TraderEntry (class)

TraderEntry

InterfaceRepo (class)

InterfaceRepo

InterfaceRepoV2 (class)

InterfaceRepoV2

FlowSystemSender (class)

FlowSystemSender

FlowSystemReceiver (class)

FlowSystemReceiver

FlowSystem (class)

FlowSystem

GlobalComm (class)

GlobalComm

TmpGlobalComm (class)

TmpGlobalComm

TraderOffer (class)

TraderOffer

TraderQuery (class)

TraderQuery

Loader (class)

Loader

InterfaceRepo_base (class)

InterfaceRepo_base

InterfaceRepo_stub (class)

InterfaceRepo_stub

InterfaceRepo_skel (class)

InterfaceRepo_skel

InterfaceRepoV2_base (class)

InterfaceRepoV2_base

InterfaceRepoV2_stub (class)

InterfaceRepoV2_stub

InterfaceRepoV2_skel (class)

InterfaceRepoV2_skel

inline operator  InterfaceRepo ()

InterfaceRepo

[const]

FlowSystemSender_base (class)

FlowSystemSender_base

FlowSystemSender_stub (class)

FlowSystemSender_stub

FlowSystemSender_skel (class)

FlowSystemSender_skel

FlowSystemReceiver_base (class)

FlowSystemReceiver_base

FlowSystemReceiver_stub (class)

FlowSystemReceiver_stub

FlowSystemReceiver_skel (class)

FlowSystemReceiver_skel

FlowSystem_base (class)

FlowSystem_base

FlowSystem_stub (class)

FlowSystem_stub

FlowSystem_skel (class)

FlowSystem_skel

GlobalComm_base (class)

GlobalComm_base

GlobalComm_stub (class)

GlobalComm_stub

GlobalComm_skel (class)

GlobalComm_skel

TmpGlobalComm_base (class)

TmpGlobalComm_base

TmpGlobalComm_stub (class)

TmpGlobalComm_stub

TmpGlobalComm_skel (class)

TmpGlobalComm_skel

inline operator  GlobalComm ()

GlobalComm

[const]

TraderOffer_base (class)

TraderOffer_base

TraderOffer_stub (class)

TraderOffer_stub

TraderOffer_skel (class)

TraderOffer_skel

TraderQuery_base (class)

TraderQuery_base

TraderQuery_stub (class)

TraderQuery_stub

TraderQuery_skel (class)

TraderQuery_skel

Loader_base (class)

Loader_base

Loader_stub (class)

Loader_stub

Loader_skel (class)

Loader_skel

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

InterfaceRepo::insertModule

inline void  InterfaceRepo::removeModule (long moduleID)

InterfaceRepo::removeModule

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

InterfaceRepo::queryInterface

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

InterfaceRepo::queryType

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

InterfaceRepo::queryEnum

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

InterfaceRepo::queryChildren

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

InterfaceRepo::queryInterfaces

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

InterfaceRepo::queryTypes

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

InterfaceRepo::queryEnums

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

InterfaceRepoV2::insertModule

inline void  InterfaceRepoV2::removeModule (long moduleID)

InterfaceRepoV2::removeModule

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

InterfaceRepoV2::queryInterface

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

InterfaceRepoV2::queryType

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

InterfaceRepoV2::queryEnum

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

InterfaceRepoV2::queryChildren

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

InterfaceRepoV2::queryInterfaces

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

InterfaceRepoV2::queryTypes

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

InterfaceRepoV2::queryEnums

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

InterfaceRepoV2::identifyType

inline void  FlowSystemSender::processed ()

FlowSystemSender::processed

inline void  FlowSystemSender::disconnect ()

FlowSystemSender::disconnect

inline long  FlowSystemReceiver::receiveHandlerID ()

FlowSystemReceiver::receiveHandlerID

inline void  FlowSystemReceiver::disconnect ()

FlowSystemReceiver::disconnect

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

FlowSystem::startObject

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

FlowSystem::stopObject

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

FlowSystem::connectObject

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

FlowSystem::disconnectObject

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

FlowSystem::queryFlags

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

FlowSystem::setFloatValue

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

FlowSystem::createReceiver

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

GlobalComm::put

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

GlobalComm::get

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

GlobalComm::erase

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

TmpGlobalComm::put

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

TmpGlobalComm::get

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

TmpGlobalComm::erase

inline std::string  TraderOffer::interfaceName ()

TraderOffer::interfaceName

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

TraderOffer::getProperty

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

TraderQuery::supports

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

TraderQuery::query

inline std::string  Loader::dataVersion ()

Loader::dataVersion

inline std::vector<Arts::TraderEntry> *  Loader::traderEntries ()

Loader::traderEntries

inline std::vector<Arts::ModuleDef> *  Loader::modules ()

Loader::modules

inline Arts::Object  Loader::loadObject (Arts::TraderOffer offer)

Loader::loadObject

FlowSystem_impl (class)

FlowSystem_impl

ObjectManager (class)

ObjectManager

Object_skel (class)

Object_skel

ReferenceClean (class)

ReferenceClean

DelayedReturn (class)

DelayedReturn

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)

(*mcop_sighandler)

Dispatcher (class)

Dispatcher

Factory (class)

Factory

Object_stub (class)

Object_stub

RemoteScheduleNode (class)

RemoteScheduleNode

ScheduleNode (class)

ScheduleNode

IDLFileReg (class)

IDLFileReg

InterfaceRepo_impl (class)

InterfaceRepo_impl

IOType (struct)

IOType

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

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.

See also: IOManager

IOWatchFD (class)

IOWatchFD

TimeNotify (class)

TimeNotify

TimeNotify is the base class you can derive from to receive timer callbacks. You will need to call the addTimer function of the IOManager to start watching a filedescriptor.

See also: IOManager

TimeWatcher (class)

TimeWatcher

IOManager (class)

IOManager

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

StdIOManager (class)

StdIOManager

MCOPUtils (class)

MCOPUtils

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

(*DispatchFunction)

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

(*OnewayDispatchFunction)

typedef void  (*DynamicDispatchFunction) (void *object, long methodID, Buffer *request, Buffer *result)

(*DynamicDispatchFunction)

WeakReferenceBase (class)

WeakReferenceBase

Object (class)

Object

DynamicSkeletonBase (class)

DynamicSkeletonBase

Object_base (class)

Object_base

AnyConstRef (class)

AnyConstRef

Pool (class)

Pool

SocketConnection (class)

SocketConnection

StartupClass (class)

StartupClass

StartupManager (class)

StartupManager

TCPConnection (class)

TCPConnection

TCPServer (class)

TCPServer

Type (class)

Type

Base class for the IDL mapping of struct-like types

UnixConnection (class)

UnixConnection

UnixServer (class)

UnixServer

GenericDataChannel (class)

GenericDataChannel

GenericDataPacket (class)

GenericDataPacket

DataPacket (class)

DataPacket

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

RawDataPacket (class)

RawDataPacket

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

FloatDataPacket (class)

FloatDataPacket

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

ByteDataPacket (class)

ByteDataPacket

GenericAsyncStream (class)

GenericAsyncStream

AsyncStream (class)

AsyncStream

FloatAsyncStream (class)

FloatAsyncStream

ByteAsyncStream (class)

ByteAsyncStream

Notification (struct)

Notification

typedef void  (*NotificationDestroyFunction) (const Notification& n)

(*NotificationDestroyFunction)

NotificationClient (class)

NotificationClient

NotificationManager (class)

NotificationManager

ExtensionLoader (class)

ExtensionLoader

MCOPConfig (class)

MCOPConfig

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

connect

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

connect

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

connect

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

connect

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

disconnect

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

disconnect

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

disconnect

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

disconnect

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

setValue

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

setValue

Reference (class)

Reference

SubClass (class)

SubClass

DynamicCast (class)

DynamicCast

WeakReference (class)

WeakReference

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)

DynamicRequest

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)

AnyRefBase

AnyRef (class)

AnyRef

Debug (class)

Debug

DynamicSkeleton (class)

DynamicSkeleton

DynamicSkeleton is used to dynamically implement an interface (i.e. without static type bindings as generated by the MCOP idl compiler.

You will always implement a mixed version: mcopidl generated skeletons up to a certain point, and above this, dynamically implemented interfaces. So you'll inherit DynamicSkeleton<Static_skel> and give the interface you want to implement dynamically as argument. Suppose your idl file looks like


 interface A { void a(); };
 interface B : A { void b(); };

And you want to implement interface A "classic" (i.e. with mcopidl generated virtual void a()) and interface B "dynamic", you would do


 typedef Arts::DynamicSkeleton<A_skel> A_dskel;   // convenient with typedef

 class B_impl : public A_dskel {
 public:
   B_impl() : A_dskel("B") {  // we dynamically implement the B interface
   }
   void a() { // through A_skel
     arts_info("a called");
   }
   void process(long methodID, Arts::Buffer *request, Arts::Buffer *result)
   {
	   const Arts::MethodDef& methodDef = getMethodDef(methodID);
	 
	   if(methodDef.name == "b")
	     arts_info("b called!");
	   else
	     arts_fatal("Unknown method '%s' called");
	 }
 };

Mutex_impl (class)

Mutex_impl

Base class for platform specific mutex code

Thread_impl (class)

Thread_impl

Base class for platform specific thread code

ThreadCondition_impl (class)

ThreadCondition_impl

Base class for platform specific thread condition code

Thread (class)

Thread

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)

SystemThreads

Encapsulates the operating system threading facilities

Mutex (class)

Mutex

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;
   }
 };

ThreadCondition (class)

ThreadCondition

A thread condition

Thread conditions are used to let a different thread know that a certain condition might have changed. For instance, if you have a thread that waits until a counter exceeds a limit, the thread would look like this:


 class WaitCounter : public Arts::Thread 
 {
   int counter;
   Arts::Mutex mutex;
   Arts::ThreadCondition cond;
 
 public:
   WaitCounter() : counter(0) {}

   void run() {  // run will terminate once the counter reaches 20
     mutex.lock();
     while(counter < 20)
       cond.wait(mutex);
     mutex.unlock();
   }

   void inc() {  // inc will increment the counter and indicate the change
     mutex.lock();
     counter++;
     cond.wakeOne();
     mutex.unlock();
   }
 };

DirManager (class)

DirManager

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

AutoSuspendState

enum AudioManagerDirection {amPlay = 0, amRecord = 1}

AudioManagerDirection

AudioManagerInfo (class)

AudioManagerInfo

SynthModule (class)

SynthModule

Synth_PLAY (class)

Synth_PLAY

Synth_RECORD (class)

Synth_RECORD

Synth_FREQUENCY (class)

Synth_FREQUENCY

Synth_WAVE_SIN (class)

Synth_WAVE_SIN

Synth_MULTI_ADD (class)

Synth_MULTI_ADD

Synth_ADD (class)

Synth_ADD

Synth_MUL (class)

Synth_MUL

Synth_PLAY_WAV (class)

Synth_PLAY_WAV

Synth_BUS_UPLINK (class)

Synth_BUS_UPLINK

Synth_BUS_DOWNLINK (class)

Synth_BUS_DOWNLINK

ByteStreamToAudio (class)

ByteStreamToAudio

StereoEffect (class)

StereoEffect

StereoVolumeControl (class)

StereoVolumeControl

StereoFFTScope (class)

StereoFFTScope

StereoEffectStack (class)

StereoEffectStack

AudioManagerClient (class)

AudioManagerClient

AudioManager (class)

AudioManager

Synth_AMAN_PLAY (class)

Synth_AMAN_PLAY

Synth_AMAN_RECORD (class)

Synth_AMAN_RECORD

SynthModule_base (class)

SynthModule_base

SynthModule_stub (class)

SynthModule_stub

SynthModule_skel (class)

SynthModule_skel

Synth_PLAY_base (class)

Synth_PLAY_base

Synth_PLAY_stub (class)

Synth_PLAY_stub

Synth_PLAY_skel (class)

Synth_PLAY_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_RECORD_base (class)

Synth_RECORD_base

Synth_RECORD_stub (class)

Synth_RECORD_stub

Synth_RECORD_skel (class)

Synth_RECORD_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_FREQUENCY_base (class)

Synth_FREQUENCY_base

Synth_FREQUENCY_stub (class)

Synth_FREQUENCY_stub

Synth_FREQUENCY_skel (class)

Synth_FREQUENCY_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_WAVE_SIN_base (class)

Synth_WAVE_SIN_base

Synth_WAVE_SIN_stub (class)

Synth_WAVE_SIN_stub

Synth_WAVE_SIN_skel (class)

Synth_WAVE_SIN_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_MULTI_ADD_base (class)

Synth_MULTI_ADD_base

Synth_MULTI_ADD_stub (class)

Synth_MULTI_ADD_stub

Synth_MULTI_ADD_skel (class)

Synth_MULTI_ADD_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_ADD_base (class)

Synth_ADD_base

Synth_ADD_stub (class)

Synth_ADD_stub

Synth_ADD_skel (class)

Synth_ADD_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_MUL_base (class)

Synth_MUL_base

Synth_MUL_stub (class)

Synth_MUL_stub

Synth_MUL_skel (class)

Synth_MUL_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_PLAY_WAV_base (class)

Synth_PLAY_WAV_base

Synth_PLAY_WAV_stub (class)

Synth_PLAY_WAV_stub

Synth_PLAY_WAV_skel (class)

Synth_PLAY_WAV_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_BUS_UPLINK_base (class)

Synth_BUS_UPLINK_base

Synth_BUS_UPLINK_stub (class)

Synth_BUS_UPLINK_stub

Synth_BUS_UPLINK_skel (class)

Synth_BUS_UPLINK_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_BUS_DOWNLINK_base (class)

Synth_BUS_DOWNLINK_base

Synth_BUS_DOWNLINK_stub (class)

Synth_BUS_DOWNLINK_stub

Synth_BUS_DOWNLINK_skel (class)

Synth_BUS_DOWNLINK_skel

inline operator  SynthModule ()

SynthModule

[const]

ByteStreamToAudio_base (class)

ByteStreamToAudio_base

ByteStreamToAudio_stub (class)

ByteStreamToAudio_stub

ByteStreamToAudio_skel (class)

ByteStreamToAudio_skel

inline operator  SynthModule ()

SynthModule

[const]

StereoEffect_base (class)

StereoEffect_base

StereoEffect_stub (class)

StereoEffect_stub

StereoEffect_skel (class)

StereoEffect_skel

inline operator  SynthModule ()

SynthModule

[const]

StereoVolumeControl_base (class)

StereoVolumeControl_base

StereoVolumeControl_stub (class)

StereoVolumeControl_stub

StereoVolumeControl_skel (class)

StereoVolumeControl_skel

inline operator  StereoEffect ()

StereoEffect

[const]

inline operator  SynthModule ()

SynthModule

[const]

StereoFFTScope_base (class)

StereoFFTScope_base

StereoFFTScope_stub (class)

StereoFFTScope_stub

StereoFFTScope_skel (class)

StereoFFTScope_skel

inline operator  StereoEffect ()

StereoEffect

[const]

inline operator  SynthModule ()

SynthModule

[const]

StereoEffectStack_base (class)

StereoEffectStack_base

StereoEffectStack_stub (class)

StereoEffectStack_stub

StereoEffectStack_skel (class)

StereoEffectStack_skel

inline operator  StereoEffect ()

StereoEffect

[const]

inline operator  SynthModule ()

SynthModule

[const]

AudioManagerClient_base (class)

AudioManagerClient_base

AudioManagerClient_stub (class)

AudioManagerClient_stub

AudioManagerClient_skel (class)

AudioManagerClient_skel

AudioManager_base (class)

AudioManager_base

AudioManager_stub (class)

AudioManager_stub

AudioManager_skel (class)

AudioManager_skel

Synth_AMAN_PLAY_base (class)

Synth_AMAN_PLAY_base

Synth_AMAN_PLAY_stub (class)

Synth_AMAN_PLAY_stub

Synth_AMAN_PLAY_skel (class)

Synth_AMAN_PLAY_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_AMAN_RECORD_base (class)

Synth_AMAN_RECORD_base

Synth_AMAN_RECORD_stub (class)

Synth_AMAN_RECORD_stub

Synth_AMAN_RECORD_skel (class)

Synth_AMAN_RECORD_skel

inline operator  SynthModule ()

SynthModule

[const]

inline Arts::AutoSuspendState  SynthModule::autoSuspend ()

SynthModule::autoSuspend

inline void  SynthModule::start ()

SynthModule::start

inline void  SynthModule::stop ()

SynthModule::stop

inline void  SynthModule::streamInit ()

SynthModule::streamInit

inline void  SynthModule::streamStart ()

SynthModule::streamStart

inline void  SynthModule::streamEnd ()

SynthModule::streamEnd

inline Arts::AutoSuspendState  Synth_PLAY::autoSuspend ()

Synth_PLAY::autoSuspend

inline void  Synth_PLAY::start ()

Synth_PLAY::start

inline void  Synth_PLAY::stop ()

Synth_PLAY::stop

inline void  Synth_PLAY::streamInit ()

Synth_PLAY::streamInit

inline void  Synth_PLAY::streamStart ()

Synth_PLAY::streamStart

inline void  Synth_PLAY::streamEnd ()

Synth_PLAY::streamEnd

inline Arts::AutoSuspendState  Synth_RECORD::autoSuspend ()

Synth_RECORD::autoSuspend

inline void  Synth_RECORD::start ()

Synth_RECORD::start

inline void  Synth_RECORD::stop ()

Synth_RECORD::stop

inline void  Synth_RECORD::streamInit ()

Synth_RECORD::streamInit

inline void  Synth_RECORD::streamStart ()

Synth_RECORD::streamStart

inline void  Synth_RECORD::streamEnd ()

Synth_RECORD::streamEnd

inline Arts::AutoSuspendState  Synth_FREQUENCY::autoSuspend ()

Synth_FREQUENCY::autoSuspend

inline void  Synth_FREQUENCY::start ()

Synth_FREQUENCY::start

inline void  Synth_FREQUENCY::stop ()

Synth_FREQUENCY::stop

inline void  Synth_FREQUENCY::streamInit ()

Synth_FREQUENCY::streamInit

inline void  Synth_FREQUENCY::streamStart ()

Synth_FREQUENCY::streamStart

inline void  Synth_FREQUENCY::streamEnd ()

Synth_FREQUENCY::streamEnd

inline Arts::AutoSuspendState  Synth_WAVE_SIN::autoSuspend ()

Synth_WAVE_SIN::autoSuspend

inline void  Synth_WAVE_SIN::start ()

Synth_WAVE_SIN::start

inline void  Synth_WAVE_SIN::stop ()

Synth_WAVE_SIN::stop

inline void  Synth_WAVE_SIN::streamInit ()

Synth_WAVE_SIN::streamInit

inline void  Synth_WAVE_SIN::streamStart ()

Synth_WAVE_SIN::streamStart

inline void  Synth_WAVE_SIN::streamEnd ()

Synth_WAVE_SIN::streamEnd

inline Arts::AutoSuspendState  Synth_MULTI_ADD::autoSuspend ()

Synth_MULTI_ADD::autoSuspend

inline void  Synth_MULTI_ADD::start ()

Synth_MULTI_ADD::start

inline void  Synth_MULTI_ADD::stop ()

Synth_MULTI_ADD::stop

inline void  Synth_MULTI_ADD::streamInit ()

Synth_MULTI_ADD::streamInit

inline void  Synth_MULTI_ADD::streamStart ()

Synth_MULTI_ADD::streamStart

inline void  Synth_MULTI_ADD::streamEnd ()

Synth_MULTI_ADD::streamEnd

inline Arts::AutoSuspendState  Synth_ADD::autoSuspend ()

Synth_ADD::autoSuspend

inline void  Synth_ADD::start ()

Synth_ADD::start

inline void  Synth_ADD::stop ()

Synth_ADD::stop

inline void  Synth_ADD::streamInit ()

Synth_ADD::streamInit

inline void  Synth_ADD::streamStart ()

Synth_ADD::streamStart

inline void  Synth_ADD::streamEnd ()

Synth_ADD::streamEnd

inline Arts::AutoSuspendState  Synth_MUL::autoSuspend ()

Synth_MUL::autoSuspend

inline void  Synth_MUL::start ()

Synth_MUL::start

inline void  Synth_MUL::stop ()

Synth_MUL::stop

inline void  Synth_MUL::streamInit ()

Synth_MUL::streamInit

inline void  Synth_MUL::streamStart ()

Synth_MUL::streamStart

inline void  Synth_MUL::streamEnd ()

Synth_MUL::streamEnd

inline Arts::AutoSuspendState  Synth_PLAY_WAV::autoSuspend ()

Synth_PLAY_WAV::autoSuspend

inline void  Synth_PLAY_WAV::start ()

Synth_PLAY_WAV::start

inline void  Synth_PLAY_WAV::stop ()

Synth_PLAY_WAV::stop

inline void  Synth_PLAY_WAV::streamInit ()

Synth_PLAY_WAV::streamInit

inline void  Synth_PLAY_WAV::streamStart ()

Synth_PLAY_WAV::streamStart

inline void  Synth_PLAY_WAV::streamEnd ()

Synth_PLAY_WAV::streamEnd

inline float  Synth_PLAY_WAV::speed ()

Synth_PLAY_WAV::speed

inline void  Synth_PLAY_WAV::speed (float _newValue)

Synth_PLAY_WAV::speed

inline std::string  Synth_PLAY_WAV::filename ()

Synth_PLAY_WAV::filename

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

Synth_PLAY_WAV::filename

inline bool  Synth_PLAY_WAV::finished ()

Synth_PLAY_WAV::finished

inline Arts::AutoSuspendState  Synth_BUS_UPLINK::autoSuspend ()

Synth_BUS_UPLINK::autoSuspend

inline void  Synth_BUS_UPLINK::start ()

Synth_BUS_UPLINK::start

inline void  Synth_BUS_UPLINK::stop ()

Synth_BUS_UPLINK::stop

inline void  Synth_BUS_UPLINK::streamInit ()

Synth_BUS_UPLINK::streamInit

inline void  Synth_BUS_UPLINK::streamStart ()

Synth_BUS_UPLINK::streamStart

inline void  Synth_BUS_UPLINK::streamEnd ()

Synth_BUS_UPLINK::streamEnd

inline std::string  Synth_BUS_UPLINK::busname ()

Synth_BUS_UPLINK::busname

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

Synth_BUS_UPLINK::busname

inline Arts::AutoSuspendState  Synth_BUS_DOWNLINK::autoSuspend ()

Synth_BUS_DOWNLINK::autoSuspend

inline void  Synth_BUS_DOWNLINK::start ()

Synth_BUS_DOWNLINK::start

inline void  Synth_BUS_DOWNLINK::stop ()

Synth_BUS_DOWNLINK::stop

inline void  Synth_BUS_DOWNLINK::streamInit ()

Synth_BUS_DOWNLINK::streamInit

inline void  Synth_BUS_DOWNLINK::streamStart ()

Synth_BUS_DOWNLINK::streamStart

inline void  Synth_BUS_DOWNLINK::streamEnd ()

Synth_BUS_DOWNLINK::streamEnd

inline std::string  Synth_BUS_DOWNLINK::busname ()

Synth_BUS_DOWNLINK::busname

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

Synth_BUS_DOWNLINK::busname

inline Arts::AutoSuspendState  ByteStreamToAudio::autoSuspend ()

ByteStreamToAudio::autoSuspend

inline void  ByteStreamToAudio::start ()

ByteStreamToAudio::start

inline void  ByteStreamToAudio::stop ()

ByteStreamToAudio::stop

inline void  ByteStreamToAudio::streamInit ()

ByteStreamToAudio::streamInit

inline void  ByteStreamToAudio::streamStart ()

ByteStreamToAudio::streamStart

inline void  ByteStreamToAudio::streamEnd ()

ByteStreamToAudio::streamEnd

inline long  ByteStreamToAudio::samplingRate ()

ByteStreamToAudio::samplingRate

inline void  ByteStreamToAudio::samplingRate (long _newValue)

ByteStreamToAudio::samplingRate

inline long  ByteStreamToAudio::channels ()

ByteStreamToAudio::channels

inline void  ByteStreamToAudio::channels (long _newValue)

ByteStreamToAudio::channels

inline long  ByteStreamToAudio::bits ()

ByteStreamToAudio::bits

inline void  ByteStreamToAudio::bits (long _newValue)

ByteStreamToAudio::bits

inline bool  ByteStreamToAudio::running ()

ByteStreamToAudio::running

inline Arts::AutoSuspendState  StereoEffect::autoSuspend ()

StereoEffect::autoSuspend

inline void  StereoEffect::start ()

StereoEffect::start

inline void  StereoEffect::stop ()

StereoEffect::stop

inline void  StereoEffect::streamInit ()

StereoEffect::streamInit

inline void  StereoEffect::streamStart ()

StereoEffect::streamStart

inline void  StereoEffect::streamEnd ()

StereoEffect::streamEnd

inline Arts::AutoSuspendState  StereoVolumeControl::autoSuspend ()

StereoVolumeControl::autoSuspend

inline void  StereoVolumeControl::start ()

StereoVolumeControl::start

inline void  StereoVolumeControl::stop ()

StereoVolumeControl::stop

inline void  StereoVolumeControl::streamInit ()

StereoVolumeControl::streamInit

inline void  StereoVolumeControl::streamStart ()

StereoVolumeControl::streamStart

inline void  StereoVolumeControl::streamEnd ()

StereoVolumeControl::streamEnd

inline float  StereoVolumeControl::scaleFactor ()

StereoVolumeControl::scaleFactor

inline void  StereoVolumeControl::scaleFactor (float _newValue)

StereoVolumeControl::scaleFactor

inline float  StereoVolumeControl::currentVolumeLeft ()

StereoVolumeControl::currentVolumeLeft

inline float  StereoVolumeControl::currentVolumeRight ()

StereoVolumeControl::currentVolumeRight

inline Arts::AutoSuspendState  StereoFFTScope::autoSuspend ()

StereoFFTScope::autoSuspend

inline void  StereoFFTScope::start ()

StereoFFTScope::start

inline void  StereoFFTScope::stop ()

StereoFFTScope::stop

inline void  StereoFFTScope::streamInit ()

StereoFFTScope::streamInit

inline void  StereoFFTScope::streamStart ()

StereoFFTScope::streamStart

inline void  StereoFFTScope::streamEnd ()

StereoFFTScope::streamEnd

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

StereoFFTScope::scope

inline Arts::AutoSuspendState  StereoEffectStack::autoSuspend ()

StereoEffectStack::autoSuspend

inline void  StereoEffectStack::start ()

StereoEffectStack::start

inline void  StereoEffectStack::stop ()

StereoEffectStack::stop

inline void  StereoEffectStack::streamInit ()

StereoEffectStack::streamInit

inline void  StereoEffectStack::streamStart ()

StereoEffectStack::streamStart

inline void  StereoEffectStack::streamEnd ()

StereoEffectStack::streamEnd

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

StereoEffectStack::insertTop

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

StereoEffectStack::insertBottom

inline void  StereoEffectStack::remove (long ID)

StereoEffectStack::remove

inline long  AudioManagerClient::ID ()

AudioManagerClient::ID

inline Arts::AudioManagerDirection  AudioManagerClient::direction ()

AudioManagerClient::direction

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

AudioManagerClient::direction

inline std::string  AudioManagerClient::title ()

AudioManagerClient::title

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

AudioManagerClient::title

inline std::string  AudioManagerClient::autoRestoreID ()

AudioManagerClient::autoRestoreID

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

AudioManagerClient::autoRestoreID

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

AudioManagerClient::AudioManagerClient

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

AudioManager::destinations

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

AudioManager::clients

inline long  AudioManager::changes ()

AudioManager::changes

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

AudioManager::setDestination

inline Arts::AutoSuspendState  Synth_AMAN_PLAY::autoSuspend ()

Synth_AMAN_PLAY::autoSuspend

inline void  Synth_AMAN_PLAY::start ()

Synth_AMAN_PLAY::start

inline void  Synth_AMAN_PLAY::stop ()

Synth_AMAN_PLAY::stop

inline void  Synth_AMAN_PLAY::streamInit ()

Synth_AMAN_PLAY::streamInit

inline void  Synth_AMAN_PLAY::streamStart ()

Synth_AMAN_PLAY::streamStart

inline void  Synth_AMAN_PLAY::streamEnd ()

Synth_AMAN_PLAY::streamEnd

inline std::string  Synth_AMAN_PLAY::title ()

Synth_AMAN_PLAY::title

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

Synth_AMAN_PLAY::title

inline std::string  Synth_AMAN_PLAY::autoRestoreID ()

Synth_AMAN_PLAY::autoRestoreID

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

Synth_AMAN_PLAY::autoRestoreID

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

Synth_AMAN_PLAY::Synth_AMAN_PLAY

inline Arts::AutoSuspendState  Synth_AMAN_RECORD::autoSuspend ()

Synth_AMAN_RECORD::autoSuspend

inline void  Synth_AMAN_RECORD::start ()

Synth_AMAN_RECORD::start

inline void  Synth_AMAN_RECORD::stop ()

Synth_AMAN_RECORD::stop

inline void  Synth_AMAN_RECORD::streamInit ()

Synth_AMAN_RECORD::streamInit

inline void  Synth_AMAN_RECORD::streamStart ()

Synth_AMAN_RECORD::streamStart

inline void  Synth_AMAN_RECORD::streamEnd ()

Synth_AMAN_RECORD::streamEnd

inline std::string  Synth_AMAN_RECORD::title ()

Synth_AMAN_RECORD::title

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

Synth_AMAN_RECORD::title

inline std::string  Synth_AMAN_RECORD::autoRestoreID ()

Synth_AMAN_RECORD::autoRestoreID

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

Synth_AMAN_RECORD::autoRestoreID

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

Synth_AMAN_RECORD::Synth_AMAN_RECORD

ASProducer (class)

ASProducer

ASConsumer (class)

ASConsumer

AudioSubSystemStart (class)

AudioSubSystemStart

AudioSubSystem (class)

AudioSubSystem

Cache (class)

Cache

CachedObject (class)

CachedObject

CachedWav (class)

CachedWav

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

convert_mono_8_float

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

interpolate_mono_8_float

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

convert_mono_16le_float

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

interpolate_mono_16le_float

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

convert_mono_16be_float

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

interpolate_mono_16be_float

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

convert_stereo_i8_2float

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

interpolate_stereo_i8_2float

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

convert_stereo_i16le_2float

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

interpolate_stereo_i16le_2float

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

convert_stereo_i16be_2float

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

interpolate_stereo_i16be_2float

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

convert_mono_float_float

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

interpolate_mono_float_float

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

convert_stereo_ifloat_2float

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

interpolate_stereo_ifloat_2float

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

convert_mono_float_16le

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

convert_stereo_2float_i16le

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

convert_mono_float_16be

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

convert_stereo_2float_i16be

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

convert_mono_float_8

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

convert_stereo_2float_i8

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 )

uni_convert_stereo_2float

PipeSegment (class)

PipeSegment

PipeBuffer (class)

PipeBuffer

StdSynthModule (class)

StdSynthModule

SynthBuffer (class)

SynthBuffer

StdScheduleNode (class)

StdScheduleNode

Port (class)

Port

AudioPort (class)

AudioPort

MultiPort (class)

MultiPort

StdFlowSystem (class)

StdFlowSystem

AudioIOFactory (class)

AudioIOFactory

AudioIO (class)

AudioIO

Refiller (class)

Refiller

Resampler (class)

Resampler

CpuInfo (class)

CpuInfo

Provides information about the availability of the various "Multimedia extensions" the CPU supports. If you implement a routine in assembler, use flags() to know which SIMD instructions the user's CPU knows about.

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

RealtimeStatus

SampleStorageEntry (class)

SampleStorageEntry

SampleStorage (class)

SampleStorage

ByteSoundProducer (class)

ByteSoundProducer

SimpleSoundServer (class)

SimpleSoundServer

SoundServer (class)

SoundServer

SoundServerV2 (class)

SoundServerV2

WavPlayObject (class)

WavPlayObject

SampleStorageEntry_base (class)

SampleStorageEntry_base

SampleStorageEntry_stub (class)

SampleStorageEntry_stub

SampleStorageEntry_skel (class)

SampleStorageEntry_skel

SampleStorage_base (class)

SampleStorage_base

SampleStorage_stub (class)

SampleStorage_stub

SampleStorage_skel (class)

SampleStorage_skel

ByteSoundProducer_base (class)

ByteSoundProducer_base

ByteSoundProducer_stub (class)

ByteSoundProducer_stub

ByteSoundProducer_skel (class)

ByteSoundProducer_skel

inline operator  SynthModule ()

SynthModule

[const]

SimpleSoundServer_base (class)

SimpleSoundServer_base

SimpleSoundServer_stub (class)

SimpleSoundServer_stub

SimpleSoundServer_skel (class)

SimpleSoundServer_skel

inline operator  PlayObjectFactory ()

PlayObjectFactory

[const]

SoundServer_base (class)

SoundServer_base

SoundServer_stub (class)

SoundServer_stub

SoundServer_skel (class)

SoundServer_skel

inline operator  SimpleSoundServer ()

SimpleSoundServer

[const]

inline operator  PlayObjectFactory ()

PlayObjectFactory

[const]

SoundServerV2_base (class)

SoundServerV2_base

SoundServerV2_stub (class)

SoundServerV2_stub

SoundServerV2_skel (class)

SoundServerV2_skel

inline operator  SoundServer ()

SoundServer

[const]

inline operator  SimpleSoundServer ()

SimpleSoundServer

[const]

PlayObjectFactory (class)

PlayObjectFactory

PlayObjectFactoryV2 (class)

PlayObjectFactoryV2

WavPlayObject_base (class)

WavPlayObject_base

WavPlayObject_stub (class)

WavPlayObject_stub

WavPlayObject_skel (class)

WavPlayObject_skel

PlayObject (class)

PlayObject

PlayObject_private (class)

PlayObject_private

inline operator  SynthModule ()

SynthModule

[const]

inline std::string  SampleStorageEntry::name ()

SampleStorageEntry::name

inline std::string  SampleStorageEntry::filename ()

SampleStorageEntry::filename

inline bool  SampleStorageEntry::completed ()

SampleStorageEntry::completed

inline void  SampleStorageEntry::write (const std::vector<Arts::mcopbyte>& data)

SampleStorageEntry::write

inline void  SampleStorageEntry::finish ()

SampleStorageEntry::finish

inline  SampleStorage::SampleStorage (const std::string& directory, bool clearOnInit)

SampleStorage::SampleStorage

inline Arts::SampleStorageEntry  SampleStorage::createEntry (const std::string& name)

SampleStorage::createEntry

inline void  SampleStorage::addEntry (Arts::SampleStorageEntry entry)

SampleStorage::addEntry

inline void  SampleStorage::removeEntry (Arts::SampleStorageEntry entry)

SampleStorage::removeEntry

inline Arts::SampleStorageEntry  SampleStorage::findEntry (const std::string& name)

SampleStorage::findEntry

inline Arts::AutoSuspendState  ByteSoundProducer::autoSuspend ()

ByteSoundProducer::autoSuspend

inline void  ByteSoundProducer::start ()

ByteSoundProducer::start

inline void  ByteSoundProducer::stop ()

ByteSoundProducer::stop

inline void  ByteSoundProducer::streamInit ()

ByteSoundProducer::streamInit

inline void  ByteSoundProducer::streamStart ()

ByteSoundProducer::streamStart

inline void  ByteSoundProducer::streamEnd ()

ByteSoundProducer::streamEnd

inline long  ByteSoundProducer::samplingRate ()

ByteSoundProducer::samplingRate

inline long  ByteSoundProducer::channels ()

ByteSoundProducer::channels

inline long  ByteSoundProducer::bits ()

ByteSoundProducer::bits

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

SimpleSoundServer::createPlayObject

inline Arts::StereoEffectStack  SimpleSoundServer::outstack ()

SimpleSoundServer::outstack

inline float  SimpleSoundServer::minStreamBufferTime ()

SimpleSoundServer::minStreamBufferTime

inline float  SimpleSoundServer::serverBufferTime ()

SimpleSoundServer::serverBufferTime

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

SimpleSoundServer::play

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

SimpleSoundServer::attach

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

SimpleSoundServer::detach

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

SimpleSoundServer::createObject

inline Arts::StereoEffectStack  SoundServer::outstack ()

SoundServer::outstack

inline float  SoundServer::minStreamBufferTime ()

SoundServer::minStreamBufferTime

inline float  SoundServer::serverBufferTime ()

SoundServer::serverBufferTime

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

SoundServer::play

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

SoundServer::attach

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

SoundServer::detach

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

SoundServer::createObject

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

SoundServer::createPlayObject

inline Arts::RealtimeStatus  SoundServer::realtimeStatus ()

SoundServer::realtimeStatus

inline long  SoundServer::secondsUntilSuspend ()

SoundServer::secondsUntilSuspend

inline bool  SoundServer::suspend ()

SoundServer::suspend

inline bool  SoundServer::terminate ()

SoundServer::terminate

inline Arts::RealtimeStatus  SoundServerV2::realtimeStatus ()

SoundServerV2::realtimeStatus

inline long  SoundServerV2::secondsUntilSuspend ()

SoundServerV2::secondsUntilSuspend

inline bool  SoundServerV2::suspend ()

SoundServerV2::suspend

inline bool  SoundServerV2::terminate ()

SoundServerV2::terminate

inline Arts::StereoEffectStack  SoundServerV2::outstack ()

SoundServerV2::outstack

inline float  SoundServerV2::minStreamBufferTime ()

SoundServerV2::minStreamBufferTime

inline float  SoundServerV2::serverBufferTime ()

SoundServerV2::serverBufferTime

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

SoundServerV2::play

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

SoundServerV2::attach

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

SoundServerV2::detach

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

SoundServerV2::createObject

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

SoundServerV2::createPlayObject

inline Arts::PlayObject  SoundServerV2::createPlayObjectForURL (const std::string& url, const std::string& mimetype, bool createBUS)

SoundServerV2::createPlayObjectForURL

inline Arts::PlayObject  SoundServerV2::createPlayObjectForStream (Arts::InputStream instream, const std::string& mimetype, bool createBUS)

SoundServerV2::createPlayObjectForStream

inline long  SoundServerV2::autoSuspendSeconds ()

SoundServerV2::autoSuspendSeconds

inline void  SoundServerV2::autoSuspendSeconds (long _newValue)

SoundServerV2::autoSuspendSeconds

inline long  SoundServerV2::bufferSizeMultiplier ()

SoundServerV2::bufferSizeMultiplier

inline void  SoundServerV2::bufferSizeMultiplier (long _newValue)

SoundServerV2::bufferSizeMultiplier

inline std::string  SoundServerV2::audioMethod ()

SoundServerV2::audioMethod

inline long  SoundServerV2::samplingRate ()

SoundServerV2::samplingRate

inline long  SoundServerV2::channels ()

SoundServerV2::channels

inline long  SoundServerV2::bits ()

SoundServerV2::bits

inline bool  SoundServerV2::fullDuplex ()

SoundServerV2::fullDuplex

inline std::string  SoundServerV2::audioDevice ()

SoundServerV2::audioDevice

inline long  SoundServerV2::fragments ()

SoundServerV2::fragments

inline long  SoundServerV2::fragmentSize ()

SoundServerV2::fragmentSize

inline std::string  SoundServerV2::version ()

SoundServerV2::version

inline Arts::StereoVolumeControl  SoundServerV2::outVolume ()

SoundServerV2::outVolume

inline Arts::SampleStorage  SoundServerV2::sampleStorage ()

SoundServerV2::sampleStorage

inline void  SoundServerV2::checkNewObjects ()

SoundServerV2::checkNewObjects

inline std::string  WavPlayObject::description ()

WavPlayObject::description

inline Arts::poTime  WavPlayObject::currentTime ()

WavPlayObject::currentTime

inline Arts::poTime  WavPlayObject::overallTime ()

WavPlayObject::overallTime

inline Arts::poCapabilities  WavPlayObject::capabilities ()

WavPlayObject::capabilities

inline std::string  WavPlayObject::mediaName ()

WavPlayObject::mediaName

inline Arts::poState  WavPlayObject::state ()

WavPlayObject::state

inline void  WavPlayObject::play ()

WavPlayObject::play

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

WavPlayObject::seek

inline void  WavPlayObject::pause ()

WavPlayObject::pause

inline void  WavPlayObject::halt ()

WavPlayObject::halt

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

WavPlayObject::loadMedia

inline Arts::AutoSuspendState  WavPlayObject::autoSuspend ()

WavPlayObject::autoSuspend

inline void  WavPlayObject::start ()

WavPlayObject::start

inline void  WavPlayObject::stop ()

WavPlayObject::stop

inline void  WavPlayObject::streamInit ()

WavPlayObject::streamInit

inline void  WavPlayObject::streamStart ()

WavPlayObject::streamStart

inline void  WavPlayObject::streamEnd ()

WavPlayObject::streamEnd

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

poState

enum poCapabilities {capSeek = 1, capPause = 2}

poCapabilities

poTime (class)

poTime

InputStream (class)

InputStream

FileInputStream (class)

FileInputStream

StdoutWriter (class)

StdoutWriter

StreamPlayObject (class)

StreamPlayObject

PlayObject_private_base (class)

PlayObject_private_base

PlayObject_private_stub (class)

PlayObject_private_stub

PlayObject_private_skel (class)

PlayObject_private_skel

PlayObject_base (class)

PlayObject_base

PlayObject_stub (class)

PlayObject_stub

PlayObject_skel (class)

PlayObject_skel

inline operator  PlayObject_private ()

PlayObject_private

[const]

PlayObjectFactory_base (class)

PlayObjectFactory_base

PlayObjectFactory_stub (class)

PlayObjectFactory_stub

PlayObjectFactory_skel (class)

PlayObjectFactory_skel

InputStream_base (class)

InputStream_base

InputStream_stub (class)

InputStream_stub

InputStream_skel (class)

InputStream_skel

inline operator  SynthModule ()

SynthModule

[const]

FileInputStream_base (class)

FileInputStream_base

FileInputStream_stub (class)

FileInputStream_stub

FileInputStream_skel (class)

FileInputStream_skel

inline operator  InputStream ()

InputStream

[const]

inline operator  SynthModule ()

SynthModule

[const]

StdoutWriter_base (class)

StdoutWriter_base

StdoutWriter_stub (class)

StdoutWriter_stub

StdoutWriter_skel (class)

StdoutWriter_skel

inline operator  SynthModule ()

SynthModule

[const]

StreamPlayObject_base (class)

StreamPlayObject_base

StreamPlayObject_stub (class)

StreamPlayObject_stub

StreamPlayObject_skel (class)

StreamPlayObject_skel

inline operator  PlayObject ()

PlayObject

[const]

inline operator  PlayObject_private ()

PlayObject_private

[const]

PlayObjectFactoryV2_base (class)

PlayObjectFactoryV2_base

PlayObjectFactoryV2_stub (class)

PlayObjectFactoryV2_stub

PlayObjectFactoryV2_skel (class)

PlayObjectFactoryV2_skel

inline operator  PlayObjectFactory ()

PlayObjectFactory

[const]

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

PlayObject_private::loadMedia

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

PlayObject::loadMedia

inline std::string  PlayObject::description ()

PlayObject::description

inline Arts::poTime  PlayObject::currentTime ()

PlayObject::currentTime

inline Arts::poTime  PlayObject::overallTime ()

PlayObject::overallTime

inline Arts::poCapabilities  PlayObject::capabilities ()

PlayObject::capabilities

inline std::string  PlayObject::mediaName ()

PlayObject::mediaName

inline Arts::poState  PlayObject::state ()

PlayObject::state

inline void  PlayObject::play ()

PlayObject::play

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

PlayObject::seek

inline void  PlayObject::pause ()

PlayObject::pause

inline void  PlayObject::halt ()

PlayObject::halt

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

PlayObjectFactory::createPlayObject

inline Arts::AutoSuspendState  InputStream::autoSuspend ()

InputStream::autoSuspend

inline void  InputStream::start ()

InputStream::start

inline void  InputStream::stop ()

InputStream::stop

inline void  InputStream::streamInit ()

InputStream::streamInit

inline void  InputStream::streamStart ()

InputStream::streamStart

inline void  InputStream::streamEnd ()

InputStream::streamEnd

inline bool  InputStream::eof ()

InputStream::eof

inline long  InputStream::size ()

InputStream::size

inline bool  InputStream::seekOk ()

InputStream::seekOk

inline long  InputStream::seek (long position)

InputStream::seek

inline bool  FileInputStream::eof ()

FileInputStream::eof

inline long  FileInputStream::size ()

FileInputStream::size

inline bool  FileInputStream::seekOk ()

FileInputStream::seekOk

inline long  FileInputStream::seek (long position)

FileInputStream::seek

inline Arts::AutoSuspendState  FileInputStream::autoSuspend ()

FileInputStream::autoSuspend

inline void  FileInputStream::start ()

FileInputStream::start

inline void  FileInputStream::stop ()

FileInputStream::stop

inline void  FileInputStream::streamInit ()

FileInputStream::streamInit

inline void  FileInputStream::streamStart ()

FileInputStream::streamStart

inline void  FileInputStream::streamEnd ()

FileInputStream::streamEnd

inline std::string  FileInputStream::filename ()

FileInputStream::filename

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

FileInputStream::filename

inline bool  FileInputStream::open (const std::string& filename)

FileInputStream::open

inline Arts::AutoSuspendState  StdoutWriter::autoSuspend ()

StdoutWriter::autoSuspend

inline void  StdoutWriter::start ()

StdoutWriter::start

inline void  StdoutWriter::stop ()

StdoutWriter::stop

inline void  StdoutWriter::streamInit ()

StdoutWriter::streamInit

inline void  StdoutWriter::streamStart ()

StdoutWriter::streamStart

inline void  StdoutWriter::streamEnd ()

StdoutWriter::streamEnd

inline std::string  StreamPlayObject::description ()

StreamPlayObject::description

inline Arts::poTime  StreamPlayObject::currentTime ()

StreamPlayObject::currentTime

inline Arts::poTime  StreamPlayObject::overallTime ()

StreamPlayObject::overallTime

inline Arts::poCapabilities  StreamPlayObject::capabilities ()

StreamPlayObject::capabilities

inline std::string  StreamPlayObject::mediaName ()

StreamPlayObject::mediaName

inline Arts::poState  StreamPlayObject::state ()

StreamPlayObject::state

inline void  StreamPlayObject::play ()

StreamPlayObject::play

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

StreamPlayObject::seek

inline void  StreamPlayObject::pause ()

StreamPlayObject::pause

inline void  StreamPlayObject::halt ()

StreamPlayObject::halt

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

StreamPlayObject::loadMedia

inline bool  StreamPlayObject::streamMedia (Arts::InputStream instream)

StreamPlayObject::streamMedia

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

PlayObjectFactoryV2::createPlayObject

inline Arts::PlayObject  PlayObjectFactoryV2::createPlayObjectForURL (const std::string& url, const std::string& mimetype, bool createBUS)

PlayObjectFactoryV2::createPlayObjectForURL

inline Arts::PlayObject  PlayObjectFactoryV2::createPlayObjectForStream (Arts::InputStream instream, const std::string& mimetype, bool createBUS)

PlayObjectFactoryV2::createPlayObjectForStream

GIOManager (class)

GIOManager

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

QIOManager (class)

QIOManager

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

enum PortDirection {input = 0, output = 1}

PortDirection

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

PortConnType

PortType (class)

PortType

ModuleInfo (class)

ModuleInfo

PortDesc (class)

PortDesc

ModuleDesc (class)

ModuleDesc

StructureDesc (class)

StructureDesc

StructurePortDesc (class)

StructurePortDesc

ObjectFactory (class)

ObjectFactory

LocalFactory (class)

LocalFactory

StructureBuilder (class)

StructureBuilder

ArtsBuilderLoader (class)

ArtsBuilderLoader

Structure (class)

Structure

PortDesc_base (class)

PortDesc_base

PortDesc_stub (class)

PortDesc_stub

PortDesc_skel (class)

PortDesc_skel

ModuleDesc_base (class)

ModuleDesc_base

ModuleDesc_stub (class)

ModuleDesc_stub

ModuleDesc_skel (class)

ModuleDesc_skel

StructureDesc_base (class)

StructureDesc_base

StructureDesc_stub (class)

StructureDesc_stub

StructureDesc_skel (class)

StructureDesc_skel

StructurePortDesc_base (class)

StructurePortDesc_base

StructurePortDesc_stub (class)

StructurePortDesc_stub

StructurePortDesc_skel (class)

StructurePortDesc_skel

inline operator  PortDesc ()

PortDesc

[const]

ObjectFactory_base (class)

ObjectFactory_base

ObjectFactory_stub (class)

ObjectFactory_stub

ObjectFactory_skel (class)

ObjectFactory_skel

LocalFactory_base (class)

LocalFactory_base

LocalFactory_stub (class)

LocalFactory_stub

LocalFactory_skel (class)

LocalFactory_skel

inline operator  ObjectFactory ()

ObjectFactory

[const]

StructureBuilder_base (class)

StructureBuilder_base

StructureBuilder_stub (class)

StructureBuilder_stub

StructureBuilder_skel (class)

StructureBuilder_skel

ArtsBuilderLoader_base (class)

ArtsBuilderLoader_base

ArtsBuilderLoader_stub (class)

ArtsBuilderLoader_stub

ArtsBuilderLoader_skel (class)

ArtsBuilderLoader_skel

inline operator  Loader ()

Loader

[const]

Structure_base (class)

Structure_base

Structure_stub (class)

Structure_stub

Structure_skel (class)

Structure_skel

inline operator  SynthModule ()

SynthModule

[const]

inline long  PortDesc::ID ()

PortDesc::ID

inline Arts::ModuleDesc  PortDesc::parent ()

PortDesc::parent

inline std::string  PortDesc::name ()

PortDesc::name

inline Arts::PortType  PortDesc::type ()

PortDesc::type

inline bool  PortDesc::isConnected ()

PortDesc::isConnected

inline bool  PortDesc::hasValue ()

PortDesc::hasValue

inline void  PortDesc::hasValue (bool _newValue)

PortDesc::hasValue

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

PortDesc::connections

inline float  PortDesc::floatValue ()

PortDesc::floatValue

inline void  PortDesc::floatValue (float _newValue)

PortDesc::floatValue

inline std::string  PortDesc::stringValue ()

PortDesc::stringValue

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

PortDesc::stringValue

inline Arts::Any  PortDesc::value ()

PortDesc::value

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

PortDesc::value

inline long  PortDesc::internalOldID ()

PortDesc::internalOldID

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

PortDesc::PortDesc

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

PortDesc::connectTo

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

PortDesc::disconnectFrom

inline void  PortDesc::disconnectAll ()

PortDesc::disconnectAll

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

PortDesc::saveToList

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

PortDesc::loadFromList

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

PortDesc::internalConnectInput

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

PortDesc::internalReConnect

inline long  ModuleDesc::ID ()

ModuleDesc::ID

inline Arts::StructureDesc  ModuleDesc::parent ()

ModuleDesc::parent

inline std::string  ModuleDesc::name ()

ModuleDesc::name

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

ModuleDesc::ports

inline long  ModuleDesc::x ()

ModuleDesc::x

inline long  ModuleDesc::y ()

ModuleDesc::y

inline long  ModuleDesc::width ()

ModuleDesc::width

inline long  ModuleDesc::height ()

ModuleDesc::height

inline bool  ModuleDesc::isInterface ()

ModuleDesc::isInterface

inline bool  ModuleDesc::isStructure ()

ModuleDesc::isStructure

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

ModuleDesc::ModuleDesc

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

ModuleDesc::moveTo

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

ModuleDesc::findPort

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

ModuleDesc::saveToList

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

ModuleDesc::loadFromList

inline bool  StructureDesc::valid ()

StructureDesc::valid

inline std::string  StructureDesc::name ()

StructureDesc::name

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

StructureDesc::name

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

StructureDesc::modules

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

StructureDesc::ports

inline Arts::ModuleInfo  StructureDesc::externalInterface ()

StructureDesc::externalInterface

inline long  StructureDesc::obtainID ()

StructureDesc::obtainID

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

StructureDesc::saveToList

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

StructureDesc::loadFromList

inline void  StructureDesc::clear ()

StructureDesc::clear

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

StructureDesc::createModuleDesc

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

StructureDesc::freeModuleDesc

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

StructureDesc::createStructurePortDesc

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

StructureDesc::freeStructurePortDesc

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

StructureDesc::moveStructurePortDesc

inline long  StructurePortDesc::ID ()

StructurePortDesc::ID

inline Arts::ModuleDesc  StructurePortDesc::parent ()

StructurePortDesc::parent

inline std::string  StructurePortDesc::name ()

StructurePortDesc::name

inline Arts::PortType  StructurePortDesc::type ()

StructurePortDesc::type

inline bool  StructurePortDesc::isConnected ()

StructurePortDesc::isConnected

inline bool  StructurePortDesc::hasValue ()

StructurePortDesc::hasValue

inline void  StructurePortDesc::hasValue (bool _newValue)

StructurePortDesc::hasValue

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

StructurePortDesc::connections

inline float  StructurePortDesc::floatValue ()

StructurePortDesc::floatValue

inline void  StructurePortDesc::floatValue (float _newValue)

StructurePortDesc::floatValue

inline std::string  StructurePortDesc::stringValue ()

StructurePortDesc::stringValue

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

StructurePortDesc::stringValue

inline Arts::Any  StructurePortDesc::value ()

StructurePortDesc::value

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

StructurePortDesc::value

inline long  StructurePortDesc::internalOldID ()

StructurePortDesc::internalOldID

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

StructurePortDesc::StructurePortDesc

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

StructurePortDesc::connectTo

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

StructurePortDesc::disconnectFrom

inline void  StructurePortDesc::disconnectAll ()

StructurePortDesc::disconnectAll

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

StructurePortDesc::saveToList

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

StructurePortDesc::loadFromList

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

StructurePortDesc::internalConnectInput

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

StructurePortDesc::internalReConnect

inline long  StructurePortDesc::x ()

StructurePortDesc::x

inline long  StructurePortDesc::y ()

StructurePortDesc::y

inline long  StructurePortDesc::position ()

StructurePortDesc::position

inline Arts::StructureDesc  StructurePortDesc::parentStructure ()

StructurePortDesc::parentStructure

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

StructurePortDesc::StructurePortDesc

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

StructurePortDesc::moveTo

inline void  StructurePortDesc::lowerPosition ()

StructurePortDesc::lowerPosition

inline void  StructurePortDesc::raisePosition ()

StructurePortDesc::raisePosition

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

StructurePortDesc::rename

inline void  StructurePortDesc::internalSetPosition (long position)

StructurePortDesc::internalSetPosition

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

ObjectFactory::createObject

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

LocalFactory::createObject

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

StructureBuilder::addFactory

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

StructureBuilder::createObject

inline Arts::ModuleDef  StructureBuilder::createTypeInfo (Arts::StructureDesc structure)

StructureBuilder::createTypeInfo

inline std::string  ArtsBuilderLoader::dataVersion ()

ArtsBuilderLoader::dataVersion

inline std::vector<Arts::TraderEntry> *  ArtsBuilderLoader::traderEntries ()

ArtsBuilderLoader::traderEntries

inline std::vector<Arts::ModuleDef> *  ArtsBuilderLoader::modules ()

ArtsBuilderLoader::modules

inline Arts::Object  ArtsBuilderLoader::loadObject (Arts::TraderOffer offer)

ArtsBuilderLoader::loadObject

inline Arts::AutoSuspendState  Structure::autoSuspend ()

Structure::autoSuspend

inline void  Structure::start ()

Structure::start

inline void  Structure::stop ()

Structure::stop

inline void  Structure::streamInit ()

Structure::streamInit

inline void  Structure::streamStart ()

Structure::streamStart

inline void  Structure::streamEnd ()

Structure::streamEnd

inline void  Structure::run ()

Structure::run

inline void  Structure::halt ()

Structure::halt

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

MidiCommandStatus

enum MidiCommandParameter {mcpSustain = 64, mcpAllNotesOff = 123}

MidiCommandParameter

enum MidiClientDirection {mcdPlay = 0, mcdRecord = 1}

MidiClientDirection

enum MidiClientType {mctDestination = 0, mctApplication = 1}

MidiClientType

TimeStamp (class)

TimeStamp

MidiCommand (class)

MidiCommand

MidiEvent (class)

MidiEvent

MidiClientInfo (class)

MidiClientInfo

MidiPort (class)

MidiPort

MidiClient (class)

MidiClient

MidiManager (class)

MidiManager

MidiTest (class)

MidiTest

RawMidiPort (class)

RawMidiPort

MidiTimer (class)

MidiTimer

SystemMidiTimer (class)

SystemMidiTimer

AudioMidiTimer (class)

AudioMidiTimer

MidiPort_base (class)

MidiPort_base

MidiPort_stub (class)

MidiPort_stub

MidiPort_skel (class)

MidiPort_skel

MidiClient_base (class)

MidiClient_base

MidiClient_stub (class)

MidiClient_stub

MidiClient_skel (class)

MidiClient_skel

MidiManager_base (class)

MidiManager_base

MidiManager_stub (class)

MidiManager_stub

MidiManager_skel (class)

MidiManager_skel

MidiTest_base (class)

MidiTest_base

MidiTest_stub (class)

MidiTest_stub

MidiTest_skel (class)

MidiTest_skel

inline operator  MidiPort ()

MidiPort

[const]

RawMidiPort_base (class)

RawMidiPort_base

RawMidiPort_stub (class)

RawMidiPort_stub

RawMidiPort_skel (class)

RawMidiPort_skel

inline operator  MidiPort ()

MidiPort

[const]

MidiTimer_base (class)

MidiTimer_base

MidiTimer_stub (class)

MidiTimer_stub

MidiTimer_skel (class)

MidiTimer_skel

SystemMidiTimer_base (class)

SystemMidiTimer_base

SystemMidiTimer_stub (class)

SystemMidiTimer_stub

SystemMidiTimer_skel (class)

SystemMidiTimer_skel

inline operator  MidiTimer ()

MidiTimer

[const]

AudioMidiTimer_base (class)

AudioMidiTimer_base

AudioMidiTimer_stub (class)

AudioMidiTimer_stub

AudioMidiTimer_skel (class)

AudioMidiTimer_skel

inline operator  MidiTimer ()

MidiTimer

[const]

inline Arts::TimeStamp  MidiPort::time ()

MidiPort::time

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

MidiPort::processCommand

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

MidiPort::processEvent

inline Arts::MidiClientInfo  MidiClient::info ()

MidiClient::info

inline std::string  MidiClient::title ()

MidiClient::title

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

MidiClient::title

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

MidiClient::addInputPort

inline Arts::MidiPort  MidiClient::addOutputPort ()

MidiClient::addOutputPort

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

MidiClient::removePort

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

MidiManager::clients

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

MidiManager::addClient

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

MidiManager::connect

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

MidiManager::disconnect

inline Arts::TimeStamp  MidiTest::time ()

MidiTest::time

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

MidiTest::processCommand

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

MidiTest::processEvent

inline Arts::TimeStamp  RawMidiPort::time ()

RawMidiPort::time

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

RawMidiPort::processCommand

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

RawMidiPort::processEvent

inline std::string  RawMidiPort::device ()

RawMidiPort::device

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

RawMidiPort::device

inline bool  RawMidiPort::input ()

RawMidiPort::input

inline void  RawMidiPort::input (bool _newValue)

RawMidiPort::input

inline bool  RawMidiPort::output ()

RawMidiPort::output

inline void  RawMidiPort::output (bool _newValue)

RawMidiPort::output

inline bool  RawMidiPort::running ()

RawMidiPort::running

inline void  RawMidiPort::running (bool _newValue)

RawMidiPort::running

inline bool  RawMidiPort::open ()

RawMidiPort::open

inline Arts::TimeStamp  MidiTimer::time ()

MidiTimer::time

inline void  MidiTimer::queueEvent (Arts::MidiPort port, const Arts::MidiEvent& event)

MidiTimer::queueEvent

inline Arts::TimeStamp  SystemMidiTimer::time ()

SystemMidiTimer::time

inline void  SystemMidiTimer::queueEvent (Arts::MidiPort port, const Arts::MidiEvent& event)

SystemMidiTimer::queueEvent

inline Arts::TimeStamp  AudioMidiTimer::time ()

AudioMidiTimer::time

inline void  AudioMidiTimer::queueEvent (Arts::MidiPort port, const Arts::MidiEvent& event)

AudioMidiTimer::queueEvent

Widget (class)

Widget

Button (class)

Button

Poti (class)

Poti

LineEdit (class)

LineEdit

GuiFactory (class)

GuiFactory

GenericGuiFactory (class)

GenericGuiFactory

Widget_base (class)

Widget_base

Widget_stub (class)

Widget_stub

Widget_skel (class)

Widget_skel

Button_base (class)

Button_base

Button_stub (class)

Button_stub

Button_skel (class)

Button_skel

inline operator  Widget ()

Widget

[const]

Poti_base (class)

Poti_base

Poti_stub (class)

Poti_stub

Poti_skel (class)

Poti_skel

inline operator  Widget ()

Widget

[const]

LineEdit_base (class)

LineEdit_base

LineEdit_stub (class)

LineEdit_stub

LineEdit_skel (class)

LineEdit_skel

inline operator  Widget ()

Widget

[const]

GuiFactory_base (class)

GuiFactory_base

GuiFactory_stub (class)

GuiFactory_stub

GuiFactory_skel (class)

GuiFactory_skel

GenericGuiFactory_base (class)

GenericGuiFactory_base

GenericGuiFactory_stub (class)

GenericGuiFactory_stub

GenericGuiFactory_skel (class)

GenericGuiFactory_skel

inline operator  GuiFactory ()

GuiFactory

[const]

inline long  Widget::widgetID ()

Widget::widgetID

inline Arts::Widget  Widget::parent ()

Widget::parent

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

Widget::parent

inline long  Widget::x ()

Widget::x

inline void  Widget::x (long _newValue)

Widget::x

inline long  Widget::y ()

Widget::y

inline void  Widget::y (long _newValue)

Widget::y

inline long  Widget::width ()

Widget::width

inline void  Widget::width (long _newValue)

Widget::width

inline long  Widget::height ()

Widget::height

inline void  Widget::height (long _newValue)

Widget::height

inline bool  Widget::visible ()

Widget::visible

inline void  Widget::visible (bool _newValue)

Widget::visible

inline void  Widget::show ()

Widget::show

inline void  Widget::hide ()

Widget::hide

inline long  Button::widgetID ()

Button::widgetID

inline Arts::Widget  Button::parent ()

Button::parent

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

Button::parent

inline long  Button::x ()

Button::x

inline void  Button::x (long _newValue)

Button::x

inline long  Button::y ()

Button::y

inline void  Button::y (long _newValue)

Button::y

inline long  Button::width ()

Button::width

inline void  Button::width (long _newValue)

Button::width

inline long  Button::height ()

Button::height

inline void  Button::height (long _newValue)

Button::height

inline bool  Button::visible ()

Button::visible

inline void  Button::visible (bool _newValue)

Button::visible

inline void  Button::show ()

Button::show

inline void  Button::hide ()

Button::hide

inline std::string  Button::text ()

Button::text

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

Button::text

inline long  Poti::widgetID ()

Poti::widgetID

inline Arts::Widget  Poti::parent ()

Poti::parent

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

Poti::parent

inline long  Poti::x ()

Poti::x

inline void  Poti::x (long _newValue)

Poti::x

inline long  Poti::y ()

Poti::y

inline void  Poti::y (long _newValue)

Poti::y

inline long  Poti::width ()

Poti::width

inline void  Poti::width (long _newValue)

Poti::width

inline long  Poti::height ()

Poti::height

inline void  Poti::height (long _newValue)

Poti::height

inline bool  Poti::visible ()

Poti::visible

inline void  Poti::visible (bool _newValue)

Poti::visible

inline void  Poti::show ()

Poti::show

inline void  Poti::hide ()

Poti::hide

inline std::string  Poti::text ()

Poti::text

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

Poti::text

inline std::string  Poti::color ()

Poti::color

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

Poti::color

inline float  Poti::min ()

Poti::min

inline void  Poti::min (float _newValue)

Poti::min

inline float  Poti::max ()

Poti::max

inline void  Poti::max (float _newValue)

Poti::max

inline float  Poti::value ()

Poti::value

inline void  Poti::value (float _newValue)

Poti::value

inline long  LineEdit::widgetID ()

LineEdit::widgetID

inline Arts::Widget  LineEdit::parent ()

LineEdit::parent

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

LineEdit::parent

inline long  LineEdit::x ()

LineEdit::x

inline void  LineEdit::x (long _newValue)

LineEdit::x

inline long  LineEdit::y ()

LineEdit::y

inline void  LineEdit::y (long _newValue)

LineEdit::y

inline long  LineEdit::width ()

LineEdit::width

inline void  LineEdit::width (long _newValue)

LineEdit::width

inline long  LineEdit::height ()

LineEdit::height

inline void  LineEdit::height (long _newValue)

LineEdit::height

inline bool  LineEdit::visible ()

LineEdit::visible

inline void  LineEdit::visible (bool _newValue)

LineEdit::visible

inline void  LineEdit::show ()

LineEdit::show

inline void  LineEdit::hide ()

LineEdit::hide

inline std::string  LineEdit::text ()

LineEdit::text

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

LineEdit::text

inline Arts::Widget  GuiFactory::createGui (Arts::Object runningObject)

GuiFactory::createGui

inline Arts::Widget  GenericGuiFactory::createGui (Arts::Object runningObject)

GenericGuiFactory::createGui

ObjectCache (class)

ObjectCache

MidiReleaseHelper (class)

MidiReleaseHelper

Synth_CAPTURE_WAV (class)

Synth_CAPTURE_WAV

Synth_NIL (class)

Synth_NIL

Synth_DEBUG (class)

Synth_DEBUG

Synth_DATA (class)

Synth_DATA

Synth_ATAN_SATURATE (class)

Synth_ATAN_SATURATE

Synth_BRICKWALL_LIMITER (class)

Synth_BRICKWALL_LIMITER

Synth_AUTOPANNER (class)

Synth_AUTOPANNER

Synth_DELAY (class)

Synth_DELAY

Synth_CDELAY (class)

Synth_CDELAY

Synth_FM_SOURCE (class)

Synth_FM_SOURCE

Synth_TREMOLO (class)

Synth_TREMOLO

Synth_FX_CFLANGER (class)

Synth_FX_CFLANGER

Synth_NOISE (class)

Synth_NOISE

Synth_WAVE_TRI (class)

Synth_WAVE_TRI

Synth_WAVE_SQUARE (class)

Synth_WAVE_SQUARE

Synth_WAVE_PULSE (class)

Synth_WAVE_PULSE

Synth_WAVE_SOFTSAW (class)

Synth_WAVE_SOFTSAW

Synth_OSC_SAW (class)

Synth_OSC_SAW

Synth_ENVELOPE_ADSR (class)

Synth_ENVELOPE_ADSR

Synth_SHELVE_CUTOFF (class)

Synth_SHELVE_CUTOFF

Synth_XFADE (class)

Synth_XFADE

Synth_MIDI_TEST (class)

Synth_MIDI_TEST

Synth_MIDI_DEBUG (class)

Synth_MIDI_DEBUG

Synth_FREEVERB (class)

Synth_FREEVERB

FreeverbGuiFactory (class)

FreeverbGuiFactory

Synth_CPU_LOAD (class)

Synth_CPU_LOAD

Synth_STD_EQUALIZER (class)

Synth_STD_EQUALIZER

Synth_RC (class)

Synth_RC

Synth_MOOG_VCF (class)

Synth_MOOG_VCF

Synth_PSCALE (class)

Synth_PSCALE

Synth_SEQUENCE (class)

Synth_SEQUENCE

Synth_PITCH_SHIFT (class)

Synth_PITCH_SHIFT

Interface_MIDI_NOTE (class)

Interface_MIDI_NOTE

Synth_STRUCT_KILL (class)

Synth_STRUCT_KILL

ObjectCache_base (class)

ObjectCache_base

ObjectCache_stub (class)

ObjectCache_stub

ObjectCache_skel (class)

ObjectCache_skel

MidiReleaseHelper_base (class)

MidiReleaseHelper_base

MidiReleaseHelper_stub (class)

MidiReleaseHelper_stub

MidiReleaseHelper_skel (class)

MidiReleaseHelper_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_CAPTURE_WAV_base (class)

Synth_CAPTURE_WAV_base

Synth_CAPTURE_WAV_stub (class)

Synth_CAPTURE_WAV_stub

Synth_CAPTURE_WAV_skel (class)

Synth_CAPTURE_WAV_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_NIL_base (class)

Synth_NIL_base

Synth_NIL_stub (class)

Synth_NIL_stub

Synth_NIL_skel (class)

Synth_NIL_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_DEBUG_base (class)

Synth_DEBUG_base

Synth_DEBUG_stub (class)

Synth_DEBUG_stub

Synth_DEBUG_skel (class)

Synth_DEBUG_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_DATA_base (class)

Synth_DATA_base

Synth_DATA_stub (class)

Synth_DATA_stub

Synth_DATA_skel (class)

Synth_DATA_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_ATAN_SATURATE_base (class)

Synth_ATAN_SATURATE_base

Synth_ATAN_SATURATE_stub (class)

Synth_ATAN_SATURATE_stub

Synth_ATAN_SATURATE_skel (class)

Synth_ATAN_SATURATE_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_BRICKWALL_LIMITER_base (class)

Synth_BRICKWALL_LIMITER_base

Synth_BRICKWALL_LIMITER_stub (class)

Synth_BRICKWALL_LIMITER_stub

Synth_BRICKWALL_LIMITER_skel (class)

Synth_BRICKWALL_LIMITER_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_AUTOPANNER_base (class)

Synth_AUTOPANNER_base

Synth_AUTOPANNER_stub (class)

Synth_AUTOPANNER_stub

Synth_AUTOPANNER_skel (class)

Synth_AUTOPANNER_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_DELAY_base (class)

Synth_DELAY_base

Synth_DELAY_stub (class)

Synth_DELAY_stub

Synth_DELAY_skel (class)

Synth_DELAY_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_CDELAY_base (class)

Synth_CDELAY_base

Synth_CDELAY_stub (class)

Synth_CDELAY_stub

Synth_CDELAY_skel (class)

Synth_CDELAY_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_FM_SOURCE_base (class)

Synth_FM_SOURCE_base

Synth_FM_SOURCE_stub (class)

Synth_FM_SOURCE_stub

Synth_FM_SOURCE_skel (class)

Synth_FM_SOURCE_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_TREMOLO_base (class)

Synth_TREMOLO_base

Synth_TREMOLO_stub (class)

Synth_TREMOLO_stub

Synth_TREMOLO_skel (class)

Synth_TREMOLO_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_FX_CFLANGER_base (class)

Synth_FX_CFLANGER_base

Synth_FX_CFLANGER_stub (class)

Synth_FX_CFLANGER_stub

Synth_FX_CFLANGER_skel (class)

Synth_FX_CFLANGER_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_NOISE_base (class)

Synth_NOISE_base

Synth_NOISE_stub (class)

Synth_NOISE_stub

Synth_NOISE_skel (class)

Synth_NOISE_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_WAVE_TRI_base (class)

Synth_WAVE_TRI_base

Synth_WAVE_TRI_stub (class)

Synth_WAVE_TRI_stub

Synth_WAVE_TRI_skel (class)

Synth_WAVE_TRI_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_WAVE_SQUARE_base (class)

Synth_WAVE_SQUARE_base

Synth_WAVE_SQUARE_stub (class)

Synth_WAVE_SQUARE_stub

Synth_WAVE_SQUARE_skel (class)

Synth_WAVE_SQUARE_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_WAVE_PULSE_base (class)

Synth_WAVE_PULSE_base

Synth_WAVE_PULSE_stub (class)

Synth_WAVE_PULSE_stub

Synth_WAVE_PULSE_skel (class)

Synth_WAVE_PULSE_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_WAVE_SOFTSAW_base (class)

Synth_WAVE_SOFTSAW_base

Synth_WAVE_SOFTSAW_stub (class)

Synth_WAVE_SOFTSAW_stub

Synth_WAVE_SOFTSAW_skel (class)

Synth_WAVE_SOFTSAW_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_OSC_SAW_base (class)

Synth_OSC_SAW_base

Synth_OSC_SAW_stub (class)

Synth_OSC_SAW_stub

Synth_OSC_SAW_skel (class)

Synth_OSC_SAW_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_ENVELOPE_ADSR_base (class)

Synth_ENVELOPE_ADSR_base

Synth_ENVELOPE_ADSR_stub (class)

Synth_ENVELOPE_ADSR_stub

Synth_ENVELOPE_ADSR_skel (class)

Synth_ENVELOPE_ADSR_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_SHELVE_CUTOFF_base (class)

Synth_SHELVE_CUTOFF_base

Synth_SHELVE_CUTOFF_stub (class)

Synth_SHELVE_CUTOFF_stub

Synth_SHELVE_CUTOFF_skel (class)

Synth_SHELVE_CUTOFF_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_XFADE_base (class)

Synth_XFADE_base

Synth_XFADE_stub (class)

Synth_XFADE_stub

Synth_XFADE_skel (class)

Synth_XFADE_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_MIDI_TEST_base (class)

Synth_MIDI_TEST_base

Synth_MIDI_TEST_stub (class)

Synth_MIDI_TEST_stub

Synth_MIDI_TEST_skel (class)

Synth_MIDI_TEST_skel

inline operator  SynthModule ()

SynthModule

[const]

inline operator  MidiPort ()

MidiPort

[const]

Synth_MIDI_DEBUG_base (class)

Synth_MIDI_DEBUG_base

Synth_MIDI_DEBUG_stub (class)

Synth_MIDI_DEBUG_stub

Synth_MIDI_DEBUG_skel (class)

Synth_MIDI_DEBUG_skel

inline operator  SynthModule ()

SynthModule

[const]

inline operator  MidiPort ()

MidiPort

[const]

Synth_FREEVERB_base (class)

Synth_FREEVERB_base

Synth_FREEVERB_stub (class)

Synth_FREEVERB_stub

Synth_FREEVERB_skel (class)

Synth_FREEVERB_skel

inline operator  StereoEffect ()

StereoEffect

[const]

inline operator  SynthModule ()

SynthModule

[const]

FreeverbGuiFactory_base (class)

FreeverbGuiFactory_base

FreeverbGuiFactory_stub (class)

FreeverbGuiFactory_stub

FreeverbGuiFactory_skel (class)

FreeverbGuiFactory_skel

inline operator  GuiFactory ()

GuiFactory

[const]

Synth_CPU_LOAD_base (class)

Synth_CPU_LOAD_base

Synth_CPU_LOAD_stub (class)

Synth_CPU_LOAD_stub

Synth_CPU_LOAD_skel (class)

Synth_CPU_LOAD_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_STD_EQUALIZER_base (class)

Synth_STD_EQUALIZER_base

Synth_STD_EQUALIZER_stub (class)

Synth_STD_EQUALIZER_stub

Synth_STD_EQUALIZER_skel (class)

Synth_STD_EQUALIZER_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_RC_base (class)

Synth_RC_base

Synth_RC_stub (class)

Synth_RC_stub

Synth_RC_skel (class)

Synth_RC_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_MOOG_VCF_base (class)

Synth_MOOG_VCF_base

Synth_MOOG_VCF_stub (class)

Synth_MOOG_VCF_stub

Synth_MOOG_VCF_skel (class)

Synth_MOOG_VCF_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_PSCALE_base (class)

Synth_PSCALE_base

Synth_PSCALE_stub (class)

Synth_PSCALE_stub

Synth_PSCALE_skel (class)

Synth_PSCALE_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_SEQUENCE_base (class)

Synth_SEQUENCE_base

Synth_SEQUENCE_stub (class)

Synth_SEQUENCE_stub

Synth_SEQUENCE_skel (class)

Synth_SEQUENCE_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_PITCH_SHIFT_base (class)

Synth_PITCH_SHIFT_base

Synth_PITCH_SHIFT_stub (class)

Synth_PITCH_SHIFT_stub

Synth_PITCH_SHIFT_skel (class)

Synth_PITCH_SHIFT_skel

inline operator  SynthModule ()

SynthModule

[const]

Interface_MIDI_NOTE_base (class)

Interface_MIDI_NOTE_base

Interface_MIDI_NOTE_stub (class)

Interface_MIDI_NOTE_stub

Interface_MIDI_NOTE_skel (class)

Interface_MIDI_NOTE_skel

inline operator  SynthModule ()

SynthModule

[const]

Synth_STRUCT_KILL_base (class)

Synth_STRUCT_KILL_base

Synth_STRUCT_KILL_stub (class)

Synth_STRUCT_KILL_stub

Synth_STRUCT_KILL_skel (class)

Synth_STRUCT_KILL_skel

inline operator  SynthModule ()

SynthModule

[const]

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

ObjectCache::put

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

ObjectCache::get

inline Arts::AutoSuspendState  MidiReleaseHelper::autoSuspend ()

MidiReleaseHelper::autoSuspend

inline void  MidiReleaseHelper::start ()

MidiReleaseHelper::start

inline void  MidiReleaseHelper::stop ()

MidiReleaseHelper::stop

inline void  MidiReleaseHelper::streamInit ()

MidiReleaseHelper::streamInit

inline void  MidiReleaseHelper::streamStart ()

MidiReleaseHelper::streamStart

inline void  MidiReleaseHelper::streamEnd ()

MidiReleaseHelper::streamEnd

inline Arts::SynthModule  MidiReleaseHelper::voice ()

MidiReleaseHelper::voice

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

MidiReleaseHelper::voice

inline std::string  MidiReleaseHelper::name ()

MidiReleaseHelper::name

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

MidiReleaseHelper::name

inline Arts::ObjectCache  MidiReleaseHelper::cache ()

MidiReleaseHelper::cache

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

MidiReleaseHelper::cache

inline bool  MidiReleaseHelper::terminate ()

MidiReleaseHelper::terminate

inline Arts::AutoSuspendState  Synth_CAPTURE_WAV::autoSuspend ()

Synth_CAPTURE_WAV::autoSuspend

inline void  Synth_CAPTURE_WAV::start ()

Synth_CAPTURE_WAV::start

inline void  Synth_CAPTURE_WAV::stop ()

Synth_CAPTURE_WAV::stop

inline void  Synth_CAPTURE_WAV::streamInit ()

Synth_CAPTURE_WAV::streamInit

inline void  Synth_CAPTURE_WAV::streamStart ()

Synth_CAPTURE_WAV::streamStart

inline void  Synth_CAPTURE_WAV::streamEnd ()

Synth_CAPTURE_WAV::streamEnd

inline Arts::AutoSuspendState  Synth_NIL::autoSuspend ()

Synth_NIL::autoSuspend

inline void  Synth_NIL::start ()

Synth_NIL::start

inline void  Synth_NIL::stop ()

Synth_NIL::stop

inline void  Synth_NIL::streamInit ()

Synth_NIL::streamInit

inline void  Synth_NIL::streamStart ()

Synth_NIL::streamStart

inline void  Synth_NIL::streamEnd ()

Synth_NIL::streamEnd

inline Arts::AutoSuspendState  Synth_DEBUG::autoSuspend ()

Synth_DEBUG::autoSuspend

inline void  Synth_DEBUG::start ()

Synth_DEBUG::start

inline void  Synth_DEBUG::stop ()

Synth_DEBUG::stop

inline void  Synth_DEBUG::streamInit ()

Synth_DEBUG::streamInit

inline void  Synth_DEBUG::streamStart ()

Synth_DEBUG::streamStart

inline void  Synth_DEBUG::streamEnd ()

Synth_DEBUG::streamEnd

inline std::string  Synth_DEBUG::comment ()

Synth_DEBUG::comment

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

Synth_DEBUG::comment

inline Arts::AutoSuspendState  Synth_DATA::autoSuspend ()

Synth_DATA::autoSuspend

inline void  Synth_DATA::start ()

Synth_DATA::start

inline void  Synth_DATA::stop ()

Synth_DATA::stop

inline void  Synth_DATA::streamInit ()

Synth_DATA::streamInit

inline void  Synth_DATA::streamStart ()

Synth_DATA::streamStart

inline void  Synth_DATA::streamEnd ()

Synth_DATA::streamEnd

inline float  Synth_DATA::value ()

Synth_DATA::value

inline void  Synth_DATA::value (float _newValue)

Synth_DATA::value

inline Arts::AutoSuspendState  Synth_ATAN_SATURATE::autoSuspend ()

Synth_ATAN_SATURATE::autoSuspend

inline void  Synth_ATAN_SATURATE::start ()

Synth_ATAN_SATURATE::start

inline void  Synth_ATAN_SATURATE::stop ()

Synth_ATAN_SATURATE::stop

inline void  Synth_ATAN_SATURATE::streamInit ()

Synth_ATAN_SATURATE::streamInit

inline void  Synth_ATAN_SATURATE::streamStart ()

Synth_ATAN_SATURATE::streamStart

inline void  Synth_ATAN_SATURATE::streamEnd ()

Synth_ATAN_SATURATE::streamEnd

inline float  Synth_ATAN_SATURATE::inscale ()

Synth_ATAN_SATURATE::inscale

inline void  Synth_ATAN_SATURATE::inscale (float _newValue)

Synth_ATAN_SATURATE::inscale

inline Arts::AutoSuspendState  Synth_BRICKWALL_LIMITER::autoSuspend ()

Synth_BRICKWALL_LIMITER::autoSuspend

inline void  Synth_BRICKWALL_LIMITER::start ()

Synth_BRICKWALL_LIMITER::start

inline void  Synth_BRICKWALL_LIMITER::stop ()

Synth_BRICKWALL_LIMITER::stop

inline void  Synth_BRICKWALL_LIMITER::streamInit ()

Synth_BRICKWALL_LIMITER::streamInit

inline void  Synth_BRICKWALL_LIMITER::streamStart ()

Synth_BRICKWALL_LIMITER::streamStart

inline void  Synth_BRICKWALL_LIMITER::streamEnd ()

Synth_BRICKWALL_LIMITER::streamEnd

inline Arts::AutoSuspendState  Synth_AUTOPANNER::autoSuspend ()

Synth_AUTOPANNER::autoSuspend

inline void  Synth_AUTOPANNER::start ()

Synth_AUTOPANNER::start

inline void  Synth_AUTOPANNER::stop ()

Synth_AUTOPANNER::stop

inline void  Synth_AUTOPANNER::streamInit ()

Synth_AUTOPANNER::streamInit

inline void  Synth_AUTOPANNER::streamStart ()

Synth_AUTOPANNER::streamStart

inline void  Synth_AUTOPANNER::streamEnd ()

Synth_AUTOPANNER::streamEnd

inline Arts::AutoSuspendState  Synth_DELAY::autoSuspend ()

Synth_DELAY::autoSuspend

inline void  Synth_DELAY::start ()

Synth_DELAY::start

inline void  Synth_DELAY::stop ()

Synth_DELAY::stop

inline void  Synth_DELAY::streamInit ()

Synth_DELAY::streamInit

inline void  Synth_DELAY::streamStart ()

Synth_DELAY::streamStart

inline void  Synth_DELAY::streamEnd ()

Synth_DELAY::streamEnd

inline Arts::AutoSuspendState  Synth_CDELAY::autoSuspend ()

Synth_CDELAY::autoSuspend

inline void  Synth_CDELAY::start ()

Synth_CDELAY::start

inline void  Synth_CDELAY::stop ()

Synth_CDELAY::stop

inline void  Synth_CDELAY::streamInit ()

Synth_CDELAY::streamInit

inline void  Synth_CDELAY::streamStart ()

Synth_CDELAY::streamStart

inline void  Synth_CDELAY::streamEnd ()

Synth_CDELAY::streamEnd

inline float  Synth_CDELAY::time ()

Synth_CDELAY::time

inline void  Synth_CDELAY::time (float _newValue)

Synth_CDELAY::time

inline Arts::AutoSuspendState  Synth_FM_SOURCE::autoSuspend ()

Synth_FM_SOURCE::autoSuspend

inline void  Synth_FM_SOURCE::start ()

Synth_FM_SOURCE::start

inline void  Synth_FM_SOURCE::stop ()

Synth_FM_SOURCE::stop

inline void  Synth_FM_SOURCE::streamInit ()

Synth_FM_SOURCE::streamInit

inline void  Synth_FM_SOURCE::streamStart ()

Synth_FM_SOURCE::streamStart

inline void  Synth_FM_SOURCE::streamEnd ()

Synth_FM_SOURCE::streamEnd

inline Arts::AutoSuspendState  Synth_TREMOLO::autoSuspend ()

Synth_TREMOLO::autoSuspend

inline void  Synth_TREMOLO::start ()

Synth_TREMOLO::start

inline void  Synth_TREMOLO::stop ()

Synth_TREMOLO::stop

inline void  Synth_TREMOLO::streamInit ()

Synth_TREMOLO::streamInit

inline void  Synth_TREMOLO::streamStart ()

Synth_TREMOLO::streamStart

inline void  Synth_TREMOLO::streamEnd ()

Synth_TREMOLO::streamEnd

inline Arts::AutoSuspendState  Synth_FX_CFLANGER::autoSuspend ()

Synth_FX_CFLANGER::autoSuspend

inline void  Synth_FX_CFLANGER::start ()

Synth_FX_CFLANGER::start

inline void  Synth_FX_CFLANGER::stop ()

Synth_FX_CFLANGER::stop

inline void  Synth_FX_CFLANGER::streamInit ()

Synth_FX_CFLANGER::streamInit

inline void  Synth_FX_CFLANGER::streamStart ()

Synth_FX_CFLANGER::streamStart

inline void  Synth_FX_CFLANGER::streamEnd ()

Synth_FX_CFLANGER::streamEnd

inline float  Synth_FX_CFLANGER::mintime ()

Synth_FX_CFLANGER::mintime

inline void  Synth_FX_CFLANGER::mintime (float _newValue)

Synth_FX_CFLANGER::mintime

inline float  Synth_FX_CFLANGER::maxtime ()

Synth_FX_CFLANGER::maxtime

inline void  Synth_FX_CFLANGER::maxtime (float _newValue)

Synth_FX_CFLANGER::maxtime

inline Arts::AutoSuspendState  Synth_NOISE::autoSuspend ()

Synth_NOISE::autoSuspend

inline void  Synth_NOISE::start ()

Synth_NOISE::start

inline void  Synth_NOISE::stop ()

Synth_NOISE::stop

inline void  Synth_NOISE::streamInit ()

Synth_NOISE::streamInit

inline void  Synth_NOISE::streamStart ()

Synth_NOISE::streamStart

inline void  Synth_NOISE::streamEnd ()

Synth_NOISE::streamEnd

inline Arts::AutoSuspendState  Synth_WAVE_TRI::autoSuspend ()

Synth_WAVE_TRI::autoSuspend

inline void  Synth_WAVE_TRI::start ()

Synth_WAVE_TRI::start

inline void  Synth_WAVE_TRI::stop ()

Synth_WAVE_TRI::stop

inline void  Synth_WAVE_TRI::streamInit ()

Synth_WAVE_TRI::streamInit

inline void  Synth_WAVE_TRI::streamStart ()

Synth_WAVE_TRI::streamStart

inline void  Synth_WAVE_TRI::streamEnd ()

Synth_WAVE_TRI::streamEnd

inline Arts::AutoSuspendState  Synth_WAVE_SQUARE::autoSuspend ()

Synth_WAVE_SQUARE::autoSuspend

inline void  Synth_WAVE_SQUARE::start ()

Synth_WAVE_SQUARE::start

inline void  Synth_WAVE_SQUARE::stop ()

Synth_WAVE_SQUARE::stop

inline void  Synth_WAVE_SQUARE::streamInit ()

Synth_WAVE_SQUARE::streamInit

inline void  Synth_WAVE_SQUARE::streamStart ()

Synth_WAVE_SQUARE::streamStart

inline void  Synth_WAVE_SQUARE::streamEnd ()

Synth_WAVE_SQUARE::streamEnd

inline Arts::AutoSuspendState  Synth_WAVE_PULSE::autoSuspend ()

Synth_WAVE_PULSE::autoSuspend

inline void  Synth_WAVE_PULSE::start ()

Synth_WAVE_PULSE::start

inline void  Synth_WAVE_PULSE::stop ()

Synth_WAVE_PULSE::stop

inline void  Synth_WAVE_PULSE::streamInit ()

Synth_WAVE_PULSE::streamInit

inline void  Synth_WAVE_PULSE::streamStart ()

Synth_WAVE_PULSE::streamStart

inline void  Synth_WAVE_PULSE::streamEnd ()

Synth_WAVE_PULSE::streamEnd

inline float  Synth_WAVE_PULSE::dutycycle ()

Synth_WAVE_PULSE::dutycycle

inline void  Synth_WAVE_PULSE::dutycycle (float _newValue)

Synth_WAVE_PULSE::dutycycle

inline Arts::AutoSuspendState  Synth_WAVE_SOFTSAW::autoSuspend ()

Synth_WAVE_SOFTSAW::autoSuspend

inline void  Synth_WAVE_SOFTSAW::start ()

Synth_WAVE_SOFTSAW::start

inline void  Synth_WAVE_SOFTSAW::stop ()

Synth_WAVE_SOFTSAW::stop

inline void  Synth_WAVE_SOFTSAW::streamInit ()

Synth_WAVE_SOFTSAW::streamInit

inline void  Synth_WAVE_SOFTSAW::streamStart ()

Synth_WAVE_SOFTSAW::streamStart

inline void  Synth_WAVE_SOFTSAW::streamEnd ()

Synth_WAVE_SOFTSAW::streamEnd

inline Arts::AutoSuspendState  Synth_OSC_SAW::autoSuspend ()

Synth_OSC_SAW::autoSuspend

inline void  Synth_OSC_SAW::start ()

Synth_OSC_SAW::start

inline void  Synth_OSC_SAW::stop ()

Synth_OSC_SAW::stop

inline void  Synth_OSC_SAW::streamInit ()

Synth_OSC_SAW::streamInit

inline void  Synth_OSC_SAW::streamStart ()

Synth_OSC_SAW::streamStart

inline void  Synth_OSC_SAW::streamEnd ()

Synth_OSC_SAW::streamEnd

inline Arts::AutoSuspendState  Synth_ENVELOPE_ADSR::autoSuspend ()

Synth_ENVELOPE_ADSR::autoSuspend

inline void  Synth_ENVELOPE_ADSR::start ()

Synth_ENVELOPE_ADSR::start

inline void  Synth_ENVELOPE_ADSR::stop ()

Synth_ENVELOPE_ADSR::stop

inline void  Synth_ENVELOPE_ADSR::streamInit ()

Synth_ENVELOPE_ADSR::streamInit

inline void  Synth_ENVELOPE_ADSR::streamStart ()

Synth_ENVELOPE_ADSR::streamStart

inline void  Synth_ENVELOPE_ADSR::streamEnd ()

Synth_ENVELOPE_ADSR::streamEnd

inline Arts::AutoSuspendState  Synth_SHELVE_CUTOFF::autoSuspend ()

Synth_SHELVE_CUTOFF::autoSuspend

inline void  Synth_SHELVE_CUTOFF::start ()

Synth_SHELVE_CUTOFF::start

inline void  Synth_SHELVE_CUTOFF::stop ()

Synth_SHELVE_CUTOFF::stop

inline void  Synth_SHELVE_CUTOFF::streamInit ()

Synth_SHELVE_CUTOFF::streamInit

inline void  Synth_SHELVE_CUTOFF::streamStart ()

Synth_SHELVE_CUTOFF::streamStart

inline void  Synth_SHELVE_CUTOFF::streamEnd ()

Synth_SHELVE_CUTOFF::streamEnd

inline Arts::AutoSuspendState  Synth_XFADE::autoSuspend ()

Synth_XFADE::autoSuspend

inline void  Synth_XFADE::start ()

Synth_XFADE::start

inline void  Synth_XFADE::stop ()

Synth_XFADE::stop

inline void  Synth_XFADE::streamInit ()

Synth_XFADE::streamInit

inline void  Synth_XFADE::streamStart ()

Synth_XFADE::streamStart

inline void  Synth_XFADE::streamEnd ()

Synth_XFADE::streamEnd

inline Arts::AutoSuspendState  Synth_MIDI_TEST::autoSuspend ()

Synth_MIDI_TEST::autoSuspend

inline void  Synth_MIDI_TEST::start ()

Synth_MIDI_TEST::start

inline void  Synth_MIDI_TEST::stop ()

Synth_MIDI_TEST::stop

inline void  Synth_MIDI_TEST::streamInit ()

Synth_MIDI_TEST::streamInit

inline void  Synth_MIDI_TEST::streamStart ()

Synth_MIDI_TEST::streamStart

inline void  Synth_MIDI_TEST::streamEnd ()

Synth_MIDI_TEST::streamEnd

inline Arts::TimeStamp  Synth_MIDI_TEST::time ()

Synth_MIDI_TEST::time

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

Synth_MIDI_TEST::processCommand

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

Synth_MIDI_TEST::processEvent

inline std::string  Synth_MIDI_TEST::filename ()

Synth_MIDI_TEST::filename

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

Synth_MIDI_TEST::filename

inline Arts::AutoSuspendState  Synth_MIDI_DEBUG::autoSuspend ()

Synth_MIDI_DEBUG::autoSuspend

inline void  Synth_MIDI_DEBUG::start ()

Synth_MIDI_DEBUG::start

inline void  Synth_MIDI_DEBUG::stop ()

Synth_MIDI_DEBUG::stop

inline void  Synth_MIDI_DEBUG::streamInit ()

Synth_MIDI_DEBUG::streamInit

inline void  Synth_MIDI_DEBUG::streamStart ()

Synth_MIDI_DEBUG::streamStart

inline void  Synth_MIDI_DEBUG::streamEnd ()

Synth_MIDI_DEBUG::streamEnd

inline Arts::TimeStamp  Synth_MIDI_DEBUG::time ()

Synth_MIDI_DEBUG::time

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

Synth_MIDI_DEBUG::processCommand

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

Synth_MIDI_DEBUG::processEvent

inline Arts::AutoSuspendState  Synth_FREEVERB::autoSuspend ()

Synth_FREEVERB::autoSuspend

inline void  Synth_FREEVERB::start ()

Synth_FREEVERB::start

inline void  Synth_FREEVERB::stop ()

Synth_FREEVERB::stop

inline void  Synth_FREEVERB::streamInit ()

Synth_FREEVERB::streamInit

inline void  Synth_FREEVERB::streamStart ()

Synth_FREEVERB::streamStart

inline void  Synth_FREEVERB::streamEnd ()

Synth_FREEVERB::streamEnd

inline float  Synth_FREEVERB::roomsize ()

Synth_FREEVERB::roomsize

inline void  Synth_FREEVERB::roomsize (float _newValue)

Synth_FREEVERB::roomsize

inline float  Synth_FREEVERB::damp ()

Synth_FREEVERB::damp

inline void  Synth_FREEVERB::damp (float _newValue)

Synth_FREEVERB::damp

inline float  Synth_FREEVERB::wet ()

Synth_FREEVERB::wet

inline void  Synth_FREEVERB::wet (float _newValue)

Synth_FREEVERB::wet

inline float  Synth_FREEVERB::dry ()

Synth_FREEVERB::dry

inline void  Synth_FREEVERB::dry (float _newValue)

Synth_FREEVERB::dry

inline float  Synth_FREEVERB::width ()

Synth_FREEVERB::width

inline void  Synth_FREEVERB::width (float _newValue)

Synth_FREEVERB::width

inline float  Synth_FREEVERB::mode ()

Synth_FREEVERB::mode

inline void  Synth_FREEVERB::mode (float _newValue)

Synth_FREEVERB::mode

inline Arts::Widget  FreeverbGuiFactory::createGui (Arts::Object runningObject)

FreeverbGuiFactory::createGui

inline Arts::AutoSuspendState  Synth_CPU_LOAD::autoSuspend ()

Synth_CPU_LOAD::autoSuspend

inline void  Synth_CPU_LOAD::start ()

Synth_CPU_LOAD::start

inline void  Synth_CPU_LOAD::stop ()

Synth_CPU_LOAD::stop

inline void  Synth_CPU_LOAD::streamInit ()

Synth_CPU_LOAD::streamInit

inline void  Synth_CPU_LOAD::streamStart ()

Synth_CPU_LOAD::streamStart

inline void  Synth_CPU_LOAD::streamEnd ()

Synth_CPU_LOAD::streamEnd

inline long  Synth_CPU_LOAD::count ()

Synth_CPU_LOAD::count

inline void  Synth_CPU_LOAD::count (long _newValue)

Synth_CPU_LOAD::count

inline Arts::AutoSuspendState  Synth_STD_EQUALIZER::autoSuspend ()

Synth_STD_EQUALIZER::autoSuspend

inline void  Synth_STD_EQUALIZER::start ()

Synth_STD_EQUALIZER::start

inline void  Synth_STD_EQUALIZER::stop ()

Synth_STD_EQUALIZER::stop

inline void  Synth_STD_EQUALIZER::streamInit ()

Synth_STD_EQUALIZER::streamInit

inline void  Synth_STD_EQUALIZER::streamStart ()

Synth_STD_EQUALIZER::streamStart

inline void  Synth_STD_EQUALIZER::streamEnd ()

Synth_STD_EQUALIZER::streamEnd

inline float  Synth_STD_EQUALIZER::low ()

Synth_STD_EQUALIZER::low

inline void  Synth_STD_EQUALIZER::low (float _newValue)

Synth_STD_EQUALIZER::low

inline float  Synth_STD_EQUALIZER::mid ()

Synth_STD_EQUALIZER::mid

inline void  Synth_STD_EQUALIZER::mid (float _newValue)

Synth_STD_EQUALIZER::mid

inline float  Synth_STD_EQUALIZER::high ()

Synth_STD_EQUALIZER::high

inline void  Synth_STD_EQUALIZER::high (float _newValue)

Synth_STD_EQUALIZER::high

inline float  Synth_STD_EQUALIZER::frequency ()

Synth_STD_EQUALIZER::frequency

inline void  Synth_STD_EQUALIZER::frequency (float _newValue)

Synth_STD_EQUALIZER::frequency

inline float  Synth_STD_EQUALIZER::q ()

Synth_STD_EQUALIZER::q

inline void  Synth_STD_EQUALIZER::q (float _newValue)

Synth_STD_EQUALIZER::q

inline Arts::AutoSuspendState  Synth_RC::autoSuspend ()

Synth_RC::autoSuspend

inline void  Synth_RC::start ()

Synth_RC::start

inline void  Synth_RC::stop ()

Synth_RC::stop

inline void  Synth_RC::streamInit ()

Synth_RC::streamInit

inline void  Synth_RC::streamStart ()

Synth_RC::streamStart

inline void  Synth_RC::streamEnd ()

Synth_RC::streamEnd

inline float  Synth_RC::b ()

Synth_RC::b

inline void  Synth_RC::b (float _newValue)

Synth_RC::b

inline float  Synth_RC::f ()

Synth_RC::f

inline void  Synth_RC::f (float _newValue)

Synth_RC::f

inline Arts::AutoSuspendState  Synth_MOOG_VCF::autoSuspend ()

Synth_MOOG_VCF::autoSuspend

inline void  Synth_MOOG_VCF::start ()

Synth_MOOG_VCF::start

inline void  Synth_MOOG_VCF::stop ()

Synth_MOOG_VCF::stop

inline void  Synth_MOOG_VCF::streamInit ()

Synth_MOOG_VCF::streamInit

inline void  Synth_MOOG_VCF::streamStart ()

Synth_MOOG_VCF::streamStart

inline void  Synth_MOOG_VCF::streamEnd ()

Synth_MOOG_VCF::streamEnd

inline float  Synth_MOOG_VCF::frequency ()

Synth_MOOG_VCF::frequency

inline void  Synth_MOOG_VCF::frequency (float _newValue)

Synth_MOOG_VCF::frequency

inline float  Synth_MOOG_VCF::resonance ()

Synth_MOOG_VCF::resonance

inline void  Synth_MOOG_VCF::resonance (float _newValue)

Synth_MOOG_VCF::resonance

inline Arts::AutoSuspendState  Synth_PSCALE::autoSuspend ()

Synth_PSCALE::autoSuspend

inline void  Synth_PSCALE::start ()

Synth_PSCALE::start

inline void  Synth_PSCALE::stop ()

Synth_PSCALE::stop

inline void  Synth_PSCALE::streamInit ()

Synth_PSCALE::streamInit

inline void  Synth_PSCALE::streamStart ()

Synth_PSCALE::streamStart

inline void  Synth_PSCALE::streamEnd ()

Synth_PSCALE::streamEnd

inline float  Synth_PSCALE::top ()

Synth_PSCALE::top

inline void  Synth_PSCALE::top (float _newValue)

Synth_PSCALE::top

inline Arts::AutoSuspendState  Synth_SEQUENCE::autoSuspend ()

Synth_SEQUENCE::autoSuspend

inline void  Synth_SEQUENCE::start ()

Synth_SEQUENCE::start

inline void  Synth_SEQUENCE::stop ()

Synth_SEQUENCE::stop

inline void  Synth_SEQUENCE::streamInit ()

Synth_SEQUENCE::streamInit

inline void  Synth_SEQUENCE::streamStart ()

Synth_SEQUENCE::streamStart

inline void  Synth_SEQUENCE::streamEnd ()

Synth_SEQUENCE::streamEnd

inline float  Synth_SEQUENCE::speed ()

Synth_SEQUENCE::speed

inline void  Synth_SEQUENCE::speed (float _newValue)

Synth_SEQUENCE::speed

inline std::string  Synth_SEQUENCE::seq ()

Synth_SEQUENCE::seq

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

Synth_SEQUENCE::seq

inline Arts::AutoSuspendState  Synth_PITCH_SHIFT::autoSuspend ()

Synth_PITCH_SHIFT::autoSuspend

inline void  Synth_PITCH_SHIFT::start ()

Synth_PITCH_SHIFT::start

inline void  Synth_PITCH_SHIFT::stop ()

Synth_PITCH_SHIFT::stop

inline void  Synth_PITCH_SHIFT::streamInit ()

Synth_PITCH_SHIFT::streamInit

inline void  Synth_PITCH_SHIFT::streamStart ()

Synth_PITCH_SHIFT::streamStart

inline void  Synth_PITCH_SHIFT::streamEnd ()

Synth_PITCH_SHIFT::streamEnd

inline float  Synth_PITCH_SHIFT::speed ()

Synth_PITCH_SHIFT::speed

inline void  Synth_PITCH_SHIFT::speed (float _newValue)

Synth_PITCH_SHIFT::speed

inline float  Synth_PITCH_SHIFT::frequency ()

Synth_PITCH_SHIFT::frequency

inline void  Synth_PITCH_SHIFT::frequency (float _newValue)

Synth_PITCH_SHIFT::frequency

inline Arts::AutoSuspendState  Interface_MIDI_NOTE::autoSuspend ()

Interface_MIDI_NOTE::autoSuspend

inline void  Interface_MIDI_NOTE::start ()

Interface_MIDI_NOTE::start

inline void  Interface_MIDI_NOTE::stop ()

Interface_MIDI_NOTE::stop

inline void  Interface_MIDI_NOTE::streamInit ()

Interface_MIDI_NOTE::streamInit

inline void  Interface_MIDI_NOTE::streamStart ()

Interface_MIDI_NOTE::streamStart

inline void  Interface_MIDI_NOTE::streamEnd ()

Interface_MIDI_NOTE::streamEnd

inline Arts::AutoSuspendState  Synth_STRUCT_KILL::autoSuspend ()

Synth_STRUCT_KILL::autoSuspend

inline void  Synth_STRUCT_KILL::start ()

Synth_STRUCT_KILL::start

inline void  Synth_STRUCT_KILL::stop ()

Synth_STRUCT_KILL::stop

inline void  Synth_STRUCT_KILL::streamInit ()

Synth_STRUCT_KILL::streamInit

inline void  Synth_STRUCT_KILL::streamStart ()

Synth_STRUCT_KILL::streamStart

inline void  Synth_STRUCT_KILL::streamEnd ()

Synth_STRUCT_KILL::streamEnd


Generated by: stefan on stefan on Sat Jun 2 23:13:28 2001, using kdoc 2.0a53.