/* this file was generated by the MCOP idl compiler - DO NOT EDIT */

#ifndef ARTSMODULES_H
#define ARTSMODULES_H

#include "common.h"

#include "arts_export.h"

// includes of other idl definitions
#include "artsflow.h"
#include "artsmidi.h"
#include "artsgui.h"
#include "artsmodulescommon.h"
#include "artsmodulessynth.h"
#include "artsmoduleseffects.h"
#include "artsmodulesmixers.h"

namespace Arts {
class Interface_MIDI_NOTE;
class Synth_STRUCT_KILL;

class ARTS_EXPORT Interface_MIDI_NOTE_base : virtual public Arts::SynthModule_base {
public:
	static unsigned long _IID; // interface ID

	static Interface_MIDI_NOTE_base *_create(const std::string& subClass = "Arts::Interface_MIDI_NOTE");
	static Interface_MIDI_NOTE_base *_fromString(const std::string& objectref);
	static Interface_MIDI_NOTE_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static Interface_MIDI_NOTE_base *_fromDynamicCast(const Arts::Object& object);
	inline Interface_MIDI_NOTE_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT Interface_MIDI_NOTE_stub : virtual public Interface_MIDI_NOTE_base, virtual public Arts::SynthModule_stub {
protected:
	Interface_MIDI_NOTE_stub();

public:
	Interface_MIDI_NOTE_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Interface_MIDI_NOTE_skel : virtual public Interface_MIDI_NOTE_base, virtual public Arts::SynthModule_skel {
protected:
	// variables for streams
	float *frequency;                         // outgoing stream
	float *velocity;                          // outgoing stream
	float *pressed;                           // outgoing stream

public:
	Interface_MIDI_NOTE_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Interface_MIDI_NOTE : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Interface_MIDI_NOTE_base *_cache;
	inline Interface_MIDI_NOTE_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Interface_MIDI_NOTE_base *)_pool->base->_cast(Interface_MIDI_NOTE_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Interface_MIDI_NOTE(Interface_MIDI_NOTE_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Interface_MIDI_NOTE_base _base_class;

	inline Interface_MIDI_NOTE() : Arts::Object(_Creator), _cache(0) {}
	inline Interface_MIDI_NOTE(const Arts::SubClass& s) :
		Arts::Object(Interface_MIDI_NOTE_base::_create(s.string())), _cache(0) {}
	inline Interface_MIDI_NOTE(const Arts::Reference &r) :
		Arts::Object(r.isString()?(Interface_MIDI_NOTE_base::_fromString(r.string())):(Interface_MIDI_NOTE_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline Interface_MIDI_NOTE(const Arts::DynamicCast& c) : Arts::Object(Interface_MIDI_NOTE_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline Interface_MIDI_NOTE(const Interface_MIDI_NOTE& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline Interface_MIDI_NOTE(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static Interface_MIDI_NOTE null() {return Interface_MIDI_NOTE((Interface_MIDI_NOTE_base*)0);}
	inline static Interface_MIDI_NOTE _from_base(Interface_MIDI_NOTE_base* b) {return Interface_MIDI_NOTE(b);}
	inline Interface_MIDI_NOTE& operator=(const Interface_MIDI_NOTE& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline Interface_MIDI_NOTE_base* _base() {return _cache?_cache:_method_call();}

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
};

class ARTS_EXPORT Synth_STRUCT_KILL_base : virtual public Arts::SynthModule_base {
public:
	static unsigned long _IID; // interface ID

	static Synth_STRUCT_KILL_base *_create(const std::string& subClass = "Arts::Synth_STRUCT_KILL");
	static Synth_STRUCT_KILL_base *_fromString(const std::string& objectref);
	static Synth_STRUCT_KILL_base *_fromReference(Arts::ObjectReference ref, bool needcopy);

	static Synth_STRUCT_KILL_base *_fromDynamicCast(const Arts::Object& object);
	inline Synth_STRUCT_KILL_base *_copy() {
		assert(_refCnt > 0);
		_refCnt++;
		return this;
	}

	virtual std::vector<std::string> _defaultPortsIn() const;
	virtual std::vector<std::string> _defaultPortsOut() const;

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT Synth_STRUCT_KILL_stub : virtual public Synth_STRUCT_KILL_base, virtual public Arts::SynthModule_stub {
protected:
	Synth_STRUCT_KILL_stub();

public:
	Synth_STRUCT_KILL_stub(Arts::Connection *connection, long objectID);

};

class ARTS_EXPORT Synth_STRUCT_KILL_skel : virtual public Synth_STRUCT_KILL_base, virtual public Arts::SynthModule_skel {
protected:
	// variables for streams
	float *ready;                             // incoming stream

public:
	Synth_STRUCT_KILL_skel();

	static std::string _interfaceNameSkel();
	std::string _interfaceName();
	bool _isCompatibleWith(const std::string& interfacename);
	void _buildMethodTable();
	void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
};

}
#include "reference.h"
namespace Arts {
class ARTS_EXPORT Synth_STRUCT_KILL : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Synth_STRUCT_KILL_base *_cache;
	inline Synth_STRUCT_KILL_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Synth_STRUCT_KILL_base *)_pool->base->_cast(Synth_STRUCT_KILL_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Synth_STRUCT_KILL(Synth_STRUCT_KILL_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Synth_STRUCT_KILL_base _base_class;

	inline Synth_STRUCT_KILL() : Arts::Object(_Creator), _cache(0) {}
	inline Synth_STRUCT_KILL(const Arts::SubClass& s) :
		Arts::Object(Synth_STRUCT_KILL_base::_create(s.string())), _cache(0) {}
	inline Synth_STRUCT_KILL(const Arts::Reference &r) :
		Arts::Object(r.isString()?(Synth_STRUCT_KILL_base::_fromString(r.string())):(Synth_STRUCT_KILL_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline Synth_STRUCT_KILL(const Arts::DynamicCast& c) : Arts::Object(Synth_STRUCT_KILL_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline Synth_STRUCT_KILL(const Synth_STRUCT_KILL& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline Synth_STRUCT_KILL(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static Synth_STRUCT_KILL null() {return Synth_STRUCT_KILL((Synth_STRUCT_KILL_base*)0);}
	inline static Synth_STRUCT_KILL _from_base(Synth_STRUCT_KILL_base* b) {return Synth_STRUCT_KILL(b);}
	inline Synth_STRUCT_KILL& operator=(const Synth_STRUCT_KILL& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline Synth_STRUCT_KILL_base* _base() {return _cache?_cache:_method_call();}

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
};

}
// Forward wrapper calls to _base classes:

inline Arts::AutoSuspendState Arts::Interface_MIDI_NOTE::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Interface_MIDI_NOTE::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Interface_MIDI_NOTE::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Interface_MIDI_NOTE::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Interface_MIDI_NOTE::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Interface_MIDI_NOTE::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

inline Arts::AutoSuspendState Arts::Synth_STRUCT_KILL::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

inline void Arts::Synth_STRUCT_KILL::start()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
}

inline void Arts::Synth_STRUCT_KILL::stop()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
}

inline void Arts::Synth_STRUCT_KILL::streamInit()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
}

inline void Arts::Synth_STRUCT_KILL::streamStart()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
}

inline void Arts::Synth_STRUCT_KILL::streamEnd()
{
	 _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
}

#endif /* ARTSMODULES_H */
