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

#include "artsmoduleseffects.h"

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

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

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

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

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

	return _fromString(object._toString());
}

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

std::vector<std::string> Arts::StereoToMono_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	return ret;
}
std::vector<std::string> Arts::StereoToMono_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	ret.push_back("outmono");
	return ret;
}

void *Arts::StereoToMono_base::_cast(unsigned long iid)
{
	if(iid == Arts::StereoToMono_base::_IID) return (Arts::StereoToMono_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;
}

Arts::StereoToMono_stub::StereoToMono_stub()
{
	// constructor for subclasses (don't use directly)
}

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

float Arts::StereoToMono_stub::pan()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f70616e0000000006666c6f617400000000020000000000000000");
	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 Arts::StereoToMono_stub::pan(float newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f70616e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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 Arts::StereoToMono_skel::_interfaceName()
{
	return "Arts::StereoToMono";
}

bool Arts::StereoToMono_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::StereoToMono") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::StereoToMono_skel::_interfaceNameSkel()
{
	return "Arts::StereoToMono";
}

// _get_pan
static void _dispatch_Arts_StereoToMono_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::StereoToMono_skel *)object)->pan());
}

// _set_pan
static void _dispatch_Arts_StereoToMono_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::StereoToMono_skel *)object)->pan(newValue);
}

void Arts::StereoToMono_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000095f6765745f70616e0000000006666c6f61740000000002"
        "0000000000000000000000095f7365745f70616e0000000005766f696400000000"
        "020000000100000006666c6f617400000000096e657756616c7565000000000000"
        "000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_StereoToMono_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoToMono_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::StereoToMono_skel::StereoToMono_skel()
{
	_initStream("inleft",&inleft,9);
	_initStream("inright",&inright,9);
	_initStream("outmono",&outmono,10);
}

Arts::Object_base* Arts::StereoToMono::_Creator() {
	return Arts::StereoToMono_base::_create();
}

unsigned long Arts::StereoToMono_base::_IID = Arts::MCOPUtils::makeIID("Arts::StereoToMono");

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

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

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

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

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

	return _fromString(object._toString());
}

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

std::vector<std::string> Arts::MonoToStereo_base::_defaultPortsIn() const {
	std::vector<std::string> ret;
	ret.push_back("inmono");
	return ret;
}
std::vector<std::string> Arts::MonoToStereo_base::_defaultPortsOut() const {
	std::vector<std::string> ret;
	return ret;
}

void *Arts::MonoToStereo_base::_cast(unsigned long iid)
{
	if(iid == Arts::MonoToStereo_base::_IID) return (Arts::MonoToStereo_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;
}

Arts::MonoToStereo_stub::MonoToStereo_stub()
{
	// constructor for subclasses (don't use directly)
}

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

float Arts::MonoToStereo_stub::pan()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f70616e0000000006666c6f617400000000020000000000000000");
	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 Arts::MonoToStereo_stub::pan(float newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f70616e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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 Arts::MonoToStereo_skel::_interfaceName()
{
	return "Arts::MonoToStereo";
}

bool Arts::MonoToStereo_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::MonoToStereo") return true;
	if (interfacename == "Arts::SynthModule") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::MonoToStereo_skel::_interfaceNameSkel()
{
	return "Arts::MonoToStereo";
}

// _get_pan
static void _dispatch_Arts_MonoToStereo_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::MonoToStereo_skel *)object)->pan());
}

// _set_pan
static void _dispatch_Arts_MonoToStereo_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::MonoToStereo_skel *)object)->pan(newValue);
}

void Arts::MonoToStereo_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000095f6765745f70616e0000000006666c6f61740000000002"
        "0000000000000000000000095f7365745f70616e0000000005766f696400000000"
        "020000000100000006666c6f617400000000096e657756616c7565000000000000"
        "000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_MonoToStereo_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_MonoToStereo_01,this,Arts::MethodDef(m));
	Arts::SynthModule_skel::_buildMethodTable();
}

Arts::MonoToStereo_skel::MonoToStereo_skel()
{
	_initStream("inmono",&inmono,9);
	_initStream("outleft",&outleft,10);
	_initStream("outright",&outright,10);
}

Arts::Object_base* Arts::MonoToStereo::_Creator() {
	return Arts::MonoToStereo_base::_create();
}

unsigned long Arts::MonoToStereo_base::_IID = Arts::MCOPUtils::makeIID("Arts::MonoToStereo");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::StereoBalance_base::_cast(unsigned long iid)
{
	if(iid == Arts::StereoBalance_base::_IID) return (Arts::StereoBalance_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;
}

Arts::StereoBalance_stub::StereoBalance_stub()
{
	// constructor for subclasses (don't use directly)
}

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

float Arts::StereoBalance_stub::balance()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f62616c616e63650000000006666c6f617400000000020000000000000000");
	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 Arts::StereoBalance_stub::balance(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f62616c616e63650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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 Arts::StereoBalance_skel::_interfaceName()
{
	return "Arts::StereoBalance";
}

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

std::string Arts::StereoBalance_skel::_interfaceNameSkel()
{
	return "Arts::StereoBalance";
}

// _get_balance
static void _dispatch_Arts_StereoBalance_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::StereoBalance_skel *)object)->balance());
}

// _set_balance
static void _dispatch_Arts_StereoBalance_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::StereoBalance_skel *)object)->balance(newValue);
}

void Arts::StereoBalance_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000d5f6765745f62616c616e63650000000006666c6f617400"
        "0000000200000000000000000000000d5f7365745f62616c616e63650000000005"
        "766f696400000000020000000100000006666c6f617400000000096e657756616c"
        "7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_StereoBalance_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoBalance_01,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Arts::StereoBalance_skel::StereoBalance_skel()
{
}

Arts::Object_base* Arts::StereoBalance::_Creator() {
	return Arts::StereoBalance_base::_create();
}

unsigned long Arts::StereoBalance_base::_IID = Arts::MCOPUtils::makeIID("Arts::StereoBalance");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

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

Arts::StereoBalanceGuiFactory_stub::StereoBalanceGuiFactory_stub()
{
	// constructor for subclasses (don't use directly)
}

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

std::string Arts::StereoBalanceGuiFactory_skel::_interfaceName()
{
	return "Arts::StereoBalanceGuiFactory";
}

bool Arts::StereoBalanceGuiFactory_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::StereoBalanceGuiFactory") return true;
	if (interfacename == "Arts::GuiFactory") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::StereoBalanceGuiFactory_skel::_interfaceNameSkel()
{
	return "Arts::StereoBalanceGuiFactory";
}

void Arts::StereoBalanceGuiFactory_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::GuiFactory_skel::_buildMethodTable();
}

Arts::StereoBalanceGuiFactory_skel::StereoBalanceGuiFactory_skel()
{
}

Arts::Object_base* Arts::StereoBalanceGuiFactory::_Creator() {
	return Arts::StereoBalanceGuiFactory_base::_create();
}

unsigned long Arts::StereoBalanceGuiFactory_base::_IID = Arts::MCOPUtils::makeIID("Arts::StereoBalanceGuiFactory");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::FiveBandMonoComplexEQ_base::_cast(unsigned long iid)
{
	if(iid == Arts::FiveBandMonoComplexEQ_base::_IID) return (Arts::FiveBandMonoComplexEQ_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;
}

Arts::FiveBandMonoComplexEQ_stub::FiveBandMonoComplexEQ_stub()
{
	// constructor for subclasses (don't use directly)
}

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

Arts::StereoToMono Arts::FiveBandMonoComplexEQ_stub::s2m()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f73326d0000000013417274733a3a53746572656f546f4d6f6e6f00000000020000000000000000");
	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 Arts::StereoToMono::null();
	Arts::StereoToMono_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::StereoToMono::_from_base(returnCode);
}

float Arts::FiveBandMonoComplexEQ_stub::lowfreq()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f6c6f77667265710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::lowfreq(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f6c6f77667265710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::lowq()
{
	long methodID = _lookupMethodFast("method:0000000a5f6765745f6c6f77710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::lowq(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000a5f7365745f6c6f77710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::lowgain()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f6c6f776761696e0000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::lowgain(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f6c6f776761696e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::mid1freq()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f6d696431667265710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::mid1freq(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f6d696431667265710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::mid1q()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f6d696431710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::mid1q(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f6d696431710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::mid1gain()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f6d6964316761696e0000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::mid1gain(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f6d6964316761696e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::mid2freq()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f6d696432667265710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::mid2freq(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f6d696432667265710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::mid2q()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f6d696432710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::mid2q(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f6d696432710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::mid2gain()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f6d6964326761696e0000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::mid2gain(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f6d6964326761696e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::mid3freq()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f6d696433667265710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::mid3freq(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f6d696433667265710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::mid3q()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f6d696433710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::mid3q(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f6d696433710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::mid3gain()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f6d6964336761696e0000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::mid3gain(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f6d6964336761696e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::highfreq()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f68696768667265710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::highfreq(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f68696768667265710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::highq()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f68696768710000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::highq(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f68696768710000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::FiveBandMonoComplexEQ_stub::highgain()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f686967686761696e0000000006666c6f617400000000020000000000000000");
	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 Arts::FiveBandMonoComplexEQ_stub::highgain(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f686967686761696e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

Arts::MonoToStereo Arts::FiveBandMonoComplexEQ_stub::m2s()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f6d32730000000013417274733a3a4d6f6e6f546f53746572656f00000000020000000000000000");
	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 Arts::MonoToStereo::null();
	Arts::MonoToStereo_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::MonoToStereo::_from_base(returnCode);
}

std::string Arts::FiveBandMonoComplexEQ_skel::_interfaceName()
{
	return "Arts::FiveBandMonoComplexEQ";
}

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

std::string Arts::FiveBandMonoComplexEQ_skel::_interfaceNameSkel()
{
	return "Arts::FiveBandMonoComplexEQ";
}

// _get_s2m
static void _dispatch_Arts_FiveBandMonoComplexEQ_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::StereoToMono returnCode = ((Arts::FiveBandMonoComplexEQ_skel *)object)->s2m();
	Arts::writeObject(*result,returnCode._base());
}

// _get_lowfreq
static void _dispatch_Arts_FiveBandMonoComplexEQ_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->lowfreq());
}

// _set_lowfreq
static void _dispatch_Arts_FiveBandMonoComplexEQ_02(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->lowfreq(newValue);
}

// _get_lowq
static void _dispatch_Arts_FiveBandMonoComplexEQ_03(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->lowq());
}

// _set_lowq
static void _dispatch_Arts_FiveBandMonoComplexEQ_04(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->lowq(newValue);
}

// _get_lowgain
static void _dispatch_Arts_FiveBandMonoComplexEQ_05(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->lowgain());
}

// _set_lowgain
static void _dispatch_Arts_FiveBandMonoComplexEQ_06(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->lowgain(newValue);
}

// _get_mid1freq
static void _dispatch_Arts_FiveBandMonoComplexEQ_07(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->mid1freq());
}

// _set_mid1freq
static void _dispatch_Arts_FiveBandMonoComplexEQ_08(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->mid1freq(newValue);
}

// _get_mid1q
static void _dispatch_Arts_FiveBandMonoComplexEQ_09(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->mid1q());
}

// _set_mid1q
static void _dispatch_Arts_FiveBandMonoComplexEQ_10(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->mid1q(newValue);
}

// _get_mid1gain
static void _dispatch_Arts_FiveBandMonoComplexEQ_11(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->mid1gain());
}

// _set_mid1gain
static void _dispatch_Arts_FiveBandMonoComplexEQ_12(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->mid1gain(newValue);
}

// _get_mid2freq
static void _dispatch_Arts_FiveBandMonoComplexEQ_13(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->mid2freq());
}

// _set_mid2freq
static void _dispatch_Arts_FiveBandMonoComplexEQ_14(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->mid2freq(newValue);
}

// _get_mid2q
static void _dispatch_Arts_FiveBandMonoComplexEQ_15(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->mid2q());
}

// _set_mid2q
static void _dispatch_Arts_FiveBandMonoComplexEQ_16(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->mid2q(newValue);
}

// _get_mid2gain
static void _dispatch_Arts_FiveBandMonoComplexEQ_17(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->mid2gain());
}

// _set_mid2gain
static void _dispatch_Arts_FiveBandMonoComplexEQ_18(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->mid2gain(newValue);
}

// _get_mid3freq
static void _dispatch_Arts_FiveBandMonoComplexEQ_19(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->mid3freq());
}

// _set_mid3freq
static void _dispatch_Arts_FiveBandMonoComplexEQ_20(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->mid3freq(newValue);
}

// _get_mid3q
static void _dispatch_Arts_FiveBandMonoComplexEQ_21(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->mid3q());
}

// _set_mid3q
static void _dispatch_Arts_FiveBandMonoComplexEQ_22(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->mid3q(newValue);
}

// _get_mid3gain
static void _dispatch_Arts_FiveBandMonoComplexEQ_23(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->mid3gain());
}

// _set_mid3gain
static void _dispatch_Arts_FiveBandMonoComplexEQ_24(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->mid3gain(newValue);
}

// _get_highfreq
static void _dispatch_Arts_FiveBandMonoComplexEQ_25(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->highfreq());
}

// _set_highfreq
static void _dispatch_Arts_FiveBandMonoComplexEQ_26(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->highfreq(newValue);
}

// _get_highq
static void _dispatch_Arts_FiveBandMonoComplexEQ_27(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->highq());
}

// _set_highq
static void _dispatch_Arts_FiveBandMonoComplexEQ_28(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->highq(newValue);
}

// _get_highgain
static void _dispatch_Arts_FiveBandMonoComplexEQ_29(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::FiveBandMonoComplexEQ_skel *)object)->highgain());
}

// _set_highgain
static void _dispatch_Arts_FiveBandMonoComplexEQ_30(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::FiveBandMonoComplexEQ_skel *)object)->highgain(newValue);
}

// _get_m2s
static void _dispatch_Arts_FiveBandMonoComplexEQ_31(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::MonoToStereo returnCode = ((Arts::FiveBandMonoComplexEQ_skel *)object)->m2s();
	Arts::writeObject(*result,returnCode._base());
}

void Arts::FiveBandMonoComplexEQ_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000095f6765745f73326d0000000013417274733a3a53746572"
        "656f546f4d6f6e6f000000000200000000000000000000000d5f6765745f6c6f77"
        "667265710000000006666c6f6174000000000200000000000000000000000d5f73"
        "65745f6c6f77667265710000000005766f69640000000002000000010000000666"
        "6c6f617400000000096e657756616c75650000000000000000000000000a5f6765"
        "745f6c6f77710000000006666c6f6174000000000200000000000000000000000a"
        "5f7365745f6c6f77710000000005766f696400000000020000000100000006666c"
        "6f617400000000096e657756616c75650000000000000000000000000d5f676574"
        "5f6c6f776761696e0000000006666c6f6174000000000200000000000000000000"
        "000d5f7365745f6c6f776761696e0000000005766f696400000000020000000100"
        "000006666c6f617400000000096e657756616c7565000000000000000000000000"
        "0e5f6765745f6d696431667265710000000006666c6f6174000000000200000000"
        "000000000000000e5f7365745f6d696431667265710000000005766f6964000000"
        "00020000000100000006666c6f617400000000096e657756616c75650000000000"
        "000000000000000b5f6765745f6d696431710000000006666c6f61740000000002"
        "00000000000000000000000b5f7365745f6d696431710000000005766f69640000"
        "0000020000000100000006666c6f617400000000096e657756616c756500000000"
        "00000000000000000e5f6765745f6d6964316761696e0000000006666c6f617400"
        "0000000200000000000000000000000e5f7365745f6d6964316761696e00000000"
        "05766f696400000000020000000100000006666c6f617400000000096e65775661"
        "6c75650000000000000000000000000e5f6765745f6d6964326672657100000000"
        "06666c6f6174000000000200000000000000000000000e5f7365745f6d69643266"
        "7265710000000005766f696400000000020000000100000006666c6f6174000000"
        "00096e657756616c75650000000000000000000000000b5f6765745f6d69643271"
        "0000000006666c6f6174000000000200000000000000000000000b5f7365745f6d"
        "696432710000000005766f696400000000020000000100000006666c6f61740000"
        "0000096e657756616c75650000000000000000000000000e5f6765745f6d696432"
        "6761696e0000000006666c6f6174000000000200000000000000000000000e5f73"
        "65745f6d6964326761696e0000000005766f696400000000020000000100000006"
        "666c6f617400000000096e657756616c75650000000000000000000000000e5f67"
        "65745f6d696433667265710000000006666c6f6174000000000200000000000000"
        "000000000e5f7365745f6d696433667265710000000005766f6964000000000200"
        "00000100000006666c6f617400000000096e657756616c75650000000000000000"
        "000000000b5f6765745f6d696433710000000006666c6f61740000000002000000"
        "00000000000000000b5f7365745f6d696433710000000005766f69640000000002"
        "0000000100000006666c6f617400000000096e657756616c756500000000000000"
        "00000000000e5f6765745f6d6964336761696e0000000006666c6f617400000000"
        "0200000000000000000000000e5f7365745f6d6964336761696e0000000005766f"
        "696400000000020000000100000006666c6f617400000000096e657756616c7565"
        "0000000000000000000000000e5f6765745f68696768667265710000000006666c"
        "6f6174000000000200000000000000000000000e5f7365745f6869676866726571"
        "0000000005766f696400000000020000000100000006666c6f617400000000096e"
        "657756616c75650000000000000000000000000b5f6765745f6869676871000000"
        "0006666c6f6174000000000200000000000000000000000b5f7365745f68696768"
        "710000000005766f696400000000020000000100000006666c6f61740000000009"
        "6e657756616c75650000000000000000000000000e5f6765745f68696768676169"
        "6e0000000006666c6f6174000000000200000000000000000000000e5f7365745f"
        "686967686761696e0000000005766f696400000000020000000100000006666c6f"
        "617400000000096e657756616c7565000000000000000000000000095f6765745f"
        "6d32730000000013417274733a3a4d6f6e6f546f53746572656f00000000020000"
        "000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_07,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_08,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_09,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_10,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_11,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_12,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_13,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_14,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_15,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_16,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_17,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_18,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_19,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_20,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_21,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_22,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_23,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_24,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_25,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_26,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_27,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_28,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_29,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_30,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_FiveBandMonoComplexEQ_31,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Arts::FiveBandMonoComplexEQ_skel::FiveBandMonoComplexEQ_skel()
{
}

Arts::Object_base* Arts::FiveBandMonoComplexEQ::_Creator() {
	return Arts::FiveBandMonoComplexEQ_base::_create();
}

unsigned long Arts::FiveBandMonoComplexEQ_base::_IID = Arts::MCOPUtils::makeIID("Arts::FiveBandMonoComplexEQ");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

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

Arts::FiveBandMonoComplexEQGuiFactory_stub::FiveBandMonoComplexEQGuiFactory_stub()
{
	// constructor for subclasses (don't use directly)
}

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

std::string Arts::FiveBandMonoComplexEQGuiFactory_skel::_interfaceName()
{
	return "Arts::FiveBandMonoComplexEQGuiFactory";
}

bool Arts::FiveBandMonoComplexEQGuiFactory_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::FiveBandMonoComplexEQGuiFactory") return true;
	if (interfacename == "Arts::GuiFactory") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::FiveBandMonoComplexEQGuiFactory_skel::_interfaceNameSkel()
{
	return "Arts::FiveBandMonoComplexEQGuiFactory";
}

void Arts::FiveBandMonoComplexEQGuiFactory_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::GuiFactory_skel::_buildMethodTable();
}

Arts::FiveBandMonoComplexEQGuiFactory_skel::FiveBandMonoComplexEQGuiFactory_skel()
{
}

Arts::Object_base* Arts::FiveBandMonoComplexEQGuiFactory::_Creator() {
	return Arts::FiveBandMonoComplexEQGuiFactory_base::_create();
}

unsigned long Arts::FiveBandMonoComplexEQGuiFactory_base::_IID = Arts::MCOPUtils::makeIID("Arts::FiveBandMonoComplexEQGuiFactory");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::Synth_VOICE_REMOVAL_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_VOICE_REMOVAL_base::_IID) return (Arts::Synth_VOICE_REMOVAL_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;
}

Arts::Synth_VOICE_REMOVAL_stub::Synth_VOICE_REMOVAL_stub()
{
	// constructor for subclasses (don't use directly)
}

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

float Arts::Synth_VOICE_REMOVAL_stub::position()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f706f736974696f6e0000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_VOICE_REMOVAL_stub::position(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f706f736974696f6e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_VOICE_REMOVAL_stub::frequency()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f6672657175656e63790000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_VOICE_REMOVAL_stub::frequency(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f6672657175656e63790000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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 Arts::Synth_VOICE_REMOVAL_skel::_interfaceName()
{
	return "Arts::Synth_VOICE_REMOVAL";
}

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

std::string Arts::Synth_VOICE_REMOVAL_skel::_interfaceNameSkel()
{
	return "Arts::Synth_VOICE_REMOVAL";
}

// _get_position
static void _dispatch_Arts_Synth_VOICE_REMOVAL_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_VOICE_REMOVAL_skel *)object)->position());
}

// _set_position
static void _dispatch_Arts_Synth_VOICE_REMOVAL_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_VOICE_REMOVAL_skel *)object)->position(newValue);
}

// _get_frequency
static void _dispatch_Arts_Synth_VOICE_REMOVAL_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_VOICE_REMOVAL_skel *)object)->frequency());
}

// _set_frequency
static void _dispatch_Arts_Synth_VOICE_REMOVAL_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_VOICE_REMOVAL_skel *)object)->frequency(newValue);
}

void Arts::Synth_VOICE_REMOVAL_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000e5f6765745f706f736974696f6e0000000006666c6f6174"
        "000000000200000000000000000000000e5f7365745f706f736974696f6e000000"
        "0005766f696400000000020000000100000006666c6f617400000000096e657756"
        "616c75650000000000000000000000000f5f6765745f6672657175656e63790000"
        "000006666c6f6174000000000200000000000000000000000f5f7365745f667265"
        "7175656e63790000000005766f696400000000020000000100000006666c6f6174"
        "00000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_VOICE_REMOVAL_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_VOICE_REMOVAL_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_VOICE_REMOVAL_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_VOICE_REMOVAL_03,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Arts::Synth_VOICE_REMOVAL_skel::Synth_VOICE_REMOVAL_skel()
{
}

Arts::Object_base* Arts::Synth_VOICE_REMOVAL::_Creator() {
	return Arts::Synth_VOICE_REMOVAL_base::_create();
}

unsigned long Arts::Synth_VOICE_REMOVAL_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_VOICE_REMOVAL");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

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

Arts::VoiceRemovalGuiFactory_stub::VoiceRemovalGuiFactory_stub()
{
	// constructor for subclasses (don't use directly)
}

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

std::string Arts::VoiceRemovalGuiFactory_skel::_interfaceName()
{
	return "Arts::VoiceRemovalGuiFactory";
}

bool Arts::VoiceRemovalGuiFactory_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::VoiceRemovalGuiFactory") return true;
	if (interfacename == "Arts::GuiFactory") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::VoiceRemovalGuiFactory_skel::_interfaceNameSkel()
{
	return "Arts::VoiceRemovalGuiFactory";
}

void Arts::VoiceRemovalGuiFactory_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::GuiFactory_skel::_buildMethodTable();
}

Arts::VoiceRemovalGuiFactory_skel::VoiceRemovalGuiFactory_skel()
{
}

Arts::Object_base* Arts::VoiceRemovalGuiFactory::_Creator() {
	return Arts::VoiceRemovalGuiFactory_base::_create();
}

unsigned long Arts::VoiceRemovalGuiFactory_base::_IID = Arts::MCOPUtils::makeIID("Arts::VoiceRemovalGuiFactory");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::Synth_STEREO_COMPRESSOR_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_STEREO_COMPRESSOR_base::_IID) return (Arts::Synth_STEREO_COMPRESSOR_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;
}

Arts::Synth_STEREO_COMPRESSOR_stub::Synth_STEREO_COMPRESSOR_stub()
{
	// constructor for subclasses (don't use directly)
}

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

float Arts::Synth_STEREO_COMPRESSOR_stub::attack()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f61747461636b0000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_STEREO_COMPRESSOR_stub::attack(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f61747461636b0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_STEREO_COMPRESSOR_stub::release()
{
	long methodID = _lookupMethodFast("method:0000000d5f6765745f72656c656173650000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_STEREO_COMPRESSOR_stub::release(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000d5f7365745f72656c656173650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_STEREO_COMPRESSOR_stub::threshold()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f7468726573686f6c640000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_STEREO_COMPRESSOR_stub::threshold(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f7468726573686f6c640000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_STEREO_COMPRESSOR_stub::ratio()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f726174696f0000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_STEREO_COMPRESSOR_stub::ratio(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f726174696f0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_STEREO_COMPRESSOR_stub::output()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f6f75747075740000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_STEREO_COMPRESSOR_stub::output(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f6f75747075740000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

bool Arts::Synth_STEREO_COMPRESSOR_stub::thru()
{
	long methodID = _lookupMethodFast("method:0000000a5f6765745f746872750000000008626f6f6c65616e00000000020000000000000000");
	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 false; // error occurred
	bool returnCode = result->readBool();
	delete result;
	return returnCode;
}

void Arts::Synth_STEREO_COMPRESSOR_stub::thru(bool newValue)
{
	long methodID = _lookupMethodFast("method:0000000a5f7365745f746872750000000005766f696400000000020000000100000008626f6f6c65616e00000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeBool(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

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

std::string Arts::Synth_STEREO_COMPRESSOR_skel::_interfaceName()
{
	return "Arts::Synth_STEREO_COMPRESSOR";
}

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

std::string Arts::Synth_STEREO_COMPRESSOR_skel::_interfaceNameSkel()
{
	return "Arts::Synth_STEREO_COMPRESSOR";
}

// _get_attack
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->attack());
}

// _set_attack
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->attack(newValue);
}

// _get_release
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->release());
}

// _set_release
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->release(newValue);
}

// _get_threshold
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_04(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->threshold());
}

// _set_threshold
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_05(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->threshold(newValue);
}

// _get_ratio
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_06(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->ratio());
}

// _set_ratio
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_07(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->ratio(newValue);
}

// _get_output
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_08(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->output());
}

// _set_output
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_09(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->output(newValue);
}

// _get_thru
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_10(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeBool(((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->thru());
}

// _set_thru
static void _dispatch_Arts_Synth_STEREO_COMPRESSOR_11(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	bool newValue = request->readBool();
	((Arts::Synth_STEREO_COMPRESSOR_skel *)object)->thru(newValue);
}

void Arts::Synth_STEREO_COMPRESSOR_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000c5f6765745f61747461636b0000000006666c6f61740000"
        "00000200000000000000000000000c5f7365745f61747461636b0000000005766f"
        "696400000000020000000100000006666c6f617400000000096e657756616c7565"
        "0000000000000000000000000d5f6765745f72656c656173650000000006666c6f"
        "6174000000000200000000000000000000000d5f7365745f72656c656173650000"
        "000005766f696400000000020000000100000006666c6f617400000000096e6577"
        "56616c75650000000000000000000000000f5f6765745f7468726573686f6c6400"
        "00000006666c6f6174000000000200000000000000000000000f5f7365745f7468"
        "726573686f6c640000000005766f696400000000020000000100000006666c6f61"
        "7400000000096e657756616c75650000000000000000000000000b5f6765745f72"
        "6174696f0000000006666c6f6174000000000200000000000000000000000b5f73"
        "65745f726174696f0000000005766f696400000000020000000100000006666c6f"
        "617400000000096e657756616c75650000000000000000000000000c5f6765745f"
        "6f75747075740000000006666c6f6174000000000200000000000000000000000c"
        "5f7365745f6f75747075740000000005766f696400000000020000000100000006"
        "666c6f617400000000096e657756616c75650000000000000000000000000a5f67"
        "65745f746872750000000008626f6f6c65616e0000000002000000000000000000"
        "00000a5f7365745f746872750000000005766f6964000000000200000001000000"
        "08626f6f6c65616e00000000096e657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_07,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_08,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_09,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_10,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_COMPRESSOR_11,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Arts::Synth_STEREO_COMPRESSOR_skel::Synth_STEREO_COMPRESSOR_skel()
{
}

Arts::Object_base* Arts::Synth_STEREO_COMPRESSOR::_Creator() {
	return Arts::Synth_STEREO_COMPRESSOR_base::_create();
}

unsigned long Arts::Synth_STEREO_COMPRESSOR_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_STEREO_COMPRESSOR");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

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

Arts::StereoCompressorGuiFactory_stub::StereoCompressorGuiFactory_stub()
{
	// constructor for subclasses (don't use directly)
}

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

std::string Arts::StereoCompressorGuiFactory_skel::_interfaceName()
{
	return "Arts::StereoCompressorGuiFactory";
}

bool Arts::StereoCompressorGuiFactory_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::StereoCompressorGuiFactory") return true;
	if (interfacename == "Arts::GuiFactory") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::StereoCompressorGuiFactory_skel::_interfaceNameSkel()
{
	return "Arts::StereoCompressorGuiFactory";
}

void Arts::StereoCompressorGuiFactory_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::GuiFactory_skel::_buildMethodTable();
}

Arts::StereoCompressorGuiFactory_skel::StereoCompressorGuiFactory_skel()
{
}

Arts::Object_base* Arts::StereoCompressorGuiFactory::_Creator() {
	return Arts::StereoCompressorGuiFactory_base::_create();
}

unsigned long Arts::StereoCompressorGuiFactory_base::_IID = Arts::MCOPUtils::makeIID("Arts::StereoCompressorGuiFactory");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::Synth_STEREO_PITCH_SHIFT_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_STEREO_PITCH_SHIFT_base::_IID) return (Arts::Synth_STEREO_PITCH_SHIFT_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;
}

Arts::Synth_STEREO_PITCH_SHIFT_stub::Synth_STEREO_PITCH_SHIFT_stub()
{
	// constructor for subclasses (don't use directly)
}

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

float Arts::Synth_STEREO_PITCH_SHIFT_stub::speed()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f73706565640000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_STEREO_PITCH_SHIFT_stub::speed(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f73706565640000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_STEREO_PITCH_SHIFT_stub::frequency()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f6672657175656e63790000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_STEREO_PITCH_SHIFT_stub::frequency(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f6672657175656e63790000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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 Arts::Synth_STEREO_PITCH_SHIFT_skel::_interfaceName()
{
	return "Arts::Synth_STEREO_PITCH_SHIFT";
}

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

std::string Arts::Synth_STEREO_PITCH_SHIFT_skel::_interfaceNameSkel()
{
	return "Arts::Synth_STEREO_PITCH_SHIFT";
}

// _get_speed
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STEREO_PITCH_SHIFT_skel *)object)->speed());
}

// _set_speed
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STEREO_PITCH_SHIFT_skel *)object)->speed(newValue);
}

// _get_frequency
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STEREO_PITCH_SHIFT_skel *)object)->frequency());
}

// _set_frequency
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STEREO_PITCH_SHIFT_skel *)object)->frequency(newValue);
}

void Arts::Synth_STEREO_PITCH_SHIFT_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000b5f6765745f73706565640000000006666c6f6174000000"
        "000200000000000000000000000b5f7365745f73706565640000000005766f6964"
        "00000000020000000100000006666c6f617400000000096e657756616c75650000"
        "000000000000000000000f5f6765745f6672657175656e63790000000006666c6f"
        "6174000000000200000000000000000000000f5f7365745f6672657175656e6379"
        "0000000005766f696400000000020000000100000006666c6f617400000000096e"
        "657756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_03,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Arts::Synth_STEREO_PITCH_SHIFT_skel::Synth_STEREO_PITCH_SHIFT_skel()
{
}

Arts::Object_base* Arts::Synth_STEREO_PITCH_SHIFT::_Creator() {
	return Arts::Synth_STEREO_PITCH_SHIFT_base::_create();
}

unsigned long Arts::Synth_STEREO_PITCH_SHIFT_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_STEREO_PITCH_SHIFT");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::Synth_STEREO_PITCH_SHIFT_FFT_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_STEREO_PITCH_SHIFT_FFT_base::_IID) return (Arts::Synth_STEREO_PITCH_SHIFT_FFT_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;
}

Arts::Synth_STEREO_PITCH_SHIFT_FFT_stub::Synth_STEREO_PITCH_SHIFT_FFT_stub()
{
	// constructor for subclasses (don't use directly)
}

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

float Arts::Synth_STEREO_PITCH_SHIFT_FFT_stub::speed()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f73706565640000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_STEREO_PITCH_SHIFT_FFT_stub::speed(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f73706565640000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_STEREO_PITCH_SHIFT_FFT_stub::scaleFactor()
{
	long methodID = _lookupMethodFast("method:000000115f6765745f7363616c65466163746f720000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_STEREO_PITCH_SHIFT_FFT_stub::scaleFactor(float newValue)
{
	long methodID = _lookupMethodFast("method:000000115f7365745f7363616c65466163746f720000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

long Arts::Synth_STEREO_PITCH_SHIFT_FFT_stub::frameSize()
{
	long methodID = _lookupMethodFast("method:0000000f5f6765745f6672616d6553697a6500000000056c6f6e6700000000020000000000000000");
	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 Arts::Synth_STEREO_PITCH_SHIFT_FFT_stub::frameSize(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000f5f7365745f6672616d6553697a650000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	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 Arts::Synth_STEREO_PITCH_SHIFT_FFT_stub::oversample()
{
	long methodID = _lookupMethodFast("method:000000105f6765745f6f76657273616d706c6500000000056c6f6e6700000000020000000000000000");
	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 Arts::Synth_STEREO_PITCH_SHIFT_FFT_stub::oversample(long newValue)
{
	long methodID = _lookupMethodFast("method:000000105f7365745f6f76657273616d706c650000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	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 Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel::_interfaceName()
{
	return "Arts::Synth_STEREO_PITCH_SHIFT_FFT";
}

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

std::string Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel::_interfaceNameSkel()
{
	return "Arts::Synth_STEREO_PITCH_SHIFT_FFT";
}

// _get_speed
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel *)object)->speed());
}

// _set_speed
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel *)object)->speed(newValue);
}

// _get_scaleFactor
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel *)object)->scaleFactor());
}

// _set_scaleFactor
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel *)object)->scaleFactor(newValue);
}

// _get_frameSize
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_04(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel *)object)->frameSize());
}

// _set_frameSize
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_05(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel *)object)->frameSize(newValue);
}

// _get_oversample
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_06(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel *)object)->oversample());
}

// _set_oversample
static void _dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_07(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel *)object)->oversample(newValue);
}

void Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000b5f6765745f73706565640000000006666c6f6174000000"
        "000200000000000000000000000b5f7365745f73706565640000000005766f6964"
        "00000000020000000100000006666c6f617400000000096e657756616c75650000"
        "00000000000000000000115f6765745f7363616c65466163746f72000000000666"
        "6c6f617400000000020000000000000000000000115f7365745f7363616c654661"
        "63746f720000000005766f696400000000020000000100000006666c6f61740000"
        "0000096e657756616c75650000000000000000000000000f5f6765745f6672616d"
        "6553697a6500000000056c6f6e67000000000200000000000000000000000f5f73"
        "65745f6672616d6553697a650000000005766f6964000000000200000001000000"
        "056c6f6e6700000000096e657756616c7565000000000000000000000000105f67"
        "65745f6f76657273616d706c6500000000056c6f6e670000000002000000000000"
        "0000000000105f7365745f6f76657273616d706c650000000005766f6964000000"
        "000200000001000000056c6f6e6700000000096e657756616c7565000000000000"
        "000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_PITCH_SHIFT_FFT_07,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Arts::Synth_STEREO_PITCH_SHIFT_FFT_skel::Synth_STEREO_PITCH_SHIFT_FFT_skel()
{
}

Arts::Object_base* Arts::Synth_STEREO_PITCH_SHIFT_FFT::_Creator() {
	return Arts::Synth_STEREO_PITCH_SHIFT_FFT_base::_create();
}

unsigned long Arts::Synth_STEREO_PITCH_SHIFT_FFT_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_STEREO_PITCH_SHIFT_FFT");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::Synth_STEREO_FIR_EQUALIZER_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_STEREO_FIR_EQUALIZER_base::_IID) return (Arts::Synth_STEREO_FIR_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;
}

Arts::Synth_STEREO_FIR_EQUALIZER_stub::Synth_STEREO_FIR_EQUALIZER_stub()
{
	// constructor for subclasses (don't use directly)
}

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

std::vector<Arts::GraphPoint> * Arts::Synth_STEREO_FIR_EQUALIZER_stub::frequencies()
{
	long methodID = _lookupMethodFast("method:000000115f6765745f6672657175656e6369657300000000122a417274733a3a4772617068506f696e7400000000020000000000000000");
	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<Arts::GraphPoint> *_returnCode = new std::vector<Arts::GraphPoint>;
	if(!result) return _returnCode; // error occurred
	Arts::readTypeSeq(*result,*_returnCode);
	delete result;
	return _returnCode;
}

void Arts::Synth_STEREO_FIR_EQUALIZER_stub::frequencies(const std::vector<Arts::GraphPoint>& newValue)
{
	long methodID = _lookupMethodFast("method:000000115f7365745f6672657175656e636965730000000005766f6964000000000200000001000000122a417274733a3a4772617068506f696e7400000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	Arts::writeTypeSeq(*request,newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

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

long Arts::Synth_STEREO_FIR_EQUALIZER_stub::taps()
{
	long methodID = _lookupMethodFast("method:0000000a5f6765745f7461707300000000056c6f6e6700000000020000000000000000");
	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 Arts::Synth_STEREO_FIR_EQUALIZER_stub::taps(long newValue)
{
	long methodID = _lookupMethodFast("method:0000000a5f7365745f746170730000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
	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 Arts::Synth_STEREO_FIR_EQUALIZER_skel::_interfaceName()
{
	return "Arts::Synth_STEREO_FIR_EQUALIZER";
}

bool Arts::Synth_STEREO_FIR_EQUALIZER_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::Synth_STEREO_FIR_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 Arts::Synth_STEREO_FIR_EQUALIZER_skel::_interfaceNameSkel()
{
	return "Arts::Synth_STEREO_FIR_EQUALIZER";
}

// _get_frequencies
static void _dispatch_Arts_Synth_STEREO_FIR_EQUALIZER_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	std::vector<Arts::GraphPoint> *_returnCode = ((Arts::Synth_STEREO_FIR_EQUALIZER_skel *)object)->frequencies();
	Arts::writeTypeSeq(*result,*_returnCode);
	delete _returnCode;
}

// _set_frequencies
static void _dispatch_Arts_Synth_STEREO_FIR_EQUALIZER_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::vector<Arts::GraphPoint> newValue;
	Arts::readTypeSeq(*request,newValue);
	((Arts::Synth_STEREO_FIR_EQUALIZER_skel *)object)->frequencies(newValue);
}

// _get_taps
static void _dispatch_Arts_Synth_STEREO_FIR_EQUALIZER_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeLong(((Arts::Synth_STEREO_FIR_EQUALIZER_skel *)object)->taps());
}

// _set_taps
static void _dispatch_Arts_Synth_STEREO_FIR_EQUALIZER_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	long newValue = request->readLong();
	((Arts::Synth_STEREO_FIR_EQUALIZER_skel *)object)->taps(newValue);
}

void Arts::Synth_STEREO_FIR_EQUALIZER_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:000000115f6765745f6672657175656e6369657300000000122a41"
        "7274733a3a4772617068506f696e7400000000020000000000000000000000115f"
        "7365745f6672657175656e636965730000000005766f6964000000000200000001"
        "000000122a417274733a3a4772617068506f696e7400000000096e657756616c75"
        "650000000000000000000000000a5f6765745f7461707300000000056c6f6e6700"
        "0000000200000000000000000000000a5f7365745f746170730000000005766f69"
        "64000000000200000001000000056c6f6e6700000000096e657756616c75650000"
        "00000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_STEREO_FIR_EQUALIZER_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_FIR_EQUALIZER_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_FIR_EQUALIZER_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_STEREO_FIR_EQUALIZER_03,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Arts::Synth_STEREO_FIR_EQUALIZER_skel::Synth_STEREO_FIR_EQUALIZER_skel()
{
}

Arts::Object_base* Arts::Synth_STEREO_FIR_EQUALIZER::_Creator() {
	return Arts::Synth_STEREO_FIR_EQUALIZER_base::_create();
}

unsigned long Arts::Synth_STEREO_FIR_EQUALIZER_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_STEREO_FIR_EQUALIZER");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

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

Arts::StereoFirEqualizerGuiFactory_stub::StereoFirEqualizerGuiFactory_stub()
{
	// constructor for subclasses (don't use directly)
}

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

std::string Arts::StereoFirEqualizerGuiFactory_skel::_interfaceName()
{
	return "Arts::StereoFirEqualizerGuiFactory";
}

bool Arts::StereoFirEqualizerGuiFactory_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::StereoFirEqualizerGuiFactory") return true;
	if (interfacename == "Arts::GuiFactory") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::StereoFirEqualizerGuiFactory_skel::_interfaceNameSkel()
{
	return "Arts::StereoFirEqualizerGuiFactory";
}

void Arts::StereoFirEqualizerGuiFactory_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::GuiFactory_skel::_buildMethodTable();
}

Arts::StereoFirEqualizerGuiFactory_skel::StereoFirEqualizerGuiFactory_skel()
{
}

Arts::Object_base* Arts::StereoFirEqualizerGuiFactory::_Creator() {
	return Arts::StereoFirEqualizerGuiFactory_base::_create();
}

unsigned long Arts::StereoFirEqualizerGuiFactory_base::_IID = Arts::MCOPUtils::makeIID("Arts::StereoFirEqualizerGuiFactory");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::Synth_FREEVERB_base::_cast(unsigned long iid)
{
	if(iid == Arts::Synth_FREEVERB_base::_IID) return (Arts::Synth_FREEVERB_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;
}

Arts::Synth_FREEVERB_stub::Synth_FREEVERB_stub()
{
	// constructor for subclasses (don't use directly)
}

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

float Arts::Synth_FREEVERB_stub::roomsize()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f726f6f6d73697a650000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_FREEVERB_stub::roomsize(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f726f6f6d73697a650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_FREEVERB_stub::damp()
{
	long methodID = _lookupMethodFast("method:0000000a5f6765745f64616d700000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_FREEVERB_stub::damp(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000a5f7365745f64616d700000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_FREEVERB_stub::wet()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f7765740000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_FREEVERB_stub::wet(float newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f7765740000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_FREEVERB_stub::dry()
{
	long methodID = _lookupMethodFast("method:000000095f6765745f6472790000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_FREEVERB_stub::dry(float newValue)
{
	long methodID = _lookupMethodFast("method:000000095f7365745f6472790000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_FREEVERB_stub::width()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f77696474680000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_FREEVERB_stub::width(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f77696474680000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::Synth_FREEVERB_stub::mode()
{
	long methodID = _lookupMethodFast("method:0000000a5f6765745f6d6f64650000000006666c6f617400000000020000000000000000");
	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 Arts::Synth_FREEVERB_stub::mode(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000a5f7365745f6d6f64650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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 Arts::Synth_FREEVERB_skel::_interfaceName()
{
	return "Arts::Synth_FREEVERB";
}

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

std::string Arts::Synth_FREEVERB_skel::_interfaceNameSkel()
{
	return "Arts::Synth_FREEVERB";
}

// _get_roomsize
static void _dispatch_Arts_Synth_FREEVERB_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_FREEVERB_skel *)object)->roomsize());
}

// _set_roomsize
static void _dispatch_Arts_Synth_FREEVERB_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_FREEVERB_skel *)object)->roomsize(newValue);
}

// _get_damp
static void _dispatch_Arts_Synth_FREEVERB_02(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_FREEVERB_skel *)object)->damp());
}

// _set_damp
static void _dispatch_Arts_Synth_FREEVERB_03(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_FREEVERB_skel *)object)->damp(newValue);
}

// _get_wet
static void _dispatch_Arts_Synth_FREEVERB_04(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_FREEVERB_skel *)object)->wet());
}

// _set_wet
static void _dispatch_Arts_Synth_FREEVERB_05(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_FREEVERB_skel *)object)->wet(newValue);
}

// _get_dry
static void _dispatch_Arts_Synth_FREEVERB_06(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_FREEVERB_skel *)object)->dry());
}

// _set_dry
static void _dispatch_Arts_Synth_FREEVERB_07(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_FREEVERB_skel *)object)->dry(newValue);
}

// _get_width
static void _dispatch_Arts_Synth_FREEVERB_08(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_FREEVERB_skel *)object)->width());
}

// _set_width
static void _dispatch_Arts_Synth_FREEVERB_09(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_FREEVERB_skel *)object)->width(newValue);
}

// _get_mode
static void _dispatch_Arts_Synth_FREEVERB_10(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::Synth_FREEVERB_skel *)object)->mode());
}

// _set_mode
static void _dispatch_Arts_Synth_FREEVERB_11(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::Synth_FREEVERB_skel *)object)->mode(newValue);
}

void Arts::Synth_FREEVERB_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000e5f6765745f726f6f6d73697a650000000006666c6f6174"
        "000000000200000000000000000000000e5f7365745f726f6f6d73697a65000000"
        "0005766f696400000000020000000100000006666c6f617400000000096e657756"
        "616c75650000000000000000000000000a5f6765745f64616d700000000006666c"
        "6f6174000000000200000000000000000000000a5f7365745f64616d7000000000"
        "05766f696400000000020000000100000006666c6f617400000000096e65775661"
        "6c7565000000000000000000000000095f6765745f7765740000000006666c6f61"
        "7400000000020000000000000000000000095f7365745f7765740000000005766f"
        "696400000000020000000100000006666c6f617400000000096e657756616c7565"
        "000000000000000000000000095f6765745f6472790000000006666c6f61740000"
        "0000020000000000000000000000095f7365745f6472790000000005766f696400"
        "000000020000000100000006666c6f617400000000096e657756616c7565000000"
        "0000000000000000000b5f6765745f77696474680000000006666c6f6174000000"
        "000200000000000000000000000b5f7365745f77696474680000000005766f6964"
        "00000000020000000100000006666c6f617400000000096e657756616c75650000"
        "000000000000000000000a5f6765745f6d6f64650000000006666c6f6174000000"
        "000200000000000000000000000a5f7365745f6d6f64650000000005766f696400"
        "000000020000000100000006666c6f617400000000096e657756616c7565000000"
        "000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Synth_FREEVERB_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_07,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_08,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_09,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_10,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Synth_FREEVERB_11,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Arts::Synth_FREEVERB_skel::Synth_FREEVERB_skel()
{
}

Arts::Object_base* Arts::Synth_FREEVERB::_Creator() {
	return Arts::Synth_FREEVERB_base::_create();
}

unsigned long Arts::Synth_FREEVERB_base::_IID = Arts::MCOPUtils::makeIID("Arts::Synth_FREEVERB");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

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

Arts::FreeverbGuiFactory_stub::FreeverbGuiFactory_stub()
{
	// constructor for subclasses (don't use directly)
}

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

std::string Arts::FreeverbGuiFactory_skel::_interfaceName()
{
	return "Arts::FreeverbGuiFactory";
}

bool Arts::FreeverbGuiFactory_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::FreeverbGuiFactory") return true;
	if (interfacename == "Arts::GuiFactory") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::FreeverbGuiFactory_skel::_interfaceNameSkel()
{
	return "Arts::FreeverbGuiFactory";
}

void Arts::FreeverbGuiFactory_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::GuiFactory_skel::_buildMethodTable();
}

Arts::FreeverbGuiFactory_skel::FreeverbGuiFactory_skel()
{
}

Arts::Object_base* Arts::FreeverbGuiFactory::_Creator() {
	return Arts::FreeverbGuiFactory_base::_create();
}

unsigned long Arts::FreeverbGuiFactory_base::_IID = Arts::MCOPUtils::makeIID("Arts::FreeverbGuiFactory");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::Effect_WAVECAPTURE_base::_cast(unsigned long iid)
{
	if(iid == Arts::Effect_WAVECAPTURE_base::_IID) return (Arts::Effect_WAVECAPTURE_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;
}

Arts::Effect_WAVECAPTURE_stub::Effect_WAVECAPTURE_stub()
{
	// constructor for subclasses (don't use directly)
}

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

std::string Arts::Effect_WAVECAPTURE_stub::filename()
{
	long methodID = _lookupMethodFast("method:0000000e5f6765745f66696c656e616d650000000007737472696e6700000000020000000000000000");
	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""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::Effect_WAVECAPTURE_stub::filename(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:0000000e5f7365745f66696c656e616d650000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

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

std::string Arts::Effect_WAVECAPTURE_skel::_interfaceName()
{
	return "Arts::Effect_WAVECAPTURE";
}

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

std::string Arts::Effect_WAVECAPTURE_skel::_interfaceNameSkel()
{
	return "Arts::Effect_WAVECAPTURE";
}

// _get_filename
static void _dispatch_Arts_Effect_WAVECAPTURE_00(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::Effect_WAVECAPTURE_skel *)object)->filename());
}

// _set_filename
static void _dispatch_Arts_Effect_WAVECAPTURE_01(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::Effect_WAVECAPTURE_skel *)object)->filename(newValue);
}

void Arts::Effect_WAVECAPTURE_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000e5f6765745f66696c656e616d650000000007737472696e"
        "67000000000200000000000000000000000e5f7365745f66696c656e616d650000"
        "000005766f696400000000020000000100000007737472696e6700000000096e65"
        "7756616c7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_Effect_WAVECAPTURE_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_Effect_WAVECAPTURE_01,this,Arts::MethodDef(m));
	Arts::StereoEffect_skel::_buildMethodTable();
}

Arts::Effect_WAVECAPTURE_skel::Effect_WAVECAPTURE_skel()
{
}

Arts::Object_base* Arts::Effect_WAVECAPTURE::_Creator() {
	return Arts::Effect_WAVECAPTURE_base::_create();
}

unsigned long Arts::Effect_WAVECAPTURE_base::_IID = Arts::MCOPUtils::makeIID("Arts::Effect_WAVECAPTURE");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

void *Arts::StereoVolumeControlGui_base::_cast(unsigned long iid)
{
	if(iid == Arts::StereoVolumeControlGui_base::_IID) return (Arts::StereoVolumeControlGui_base *)this;
	if(iid == Arts::LayoutBox_base::_IID) return (Arts::LayoutBox_base *)this;
	if(iid == Arts::Frame_base::_IID) return (Arts::Frame_base *)this;
	if(iid == Arts::Widget_base::_IID) return (Arts::Widget_base *)this;
	if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
	return 0;
}

Arts::StereoVolumeControlGui_stub::StereoVolumeControlGui_stub()
{
	// constructor for subclasses (don't use directly)
}

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

void Arts::StereoVolumeControlGui_stub::constructor(Arts::StereoVolumeControl svc)
{
	long methodID = _lookupMethodFast("method:0000000c636f6e7374727563746f720000000005766f69640000000002000000010000001a417274733a3a53746572656f566f6c756d65436f6e74726f6c0000000004737663000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	Arts::writeObject(*request,svc._base());
	request->patchLength();
	_connection->qSendBuffer(request);

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

std::string Arts::StereoVolumeControlGui_stub::title()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f7469746c650000000007737472696e6700000000020000000000000000");
	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""; // error occurred
	std::string returnCode;
	result->readString(returnCode);
	delete result;
	return returnCode;
}

void Arts::StereoVolumeControlGui_stub::title(const std::string& newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f7469746c650000000005766f696400000000020000000100000007737472696e6700000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeString(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

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

float Arts::StereoVolumeControlGui_stub::dbmin()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f64626d696e0000000006666c6f617400000000020000000000000000");
	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 Arts::StereoVolumeControlGui_stub::dbmin(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f64626d696e0000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

float Arts::StereoVolumeControlGui_stub::dbmax()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f64626d61780000000006666c6f617400000000020000000000000000");
	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 Arts::StereoVolumeControlGui_stub::dbmax(float newValue)
{
	long methodID = _lookupMethodFast("method:0000000b5f7365745f64626d61780000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
	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;
}

Arts::LevelMeter Arts::StereoVolumeControlGui_stub::left()
{
	long methodID = _lookupMethodFast("method:0000000a5f6765745f6c6566740000000011417274733a3a4c6576656c4d6574657200000000020000000000000000");
	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 Arts::LevelMeter::null();
	Arts::LevelMeter_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::LevelMeter::_from_base(returnCode);
}

Arts::LevelMeter Arts::StereoVolumeControlGui_stub::right()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f72696768740000000011417274733a3a4c6576656c4d6574657200000000020000000000000000");
	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 Arts::LevelMeter::null();
	Arts::LevelMeter_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::LevelMeter::_from_base(returnCode);
}

Arts::VolumeFader Arts::StereoVolumeControlGui_stub::fader()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f66616465720000000012417274733a3a566f6c756d65466164657200000000020000000000000000");
	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 Arts::VolumeFader::null();
	Arts::VolumeFader_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::VolumeFader::_from_base(returnCode);
}

Arts::Tickmarks Arts::StereoVolumeControlGui_stub::levelmetertickmarks()
{
	long methodID = _lookupMethodFast("method:000000195f6765745f6c6576656c6d657465727469636b6d61726b730000000010417274733a3a5469636b6d61726b7300000000020000000000000000");
	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 Arts::Tickmarks::null();
	Arts::Tickmarks_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::Tickmarks::_from_base(returnCode);
}

Arts::Tickmarks Arts::StereoVolumeControlGui_stub::volumefadertickmarks()
{
	long methodID = _lookupMethodFast("method:0000001a5f6765745f766f6c756d6566616465727469636b6d61726b730000000010417274733a3a5469636b6d61726b7300000000020000000000000000");
	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 Arts::Tickmarks::null();
	Arts::Tickmarks_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::Tickmarks::_from_base(returnCode);
}

Arts::Label Arts::StereoVolumeControlGui_stub::label()
{
	long methodID = _lookupMethodFast("method:0000000b5f6765745f6c6162656c000000000c417274733a3a4c6162656c00000000020000000000000000");
	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 Arts::Label::null();
	Arts::Label_base* returnCode;
	Arts::readObject(*result,returnCode);
	delete result;
	return Arts::Label::_from_base(returnCode);
}

bool Arts::StereoVolumeControlGui_stub::couple()
{
	long methodID = _lookupMethodFast("method:0000000c5f6765745f636f75706c650000000008626f6f6c65616e00000000020000000000000000");
	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 false; // error occurred
	bool returnCode = result->readBool();
	delete result;
	return returnCode;
}

void Arts::StereoVolumeControlGui_stub::couple(bool newValue)
{
	long methodID = _lookupMethodFast("method:0000000c5f7365745f636f75706c650000000005766f696400000000020000000100000008626f6f6c65616e00000000096e657756616c7565000000000000000000");
	long requestID;
	Arts::Buffer *request, *result;
	request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
	request->writeBool(newValue);
	request->patchLength();
	_connection->qSendBuffer(request);

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

std::string Arts::StereoVolumeControlGui_skel::_interfaceName()
{
	return "Arts::StereoVolumeControlGui";
}

bool Arts::StereoVolumeControlGui_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::StereoVolumeControlGui") return true;
	if (interfacename == "Arts::LayoutBox") return true;
	if (interfacename == "Arts::Frame") return true;
	if (interfacename == "Arts::Widget") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::StereoVolumeControlGui_skel::_interfaceNameSkel()
{
	return "Arts::StereoVolumeControlGui";
}

// constructor
static void _dispatch_Arts_StereoVolumeControlGui_00(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	Arts::StereoVolumeControl_base* _temp_svc;
	Arts::readObject(*request,_temp_svc);
	Arts::StereoVolumeControl svc = Arts::StereoVolumeControl::_from_base(_temp_svc);
	((Arts::StereoVolumeControlGui_skel *)object)->constructor(svc);
}

// _get_title
static void _dispatch_Arts_StereoVolumeControlGui_01(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeString(((Arts::StereoVolumeControlGui_skel *)object)->title());
}

// _set_title
static void _dispatch_Arts_StereoVolumeControlGui_02(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	std::string newValue;
	request->readString(newValue);
	((Arts::StereoVolumeControlGui_skel *)object)->title(newValue);
}

// _get_dbmin
static void _dispatch_Arts_StereoVolumeControlGui_03(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::StereoVolumeControlGui_skel *)object)->dbmin());
}

// _set_dbmin
static void _dispatch_Arts_StereoVolumeControlGui_04(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::StereoVolumeControlGui_skel *)object)->dbmin(newValue);
}

// _get_dbmax
static void _dispatch_Arts_StereoVolumeControlGui_05(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeFloat(((Arts::StereoVolumeControlGui_skel *)object)->dbmax());
}

// _set_dbmax
static void _dispatch_Arts_StereoVolumeControlGui_06(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	float newValue = request->readFloat();
	((Arts::StereoVolumeControlGui_skel *)object)->dbmax(newValue);
}

// _get_left
static void _dispatch_Arts_StereoVolumeControlGui_07(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::LevelMeter returnCode = ((Arts::StereoVolumeControlGui_skel *)object)->left();
	Arts::writeObject(*result,returnCode._base());
}

// _get_right
static void _dispatch_Arts_StereoVolumeControlGui_08(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::LevelMeter returnCode = ((Arts::StereoVolumeControlGui_skel *)object)->right();
	Arts::writeObject(*result,returnCode._base());
}

// _get_fader
static void _dispatch_Arts_StereoVolumeControlGui_09(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::VolumeFader returnCode = ((Arts::StereoVolumeControlGui_skel *)object)->fader();
	Arts::writeObject(*result,returnCode._base());
}

// _get_levelmetertickmarks
static void _dispatch_Arts_StereoVolumeControlGui_10(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::Tickmarks returnCode = ((Arts::StereoVolumeControlGui_skel *)object)->levelmetertickmarks();
	Arts::writeObject(*result,returnCode._base());
}

// _get_volumefadertickmarks
static void _dispatch_Arts_StereoVolumeControlGui_11(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::Tickmarks returnCode = ((Arts::StereoVolumeControlGui_skel *)object)->volumefadertickmarks();
	Arts::writeObject(*result,returnCode._base());
}

// _get_label
static void _dispatch_Arts_StereoVolumeControlGui_12(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	Arts::Label returnCode = ((Arts::StereoVolumeControlGui_skel *)object)->label();
	Arts::writeObject(*result,returnCode._base());
}

// _get_couple
static void _dispatch_Arts_StereoVolumeControlGui_13(void *object, Arts::Buffer *, Arts::Buffer *result)
{
	result->writeBool(((Arts::StereoVolumeControlGui_skel *)object)->couple());
}

// _set_couple
static void _dispatch_Arts_StereoVolumeControlGui_14(void *object, Arts::Buffer *request, Arts::Buffer *)
{
	bool newValue = request->readBool();
	((Arts::StereoVolumeControlGui_skel *)object)->couple(newValue);
}

void Arts::StereoVolumeControlGui_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:0000000c636f6e7374727563746f720000000005766f6964000000"
        "0002000000010000001a417274733a3a53746572656f566f6c756d65436f6e7472"
        "6f6c00000000047376630000000000000000000000000b5f6765745f7469746c65"
        "0000000007737472696e67000000000200000000000000000000000b5f7365745f"
        "7469746c650000000005766f696400000000020000000100000007737472696e67"
        "00000000096e657756616c75650000000000000000000000000b5f6765745f6462"
        "6d696e0000000006666c6f6174000000000200000000000000000000000b5f7365"
        "745f64626d696e0000000005766f696400000000020000000100000006666c6f61"
        "7400000000096e657756616c75650000000000000000000000000b5f6765745f64"
        "626d61780000000006666c6f6174000000000200000000000000000000000b5f73"
        "65745f64626d61780000000005766f696400000000020000000100000006666c6f"
        "617400000000096e657756616c75650000000000000000000000000a5f6765745f"
        "6c6566740000000011417274733a3a4c6576656c4d657465720000000002000000"
        "00000000000000000b5f6765745f72696768740000000011417274733a3a4c6576"
        "656c4d65746572000000000200000000000000000000000b5f6765745f66616465"
        "720000000012417274733a3a566f6c756d65466164657200000000020000000000"
        "000000000000195f6765745f6c6576656c6d657465727469636b6d61726b730000"
        "000010417274733a3a5469636b6d61726b73000000000200000000000000000000"
        "001a5f6765745f766f6c756d6566616465727469636b6d61726b73000000001041"
        "7274733a3a5469636b6d61726b73000000000200000000000000000000000b5f67"
        "65745f6c6162656c000000000c417274733a3a4c6162656c000000000200000000"
        "000000000000000c5f6765745f636f75706c650000000008626f6f6c65616e0000"
        "00000200000000000000000000000c5f7365745f636f75706c650000000005766f"
        "696400000000020000000100000008626f6f6c65616e00000000096e657756616c"
        "7565000000000000000000",
		"MethodTable"
	);
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_00,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_01,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_02,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_03,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_04,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_05,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_06,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_07,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_08,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_09,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_10,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_11,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_12,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_13,this,Arts::MethodDef(m));
	_addMethod(_dispatch_Arts_StereoVolumeControlGui_14,this,Arts::MethodDef(m));
	Arts::LayoutBox_skel::_buildMethodTable();
}

Arts::StereoVolumeControlGui_skel::StereoVolumeControlGui_skel()
{
}

Arts::Object_base* Arts::StereoVolumeControlGui::_Creator() {
	return Arts::StereoVolumeControlGui_base::_create();
}

unsigned long Arts::StereoVolumeControlGui_base::_IID = Arts::MCOPUtils::makeIID("Arts::StereoVolumeControlGui");

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

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

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

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

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

	return _fromString(object._toString());
}

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

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

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

Arts::StereoVolumeControlGuiFactory_stub::StereoVolumeControlGuiFactory_stub()
{
	// constructor for subclasses (don't use directly)
}

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

std::string Arts::StereoVolumeControlGuiFactory_skel::_interfaceName()
{
	return "Arts::StereoVolumeControlGuiFactory";
}

bool Arts::StereoVolumeControlGuiFactory_skel::_isCompatibleWith(const std::string& interfacename)
{
	if (interfacename == "Arts::StereoVolumeControlGuiFactory") return true;
	if (interfacename == "Arts::GuiFactory") return true;
	if (interfacename == "Arts::Object") return true;
	return false;
}

std::string Arts::StereoVolumeControlGuiFactory_skel::_interfaceNameSkel()
{
	return "Arts::StereoVolumeControlGuiFactory";
}

void Arts::StereoVolumeControlGuiFactory_skel::_buildMethodTable()
{
	Arts::Buffer m;
	m.fromString(
        "MethodTable:",
		"MethodTable"
	);
	Arts::GuiFactory_skel::_buildMethodTable();
}

Arts::StereoVolumeControlGuiFactory_skel::StereoVolumeControlGuiFactory_skel()
{
}

Arts::Object_base* Arts::StereoVolumeControlGuiFactory::_Creator() {
	return Arts::StereoVolumeControlGuiFactory_base::_create();
}

unsigned long Arts::StereoVolumeControlGuiFactory_base::_IID = Arts::MCOPUtils::makeIID("Arts::StereoVolumeControlGuiFactory");

static Arts::IDLFileReg IDLFileReg_artsmoduleseffects("artsmoduleseffects",
    "IDLFile:000000010000000000000000000000001300000013417274733a3a53746572"
    "656f546f4d6f6e6f000000000100000012417274733a3a53796e74684d6f64756c6500"
    "00000000000000040000000470616e0000000006666c6f617400000000130000000000"
    "000007696e6c6566740000000006666c6f617400000000090000000000000008696e72"
    "696768740000000006666c6f6174000000000900000000000000086f75746d6f6e6f00"
    "00000006666c6f6174000000000a00000000000000000000000000000013417274733a"
    "3a4d6f6e6f546f53746572656f000000000100000012417274733a3a53796e74684d6f"
    "64756c650000000000000000040000000470616e0000000006666c6f61740000000013"
    "0000000000000007696e6d6f6e6f0000000006666c6f61740000000009000000000000"
    "00086f75746c6566740000000006666c6f6174000000000a00000000000000096f7574"
    "72696768740000000006666c6f6174000000000a000000000000000000000000000000"
    "14417274733a3a53746572656f42616c616e6365000000000100000013417274733a3a"
    "53746572656f4566666563740000000000000000010000000862616c616e6365000000"
    "0006666c6f617400000000130000000000000000000000000000001e417274733a3a53"
    "746572656f42616c616e6365477569466163746f727900000000010000001141727473"
    "3a3a477569466163746f727900000000000000000000000000000000000000001c4172"
    "74733a3a4669766542616e644d6f6e6f436f6d706c6578455100000000010000001341"
    "7274733a3a53746572656f4566666563740000000000000000110000000473326d0000"
    "000013417274733a3a53746572656f546f4d6f6e6f000000001200000000000000086c"
    "6f77667265710000000006666c6f6174000000001300000000000000056c6f77710000"
    "000006666c6f6174000000001300000000000000086c6f776761696e0000000006666c"
    "6f6174000000001300000000000000096d696431667265710000000006666c6f617400"
    "0000001300000000000000066d696431710000000006666c6f61740000000013000000"
    "00000000096d6964316761696e0000000006666c6f6174000000001300000000000000"
    "096d696432667265710000000006666c6f6174000000001300000000000000066d6964"
    "32710000000006666c6f6174000000001300000000000000096d6964326761696e0000"
    "000006666c6f6174000000001300000000000000096d69643366726571000000000666"
    "6c6f6174000000001300000000000000066d696433710000000006666c6f6174000000"
    "001300000000000000096d6964336761696e0000000006666c6f617400000000130000"
    "00000000000968696768667265710000000006666c6f61740000000013000000000000"
    "000668696768710000000006666c6f6174000000001300000000000000096869676867"
    "61696e0000000006666c6f6174000000001300000000000000046d3273000000001341"
    "7274733a3a4d6f6e6f546f53746572656f000000001200000000000000000000000000"
    "000026417274733a3a4669766542616e644d6f6e6f436f6d706c657845514775694661"
    "63746f7279000000000100000011417274733a3a477569466163746f72790000000000"
    "0000000000000000000000000000001a417274733a3a53796e74685f564f4943455f52"
    "454d4f56414c000000000100000013417274733a3a53746572656f4566666563740000"
    "0000000000000200000009706f736974696f6e0000000006666c6f6174000000001300"
    "0000000000000a6672657175656e63790000000006666c6f6174000000001300000000"
    "00000000000000000000001d417274733a3a566f69636552656d6f76616c4775694661"
    "63746f7279000000000100000011417274733a3a477569466163746f72790000000000"
    "0000000000000000000000000000001e417274733a3a53796e74685f53544552454f5f"
    "434f4d50524553534f52000000000100000013417274733a3a53746572656f45666665"
    "63740000000000000000060000000761747461636b0000000006666c6f617400000000"
    "13000000000000000872656c656173650000000006666c6f6174000000001300000000"
    "0000000a7468726573686f6c640000000006666c6f6174000000001300000000000000"
    "06726174696f0000000006666c6f6174000000001300000000000000076f7574707574"
    "0000000006666c6f617400000000130000000000000005746872750000000008626f6f"
    "6c65616e000000001300000000000000000000000000000021417274733a3a53746572"
    "656f436f6d70726573736f72477569466163746f727900000000010000001141727473"
    "3a3a477569466163746f727900000000000000000000000000000000000000001f4172"
    "74733a3a53796e74685f53544552454f5f50495443485f534849465400000000010000"
    "0013417274733a3a53746572656f456666656374000000000000000002000000067370"
    "6565640000000006666c6f61740000000013000000000000000a6672657175656e6379"
    "0000000006666c6f617400000000130000000000000000000000000000002341727473"
    "3a3a53796e74685f53544552454f5f50495443485f53484946545f4646540000000001"
    "00000013417274733a3a53746572656f45666665637400000000000000000400000006"
    "73706565640000000006666c6f61740000000013000000000000000c7363616c654661"
    "63746f720000000006666c6f61740000000013000000000000000a6672616d6553697a"
    "6500000000056c6f6e670000000013000000000000000b6f76657273616d706c650000"
    "0000056c6f6e67000000001300000000000000000000000000000021417274733a3a53"
    "796e74685f53544552454f5f4649525f455155414c495a455200000000010000001341"
    "7274733a3a53746572656f4566666563740000000000000000020000000c6672657175"
    "656e6369657300000000122a417274733a3a4772617068506f696e7400000000130000"
    "0000000000057461707300000000056c6f6e6700000000130000000000000000000000"
    "0000000023417274733a3a53746572656f466972457175616c697a6572477569466163"
    "746f7279000000000100000011417274733a3a477569466163746f7279000000000000"
    "000000000000000000000000000015417274733a3a53796e74685f4652454556455242"
    "000000000100000013417274733a3a53746572656f4566666563740000000000000000"
    "0600000009726f6f6d73697a650000000006666c6f6174000000001300000000000000"
    "0564616d700000000006666c6f61740000000013000000000000000477657400000000"
    "06666c6f6174000000001300000000000000046472790000000006666c6f6174000000"
    "0013000000000000000677696474680000000006666c6f617400000000130000000000"
    "0000056d6f64650000000006666c6f6174000000001300000000000000000000000000"
    "000019417274733a3a4672656576657262477569466163746f72790000000001000000"
    "11417274733a3a477569466163746f7279000000000000000000000000000000000000"
    "000019417274733a3a4566666563745f57415645434150545552450000000001000000"
    "13417274733a3a53746572656f4566666563740000000000000000010000000966696c"
    "656e616d650000000007737472696e6700000000130000000000000000000000000000"
    "001d417274733a3a53746572656f566f6c756d65436f6e74726f6c4775690000000001"
    "00000010417274733a3a4c61796f7574426f7800000000010000000c636f6e73747275"
    "63746f720000000005766f69640000000002000000010000001a417274733a3a537465"
    "72656f566f6c756d65436f6e74726f6c00000000047376630000000000000000000000"
    "000a000000067469746c650000000007737472696e6700000000130000000000000006"
    "64626d696e0000000006666c6f61740000000013000000000000000664626d61780000"
    "000006666c6f6174000000001300000000000000056c6566740000000011417274733a"
    "3a4c6576656c4d65746572000000001200000000000000067269676874000000001141"
    "7274733a3a4c6576656c4d657465720000000012000000000000000666616465720000"
    "000012417274733a3a566f6c756d654661646572000000001200000000000000146c65"
    "76656c6d657465727469636b6d61726b730000000010417274733a3a5469636b6d6172"
    "6b7300000000120000000000000015766f6c756d6566616465727469636b6d61726b73"
    "0000000010417274733a3a5469636b6d61726b73000000001200000000000000066c61"
    "62656c000000000c417274733a3a4c6162656c00000000120000000000000007636f75"
    "706c650000000008626f6f6c65616e0000000013000000000000000000000000000000"
    "24417274733a3a53746572656f566f6c756d65436f6e74726f6c477569466163746f72"
    "79000000000100000011417274733a3a477569466163746f7279000000000000000000"
    "000000000000000000000000"
);
