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

#ifndef ARTSMODULESMIXERS_H
#define ARTSMODULESMIXERS_H

#include "common.h"

#include "arts_export.h"

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

namespace Arts {
class SimpleMixerChannel;
class SimpleMixerChannelGuiFactory;
class MonoSimpleMixerChannel;
class MonoSimpleMixerChannelGuiFactory;
class Synth_AUX_BUS;
class LittleStereoMixerChannel;
class LittleStereoMixerChannelGuiFactory;

class ARTS_EXPORT SimpleMixerChannel_base : virtual public Arts::Environment::MixerChannel_base {
public:
	static unsigned long _IID; // interface ID

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

	static SimpleMixerChannel_base *_fromDynamicCast(const Arts::Object& object);
	inline SimpleMixerChannel_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::Synth_STD_EQUALIZER equalizerLeft() = 0;
	virtual Arts::Synth_STD_EQUALIZER equalizerRight() = 0;
	virtual Arts::StereoEffectStack insertEffects() = 0;
	virtual float gainLeft() = 0;
	virtual void gainLeft(float newValue) = 0;
	virtual float gainRight() = 0;
	virtual void gainRight(float newValue) = 0;
	virtual float pan() = 0;
	virtual void pan(float newValue) = 0;
	virtual float volumeLeft() = 0;
	virtual void volumeLeft(float newValue) = 0;
	virtual float volumeRight() = 0;
	virtual void volumeRight(float newValue) = 0;
};

class ARTS_EXPORT SimpleMixerChannel_stub : virtual public SimpleMixerChannel_base, virtual public Arts::Environment::MixerChannel_stub {
protected:
	SimpleMixerChannel_stub();

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

	Arts::Synth_STD_EQUALIZER equalizerLeft();
	Arts::Synth_STD_EQUALIZER equalizerRight();
	Arts::StereoEffectStack insertEffects();
	float gainLeft();
	void gainLeft(float newValue);
	float gainRight();
	void gainRight(float newValue);
	float pan();
	void pan(float newValue);
	float volumeLeft();
	void volumeLeft(float newValue);
	float volumeRight();
	void volumeRight(float newValue);
};

class ARTS_EXPORT SimpleMixerChannel_skel : virtual public SimpleMixerChannel_base, virtual public Arts::Environment::MixerChannel_skel {
protected:
	// emitters for change notifications
	inline void gainLeft_changed(float newValue) {
		_emit_changed("gainLeft_changed",newValue);
	}
	inline void gainRight_changed(float newValue) {
		_emit_changed("gainRight_changed",newValue);
	}
	inline void pan_changed(float newValue) {
		_emit_changed("pan_changed",newValue);
	}
	inline void volumeLeft_changed(float newValue) {
		_emit_changed("volumeLeft_changed",newValue);
	}
	inline void volumeRight_changed(float newValue) {
		_emit_changed("volumeRight_changed",newValue);
	}

public:
	SimpleMixerChannel_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 SimpleMixerChannel : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	SimpleMixerChannel_base *_cache;
	inline SimpleMixerChannel_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(SimpleMixerChannel_base *)_pool->base->_cast(SimpleMixerChannel_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline SimpleMixerChannel(SimpleMixerChannel_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef SimpleMixerChannel_base _base_class;

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

	inline std::string name();
	inline void name(const std::string& _newValue);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline Arts::Synth_STD_EQUALIZER equalizerLeft();
	inline Arts::Synth_STD_EQUALIZER equalizerRight();
	inline Arts::StereoEffectStack insertEffects();
	inline float gainLeft();
	inline void gainLeft(float _newValue);
	inline float gainRight();
	inline void gainRight(float _newValue);
	inline float pan();
	inline void pan(float _newValue);
	inline float volumeLeft();
	inline void volumeLeft(float _newValue);
	inline float volumeRight();
	inline void volumeRight(float _newValue);
};

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

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

	static SimpleMixerChannelGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
	inline SimpleMixerChannelGuiFactory_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 SimpleMixerChannelGuiFactory_stub : virtual public SimpleMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	SimpleMixerChannelGuiFactory_stub();

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

};

class ARTS_EXPORT SimpleMixerChannelGuiFactory_skel : virtual public SimpleMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	SimpleMixerChannelGuiFactory_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 SimpleMixerChannelGuiFactory : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	SimpleMixerChannelGuiFactory_base *_cache;
	inline SimpleMixerChannelGuiFactory_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(SimpleMixerChannelGuiFactory_base *)_pool->base->_cast(SimpleMixerChannelGuiFactory_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline SimpleMixerChannelGuiFactory(SimpleMixerChannelGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef SimpleMixerChannelGuiFactory_base _base_class;

	inline SimpleMixerChannelGuiFactory() : Arts::Object(_Creator), _cache(0) {}
	inline SimpleMixerChannelGuiFactory(const Arts::SubClass& s) :
		Arts::Object(SimpleMixerChannelGuiFactory_base::_create(s.string())), _cache(0) {}
	inline SimpleMixerChannelGuiFactory(const Arts::Reference &r) :
		Arts::Object(r.isString()?(SimpleMixerChannelGuiFactory_base::_fromString(r.string())):(SimpleMixerChannelGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline SimpleMixerChannelGuiFactory(const Arts::DynamicCast& c) : Arts::Object(SimpleMixerChannelGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline SimpleMixerChannelGuiFactory(const SimpleMixerChannelGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline SimpleMixerChannelGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static SimpleMixerChannelGuiFactory null() {return SimpleMixerChannelGuiFactory((SimpleMixerChannelGuiFactory_base*)0);}
	inline static SimpleMixerChannelGuiFactory _from_base(SimpleMixerChannelGuiFactory_base* b) {return SimpleMixerChannelGuiFactory(b);}
	inline SimpleMixerChannelGuiFactory& operator=(const SimpleMixerChannelGuiFactory& 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 SimpleMixerChannelGuiFactory_base* _base() {return _cache?_cache:_method_call();}

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

class ARTS_EXPORT MonoSimpleMixerChannel_base : virtual public Arts::Environment::MixerChannel_base {
public:
	static unsigned long _IID; // interface ID

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

	static MonoSimpleMixerChannel_base *_fromDynamicCast(const Arts::Object& object);
	inline MonoSimpleMixerChannel_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::Synth_STD_EQUALIZER equalizer() = 0;
	virtual Arts::StereoEffectStack insertEffects() = 0;
	virtual float gain() = 0;
	virtual void gain(float newValue) = 0;
	virtual float pan() = 0;
	virtual void pan(float newValue) = 0;
	virtual float volume() = 0;
	virtual void volume(float newValue) = 0;
};

class ARTS_EXPORT MonoSimpleMixerChannel_stub : virtual public MonoSimpleMixerChannel_base, virtual public Arts::Environment::MixerChannel_stub {
protected:
	MonoSimpleMixerChannel_stub();

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

	Arts::Synth_STD_EQUALIZER equalizer();
	Arts::StereoEffectStack insertEffects();
	float gain();
	void gain(float newValue);
	float pan();
	void pan(float newValue);
	float volume();
	void volume(float newValue);
};

class ARTS_EXPORT MonoSimpleMixerChannel_skel : virtual public MonoSimpleMixerChannel_base, virtual public Arts::Environment::MixerChannel_skel {
protected:
	// emitters for change notifications
	inline void gain_changed(float newValue) {
		_emit_changed("gain_changed",newValue);
	}
	inline void pan_changed(float newValue) {
		_emit_changed("pan_changed",newValue);
	}
	inline void volume_changed(float newValue) {
		_emit_changed("volume_changed",newValue);
	}

public:
	MonoSimpleMixerChannel_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 MonoSimpleMixerChannel : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	MonoSimpleMixerChannel_base *_cache;
	inline MonoSimpleMixerChannel_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(MonoSimpleMixerChannel_base *)_pool->base->_cast(MonoSimpleMixerChannel_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline MonoSimpleMixerChannel(MonoSimpleMixerChannel_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef MonoSimpleMixerChannel_base _base_class;

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

	inline std::string name();
	inline void name(const std::string& _newValue);
	inline Arts::AutoSuspendState autoSuspend();
	inline void start();
	inline void stop();
	inline void streamInit();
	inline void streamStart();
	inline void streamEnd();
	inline Arts::Synth_STD_EQUALIZER equalizer();
	inline Arts::StereoEffectStack insertEffects();
	inline float gain();
	inline void gain(float _newValue);
	inline float pan();
	inline void pan(float _newValue);
	inline float volume();
	inline void volume(float _newValue);
};

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

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

	static MonoSimpleMixerChannelGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
	inline MonoSimpleMixerChannelGuiFactory_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 MonoSimpleMixerChannelGuiFactory_stub : virtual public MonoSimpleMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	MonoSimpleMixerChannelGuiFactory_stub();

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

};

class ARTS_EXPORT MonoSimpleMixerChannelGuiFactory_skel : virtual public MonoSimpleMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	MonoSimpleMixerChannelGuiFactory_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 MonoSimpleMixerChannelGuiFactory : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	MonoSimpleMixerChannelGuiFactory_base *_cache;
	inline MonoSimpleMixerChannelGuiFactory_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(MonoSimpleMixerChannelGuiFactory_base *)_pool->base->_cast(MonoSimpleMixerChannelGuiFactory_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline MonoSimpleMixerChannelGuiFactory(MonoSimpleMixerChannelGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef MonoSimpleMixerChannelGuiFactory_base _base_class;

	inline MonoSimpleMixerChannelGuiFactory() : Arts::Object(_Creator), _cache(0) {}
	inline MonoSimpleMixerChannelGuiFactory(const Arts::SubClass& s) :
		Arts::Object(MonoSimpleMixerChannelGuiFactory_base::_create(s.string())), _cache(0) {}
	inline MonoSimpleMixerChannelGuiFactory(const Arts::Reference &r) :
		Arts::Object(r.isString()?(MonoSimpleMixerChannelGuiFactory_base::_fromString(r.string())):(MonoSimpleMixerChannelGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline MonoSimpleMixerChannelGuiFactory(const Arts::DynamicCast& c) : Arts::Object(MonoSimpleMixerChannelGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline MonoSimpleMixerChannelGuiFactory(const MonoSimpleMixerChannelGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline MonoSimpleMixerChannelGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static MonoSimpleMixerChannelGuiFactory null() {return MonoSimpleMixerChannelGuiFactory((MonoSimpleMixerChannelGuiFactory_base*)0);}
	inline static MonoSimpleMixerChannelGuiFactory _from_base(MonoSimpleMixerChannelGuiFactory_base* b) {return MonoSimpleMixerChannelGuiFactory(b);}
	inline MonoSimpleMixerChannelGuiFactory& operator=(const MonoSimpleMixerChannelGuiFactory& 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 MonoSimpleMixerChannelGuiFactory_base* _base() {return _cache?_cache:_method_call();}

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

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

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

	static Synth_AUX_BUS_base *_fromDynamicCast(const Arts::Object& object);
	inline Synth_AUX_BUS_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 level() = 0;
	virtual void level(float newValue) = 0;
	virtual long channel() = 0;
	virtual void channel(long newValue) = 0;
};

class ARTS_EXPORT Synth_AUX_BUS_stub : virtual public Synth_AUX_BUS_base, virtual public Arts::SynthModule_stub {
protected:
	Synth_AUX_BUS_stub();

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

	float level();
	void level(float newValue);
	long channel();
	void channel(long newValue);
};

class ARTS_EXPORT Synth_AUX_BUS_skel : virtual public Synth_AUX_BUS_base, virtual public Arts::SynthModule_skel {
protected:
	// variables for streams
	float *invalue;                           // incoming stream

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

public:
	Synth_AUX_BUS_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_AUX_BUS : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	Synth_AUX_BUS_base *_cache;
	inline Synth_AUX_BUS_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(Synth_AUX_BUS_base *)_pool->base->_cast(Synth_AUX_BUS_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline Synth_AUX_BUS(Synth_AUX_BUS_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef Synth_AUX_BUS_base _base_class;

	inline Synth_AUX_BUS() : Arts::Object(_Creator), _cache(0) {}
	inline Synth_AUX_BUS(const Arts::SubClass& s) :
		Arts::Object(Synth_AUX_BUS_base::_create(s.string())), _cache(0) {}
	inline Synth_AUX_BUS(const Arts::Reference &r) :
		Arts::Object(r.isString()?(Synth_AUX_BUS_base::_fromString(r.string())):(Synth_AUX_BUS_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline Synth_AUX_BUS(const Arts::DynamicCast& c) : Arts::Object(Synth_AUX_BUS_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline Synth_AUX_BUS(const Synth_AUX_BUS& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline Synth_AUX_BUS(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static Synth_AUX_BUS null() {return Synth_AUX_BUS((Synth_AUX_BUS_base*)0);}
	inline static Synth_AUX_BUS _from_base(Synth_AUX_BUS_base* b) {return Synth_AUX_BUS(b);}
	inline Synth_AUX_BUS& operator=(const Synth_AUX_BUS& target) {
		if (_pool == target._pool) return *this;
		_pool->Dec();
		_pool = target._pool;
		_cache = target._cache;
		_pool->Inc();
		return *this;
	}
	inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
	inline Synth_AUX_BUS_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 level();
	inline void level(float _newValue);
	inline long channel();
	inline void channel(long _newValue);
};

class ARTS_EXPORT LittleStereoMixerChannel_base : virtual public Arts::Environment::MixerChannel_base {
public:
	static unsigned long _IID; // interface ID

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

	static LittleStereoMixerChannel_base *_fromDynamicCast(const Arts::Object& object);
	inline LittleStereoMixerChannel_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 volume() = 0;
	virtual void volume(float newValue) = 0;
	virtual float balance() = 0;
	virtual void balance(float newValue) = 0;
};

class ARTS_EXPORT LittleStereoMixerChannel_stub : virtual public LittleStereoMixerChannel_base, virtual public Arts::Environment::MixerChannel_stub {
protected:
	LittleStereoMixerChannel_stub();

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

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

class ARTS_EXPORT LittleStereoMixerChannel_skel : virtual public LittleStereoMixerChannel_base, virtual public Arts::Environment::MixerChannel_skel {
protected:
	// emitters for change notifications
	inline void volume_changed(float newValue) {
		_emit_changed("volume_changed",newValue);
	}
	inline void balance_changed(float newValue) {
		_emit_changed("balance_changed",newValue);
	}

public:
	LittleStereoMixerChannel_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 LittleStereoMixerChannel : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	LittleStereoMixerChannel_base *_cache;
	inline LittleStereoMixerChannel_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(LittleStereoMixerChannel_base *)_pool->base->_cast(LittleStereoMixerChannel_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline LittleStereoMixerChannel(LittleStereoMixerChannel_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef LittleStereoMixerChannel_base _base_class;

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

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

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

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

	static LittleStereoMixerChannelGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
	inline LittleStereoMixerChannelGuiFactory_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 LittleStereoMixerChannelGuiFactory_stub : virtual public LittleStereoMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_stub {
protected:
	LittleStereoMixerChannelGuiFactory_stub();

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

};

class ARTS_EXPORT LittleStereoMixerChannelGuiFactory_skel : virtual public LittleStereoMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_skel {
public:
	LittleStereoMixerChannelGuiFactory_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 LittleStereoMixerChannelGuiFactory : public Arts::Object {
private:
	static Arts::Object_base* _Creator();
	LittleStereoMixerChannelGuiFactory_base *_cache;
	inline LittleStereoMixerChannelGuiFactory_base *_method_call() {
		_pool->checkcreate();
		if(_pool->base) {
			_cache=(LittleStereoMixerChannelGuiFactory_base *)_pool->base->_cast(LittleStereoMixerChannelGuiFactory_base::_IID);
			assert(_cache);
		}
		return _cache;
	}

protected:
	inline LittleStereoMixerChannelGuiFactory(LittleStereoMixerChannelGuiFactory_base* b) : Arts::Object(b), _cache(0) {}


public:
	typedef LittleStereoMixerChannelGuiFactory_base _base_class;

	inline LittleStereoMixerChannelGuiFactory() : Arts::Object(_Creator), _cache(0) {}
	inline LittleStereoMixerChannelGuiFactory(const Arts::SubClass& s) :
		Arts::Object(LittleStereoMixerChannelGuiFactory_base::_create(s.string())), _cache(0) {}
	inline LittleStereoMixerChannelGuiFactory(const Arts::Reference &r) :
		Arts::Object(r.isString()?(LittleStereoMixerChannelGuiFactory_base::_fromString(r.string())):(LittleStereoMixerChannelGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
	inline LittleStereoMixerChannelGuiFactory(const Arts::DynamicCast& c) : Arts::Object(LittleStereoMixerChannelGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
	inline LittleStereoMixerChannelGuiFactory(const LittleStereoMixerChannelGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
	inline LittleStereoMixerChannelGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
	inline static LittleStereoMixerChannelGuiFactory null() {return LittleStereoMixerChannelGuiFactory((LittleStereoMixerChannelGuiFactory_base*)0);}
	inline static LittleStereoMixerChannelGuiFactory _from_base(LittleStereoMixerChannelGuiFactory_base* b) {return LittleStereoMixerChannelGuiFactory(b);}
	inline LittleStereoMixerChannelGuiFactory& operator=(const LittleStereoMixerChannelGuiFactory& 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 LittleStereoMixerChannelGuiFactory_base* _base() {return _cache?_cache:_method_call();}

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

}
// Forward wrapper calls to _base classes:

inline std::string Arts::SimpleMixerChannel::name()
{
	return _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name():static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name();
}

inline void Arts::SimpleMixerChannel::name(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name(_newValue):static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name(_newValue);
}

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

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

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

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

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

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

inline Arts::Synth_STD_EQUALIZER Arts::SimpleMixerChannel::equalizerLeft()
{
	return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->equalizerLeft():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->equalizerLeft();
}

inline Arts::Synth_STD_EQUALIZER Arts::SimpleMixerChannel::equalizerRight()
{
	return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->equalizerRight():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->equalizerRight();
}

inline Arts::StereoEffectStack Arts::SimpleMixerChannel::insertEffects()
{
	return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->insertEffects():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->insertEffects();
}

inline float Arts::SimpleMixerChannel::gainLeft()
{
	return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->gainLeft():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->gainLeft();
}

inline void Arts::SimpleMixerChannel::gainLeft(float _newValue)
{
	 _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->gainLeft(_newValue):static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->gainLeft(_newValue);
}

inline float Arts::SimpleMixerChannel::gainRight()
{
	return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->gainRight():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->gainRight();
}

inline void Arts::SimpleMixerChannel::gainRight(float _newValue)
{
	 _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->gainRight(_newValue):static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->gainRight(_newValue);
}

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

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

inline float Arts::SimpleMixerChannel::volumeLeft()
{
	return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->volumeLeft():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->volumeLeft();
}

inline void Arts::SimpleMixerChannel::volumeLeft(float _newValue)
{
	 _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->volumeLeft(_newValue):static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->volumeLeft(_newValue);
}

inline float Arts::SimpleMixerChannel::volumeRight()
{
	return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->volumeRight():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->volumeRight();
}

inline void Arts::SimpleMixerChannel::volumeRight(float _newValue)
{
	 _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->volumeRight(_newValue):static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->volumeRight(_newValue);
}

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

inline std::string Arts::MonoSimpleMixerChannel::name()
{
	return _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name():static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name();
}

inline void Arts::MonoSimpleMixerChannel::name(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name(_newValue):static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name(_newValue);
}

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

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

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

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

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

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

inline Arts::Synth_STD_EQUALIZER Arts::MonoSimpleMixerChannel::equalizer()
{
	return _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->equalizer():static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->equalizer();
}

inline Arts::StereoEffectStack Arts::MonoSimpleMixerChannel::insertEffects()
{
	return _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->insertEffects():static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->insertEffects();
}

inline float Arts::MonoSimpleMixerChannel::gain()
{
	return _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->gain():static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->gain();
}

inline void Arts::MonoSimpleMixerChannel::gain(float _newValue)
{
	 _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->gain(_newValue):static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->gain(_newValue);
}

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

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

inline float Arts::MonoSimpleMixerChannel::volume()
{
	return _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->volume():static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->volume();
}

inline void Arts::MonoSimpleMixerChannel::volume(float _newValue)
{
	 _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->volume(_newValue):static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->volume(_newValue);
}

inline Arts::Widget Arts::MonoSimpleMixerChannelGuiFactory::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_AUX_BUS::autoSuspend()
{
	return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
}

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

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

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

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

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

inline float Arts::Synth_AUX_BUS::level()
{
	return _cache?static_cast<Arts::Synth_AUX_BUS_base*>(_cache)->level():static_cast<Arts::Synth_AUX_BUS_base*>(_method_call())->level();
}

inline void Arts::Synth_AUX_BUS::level(float _newValue)
{
	 _cache?static_cast<Arts::Synth_AUX_BUS_base*>(_cache)->level(_newValue):static_cast<Arts::Synth_AUX_BUS_base*>(_method_call())->level(_newValue);
}

inline long Arts::Synth_AUX_BUS::channel()
{
	return _cache?static_cast<Arts::Synth_AUX_BUS_base*>(_cache)->channel():static_cast<Arts::Synth_AUX_BUS_base*>(_method_call())->channel();
}

inline void Arts::Synth_AUX_BUS::channel(long _newValue)
{
	 _cache?static_cast<Arts::Synth_AUX_BUS_base*>(_cache)->channel(_newValue):static_cast<Arts::Synth_AUX_BUS_base*>(_method_call())->channel(_newValue);
}

inline std::string Arts::LittleStereoMixerChannel::name()
{
	return _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name():static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name();
}

inline void Arts::LittleStereoMixerChannel::name(const std::string& _newValue)
{
	 _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name(_newValue):static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name(_newValue);
}

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

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

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

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

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

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

inline float Arts::LittleStereoMixerChannel::volume()
{
	return _cache?static_cast<Arts::LittleStereoMixerChannel_base*>(_cache)->volume():static_cast<Arts::LittleStereoMixerChannel_base*>(_method_call())->volume();
}

inline void Arts::LittleStereoMixerChannel::volume(float _newValue)
{
	 _cache?static_cast<Arts::LittleStereoMixerChannel_base*>(_cache)->volume(_newValue):static_cast<Arts::LittleStereoMixerChannel_base*>(_method_call())->volume(_newValue);
}

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

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

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

#endif /* ARTSMODULESMIXERS_H */
