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

#ifndef ARTSMODULESEFFECTS_H
#define ARTSMODULESEFFECTS_H

#include "common.h"

#include "arts_export.h"

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

namespace Arts {
class StereoToMono;
class MonoToStereo;
class StereoBalance;
class StereoBalanceGuiFactory;
class FiveBandMonoComplexEQ;
class FiveBandMonoComplexEQGuiFactory;
class Synth_VOICE_REMOVAL;
class VoiceRemovalGuiFactory;
class Synth_STEREO_COMPRESSOR;
class StereoCompressorGuiFactory;
class Synth_STEREO_PITCH_SHIFT;
class Synth_STEREO_PITCH_SHIFT_FFT;
class Synth_STEREO_FIR_EQUALIZER;
class StereoFirEqualizerGuiFactory;
class Synth_FREEVERB;
class FreeverbGuiFactory;
class Effect_WAVECAPTURE;
class StereoVolumeControlGui;
class StereoVolumeControlGuiFactory;

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

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

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

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

	void *_cast(unsigned long iid);

	virtual float pan() = 0;
	virtual void pan(float newValue) = 0;
};

class ARTS_EXPORT StereoToMono_stub : virtual public StereoToMono_base, virtual public Arts::SynthModule_stub {
protected:
	StereoToMono_stub();

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

	float pan();
	void pan(float newValue);
};

class ARTS_EXPORT StereoToMono_skel : virtual public StereoToMono_base, virtual public Arts::SynthModule_skel {
protected:
	// variables for streams
	float *inleft;                            // incoming stream
	float *inright;                           // incoming stream
	float *outmono;                           // outgoing stream

protected:
	// emitters for change notifications
	inline void pan_changed(float newValue) {
		_emit_changed("pan_changed",newValue);
	}

public:
	StereoToMono_skel();

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

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

protected:
	inline StereoToMono(StereoToMono_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoToMono_base _base_class;

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

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

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

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

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

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

	void *_cast(unsigned long iid);

	virtual float pan() = 0;
	virtual void pan(float newValue) = 0;
};

class ARTS_EXPORT MonoToStereo_stub : virtual public MonoToStereo_base, virtual public Arts::SynthModule_stub {
protected:
	MonoToStereo_stub();

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

	float pan();
	void pan(float newValue);
};

class ARTS_EXPORT MonoToStereo_skel : virtual public MonoToStereo_base, virtual public Arts::SynthModule_skel {
protected:
	// variables for streams
	float *inmono;                            // incoming stream
	float *outleft;                           // outgoing stream
	float *outright;                          // outgoing stream

protected:
	// emitters for change notifications
	inline void pan_changed(float newValue) {
		_emit_changed("pan_changed",newValue);
	}

public:
	MonoToStereo_skel();

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

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

protected:
	inline MonoToStereo(MonoToStereo_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef MonoToStereo_base _base_class;

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

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

class ARTS_EXPORT StereoBalance_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual float balance() = 0;
	virtual void balance(float newValue) = 0;
};

class ARTS_EXPORT StereoBalance_stub : virtual public StereoBalance_base, virtual public Arts::StereoEffect_stub {
protected:
	StereoBalance_stub();

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

	float balance();
	void balance(float newValue);
};

class ARTS_EXPORT StereoBalance_skel : virtual public StereoBalance_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void balance_changed(float newValue) {
		_emit_changed("balance_changed",newValue);
	}

public:
	StereoBalance_skel();

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

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

protected:
	inline StereoBalance(StereoBalance_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoBalance_base _base_class;

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

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

class ARTS_EXPORT StereoBalanceGuiFactory_base : virtual public Arts::GuiFactory_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT StereoBalanceGuiFactory_stub : virtual public StereoBalanceGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	StereoBalanceGuiFactory_stub();

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

};

class ARTS_EXPORT StereoBalanceGuiFactory_skel : virtual public StereoBalanceGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	StereoBalanceGuiFactory_skel();

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

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

protected:
	inline StereoBalanceGuiFactory(StereoBalanceGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoBalanceGuiFactory_base _base_class;

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

	inline Arts::Widget createGui(Arts::Object runningObject);
};

class ARTS_EXPORT FiveBandMonoComplexEQ_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual Arts::StereoToMono s2m() = 0;
	virtual float lowfreq() = 0;
	virtual void lowfreq(float newValue) = 0;
	virtual float lowq() = 0;
	virtual void lowq(float newValue) = 0;
	virtual float lowgain() = 0;
	virtual void lowgain(float newValue) = 0;
	virtual float mid1freq() = 0;
	virtual void mid1freq(float newValue) = 0;
	virtual float mid1q() = 0;
	virtual void mid1q(float newValue) = 0;
	virtual float mid1gain() = 0;
	virtual void mid1gain(float newValue) = 0;
	virtual float mid2freq() = 0;
	virtual void mid2freq(float newValue) = 0;
	virtual float mid2q() = 0;
	virtual void mid2q(float newValue) = 0;
	virtual float mid2gain() = 0;
	virtual void mid2gain(float newValue) = 0;
	virtual float mid3freq() = 0;
	virtual void mid3freq(float newValue) = 0;
	virtual float mid3q() = 0;
	virtual void mid3q(float newValue) = 0;
	virtual float mid3gain() = 0;
	virtual void mid3gain(float newValue) = 0;
	virtual float highfreq() = 0;
	virtual void highfreq(float newValue) = 0;
	virtual float highq() = 0;
	virtual void highq(float newValue) = 0;
	virtual float highgain() = 0;
	virtual void highgain(float newValue) = 0;
	virtual Arts::MonoToStereo m2s() = 0;
};

class ARTS_EXPORT FiveBandMonoComplexEQ_stub : virtual public FiveBandMonoComplexEQ_base, virtual public Arts::StereoEffect_stub {
protected:
	FiveBandMonoComplexEQ_stub();

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

	Arts::StereoToMono s2m();
	float lowfreq();
	void lowfreq(float newValue);
	float lowq();
	void lowq(float newValue);
	float lowgain();
	void lowgain(float newValue);
	float mid1freq();
	void mid1freq(float newValue);
	float mid1q();
	void mid1q(float newValue);
	float mid1gain();
	void mid1gain(float newValue);
	float mid2freq();
	void mid2freq(float newValue);
	float mid2q();
	void mid2q(float newValue);
	float mid2gain();
	void mid2gain(float newValue);
	float mid3freq();
	void mid3freq(float newValue);
	float mid3q();
	void mid3q(float newValue);
	float mid3gain();
	void mid3gain(float newValue);
	float highfreq();
	void highfreq(float newValue);
	float highq();
	void highq(float newValue);
	float highgain();
	void highgain(float newValue);
	Arts::MonoToStereo m2s();
};

class ARTS_EXPORT FiveBandMonoComplexEQ_skel : virtual public FiveBandMonoComplexEQ_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void lowfreq_changed(float newValue) {
		_emit_changed("lowfreq_changed",newValue);
	}
	inline void lowq_changed(float newValue) {
		_emit_changed("lowq_changed",newValue);
	}
	inline void lowgain_changed(float newValue) {
		_emit_changed("lowgain_changed",newValue);
	}
	inline void mid1freq_changed(float newValue) {
		_emit_changed("mid1freq_changed",newValue);
	}
	inline void mid1q_changed(float newValue) {
		_emit_changed("mid1q_changed",newValue);
	}
	inline void mid1gain_changed(float newValue) {
		_emit_changed("mid1gain_changed",newValue);
	}
	inline void mid2freq_changed(float newValue) {
		_emit_changed("mid2freq_changed",newValue);
	}
	inline void mid2q_changed(float newValue) {
		_emit_changed("mid2q_changed",newValue);
	}
	inline void mid2gain_changed(float newValue) {
		_emit_changed("mid2gain_changed",newValue);
	}
	inline void mid3freq_changed(float newValue) {
		_emit_changed("mid3freq_changed",newValue);
	}
	inline void mid3q_changed(float newValue) {
		_emit_changed("mid3q_changed",newValue);
	}
	inline void mid3gain_changed(float newValue) {
		_emit_changed("mid3gain_changed",newValue);
	}
	inline void highfreq_changed(float newValue) {
		_emit_changed("highfreq_changed",newValue);
	}
	inline void highq_changed(float newValue) {
		_emit_changed("highq_changed",newValue);
	}
	inline void highgain_changed(float newValue) {
		_emit_changed("highgain_changed",newValue);
	}

public:
	FiveBandMonoComplexEQ_skel();

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

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

protected:
	inline FiveBandMonoComplexEQ(FiveBandMonoComplexEQ_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef FiveBandMonoComplexEQ_base _base_class;

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

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline Arts::StereoToMono s2m();
	inline float lowfreq();
	inline void lowfreq(float _newValue);
	inline float lowq();
	inline void lowq(float _newValue);
	inline float lowgain();
	inline void lowgain(float _newValue);
	inline float mid1freq();
	inline void mid1freq(float _newValue);
	inline float mid1q();
	inline void mid1q(float _newValue);
	inline float mid1gain();
	inline void mid1gain(float _newValue);
	inline float mid2freq();
	inline void mid2freq(float _newValue);
	inline float mid2q();
	inline void mid2q(float _newValue);
	inline float mid2gain();
	inline void mid2gain(float _newValue);
	inline float mid3freq();
	inline void mid3freq(float _newValue);
	inline float mid3q();
	inline void mid3q(float _newValue);
	inline float mid3gain();
	inline void mid3gain(float _newValue);
	inline float highfreq();
	inline void highfreq(float _newValue);
	inline float highq();
	inline void highq(float _newValue);
	inline float highgain();
	inline void highgain(float _newValue);
	inline Arts::MonoToStereo m2s();
};

class ARTS_EXPORT FiveBandMonoComplexEQGuiFactory_base : virtual public Arts::GuiFactory_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT FiveBandMonoComplexEQGuiFactory_stub : virtual public FiveBandMonoComplexEQGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	FiveBandMonoComplexEQGuiFactory_stub();

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

};

class ARTS_EXPORT FiveBandMonoComplexEQGuiFactory_skel : virtual public FiveBandMonoComplexEQGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	FiveBandMonoComplexEQGuiFactory_skel();

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

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

protected:
	inline FiveBandMonoComplexEQGuiFactory(FiveBandMonoComplexEQGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef FiveBandMonoComplexEQGuiFactory_base _base_class;

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

	inline Arts::Widget createGui(Arts::Object runningObject);
};

class ARTS_EXPORT Synth_VOICE_REMOVAL_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual float position() = 0;
	virtual void position(float newValue) = 0;
	virtual float frequency() = 0;
	virtual void frequency(float newValue) = 0;
};

class ARTS_EXPORT Synth_VOICE_REMOVAL_stub : virtual public Synth_VOICE_REMOVAL_base, virtual public Arts::StereoEffect_stub {
protected:
	Synth_VOICE_REMOVAL_stub();

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

	float position();
	void position(float newValue);
	float frequency();
	void frequency(float newValue);
};

class ARTS_EXPORT Synth_VOICE_REMOVAL_skel : virtual public Synth_VOICE_REMOVAL_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void position_changed(float newValue) {
		_emit_changed("position_changed",newValue);
	}
	inline void frequency_changed(float newValue) {
		_emit_changed("frequency_changed",newValue);
	}

public:
	Synth_VOICE_REMOVAL_skel();

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

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

protected:
	inline Synth_VOICE_REMOVAL(Synth_VOICE_REMOVAL_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Synth_VOICE_REMOVAL_base _base_class;

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

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float position();
	inline void position(float _newValue);
	inline float frequency();
	inline void frequency(float _newValue);
};

class ARTS_EXPORT VoiceRemovalGuiFactory_base : virtual public Arts::GuiFactory_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT VoiceRemovalGuiFactory_stub : virtual public VoiceRemovalGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	VoiceRemovalGuiFactory_stub();

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

};

class ARTS_EXPORT VoiceRemovalGuiFactory_skel : virtual public VoiceRemovalGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	VoiceRemovalGuiFactory_skel();

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

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

protected:
	inline VoiceRemovalGuiFactory(VoiceRemovalGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef VoiceRemovalGuiFactory_base _base_class;

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

	inline Arts::Widget createGui(Arts::Object runningObject);
};

class ARTS_EXPORT Synth_STEREO_COMPRESSOR_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual float attack() = 0;
	virtual void attack(float newValue) = 0;
	virtual float release() = 0;
	virtual void release(float newValue) = 0;
	virtual float threshold() = 0;
	virtual void threshold(float newValue) = 0;
	virtual float ratio() = 0;
	virtual void ratio(float newValue) = 0;
	virtual float output() = 0;
	virtual void output(float newValue) = 0;
	virtual bool thru() = 0;
	virtual void thru(bool newValue) = 0;
};

class ARTS_EXPORT Synth_STEREO_COMPRESSOR_stub : virtual public Synth_STEREO_COMPRESSOR_base, virtual public Arts::StereoEffect_stub {
protected:
	Synth_STEREO_COMPRESSOR_stub();

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

	float attack();
	void attack(float newValue);
	float release();
	void release(float newValue);
	float threshold();
	void threshold(float newValue);
	float ratio();
	void ratio(float newValue);
	float output();
	void output(float newValue);
	bool thru();
	void thru(bool newValue);
};

class ARTS_EXPORT Synth_STEREO_COMPRESSOR_skel : virtual public Synth_STEREO_COMPRESSOR_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void attack_changed(float newValue) {
		_emit_changed("attack_changed",newValue);
	}
	inline void release_changed(float newValue) {
		_emit_changed("release_changed",newValue);
	}
	inline void threshold_changed(float newValue) {
		_emit_changed("threshold_changed",newValue);
	}
	inline void ratio_changed(float newValue) {
		_emit_changed("ratio_changed",newValue);
	}
	inline void output_changed(float newValue) {
		_emit_changed("output_changed",newValue);
	}
	inline void thru_changed(bool newValue) {
		_emit_changed("thru_changed",newValue);
	}

public:
	Synth_STEREO_COMPRESSOR_skel();

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

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

protected:
	inline Synth_STEREO_COMPRESSOR(Synth_STEREO_COMPRESSOR_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Synth_STEREO_COMPRESSOR_base _base_class;

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

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float attack();
	inline void attack(float _newValue);
	inline float release();
	inline void release(float _newValue);
	inline float threshold();
	inline void threshold(float _newValue);
	inline float ratio();
	inline void ratio(float _newValue);
	inline float output();
	inline void output(float _newValue);
	inline bool thru();
	inline void thru(bool _newValue);
};

class ARTS_EXPORT StereoCompressorGuiFactory_base : virtual public Arts::GuiFactory_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT StereoCompressorGuiFactory_stub : virtual public StereoCompressorGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	StereoCompressorGuiFactory_stub();

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

};

class ARTS_EXPORT StereoCompressorGuiFactory_skel : virtual public StereoCompressorGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	StereoCompressorGuiFactory_skel();

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

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

protected:
	inline StereoCompressorGuiFactory(StereoCompressorGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoCompressorGuiFactory_base _base_class;

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

	inline Arts::Widget createGui(Arts::Object runningObject);
};

class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual float speed() = 0;
	virtual void speed(float newValue) = 0;
	virtual float frequency() = 0;
	virtual void frequency(float newValue) = 0;
};

class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_stub : virtual public Synth_STEREO_PITCH_SHIFT_base, virtual public Arts::StereoEffect_stub {
protected:
	Synth_STEREO_PITCH_SHIFT_stub();

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

	float speed();
	void speed(float newValue);
	float frequency();
	void frequency(float newValue);
};

class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_skel : virtual public Synth_STEREO_PITCH_SHIFT_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void speed_changed(float newValue) {
		_emit_changed("speed_changed",newValue);
	}
	inline void frequency_changed(float newValue) {
		_emit_changed("frequency_changed",newValue);
	}

public:
	Synth_STEREO_PITCH_SHIFT_skel();

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

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

protected:
	inline Synth_STEREO_PITCH_SHIFT(Synth_STEREO_PITCH_SHIFT_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Synth_STEREO_PITCH_SHIFT_base _base_class;

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

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float speed();
	inline void speed(float _newValue);
	inline float frequency();
	inline void frequency(float _newValue);
};

class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_FFT_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual float speed() = 0;
	virtual void speed(float newValue) = 0;
	virtual float scaleFactor() = 0;
	virtual void scaleFactor(float newValue) = 0;
	virtual long frameSize() = 0;
	virtual void frameSize(long newValue) = 0;
	virtual long oversample() = 0;
	virtual void oversample(long newValue) = 0;
};

class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_FFT_stub : virtual public Synth_STEREO_PITCH_SHIFT_FFT_base, virtual public Arts::StereoEffect_stub {
protected:
	Synth_STEREO_PITCH_SHIFT_FFT_stub();

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

	float speed();
	void speed(float newValue);
	float scaleFactor();
	void scaleFactor(float newValue);
	long frameSize();
	void frameSize(long newValue);
	long oversample();
	void oversample(long newValue);
};

class ARTS_EXPORT Synth_STEREO_PITCH_SHIFT_FFT_skel : virtual public Synth_STEREO_PITCH_SHIFT_FFT_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void speed_changed(float newValue) {
		_emit_changed("speed_changed",newValue);
	}
	inline void scaleFactor_changed(float newValue) {
		_emit_changed("scaleFactor_changed",newValue);
	}
	inline void frameSize_changed(long newValue) {
		_emit_changed("frameSize_changed",newValue);
	}
	inline void oversample_changed(long newValue) {
		_emit_changed("oversample_changed",newValue);
	}

public:
	Synth_STEREO_PITCH_SHIFT_FFT_skel();

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

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

protected:
	inline Synth_STEREO_PITCH_SHIFT_FFT(Synth_STEREO_PITCH_SHIFT_FFT_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Synth_STEREO_PITCH_SHIFT_FFT_base _base_class;

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

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float speed();
	inline void speed(float _newValue);
	inline float scaleFactor();
	inline void scaleFactor(float _newValue);
	inline long frameSize();
	inline void frameSize(long _newValue);
	inline long oversample();
	inline void oversample(long _newValue);
};

class ARTS_EXPORT Synth_STEREO_FIR_EQUALIZER_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual std::vector<Arts::GraphPoint> * frequencies() = 0;
	virtual void frequencies(const std::vector<Arts::GraphPoint>& newValue) = 0;
	virtual long taps() = 0;
	virtual void taps(long newValue) = 0;
};

class ARTS_EXPORT Synth_STEREO_FIR_EQUALIZER_stub : virtual public Synth_STEREO_FIR_EQUALIZER_base, virtual public Arts::StereoEffect_stub {
protected:
	Synth_STEREO_FIR_EQUALIZER_stub();

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

	std::vector<Arts::GraphPoint> * frequencies();
	void frequencies(const std::vector<Arts::GraphPoint>& newValue);
	long taps();
	void taps(long newValue);
};

class ARTS_EXPORT Synth_STEREO_FIR_EQUALIZER_skel : virtual public Synth_STEREO_FIR_EQUALIZER_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void taps_changed(long newValue) {
		_emit_changed("taps_changed",newValue);
	}

public:
	Synth_STEREO_FIR_EQUALIZER_skel();

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

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

protected:
	inline Synth_STEREO_FIR_EQUALIZER(Synth_STEREO_FIR_EQUALIZER_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Synth_STEREO_FIR_EQUALIZER_base _base_class;

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

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline std::vector<Arts::GraphPoint> * frequencies();
	inline void frequencies(const std::vector<Arts::GraphPoint>& _newValue);
	inline long taps();
	inline void taps(long _newValue);
};

class ARTS_EXPORT StereoFirEqualizerGuiFactory_base : virtual public Arts::GuiFactory_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT StereoFirEqualizerGuiFactory_stub : virtual public StereoFirEqualizerGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	StereoFirEqualizerGuiFactory_stub();

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

};

class ARTS_EXPORT StereoFirEqualizerGuiFactory_skel : virtual public StereoFirEqualizerGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	StereoFirEqualizerGuiFactory_skel();

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

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

protected:
	inline StereoFirEqualizerGuiFactory(StereoFirEqualizerGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoFirEqualizerGuiFactory_base _base_class;

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

	inline Arts::Widget createGui(Arts::Object runningObject);
};

class ARTS_EXPORT Synth_FREEVERB_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual float roomsize() = 0;
	virtual void roomsize(float newValue) = 0;
	virtual float damp() = 0;
	virtual void damp(float newValue) = 0;
	virtual float wet() = 0;
	virtual void wet(float newValue) = 0;
	virtual float dry() = 0;
	virtual void dry(float newValue) = 0;
	virtual float width() = 0;
	virtual void width(float newValue) = 0;
	virtual float mode() = 0;
	virtual void mode(float newValue) = 0;
};

class ARTS_EXPORT Synth_FREEVERB_stub : virtual public Synth_FREEVERB_base, virtual public Arts::StereoEffect_stub {
protected:
	Synth_FREEVERB_stub();

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

	float roomsize();
	void roomsize(float newValue);
	float damp();
	void damp(float newValue);
	float wet();
	void wet(float newValue);
	float dry();
	void dry(float newValue);
	float width();
	void width(float newValue);
	float mode();
	void mode(float newValue);
};

class ARTS_EXPORT Synth_FREEVERB_skel : virtual public Synth_FREEVERB_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void roomsize_changed(float newValue) {
		_emit_changed("roomsize_changed",newValue);
	}
	inline void damp_changed(float newValue) {
		_emit_changed("damp_changed",newValue);
	}
	inline void wet_changed(float newValue) {
		_emit_changed("wet_changed",newValue);
	}
	inline void dry_changed(float newValue) {
		_emit_changed("dry_changed",newValue);
	}
	inline void width_changed(float newValue) {
		_emit_changed("width_changed",newValue);
	}
	inline void mode_changed(float newValue) {
		_emit_changed("mode_changed",newValue);
	}

public:
	Synth_FREEVERB_skel();

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

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

protected:
	inline Synth_FREEVERB(Synth_FREEVERB_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Synth_FREEVERB_base _base_class;

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

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline float roomsize();
	inline void roomsize(float _newValue);
	inline float damp();
	inline void damp(float _newValue);
	inline float wet();
	inline void wet(float _newValue);
	inline float dry();
	inline void dry(float _newValue);
	inline float width();
	inline void width(float _newValue);
	inline float mode();
	inline void mode(float _newValue);
};

class ARTS_EXPORT FreeverbGuiFactory_base : virtual public Arts::GuiFactory_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT FreeverbGuiFactory_stub : virtual public FreeverbGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	FreeverbGuiFactory_stub();

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

};

class ARTS_EXPORT FreeverbGuiFactory_skel : virtual public FreeverbGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	FreeverbGuiFactory_skel();

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

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

protected:
	inline FreeverbGuiFactory(FreeverbGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef FreeverbGuiFactory_base _base_class;

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

	inline Arts::Widget createGui(Arts::Object runningObject);
};

class ARTS_EXPORT Effect_WAVECAPTURE_base : virtual public Arts::StereoEffect_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual std::string filename() = 0;
	virtual void filename(const std::string& newValue) = 0;
};

class ARTS_EXPORT Effect_WAVECAPTURE_stub : virtual public Effect_WAVECAPTURE_base, virtual public Arts::StereoEffect_stub {
protected:
	Effect_WAVECAPTURE_stub();

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

	std::string filename();
	void filename(const std::string& newValue);
};

class ARTS_EXPORT Effect_WAVECAPTURE_skel : virtual public Effect_WAVECAPTURE_base, virtual public Arts::StereoEffect_skel {
protected:
	// emitters for change notifications
	inline void filename_changed(const std::string& newValue) {
		_emit_changed("filename_changed",newValue);
	}

public:
	Effect_WAVECAPTURE_skel();

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

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

protected:
	inline Effect_WAVECAPTURE(Effect_WAVECAPTURE_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Effect_WAVECAPTURE_base _base_class;

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

	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline std::string filename();
	inline void filename(const std::string& _newValue);
};

class ARTS_EXPORT StereoVolumeControlGui_base : virtual public Arts::LayoutBox_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

	virtual std::string title() = 0;
	virtual void title(const std::string& newValue) = 0;
	virtual float dbmin() = 0;
	virtual void dbmin(float newValue) = 0;
	virtual float dbmax() = 0;
	virtual void dbmax(float newValue) = 0;
	virtual Arts::LevelMeter left() = 0;
	virtual Arts::LevelMeter right() = 0;
	virtual Arts::VolumeFader fader() = 0;
	virtual Arts::Tickmarks levelmetertickmarks() = 0;
	virtual Arts::Tickmarks volumefadertickmarks() = 0;
	virtual Arts::Label label() = 0;
	virtual bool couple() = 0;
	virtual void couple(bool newValue) = 0;
	virtual void constructor(Arts::StereoVolumeControl svc) = 0;
};

class ARTS_EXPORT StereoVolumeControlGui_stub : virtual public StereoVolumeControlGui_base, virtual public Arts::LayoutBox_stub {
protected:
	StereoVolumeControlGui_stub();

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

	std::string title();
	void title(const std::string& newValue);
	float dbmin();
	void dbmin(float newValue);
	float dbmax();
	void dbmax(float newValue);
	Arts::LevelMeter left();
	Arts::LevelMeter right();
	Arts::VolumeFader fader();
	Arts::Tickmarks levelmetertickmarks();
	Arts::Tickmarks volumefadertickmarks();
	Arts::Label label();
	bool couple();
	void couple(bool newValue);
	void constructor(Arts::StereoVolumeControl svc);
};

class ARTS_EXPORT StereoVolumeControlGui_skel : virtual public StereoVolumeControlGui_base, virtual public Arts::LayoutBox_skel {
protected:
	// emitters for change notifications
	inline void title_changed(const std::string& newValue) {
		_emit_changed("title_changed",newValue);
	}
	inline void dbmin_changed(float newValue) {
		_emit_changed("dbmin_changed",newValue);
	}
	inline void dbmax_changed(float newValue) {
		_emit_changed("dbmax_changed",newValue);
	}
	inline void couple_changed(bool newValue) {
		_emit_changed("couple_changed",newValue);
	}

public:
	StereoVolumeControlGui_skel();

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

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

protected:
	inline StereoVolumeControlGui(StereoVolumeControlGui_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoVolumeControlGui_base _base_class;

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

	inline Arts::Direction direction();
	inline void direction(Arts::Direction _newValue);
	inline long spacing();
	inline void spacing(long _newValue);
	inline long layoutmargin();
	inline void layoutmargin(long _newValue);
	inline void addWidget(Arts::Widget widget, long stretch, long align);
	inline void addWidget(Arts::Widget widget, long stretch);
	inline void addWidget(Arts::Widget widget);
	inline void insertWidget(long position, Arts::Widget widget, long stretch, long align);
	inline void insertWidget(long position, Arts::Widget widget, long stretch);
	inline void insertWidget(long position, Arts::Widget widget);
	inline void addStretch(long stretch);
	inline void addStretch();
	inline void addSpace(long space);
	inline void addStrut(long size);
	inline void addSeparator(long stretch, long align);
	inline void addSeparator(long stretch);
	inline void addSeparator();
	inline void addLine(long width, long space, long stretch, long align);
	inline void addLine(long width, long space, long stretch);
	inline void addLine(long width, long space);
	inline long margin();
	inline void margin(long _newValue);
	inline long linewidth();
	inline void linewidth(long _newValue);
	inline long midlinewidth();
	inline void midlinewidth(long _newValue);
	inline long framestyle();
	inline void framestyle(long _newValue);
	inline Arts::Shape frameshape();
	inline void frameshape(Arts::Shape _newValue);
	inline Arts::Shadow frameshadow();
	inline void frameshadow(Arts::Shadow _newValue);
	inline StereoVolumeControlGui(Arts::Widget parent);
	inline long widgetID();
	inline Arts::Widget parent();
	inline void parent(Arts::Widget _newValue);
	inline long x();
	inline void x(long _newValue);
	inline long y();
	inline void y(long _newValue);
	inline long width();
	inline void width(long _newValue);
	inline long height();
	inline void height(long _newValue);
	inline bool visible();
	inline void visible(bool _newValue);
	inline Arts::SizePolicy hSizePolicy();
	inline void hSizePolicy(Arts::SizePolicy _newValue);
	inline Arts::SizePolicy vSizePolicy();
	inline void vSizePolicy(Arts::SizePolicy _newValue);
	inline void show();
	inline void hide();
	inline std::string title();
	inline void title(const std::string& _newValue);
	inline float dbmin();
	inline void dbmin(float _newValue);
	inline float dbmax();
	inline void dbmax(float _newValue);
	inline Arts::LevelMeter left();
	inline Arts::LevelMeter right();
	inline Arts::VolumeFader fader();
	inline Arts::Tickmarks levelmetertickmarks();
	inline Arts::Tickmarks volumefadertickmarks();
	inline Arts::Label label();
	inline bool couple();
	inline void couple(bool _newValue);
	inline StereoVolumeControlGui(Arts::StereoVolumeControl svc);
};

class ARTS_EXPORT StereoVolumeControlGuiFactory_base : virtual public Arts::GuiFactory_base {
public:
	static unsigned long _IID; // interface ID

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

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

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

	void *_cast(unsigned long iid);

};

class ARTS_EXPORT StereoVolumeControlGuiFactory_stub : virtual public StereoVolumeControlGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	StereoVolumeControlGuiFactory_stub();

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

};

class ARTS_EXPORT StereoVolumeControlGuiFactory_skel : virtual public StereoVolumeControlGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	StereoVolumeControlGuiFactory_skel();

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

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

protected:
	inline StereoVolumeControlGuiFactory(StereoVolumeControlGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef StereoVolumeControlGuiFactory_base _base_class;

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

	inline Arts::Widget createGui(Arts::Object runningObject);
};

}
// Forward wrapper calls to _base classes:

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

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

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

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

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

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

inline float Arts::StereoToMono::pan()
{
	return _cache?static_cast<Arts::StereoToMono_base*>(_cache)->pan():static_cast<Arts::StereoToMono_base*>(_method_call())->pan();
}

inline void Arts::StereoToMono::pan(float _newValue)
{
	 _cache?static_cast<Arts::StereoToMono_base*>(_cache)->pan(_newValue):static_cast<Arts::StereoToMono_base*>(_method_call())->pan(_newValue);
}

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

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

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

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

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

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

inline float Arts::MonoToStereo::pan()
{
	return _cache?static_cast<Arts::MonoToStereo_base*>(_cache)->pan():static_cast<Arts::MonoToStereo_base*>(_method_call())->pan();
}

inline void Arts::MonoToStereo::pan(float _newValue)
{
	 _cache?static_cast<Arts::MonoToStereo_base*>(_cache)->pan(_newValue):static_cast<Arts::MonoToStereo_base*>(_method_call())->pan(_newValue);
}

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

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

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

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

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

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

inline float Arts::StereoBalance::balance()
{
	return _cache?static_cast<Arts::StereoBalance_base*>(_cache)->balance():static_cast<Arts::StereoBalance_base*>(_method_call())->balance();
}

inline void Arts::StereoBalance::balance(float _newValue)
{
	 _cache?static_cast<Arts::StereoBalance_base*>(_cache)->balance(_newValue):static_cast<Arts::StereoBalance_base*>(_method_call())->balance(_newValue);
}

inline Arts::Widget Arts::StereoBalanceGuiFactory::createGui(Arts::Object runningObject)
{
	return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
}

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

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

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

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

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

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

inline Arts::StereoToMono Arts::FiveBandMonoComplexEQ::s2m()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->s2m():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->s2m();
}

inline float Arts::FiveBandMonoComplexEQ::lowfreq()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowfreq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowfreq();
}

inline void Arts::FiveBandMonoComplexEQ::lowfreq(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowfreq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowfreq(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::lowq()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowq();
}

inline void Arts::FiveBandMonoComplexEQ::lowq(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowq(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::lowgain()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowgain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowgain();
}

inline void Arts::FiveBandMonoComplexEQ::lowgain(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->lowgain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->lowgain(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::mid1freq()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1freq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1freq();
}

inline void Arts::FiveBandMonoComplexEQ::mid1freq(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1freq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1freq(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::mid1q()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1q():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1q();
}

inline void Arts::FiveBandMonoComplexEQ::mid1q(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1q(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1q(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::mid1gain()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1gain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1gain();
}

inline void Arts::FiveBandMonoComplexEQ::mid1gain(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid1gain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid1gain(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::mid2freq()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2freq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2freq();
}

inline void Arts::FiveBandMonoComplexEQ::mid2freq(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2freq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2freq(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::mid2q()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2q():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2q();
}

inline void Arts::FiveBandMonoComplexEQ::mid2q(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2q(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2q(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::mid2gain()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2gain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2gain();
}

inline void Arts::FiveBandMonoComplexEQ::mid2gain(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid2gain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid2gain(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::mid3freq()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3freq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3freq();
}

inline void Arts::FiveBandMonoComplexEQ::mid3freq(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3freq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3freq(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::mid3q()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3q():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3q();
}

inline void Arts::FiveBandMonoComplexEQ::mid3q(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3q(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3q(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::mid3gain()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3gain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3gain();
}

inline void Arts::FiveBandMonoComplexEQ::mid3gain(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->mid3gain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->mid3gain(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::highfreq()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highfreq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highfreq();
}

inline void Arts::FiveBandMonoComplexEQ::highfreq(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highfreq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highfreq(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::highq()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highq():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highq();
}

inline void Arts::FiveBandMonoComplexEQ::highq(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highq(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highq(_newValue);
}

inline float Arts::FiveBandMonoComplexEQ::highgain()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highgain():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highgain();
}

inline void Arts::FiveBandMonoComplexEQ::highgain(float _newValue)
{
	 _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->highgain(_newValue):static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->highgain(_newValue);
}

inline Arts::MonoToStereo Arts::FiveBandMonoComplexEQ::m2s()
{
	return _cache?static_cast<Arts::FiveBandMonoComplexEQ_base*>(_cache)->m2s():static_cast<Arts::FiveBandMonoComplexEQ_base*>(_method_call())->m2s();
}

inline Arts::Widget Arts::FiveBandMonoComplexEQGuiFactory::createGui(Arts::Object runningObject)
{
	return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
}

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

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

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

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

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

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

inline float Arts::Synth_VOICE_REMOVAL::position()
{
	return _cache?static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_cache)->position():static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_method_call())->position();
}

inline void Arts::Synth_VOICE_REMOVAL::position(float _newValue)
{
	 _cache?static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_cache)->position(_newValue):static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_method_call())->position(_newValue);
}

inline float Arts::Synth_VOICE_REMOVAL::frequency()
{
	return _cache?static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_cache)->frequency():static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_method_call())->frequency();
}

inline void Arts::Synth_VOICE_REMOVAL::frequency(float _newValue)
{
	 _cache?static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_cache)->frequency(_newValue):static_cast<Arts::Synth_VOICE_REMOVAL_base*>(_method_call())->frequency(_newValue);
}

inline Arts::Widget Arts::VoiceRemovalGuiFactory::createGui(Arts::Object runningObject)
{
	return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
}

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

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

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

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

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

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

inline float Arts::Synth_STEREO_COMPRESSOR::attack()
{
	return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->attack():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->attack();
}

inline void Arts::Synth_STEREO_COMPRESSOR::attack(float _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->attack(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->attack(_newValue);
}

inline float Arts::Synth_STEREO_COMPRESSOR::release()
{
	return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->release():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->release();
}

inline void Arts::Synth_STEREO_COMPRESSOR::release(float _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->release(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->release(_newValue);
}

inline float Arts::Synth_STEREO_COMPRESSOR::threshold()
{
	return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->threshold():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->threshold();
}

inline void Arts::Synth_STEREO_COMPRESSOR::threshold(float _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->threshold(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->threshold(_newValue);
}

inline float Arts::Synth_STEREO_COMPRESSOR::ratio()
{
	return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->ratio():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->ratio();
}

inline void Arts::Synth_STEREO_COMPRESSOR::ratio(float _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->ratio(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->ratio(_newValue);
}

inline float Arts::Synth_STEREO_COMPRESSOR::output()
{
	return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->output():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->output();
}

inline void Arts::Synth_STEREO_COMPRESSOR::output(float _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->output(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->output(_newValue);
}

inline bool Arts::Synth_STEREO_COMPRESSOR::thru()
{
	return _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->thru():static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->thru();
}

inline void Arts::Synth_STEREO_COMPRESSOR::thru(bool _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_cache)->thru(_newValue):static_cast<Arts::Synth_STEREO_COMPRESSOR_base*>(_method_call())->thru(_newValue);
}

inline Arts::Widget Arts::StereoCompressorGuiFactory::createGui(Arts::Object runningObject)
{
	return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
}

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

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

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

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

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

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

inline float Arts::Synth_STEREO_PITCH_SHIFT::speed()
{
	return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_cache)->speed():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_method_call())->speed();
}

inline void Arts::Synth_STEREO_PITCH_SHIFT::speed(float _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_cache)->speed(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_method_call())->speed(_newValue);
}

inline float Arts::Synth_STEREO_PITCH_SHIFT::frequency()
{
	return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_cache)->frequency():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_method_call())->frequency();
}

inline void Arts::Synth_STEREO_PITCH_SHIFT::frequency(float _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_cache)->frequency(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_base*>(_method_call())->frequency(_newValue);
}

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

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

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

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

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

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

inline float Arts::Synth_STEREO_PITCH_SHIFT_FFT::speed()
{
	return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->speed():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->speed();
}

inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::speed(float _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->speed(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->speed(_newValue);
}

inline float Arts::Synth_STEREO_PITCH_SHIFT_FFT::scaleFactor()
{
	return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->scaleFactor():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->scaleFactor();
}

inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::scaleFactor(float _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->scaleFactor(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->scaleFactor(_newValue);
}

inline long Arts::Synth_STEREO_PITCH_SHIFT_FFT::frameSize()
{
	return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->frameSize():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->frameSize();
}

inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::frameSize(long _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->frameSize(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->frameSize(_newValue);
}

inline long Arts::Synth_STEREO_PITCH_SHIFT_FFT::oversample()
{
	return _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->oversample():static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->oversample();
}

inline void Arts::Synth_STEREO_PITCH_SHIFT_FFT::oversample(long _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_cache)->oversample(_newValue):static_cast<Arts::Synth_STEREO_PITCH_SHIFT_FFT_base*>(_method_call())->oversample(_newValue);
}

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

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

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

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

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

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

inline std::vector<Arts::GraphPoint> * Arts::Synth_STEREO_FIR_EQUALIZER::frequencies()
{
	return _cache?static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_cache)->frequencies():static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_method_call())->frequencies();
}

inline void Arts::Synth_STEREO_FIR_EQUALIZER::frequencies(const std::vector<Arts::GraphPoint>& _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_cache)->frequencies(_newValue):static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_method_call())->frequencies(_newValue);
}

inline long Arts::Synth_STEREO_FIR_EQUALIZER::taps()
{
	return _cache?static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_cache)->taps():static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_method_call())->taps();
}

inline void Arts::Synth_STEREO_FIR_EQUALIZER::taps(long _newValue)
{
	 _cache?static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_cache)->taps(_newValue):static_cast<Arts::Synth_STEREO_FIR_EQUALIZER_base*>(_method_call())->taps(_newValue);
}

inline Arts::Widget Arts::StereoFirEqualizerGuiFactory::createGui(Arts::Object runningObject)
{
	return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
}

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

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

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

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

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

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

inline float Arts::Synth_FREEVERB::roomsize()
{
	return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->roomsize():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->roomsize();
}

inline void Arts::Synth_FREEVERB::roomsize(float _newValue)
{
	 _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->roomsize(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->roomsize(_newValue);
}

inline float Arts::Synth_FREEVERB::damp()
{
	return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->damp():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->damp();
}

inline void Arts::Synth_FREEVERB::damp(float _newValue)
{
	 _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->damp(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->damp(_newValue);
}

inline float Arts::Synth_FREEVERB::wet()
{
	return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->wet():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->wet();
}

inline void Arts::Synth_FREEVERB::wet(float _newValue)
{
	 _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->wet(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->wet(_newValue);
}

inline float Arts::Synth_FREEVERB::dry()
{
	return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->dry():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->dry();
}

inline void Arts::Synth_FREEVERB::dry(float _newValue)
{
	 _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->dry(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->dry(_newValue);
}

inline float Arts::Synth_FREEVERB::width()
{
	return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->width():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->width();
}

inline void Arts::Synth_FREEVERB::width(float _newValue)
{
	 _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->width(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->width(_newValue);
}

inline float Arts::Synth_FREEVERB::mode()
{
	return _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->mode():static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->mode();
}

inline void Arts::Synth_FREEVERB::mode(float _newValue)
{
	 _cache?static_cast<Arts::Synth_FREEVERB_base*>(_cache)->mode(_newValue):static_cast<Arts::Synth_FREEVERB_base*>(_method_call())->mode(_newValue);
}

inline Arts::Widget Arts::FreeverbGuiFactory::createGui(Arts::Object runningObject)
{
	return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
}

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

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

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

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

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

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

inline std::string Arts::Effect_WAVECAPTURE::filename()
{
	return _cache?static_cast<Arts::Effect_WAVECAPTURE_base*>(_cache)->filename():static_cast<Arts::Effect_WAVECAPTURE_base*>(_method_call())->filename();
}

inline void Arts::Effect_WAVECAPTURE::filename(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Effect_WAVECAPTURE_base*>(_cache)->filename(_newValue):static_cast<Arts::Effect_WAVECAPTURE_base*>(_method_call())->filename(_newValue);
}

inline Arts::Direction Arts::StereoVolumeControlGui::direction()
{
	return _cache?static_cast<Arts::LayoutBox_base*>(_cache)->direction():static_cast<Arts::LayoutBox_base*>(_method_call())->direction();
}

inline void Arts::StereoVolumeControlGui::direction(Arts::Direction _newValue)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->direction(_newValue):static_cast<Arts::LayoutBox_base*>(_method_call())->direction(_newValue);
}

inline long Arts::StereoVolumeControlGui::spacing()
{
	return _cache?static_cast<Arts::LayoutBox_base*>(_cache)->spacing():static_cast<Arts::LayoutBox_base*>(_method_call())->spacing();
}

inline void Arts::StereoVolumeControlGui::spacing(long _newValue)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->spacing(_newValue):static_cast<Arts::LayoutBox_base*>(_method_call())->spacing(_newValue);
}

inline long Arts::StereoVolumeControlGui::layoutmargin()
{
	return _cache?static_cast<Arts::LayoutBox_base*>(_cache)->layoutmargin():static_cast<Arts::LayoutBox_base*>(_method_call())->layoutmargin();
}

inline void Arts::StereoVolumeControlGui::layoutmargin(long _newValue)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->layoutmargin(_newValue):static_cast<Arts::LayoutBox_base*>(_method_call())->layoutmargin(_newValue);
}

inline void Arts::StereoVolumeControlGui::addWidget(Arts::Widget widget, long stretch, long align)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addWidget(widget, stretch, align):static_cast<Arts::LayoutBox_base*>(_method_call())->addWidget(widget, stretch, align);
}

inline void Arts::StereoVolumeControlGui::addWidget(Arts::Widget widget, long stretch)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addWidget(widget, stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->addWidget(widget, stretch);
}

inline void Arts::StereoVolumeControlGui::addWidget(Arts::Widget widget)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addWidget(widget):static_cast<Arts::LayoutBox_base*>(_method_call())->addWidget(widget);
}

inline void Arts::StereoVolumeControlGui::insertWidget(long position, Arts::Widget widget, long stretch, long align)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->insertWidget(position, widget, stretch, align):static_cast<Arts::LayoutBox_base*>(_method_call())->insertWidget(position, widget, stretch, align);
}

inline void Arts::StereoVolumeControlGui::insertWidget(long position, Arts::Widget widget, long stretch)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->insertWidget(position, widget, stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->insertWidget(position, widget, stretch);
}

inline void Arts::StereoVolumeControlGui::insertWidget(long position, Arts::Widget widget)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->insertWidget(position, widget):static_cast<Arts::LayoutBox_base*>(_method_call())->insertWidget(position, widget);
}

inline void Arts::StereoVolumeControlGui::addStretch(long stretch)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addStretch(stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->addStretch(stretch);
}

inline void Arts::StereoVolumeControlGui::addStretch()
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addStretch():static_cast<Arts::LayoutBox_base*>(_method_call())->addStretch();
}

inline void Arts::StereoVolumeControlGui::addSpace(long space)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addSpace(space):static_cast<Arts::LayoutBox_base*>(_method_call())->addSpace(space);
}

inline void Arts::StereoVolumeControlGui::addStrut(long size)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addStrut(size):static_cast<Arts::LayoutBox_base*>(_method_call())->addStrut(size);
}

inline void Arts::StereoVolumeControlGui::addSeparator(long stretch, long align)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addSeparator(stretch, align):static_cast<Arts::LayoutBox_base*>(_method_call())->addSeparator(stretch, align);
}

inline void Arts::StereoVolumeControlGui::addSeparator(long stretch)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addSeparator(stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->addSeparator(stretch);
}

inline void Arts::StereoVolumeControlGui::addSeparator()
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addSeparator():static_cast<Arts::LayoutBox_base*>(_method_call())->addSeparator();
}

inline void Arts::StereoVolumeControlGui::addLine(long width, long space, long stretch, long align)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addLine(width, space, stretch, align):static_cast<Arts::LayoutBox_base*>(_method_call())->addLine(width, space, stretch, align);
}

inline void Arts::StereoVolumeControlGui::addLine(long width, long space, long stretch)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addLine(width, space, stretch):static_cast<Arts::LayoutBox_base*>(_method_call())->addLine(width, space, stretch);
}

inline void Arts::StereoVolumeControlGui::addLine(long width, long space)
{
	 _cache?static_cast<Arts::LayoutBox_base*>(_cache)->addLine(width, space):static_cast<Arts::LayoutBox_base*>(_method_call())->addLine(width, space);
}

inline long Arts::StereoVolumeControlGui::margin()
{
	return _cache?static_cast<Arts::Frame_base*>(_cache)->margin():static_cast<Arts::Frame_base*>(_method_call())->margin();
}

inline void Arts::StereoVolumeControlGui::margin(long _newValue)
{
	 _cache?static_cast<Arts::Frame_base*>(_cache)->margin(_newValue):static_cast<Arts::Frame_base*>(_method_call())->margin(_newValue);
}

inline long Arts::StereoVolumeControlGui::linewidth()
{
	return _cache?static_cast<Arts::Frame_base*>(_cache)->linewidth():static_cast<Arts::Frame_base*>(_method_call())->linewidth();
}

inline void Arts::StereoVolumeControlGui::linewidth(long _newValue)
{
	 _cache?static_cast<Arts::Frame_base*>(_cache)->linewidth(_newValue):static_cast<Arts::Frame_base*>(_method_call())->linewidth(_newValue);
}

inline long Arts::StereoVolumeControlGui::midlinewidth()
{
	return _cache?static_cast<Arts::Frame_base*>(_cache)->midlinewidth():static_cast<Arts::Frame_base*>(_method_call())->midlinewidth();
}

inline void Arts::StereoVolumeControlGui::midlinewidth(long _newValue)
{
	 _cache?static_cast<Arts::Frame_base*>(_cache)->midlinewidth(_newValue):static_cast<Arts::Frame_base*>(_method_call())->midlinewidth(_newValue);
}

inline long Arts::StereoVolumeControlGui::framestyle()
{
	return _cache?static_cast<Arts::Frame_base*>(_cache)->framestyle():static_cast<Arts::Frame_base*>(_method_call())->framestyle();
}

inline void Arts::StereoVolumeControlGui::framestyle(long _newValue)
{
	 _cache?static_cast<Arts::Frame_base*>(_cache)->framestyle(_newValue):static_cast<Arts::Frame_base*>(_method_call())->framestyle(_newValue);
}

inline Arts::Shape Arts::StereoVolumeControlGui::frameshape()
{
	return _cache?static_cast<Arts::Frame_base*>(_cache)->frameshape():static_cast<Arts::Frame_base*>(_method_call())->frameshape();
}

inline void Arts::StereoVolumeControlGui::frameshape(Arts::Shape _newValue)
{
	 _cache?static_cast<Arts::Frame_base*>(_cache)->frameshape(_newValue):static_cast<Arts::Frame_base*>(_method_call())->frameshape(_newValue);
}

inline Arts::Shadow Arts::StereoVolumeControlGui::frameshadow()
{
	return _cache?static_cast<Arts::Frame_base*>(_cache)->frameshadow():static_cast<Arts::Frame_base*>(_method_call())->frameshadow();
}

inline void Arts::StereoVolumeControlGui::frameshadow(Arts::Shadow _newValue)
{
	 _cache?static_cast<Arts::Frame_base*>(_cache)->frameshadow(_newValue):static_cast<Arts::Frame_base*>(_method_call())->frameshadow(_newValue);
}

inline Arts::StereoVolumeControlGui::StereoVolumeControlGui(Arts::Widget parent)
		: Arts::Object(StereoVolumeControlGui_base::_create())
{
	static_cast<Arts::Frame_base*>(_method_call())->constructor(parent);
}

inline long Arts::StereoVolumeControlGui::widgetID()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->widgetID():static_cast<Arts::Widget_base*>(_method_call())->widgetID();
}

inline Arts::Widget Arts::StereoVolumeControlGui::parent()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->parent():static_cast<Arts::Widget_base*>(_method_call())->parent();
}

inline void Arts::StereoVolumeControlGui::parent(Arts::Widget _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->parent(_newValue):static_cast<Arts::Widget_base*>(_method_call())->parent(_newValue);
}

inline long Arts::StereoVolumeControlGui::x()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->x():static_cast<Arts::Widget_base*>(_method_call())->x();
}

inline void Arts::StereoVolumeControlGui::x(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->x(_newValue):static_cast<Arts::Widget_base*>(_method_call())->x(_newValue);
}

inline long Arts::StereoVolumeControlGui::y()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->y():static_cast<Arts::Widget_base*>(_method_call())->y();
}

inline void Arts::StereoVolumeControlGui::y(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->y(_newValue):static_cast<Arts::Widget_base*>(_method_call())->y(_newValue);
}

inline long Arts::StereoVolumeControlGui::width()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->width():static_cast<Arts::Widget_base*>(_method_call())->width();
}

inline void Arts::StereoVolumeControlGui::width(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->width(_newValue):static_cast<Arts::Widget_base*>(_method_call())->width(_newValue);
}

inline long Arts::StereoVolumeControlGui::height()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->height():static_cast<Arts::Widget_base*>(_method_call())->height();
}

inline void Arts::StereoVolumeControlGui::height(long _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->height(_newValue):static_cast<Arts::Widget_base*>(_method_call())->height(_newValue);
}

inline bool Arts::StereoVolumeControlGui::visible()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->visible():static_cast<Arts::Widget_base*>(_method_call())->visible();
}

inline void Arts::StereoVolumeControlGui::visible(bool _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->visible(_newValue):static_cast<Arts::Widget_base*>(_method_call())->visible(_newValue);
}

inline Arts::SizePolicy Arts::StereoVolumeControlGui::hSizePolicy()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->hSizePolicy():static_cast<Arts::Widget_base*>(_method_call())->hSizePolicy();
}

inline void Arts::StereoVolumeControlGui::hSizePolicy(Arts::SizePolicy _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hSizePolicy(_newValue):static_cast<Arts::Widget_base*>(_method_call())->hSizePolicy(_newValue);
}

inline Arts::SizePolicy Arts::StereoVolumeControlGui::vSizePolicy()
{
	return _cache?static_cast<Arts::Widget_base*>(_cache)->vSizePolicy():static_cast<Arts::Widget_base*>(_method_call())->vSizePolicy();
}

inline void Arts::StereoVolumeControlGui::vSizePolicy(Arts::SizePolicy _newValue)
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->vSizePolicy(_newValue):static_cast<Arts::Widget_base*>(_method_call())->vSizePolicy(_newValue);
}

inline void Arts::StereoVolumeControlGui::show()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->show():static_cast<Arts::Widget_base*>(_method_call())->show();
}

inline void Arts::StereoVolumeControlGui::hide()
{
	 _cache?static_cast<Arts::Widget_base*>(_cache)->hide():static_cast<Arts::Widget_base*>(_method_call())->hide();
}

inline std::string Arts::StereoVolumeControlGui::title()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->title():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->title();
}

inline void Arts::StereoVolumeControlGui::title(const std::string& _newValue)
{
	 _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->title(_newValue):static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->title(_newValue);
}

inline float Arts::StereoVolumeControlGui::dbmin()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->dbmin():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->dbmin();
}

inline void Arts::StereoVolumeControlGui::dbmin(float _newValue)
{
	 _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->dbmin(_newValue):static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->dbmin(_newValue);
}

inline float Arts::StereoVolumeControlGui::dbmax()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->dbmax():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->dbmax();
}

inline void Arts::StereoVolumeControlGui::dbmax(float _newValue)
{
	 _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->dbmax(_newValue):static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->dbmax(_newValue);
}

inline Arts::LevelMeter Arts::StereoVolumeControlGui::left()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->left():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->left();
}

inline Arts::LevelMeter Arts::StereoVolumeControlGui::right()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->right():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->right();
}

inline Arts::VolumeFader Arts::StereoVolumeControlGui::fader()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->fader():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->fader();
}

inline Arts::Tickmarks Arts::StereoVolumeControlGui::levelmetertickmarks()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->levelmetertickmarks():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->levelmetertickmarks();
}

inline Arts::Tickmarks Arts::StereoVolumeControlGui::volumefadertickmarks()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->volumefadertickmarks():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->volumefadertickmarks();
}

inline Arts::Label Arts::StereoVolumeControlGui::label()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->label():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->label();
}

inline bool Arts::StereoVolumeControlGui::couple()
{
	return _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->couple():static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->couple();
}

inline void Arts::StereoVolumeControlGui::couple(bool _newValue)
{
	 _cache?static_cast<Arts::StereoVolumeControlGui_base*>(_cache)->couple(_newValue):static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->couple(_newValue);
}

inline Arts::StereoVolumeControlGui::StereoVolumeControlGui(Arts::StereoVolumeControl svc)
		: Arts::Object(StereoVolumeControlGui_base::_create())
{
	static_cast<Arts::StereoVolumeControlGui_base*>(_method_call())->constructor(svc);
}

inline Arts::Widget Arts::StereoVolumeControlGuiFactory::createGui(Arts::Object runningObject)
{
	return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
}

#endif /* ARTSMODULESEFFECTS_H */
