home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / arts / artsmodulesmixers.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-10-24  |  43.9 KB  |  1,134 lines
  1. /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
  2.  
  3. #ifndef ARTSMODULESMIXERS_H
  4. #define ARTSMODULESMIXERS_H
  5.  
  6. #include "common.h"
  7.  
  8. #include "arts_export.h"
  9.  
  10. // includes of other idl definitions
  11. #include "artsflow.h"
  12. #include "artsmodulessynth.h"
  13. #include "artsmidi.h"
  14. #include "artsmodulescommon.h"
  15. #include "artsgui.h"
  16.  
  17. namespace Arts {
  18. class SimpleMixerChannel;
  19. class SimpleMixerChannelGuiFactory;
  20. class MonoSimpleMixerChannel;
  21. class MonoSimpleMixerChannelGuiFactory;
  22. class Synth_AUX_BUS;
  23. class LittleStereoMixerChannel;
  24. class LittleStereoMixerChannelGuiFactory;
  25.  
  26. class ARTS_EXPORT SimpleMixerChannel_base : virtual public Arts::Environment::MixerChannel_base {
  27. public:
  28.     static unsigned long _IID; // interface ID
  29.  
  30.     static SimpleMixerChannel_base *_create(const std::string& subClass = "Arts::SimpleMixerChannel");
  31.     static SimpleMixerChannel_base *_fromString(const std::string& objectref);
  32.     static SimpleMixerChannel_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  33.  
  34.     static SimpleMixerChannel_base *_fromDynamicCast(const Arts::Object& object);
  35.     inline SimpleMixerChannel_base *_copy() {
  36.         assert(_refCnt > 0);
  37.         _refCnt++;
  38.         return this;
  39.     }
  40.  
  41.     virtual std::vector<std::string> _defaultPortsIn() const;
  42.     virtual std::vector<std::string> _defaultPortsOut() const;
  43.  
  44.     void *_cast(unsigned long iid);
  45.  
  46.     virtual Arts::Synth_STD_EQUALIZER equalizerLeft() = 0;
  47.     virtual Arts::Synth_STD_EQUALIZER equalizerRight() = 0;
  48.     virtual Arts::StereoEffectStack insertEffects() = 0;
  49.     virtual float gainLeft() = 0;
  50.     virtual void gainLeft(float newValue) = 0;
  51.     virtual float gainRight() = 0;
  52.     virtual void gainRight(float newValue) = 0;
  53.     virtual float pan() = 0;
  54.     virtual void pan(float newValue) = 0;
  55.     virtual float volumeLeft() = 0;
  56.     virtual void volumeLeft(float newValue) = 0;
  57.     virtual float volumeRight() = 0;
  58.     virtual void volumeRight(float newValue) = 0;
  59. };
  60.  
  61. class ARTS_EXPORT SimpleMixerChannel_stub : virtual public SimpleMixerChannel_base, virtual public Arts::Environment::MixerChannel_stub {
  62. protected:
  63.     SimpleMixerChannel_stub();
  64.  
  65. public:
  66.     SimpleMixerChannel_stub(Arts::Connection *connection, long objectID);
  67.  
  68.     Arts::Synth_STD_EQUALIZER equalizerLeft();
  69.     Arts::Synth_STD_EQUALIZER equalizerRight();
  70.     Arts::StereoEffectStack insertEffects();
  71.     float gainLeft();
  72.     void gainLeft(float newValue);
  73.     float gainRight();
  74.     void gainRight(float newValue);
  75.     float pan();
  76.     void pan(float newValue);
  77.     float volumeLeft();
  78.     void volumeLeft(float newValue);
  79.     float volumeRight();
  80.     void volumeRight(float newValue);
  81. };
  82.  
  83. class ARTS_EXPORT SimpleMixerChannel_skel : virtual public SimpleMixerChannel_base, virtual public Arts::Environment::MixerChannel_skel {
  84. protected:
  85.     // emitters for change notifications
  86.     inline void gainLeft_changed(float newValue) {
  87.         _emit_changed("gainLeft_changed",newValue);
  88.     }
  89.     inline void gainRight_changed(float newValue) {
  90.         _emit_changed("gainRight_changed",newValue);
  91.     }
  92.     inline void pan_changed(float newValue) {
  93.         _emit_changed("pan_changed",newValue);
  94.     }
  95.     inline void volumeLeft_changed(float newValue) {
  96.         _emit_changed("volumeLeft_changed",newValue);
  97.     }
  98.     inline void volumeRight_changed(float newValue) {
  99.         _emit_changed("volumeRight_changed",newValue);
  100.     }
  101.  
  102. public:
  103.     SimpleMixerChannel_skel();
  104.  
  105.     static std::string _interfaceNameSkel();
  106.     std::string _interfaceName();
  107.     bool _isCompatibleWith(const std::string& interfacename);
  108.     void _buildMethodTable();
  109.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  110. };
  111.  
  112. }
  113. #include "reference.h"
  114. namespace Arts {
  115. class ARTS_EXPORT SimpleMixerChannel : public Arts::Object {
  116. private:
  117.     static Arts::Object_base* _Creator();
  118.     SimpleMixerChannel_base *_cache;
  119.     inline SimpleMixerChannel_base *_method_call() {
  120.         _pool->checkcreate();
  121.         if(_pool->base) {
  122.             _cache=(SimpleMixerChannel_base *)_pool->base->_cast(SimpleMixerChannel_base::_IID);
  123.             assert(_cache);
  124.         }
  125.         return _cache;
  126.     }
  127.  
  128. protected:
  129.     inline SimpleMixerChannel(SimpleMixerChannel_base* b) : Arts::Object(b), _cache(0) {}
  130.  
  131.  
  132. public:
  133.     typedef SimpleMixerChannel_base _base_class;
  134.  
  135.     inline SimpleMixerChannel() : Arts::Object(_Creator), _cache(0) {}
  136.     inline SimpleMixerChannel(const Arts::SubClass& s) :
  137.         Arts::Object(SimpleMixerChannel_base::_create(s.string())), _cache(0) {}
  138.     inline SimpleMixerChannel(const Arts::Reference &r) :
  139.         Arts::Object(r.isString()?(SimpleMixerChannel_base::_fromString(r.string())):(SimpleMixerChannel_base::_fromReference(r.reference(),true))), _cache(0) {}
  140.     inline SimpleMixerChannel(const Arts::DynamicCast& c) : Arts::Object(SimpleMixerChannel_base::_fromDynamicCast(c.object())), _cache(0) {}
  141.     inline SimpleMixerChannel(const SimpleMixerChannel& target) : Arts::Object(target._pool), _cache(target._cache) {}
  142.     inline SimpleMixerChannel(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  143.     inline static SimpleMixerChannel null() {return SimpleMixerChannel((SimpleMixerChannel_base*)0);}
  144.     inline static SimpleMixerChannel _from_base(SimpleMixerChannel_base* b) {return SimpleMixerChannel(b);}
  145.     inline SimpleMixerChannel& operator=(const SimpleMixerChannel& target) {
  146.         if (_pool == target._pool) return *this;
  147.         _pool->Dec();
  148.         _pool = target._pool;
  149.         _cache = target._cache;
  150.         _pool->Inc();
  151.         return *this;
  152.     }
  153.     inline operator Arts::Environment::MixerChannel() const { return Arts::Environment::MixerChannel(*_pool); }
  154.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  155.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  156.     inline SimpleMixerChannel_base* _base() {return _cache?_cache:_method_call();}
  157.  
  158.     inline std::string name();
  159.     inline void name(const std::string& _newValue);
  160.     inline Arts::AutoSuspendState autoSuspend();
  161.     inline void start();
  162.     inline void stop();
  163.     inline void streamInit();
  164.     inline void streamStart();
  165.     inline void streamEnd();
  166.     inline Arts::Synth_STD_EQUALIZER equalizerLeft();
  167.     inline Arts::Synth_STD_EQUALIZER equalizerRight();
  168.     inline Arts::StereoEffectStack insertEffects();
  169.     inline float gainLeft();
  170.     inline void gainLeft(float _newValue);
  171.     inline float gainRight();
  172.     inline void gainRight(float _newValue);
  173.     inline float pan();
  174.     inline void pan(float _newValue);
  175.     inline float volumeLeft();
  176.     inline void volumeLeft(float _newValue);
  177.     inline float volumeRight();
  178.     inline void volumeRight(float _newValue);
  179. };
  180.  
  181. class ARTS_EXPORT SimpleMixerChannelGuiFactory_base : virtual public Arts::GuiFactory_base {
  182. public:
  183.     static unsigned long _IID; // interface ID
  184.  
  185.     static SimpleMixerChannelGuiFactory_base *_create(const std::string& subClass = "Arts::SimpleMixerChannelGuiFactory");
  186.     static SimpleMixerChannelGuiFactory_base *_fromString(const std::string& objectref);
  187.     static SimpleMixerChannelGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  188.  
  189.     static SimpleMixerChannelGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  190.     inline SimpleMixerChannelGuiFactory_base *_copy() {
  191.         assert(_refCnt > 0);
  192.         _refCnt++;
  193.         return this;
  194.     }
  195.  
  196.     virtual std::vector<std::string> _defaultPortsIn() const;
  197.     virtual std::vector<std::string> _defaultPortsOut() const;
  198.  
  199.     void *_cast(unsigned long iid);
  200.  
  201. };
  202.  
  203. class ARTS_EXPORT SimpleMixerChannelGuiFactory_stub : virtual public SimpleMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_stub {
  204. protected:
  205.     SimpleMixerChannelGuiFactory_stub();
  206.  
  207. public:
  208.     SimpleMixerChannelGuiFactory_stub(Arts::Connection *connection, long objectID);
  209.  
  210. };
  211.  
  212. class ARTS_EXPORT SimpleMixerChannelGuiFactory_skel : virtual public SimpleMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_skel {
  213. public:
  214.     SimpleMixerChannelGuiFactory_skel();
  215.  
  216.     static std::string _interfaceNameSkel();
  217.     std::string _interfaceName();
  218.     bool _isCompatibleWith(const std::string& interfacename);
  219.     void _buildMethodTable();
  220.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  221. };
  222.  
  223. }
  224. #include "reference.h"
  225. namespace Arts {
  226. class ARTS_EXPORT SimpleMixerChannelGuiFactory : public Arts::Object {
  227. private:
  228.     static Arts::Object_base* _Creator();
  229.     SimpleMixerChannelGuiFactory_base *_cache;
  230.     inline SimpleMixerChannelGuiFactory_base *_method_call() {
  231.         _pool->checkcreate();
  232.         if(_pool->base) {
  233.             _cache=(SimpleMixerChannelGuiFactory_base *)_pool->base->_cast(SimpleMixerChannelGuiFactory_base::_IID);
  234.             assert(_cache);
  235.         }
  236.         return _cache;
  237.     }
  238.  
  239. protected:
  240.     inline SimpleMixerChannelGuiFactory(SimpleMixerChannelGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  241.  
  242.  
  243. public:
  244.     typedef SimpleMixerChannelGuiFactory_base _base_class;
  245.  
  246.     inline SimpleMixerChannelGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  247.     inline SimpleMixerChannelGuiFactory(const Arts::SubClass& s) :
  248.         Arts::Object(SimpleMixerChannelGuiFactory_base::_create(s.string())), _cache(0) {}
  249.     inline SimpleMixerChannelGuiFactory(const Arts::Reference &r) :
  250.         Arts::Object(r.isString()?(SimpleMixerChannelGuiFactory_base::_fromString(r.string())):(SimpleMixerChannelGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  251.     inline SimpleMixerChannelGuiFactory(const Arts::DynamicCast& c) : Arts::Object(SimpleMixerChannelGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  252.     inline SimpleMixerChannelGuiFactory(const SimpleMixerChannelGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  253.     inline SimpleMixerChannelGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  254.     inline static SimpleMixerChannelGuiFactory null() {return SimpleMixerChannelGuiFactory((SimpleMixerChannelGuiFactory_base*)0);}
  255.     inline static SimpleMixerChannelGuiFactory _from_base(SimpleMixerChannelGuiFactory_base* b) {return SimpleMixerChannelGuiFactory(b);}
  256.     inline SimpleMixerChannelGuiFactory& operator=(const SimpleMixerChannelGuiFactory& target) {
  257.         if (_pool == target._pool) return *this;
  258.         _pool->Dec();
  259.         _pool = target._pool;
  260.         _cache = target._cache;
  261.         _pool->Inc();
  262.         return *this;
  263.     }
  264.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  265.     inline SimpleMixerChannelGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  266.  
  267.     inline Arts::Widget createGui(Arts::Object runningObject);
  268. };
  269.  
  270. class ARTS_EXPORT MonoSimpleMixerChannel_base : virtual public Arts::Environment::MixerChannel_base {
  271. public:
  272.     static unsigned long _IID; // interface ID
  273.  
  274.     static MonoSimpleMixerChannel_base *_create(const std::string& subClass = "Arts::MonoSimpleMixerChannel");
  275.     static MonoSimpleMixerChannel_base *_fromString(const std::string& objectref);
  276.     static MonoSimpleMixerChannel_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  277.  
  278.     static MonoSimpleMixerChannel_base *_fromDynamicCast(const Arts::Object& object);
  279.     inline MonoSimpleMixerChannel_base *_copy() {
  280.         assert(_refCnt > 0);
  281.         _refCnt++;
  282.         return this;
  283.     }
  284.  
  285.     virtual std::vector<std::string> _defaultPortsIn() const;
  286.     virtual std::vector<std::string> _defaultPortsOut() const;
  287.  
  288.     void *_cast(unsigned long iid);
  289.  
  290.     virtual Arts::Synth_STD_EQUALIZER equalizer() = 0;
  291.     virtual Arts::StereoEffectStack insertEffects() = 0;
  292.     virtual float gain() = 0;
  293.     virtual void gain(float newValue) = 0;
  294.     virtual float pan() = 0;
  295.     virtual void pan(float newValue) = 0;
  296.     virtual float volume() = 0;
  297.     virtual void volume(float newValue) = 0;
  298. };
  299.  
  300. class ARTS_EXPORT MonoSimpleMixerChannel_stub : virtual public MonoSimpleMixerChannel_base, virtual public Arts::Environment::MixerChannel_stub {
  301. protected:
  302.     MonoSimpleMixerChannel_stub();
  303.  
  304. public:
  305.     MonoSimpleMixerChannel_stub(Arts::Connection *connection, long objectID);
  306.  
  307.     Arts::Synth_STD_EQUALIZER equalizer();
  308.     Arts::StereoEffectStack insertEffects();
  309.     float gain();
  310.     void gain(float newValue);
  311.     float pan();
  312.     void pan(float newValue);
  313.     float volume();
  314.     void volume(float newValue);
  315. };
  316.  
  317. class ARTS_EXPORT MonoSimpleMixerChannel_skel : virtual public MonoSimpleMixerChannel_base, virtual public Arts::Environment::MixerChannel_skel {
  318. protected:
  319.     // emitters for change notifications
  320.     inline void gain_changed(float newValue) {
  321.         _emit_changed("gain_changed",newValue);
  322.     }
  323.     inline void pan_changed(float newValue) {
  324.         _emit_changed("pan_changed",newValue);
  325.     }
  326.     inline void volume_changed(float newValue) {
  327.         _emit_changed("volume_changed",newValue);
  328.     }
  329.  
  330. public:
  331.     MonoSimpleMixerChannel_skel();
  332.  
  333.     static std::string _interfaceNameSkel();
  334.     std::string _interfaceName();
  335.     bool _isCompatibleWith(const std::string& interfacename);
  336.     void _buildMethodTable();
  337.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  338. };
  339.  
  340. }
  341. #include "reference.h"
  342. namespace Arts {
  343. class ARTS_EXPORT MonoSimpleMixerChannel : public Arts::Object {
  344. private:
  345.     static Arts::Object_base* _Creator();
  346.     MonoSimpleMixerChannel_base *_cache;
  347.     inline MonoSimpleMixerChannel_base *_method_call() {
  348.         _pool->checkcreate();
  349.         if(_pool->base) {
  350.             _cache=(MonoSimpleMixerChannel_base *)_pool->base->_cast(MonoSimpleMixerChannel_base::_IID);
  351.             assert(_cache);
  352.         }
  353.         return _cache;
  354.     }
  355.  
  356. protected:
  357.     inline MonoSimpleMixerChannel(MonoSimpleMixerChannel_base* b) : Arts::Object(b), _cache(0) {}
  358.  
  359.  
  360. public:
  361.     typedef MonoSimpleMixerChannel_base _base_class;
  362.  
  363.     inline MonoSimpleMixerChannel() : Arts::Object(_Creator), _cache(0) {}
  364.     inline MonoSimpleMixerChannel(const Arts::SubClass& s) :
  365.         Arts::Object(MonoSimpleMixerChannel_base::_create(s.string())), _cache(0) {}
  366.     inline MonoSimpleMixerChannel(const Arts::Reference &r) :
  367.         Arts::Object(r.isString()?(MonoSimpleMixerChannel_base::_fromString(r.string())):(MonoSimpleMixerChannel_base::_fromReference(r.reference(),true))), _cache(0) {}
  368.     inline MonoSimpleMixerChannel(const Arts::DynamicCast& c) : Arts::Object(MonoSimpleMixerChannel_base::_fromDynamicCast(c.object())), _cache(0) {}
  369.     inline MonoSimpleMixerChannel(const MonoSimpleMixerChannel& target) : Arts::Object(target._pool), _cache(target._cache) {}
  370.     inline MonoSimpleMixerChannel(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  371.     inline static MonoSimpleMixerChannel null() {return MonoSimpleMixerChannel((MonoSimpleMixerChannel_base*)0);}
  372.     inline static MonoSimpleMixerChannel _from_base(MonoSimpleMixerChannel_base* b) {return MonoSimpleMixerChannel(b);}
  373.     inline MonoSimpleMixerChannel& operator=(const MonoSimpleMixerChannel& target) {
  374.         if (_pool == target._pool) return *this;
  375.         _pool->Dec();
  376.         _pool = target._pool;
  377.         _cache = target._cache;
  378.         _pool->Inc();
  379.         return *this;
  380.     }
  381.     inline operator Arts::Environment::MixerChannel() const { return Arts::Environment::MixerChannel(*_pool); }
  382.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  383.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  384.     inline MonoSimpleMixerChannel_base* _base() {return _cache?_cache:_method_call();}
  385.  
  386.     inline std::string name();
  387.     inline void name(const std::string& _newValue);
  388.     inline Arts::AutoSuspendState autoSuspend();
  389.     inline void start();
  390.     inline void stop();
  391.     inline void streamInit();
  392.     inline void streamStart();
  393.     inline void streamEnd();
  394.     inline Arts::Synth_STD_EQUALIZER equalizer();
  395.     inline Arts::StereoEffectStack insertEffects();
  396.     inline float gain();
  397.     inline void gain(float _newValue);
  398.     inline float pan();
  399.     inline void pan(float _newValue);
  400.     inline float volume();
  401.     inline void volume(float _newValue);
  402. };
  403.  
  404. class ARTS_EXPORT MonoSimpleMixerChannelGuiFactory_base : virtual public Arts::GuiFactory_base {
  405. public:
  406.     static unsigned long _IID; // interface ID
  407.  
  408.     static MonoSimpleMixerChannelGuiFactory_base *_create(const std::string& subClass = "Arts::MonoSimpleMixerChannelGuiFactory");
  409.     static MonoSimpleMixerChannelGuiFactory_base *_fromString(const std::string& objectref);
  410.     static MonoSimpleMixerChannelGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  411.  
  412.     static MonoSimpleMixerChannelGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  413.     inline MonoSimpleMixerChannelGuiFactory_base *_copy() {
  414.         assert(_refCnt > 0);
  415.         _refCnt++;
  416.         return this;
  417.     }
  418.  
  419.     virtual std::vector<std::string> _defaultPortsIn() const;
  420.     virtual std::vector<std::string> _defaultPortsOut() const;
  421.  
  422.     void *_cast(unsigned long iid);
  423.  
  424. };
  425.  
  426. class ARTS_EXPORT MonoSimpleMixerChannelGuiFactory_stub : virtual public MonoSimpleMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_stub {
  427. protected:
  428.     MonoSimpleMixerChannelGuiFactory_stub();
  429.  
  430. public:
  431.     MonoSimpleMixerChannelGuiFactory_stub(Arts::Connection *connection, long objectID);
  432.  
  433. };
  434.  
  435. class ARTS_EXPORT MonoSimpleMixerChannelGuiFactory_skel : virtual public MonoSimpleMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_skel {
  436. public:
  437.     MonoSimpleMixerChannelGuiFactory_skel();
  438.  
  439.     static std::string _interfaceNameSkel();
  440.     std::string _interfaceName();
  441.     bool _isCompatibleWith(const std::string& interfacename);
  442.     void _buildMethodTable();
  443.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  444. };
  445.  
  446. }
  447. #include "reference.h"
  448. namespace Arts {
  449. class ARTS_EXPORT MonoSimpleMixerChannelGuiFactory : public Arts::Object {
  450. private:
  451.     static Arts::Object_base* _Creator();
  452.     MonoSimpleMixerChannelGuiFactory_base *_cache;
  453.     inline MonoSimpleMixerChannelGuiFactory_base *_method_call() {
  454.         _pool->checkcreate();
  455.         if(_pool->base) {
  456.             _cache=(MonoSimpleMixerChannelGuiFactory_base *)_pool->base->_cast(MonoSimpleMixerChannelGuiFactory_base::_IID);
  457.             assert(_cache);
  458.         }
  459.         return _cache;
  460.     }
  461.  
  462. protected:
  463.     inline MonoSimpleMixerChannelGuiFactory(MonoSimpleMixerChannelGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  464.  
  465.  
  466. public:
  467.     typedef MonoSimpleMixerChannelGuiFactory_base _base_class;
  468.  
  469.     inline MonoSimpleMixerChannelGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  470.     inline MonoSimpleMixerChannelGuiFactory(const Arts::SubClass& s) :
  471.         Arts::Object(MonoSimpleMixerChannelGuiFactory_base::_create(s.string())), _cache(0) {}
  472.     inline MonoSimpleMixerChannelGuiFactory(const Arts::Reference &r) :
  473.         Arts::Object(r.isString()?(MonoSimpleMixerChannelGuiFactory_base::_fromString(r.string())):(MonoSimpleMixerChannelGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  474.     inline MonoSimpleMixerChannelGuiFactory(const Arts::DynamicCast& c) : Arts::Object(MonoSimpleMixerChannelGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  475.     inline MonoSimpleMixerChannelGuiFactory(const MonoSimpleMixerChannelGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  476.     inline MonoSimpleMixerChannelGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  477.     inline static MonoSimpleMixerChannelGuiFactory null() {return MonoSimpleMixerChannelGuiFactory((MonoSimpleMixerChannelGuiFactory_base*)0);}
  478.     inline static MonoSimpleMixerChannelGuiFactory _from_base(MonoSimpleMixerChannelGuiFactory_base* b) {return MonoSimpleMixerChannelGuiFactory(b);}
  479.     inline MonoSimpleMixerChannelGuiFactory& operator=(const MonoSimpleMixerChannelGuiFactory& target) {
  480.         if (_pool == target._pool) return *this;
  481.         _pool->Dec();
  482.         _pool = target._pool;
  483.         _cache = target._cache;
  484.         _pool->Inc();
  485.         return *this;
  486.     }
  487.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  488.     inline MonoSimpleMixerChannelGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  489.  
  490.     inline Arts::Widget createGui(Arts::Object runningObject);
  491. };
  492.  
  493. class ARTS_EXPORT Synth_AUX_BUS_base : virtual public Arts::SynthModule_base {
  494. public:
  495.     static unsigned long _IID; // interface ID
  496.  
  497.     static Synth_AUX_BUS_base *_create(const std::string& subClass = "Arts::Synth_AUX_BUS");
  498.     static Synth_AUX_BUS_base *_fromString(const std::string& objectref);
  499.     static Synth_AUX_BUS_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  500.  
  501.     static Synth_AUX_BUS_base *_fromDynamicCast(const Arts::Object& object);
  502.     inline Synth_AUX_BUS_base *_copy() {
  503.         assert(_refCnt > 0);
  504.         _refCnt++;
  505.         return this;
  506.     }
  507.  
  508.     virtual std::vector<std::string> _defaultPortsIn() const;
  509.     virtual std::vector<std::string> _defaultPortsOut() const;
  510.  
  511.     void *_cast(unsigned long iid);
  512.  
  513.     virtual float level() = 0;
  514.     virtual void level(float newValue) = 0;
  515.     virtual long channel() = 0;
  516.     virtual void channel(long newValue) = 0;
  517. };
  518.  
  519. class ARTS_EXPORT Synth_AUX_BUS_stub : virtual public Synth_AUX_BUS_base, virtual public Arts::SynthModule_stub {
  520. protected:
  521.     Synth_AUX_BUS_stub();
  522.  
  523. public:
  524.     Synth_AUX_BUS_stub(Arts::Connection *connection, long objectID);
  525.  
  526.     float level();
  527.     void level(float newValue);
  528.     long channel();
  529.     void channel(long newValue);
  530. };
  531.  
  532. class ARTS_EXPORT Synth_AUX_BUS_skel : virtual public Synth_AUX_BUS_base, virtual public Arts::SynthModule_skel {
  533. protected:
  534.     // variables for streams
  535.     float *invalue;                           // incoming stream
  536.  
  537. protected:
  538.     // emitters for change notifications
  539.     inline void level_changed(float newValue) {
  540.         _emit_changed("level_changed",newValue);
  541.     }
  542.     inline void channel_changed(long newValue) {
  543.         _emit_changed("channel_changed",newValue);
  544.     }
  545.  
  546. public:
  547.     Synth_AUX_BUS_skel();
  548.  
  549.     static std::string _interfaceNameSkel();
  550.     std::string _interfaceName();
  551.     bool _isCompatibleWith(const std::string& interfacename);
  552.     void _buildMethodTable();
  553.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  554. };
  555.  
  556. }
  557. #include "reference.h"
  558. namespace Arts {
  559. class ARTS_EXPORT Synth_AUX_BUS : public Arts::Object {
  560. private:
  561.     static Arts::Object_base* _Creator();
  562.     Synth_AUX_BUS_base *_cache;
  563.     inline Synth_AUX_BUS_base *_method_call() {
  564.         _pool->checkcreate();
  565.         if(_pool->base) {
  566.             _cache=(Synth_AUX_BUS_base *)_pool->base->_cast(Synth_AUX_BUS_base::_IID);
  567.             assert(_cache);
  568.         }
  569.         return _cache;
  570.     }
  571.  
  572. protected:
  573.     inline Synth_AUX_BUS(Synth_AUX_BUS_base* b) : Arts::Object(b), _cache(0) {}
  574.  
  575.  
  576. public:
  577.     typedef Synth_AUX_BUS_base _base_class;
  578.  
  579.     inline Synth_AUX_BUS() : Arts::Object(_Creator), _cache(0) {}
  580.     inline Synth_AUX_BUS(const Arts::SubClass& s) :
  581.         Arts::Object(Synth_AUX_BUS_base::_create(s.string())), _cache(0) {}
  582.     inline Synth_AUX_BUS(const Arts::Reference &r) :
  583.         Arts::Object(r.isString()?(Synth_AUX_BUS_base::_fromString(r.string())):(Synth_AUX_BUS_base::_fromReference(r.reference(),true))), _cache(0) {}
  584.     inline Synth_AUX_BUS(const Arts::DynamicCast& c) : Arts::Object(Synth_AUX_BUS_base::_fromDynamicCast(c.object())), _cache(0) {}
  585.     inline Synth_AUX_BUS(const Synth_AUX_BUS& target) : Arts::Object(target._pool), _cache(target._cache) {}
  586.     inline Synth_AUX_BUS(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  587.     inline static Synth_AUX_BUS null() {return Synth_AUX_BUS((Synth_AUX_BUS_base*)0);}
  588.     inline static Synth_AUX_BUS _from_base(Synth_AUX_BUS_base* b) {return Synth_AUX_BUS(b);}
  589.     inline Synth_AUX_BUS& operator=(const Synth_AUX_BUS& target) {
  590.         if (_pool == target._pool) return *this;
  591.         _pool->Dec();
  592.         _pool = target._pool;
  593.         _cache = target._cache;
  594.         _pool->Inc();
  595.         return *this;
  596.     }
  597.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  598.     inline Synth_AUX_BUS_base* _base() {return _cache?_cache:_method_call();}
  599.  
  600.     inline Arts::AutoSuspendState autoSuspend();
  601.     inline void start();
  602.     inline void stop();
  603.     inline void streamInit();
  604.     inline void streamStart();
  605.     inline void streamEnd();
  606.     inline float level();
  607.     inline void level(float _newValue);
  608.     inline long channel();
  609.     inline void channel(long _newValue);
  610. };
  611.  
  612. class ARTS_EXPORT LittleStereoMixerChannel_base : virtual public Arts::Environment::MixerChannel_base {
  613. public:
  614.     static unsigned long _IID; // interface ID
  615.  
  616.     static LittleStereoMixerChannel_base *_create(const std::string& subClass = "Arts::LittleStereoMixerChannel");
  617.     static LittleStereoMixerChannel_base *_fromString(const std::string& objectref);
  618.     static LittleStereoMixerChannel_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  619.  
  620.     static LittleStereoMixerChannel_base *_fromDynamicCast(const Arts::Object& object);
  621.     inline LittleStereoMixerChannel_base *_copy() {
  622.         assert(_refCnt > 0);
  623.         _refCnt++;
  624.         return this;
  625.     }
  626.  
  627.     virtual std::vector<std::string> _defaultPortsIn() const;
  628.     virtual std::vector<std::string> _defaultPortsOut() const;
  629.  
  630.     void *_cast(unsigned long iid);
  631.  
  632.     virtual float volume() = 0;
  633.     virtual void volume(float newValue) = 0;
  634.     virtual float balance() = 0;
  635.     virtual void balance(float newValue) = 0;
  636. };
  637.  
  638. class ARTS_EXPORT LittleStereoMixerChannel_stub : virtual public LittleStereoMixerChannel_base, virtual public Arts::Environment::MixerChannel_stub {
  639. protected:
  640.     LittleStereoMixerChannel_stub();
  641.  
  642. public:
  643.     LittleStereoMixerChannel_stub(Arts::Connection *connection, long objectID);
  644.  
  645.     float volume();
  646.     void volume(float newValue);
  647.     float balance();
  648.     void balance(float newValue);
  649. };
  650.  
  651. class ARTS_EXPORT LittleStereoMixerChannel_skel : virtual public LittleStereoMixerChannel_base, virtual public Arts::Environment::MixerChannel_skel {
  652. protected:
  653.     // emitters for change notifications
  654.     inline void volume_changed(float newValue) {
  655.         _emit_changed("volume_changed",newValue);
  656.     }
  657.     inline void balance_changed(float newValue) {
  658.         _emit_changed("balance_changed",newValue);
  659.     }
  660.  
  661. public:
  662.     LittleStereoMixerChannel_skel();
  663.  
  664.     static std::string _interfaceNameSkel();
  665.     std::string _interfaceName();
  666.     bool _isCompatibleWith(const std::string& interfacename);
  667.     void _buildMethodTable();
  668.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  669. };
  670.  
  671. }
  672. #include "reference.h"
  673. namespace Arts {
  674. class ARTS_EXPORT LittleStereoMixerChannel : public Arts::Object {
  675. private:
  676.     static Arts::Object_base* _Creator();
  677.     LittleStereoMixerChannel_base *_cache;
  678.     inline LittleStereoMixerChannel_base *_method_call() {
  679.         _pool->checkcreate();
  680.         if(_pool->base) {
  681.             _cache=(LittleStereoMixerChannel_base *)_pool->base->_cast(LittleStereoMixerChannel_base::_IID);
  682.             assert(_cache);
  683.         }
  684.         return _cache;
  685.     }
  686.  
  687. protected:
  688.     inline LittleStereoMixerChannel(LittleStereoMixerChannel_base* b) : Arts::Object(b), _cache(0) {}
  689.  
  690.  
  691. public:
  692.     typedef LittleStereoMixerChannel_base _base_class;
  693.  
  694.     inline LittleStereoMixerChannel() : Arts::Object(_Creator), _cache(0) {}
  695.     inline LittleStereoMixerChannel(const Arts::SubClass& s) :
  696.         Arts::Object(LittleStereoMixerChannel_base::_create(s.string())), _cache(0) {}
  697.     inline LittleStereoMixerChannel(const Arts::Reference &r) :
  698.         Arts::Object(r.isString()?(LittleStereoMixerChannel_base::_fromString(r.string())):(LittleStereoMixerChannel_base::_fromReference(r.reference(),true))), _cache(0) {}
  699.     inline LittleStereoMixerChannel(const Arts::DynamicCast& c) : Arts::Object(LittleStereoMixerChannel_base::_fromDynamicCast(c.object())), _cache(0) {}
  700.     inline LittleStereoMixerChannel(const LittleStereoMixerChannel& target) : Arts::Object(target._pool), _cache(target._cache) {}
  701.     inline LittleStereoMixerChannel(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  702.     inline static LittleStereoMixerChannel null() {return LittleStereoMixerChannel((LittleStereoMixerChannel_base*)0);}
  703.     inline static LittleStereoMixerChannel _from_base(LittleStereoMixerChannel_base* b) {return LittleStereoMixerChannel(b);}
  704.     inline LittleStereoMixerChannel& operator=(const LittleStereoMixerChannel& target) {
  705.         if (_pool == target._pool) return *this;
  706.         _pool->Dec();
  707.         _pool = target._pool;
  708.         _cache = target._cache;
  709.         _pool->Inc();
  710.         return *this;
  711.     }
  712.     inline operator Arts::Environment::MixerChannel() const { return Arts::Environment::MixerChannel(*_pool); }
  713.     inline operator Arts::StereoEffect() const { return Arts::StereoEffect(*_pool); }
  714.     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
  715.     inline LittleStereoMixerChannel_base* _base() {return _cache?_cache:_method_call();}
  716.  
  717.     inline std::string name();
  718.     inline void name(const std::string& _newValue);
  719.     inline Arts::AutoSuspendState autoSuspend();
  720.     inline void start();
  721.     inline void stop();
  722.     inline void streamInit();
  723.     inline void streamStart();
  724.     inline void streamEnd();
  725.     inline float volume();
  726.     inline void volume(float _newValue);
  727.     inline float balance();
  728.     inline void balance(float _newValue);
  729. };
  730.  
  731. class ARTS_EXPORT LittleStereoMixerChannelGuiFactory_base : virtual public Arts::GuiFactory_base {
  732. public:
  733.     static unsigned long _IID; // interface ID
  734.  
  735.     static LittleStereoMixerChannelGuiFactory_base *_create(const std::string& subClass = "Arts::LittleStereoMixerChannelGuiFactory");
  736.     static LittleStereoMixerChannelGuiFactory_base *_fromString(const std::string& objectref);
  737.     static LittleStereoMixerChannelGuiFactory_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
  738.  
  739.     static LittleStereoMixerChannelGuiFactory_base *_fromDynamicCast(const Arts::Object& object);
  740.     inline LittleStereoMixerChannelGuiFactory_base *_copy() {
  741.         assert(_refCnt > 0);
  742.         _refCnt++;
  743.         return this;
  744.     }
  745.  
  746.     virtual std::vector<std::string> _defaultPortsIn() const;
  747.     virtual std::vector<std::string> _defaultPortsOut() const;
  748.  
  749.     void *_cast(unsigned long iid);
  750.  
  751. };
  752.  
  753. class ARTS_EXPORT LittleStereoMixerChannelGuiFactory_stub : virtual public LittleStereoMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_stub {
  754. protected:
  755.     LittleStereoMixerChannelGuiFactory_stub();
  756.  
  757. public:
  758.     LittleStereoMixerChannelGuiFactory_stub(Arts::Connection *connection, long objectID);
  759.  
  760. };
  761.  
  762. class ARTS_EXPORT LittleStereoMixerChannelGuiFactory_skel : virtual public LittleStereoMixerChannelGuiFactory_base, virtual public Arts::GuiFactory_skel {
  763. public:
  764.     LittleStereoMixerChannelGuiFactory_skel();
  765.  
  766.     static std::string _interfaceNameSkel();
  767.     std::string _interfaceName();
  768.     bool _isCompatibleWith(const std::string& interfacename);
  769.     void _buildMethodTable();
  770.     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
  771. };
  772.  
  773. }
  774. #include "reference.h"
  775. namespace Arts {
  776. class ARTS_EXPORT LittleStereoMixerChannelGuiFactory : public Arts::Object {
  777. private:
  778.     static Arts::Object_base* _Creator();
  779.     LittleStereoMixerChannelGuiFactory_base *_cache;
  780.     inline LittleStereoMixerChannelGuiFactory_base *_method_call() {
  781.         _pool->checkcreate();
  782.         if(_pool->base) {
  783.             _cache=(LittleStereoMixerChannelGuiFactory_base *)_pool->base->_cast(LittleStereoMixerChannelGuiFactory_base::_IID);
  784.             assert(_cache);
  785.         }
  786.         return _cache;
  787.     }
  788.  
  789. protected:
  790.     inline LittleStereoMixerChannelGuiFactory(LittleStereoMixerChannelGuiFactory_base* b) : Arts::Object(b), _cache(0) {}
  791.  
  792.  
  793. public:
  794.     typedef LittleStereoMixerChannelGuiFactory_base _base_class;
  795.  
  796.     inline LittleStereoMixerChannelGuiFactory() : Arts::Object(_Creator), _cache(0) {}
  797.     inline LittleStereoMixerChannelGuiFactory(const Arts::SubClass& s) :
  798.         Arts::Object(LittleStereoMixerChannelGuiFactory_base::_create(s.string())), _cache(0) {}
  799.     inline LittleStereoMixerChannelGuiFactory(const Arts::Reference &r) :
  800.         Arts::Object(r.isString()?(LittleStereoMixerChannelGuiFactory_base::_fromString(r.string())):(LittleStereoMixerChannelGuiFactory_base::_fromReference(r.reference(),true))), _cache(0) {}
  801.     inline LittleStereoMixerChannelGuiFactory(const Arts::DynamicCast& c) : Arts::Object(LittleStereoMixerChannelGuiFactory_base::_fromDynamicCast(c.object())), _cache(0) {}
  802.     inline LittleStereoMixerChannelGuiFactory(const LittleStereoMixerChannelGuiFactory& target) : Arts::Object(target._pool), _cache(target._cache) {}
  803.     inline LittleStereoMixerChannelGuiFactory(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
  804.     inline static LittleStereoMixerChannelGuiFactory null() {return LittleStereoMixerChannelGuiFactory((LittleStereoMixerChannelGuiFactory_base*)0);}
  805.     inline static LittleStereoMixerChannelGuiFactory _from_base(LittleStereoMixerChannelGuiFactory_base* b) {return LittleStereoMixerChannelGuiFactory(b);}
  806.     inline LittleStereoMixerChannelGuiFactory& operator=(const LittleStereoMixerChannelGuiFactory& target) {
  807.         if (_pool == target._pool) return *this;
  808.         _pool->Dec();
  809.         _pool = target._pool;
  810.         _cache = target._cache;
  811.         _pool->Inc();
  812.         return *this;
  813.     }
  814.     inline operator Arts::GuiFactory() const { return Arts::GuiFactory(*_pool); }
  815.     inline LittleStereoMixerChannelGuiFactory_base* _base() {return _cache?_cache:_method_call();}
  816.  
  817.     inline Arts::Widget createGui(Arts::Object runningObject);
  818. };
  819.  
  820. }
  821. // Forward wrapper calls to _base classes:
  822.  
  823. inline std::string Arts::SimpleMixerChannel::name()
  824. {
  825.     return _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name():static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name();
  826. }
  827.  
  828. inline void Arts::SimpleMixerChannel::name(const std::string& _newValue)
  829. {
  830.      _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name(_newValue):static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name(_newValue);
  831. }
  832.  
  833. inline Arts::AutoSuspendState Arts::SimpleMixerChannel::autoSuspend()
  834. {
  835.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  836. }
  837.  
  838. inline void Arts::SimpleMixerChannel::start()
  839. {
  840.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  841. }
  842.  
  843. inline void Arts::SimpleMixerChannel::stop()
  844. {
  845.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  846. }
  847.  
  848. inline void Arts::SimpleMixerChannel::streamInit()
  849. {
  850.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  851. }
  852.  
  853. inline void Arts::SimpleMixerChannel::streamStart()
  854. {
  855.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  856. }
  857.  
  858. inline void Arts::SimpleMixerChannel::streamEnd()
  859. {
  860.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  861. }
  862.  
  863. inline Arts::Synth_STD_EQUALIZER Arts::SimpleMixerChannel::equalizerLeft()
  864. {
  865.     return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->equalizerLeft():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->equalizerLeft();
  866. }
  867.  
  868. inline Arts::Synth_STD_EQUALIZER Arts::SimpleMixerChannel::equalizerRight()
  869. {
  870.     return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->equalizerRight():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->equalizerRight();
  871. }
  872.  
  873. inline Arts::StereoEffectStack Arts::SimpleMixerChannel::insertEffects()
  874. {
  875.     return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->insertEffects():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->insertEffects();
  876. }
  877.  
  878. inline float Arts::SimpleMixerChannel::gainLeft()
  879. {
  880.     return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->gainLeft():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->gainLeft();
  881. }
  882.  
  883. inline void Arts::SimpleMixerChannel::gainLeft(float _newValue)
  884. {
  885.      _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->gainLeft(_newValue):static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->gainLeft(_newValue);
  886. }
  887.  
  888. inline float Arts::SimpleMixerChannel::gainRight()
  889. {
  890.     return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->gainRight():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->gainRight();
  891. }
  892.  
  893. inline void Arts::SimpleMixerChannel::gainRight(float _newValue)
  894. {
  895.      _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->gainRight(_newValue):static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->gainRight(_newValue);
  896. }
  897.  
  898. inline float Arts::SimpleMixerChannel::pan()
  899. {
  900.     return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->pan():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->pan();
  901. }
  902.  
  903. inline void Arts::SimpleMixerChannel::pan(float _newValue)
  904. {
  905.      _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->pan(_newValue):static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->pan(_newValue);
  906. }
  907.  
  908. inline float Arts::SimpleMixerChannel::volumeLeft()
  909. {
  910.     return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->volumeLeft():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->volumeLeft();
  911. }
  912.  
  913. inline void Arts::SimpleMixerChannel::volumeLeft(float _newValue)
  914. {
  915.      _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->volumeLeft(_newValue):static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->volumeLeft(_newValue);
  916. }
  917.  
  918. inline float Arts::SimpleMixerChannel::volumeRight()
  919. {
  920.     return _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->volumeRight():static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->volumeRight();
  921. }
  922.  
  923. inline void Arts::SimpleMixerChannel::volumeRight(float _newValue)
  924. {
  925.      _cache?static_cast<Arts::SimpleMixerChannel_base*>(_cache)->volumeRight(_newValue):static_cast<Arts::SimpleMixerChannel_base*>(_method_call())->volumeRight(_newValue);
  926. }
  927.  
  928. inline Arts::Widget Arts::SimpleMixerChannelGuiFactory::createGui(Arts::Object runningObject)
  929. {
  930.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  931. }
  932.  
  933. inline std::string Arts::MonoSimpleMixerChannel::name()
  934. {
  935.     return _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name():static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name();
  936. }
  937.  
  938. inline void Arts::MonoSimpleMixerChannel::name(const std::string& _newValue)
  939. {
  940.      _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name(_newValue):static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name(_newValue);
  941. }
  942.  
  943. inline Arts::AutoSuspendState Arts::MonoSimpleMixerChannel::autoSuspend()
  944. {
  945.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  946. }
  947.  
  948. inline void Arts::MonoSimpleMixerChannel::start()
  949. {
  950.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  951. }
  952.  
  953. inline void Arts::MonoSimpleMixerChannel::stop()
  954. {
  955.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  956. }
  957.  
  958. inline void Arts::MonoSimpleMixerChannel::streamInit()
  959. {
  960.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  961. }
  962.  
  963. inline void Arts::MonoSimpleMixerChannel::streamStart()
  964. {
  965.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  966. }
  967.  
  968. inline void Arts::MonoSimpleMixerChannel::streamEnd()
  969. {
  970.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  971. }
  972.  
  973. inline Arts::Synth_STD_EQUALIZER Arts::MonoSimpleMixerChannel::equalizer()
  974. {
  975.     return _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->equalizer():static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->equalizer();
  976. }
  977.  
  978. inline Arts::StereoEffectStack Arts::MonoSimpleMixerChannel::insertEffects()
  979. {
  980.     return _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->insertEffects():static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->insertEffects();
  981. }
  982.  
  983. inline float Arts::MonoSimpleMixerChannel::gain()
  984. {
  985.     return _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->gain():static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->gain();
  986. }
  987.  
  988. inline void Arts::MonoSimpleMixerChannel::gain(float _newValue)
  989. {
  990.      _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->gain(_newValue):static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->gain(_newValue);
  991. }
  992.  
  993. inline float Arts::MonoSimpleMixerChannel::pan()
  994. {
  995.     return _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->pan():static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->pan();
  996. }
  997.  
  998. inline void Arts::MonoSimpleMixerChannel::pan(float _newValue)
  999. {
  1000.      _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->pan(_newValue):static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->pan(_newValue);
  1001. }
  1002.  
  1003. inline float Arts::MonoSimpleMixerChannel::volume()
  1004. {
  1005.     return _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->volume():static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->volume();
  1006. }
  1007.  
  1008. inline void Arts::MonoSimpleMixerChannel::volume(float _newValue)
  1009. {
  1010.      _cache?static_cast<Arts::MonoSimpleMixerChannel_base*>(_cache)->volume(_newValue):static_cast<Arts::MonoSimpleMixerChannel_base*>(_method_call())->volume(_newValue);
  1011. }
  1012.  
  1013. inline Arts::Widget Arts::MonoSimpleMixerChannelGuiFactory::createGui(Arts::Object runningObject)
  1014. {
  1015.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  1016. }
  1017.  
  1018. inline Arts::AutoSuspendState Arts::Synth_AUX_BUS::autoSuspend()
  1019. {
  1020.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1021. }
  1022.  
  1023. inline void Arts::Synth_AUX_BUS::start()
  1024. {
  1025.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1026. }
  1027.  
  1028. inline void Arts::Synth_AUX_BUS::stop()
  1029. {
  1030.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1031. }
  1032.  
  1033. inline void Arts::Synth_AUX_BUS::streamInit()
  1034. {
  1035.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1036. }
  1037.  
  1038. inline void Arts::Synth_AUX_BUS::streamStart()
  1039. {
  1040.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1041. }
  1042.  
  1043. inline void Arts::Synth_AUX_BUS::streamEnd()
  1044. {
  1045.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1046. }
  1047.  
  1048. inline float Arts::Synth_AUX_BUS::level()
  1049. {
  1050.     return _cache?static_cast<Arts::Synth_AUX_BUS_base*>(_cache)->level():static_cast<Arts::Synth_AUX_BUS_base*>(_method_call())->level();
  1051. }
  1052.  
  1053. inline void Arts::Synth_AUX_BUS::level(float _newValue)
  1054. {
  1055.      _cache?static_cast<Arts::Synth_AUX_BUS_base*>(_cache)->level(_newValue):static_cast<Arts::Synth_AUX_BUS_base*>(_method_call())->level(_newValue);
  1056. }
  1057.  
  1058. inline long Arts::Synth_AUX_BUS::channel()
  1059. {
  1060.     return _cache?static_cast<Arts::Synth_AUX_BUS_base*>(_cache)->channel():static_cast<Arts::Synth_AUX_BUS_base*>(_method_call())->channel();
  1061. }
  1062.  
  1063. inline void Arts::Synth_AUX_BUS::channel(long _newValue)
  1064. {
  1065.      _cache?static_cast<Arts::Synth_AUX_BUS_base*>(_cache)->channel(_newValue):static_cast<Arts::Synth_AUX_BUS_base*>(_method_call())->channel(_newValue);
  1066. }
  1067.  
  1068. inline std::string Arts::LittleStereoMixerChannel::name()
  1069. {
  1070.     return _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name():static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name();
  1071. }
  1072.  
  1073. inline void Arts::LittleStereoMixerChannel::name(const std::string& _newValue)
  1074. {
  1075.      _cache?static_cast<Arts::Environment::MixerChannel_base*>(_cache)->name(_newValue):static_cast<Arts::Environment::MixerChannel_base*>(_method_call())->name(_newValue);
  1076. }
  1077.  
  1078. inline Arts::AutoSuspendState Arts::LittleStereoMixerChannel::autoSuspend()
  1079. {
  1080.     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
  1081. }
  1082.  
  1083. inline void Arts::LittleStereoMixerChannel::start()
  1084. {
  1085.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
  1086. }
  1087.  
  1088. inline void Arts::LittleStereoMixerChannel::stop()
  1089. {
  1090.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
  1091. }
  1092.  
  1093. inline void Arts::LittleStereoMixerChannel::streamInit()
  1094. {
  1095.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
  1096. }
  1097.  
  1098. inline void Arts::LittleStereoMixerChannel::streamStart()
  1099. {
  1100.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
  1101. }
  1102.  
  1103. inline void Arts::LittleStereoMixerChannel::streamEnd()
  1104. {
  1105.      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
  1106. }
  1107.  
  1108. inline float Arts::LittleStereoMixerChannel::volume()
  1109. {
  1110.     return _cache?static_cast<Arts::LittleStereoMixerChannel_base*>(_cache)->volume():static_cast<Arts::LittleStereoMixerChannel_base*>(_method_call())->volume();
  1111. }
  1112.  
  1113. inline void Arts::LittleStereoMixerChannel::volume(float _newValue)
  1114. {
  1115.      _cache?static_cast<Arts::LittleStereoMixerChannel_base*>(_cache)->volume(_newValue):static_cast<Arts::LittleStereoMixerChannel_base*>(_method_call())->volume(_newValue);
  1116. }
  1117.  
  1118. inline float Arts::LittleStereoMixerChannel::balance()
  1119. {
  1120.     return _cache?static_cast<Arts::LittleStereoMixerChannel_base*>(_cache)->balance():static_cast<Arts::LittleStereoMixerChannel_base*>(_method_call())->balance();
  1121. }
  1122.  
  1123. inline void Arts::LittleStereoMixerChannel::balance(float _newValue)
  1124. {
  1125.      _cache?static_cast<Arts::LittleStereoMixerChannel_base*>(_cache)->balance(_newValue):static_cast<Arts::LittleStereoMixerChannel_base*>(_method_call())->balance(_newValue);
  1126. }
  1127.  
  1128. inline Arts::Widget Arts::LittleStereoMixerChannelGuiFactory::createGui(Arts::Object runningObject)
  1129. {
  1130.     return _cache?static_cast<Arts::GuiFactory_base*>(_cache)->createGui(runningObject):static_cast<Arts::GuiFactory_base*>(_method_call())->createGui(runningObject);
  1131. }
  1132.  
  1133. #endif /* ARTSMODULESMIXERS_H */
  1134.