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

#include "noatunarts.h"

// Implementation
Noatun::Equalizer_base *Noatun::Equalizer_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::Equalizer_base *castedObject = (Noatun::Equalizer_base *)skel->_cast(Noatun::Equalizer_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::Equalizer_base *Noatun::Equalizer_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::Equalizer_base::_fromReference(r,true);
	return 0;
}

Noatun::Equalizer_base *Noatun::Equalizer_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::Equalizer_base *castedObject = (Noatun::Equalizer_base *)object._base()->_cast(Noatun::Equalizer_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::Equalizer_base *Noatun::Equalizer_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::Equalizer_base *result;
	result = (Noatun::Equalizer_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::Equalizer");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::Equalizer_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::Equalizer")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::Equalizer_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inleft");
	ret.push_back("inright");
	return ret;
}
std::vector<std::string> Noatun::Equalizer_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outleft");
	ret.push_back("outright");
	return ret;
}

void *Noatun::Equalizer_base::_cast(unsigned long iid)
{
	if(iid == Noatun::Equalizer_base::_IID) return (Noatun::Equalizer_base *)this;
	if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::Equalizer_stub::Equalizer_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::Equalizer_stub::Equalizer_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

void Noatun::Equalizer_stub::set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths)
{
	long methodID = _lookupMethodFast("method:000000047365740000000005766f6964000000000200000003000000072a666c6f617400000000076c6576656c730000000000000000072a666c6f6174000000000863656e746572730000000000000000072a666c6f61740000000007776964746873000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloatSeq(levels);
	request->writeFloatSeq(centers);
	request->writeFloatSeq(widths);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::vector<float> * Noatun::Equalizer_stub::levelCenters()
{
	long methodID = _lookupMethodFast("method:000000125f6765745f6c6576656c43656e7465727300000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

void Noatun::Equalizer_stub::levelCenters(const std::vector<float>& newValue)
{
	long methodID = _lookupMethodFast("method:000000125f7365745f6c6576656c43656e746572730000000005766f6964000000000200000001000000072a666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloatSeq(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::vector<float> * Noatun::Equalizer_stub::levelWidths()
{
	long methodID = _lookupMethodFast("method:000000115f6765745f6c6576656c57696474687300000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

void Noatun::Equalizer_stub::levelWidths(const std::vector<float>& newValue)
{
	long methodID = _lookupMethodFast("method:000000115f7365745f6c6576656c5769647468730000000005766f6964000000000200000001000000072a666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloatSeq(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::vector<float> * Noatun::Equalizer_stub::levels()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f6c6576656c7300000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

void Noatun::Equalizer_stub::levels(const std::vector<float>& newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f6c6576656c730000000005766f6964000000000200000001000000072a666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloatSeq(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

long Noatun::Equalizer_stub::bands()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f62616e647300000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Noatun::Equalizer_stub::bands(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f62616e64730000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

long Noatun::Equalizer_stub::enabled()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f656e61626c656400000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Noatun::Equalizer_stub::enabled(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f656e61626c65640000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Noatun::Equalizer_stub::preamp()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f707265616d700000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Noatun::Equalizer_stub::preamp(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f707265616d700000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::Equalizer_skel::_interfaceName()
{
	return "Noatun::Equalizer";
}

bool Noatun::Equalizer_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::Equalizer") return true;
	if (interfacename == "Arts::StereoEffect") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::Equalizer_skel::_interfaceNameSkel()
{
	return "Noatun::Equalizer";
}

// set
static void _dispatch_Noatun_Equalizer_00(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::vector<float> levels;
	request->readFloatSeq(levels);
	std::vector<float> centers;
	request->readFloatSeq(centers);
	std::vector<float> widths;
	request->readFloatSeq(widths);
	((Noatun::Equalizer_skel *)object)->set(levels,centers,widths);
}

// _get_levelCenters
static void _dispatch_Noatun_Equalizer_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::Equalizer_skel *)object)->levelCenters();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _set_levelCenters
static void _dispatch_Noatun_Equalizer_02(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::vector<float> newValue;
	request->readFloatSeq(newValue);
	((Noatun::Equalizer_skel *)object)->levelCenters(newValue);
}

// _get_levelWidths
static void _dispatch_Noatun_Equalizer_03(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::Equalizer_skel *)object)->levelWidths();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _set_levelWidths
static void _dispatch_Noatun_Equalizer_04(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::vector<float> newValue;
	request->readFloatSeq(newValue);
	((Noatun::Equalizer_skel *)object)->levelWidths(newValue);
}

// _get_levels
static void _dispatch_Noatun_Equalizer_05(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::Equalizer_skel *)object)->levels();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _set_levels
static void _dispatch_Noatun_Equalizer_06(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::vector<float> newValue;
	request->readFloatSeq(newValue);
	((Noatun::Equalizer_skel *)object)->levels(newValue);
}

// _get_bands
static void _dispatch_Noatun_Equalizer_07(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Noatun::Equalizer_skel *)object)->bands());
}

// _set_bands
static void _dispatch_Noatun_Equalizer_08(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Noatun::Equalizer_skel *)object)->bands(newValue);
}

// _get_enabled
static void _dispatch_Noatun_Equalizer_09(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Noatun::Equalizer_skel *)object)->enabled());
}

// _set_enabled
static void _dispatch_Noatun_Equalizer_10(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Noatun::Equalizer_skel *)object)->enabled(newValue);
}

// _get_preamp
static void _dispatch_Noatun_Equalizer_11(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Noatun::Equalizer_skel *)object)->preamp());
}

// _set_preamp
static void _dispatch_Noatun_Equalizer_12(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Noatun::Equalizer_skel *)object)->preamp(newValue);
}

void Noatun::Equalizer_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000047365740000000005766f69640000000002000000030000"
        "00072a666c6f617400000000076c6576656c730000000000000000072a666c6f61"
        "74000000000863656e746572730000000000000000072a666c6f61740000000007"
        "776964746873000000000000000000000000125f6765745f6c6576656c43656e74"
        "65727300000000072a666c6f617400000000020000000000000000000000125f73"
        "65745f6c6576656c43656e746572730000000005766f6964000000000200000001"
        "000000072a666c6f617400000000096e657756616c756500000000000000000000"
        "0000115f6765745f6c6576656c57696474687300000000072a666c6f6174000000"
        "00020000000000000000000000115f7365745f6c6576656c576964746873000000"
        "0005766f6964000000000200000001000000072a666c6f617400000000096e6577"
        "56616c75650000000000000000000000000c5f6765745f6c6576656c7300000000"
        "072a666c6f6174000000000200000000000000000000000c5f7365745f6c657665"
        "6c730000000005766f6964000000000200000001000000072a666c6f6174000000"
        "00096e657756616c75650000000000000000000000000b5f6765745f62616e6473"
        "00000000056c6f6e67000000000200000000000000000000000b5f7365745f6261"
        "6e64730000000005766f6964000000000200000001000000056c6f6e6700000000"
        "096e657756616c75650000000000000000000000000d5f6765745f656e61626c65"
        "6400000000056c6f6e67000000000200000000000000000000000d5f7365745f65"
        "6e61626c65640000000005766f6964000000000200000001000000056c6f6e6700"
        "000000096e657756616c75650000000000000000000000000c5f6765745f707265"
        "616d700000000006666c6f6174000000000200000000000000000000000c5f7365"
        "745f707265616d700000000005766f696400000000020000000100000006666c6f"
        "617400000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_Equalizer_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_07,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_08,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_09,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_10,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_11,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Equalizer_12,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Noatun::Equalizer_skel::Equalizer_skel()
{
}

Arts::Object_base* Noatun::Equalizer::_Creator() {
	return Noatun::Equalizer_base::_create();
}

unsigned long Noatun::Equalizer_base::_IID = Arts::MCOPUtils::makeIID("Noatun::Equalizer");

Noatun::EqualizerSSE_base *Noatun::EqualizerSSE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::EqualizerSSE_base *castedObject = (Noatun::EqualizerSSE_base *)skel->_cast(Noatun::EqualizerSSE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::EqualizerSSE_base *Noatun::EqualizerSSE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::EqualizerSSE_base::_fromReference(r,true);
	return 0;
}

Noatun::EqualizerSSE_base *Noatun::EqualizerSSE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::EqualizerSSE_base *castedObject = (Noatun::EqualizerSSE_base *)object._base()->_cast(Noatun::EqualizerSSE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::EqualizerSSE_base *Noatun::EqualizerSSE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::EqualizerSSE_base *result;
	result = (Noatun::EqualizerSSE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::EqualizerSSE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::EqualizerSSE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::EqualizerSSE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::EqualizerSSE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inleft");
	ret.push_back("inright");
	return ret;
}
std::vector<std::string> Noatun::EqualizerSSE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outleft");
	ret.push_back("outright");
	return ret;
}

void *Noatun::EqualizerSSE_base::_cast(unsigned long iid)
{
	if(iid == Noatun::EqualizerSSE_base::_IID) return (Noatun::EqualizerSSE_base *)this;
	if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::EqualizerSSE_stub::EqualizerSSE_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::EqualizerSSE_stub::EqualizerSSE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

void Noatun::EqualizerSSE_stub::set(const std::vector<float>& levels, const std::vector<float>& centers, const std::vector<float>& widths)
{
	long methodID = _lookupMethodFast("method:000000047365740000000005766f6964000000000200000003000000072a666c6f617400000000076c6576656c730000000000000000072a666c6f6174000000000863656e746572730000000000000000072a666c6f61740000000007776964746873000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloatSeq(levels);
	request->writeFloatSeq(centers);
	request->writeFloatSeq(widths);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::vector<float> * Noatun::EqualizerSSE_stub::levelCenters()
{
	long methodID = _lookupMethodFast("method:000000125f6765745f6c6576656c43656e7465727300000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

void Noatun::EqualizerSSE_stub::levelCenters(const std::vector<float>& newValue)
{
	long methodID = _lookupMethodFast("method:000000125f7365745f6c6576656c43656e746572730000000005766f6964000000000200000001000000072a666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloatSeq(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::vector<float> * Noatun::EqualizerSSE_stub::levelWidths()
{
	long methodID = _lookupMethodFast("method:000000115f6765745f6c6576656c57696474687300000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

void Noatun::EqualizerSSE_stub::levelWidths(const std::vector<float>& newValue)
{
	long methodID = _lookupMethodFast("method:000000115f7365745f6c6576656c5769647468730000000005766f6964000000000200000001000000072a666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloatSeq(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::vector<float> * Noatun::EqualizerSSE_stub::levels()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f6c6576656c7300000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

void Noatun::EqualizerSSE_stub::levels(const std::vector<float>& newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f6c6576656c730000000005766f6964000000000200000001000000072a666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloatSeq(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

long Noatun::EqualizerSSE_stub::bands()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f62616e647300000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Noatun::EqualizerSSE_stub::bands(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f62616e64730000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

long Noatun::EqualizerSSE_stub::enabled()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f656e61626c656400000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Noatun::EqualizerSSE_stub::enabled(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f656e61626c65640000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

float Noatun::EqualizerSSE_stub::preamp()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f707265616d700000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Noatun::EqualizerSSE_stub::preamp(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f707265616d700000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::EqualizerSSE_skel::_interfaceName()
{
	return "Noatun::EqualizerSSE";
}

bool Noatun::EqualizerSSE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::EqualizerSSE") return true;
	if (interfacename == "Arts::StereoEffect") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::EqualizerSSE_skel::_interfaceNameSkel()
{
	return "Noatun::EqualizerSSE";
}

// set
static void _dispatch_Noatun_EqualizerSSE_00(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::vector<float> levels;
	request->readFloatSeq(levels);
	std::vector<float> centers;
	request->readFloatSeq(centers);
	std::vector<float> widths;
	request->readFloatSeq(widths);
	((Noatun::EqualizerSSE_skel *)object)->set(levels,centers,widths);
}

// _get_levelCenters
static void _dispatch_Noatun_EqualizerSSE_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::EqualizerSSE_skel *)object)->levelCenters();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _set_levelCenters
static void _dispatch_Noatun_EqualizerSSE_02(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::vector<float> newValue;
	request->readFloatSeq(newValue);
	((Noatun::EqualizerSSE_skel *)object)->levelCenters(newValue);
}

// _get_levelWidths
static void _dispatch_Noatun_EqualizerSSE_03(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::EqualizerSSE_skel *)object)->levelWidths();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _set_levelWidths
static void _dispatch_Noatun_EqualizerSSE_04(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::vector<float> newValue;
	request->readFloatSeq(newValue);
	((Noatun::EqualizerSSE_skel *)object)->levelWidths(newValue);
}

// _get_levels
static void _dispatch_Noatun_EqualizerSSE_05(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::EqualizerSSE_skel *)object)->levels();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _set_levels
static void _dispatch_Noatun_EqualizerSSE_06(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::vector<float> newValue;
	request->readFloatSeq(newValue);
	((Noatun::EqualizerSSE_skel *)object)->levels(newValue);
}

// _get_bands
static void _dispatch_Noatun_EqualizerSSE_07(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Noatun::EqualizerSSE_skel *)object)->bands());
}

// _set_bands
static void _dispatch_Noatun_EqualizerSSE_08(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Noatun::EqualizerSSE_skel *)object)->bands(newValue);
}

// _get_enabled
static void _dispatch_Noatun_EqualizerSSE_09(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Noatun::EqualizerSSE_skel *)object)->enabled());
}

// _set_enabled
static void _dispatch_Noatun_EqualizerSSE_10(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Noatun::EqualizerSSE_skel *)object)->enabled(newValue);
}

// _get_preamp
static void _dispatch_Noatun_EqualizerSSE_11(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Noatun::EqualizerSSE_skel *)object)->preamp());
}

// _set_preamp
static void _dispatch_Noatun_EqualizerSSE_12(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Noatun::EqualizerSSE_skel *)object)->preamp(newValue);
}

void Noatun::EqualizerSSE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000047365740000000005766f69640000000002000000030000"
        "00072a666c6f617400000000076c6576656c730000000000000000072a666c6f61"
        "74000000000863656e746572730000000000000000072a666c6f61740000000007"
        "776964746873000000000000000000000000125f6765745f6c6576656c43656e74"
        "65727300000000072a666c6f617400000000020000000000000000000000125f73"
        "65745f6c6576656c43656e746572730000000005766f6964000000000200000001"
        "000000072a666c6f617400000000096e657756616c756500000000000000000000"
        "0000115f6765745f6c6576656c57696474687300000000072a666c6f6174000000"
        "00020000000000000000000000115f7365745f6c6576656c576964746873000000"
        "0005766f6964000000000200000001000000072a666c6f617400000000096e6577"
        "56616c75650000000000000000000000000c5f6765745f6c6576656c7300000000"
        "072a666c6f6174000000000200000000000000000000000c5f7365745f6c657665"
        "6c730000000005766f6964000000000200000001000000072a666c6f6174000000"
        "00096e657756616c75650000000000000000000000000b5f6765745f62616e6473"
        "00000000056c6f6e67000000000200000000000000000000000b5f7365745f6261"
        "6e64730000000005766f6964000000000200000001000000056c6f6e6700000000"
        "096e657756616c75650000000000000000000000000d5f6765745f656e61626c65"
        "6400000000056c6f6e67000000000200000000000000000000000d5f7365745f65"
        "6e61626c65640000000005766f6964000000000200000001000000056c6f6e6700"
        "000000096e657756616c75650000000000000000000000000c5f6765745f707265"
        "616d700000000006666c6f6174000000000200000000000000000000000c5f7365"
        "745f707265616d700000000005766f696400000000020000000100000006666c6f"
        "617400000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_EqualizerSSE_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_07,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_08,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_09,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_10,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_11,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_EqualizerSSE_12,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Noatun::EqualizerSSE_skel::EqualizerSSE_skel()
{
}

Arts::Object_base* Noatun::EqualizerSSE::_Creator() {
	return Noatun::EqualizerSSE_base::_create();
}

unsigned long Noatun::EqualizerSSE_base::_IID = Arts::MCOPUtils::makeIID("Noatun::EqualizerSSE");

Noatun::FFTScope_base *Noatun::FFTScope_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::FFTScope_base *castedObject = (Noatun::FFTScope_base *)skel->_cast(Noatun::FFTScope_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::FFTScope_base *Noatun::FFTScope_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::FFTScope_base::_fromReference(r,true);
	return 0;
}

Noatun::FFTScope_base *Noatun::FFTScope_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::FFTScope_base *castedObject = (Noatun::FFTScope_base *)object._base()->_cast(Noatun::FFTScope_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::FFTScope_base *Noatun::FFTScope_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::FFTScope_base *result;
	result = (Noatun::FFTScope_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::FFTScope");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::FFTScope_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::FFTScope")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::FFTScope_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inleft");
	ret.push_back("inright");
	return ret;
}
std::vector<std::string> Noatun::FFTScope_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outleft");
	ret.push_back("outright");
	return ret;
}

void *Noatun::FFTScope_base::_cast(unsigned long iid)
{
	if(iid == Noatun::FFTScope_base::_IID) return (Noatun::FFTScope_base *)this;
	if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::FFTScope_stub::FFTScope_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::FFTScope_stub::FFTScope_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::vector<float> * Noatun::FFTScope_stub::scope()
{
	long methodID = _lookupMethodFast("method:0000000673636f706500000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

float Noatun::FFTScope_stub::bandResolution()
{
	long methodID = _lookupMethodFast("method:000000145f6765745f62616e645265736f6c7574696f6e0000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Noatun::FFTScope_stub::bandResolution(float newValue)
{
	long methodID = _lookupMethodFast("method:000000145f7365745f62616e645265736f6c7574696f6e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::FFTScope_skel::_interfaceName()
{
	return "Noatun::FFTScope";
}

bool Noatun::FFTScope_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::FFTScope") return true;
	if (interfacename == "Arts::StereoEffect") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::FFTScope_skel::_interfaceNameSkel()
{
	return "Noatun::FFTScope";
}

// scope
static void _dispatch_Noatun_FFTScope_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::FFTScope_skel *)object)->scope();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _get_bandResolution
static void _dispatch_Noatun_FFTScope_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Noatun::FFTScope_skel *)object)->bandResolution());
}

// _set_bandResolution
static void _dispatch_Noatun_FFTScope_02(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Noatun::FFTScope_skel *)object)->bandResolution(newValue);
}

void Noatun::FFTScope_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000673636f706500000000072a666c6f617400000000020000"
        "000000000000000000145f6765745f62616e645265736f6c7574696f6e00000000"
        "06666c6f617400000000020000000000000000000000145f7365745f62616e6452"
        "65736f6c7574696f6e0000000005766f696400000000020000000100000006666c"
        "6f617400000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_FFTScope_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_FFTScope_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_FFTScope_02,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Noatun::FFTScope_skel::FFTScope_skel()
{
}

Arts::Object_base* Noatun::FFTScope::_Creator() {
	return Noatun::FFTScope_base::_create();
}

unsigned long Noatun::FFTScope_base::_IID = Arts::MCOPUtils::makeIID("Noatun::FFTScope");

Noatun::FFTScopeStereo_base *Noatun::FFTScopeStereo_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::FFTScopeStereo_base *castedObject = (Noatun::FFTScopeStereo_base *)skel->_cast(Noatun::FFTScopeStereo_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::FFTScopeStereo_base *Noatun::FFTScopeStereo_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::FFTScopeStereo_base::_fromReference(r,true);
	return 0;
}

Noatun::FFTScopeStereo_base *Noatun::FFTScopeStereo_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::FFTScopeStereo_base *castedObject = (Noatun::FFTScopeStereo_base *)object._base()->_cast(Noatun::FFTScopeStereo_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::FFTScopeStereo_base *Noatun::FFTScopeStereo_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::FFTScopeStereo_base *result;
	result = (Noatun::FFTScopeStereo_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::FFTScopeStereo");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::FFTScopeStereo_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::FFTScopeStereo")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::FFTScopeStereo_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inleft");
	ret.push_back("inright");
	return ret;
}
std::vector<std::string> Noatun::FFTScopeStereo_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outleft");
	ret.push_back("outright");
	return ret;
}

void *Noatun::FFTScopeStereo_base::_cast(unsigned long iid)
{
	if(iid == Noatun::FFTScopeStereo_base::_IID) return (Noatun::FFTScopeStereo_base *)this;
	if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::FFTScopeStereo_stub::FFTScopeStereo_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::FFTScopeStereo_stub::FFTScopeStereo_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::vector<float> * Noatun::FFTScopeStereo_stub::scopeRight()
{
	long methodID = _lookupMethodFast("method:0000000b73636f7065526967687400000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

std::vector<float> * Noatun::FFTScopeStereo_stub::scopeLeft()
{
	long methodID = _lookupMethodFast("method:0000000a73636f70654c65667400000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

float Noatun::FFTScopeStereo_stub::bandResolution()
{
	long methodID = _lookupMethodFast("method:000000145f6765745f62616e645265736f6c7574696f6e0000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Noatun::FFTScopeStereo_stub::bandResolution(float newValue)
{
	long methodID = _lookupMethodFast("method:000000145f7365745f62616e645265736f6c7574696f6e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::FFTScopeStereo_skel::_interfaceName()
{
	return "Noatun::FFTScopeStereo";
}

bool Noatun::FFTScopeStereo_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::FFTScopeStereo") return true;
	if (interfacename == "Arts::StereoEffect") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::FFTScopeStereo_skel::_interfaceNameSkel()
{
	return "Noatun::FFTScopeStereo";
}

// scopeRight
static void _dispatch_Noatun_FFTScopeStereo_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::FFTScopeStereo_skel *)object)->scopeRight();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// scopeLeft
static void _dispatch_Noatun_FFTScopeStereo_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::FFTScopeStereo_skel *)object)->scopeLeft();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _get_bandResolution
static void _dispatch_Noatun_FFTScopeStereo_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Noatun::FFTScopeStereo_skel *)object)->bandResolution());
}

// _set_bandResolution
static void _dispatch_Noatun_FFTScopeStereo_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Noatun::FFTScopeStereo_skel *)object)->bandResolution(newValue);
}

void Noatun::FFTScopeStereo_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000b73636f7065526967687400000000072a666c6f61740000"
        "00000200000000000000000000000a73636f70654c65667400000000072a666c6f"
        "617400000000020000000000000000000000145f6765745f62616e645265736f6c"
        "7574696f6e0000000006666c6f617400000000020000000000000000000000145f"
        "7365745f62616e645265736f6c7574696f6e0000000005766f6964000000000200"
        "00000100000006666c6f617400000000096e657756616c75650000000000000000"
        "00",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_FFTScopeStereo_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_FFTScopeStereo_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_FFTScopeStereo_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_FFTScopeStereo_03,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Noatun::FFTScopeStereo_skel::FFTScopeStereo_skel()
{
}

Arts::Object_base* Noatun::FFTScopeStereo::_Creator() {
	return Noatun::FFTScopeStereo_base::_create();
}

unsigned long Noatun::FFTScopeStereo_base::_IID = Arts::MCOPUtils::makeIID("Noatun::FFTScopeStereo");

Noatun::RawScope_base *Noatun::RawScope_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::RawScope_base *castedObject = (Noatun::RawScope_base *)skel->_cast(Noatun::RawScope_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::RawScope_base *Noatun::RawScope_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::RawScope_base::_fromReference(r,true);
	return 0;
}

Noatun::RawScope_base *Noatun::RawScope_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::RawScope_base *castedObject = (Noatun::RawScope_base *)object._base()->_cast(Noatun::RawScope_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::RawScope_base *Noatun::RawScope_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::RawScope_base *result;
	result = (Noatun::RawScope_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::RawScope");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::RawScope_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::RawScope")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::RawScope_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inleft");
	ret.push_back("inright");
	return ret;
}
std::vector<std::string> Noatun::RawScope_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outleft");
	ret.push_back("outright");
	return ret;
}

void *Noatun::RawScope_base::_cast(unsigned long iid)
{
	if(iid == Noatun::RawScope_base::_IID) return (Noatun::RawScope_base *)this;
	if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::RawScope_stub::RawScope_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::RawScope_stub::RawScope_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::vector<float> * Noatun::RawScope_stub::scope()
{
	long methodID = _lookupMethodFast("method:0000000673636f706500000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

long Noatun::RawScope_stub::buffer()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f62756666657200000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Noatun::RawScope_stub::buffer(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f6275666665720000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::RawScope_skel::_interfaceName()
{
	return "Noatun::RawScope";
}

bool Noatun::RawScope_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::RawScope") return true;
	if (interfacename == "Arts::StereoEffect") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::RawScope_skel::_interfaceNameSkel()
{
	return "Noatun::RawScope";
}

// scope
static void _dispatch_Noatun_RawScope_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::RawScope_skel *)object)->scope();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _get_buffer
static void _dispatch_Noatun_RawScope_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Noatun::RawScope_skel *)object)->buffer());
}

// _set_buffer
static void _dispatch_Noatun_RawScope_02(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Noatun::RawScope_skel *)object)->buffer(newValue);
}

void Noatun::RawScope_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000673636f706500000000072a666c6f617400000000020000"
        "0000000000000000000c5f6765745f62756666657200000000056c6f6e67000000"
        "000200000000000000000000000c5f7365745f6275666665720000000005766f69"
        "64000000000200000001000000056c6f6e6700000000096e657756616c75650000"
        "00000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_RawScope_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_RawScope_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_RawScope_02,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Noatun::RawScope_skel::RawScope_skel()
{
}

Arts::Object_base* Noatun::RawScope::_Creator() {
	return Noatun::RawScope_base::_create();
}

unsigned long Noatun::RawScope_base::_IID = Arts::MCOPUtils::makeIID("Noatun::RawScope");

Noatun::RawScopeStereo_base *Noatun::RawScopeStereo_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::RawScopeStereo_base *castedObject = (Noatun::RawScopeStereo_base *)skel->_cast(Noatun::RawScopeStereo_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::RawScopeStereo_base *Noatun::RawScopeStereo_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::RawScopeStereo_base::_fromReference(r,true);
	return 0;
}

Noatun::RawScopeStereo_base *Noatun::RawScopeStereo_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::RawScopeStereo_base *castedObject = (Noatun::RawScopeStereo_base *)object._base()->_cast(Noatun::RawScopeStereo_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::RawScopeStereo_base *Noatun::RawScopeStereo_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::RawScopeStereo_base *result;
	result = (Noatun::RawScopeStereo_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::RawScopeStereo");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::RawScopeStereo_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::RawScopeStereo")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::RawScopeStereo_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inleft");
	ret.push_back("inright");
	return ret;
}
std::vector<std::string> Noatun::RawScopeStereo_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outleft");
	ret.push_back("outright");
	return ret;
}

void *Noatun::RawScopeStereo_base::_cast(unsigned long iid)
{
	if(iid == Noatun::RawScopeStereo_base::_IID) return (Noatun::RawScopeStereo_base *)this;
	if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::RawScopeStereo_stub::RawScopeStereo_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::RawScopeStereo_stub::RawScopeStereo_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

std::vector<float> * Noatun::RawScopeStereo_stub::scopeLeft()
{
	long methodID = _lookupMethodFast("method:0000000a73636f70654c65667400000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

std::vector<float> * Noatun::RawScopeStereo_stub::scopeRight()
{
	long methodID = _lookupMethodFast("method:0000000b73636f7065526967687400000000072a666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<float> *_returnCode = new std::vector<float>;
	if(!result) return _returnCode; // error occurred
	result->readFloatSeq(*_returnCode);
	delete result;
	return _returnCode;
}

long Noatun::RawScopeStereo_stub::buffer()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f62756666657200000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Noatun::RawScopeStereo_stub::buffer(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f6275666665720000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::RawScopeStereo_skel::_interfaceName()
{
	return "Noatun::RawScopeStereo";
}

bool Noatun::RawScopeStereo_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::RawScopeStereo") return true;
	if (interfacename == "Arts::StereoEffect") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::RawScopeStereo_skel::_interfaceNameSkel()
{
	return "Noatun::RawScopeStereo";
}

// scopeLeft
static void _dispatch_Noatun_RawScopeStereo_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::RawScopeStereo_skel *)object)->scopeLeft();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// scopeRight
static void _dispatch_Noatun_RawScopeStereo_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<float> *_returnCode = ((Noatun::RawScopeStereo_skel *)object)->scopeRight();
	result->writeFloatSeq(*_returnCode);
	delete _returnCode;
}

// _get_buffer
static void _dispatch_Noatun_RawScopeStereo_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Noatun::RawScopeStereo_skel *)object)->buffer());
}

// _set_buffer
static void _dispatch_Noatun_RawScopeStereo_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Noatun::RawScopeStereo_skel *)object)->buffer(newValue);
}

void Noatun::RawScopeStereo_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000a73636f70654c65667400000000072a666c6f6174000000"
        "000200000000000000000000000b73636f7065526967687400000000072a666c6f"
        "6174000000000200000000000000000000000c5f6765745f627566666572000000"
        "00056c6f6e67000000000200000000000000000000000c5f7365745f6275666665"
        "720000000005766f6964000000000200000001000000056c6f6e6700000000096e"
        "657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_RawScopeStereo_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_RawScopeStereo_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_RawScopeStereo_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_RawScopeStereo_03,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Noatun::RawScopeStereo_skel::RawScopeStereo_skel()
{
}

Arts::Object_base* Noatun::RawScopeStereo::_Creator() {
	return Noatun::RawScopeStereo_base::_create();
}

unsigned long Noatun::RawScopeStereo_base::_IID = Arts::MCOPUtils::makeIID("Noatun::RawScopeStereo");

Noatun::StereoEffectStack_base *Noatun::StereoEffectStack_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::StereoEffectStack_base *castedObject = (Noatun::StereoEffectStack_base *)skel->_cast(Noatun::StereoEffectStack_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::StereoEffectStack_base *Noatun::StereoEffectStack_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::StereoEffectStack_base::_fromReference(r,true);
	return 0;
}

Noatun::StereoEffectStack_base *Noatun::StereoEffectStack_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::StereoEffectStack_base *castedObject = (Noatun::StereoEffectStack_base *)object._base()->_cast(Noatun::StereoEffectStack_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::StereoEffectStack_base *Noatun::StereoEffectStack_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::StereoEffectStack_base *result;
	result = (Noatun::StereoEffectStack_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::StereoEffectStack");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::StereoEffectStack_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::StereoEffectStack")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::StereoEffectStack_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inleft");
	ret.push_back("inright");
	return ret;
}
std::vector<std::string> Noatun::StereoEffectStack_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outleft");
	ret.push_back("outright");
	return ret;
}

void *Noatun::StereoEffectStack_base::_cast(unsigned long iid)
{
	if(iid == Noatun::StereoEffectStack_base::_IID) return (Noatun::StereoEffectStack_base *)this;
	if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::StereoEffectStack_stub::StereoEffectStack_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::StereoEffectStack_stub::StereoEffectStack_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

long Noatun::StereoEffectStack_stub::insertAfter(long after, Arts::StereoEffect effect, const std::string& name)
{
	long methodID = _lookupMethodFast("method:0000000c696e73657274416674657200000000056c6f6e67000000000200000003000000056c6f6e6700000000066166746572000000000000000013417274733a3a53746572656f4566666563740000000007656666656374000000000000000007737472696e6700000000056e616d65000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(after);
	Arts::writeObject(*request,effect._base());
	request->writeString(name);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Noatun::StereoEffectStack_stub::move(long after, long item)
{
	long methodID = _lookupMethodFast("method:000000056d6f76650000000005766f6964000000000200000002000000056c6f6e67000000000661667465720000000000000000056c6f6e6700000000056974656d000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(after);
	request->writeLong(item);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::vector<long> * Noatun::StereoEffectStack_stub::effectList()
{
	long methodID = _lookupMethodFast("method:0000000b6566666563744c69737400000000062a6c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	std::vector<long> *_returnCode = new std::vector<long>;
	if(!result) return _returnCode; // error occurred
	result->readLongSeq(*_returnCode);
	delete result;
	return _returnCode;
}

long Noatun::StereoEffectStack_stub::insertTop(Arts::StereoEffect effect, const std::string& name)
{
	long methodID = _lookupMethodFast("method:0000000a696e73657274546f7000000000056c6f6e6700000000020000000200000013417274733a3a53746572656f4566666563740000000007656666656374000000000000000007737472696e6700000000056e616d65000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	Arts::writeObject(*request,effect._base());
	request->writeString(name);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

long Noatun::StereoEffectStack_stub::insertBottom(Arts::StereoEffect effect, const std::string& name)
{
	long methodID = _lookupMethodFast("method:0000000d696e73657274426f74746f6d00000000056c6f6e6700000000020000000200000013417274733a3a53746572656f4566666563740000000007656666656374000000000000000007737472696e6700000000056e616d65000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	Arts::writeObject(*request,effect._base());
	request->writeString(name);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Noatun::StereoEffectStack_stub::remove(long ID)
{
	long methodID = _lookupMethodFast("method:0000000772656d6f76650000000005766f6964000000000200000001000000056c6f6e6700000000034944000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(ID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::StereoEffectStack_skel::_interfaceName()
{
	return "Noatun::StereoEffectStack";
}

bool Noatun::StereoEffectStack_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::StereoEffectStack") return true;
	if (interfacename == "Arts::StereoEffect") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::StereoEffectStack_skel::_interfaceNameSkel()
{
	return "Noatun::StereoEffectStack";
}

// insertAfter
static void _dispatch_Noatun_StereoEffectStack_00(void *object, Arts::Buffer *request, Arts::Buffer *result)
{
	long after = request->readLong();
	Arts::StereoEffect_base* _temp_effect;
	Arts::readObject(*request,_temp_effect);
	Arts::StereoEffect effect = Arts::StereoEffect::_from_base(_temp_effect);
	std::string name;
	request->readString(name);
	result->writeLong(((Noatun::StereoEffectStack_skel *)object)->insertAfter(after,effect,name));
}

// move
static void _dispatch_Noatun_StereoEffectStack_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long after = request->readLong();
	long item = request->readLong();
	((Noatun::StereoEffectStack_skel *)object)->move(after,item);
}

// effectList
static void _dispatch_Noatun_StereoEffectStack_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<long> *_returnCode = ((Noatun::StereoEffectStack_skel *)object)->effectList();
	result->writeLongSeq(*_returnCode);
	delete _returnCode;
}

// insertTop
static void _dispatch_Noatun_StereoEffectStack_03(void *object, Arts::Buffer *request, Arts::Buffer *result)
{
	Arts::StereoEffect_base* _temp_effect;
	Arts::readObject(*request,_temp_effect);
	Arts::StereoEffect effect = Arts::StereoEffect::_from_base(_temp_effect);
	std::string name;
	request->readString(name);
	result->writeLong(((Noatun::StereoEffectStack_skel *)object)->insertTop(effect,name));
}

// insertBottom
static void _dispatch_Noatun_StereoEffectStack_04(void *object, Arts::Buffer *request, Arts::Buffer *result)
{
	Arts::StereoEffect_base* _temp_effect;
	Arts::readObject(*request,_temp_effect);
	Arts::StereoEffect effect = Arts::StereoEffect::_from_base(_temp_effect);
	std::string name;
	request->readString(name);
	result->writeLong(((Noatun::StereoEffectStack_skel *)object)->insertBottom(effect,name));
}

// remove
static void _dispatch_Noatun_StereoEffectStack_05(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long ID = request->readLong();
	((Noatun::StereoEffectStack_skel *)object)->remove(ID);
}

void Noatun::StereoEffectStack_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000c696e73657274416674657200000000056c6f6e67000000"
        "000200000003000000056c6f6e6700000000066166746572000000000000000013"
        "417274733a3a53746572656f456666656374000000000765666665637400000000"
        "0000000007737472696e6700000000056e616d6500000000000000000000000005"
        "6d6f76650000000005766f6964000000000200000002000000056c6f6e67000000"
        "000661667465720000000000000000056c6f6e6700000000056974656d00000000"
        "00000000000000000b6566666563744c69737400000000062a6c6f6e6700000000"
        "0200000000000000000000000a696e73657274546f7000000000056c6f6e670000"
        "0000020000000200000013417274733a3a53746572656f45666665637400000000"
        "07656666656374000000000000000007737472696e6700000000056e616d650000"
        "000000000000000000000d696e73657274426f74746f6d00000000056c6f6e6700"
        "000000020000000200000013417274733a3a53746572656f456666656374000000"
        "0007656666656374000000000000000007737472696e6700000000056e616d6500"
        "00000000000000000000000772656d6f76650000000005766f6964000000000200"
        "000001000000056c6f6e6700000000034944000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_StereoEffectStack_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_StereoEffectStack_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_StereoEffectStack_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_StereoEffectStack_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_StereoEffectStack_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_StereoEffectStack_05,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Noatun::StereoEffectStack_skel::StereoEffectStack_skel()
{
}

Arts::Object_base* Noatun::StereoEffectStack::_Creator() {
	return Noatun::StereoEffectStack_base::_create();
}

unsigned long Noatun::StereoEffectStack_base::_IID = Arts::MCOPUtils::makeIID("Noatun::StereoEffectStack");

Noatun::StereoVolumeControl_base *Noatun::StereoVolumeControl_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::StereoVolumeControl_base *castedObject = (Noatun::StereoVolumeControl_base *)skel->_cast(Noatun::StereoVolumeControl_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::StereoVolumeControl_base *Noatun::StereoVolumeControl_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::StereoVolumeControl_base::_fromReference(r,true);
	return 0;
}

Noatun::StereoVolumeControl_base *Noatun::StereoVolumeControl_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::StereoVolumeControl_base *castedObject = (Noatun::StereoVolumeControl_base *)object._base()->_cast(Noatun::StereoVolumeControl_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::StereoVolumeControl_base *Noatun::StereoVolumeControl_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::StereoVolumeControl_base *result;
	result = (Noatun::StereoVolumeControl_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::StereoVolumeControl");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::StereoVolumeControl_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::StereoVolumeControl")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::StereoVolumeControl_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inleft");
	ret.push_back("inright");
	return ret;
}
std::vector<std::string> Noatun::StereoVolumeControl_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outleft");
	ret.push_back("outright");
	return ret;
}

void *Noatun::StereoVolumeControl_base::_cast(unsigned long iid)
{
	if(iid == Noatun::StereoVolumeControl_base::_IID) return (Noatun::StereoVolumeControl_base *)this;
	if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::StereoVolumeControl_stub::StereoVolumeControl_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::StereoVolumeControl_stub::StereoVolumeControl_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Noatun::StereoVolumeControl_stub::percent()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f70657263656e740000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Noatun::StereoVolumeControl_stub::percent(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f70657263656e740000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::StereoVolumeControl_skel::_interfaceName()
{
	return "Noatun::StereoVolumeControl";
}

bool Noatun::StereoVolumeControl_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::StereoVolumeControl") return true;
	if (interfacename == "Arts::StereoEffect") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::StereoVolumeControl_skel::_interfaceNameSkel()
{
	return "Noatun::StereoVolumeControl";
}

// _get_percent
static void _dispatch_Noatun_StereoVolumeControl_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Noatun::StereoVolumeControl_skel *)object)->percent());
}

// _set_percent
static void _dispatch_Noatun_StereoVolumeControl_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Noatun::StereoVolumeControl_skel *)object)->percent(newValue);
}

void Noatun::StereoVolumeControl_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000d5f6765745f70657263656e740000000006666c6f617400"
        "0000000200000000000000000000000d5f7365745f70657263656e740000000005"
        "766f696400000000020000000100000006666c6f617400000000096e657756616c"
        "7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_StereoVolumeControl_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_StereoVolumeControl_01,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Noatun::StereoVolumeControl_skel::StereoVolumeControl_skel()
{
}

Arts::Object_base* Noatun::StereoVolumeControl::_Creator() {
	return Noatun::StereoVolumeControl_base::_create();
}

unsigned long Noatun::StereoVolumeControl_base::_IID = Arts::MCOPUtils::makeIID("Noatun::StereoVolumeControl");

Noatun::StereoVolumeControlSSE_base *Noatun::StereoVolumeControlSSE_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::StereoVolumeControlSSE_base *castedObject = (Noatun::StereoVolumeControlSSE_base *)skel->_cast(Noatun::StereoVolumeControlSSE_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::StereoVolumeControlSSE_base *Noatun::StereoVolumeControlSSE_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::StereoVolumeControlSSE_base::_fromReference(r,true);
	return 0;
}

Noatun::StereoVolumeControlSSE_base *Noatun::StereoVolumeControlSSE_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::StereoVolumeControlSSE_base *castedObject = (Noatun::StereoVolumeControlSSE_base *)object._base()->_cast(Noatun::StereoVolumeControlSSE_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::StereoVolumeControlSSE_base *Noatun::StereoVolumeControlSSE_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::StereoVolumeControlSSE_base *result;
	result = (Noatun::StereoVolumeControlSSE_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::StereoVolumeControlSSE");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::StereoVolumeControlSSE_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::StereoVolumeControlSSE")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::StereoVolumeControlSSE_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inleft");
	ret.push_back("inright");
	return ret;
}
std::vector<std::string> Noatun::StereoVolumeControlSSE_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outleft");
	ret.push_back("outright");
	return ret;
}

void *Noatun::StereoVolumeControlSSE_base::_cast(unsigned long iid)
{
	if(iid == Noatun::StereoVolumeControlSSE_base::_IID) return (Noatun::StereoVolumeControlSSE_base *)this;
	if(iid == Arts::StereoEffect_base::_IID) return (Arts::StereoEffect_base *)this;
	if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::StereoVolumeControlSSE_stub::StereoVolumeControlSSE_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::StereoVolumeControlSSE_stub::StereoVolumeControlSSE_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

float Noatun::StereoVolumeControlSSE_stub::percent()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f70657263656e740000000006666c6f617400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0.0; // error occurred
	float returnCode = result->readFloat();
	delete result;
	return returnCode;
}

void Noatun::StereoVolumeControlSSE_stub::percent(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f70657263656e740000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeFloat(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::StereoVolumeControlSSE_skel::_interfaceName()
{
	return "Noatun::StereoVolumeControlSSE";
}

bool Noatun::StereoVolumeControlSSE_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::StereoVolumeControlSSE") return true;
	if (interfacename == "Arts::StereoEffect") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::StereoVolumeControlSSE_skel::_interfaceNameSkel()
{
	return "Noatun::StereoVolumeControlSSE";
}

// _get_percent
static void _dispatch_Noatun_StereoVolumeControlSSE_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Noatun::StereoVolumeControlSSE_skel *)object)->percent());
}

// _set_percent
static void _dispatch_Noatun_StereoVolumeControlSSE_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Noatun::StereoVolumeControlSSE_skel *)object)->percent(newValue);
}

void Noatun::StereoVolumeControlSSE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000d5f6765745f70657263656e740000000006666c6f617400"
        "0000000200000000000000000000000d5f7365745f70657263656e740000000005"
        "766f696400000000020000000100000006666c6f617400000000096e657756616c"
        "7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_StereoVolumeControlSSE_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_StereoVolumeControlSSE_01,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Noatun::StereoVolumeControlSSE_skel::StereoVolumeControlSSE_skel()
{
}

Arts::Object_base* Noatun::StereoVolumeControlSSE::_Creator() {
	return Noatun::StereoVolumeControlSSE_base::_create();
}

unsigned long Noatun::StereoVolumeControlSSE_base::_IID = Arts::MCOPUtils::makeIID("Noatun::StereoVolumeControlSSE");

Noatun::Listener_base *Noatun::Listener_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::Listener_base *castedObject = (Noatun::Listener_base *)skel->_cast(Noatun::Listener_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::Listener_base *Noatun::Listener_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::Listener_base::_fromReference(r,true);
	return 0;
}

Noatun::Listener_base *Noatun::Listener_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::Listener_base *castedObject = (Noatun::Listener_base *)object._base()->_cast(Noatun::Listener_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::Listener_base *Noatun::Listener_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::Listener_base *result;
	result = (Noatun::Listener_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::Listener");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::Listener_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::Listener")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::Listener_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Noatun::Listener_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Noatun::Listener_base::_cast(unsigned long iid)
{
	if(iid == Noatun::Listener_base::_IID) return (Noatun::Listener_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::Listener_stub::Listener_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::Listener_stub::Listener_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

void Noatun::Listener_stub::message()
{
	long methodID = _lookupMethodFast("method:000000086d6573736167650000000005766f696400000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::Listener_skel::_interfaceName()
{
	return "Noatun::Listener";
}

bool Noatun::Listener_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::Listener") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::Listener_skel::_interfaceNameSkel()
{
	return "Noatun::Listener";
}

// message
static void _dispatch_Noatun_Listener_00(void *object, Arts::Buffer *, Arts::Buffer *)
{
	((Noatun::Listener_skel *)object)->message();
}

void Noatun::Listener_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000086d6573736167650000000005766f696400000000020000"
        "000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_Listener_00,this,Arts::MethodDef(m));
}

Noatun::Listener_skel::Listener_skel()
{
}

Arts::Object_base* Noatun::Listener::_Creator() {
	return Noatun::Listener_base::_create();
}

unsigned long Noatun::Listener_base::_IID = Arts::MCOPUtils::makeIID("Noatun::Listener");

Noatun::Session_base *Noatun::Session_base::_create(const std::string& subClass)
{
	Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
	assert(skel);
	Noatun::Session_base *castedObject = (Noatun::Session_base *)skel->_cast(Noatun::Session_base::_IID);
	assert(castedObject);
	return castedObject;
}

Noatun::Session_base *Noatun::Session_base::_fromString(const std::string& objectref)
{
	Arts::ObjectReference r;

	if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
		return Noatun::Session_base::_fromReference(r,true);
	return 0;
}

Noatun::Session_base *Noatun::Session_base::_fromDynamicCast(const Arts::Object& object)
{
	if(object.isNull()) return 0;

	Noatun::Session_base *castedObject = (Noatun::Session_base *)object._base()->_cast(Noatun::Session_base::_IID);
	if(castedObject) return castedObject->_copy();

	return _fromString(object._toString());
}

Noatun::Session_base *Noatun::Session_base::_fromReference(Arts::ObjectReference r, bool needcopy)
{
	Noatun::Session_base *result;
	result = (Noatun::Session_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Noatun::Session");
	if(result)
	{
		if(!needcopy)
			result->_cancelCopyRemote();
	}
	else
	{
		Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
		if(conn)
		{
			result = new Noatun::Session_stub(conn,r.objectID);
			if(needcopy) result->_copyRemote();
			result->_useRemote();
			if (!result->_isCompatibleWith("Noatun::Session")) {
				result->_release();
				return 0;
			}
		}
	}
	return result;
}

std::vector<std::string> Noatun::Session_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Noatun::Session_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Noatun::Session_base::_cast(unsigned long iid)
{
	if(iid == Noatun::Session_base::_IID) return (Noatun::Session_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Noatun::Session_stub::Session_stub()
{
	// constructor for subclasses (don't use directly)
}

Noatun::Session_stub::Session_stub(Arts::Connection *connection, long objectID)
	: Arts::Object_stub(connection, objectID)
{
	// constructor to create a stub for an object
}

void Noatun::Session_stub::addListener(Noatun::Listener listener)
{
	long methodID = _lookupMethodFast("method:0000000c6164644c697374656e65720000000005766f6964000000000200000001000000114e6f6174756e3a3a4c697374656e657200000000096c697374656e6572000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	Arts::writeObject(*request,listener._base());
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

void Noatun::Session_stub::removeListener(Noatun::Listener listener)
{
	long methodID = _lookupMethodFast("method:0000000f72656d6f76654c697374656e65720000000005766f6964000000000200000001000000114e6f6174756e3a3a4c697374656e657200000000096c697374656e6572000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	Arts::writeObject(*request,listener._base());
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

long Noatun::Session_stub::pid()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f70696400000000056c6f6e6700000000020000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(!result) return 0; // error occurred
	long returnCode = result->readLong();
	delete result;
	return returnCode;
}

void Noatun::Session_stub::pid(long newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f7069640000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeLong(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

	result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
	if(result) delete result;
}

std::string Noatun::Session_skel::_interfaceName()
{
	return "Noatun::Session";
}

bool Noatun::Session_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Noatun::Session") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Noatun::Session_skel::_interfaceNameSkel()
{
	return "Noatun::Session";
}

// addListener
static void _dispatch_Noatun_Session_00(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	Noatun::Listener_base* _temp_listener;
	Arts::readObject(*request,_temp_listener);
	Noatun::Listener listener = Noatun::Listener::_from_base(_temp_listener);
	((Noatun::Session_skel *)object)->addListener(listener);
}

// removeListener
static void _dispatch_Noatun_Session_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	Noatun::Listener_base* _temp_listener;
	Arts::readObject(*request,_temp_listener);
	Noatun::Listener listener = Noatun::Listener::_from_base(_temp_listener);
	((Noatun::Session_skel *)object)->removeListener(listener);
}

// _get_pid
static void _dispatch_Noatun_Session_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Noatun::Session_skel *)object)->pid());
}

// _set_pid
static void _dispatch_Noatun_Session_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Noatun::Session_skel *)object)->pid(newValue);
}

void Noatun::Session_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000c6164644c697374656e65720000000005766f6964000000"
        "000200000001000000114e6f6174756e3a3a4c697374656e657200000000096c69"
        "7374656e65720000000000000000000000000f72656d6f76654c697374656e6572"
        "0000000005766f6964000000000200000001000000114e6f6174756e3a3a4c6973"
        "74656e657200000000096c697374656e6572000000000000000000000000095f67"
        "65745f70696400000000056c6f6e6700000000020000000000000000000000095f"
        "7365745f7069640000000005766f6964000000000200000001000000056c6f6e67"
        "00000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Noatun_Session_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Session_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Session_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Noatun_Session_03,this,Arts::MethodDef(m));
}

Noatun::Session_skel::Session_skel()
{
}

Arts::Object_base* Noatun::Session::_Creator() {
	return Noatun::Session_base::_create();
}

unsigned long Noatun::Session_base::_IID = Arts::MCOPUtils::makeIID("Noatun::Session");

static Arts::IDLFileReg IDLFileReg_noatunarts("noatunarts",
    "IDLFile:000000010000000000000000000000000b000000124e6f6174756e3a3a4571"
    "75616c697a6572000000000100000013417274733a3a53746572656f45666665637400"
    "00000001000000047365740000000005766f6964000000000200000003000000072a66"
    "6c6f617400000000076c6576656c730000000000000000072a666c6f61740000000008"
    "63656e746572730000000000000000072a666c6f617400000000077769647468730000"
    "00000000000000000000060000000d6c6576656c43656e7465727300000000072a666c"
    "6f61740000000013000000000000000c6c6576656c57696474687300000000072a666c"
    "6f6174000000001300000000000000076c6576656c7300000000072a666c6f61740000"
    "000013000000000000000662616e647300000000056c6f6e6700000000130000000000"
    "000008656e61626c656400000000056c6f6e6700000000130000000000000007707265"
    "616d700000000006666c6f61740000000013000000000000000000000000000000154e"
    "6f6174756e3a3a457175616c697a6572535345000000000100000013417274733a3a53"
    "746572656f4566666563740000000001000000047365740000000005766f6964000000"
    "000200000003000000072a666c6f617400000000076c6576656c730000000000000000"
    "072a666c6f6174000000000863656e746572730000000000000000072a666c6f617400"
    "00000007776964746873000000000000000000000000060000000d6c6576656c43656e"
    "7465727300000000072a666c6f61740000000013000000000000000c6c6576656c5769"
    "6474687300000000072a666c6f6174000000001300000000000000076c6576656c7300"
    "000000072a666c6f61740000000013000000000000000662616e647300000000056c6f"
    "6e6700000000130000000000000008656e61626c656400000000056c6f6e6700000000"
    "130000000000000007707265616d700000000006666c6f617400000000130000000000"
    "00000000000000000000114e6f6174756e3a3a46465453636f70650000000001000000"
    "13417274733a3a53746572656f45666665637400000000010000000673636f70650000"
    "0000072a666c6f617400000000020000000000000000000000010000000f62616e6452"
    "65736f6c7574696f6e0000000006666c6f617400000000130000000000000000000000"
    "00000000174e6f6174756e3a3a46465453636f706553746572656f0000000001000000"
    "13417274733a3a53746572656f45666665637400000000020000000b73636f70655269"
    "67687400000000072a666c6f6174000000000200000000000000000000000a73636f70"
    "654c65667400000000072a666c6f617400000000020000000000000000000000010000"
    "000f62616e645265736f6c7574696f6e0000000006666c6f6174000000001300000000"
    "0000000000000000000000114e6f6174756e3a3a52617753636f706500000000010000"
    "0013417274733a3a53746572656f45666665637400000000010000000673636f706500"
    "000000072a666c6f617400000000020000000000000000000000010000000762756666"
    "657200000000056c6f6e670000000013000000000000000000000000000000174e6f61"
    "74756e3a3a52617753636f706553746572656f000000000100000013417274733a3a53"
    "746572656f45666665637400000000020000000a73636f70654c65667400000000072a"
    "666c6f6174000000000200000000000000000000000b73636f70655269676874000000"
    "00072a666c6f6174000000000200000000000000000000000100000007627566666572"
    "00000000056c6f6e6700000000130000000000000000000000000000001a4e6f617475"
    "6e3a3a53746572656f456666656374537461636b000000000100000013417274733a3a"
    "53746572656f45666665637400000000060000000c696e736572744166746572000000"
    "00056c6f6e67000000000200000003000000056c6f6e67000000000661667465720000"
    "00000000000013417274733a3a53746572656f45666665637400000000076566666563"
    "74000000000000000007737472696e6700000000056e616d6500000000000000000000"
    "0000056d6f76650000000005766f6964000000000200000002000000056c6f6e670000"
    "00000661667465720000000000000000056c6f6e6700000000056974656d0000000000"
    "000000000000000b6566666563744c69737400000000062a6c6f6e6700000000020000"
    "0000000000000000000a696e73657274546f7000000000056c6f6e6700000000020000"
    "000200000013417274733a3a53746572656f4566666563740000000007656666656374"
    "000000000000000007737472696e6700000000056e616d650000000000000000000000"
    "000d696e73657274426f74746f6d00000000056c6f6e67000000000200000002000000"
    "13417274733a3a53746572656f45666665637400000000076566666563740000000000"
    "00000007737472696e6700000000056e616d650000000000000000000000000772656d"
    "6f76650000000005766f6964000000000200000001000000056c6f6e67000000000349"
    "440000000000000000000000000000000000000000000000001c4e6f6174756e3a3a53"
    "746572656f566f6c756d65436f6e74726f6c000000000100000013417274733a3a5374"
    "6572656f4566666563740000000000000000010000000870657263656e740000000006"
    "666c6f617400000000130000000000000000000000000000001f4e6f6174756e3a3a53"
    "746572656f566f6c756d65436f6e74726f6c535345000000000100000013417274733a"
    "3a53746572656f4566666563740000000000000000010000000870657263656e740000"
    "000006666c6f61740000000013000000000000000000000000000000114e6f6174756e"
    "3a3a4c697374656e6572000000000000000001000000086d6573736167650000000005"
    "766f696400000000020000000000000000000000000000000000000000000000104e6f"
    "6174756e3a3a53657373696f6e0000000000000000020000000c6164644c697374656e"
    "65720000000005766f6964000000000200000001000000114e6f6174756e3a3a4c6973"
    "74656e657200000000096c697374656e65720000000000000000000000000f72656d6f"
    "76654c697374656e65720000000005766f6964000000000200000001000000114e6f61"
    "74756e3a3a4c697374656e657200000000096c697374656e6572000000000000000000"
    "000000010000000470696400000000056c6f6e67000000001300000000000000000000"
    "000000000000"
);
